package test.rewolucja.energy.extension;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.DateTimeUtils;

import schedframe.resources.profile.PowerUsage;
import simulator.utils.InstanceFactory;
import test.rewolucja.energy.EnergyEvent;
import test.rewolucja.energy.EnergyEventType;
import test.rewolucja.energy.plugin.EnergyEstimationPluginInterface;
import test.rewolucja.energy.profile.PowerInterface;
import test.rewolucja.extensions.Extension;
import test.rewolucja.extensions.ExtensionException;
import test.rewolucja.extensions.ExtensionType;
import test.rewolucja.resources.ResourceType;
import test.rewolucja.resources.physical.base.ComputingResource;
import test.rewolucja.resources.test.Event;
import test.rewolucja.scheduling.JobRegistry;
import example.energy.DefaultEnergyEstimationPlugin;

public class EnergyExtension implements Extension {

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

	protected PowerInterface powerInterface;
	protected List<PowerUsage> powerUsage;
	protected EnergyEstimationPluginInterface energyEstimationPlugin;

   protected ComputingResource resource;


	
	public EnergyExtension(ComputingResource resource, PowerInterface powerInterface, String energyEstimationPluginClassName) {
		initPlugin(energyEstimationPluginClassName);
		this.powerInterface = powerInterface;
		this.resource = resource;
		this.powerUsage = new ArrayList<PowerUsage>();
		//int power = energyEstimationPlugin.estimatePowerConsumption(null, resource);
		//if(resource.getType()==ResourceType.CPU)
		//	addToPowerUsageHistory(powerInterface.getPowerConsumption(powerInterface.getPowerState()));
	}
	
	public void initPlugin(String energyEstimationPluginClassName){
		if(energyEstimationPluginClassName != null) {
			energyEstimationPlugin = (EnergyEstimationPluginInterface) InstanceFactory.createInstance(
					energyEstimationPluginClassName, EnergyEstimationPluginInterface.class);
			if(energyEstimationPlugin == null){
				energyEstimationPlugin = new DefaultEnergyEstimationPlugin();
				log.info("Using default energy estimation plugin: " + DefaultEnergyEstimationPlugin.class.getName());
				
			} else {
				energyEstimationPlugin.init(null);
			}
			
		} else {
			energyEstimationPlugin = new DefaultEnergyEstimationPlugin();
			log.info("Using default energy estimation plugin: " + DefaultEnergyEstimationPlugin.class.getName());
		}
	}

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

	@Override
	public void dispose() throws ExtensionException {
		// TODO Auto-generated method stub

	}

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

	@Override
	public boolean supportsEvent(Event event) {
		EnergyEvent enEvent = (EnergyEvent)event;
		switch (enEvent.getType()) {

		case POWER_STATE_CHANGED:
			return true;
		case FREQUENCY_CHANGED:
			return true;
		case TASK_STARTED:
			return true;
		case TASK_FINISHED:
			return true;
		default:
			return false;
		}
	}

	public PowerInterface getPowerInterface() {
		return powerInterface;
	}

	private void addToPowerUsageHistory(double power) {

		if (powerUsage.size() == 0) {
			PowerUsage usage = new PowerUsage(DateTimeUtils.currentTimeMillis(), power);
			powerUsage.add(usage);
			return;
		}

		int lastIdx = powerUsage.size() - 1;
		double lastPower = powerUsage.get(lastIdx).getValue();
		if (lastPower != power) {
			PowerUsage usage = powerUsage.get(lastIdx);
			long currentTime = DateTimeUtils.currentTimeMillis();
			if (usage.getTimestamp() == currentTime) {
				usage.setValue(power);
				if(lastIdx > 0 && powerUsage.get(lastIdx - 1).getValue() == power)
					powerUsage.remove(usage);

				//powerUsage.remove(usage);
				//usage = new PowerUsage(DateTimeUtils.currentTimeMillis(), power);
				//powerUsage.add(usage);
			} else {
				usage = new PowerUsage(DateTimeUtils.currentTimeMillis(), power);
				powerUsage.add(usage);
			}
		}
	}

	public List<PowerUsage> getPowerUsageHistory() {
		if(powerUsage.size() == 0){
			double power = energyEstimationPlugin.estimatePowerConsumption(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getName()), new JobRegistry(resource.getName()), resource);
			addToPowerUsageHistory(power);
		}
		return powerUsage;
	}


	@Override
	public void handleEvent(Event event) {
		EnergyEvent enEvent = (EnergyEvent)event;
		double power = 0;
		switch (enEvent.getType()) {
		
		case POWER_STATE_CHANGED:
			power = energyEstimationPlugin.estimatePowerConsumption(enEvent, new JobRegistry(resource.getName()), resource);
			addToPowerUsageHistory(power);
			break;
			
		case FREQUENCY_CHANGED:
			power = energyEstimationPlugin.estimatePowerConsumption(enEvent, new JobRegistry(resource.getName()), resource);
			addToPowerUsageHistory(power);
			break;
			
		case TASK_STARTED:
			
			power = energyEstimationPlugin.estimatePowerConsumption(enEvent, new JobRegistry(resource.getName()), resource);
			addToPowerUsageHistory(power);
			break;

		case TASK_FINISHED:
			//System.out.println(this.resource.getName() + " - ENERGY EXTENSION: TASK FINISHED");
			power = energyEstimationPlugin.estimatePowerConsumption(enEvent, new JobRegistry(resource.getName()), resource);
			//System.out.println(this.resource.getName() + " - ESTIMATED ENERGY:" + power);
			addToPowerUsageHistory(power);

			break;

		}
	}
	

	public ComputingResource getResource() {
		return resource;
	}


}