package experiments.simpat2014.models.article;


import java.util.List;

import schedframe.resources.CoolEmAllResourceType;
import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.resources.computing.Rack;
import schedframe.resources.computing.coolemall.NodeGroup;
import schedframe.resources.computing.profiles.energy.ResourceEvent;
import schedframe.resources.computing.profiles.energy.airthroughput.CustomAirflowStateName;
import schedframe.resources.computing.profiles.energy.power.PState;
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 example.energy.coolemall.CoolEmAllTestbedMeasurements;
import experiments.simpat2014.EnvironmentConditions;
import gridsim.dcworms.DCWormsTags;


public class NodeEnergyEstimationPluginPowerCapping extends BaseEnergyEstimationPlugin {

	//double powerCapLevel = -1;
	//double powerUpgradeLevel = -1;
	
	
	private static double Tidle = 26;

	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 static double Pidle = 6;
	private static double Pfull = 20;


	public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
			PhysicalResource resource) {
		

		//loadThresholds((ComputingResource)resource);

		Node node = (Node) resource;
		double powerConsumption = 0;

		double Pcpu = 0;	
		for(Processor cpu: node.getProcessors()){
			Pcpu = Pcpu + cpu.getPowerInterface().getRecentPowerUsage().getValue();
		}
		
		powerConsumption = Pcpu + Pidle + (Pfull- Pidle) * node.getLoadInterface().getRecentUtilization().getValue()/100;
		
		/*if(powerCapLevel!= -1 && powerConsumption > powerCapLevel){
			DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, null);
		}
		else if(powerUpgradeLevel != -1 && powerConsumption < powerUpgradeLevel){
			DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, null);
		}*/
		return powerConsumption;
	}

	@Override
	public double estimateTemperature(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) {

		Node node = (Node) resource;
		Processor cpu = node.getProcessors().get(0);
		double Pserv = 0;

		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 C = 0;
		try{
			C = Double.valueOf(cpu.getPowerInterface().getParameters().get("thermalCapacity").get(0).getContent()).doubleValue();
		} catch (Exception e){
			//
		}
		
		double V = 0;
		double Pfan = 0;
		for(Device device: node.getParent().getResourceCharacteristic().getDevices()){
			if(device.getType().equals(StandardResourceType.Fan)){
				if(Integer.valueOf(device.getName().split("_")[1]).intValue() == Integer.valueOf(node.getName().split("_")[1]).intValue() || Integer.valueOf(device.getName().split("_")[1]).intValue() == Integer.valueOf(cpu.getParent().getName().split("_")[1]).intValue() - EnvironmentConditions.NODES_IN_A_ROW){
					Fan fan = (Fan) device;
					V = fan.getAirflowInterface().getRecentAirflow().getValue();
					Pfan =  fan.getPowerInterface().getRecentPowerUsage().getValue();
					break;
				}
			}
		}

		Rcv =  1/ (k * Math.pow(V, a));
		R = Rb + Rcv; 
		
		double K = 0;
		double Cair = EnvironmentConditions.AIR_HEAT_CAPACITY;
		double ro = EnvironmentConditions.AIR_DENSITY;

		K = V * Cair * ro;
		//System.out.println("-------K: " + K +  "; V:" + V);

		double delta_t = Sim_system.clock() - timestamp;

		double Tin = EnvironmentConditions.ROOM_TEMPERATURE;
		Pserv = node.getPowerInterface().getRecentPowerUsage().getValue();
		Pserv = Pserv + Pfan;
		
		NodeGroup ng = (NodeGroup) node.getParent();
		for(Node n: ng.getNodes()){
			if(Integer.valueOf(n.getName().split("_")[1]) - Integer.valueOf(node.getName().split("_")[1]) == EnvironmentConditions.NODES_IN_A_ROW){
				Tin = n.getThermalInterface().getRecentTemperature().getValue();
			}
		}
		
		double targetTemp = Pserv/K + Tin; 
		objective_temperature = targetTemp;

		new_temperature = objective_temperature + (old_temperature - objective_temperature) * Math.exp(-delta_t / (R * C));

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

		return new_temperature;
	}
	
	/*private void loadThresholds(ComputingResource compResource){
		
		Node n = (Node) compResource;
		double pcLevel = 0;
		double puLevel = 0;
		for(Processor proc: n.getProcessors()){
			PState highestPState =  proc.getPowerInterface().getHighestPState();
			PState secondHighestPState =  proc.getPowerInterface().getLowestPState();
			for(String pStateName: proc.getPowerInterface().getSupportedPStates().keySet()){
				PState pState = proc.getPowerInterface().getSupportedPStates().get(pStateName);
				if(pState.getFrequency()  < secondHighestPState.getFrequency() && pState.getFrequency() > highestPState.getFrequency()){
					secondHighestPState = pState;
				}
			}
			double maxMinPowerUsage = 0;
			double powerUsage = 0;
			
			for(Double load: highestPState.getLoadPowerUsage().keySet()){
				powerUsage = highestPState.getLoadPowerUsage().get(load);
				if(powerUsage > maxMinPowerUsage){
					maxMinPowerUsage= powerUsage;				
				}
			}
			pcLevel = pcLevel + maxMinPowerUsage;
			
			maxMinPowerUsage = 0;
			powerUsage = 0;
			
			for(Double load: secondHighestPState.getLoadPowerUsage().keySet()){
				powerUsage = secondHighestPState.getLoadPowerUsage().get(load);
				if(powerUsage > maxMinPowerUsage){
					maxMinPowerUsage= powerUsage;				
				}
			}
			puLevel = puLevel + maxMinPowerUsage;
			
		}

		puLevel = (pcLevel * pcLevel / puLevel);

		//powerCapLevel = pcLevel;
		//powerUpgradeLevel = puLevel;
		
		powerCapLevel = 60;
		powerUpgradeLevel = 40;
	}*/
}