package test.fips.models.i5;

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.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.ConfigurationOptions;
import example.energy.BaseEnergyEstimationPlugin;
import example.energy.coolemall.CoolEmAllTestbedMeasurements;
import test.fips.EnvironmentConditions;

public class TangHeatCoolingDeviceEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {

	public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
		double airflow = 0;
		return airflow;
	}

	public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
			PhysicalResource resource) {
		
		double powerConsumption = 0;
		
		Device coolingDevice = (Device) resource;
		ComputingResource room = (ComputingResource) coolingDevice.getComputingResource();
		
		double Pload_dc = calculatePit(room);
		double Q = calculateQ( 0.02*Pload_dc, room);
		double airTemp = EnvironmentConditions.ROOM_TEMPERATURE;
		double CoP = 0.0068 * Math.pow(airTemp, 2) + 0.0008 * airTemp + 0.458;
		
		powerConsumption = Q/CoP;
		return powerConsumption;
	}
	
	private double calculatePit(ComputingResource room){
		double Pload_dc = 0;
		for(ComputingResource cr: room.getChildren()){
			Rack rack = (Rack)cr;
			Pload_dc = Pload_dc + rack.getPowerInterface().getRecentPowerUsage().getValue();
		}
		return Pload_dc;
	}

	
	private double calculateQ(double Pothers, ComputingResource room){

		double Qdc = 0;


		/**************** HEAT ****************/
		
		double Qload_dc = 0;
		double Qothers = 0;

		double delta_2; //DEBB - currently not present;
		delta_2 = 0.4;
		
		for(ComputingResource cr: room.getChildren()){
			Rack rack = (Rack)cr;
			double QnodeGroup = 0;
			for(ComputingResource nodeGroup: rack.getChildren()){
				double Qnodes = 0;
				for(ComputingResource node: nodeGroup.getChildren()){
					double Qcpu = 0;
					Node n = (Node)node;
					for(Processor proc: n.getProcessors()){
						Qcpu = Qcpu + proc.getPowerInterface().getRecentPowerUsage().getValue();
					}
					Qnodes = Qnodes + n.getPowerInterface().getRecentPowerUsage().getValue();;
				}
				double Qfans = 0;
				for(Device device: nodeGroup.getResourceCharacteristic().getDevices()){
					Fan fan = (Fan) device;
					if(fan.getPowerInterface().getRecentPowerUsage().getValue() == -1){
						try {
							Qfans = Qfans + (1 - delta_2) * fan.getAirflowInterface().getPowerConsumption(fan.getAirflowInterface().getAirflowState());
						} catch (NoSuchFieldException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}else
						Qfans = Qfans + (1 - delta_2) * fan.getPowerInterface().getRecentPowerUsage().getValue();
				}
				QnodeGroup = QnodeGroup + Qnodes + Qfans;
			}
			int nrOfPoweredOffNodes = 0;
			for(Node node: rack.getNodes()){
				if(node.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF)){
					nrOfPoweredOffNodes++;
				}
			}
			if(nrOfPoweredOffNodes != rack.getNodes().size()){
				Qload_dc  = Qload_dc + QnodeGroup + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION;
			} else {
				Qload_dc  = Qload_dc + QnodeGroup;
			}
		}
		
		Qothers = Pothers;
		
		Qdc = Qload_dc + Qothers;

		
		return Qdc;
	}
	
}