package experiments.simpat2014.models.article;

import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.resources.computing.coolemall.NodeGroup;
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 simulator.DataCenterWorkloadSimulator;
import eduni.simjava.Sim_system;
import example.energy.BaseEnergyEstimationPlugin;
import experiments.simpat2014.EnvironmentConditions;
import gridsim.dcworms.DCWormsTags;

public class CpuEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {

	private static double Pidle = 4;
	private static double Pfull = 26;

	private static int Tidle = 33;
	
	private double timestamp = 0;
	private double old_temperature = Tidle;
	private double new_temperature = -1;
	private double objective_temperature = Tidle;
	
	private boolean fan = false;
	
	private double next_timer = -1;    
	
	private int cpu_temp_monitor = 0;
	public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
			PhysicalResource resource) {
		/*double powerConsumption = 0;

		Processor cpu = (Processor)resource;
		powerConsumption = Pidle + (Pfull- Pidle) * cpu.getLoadInterface().getRecentUtilization().getValue()/100;			

		return powerConsumption;*/
		
		double processorLoad = 0;
		double powerConsumption = 0;
		Processor proc = (Processor)resource;
		if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF))
			return 0;
		else {
			
			processorLoad = proc.getLoadInterface().getRecentUtilization().getValue();
			double lowestLoadLevel = 100;
			double highestLoadLevel = 0;
			if(proc.getPowerInterface().getPState().getLoadPowerUsage().containsKey(new Double(processorLoad))){
				powerConsumption = proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(processorLoad));
				//System.out.println("power from profile: " + powerConsumption);
			} else {
				for(Double load: proc.getPowerInterface().getPState().getLoadPowerUsage().keySet()){
					if(lowestLoadLevel > load){
						lowestLoadLevel = load;
					}
					if(highestLoadLevel < load){
						highestLoadLevel = load;
					}
				}
				if(processorLoad == 0){
					try{
						powerConsumption = proc.getPowerInterface().getSupportedPowerStates().get(0).getPowerUsage();
						//System.out.println("load = 0; power = idle power usage: " + powerConsumption);
					} catch (Exception e){
						powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));
						//System.out.println("error load = 0; power = 0.7 max power: " + powerConsumption);
					}
				} else {
					
					double lowerLoadLevel = lowestLoadLevel;
					double higherLoadLevel = highestLoadLevel;
					
					try{
					
						for(Double load: proc.getPowerInterface().getPState().getLoadPowerUsage().keySet()){
							if(processorLoad > load){
								lowerLoadLevel = load;
							}
							else if(processorLoad < load){
								higherLoadLevel = load;
								break;
							}
						}
						double powerBelow;
						double powerAbove;
						double a;
						double b;
						if(lowerLoadLevel != higherLoadLevel) {
							powerBelow = proc.getPowerInterface().getPState().getLoadPowerUsage().get(lowerLoadLevel);
							powerAbove = proc.getPowerInterface().getPState().getLoadPowerUsage().get(higherLoadLevel);
							a = (powerAbove - powerBelow)/(higherLoadLevel - lowerLoadLevel);
							b = powerAbove - a * higherLoadLevel;
						} else {
							powerBelow = proc.getPowerInterface().getPState().getLoadPowerUsage().get(lowestLoadLevel);
							powerAbove = proc.getPowerInterface().getPState().getLoadPowerUsage().get(highestLoadLevel);
							a = (powerAbove - powerBelow)/(highestLoadLevel - lowestLoadLevel);
							b = powerAbove - a * highestLoadLevel;
						}
						powerConsumption = a * processorLoad + b;
						/*System.out.println("a" +lowestLoadLevel + ";" +highestLoadLevel);
						System.out.println("b" +lowerLoadLevel + ";" +higherLoadLevel);
						System.out.println("c" +powerBelow + ";" +powerAbove);
						System.out.println(resource.getFullName() + "load: " + processorLoad + "linear power estimation " + powerConsumption);*/
	
					} catch (Exception e){
						powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));	
						//System.out.println("error; power = 0.7 max power: " + powerConsumption);
					}
				}
			}
		}
		//System.out.println("estimated power consumption: " + powerConsumption);
		return powerConsumption;
	}
	
	@Override
	public double estimateTemperature(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
		double future = -1;

		Processor cpu = (Processor) resource;

		double R = 0;
		double Rb = 0;
		double Rcv = 0;
		try{
			Rb = Double.valueOf(cpu.getPowerInterface().getParameters().get("thermalResistance").get(0).getContent()).doubleValue();
		} catch (Exception e){
			//
		}
		
		double k = 0;
		try{
			k = Double.valueOf(cpu.getPowerInterface().getParameters().get("k").get(0).getContent()).doubleValue();
		} catch (Exception e){
			//
		}
		
		double a = 0;
		try{
			a = Double.valueOf(cpu.getPowerInterface().getParameters().get("a").get(0).getContent()).doubleValue();
		} catch (Exception e){
			a = 1;
		}

		double V = 0;
	
		for(Device device: cpu.getParent().getParent().getResourceCharacteristic().getDevices()){
			if(device.getType().equals(StandardResourceType.Fan)){
				if(Integer.valueOf(device.getName().split("_")[1]).intValue() == Integer.valueOf(cpu.getParent().getName().split("_")[1]).intValue() /*|| Integer.valueOf(device.getName().split("_")[1]) == Integer.valueOf(cpu.getParent().getName().split("_")[1]) - EnvironmentConditions.NODES_IN_A_ROW*/){
					Fan fan = (Fan) device;
					V = fan.getAirflowInterface().getRecentAirflow().getValue();
					break;
				}
			}
		}

		Rcv =  1/ (k * Math.pow(V, a));
		R = Rb + Rcv; 
		double C = 0;
		try{
			C = Double.valueOf(cpu.getPowerInterface().getParameters().get("thermalCapacity").get(0).getContent()).doubleValue();
		} catch (Exception e){
			//
		}
		// 1) look where we are
		double delta_t = Sim_system.clock() - timestamp;
		/***************model1*************/
		//new_temperature = objective_temperature - (objective_temperature - old_temperature) * Math.exp(-delta_t/sink);
		
		/***************model2*************/
		new_temperature = objective_temperature - (objective_temperature - old_temperature) * Math.exp(-delta_t/(R * C));
		 

		// 2) calculate if fan is needed ?
		if(new_temperature <= EnvironmentConditions.TFanLow) {
			fan = false;
		}
		if(new_temperature >= EnvironmentConditions.TFanHigh) {
			fan = true; 
		}
		
		// 3) compute new objective
		double Tin = EnvironmentConditions.ROOM_TEMPERATURE;
		double Pcpu = cpu.getPowerInterface().getRecentPowerUsage().getValue();
		new_temperature = objective_temperature - (objective_temperature - old_temperature) * Math.exp(-delta_t/(R * C));
		//new_temperature = (Pcpu * R + Tin) - (Pcpu * R + Tin - Tidle) * Math.exp(-Sim_system.clock()/(R * C));;
		
		
		NodeGroup ng = (NodeGroup) cpu.getParent().getParent();
		for(Node n: ng.getNodes()){
			if(Integer.valueOf(n.getName().split("_")[1]).intValue() - Integer.valueOf(cpu.getParent().getName().split("_")[1]).intValue() == EnvironmentConditions.NODES_IN_A_ROW){
				Tin = n.getThermalInterface().getRecentTemperature().getValue();

			}
		}
		Tin = (2 * Tin + cpu.getThermalInterface().getRecentTemperature().getValue())/3;
		/***************model1 - GEO1*************/
		//double cpuLoad = cpu.getLoadInterface().getRecentUtilization().getValue();
		//double targetTemp = Tidle + cpuLoad/100 * dTfull;
		//if(fan) {
		//	targetTemp = targetTemp - dTfan;
		//}
		
		
		/***************model2 - GEO2*************/
		//Node node = (Node) cpu.getParent();
		//Pserv = node.getPowerInterface().getRecentPowerUsage().getValue();
		//double targetTemp = Pcpu * R + Tin; 
		
		/***************model3 - GEO1 + GEO2*************/
		/*double targetTemp = Pcpu * R + Tin; 
		if(fan) {
			targetTemp = targetTemp - dTfan;
		}*/
	
		/***************model4 - WP*************/
		double targetTemp = Pcpu * R + Tin; 
		//System.out.println("----------" + targetTemp +  ": " +  Pcpu +  ": " +  R +  ": " +  Tin);
		// 4) check if we will need to tune fans
		if(fan && targetTemp < EnvironmentConditions.TFanLow) {
			double timer = C * R * Math.log((new_temperature - targetTemp)/(targetTemp - EnvironmentConditions.TFanLow));
			if(future == -1 || future > timer) {
				future = timer;
			}
		}
		if(!fan && targetTemp > EnvironmentConditions.TFanHigh) {
			double timer = C * R * Math.log((new_temperature - targetTemp)/(targetTemp - EnvironmentConditions.TFanHigh));
			if(future == -1 || future > timer) {
				future = timer;
			}
		}

		// 5) save everything
		timestamp = Sim_system.clock();
		old_temperature = new_temperature;
		objective_temperature = targetTemp;


		if((future >= 0) && ((next_timer < Sim_system.clock()) || (next_timer >= future + Sim_system.clock()))) {
			//DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(future, DCWormsTags.FANMGT, "Test");
			next_timer = future + Sim_system.clock() - 0.01;
		}		
		
		if(new_temperature < EnvironmentConditions.tempLevelMedium2Low){
			if(cpu_temp_monitor != 1){
				cpu_temp_monitor = 1;
				DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_TEMPERATURE_LIMIT_EXCEEDED, resource.getFullName());
			}
		} else if(new_temperature > EnvironmentConditions.tempLevelMedium2Low && new_temperature < EnvironmentConditions.tempLevelLow2Medium){
			if(cpu_temp_monitor != 2){
				cpu_temp_monitor = 2;
				DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_TEMPERATURE_LIMIT_EXCEEDED, resource.getFullName());
			}
		} else if(new_temperature > EnvironmentConditions.tempLevelLow2Medium && new_temperature < EnvironmentConditions.tempLevelHigh2Medium){
			if(cpu_temp_monitor != 3){
				cpu_temp_monitor = 3;
				DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_TEMPERATURE_LIMIT_EXCEEDED, resource.getFullName());
			}
		} else if(new_temperature > EnvironmentConditions.tempLevelHigh2Medium && new_temperature < EnvironmentConditions.tempLevelMedium2High){
			if(cpu_temp_monitor != 4){
				cpu_temp_monitor = 4;
				DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_TEMPERATURE_LIMIT_EXCEEDED, resource.getFullName());
			}
		} else if(new_temperature > EnvironmentConditions.tempLevelMedium2High && new_temperature < EnvironmentConditions.tempLevelMax2High){
			if(cpu_temp_monitor != 5){
				cpu_temp_monitor = 5;
				DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_TEMPERATURE_LIMIT_EXCEEDED, resource.getFullName());
			}
		} else if(new_temperature > EnvironmentConditions.tempLevelMax2High && new_temperature < EnvironmentConditions.tempLevelHigh2Max){
			if(cpu_temp_monitor != 6){
				cpu_temp_monitor = 6;
				DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_TEMPERATURE_LIMIT_EXCEEDED, resource.getFullName());
			}
		} else if(new_temperature > EnvironmentConditions.tempLevelHigh2Max){
			if(cpu_temp_monitor != 7){
				cpu_temp_monitor = 7;
				DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_TEMPERATURE_LIMIT_EXCEEDED, resource.getFullName());
			}
		}
		//DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_TEMPERATURE_LIMIT_EXCEEDED, resource.getFullName());

		return new_temperature;
	}
}