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

package ui.controller;

import classes.StorageElement;
import classes.*;
import ui.model.*;
import ui.model.DecoratedCable.CableState;
import ui.model.DecoratedSwitch.SwitchState;
import ui.model.Model.FairnessModel;
import ui.view.FlexiblePane;

import java.util.*;


/**
 * Controller for Simulation.
 *
 * @author Gruppe14
 */
public class SimulationManager {
	int global = 0;
	private Model model;
	private HashMap<Integer, DecoratedState> saves = new HashMap<Integer, DecoratedState>();
	private HashMap<Integer, VisualRepresentationalState> savesVisual = new HashMap<Integer, VisualRepresentationalState>();
	
	private HashMap<Integer, FlexManager> savesFlexManger = new HashMap<Integer, FlexManager>();
	private List<Flexibility> actualOrders = new ArrayList<Flexibility>();
	
	private int timeStep;
	private FlexiblePane flexPane;

	/**
	 * Constructor.
	 *
	 * @param m
	 *            Model
	 */
	public SimulationManager(Model m) {
		model = m;
	}
	
	
	
	
	
	
	/**
	 * calculates the flow of the edges and the supply for objects and consider old timesteps for burned cables.
	 *
	 * @param timestep
	 *            current Iteration
	 * @param updateVisual TODO
	 */
	public void calculateStateForTimeStep(int timestep, boolean updateVisual) {
		FlexManager newFlexManager = new FlexManager(model, timestep, savesFlexManger.getOrDefault(timestep-1, null));
		//Actual ordered not delete:
		FlexManager flexManagerFromActual = savesFlexManger.getOrDefault(timestep, null);
		if(flexManagerFromActual != null) {
			newFlexManager.orderFlexFromList(flexManagerFromActual.getAllFlexesOrderedThisTimeStep());
		}
		savesFlexManger.put(timestep, newFlexManager);
		
		
		
		
		HashMap<CpsEdge, CableState> map = new HashMap<CpsEdge, CableState>();
		if(timestep > 0 && saves.containsKey(timestep-1)) //if the state before exist
		{
			//make cable hastmap
			DecoratedState theStateBefore = saves.get(timestep-1);
			//edges without HolonObjects or burned
			for(DecoratedCable edge : theStateBefore.getLeftOverEdges())
			{
				map.put(edge.getModel(), edge.getState());
			}
		}
		timeStep = timestep;
		ArrayList<MinimumNetwork> list =  new ArrayList<MinimumNetwork>();
		MinimumModel minimumModel = new MinimumModel(model.getObjectsOnCanvas(), model.getEdgesOnCanvas());
		//set all BreakedManuel Cable Burned:
		for(IntermediateCableWithState cable : minimumModel.getEdgeList()) {
			if(cable.getModel().isBreakedManuel()) cable.setState(CableState.Burned);
		}
		
		//set all the state before:
		for(IntermediateCableWithState cable : minimumModel.getEdgeList()) {
			if(map.containsKey(cable.getModel())) cable.setState(map.get(cable.getModel()));
		}
		ArrayList<IntermediateCableWithState> leftOver = new ArrayList<IntermediateCableWithState>();
		boolean doAnotherLoop = true;
		while(doAnotherLoop) {
			doAnotherLoop = false;
			list = calculateNetworks(minimumModel, timestep, leftOver);
			for(MinimumNetwork net : list) {
				//if there is storage and it is needed turn it on//TODO:!!!
				if(!blackstartRunning() && !net.getStorageElementList().isEmpty()) {

                    StorageProductionController SPC = new StorageProductionController(net.getStorageElementList()); //TODO: unschoen
                    SPC.disableStorageDischarging(-1);

                    //calc consuption and production
                    float consumption = calculateConsumption(net);
                    float production = calculateProduction(net);
                    float difference = production - consumption;
                    System.out.println("Consumption " + consumption);
                    System.out.println("production " + production);
                    System.out.println("Difference " + difference);

                    if(difference > 0){
                        SPC.enableStorageCharging(difference);
                    }
                    if(difference < 0){
                        SPC.enableStorageDischarging(-difference);
                    }
                }

				float energyOnCables = net.getHolonObjectList()
						.stream()
						.filter(object -> object.getEnergyAtTimeStepWithFlex(timestep, newFlexManager) > 0.0f)
						.map(object -> object.getEnergyAtTimeStepWithFlex(timestep, newFlexManager))
						.reduce(0.0f, ((a,b) -> a + b));
				//calculation for storage
				net.getHolonObjectList()
						.stream()
						.flatMap(holonObject -> holonObject.getElements().stream())
						.map(ele -> {
							if (ele instanceof StorageElement) {
								return (StorageElement) ele;
							}else {
								return null;
							}
						})
						.filter(Objects::nonNull)
						.filter(ele -> (ele.getStatus().equals(StorageElement.Mode.EMIT)
								|| (ele.getStatus().equals(StorageElement.Mode.COLLECT))))
						.forEach(StorageElement::stateOfChargeCalculation);

				//find the cable with the energy supplied from his two connected objects are the biggest, from all cables that the network give more energy than the cablecapacity. 
				IntermediateCableWithState cable = net.getEdgeList().stream().filter(aCable -> energyOnCables > aCable.getModel().getCapacity() && !aCable.getModel().isUnlimitedCapacity()).max((lhs,rhs) -> Float.compare(lhs.getEnergyFromConnetedAtTimestep(timestep, newFlexManager), rhs.getEnergyFromConnetedAtTimestep(timestep, newFlexManager))).orElse(null);
				if(cable != null) {
					cable.setState(CableState.Burned);
					doAnotherLoop = true;
				}
			}
		}
		ArrayList<DecoratedNetwork> decorNetworks = new ArrayList<DecoratedNetwork>();
		FairnessModel actualFairnessModel = model.getFairnessModel();
		for (MinimumNetwork net : list) {
			decorNetworks.add(new DecoratedNetwork(net, timestep, actualFairnessModel, newFlexManager));
		}
		ArrayList<DecoratedCable> leftOverDecoratedCables = new ArrayList<DecoratedCable>();
		
		for(IntermediateCableWithState cable: leftOver) {
			leftOverDecoratedCables.add(new DecoratedCable(cable.getModel(), cable.getState(), 0.0f));
		}
		ArrayList<DecoratedSwitch> listOfDecoratedSwitches = decorateSwitches(minimumModel, timestep);
		DecoratedState stateFromThisTimestep = new DecoratedState(decorNetworks, leftOverDecoratedCables, listOfDecoratedSwitches, flexManagerFromActual, timestep);
		saves.put(timestep, stateFromThisTimestep);
		if(updateVisual)savesVisual.put(timestep, new VisualRepresentationalState(stateFromThisTimestep, minimumModel));
	}
	/** 
	 * Decorate a switch
	 * @param minModel
	 * @param iteration
	 * @return
	 */
	public static ArrayList<DecoratedSwitch> decorateSwitches(MinimumModel minModel, int iteration) {
		ArrayList<DecoratedSwitch> aListOfDecoratedSwitches = new ArrayList<DecoratedSwitch>(); 
		for(HolonSwitch hSwitch: minModel.getSwitchList()) {
			aListOfDecoratedSwitches.add(new DecoratedSwitch(hSwitch, hSwitch.getState(iteration) ? SwitchState.Closed : SwitchState.Open));
		}
		return aListOfDecoratedSwitches;
	}
	/**
	 * SubFunction to calculate the Networks from the model.
	 * @param minModel
	 * @param Iteration
	 * @param leftOver
	 * @return
	 */
	ArrayList<MinimumNetwork> calculateNetworks(MinimumModel minModel, int Iteration, ArrayList<IntermediateCableWithState> leftOver){
		//Copy minModel ObjectList
		ArrayList<HolonObject> holonObjectList = new ArrayList<HolonObject>();
		for(HolonObject holonObject: minModel.getHolonObjectList()) {
			holonObjectList.add(holonObject);
		}
		//Copy minModelEdgeList
		ArrayList<IntermediateCableWithState> edgeList = new ArrayList<IntermediateCableWithState>();
		for(IntermediateCableWithState cable: minModel.getEdgeList()) {
			edgeList.add(cable);
		}
		
		ArrayList<MinimumNetwork> listOfNetworks = new ArrayList<MinimumNetwork>();
		while(!holonObjectList.isEmpty()) {
			//lookAt the first holonObject and find his neighbors
			HolonObject lookAtObject = holonObjectList.get(0);
			//delete out of list
			holonObjectList.remove(0);
			//create a new Network
			MinimumNetwork actualNetwork = new MinimumNetwork(new ArrayList<HolonObject>(), new ArrayList<IntermediateCableWithState>());
			actualNetwork.getHolonObjectList().add(lookAtObject);
			//create List of neighbors
			LinkedList<AbstractCpsObject> neighbors = new LinkedList<AbstractCpsObject>();
			populateListOfNeighbors(edgeList, lookAtObject, actualNetwork, neighbors);
			while(!neighbors.isEmpty()) {
				AbstractCpsObject lookAtNeighbor = neighbors.getFirst();
				if(lookAtNeighbor instanceof HolonObject) {
					actualNetwork.getHolonObjectList().add((HolonObject) lookAtNeighbor);
					holonObjectList.remove(lookAtNeighbor);
				}
				//When HolonSwitch Check if closed
				if(!(lookAtNeighbor instanceof HolonSwitch) || ((HolonSwitch)lookAtNeighbor).getState(Iteration)) {
					populateListOfNeighbors(edgeList, lookAtNeighbor, actualNetwork, neighbors);
				}
				
				neighbors.removeFirst();
			}
			//add storages
            for (HolonObject holonObject : actualNetwork.getHolonObjectList()) {
                for (HolonElement ele : holonObject.getElements()) {
                    if(ele instanceof StorageElement){
                        actualNetwork.getStorageElementList().add((StorageElement) ele);
                    }
                }
            }

			listOfNetworks.add(actualNetwork);
		}	
		if(leftOver!= null) {
			leftOver.clear();
			for(IntermediateCableWithState cable: edgeList) {
				leftOver.add(cable);
			}
		}
		return listOfNetworks;
	}
	/**
	 * Adds the neighbors.
	 * @param edgeList
	 * @param lookAtObject
	 * @param actualNetwork
	 * @param neighbors
	 */
	void populateListOfNeighbors(ArrayList<IntermediateCableWithState> edgeList, AbstractCpsObject lookAtObject,
			MinimumNetwork actualNetwork, LinkedList<AbstractCpsObject> neighbors) {
		ListIterator<IntermediateCableWithState> iter = edgeList.listIterator();
		while(iter.hasNext())
		{
			IntermediateCableWithState lookAtEdge = iter.next();
			if(lookAtEdge.getState() == CableState.Working && lookAtEdge.getModel().isConnectedTo(lookAtObject)) {
				iter.remove();
				actualNetwork.getEdgeList().add(lookAtEdge);
				
				//Add neighbar
				AbstractCpsObject edgeNeighbor;
				if(lookAtEdge.getModel().getA().equals(lookAtObject)) {
					edgeNeighbor = lookAtEdge.getModel().getB();
					
				}else {
					edgeNeighbor = lookAtEdge.getModel().getA();
				}
				if(!neighbors.contains(edgeNeighbor)) {
					neighbors.add(edgeNeighbor);
				}
			}
		}
	}

