package test.rewolucja.energy.profile;

import gridsim.GridSimTags;
import gridsim.gssim.GssimTags;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import schedframe.resources.PowerState;
import schedframe.resources.units.CpuSpeed;
import schedframe.scheduling.utils.ResourceParameterName;
import test.rewolucja.energy.EnergyEvent;
import test.rewolucja.energy.EnergyEventType;
import test.rewolucja.energy.extension.EnergyExtension;
import test.rewolucja.extensions.ExtensionType;
import test.rewolucja.resources.ResourceStatus;
import test.rewolucja.resources.physical.implementation.CPU;

public class CPUPowerProfile extends AbstractPowerProfile{

	protected CPU cpu;
	protected PState pState;

	public CPUPowerProfile(){
		powerState = PowerState.ON;
		pState = getSupportedPStates().get(PStateType.P0);
	}

	public void visit(CPU p){
		cpu = p;
		energyExtension = (EnergyExtension) cpu.getExtensionList().getExtension(ExtensionType.ENERGY_EXTENSION);
	}

	public boolean setPowerState(PowerState state){
		if(!supportPowerState(state))
			return false;
		powerState = state;

		if(state == PowerState.OFF){
			cpu.setStatus(ResourceStatus.NOTAVAILABLE);
		}
		else if(state == PowerState.ON){
			cpu.setStatus(ResourceStatus.FREE);
		}
		
		cpu.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, cpu.getName()));
		return true;
	}

	
	public double getPowerConsumption(PowerState state) {
		if(powerState == PowerState.OFF)
			return 0;
		else if(powerState == PowerState.ON){
			if(cpu.getStatus() == ResourceStatus.BUSY)
				return getPState().getPower();
			else if(cpu.getStatus() == ResourceStatus.FREE)
				return getPState().getPower()/1.25;
		}
		return 1;
	}


	public boolean supportPowerState(PowerState state) {
		switch(state){
			case ON: 
				return true;
			case OFF: 
				return true;
			default: return false;
		}
	}

	public List<PowerState> getSupportedPowerStates() {
		return Arrays.asList(new PowerState[]{PowerState.ON, PowerState.OFF});
	}

	
	public double getFrequency() {
		return pState.getFrequency();
	}

	public boolean setFrequency(double freq) {
		for(PStateType pStateType: getSupportedPStates().keySet()){
			if(getSupportedPStates().get(pStateType).getFrequency() == freq){
				setPState(pStateType);
				return true;
			}
		}
		return false;
	}

	public PState getPState(){
		return pState;
	}
	
	public boolean setPState(PStateType pStateType){
		PState newPState = getSupportedPStates().get(pStateType);
		if(newPState != null)
		{
			double factor = pState.getFrequency()/newPState.getFrequency();
			pState = newPState;
			CpuSpeed speed = (CpuSpeed )cpu.getResourceCharacteristic().getResourceUnits().get(ResourceParameterName.CPUSPEED).get(0);
			//speed.setAmount((int)pState.getFrequency());

			cpu.handleEvent(new EnergyEvent(EnergyEventType.FREQUENCY_CHANGED, cpu.getName()));
			cpu.getLogicalResource().sendInternal(GridSimTags.SCHEDULE_NOW, GssimTags.UPDATE, cpu.getName());
			return true;
		}
		return false;
	}
	
	public Map<PStateType, PState> getSupportedPStates(){
		return DefaultModel.getConfiguration();
	}
	
	private static class DefaultModel{
		private static Map<PStateType, PState> pStates;
		static {
			Map<PStateType, PState> pStatesMap = new HashMap<PStateType, PState>();
			pStatesMap.put(PStateType.P0, new PState(PStateType.P0, 3000, 0, 350));
			pStatesMap.put(PStateType.P1, new PState(PStateType.P1, 2660, 0, 343));
			pStatesMap.put(PStateType.P2, new PState(PStateType.P2, 2330, 0, 337));
			pStatesMap.put(PStateType.P3, new PState(PStateType.P3, 2000, 0, 330));
			pStates = Collections.unmodifiableMap(pStatesMap);
		}
		
		public static Map<PStateType, PState> getConfiguration(){
			return pStates;
		}
	}
}