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.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 ComputingResource computingResource;

	public EnergyExtension(PowerInterface powerInterface, PowerProfile pp) {
		this.powerInterface = powerInterface;
		this.powerProfile = pp;
	}

	public EnergyExtension(PowerInterface powerInterface, PowerProfile powerProfile,
			AirThroughputInterface airFlowInterface, AirThroughputProfile airFlowProfile) {
		super();
		this.powerInterface = powerInterface;
		this.powerProfile = powerProfile;
		this.airFlowInterface = airFlowInterface;
		this.airFlowProfile = airFlowProfile;
	}
	
	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 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;
		
		if(airFlowProfile == null)
			return false;	
		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;
		switch (enEvent.getType()) {
		
		case POWER_STATE_CHANGED:
			power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
			/*if(resource instanceof ComputingNode){
				ComputingNode node = (ComputingNode)resource;
				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);
			break;
			
		case TASK_STARTED:
			power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
			powerProfile.addToPowerUsageHistory(power);
			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);
			break;
		case AIRFLOW_STATE_CHANGED:
			System.out.println("=====" + computingResource.getName());
			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);
			break;
		}
	}

	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;
	}

}