package classes;

import classes.StorageElement;
import classes.comparator.StorageElemCompOnCharge;
import classes.comparator.StorageElemCompOnDistance;

import java.util.ArrayList;
import java.util.Collections;

public class StorageProductionController {
	private ArrayList<StorageElement> storages;
	private float energyRequiredForPowerplantBlackstart;

	public StorageProductionController(ArrayList<StorageElement> storages, float energyRequiredForPowerplantBlackstart) {
		this.storages = storages;
		this.energyRequiredForPowerplantBlackstart = energyRequiredForPowerplantBlackstart;
	}

	public double currentPossibleStorageProduction() {
		return getPossibleProduction(storages);
	}

//	public float currentStorageProduction() {
//		float producedEnergy = 0;
//		for (StorageElement ele : storages) {
//			if (ele.getStatus().equals(StorageElement.Mode.EMIT)) {
//				// needed to no emit more than what is available
//				if(ele.getStateOfCharge() - ele.getEnergyPerElement() < 0){
//					ele.setEnergyPerElement(ele.getStateOfCharge());
//				}
//				producedEnergy += ele.getEnergyPerElement();
//			}
//		}
//		return producedEnergy;
//	}

	public void enableStorageDischarging(final double energyNeeded) {
		Collections.sort(storages, Collections.reverseOrder());
//		System.out.println("energy needed from storage" + energyNeeded);
//		int storagesLeft = storages.size();
        double energyLeftToEnabled = energyNeeded;
        	for (StorageElement se: storages) {
				if(!se.chargeDepleted()){
					energyLeftToEnabled = energyLeftToEnabled - se.setStatusAndSetEnergy(
											StorageElement.Mode.EMIT, energyLeftToEnabled, energyRequiredForPowerplantBlackstart);
				}
//				storagesLeft = storagesLeft - 1;
                if(energyLeftToEnabled <= 0){
                	System.out.println("enabled energy from storage");
//					assessFitness(1,1,1,energyNeeded);
                    return;
                }/*else if(storagesLeft <= 0){
                	System.out.println("nicht genug enabled");
				}*/
            }

	}

	public void setAllStorageToStandy() {
		for (StorageElement se : storages) {
			se.setStatusAndSetEnergy(StorageElement.Mode.STANDBY, 0, energyRequiredForPowerplantBlackstart);
		}
	}

	//TODO: selbe probleme wie discharging
	void enableStorageCharging(float energyAvailable){
		Collections.sort(storages, new StorageElemCompOnCharge());
		System.out.println("energy available to storage" + energyAvailable);
		double availableEnergyLeft = energyAvailable;
		for (StorageElement se: storages) {
			if(!se.fullyCharged()){
				availableEnergyLeft = availableEnergyLeft - se.setStatusAndSetEnergy(
						StorageElement.Mode.COLLECT, availableEnergyLeft, energyRequiredForPowerplantBlackstart);
			}
			if(availableEnergyLeft <= 0){
				System.out.println("storage charging");
				return;
			}
		}
	}

//	private void assessFitness(float w1, float w2, float w3, double energyNeeded){
//		double fitness = 0f;
//
//		fitness = w1 * distanceFitness(energyNeeded) + w2 * supplyFitness(energyNeeded) + w3 * holdMaxPowerFitness();
//		System.out.println("Fitness score: " + fitness);
//	}
//
//	private double distanceFitness(double energyNeeded){//TODO: nicht lieber mit wiederstand?
//		double distancePenalty = 0;
//		ArrayList<StorageElement> sortedElements = storages;
//		Collections.sort(sortedElements, Collections.reverseOrder());
//		for (StorageElement ele : sortedElements) {
//			if(!ele.chargeDepleted()){
//				if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
//					distancePenalty += goodDistance(energyNeeded ,ele);
//					energyNeeded -= ele.getEnergyPerElement();
//				}
//			}
//		}
//		return distancePenalty;
//	}
//
//	private double goodDistance(double energyNeeded, StorageElement ele){
//		if(energyNeeded <= 0){
//			return 0;
//		}
//		if(energyNeeded >= ele.getCurrentMaxOutRatio()){
//			if(ele.getChargingRatio() < ele.getCurrentMaxOutRatio()){
//				return Math.abs(ele.getCurrentMaxOutRatio() - ele.getChargingRatio());
//			}else{
//				return 0;
//			}
//		}else{
//			if(ele.getChargingRatio() < energyNeeded){
//				return Math.abs(energyNeeded - ele.getChargingRatio());
//			}else{
//				return 0;
//			}
//		}
//	}

//	private double produceTooMuch(StorageElement ele){
//		if(avgUtilization() >= ele.getUtilization(energyRequiredForPowerplantBlackstart)){
//			return 0;
//		}else{
//			return Math.abs(avgUtilization() - ele.getUtilization(energyRequiredForPowerplantBlackstart));
//		}
//	}
//
//	private double produceTooLittle(StorageElement ele){
//		if(avgUtilization() <= ele.getUtilization(energyRequiredForPowerplantBlackstart)){
//			return 0;
//		}else{
//			return Math.abs(avgUtilization() - ele.getUtilization(energyRequiredForPowerplantBlackstart));
//		}
//	}
//
//	private double avgDistance(){
//		double totalDistance = 0;
//		for (StorageElement ele : storages) {
//			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
//				totalDistance += ele.getHighDistance() + ele.getLowDistance();
//			}
//		}
//		return totalDistance/activeStorages();
//	}
//
//	private double avgUtilization(){
//		double totalUtilization = 0;
//		for (StorageElement ele : storages) {
//			if(!ele.chargeDepleted()){
//				totalUtilization += ele.getUtilization(energyRequiredForPowerplantBlackstart);
//			}
//		}
//		return totalUtilization/activeStorages();
//	}
//
//	private double activeStorages(){
//		double activeStorages = 0;
//		for (StorageElement ele : storages) {
//			if(ele.getStatus().equals(StorageElement.Mode.EMIT)){
//				activeStorages++;
//			}
//		}
//		return activeStorages;
//	}

//	private double supplyFitness(double energyNeeded){
//		double activeStoragePower = 0;
//		for (StorageElement ele : storages) {
//			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
//				activeStoragePower += ele.getEnergyPerElement();
//			}
//		}
//		if((int) activeStoragePower + 1 < energyNeeded){
//			return Math.pow(9000, 9000);//TODO:
//		}else{
//			return Math.abs(activeStoragePower - energyNeeded);
//		}
//	}
//
//	private double holdMaxPowerFitness(){
//		double willNotHoldPower = 0;
//		for (StorageElement ele : storages) {
//			if(ele.getStatus().equals(StorageElement.Mode.EMIT)) {
//				willNotHoldPower += maxPowerNextIteration(ele);
//			}
//		}
//		return willNotHoldPower;
//	}
//
//	private double maxPowerNextIteration(StorageElement ele){
//		if(ele.getStateOfCharge() - ele.getChargingRatio() >= ele.getNominalOutRatio()){//TODO:
//			return 0;
//		}else{
//			return ele.getNominalOutRatio() - (ele.getStateOfCharge() - ele.getChargingRatio());
//		}
//	}

