package experiments.e2dc2014;

import schedframe.events.EventReason;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.resources.computing.profiles.energy.ResourceEvent;
import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
import schedframe.resources.devices.Device;
import schedframe.resources.devices.Fan;
import schedframe.resources.devices.PhysicalResource;
import schedframe.scheduling.manager.tasks.JobRegistry;
import example.energy.BaseEnergyEstimationPlugin;

public class FanEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {

	public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
			PhysicalResource resource) {
		
		double powerConsumption = 0;
		
		Fan fan = (Fan) resource;
		try {
			powerConsumption = fan.getAirflowInterface().getPowerConsumption(fan.getAirflowInterface().getAirflowState());
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		/*if(resource.getAirThroughputInterface().getAirThroughputState().getName().equals(new UserAirThroughputStateName("1").getName())){
			powerConsumption = CoolEmAllTestbedMeasurements.SINGLE_FAN_OFF_POWER_CONSUMPTION;
		} else {
			powerConsumption = CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION;
		}*/
		return powerConsumption * getFactor(fan)/(double)fan.getChilledResources().size();
	}
	
	public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
		
		double airflow = 0;
		Fan fan = (Fan) resource;
		try {
			if(event.getReason() == EventReason.SIM_INIT)
				airflow = fan.getAirflowInterface().getAirflow(fan.getAirflowInterface().getAirflowState());
			else
				airflow = fan.getAirflowInterface().getAirflow(fan.getAirflowInterface().getAirflowState());
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		/*if(event.getReason() == EventReason.SIM_INIT){
			if(resource.getAirThroughputInterface().getAirThroughputState().getName().equals(new UserAirThroughputStateName("1").getName())){
				airThroughput = CoolEmAllTestbedMeasurements.SINGLE_FAN_OFF_AIR_FLOW;
			} else {
				airThroughput = CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_AIR_FLOW;
			}
		}
		else {
			if(resource.getAirThroughputInterface().getAirThroughputState().getName().equals(new UserAirThroughputStateName("1").getName())){
				airThroughput = CoolEmAllTestbedMeasurements.SINGLE_FAN_OFF_AIR_FLOW;
			} else {
				airThroughput = CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_AIR_FLOW;
			}
		}*/
		
		return airflow * getFactor(fan)/(double)fan.getChilledResources().size();
	}
	
	private int getNumberOfWorkingNodes(Device device){
		int quantity = 0;
		Fan fan = (Fan) device;
		for(ComputingResource compRes: device.getComputingResource().getChildren()){
			Node node = (Node)compRes;
			if(fan.getChilledResources().contains(node.getFullName()) && node.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON) ){
				quantity++;
			}
		}
		return quantity;
	}

	private double getFactor(Device device){

		double factor = 0;;
		Fan fan = (Fan) device;
		for(ComputingResource compRes: device.getComputingResource().getChildren()){
			Node node = (Node)compRes;
			double nrOfComputingProcessor = 0;
			double meanCurrFrequency = 0;
			double meanMaxFrequency = 0;
			if(fan.getChilledResources().contains(node.getFullName()) && node.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON) ){
				for(Processor proc: node.getProcessors()){
					if(proc.getCores().size() != proc.getFreeCores().size()){
						nrOfComputingProcessor++;
						meanCurrFrequency = meanCurrFrequency + proc.getPowerInterface().getFrequency();
						meanMaxFrequency = meanMaxFrequency + proc.getPowerInterface().getLowestPState().getFrequency();	
					} else {
						meanCurrFrequency = meanCurrFrequency + proc.getPowerInterface().getHighestPState().getFrequency();
						meanMaxFrequency = meanMaxFrequency + proc.getPowerInterface().getLowestPState().getFrequency();						
					}

				}
				meanCurrFrequency = meanCurrFrequency/node.getProcessors().size();
				meanMaxFrequency = meanMaxFrequency/node.getProcessors().size();
				factor = factor + (meanCurrFrequency /meanMaxFrequency) * (0.5 + nrOfComputingProcessor/node.getProcessors().size());
			}
		}
		return factor;
	}
}