package experiments.simpat2014.models.article;

import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.ComputingResource;
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.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 example.energy.BaseEnergyEstimationPlugin;
import experiments.simpat2014.EnvironmentConditions;
import gridsim.dcworms.DCWormsTags;

public class NodeGroupEnergyEstimationPluginPowerCapping extends BaseEnergyEstimationPlugin{

	double powerCapLevel = -1;
	double powerUpgradeLevel = -1;
	
	public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
			PhysicalResource resource) {
		

		loadThresholds((ComputingResource)resource);
		
		double powerConsumption = 0;
		NodeGroup nodeGroup = (NodeGroup)resource;
		for(Node node: nodeGroup.getNodes()){
			try{
				powerConsumption = powerConsumption + node.getPowerInterface().getRecentPowerUsage().getValue();
				powerConsumption = powerConsumption + node.getProcessors().get(0).getResourceCharacteristic().getDevices().get(0).getPowerInterface().getRecentPowerUsage().getValue();

			} catch (Exception e){
			}
		}

		for(Device device: nodeGroup.getResourceCharacteristic().getDevices()){
			if(device.getType().equals(StandardResourceType.Fan)){
				Fan fan = (Fan) device;
				powerConsumption = powerConsumption + fan.getPowerInterface().getRecentPowerUsage().getValue();
			}
		}
		
		if(powerCapLevel!= -1 && powerConsumption > powerCapLevel){
			DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, resource.getFullName());
		}
		else if(powerUpgradeLevel != -1 && powerConsumption < powerUpgradeLevel){
			DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, resource.getFullName());
		}
		
		return powerConsumption;
	}

	private void loadThresholds(ComputingResource compResource){
		
		NodeGroup ng = (NodeGroup) compResource;
		double pcLevel = 0;
		double puLevel = 0;
		for(Processor proc: ng.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 = EnvironmentConditions.powerCapLevel;
		powerUpgradeLevel = EnvironmentConditions.powerUpgradeLevel;
	}
}