package simulator.stats;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import simulator.stats.implementation.MetricsStats;
import example.energy.coolemall.CoolEmAllTestbedMeasurements;

public class MetricsCalculator {
	
	protected static final double MILLI_SEC = 1000;
	protected static final double SEC_IN_HOUR = 3600;
	
	protected Map<String, List<GSSAccumulator>> metricsData = new HashMap<String, List<GSSAccumulator>>();
	protected long timestamp;
	protected long startTime;
	protected long endTime;

	public List<MetricsStats> calulateMetrics(long timestamp){
		this.timestamp = timestamp;
		List<MetricsStats> metrics = new ArrayList<MetricsStats>();
		/*for(String resourceTypeName: metricsData.keySet()){
			MetricsStats metric = new MetricsStats(resourceTypeName, "energyUsage", metricsData.get(resourceTypeName).getMax());
			metrics.add(metric);}
		}*/
		metrics.add(calculateITComputingEnergyConsumption());
		metrics.add(calculateITEnergyConsumption());
		metrics.add(calculateNodeGroupFansEnergyConsumption());
		
		metrics.add(calculateRackEnergyConsumption());
		metrics.add(calculateDataCenterFansEnergyConsumption());
		metrics.add(calculateCoolingDeviceEnergyConsumption());
		metrics.add(calculateOtherDevicesEnergyConsumption());
		
		metrics.add(calculateTotalEnergyConsumption());
		
		metrics.add(calculateMeanRackPower());
		metrics.add(calculateMeanPower());
		metrics.add(calculateMaxRackPower());
		metrics.add(calculateMaxPower());
		
		metrics.add(calculatePUE());
		metrics.add(calculatePUELevel4());
		metrics.add(calculateEnergyWasteRate());
		
		metrics.add(calculateUsefulWork());
		metrics.add(calculateProductivity());

		return metrics;
	}
	
	public void addMetricsData(String resourceTypeName, GSSAccumulator resourceEnergyAccumulator){
		List<GSSAccumulator> resourceEnergyAccumulatorList = metricsData.get(resourceTypeName);
		if(resourceEnergyAccumulatorList == null){
			resourceEnergyAccumulatorList = new ArrayList<GSSAccumulator>();
		}
		resourceEnergyAccumulatorList.add(resourceEnergyAccumulator);
		metricsData.put(resourceTypeName, resourceEnergyAccumulatorList);
	}
	
	public Map<String, List<GSSAccumulator>> getMetricsData(){
		return metricsData;
	}
	