	public void scheduleDischarging(final double energyNeeded){
		ArrayList<StorageElement> lowRisk = new ArrayList<StorageElement>();
		ArrayList<StorageElement> middleRisk = new ArrayList<StorageElement>();
		ArrayList<StorageElement> highRisk = new ArrayList<StorageElement>();
		
		//vorsortieren
		for (StorageElement ele : storages) {
			if(ele.getStateOfChargeInPercent() < 0.2){
				if(!ele.chargeDepleted()
						&& ele.getStateOfCharge() - ele.getCurrentMaxOutRatio() < ele.getCurrentMaxOutRatio()){
					highRisk.add(ele);
				}else{
					middleRisk.add(ele);
				}
			}else{
				lowRisk.add(ele);
			}
		}

		double energyLeftToEnabled = energyNeeded;
		//activate with lowRisk
		lowRisk.sort(new StorageElemCompOnDistance());
		for (StorageElement ele : lowRisk) {
			energyLeftToEnabled -= ele.setStatusAndSetEnergy(
					StorageElement.Mode.EMIT, energyLeftToEnabled, energyRequiredForPowerplantBlackstart);
			if(energyLeftToEnabled <=0) {
				return;
			}
		}

		double middleRiskEnable = 0;
		middleRisk.sort(new StorageElemCompOnCharge());
		if(energyLeftToEnabled <=0){
			return;
		}else{
			for(StorageElement ele : middleRisk){
				energyLeftToEnabled -= ele.setStatusAndSetEnergy(
						StorageElement.Mode.EMIT, energyLeftToEnabled, energyRequiredForPowerplantBlackstart);
				if(energyLeftToEnabled <=0) {
					return;
				}
			}
		}
		energyLeftToEnabled -= middleRiskEnable;



		double highRiskenable = 0;
		//activate with highRisk
		if(energyLeftToEnabled <=0){
			return;
		}else {
			double possibleHighRiskProduction = getPossibleProduction(highRisk);


			for (StorageElement ele : highRisk) {
				highRiskenable = highRiskenable + ele.setStatusAndSetEnergy(
						StorageElement.Mode.EMIT,
						ele.getPossibleProduction(energyRequiredForPowerplantBlackstart)/possibleHighRiskProduction * energyLeftToEnabled,
						energyRequiredForPowerplantBlackstart);
			}
		}

		System.out.println("energy left to enable = " + energyLeftToEnabled + " highrisk enable = "+ highRiskenable);
	}

	private double getPossibleProduction(ArrayList<StorageElement> list){
		double production = 0;
		for (StorageElement ele: list) {
			production += ele.getPossibleProduction(energyRequiredForPowerplantBlackstart);
		}
		return production;
	}
}