	/**
	 * Get all Subnets.Not functional.
	 *
	 * @return all Subnets
	 */
	@Deprecated
	public ArrayList<SubNet> getSubNets() {
		return new ArrayList<SubNet>();
	}



	public FlexiblePane getFlexiblePane() {
		return flexPane;
	}

	void setFlexiblePane(FlexiblePane fp) {
		flexPane = fp;
	}

	
	public DecoratedState getActualDecorState() {
		return getDecorState(timeStep);
	}
	public VisualRepresentationalState getActualVisualRepresentationalState(){
		return savesVisual.getOrDefault(timeStep, null);
	}
	public FlexManager getActualFlexManager() {
		return savesFlexManger.getOrDefault(timeStep, null);
	}
	public void resetFlexManager(){
		savesFlexManger.clear();
	}
	public void resetFlexManagerForTimeStep(int timestep) {
		FlexManager newFlexManager = new FlexManager(model, timestep, savesFlexManger.getOrDefault(timestep-1, null));
		savesFlexManger.put(timestep, newFlexManager);
	}
	
	public DecoratedState getDecorState(int timestep) {
		return saves.getOrDefault(timestep, null);
	}
	public VisualRepresentationalState getVisualRepresentationalState(int timestep) {
		return savesVisual.getOrDefault(timestep, null);
	}