	private MetricsStats calculateTotalEnergyConsumption(){
		
		MetricsStats metric;
		try{
			
			double roomPower = 0;
			for(GSSAccumulator acc: metricsData.get("Room")){
				roomPower = roomPower + acc.getSum();
			}
			metric = new MetricsStats("CoolEmAllTestbed", "Total_energy_consumption", roomPower, timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	private MetricsStats calculateITComputingEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double itComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Processor")){
				itComputingPower = itComputingPower + acc.getSum();
			}
			metric = new MetricsStats("CoolEmAllTestbed", "Total_processors_energy_consumption", (itComputingPower), timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_processors_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	private MetricsStats calculateITEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double totalSitePower = 0; 
			for(GSSAccumulator acc: metricsData.get("Rack")){
				totalSitePower = totalSitePower + acc.getSum();
			}
			double nodeComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Processor")){
				itComputingPower = itComputingPower + acc.getSum();
			}
			double fanPowerConumspion = nodeComputingPower - itComputingPower;
			metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption", (totalSitePower * CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY - fanPowerConumspion), timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	private MetricsStats calculateNodeGroupFansEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double nodeComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Processor")){
				itComputingPower = itComputingPower + acc.getSum();
			}
			double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
			metric = new MetricsStats("CoolEmAllTestbed", "Total_node_group_fans_energy_consumption", nodeGroupFansPowerConumspion, timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_node_group_fans_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	private MetricsStats calculatePUELevel4(){
		
		MetricsStats metric;
		try{
			
			double roomPower = 0;
			for(GSSAccumulator acc: metricsData.get("Room")){
				roomPower = roomPower + acc.getSum();
			}
			
			double totalSitePower = 0;
			for(GSSAccumulator acc: metricsData.get("Rack")){
				totalSitePower = totalSitePower + acc.getSum();
			}
			
		
			double nodeComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Processor")){
				itComputingPower = itComputingPower + acc.getSum();
			}
			double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;

			metric = new MetricsStats("CoolEmAllTestbed", "PUE_Level_4", roomPower/(totalSitePower * CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY - nodeGroupFansPowerConumspion), timestamp, "");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "PUE_Level_4", -1, timestamp, "");
		}
		return metric;
	}
	
	private MetricsStats calculatePUE(){
		
		MetricsStats metric;
		try{
			
			double roomPower = 0;
			for(GSSAccumulator acc: metricsData.get("Room")){
				roomPower = roomPower + acc.getSum();
			}
			
			double totalSitePower = 0;
			for(GSSAccumulator acc: metricsData.get("Rack")){
				totalSitePower = totalSitePower + acc.getSum();
			}


			metric = new MetricsStats("CoolEmAllTestbed", "PUE", roomPower/totalSitePower, timestamp, "");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "PUE", -1, timestamp, "");
		}
		return metric;
	}

	private MetricsStats calculateUsefulWork(){
		
		MetricsStats metric;
		try{
			double usefulWork = 0;
			for(String key: metricsData.keySet()){
				if(key.contains("/")){
					for(GSSAccumulator acc: metricsData.get(key)){
						usefulWork= usefulWork + acc.getSum();
					}
				}
			}
			metric = new MetricsStats("CoolEmAllTestbed", "Useful_Work", usefulWork, timestamp, "UW units");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Useful_Work", -1, timestamp, "UW units");
		}
		
		return metric;
	}
	
	private MetricsStats calculateProductivity(){
		
		MetricsStats metric;
		try{
			double usefulWork = 0;
			for(String key: metricsData.keySet()){
				if(key.contains("/")){
					for(GSSAccumulator acc: metricsData.get(key)){
						usefulWork= usefulWork + acc.getSum();
					}
				}
			}
			double totalSitePower = 0; 
			for(GSSAccumulator acc: metricsData.get("Rack")){
				totalSitePower = totalSitePower + acc.getSum();
			}
			
			metric = new MetricsStats("CoolEmAllTestbed", "Productivity", usefulWork/totalSitePower, timestamp, "UW units/Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Productivity", -1, timestamp, "UW units/Wh");
		}
		
		return metric;
	}
	
	
	private MetricsStats calculateMaxRackPower(){
		
		MetricsStats metric;
		try{
			double maxPower = 0;
			
			for(GSSAccumulator acc: metricsData.get("Rack_MAX")){
				maxPower = maxPower + acc.getSum();
			}

			metric = new MetricsStats("CoolEmAllTestbed", "Max_rack_power", maxPower, timestamp, "W");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Max_rack_power", -1, timestamp, "W");
		}
		
		return metric;
	}
	
	private MetricsStats calculateMaxPower(){
		
		MetricsStats metric;
		try{
			double maxPower = 0;
			
			for(GSSAccumulator acc: metricsData.get("Room_MAX")){
				maxPower = maxPower + acc.getSum();
			}

			metric = new MetricsStats("CoolEmAllTestbed", "Max_power", maxPower, timestamp, "W");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Max_power", -1, timestamp, "W");
		}
		
		return metric;
	}
	
	private MetricsStats calculateDataCenterFansEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double inletsPower = 0;
			for(GSSAccumulator acc: metricsData.get("Inlet")){
				inletsPower = inletsPower + acc.getSum();
			}
			
			double outletsPower = 0;
			for(GSSAccumulator acc: metricsData.get("Outlet")){
				outletsPower = outletsPower + acc.getSum();
			}
			
			double nodeComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Processor")){
				itComputingPower = itComputingPower + acc.getSum();
			}
			double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
			
			metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", (inletsPower + outletsPower - nodeGroupFansPowerConumspion), timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	
	private MetricsStats calculateRackEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double roomPower = 0;
			for(GSSAccumulator acc: metricsData.get("Rack")){
				roomPower = roomPower + acc.getSum();
			}
			metric = new MetricsStats("CoolEmAllTestbed", "Total_rack_energy_consumption", roomPower, timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_rack_device_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	private MetricsStats calculateCoolingDeviceEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double coolingDevicePower = 0;
			for(GSSAccumulator acc: metricsData.get("CoolingDevice")){
				coolingDevicePower = coolingDevicePower + acc.getSum();
			}
			metric = new MetricsStats("CoolEmAllTestbed", "Total_cooling_device_energy_consumption", coolingDevicePower, timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_cooling_device_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	private MetricsStats calculateOtherDevicesEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double roomPower = 0;
			for(GSSAccumulator acc: metricsData.get("Room")){
				roomPower = roomPower + acc.getSum();
			}
			
			double totalSitePower = 0;
			for(GSSAccumulator acc: metricsData.get("Rack")){
				totalSitePower = totalSitePower + acc.getSum();
			}
			
			double coolingDevicePower = 0;
			for(GSSAccumulator acc: metricsData.get("CoolingDevice")){
				coolingDevicePower = coolingDevicePower + acc.getSum();
			}
			
			double inletsPower = 0;
			for(GSSAccumulator acc: metricsData.get("Inlet")){
				inletsPower = inletsPower + acc.getSum();
			}
			
			double outletsPower = 0;
			for(GSSAccumulator acc: metricsData.get("Outlet")){
				outletsPower = outletsPower + acc.getSum();
			}
			
			double nodeComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(GSSAccumulator acc: metricsData.get("Processor")){
				itComputingPower = itComputingPower + acc.getSum();
			}
			double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
			
			metric = new MetricsStats("CoolEmAllTestbed", "Total_other_devices_energy_consumption", roomPower - (totalSitePower + coolingDevicePower + (inletsPower + outletsPower - nodeGroupFansPowerConumspion)), timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_other_devices_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}

	
	private MetricsStats calculateMeanPower(){
		
		MetricsStats metric;
		try{
			
			double roomPower = 0;
			for(GSSAccumulator acc: metricsData.get("Room")){
				roomPower = roomPower + acc.getSum();
			}
			metric = new MetricsStats("CoolEmAllTestbed", "Mean_power", roomPower/((this.endTime - this.startTime)/(SEC_IN_HOUR * MILLI_SEC)), timestamp, "W");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Mean_power", -1, timestamp, "W");
		}
		return metric;
	}
	
	
	private MetricsStats calculateMeanRackPower(){
		
		MetricsStats metric;
		try{
			
			double roomPower = 0;
			for(GSSAccumulator acc: metricsData.get("Rack")){
				roomPower = roomPower + acc.getSum();
			}
			metric = new MetricsStats("CoolEmAllTestbed", "Mean_rack_power", roomPower/((this.endTime - this.startTime)/(SEC_IN_HOUR * MILLI_SEC)), timestamp, "W");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Mean_rack_power", -1, timestamp, "W");
		}
		return metric;
	}
	
	private MetricsStats calculateEnergyWasteRate(){
		
		MetricsStats metric;
		try{
			double itComputingEnergy = 0;
			for(GSSAccumulator acc: metricsData.get("Processor_CALC")){
				itComputingEnergy = itComputingEnergy + acc.getSum();
			}
			itComputingEnergy = itComputingEnergy + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION * (this.endTime - this.startTime)/(SEC_IN_HOUR * MILLI_SEC);
			double itEnergy = calculateITEnergyConsumption().getValue();
			
			metric = new MetricsStats("CoolEmAllTestbed", "Energy_waste_rate", (1 - itComputingEnergy/itEnergy) * 100, timestamp, "%");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Energy_waste_rate", -1, timestamp, "%");
		}
		return metric;
	}
	
	public long getStartTime() {
		return startTime;
	}

	public void setStartTime(long startTime) {
		this.startTime = startTime;
	}

	public long getEndTime() {
		return endTime;
	}

	public void setEndTime(long endTime) {
		this.endTime = endTime;
	}
}