package schedframe.resources.computing.profiles.energy;

import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import schedframe.events.Event;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.extensions.Extension;
import schedframe.resources.computing.extensions.ExtensionException;
import schedframe.resources.computing.extensions.ExtensionType;
import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputInterfaceFactory;
import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile;
import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirThroughputInterface;
import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory;
import schedframe.resources.computing.profiles.energy.power.PowerProfile;
import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
import schedframe.resources.computing.profiles.energy.thermal.ThermalInterfaceFactory;
import schedframe.resources.computing.profiles.energy.thermal.ThermalProfile;
import schedframe.resources.computing.profiles.energy.thermal.ui.ThermalInterface;
import schedframe.scheduling.manager.tasks.JobRegistryImpl;

public class EnergyExtension implements Extension{

	private Log log = LogFactory.getLog(EnergyExtension.class);

	protected PowerInterface powerInterface;
	protected PowerProfile powerProfile;
	
	protected AirThroughputInterface airFlowInterface;
	protected AirThroughputProfile airFlowProfile;
	
	protected ThermalInterface thermalInterface;
	protected ThermalProfile thermalProfile;
	
  	protected ComputingResource computingResource;


	public EnergyExtension(ComputingResource computingResource, PowerInterface powerInterface, PowerProfile powerProfile) {
		this.powerProfile = powerProfile;
		this.powerInterface = PowerInterfaceFactory.createPowerInterface(computingResource, powerProfile);
	}
	
	public EnergyExtension(ComputingResource computingResource, PowerProfile powerProfile,
			AirThroughputProfile airFlowProfile) {
		super();
		this.computingResource = computingResource;
		this.powerProfile = powerProfile;
		this.powerInterface = PowerInterfaceFactory.createPowerInterface(computingResource, powerProfile);
		this.airFlowProfile = airFlowProfile;
		this.airFlowInterface = AirThroughputInterfaceFactory.createAirThroughputInterface(computingResource, airFlowProfile);
	}
	
	public EnergyExtension(ComputingResource computingResource, PowerProfile powerProfile,
			AirThroughputProfile airFlowProfile, ThermalProfile thermalProfile) {
		super();
		this.computingResource = computingResource;
		this.powerProfile = powerProfile;
		this.powerInterface = PowerInterfaceFactory.createPowerInterface(computingResource, powerProfile);
		this.airFlowProfile = airFlowProfile;
		this.airFlowInterface = AirThroughputInterfaceFactory.createAirThroughputInterface(computingResource, airFlowProfile);
		this.thermalProfile = thermalProfile;
		this.thermalInterface = ThermalInterfaceFactory.createThermalInterface(computingResource, thermalProfile);
	}

	public boolean supportsEvent(Event event) {

		if(powerProfile == null || powerProfile.getEnergyEstimationPlugin() == null)
			return false;
		if(event.getType().getName().equals(EnergyEventType.POWER_STATE_CHANGED.getName()))
			return true;
		else if(event.getType().getName().equals(EnergyEventType.FREQUENCY_CHANGED.getName()))
			return true;
		else if(event.getType().getName().equals(EnergyEventType.TASK_STARTED.getName()))
			return true;
		else if(event.getType().getName().equals(EnergyEventType.TASK_FINISHED.getName()))
			return true;
		else if(event.getType().getName().equals(EnergyEventType.RESOURCE_UTILIZATION_CHANGED.getName()))
			return true;
	
		if(event.getType().getName().equals(EnergyEventType.AIRFLOW_STATE_CHANGED.getName()))
			return true;
		
		else return false;
	}

	public void handleEvent(Event event) {
		
		EnergyEvent enEvent = (EnergyEvent)event;
		double power = 0;
		double temperature = 0;
		try{
			switch (enEvent.getType()) {
			
			case POWER_STATE_CHANGED:
				power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				/*if(computingResource instanceof ComputingNode){
					ComputingNode node = (ComputingNode)computingResource;
					if(event.getData() instanceof PowerState){
						PowerState newState = (PowerState)event.getData();
						if(newState == PowerState.ON) {
							addToPowerUsageHistory(power+node.getPowerInterface().START_COST);
							addToPowerUsageHistory(DateTimeUtils.currentTimeMillis() + node.getPowerInterface().START_TIME, power);
						}else if(newState == PowerState.OFF){
							addToPowerUsageHistory(power+node.getPowerInterface().SHUTDOWN_COST);
							addToPowerUsageHistory(DateTimeUtils.currentTimeMillis() + node.getPowerInterface().SHUTDOWN_TIME, power);
						}
					}
				}
				else*/ powerProfile.addToPowerUsageHistory(power);
				break;
				
			case FREQUENCY_CHANGED:
				power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				powerProfile.addToPowerUsageHistory(power);
				temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				thermalProfile.addToTemperatureHistory(temperature);
				break;
				
			case TASK_STARTED:
				power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				powerProfile.addToPowerUsageHistory(power);
				temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				thermalProfile.addToTemperatureHistory(temperature);
				break;
	
			case TASK_FINISHED:
				//System.out.println(this.resource.getName() + " - ENERGY EXTENSION: TASK FINISHED");
				power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				//System.out.println(this.resource.getName() + " - ESTIMATED ENERGY:" + power);
				powerProfile.addToPowerUsageHistory(power);
				temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				thermalProfile.addToTemperatureHistory(temperature);
				break;
				
			case RESOURCE_UTILIZATION_CHANGED:
				power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				powerProfile.addToPowerUsageHistory(power);
				temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				thermalProfile.addToTemperatureHistory(temperature);
				break;
				
			case AIRFLOW_STATE_CHANGED:
				double airFlow = powerProfile.getEnergyEstimationPlugin().estimateAirThroughput(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				airFlowProfile.addToPowerUsageHistory(airFlow);
				power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				powerProfile.addToPowerUsageHistory(power);
				temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
				thermalProfile.addToTemperatureHistory(temperature);
				break;
			}
		}catch(Exception e){
			
		}
	}

	public void init(Properties properties) throws ExtensionException {
		// TODO Auto-generated method stub
	}

	public ExtensionType getType() {
		return ExtensionType.ENERGY_EXTENSION;
	}

	/*public ComputingResource getResource() {
		return computingResource;
	}

	public void setResource(ComputingResource compRes){
		this.computingResource = compRes;
	}*/

	public PowerInterface getPowerInterface() {
		return powerInterface;
	}

	public PowerProfile getPowerProfile() {
		return powerProfile;
	}

	public AirThroughputInterface getAirThroughputInterface() {
		return airFlowInterface;
	}

	public AirThroughputProfile getAirFlowProfile() {
		return airFlowProfile;
	}
	
	public ThermalProfile getThermalProfile() {
		return thermalProfile;
	}

	public ThermalInterface getThermalInterface() {
		return thermalInterface;
	}

}