package simulator.stats;

import java.util.ArrayList;
import java.util.List;

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

public class CoolEmAllMetricsCalculator extends AbstractMetricsCalculator{
	
	public CoolEmAllMetricsCalculator (long startTime, long endTime, long timestamp){
		super(startTime, endTime, timestamp);
	}
	
	public List<MetricsStats> calulateMetrics(){
		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;
	}

	private MetricsStats calculateTotalEnergyConsumption(){
		
		MetricsStats metric;
		try{
			
			double roomPower = 0;
			for(DCwormsAccumulator 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(DCwormsAccumulator 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(DCwormsAccumulator acc: metricsData.get("Rack")){
				totalSitePower = totalSitePower + acc.getSum();
			}
			double nodeComputingPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Processor")){
				itComputingPower = itComputingPower + acc.getSum();
			}
			double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
			metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption", (totalSitePower * CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY - nodeGroupFansPowerConumspion), 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(DCwormsAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(DCwormsAccumulator 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(DCwormsAccumulator acc: metricsData.get("Room")){
				roomPower = roomPower + acc.getSum();
			}
			
			double totalSitePower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Rack")){
				totalSitePower = totalSitePower + acc.getSum();
			}
			
		
			double nodeComputingPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(DCwormsAccumulator 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(DCwormsAccumulator acc: metricsData.get("Room")){
				roomPower = roomPower + acc.getSum();
			}
			
			double totalSitePower = 0;
			for(DCwormsAccumulator 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("UW_")){
					for(DCwormsAccumulator 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(DCwormsAccumulator acc: metricsData.get(key)){
						usefulWork= usefulWork + acc.getSum();
					}
				}
			}
			double totalSitePower = 0; 
			for(DCwormsAccumulator 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(DCwormsAccumulator 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(DCwormsAccumulator 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(DCwormsAccumulator acc: metricsData.get("Inlet")){
				inletsPower = inletsPower + acc.getSum();
			}
			
			double outletsPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Outlet")){
				outletsPower = outletsPower + acc.getSum();
			}
			
			double nodeComputingPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(DCwormsAccumulator 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(DCwormsAccumulator 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_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	private MetricsStats calculateCoolingDeviceEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double coolingDevicePower = 0;
			for(DCwormsAccumulator 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_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	private MetricsStats calculateDataCenterFansEnergyConsumptionOld(){
		
		MetricsStats metric;
		try{

			double flowPump = 0;
			for(String key: metricsData.keySet()){
				if(key.contains("FlowPump")){
					for(DCwormsAccumulator acc: metricsData.get(key)){
						flowPump = flowPump + acc.getSum();
					}
				}
			}

			metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", (flowPump), timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}
	
	
	private MetricsStats calculateOtherDevicesEnergyConsumption(){
		
		MetricsStats metric;
		try{
			double roomPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Room")){
				roomPower = roomPower + acc.getSum();
			}
			
			double totalSitePower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Rack")){
				totalSitePower = totalSitePower + acc.getSum();
			}
			
			double coolingDevicePower = 0;
			for(DCwormsAccumulator acc: metricsData.get("CoolingDevice")){
				coolingDevicePower = coolingDevicePower + acc.getSum();
			}
			
			double inletsPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Inlet")){
				inletsPower = inletsPower + acc.getSum();
			}
			
			double outletsPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Outlet")){
				outletsPower = outletsPower + acc.getSum();
			}
			
			double nodeComputingPower = 0;
			for(DCwormsAccumulator acc: metricsData.get("Node")){
				nodeComputingPower = nodeComputingPower+ acc.getSum();
			}
			double itComputingPower = 0;
			for(DCwormsAccumulator 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_energy_consumption", -1, timestamp, "Wh");
		}
		return metric;
	}

	
	private MetricsStats calculateMeanPower(){
		
		MetricsStats metric;
		try{
			
			double roomPower = 0;
			for(DCwormsAccumulator 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(DCwormsAccumulator 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(DCwormsAccumulator acc: metricsData.get("Processor_CALC")){
				itComputingEnergy = itComputingEnergy + acc.getSum();
			}
			
			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;
	}
	
}