	////////////////////////////////////////TODO:comments

	public boolean blackstartRunning(){
        for (HolonElement ele : getPowerPlant().getElements()) {
            if (ele.getEleName().equals("Blackstart")) {
                if (ele.isActive()) {
                    return true;
                } else {
                    return false;
                }
            }
        }
        return false;
    }

    public HolonObject getPowerPlant() {
        for (AbstractCpsObject cps : model.getAllHolonObjectsOnCanvas()) {
            // geht nur wenn nur ein power plant vorhanden ist
            if (cps instanceof HolonObject) {
                if (cps.getObjName().equals("Power Plant")) {
                    return (HolonObject) cps;
                }
            }
        }
        return null;
    }

    public float calculateProduction(MinimumNetwork net){
	    float production = 0;
        for (HolonObject holonObject : net.getHolonObjectList()) {
            for(HolonElement holonElement : holonObject.getElements()){
                if(holonElement.isActive()){
                    if(holonElement.getEnergyAtTimeStep(model.getCurIteration()) > 0){
                        production = production + holonElement.getEnergyAtTimeStep(model.getCurIteration());
                    }
                }
            }
        }
        return production;
    }

    public float calculateConsumption(MinimumNetwork net){
        float consumption = 0;
        for (HolonObject holonObject : net.getHolonObjectList()) {
            for(HolonElement holonElement : holonObject.getElements()){
                if(holonElement.isActive()){
                    if(holonElement.getEnergyPerElement() < 0){
                        consumption = consumption - holonElement.getEnergyPerElement() * holonElement.getAmount();
                    }
                }
            }
        }
        return consumption;
    }

}