package simulator.stats;

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

import simulator.stats.implementation.MetricsStats;

public class DCwormsMetricsCalculator extends AbstractMetricsCalculator{

	public DCwormsMetricsCalculator (long startTime, long endTime, long timestamp){
		super(startTime, endTime, timestamp);
	}
	
	public List<MetricsStats> calulateMetrics(){
		List<MetricsStats> metrics = new ArrayList<MetricsStats>();

		/*
		metrics.add(calculateITComputingEnergyConsumption());
		metrics.add(calculateITEnergyConsumption());
		
		metrics.add(calculateCoolingDeviceEnergyConsumption());
		
		metrics.add(calculateTotalEnergyConsumption());
		
		metrics.add(calculateMeanPower());
		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 - not implemented yet", 0, timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_energy_consumption - not implemented yet", -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 - not implemented yet", 0, timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_processors_energy_consumption - not implemented yet", -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 fanPowerConumspion = nodeComputingPower - itComputingPower;
			metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption - not implemented yet", 0, timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption - not implemented yet", -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 - not implemented yet", 0, timestamp, "");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "PUE_Level_4 - not implemented yet", -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 - not implemented yet", 0, timestamp, "");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "PUE - not implemented yet", -1, timestamp, "");
		}
		return metric;
	}

	private MetricsStats calculateUsefulWork(){
		
		MetricsStats metric;
		try{
			double usefulWork = 0;
			for(String key: metricsData.keySet()){
				if(key.contains("/")){
					for(DCwormsAccumulator acc: metricsData.get(key)){
						usefulWork= usefulWork + acc.getSum();
					}
				}
			}
			metric = new MetricsStats("CoolEmAllTestbed", "Useful_Work - not implemented yet", 0, timestamp, "UW units");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Useful_Work - not implemented yet", -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 - not implemented yet", 0, timestamp, "UW units/Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Productivity - not implemented yet", -1, timestamp, "UW units/Wh");
		}
		
		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 - not implemented yet", 0, timestamp, "W");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Max_power - not implemented yet", -1, timestamp, "W");
		}
		
		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 - not implemented yet", 0, timestamp, "Wh");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Total_cooling_device_energy_consumption - not implemented yet", -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 - not implemented yet", 0, timestamp, "W");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Mean_power - not implemented yet", -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 - not implemented yet", 0, timestamp, "%");
		} catch (Exception e){
			metric = new MetricsStats("CoolEmAllTestbed", "Energy_waste_rate - not implemented yet", -1, timestamp, "%");
		}
		return metric;
	}
	
}