praktikum-holons/src/ui/controller/StorageProductionController.java

package ui.controller;

import classes.StorageElement;

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

public class StorageProductionController {
	private ArrayList<StorageElement> storages;

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

	public float currentPossibleStorageProduction() {
		float possibleEnergy = 0;
		for (StorageElement so : storages) {
			possibleEnergy += so.getPossibleProduction();
		}
		return possibleEnergy;
	}

	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 float energyNeeded) {
		Collections.sort(storages, Collections.reverseOrder());
		System.out.println("energy needed from storage" + energyNeeded);
        float energyLeftToEnabled = energyNeeded;


//        if(currentStorageProduction() < energyNeeded){//TODO: das if muss ich nochmal ueberdenken
//        	energyLeftToEnabled = energyNeeded - currentStorageProduction();
            //DONE?: Problem: es wird abgezogen weil ja schon emitter aber wir wolle das ja erhoehen...
        	for (StorageElement se: storages) {
//                if (se.getStatus().equals(StorageElement.Mode.STANDBY)
//                || se.getStatus().equals(StorageElement.Mode.COLLECT)
//				|| (se.getStatus().equals(StorageElement.Mode.EMIT)
//						&& se.getEnergyPerElement() < se.getMaxOutRatio()
//						&& se.getEnergyPerElement() < se.getStateOfCharge())) {
                    // TODO: eventuell nach entfernung sortieren
				if(!se.chargeDepleted()){
					energyLeftToEnabled = energyLeftToEnabled - se.setStatusAndSetEnergy(StorageElement.Mode.EMIT, energyLeftToEnabled);
				}
//                }

                if(energyLeftToEnabled <= 0){
                	System.out.println("enabled energy from storage");
                    return;
                }
            }
//        }else{
//            disableStorageProduction(energyNeeded - currentStorageProduction());
//        }
	}

	//TODO: redo algorithm to actually us it right...
	public void disableStorageDischarging(float energyNotNeeded) {
		if(energyNotNeeded == -1) {
			for (StorageElement se : storages) {
				se.setStatusAndSetEnergy(StorageElement.Mode.STANDBY, 0);
			}
		}
//		float disabledEnergy = 0;
//
//		//TODO: disable furthest first?
//		for (StorageElement se : storages) {
//			if (se.getStatus().equals(StorageElement.Mode.EMIT)) {
//				if(se.getEnergyPerElement() > energyNotNeeded){
//					disabledEnergy = disabledEnergy + energyNotNeeded;
//					se.setStatusAndSetEnergy(StorageElement.Mode.EMIT, se.getEnergyPerElement() - energyNotNeeded);
//				}else{
//					disabledEnergy = disabledEnergy + se.getEnergyPerElement();
//					se.setStatusAndSetEnergy(StorageElement.Mode.STANDBY, 0);
//				}
//			}
//			if (disabledEnergy >= energyNotNeeded) {
//				return;
//			}
//		}
	}

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