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

package ui.controller;

import classes.*;
import ui.model.Model;
import ui.view.FlexiblePane;
import ui.view.MyCanvas;

import java.util.ArrayList;
import java.util.HashMap;

/**
 * Controller for Simulation.
 *
 * @author Gruppe14
 */
public class SimulationManager {
    int global = 0;
    private Model model;
    private ArrayList<AbstractCpsObject> objectsToHandle;
    //	private ArrayList<CpsEdge> allConnections;
    private ArrayList<SubNet> subNets;
    private ArrayList<CpsEdge> brokenEdges;
    private MyCanvas canvas;
    private int timeStep;
    private HashMap<Integer, Float> tagTable = new HashMap<>();
    private FlexiblePane flexPane;

    /**
     * Constructor.
     *
     * @param m Model
     */
    SimulationManager(Model m) {
        canvas = null;
        model = m;
        subNets = new ArrayList<>();
        brokenEdges = new ArrayList<>();
    }

    /**
     * calculates the flow of the edges and the supply for objects.
     *
     * @param x current Iteration
     */
    void calculateStateForTimeStep(int x) {
        reset();
        timeStep = x;
        searchForSubNets();
        for (SubNet singleSubNet : subNets) {
            resetConnections(singleSubNet.getObjects().get(0), new ArrayList<>(), new ArrayList<>());
        }
        for (SubNet singleSubNet : subNets) {
            float production = calculateEnergy("prod", singleSubNet, timeStep);
            float consumption = calculateEnergy("cons", singleSubNet, timeStep);
            // wasted energy is computed by sum, since consumption is a negative value
            float wastedEnergy = production + consumption;

            float minConsumption = calculateMinimumEnergy(singleSubNet, timeStep);

            // --------------- use flexible devices ---------------
            // TODO: add global setting, whether the grid should react with flexible devices or whether it should not
            if (wastedEnergy > 0) {
                turnOnFlexibleDevices(singleSubNet, wastedEnergy);

                // recompute after having examined/turned on all flexible devices
                production = calculateEnergy("prod", singleSubNet, timeStep);
                consumption = calculateEnergy("cons", singleSubNet, timeStep);
                wastedEnergy = production + consumption;
            }

            // --------------- set flow simulation ---------------
            setFlowSimulation(singleSubNet);

            // --------------- visualise graph ---------------
            for (HolonObject hl : singleSubNet.getObjects()) {
                if (hl.getState() != HolonObject.NO_ENERGY
                        && hl.getState() != HolonObject.PRODUCER) {
                    for (int i = 0; i < hl.getConnections().size(); i++) {
                        CpsEdge edge = hl.getConnectedTo().get(i);
                        if (edge.isWorking() && edge.getFlow() > 0
                                || edge.getCapacity() == CpsEdge.CAPACITY_INFINITE) {
                            if ((production + consumption) >= 0) {
                                if (wastedEnergy > 0) {
                                    hl.setState(HolonObject.OVER_SUPPLIED);
                                } else {
                                    hl.setState(HolonObject.SUPPLIED);
                                }
                            } else {
                                if ((production + minConsumption) >= 0) {
                                    hl.setState(HolonObject.PARTIALLY_SUPPLIED);
                                } else if (hl.checkIfPartiallySupplied(timeStep)) {
                                    hl.setState(HolonObject.PARTIALLY_SUPPLIED);
                                } else {
                                    hl.setState(HolonObject.NOT_SUPPLIED);
                                }
                            }
                            break;
                        }
                    }
                    if (hl.checkIfPartiallySupplied(timeStep)
                            && hl.getState() != HolonObject.SUPPLIED
                            && hl.getState() != HolonObject.OVER_SUPPLIED) {
                        hl.setState(HolonObject.PARTIALLY_SUPPLIED);
                    }
                }
            }
        }
        canvas.repaint();
        flexPane.recalculate();
    }

    /**
     * search for all flexible devices in the network and turn them on, until wasted energy = 0
     * or all devices have been examined
     *
     * @param subNet       the subnet
     * @param wastedEnergy the currently wasted energy
     */
    private void turnOnFlexibleDevices(SubNet subNet, float wastedEnergy) {
        for (HolonObject holonOb : subNet.getObjects()) {
            for (HolonElement holonEl : holonOb.getElements()) {
                // if this element is flexible
                float energyOfElement = holonEl.getEnergy();
                if (holonEl.isFlexible() && energyOfElement < 0) {
//                    if (energyOfElement <= wastedEnergy) {
//                        holonEl.setActive(true);
//                        wastedEnergy += energyOfElement;
//                    }else{
//                    }

//                    System.out.println("el.getEnergy(): " + holonEl.getEnergy());
//                    System.out.println("wasted: " + wastedEnergy);
                }
            }
        }
//        System.out.println();
    }

    /**
     * Set Flow Simulation.
     *
     * @param sN Subnet
     */
    private void setFlowSimulation(SubNet sN) {
        ArrayList<AbstractCpsObject> producers = new ArrayList<>();
        AbstractCpsObject tmp = null;
        tagTable = new HashMap<>();
        // traverse all objects in this subnet
        for (HolonObject hl : sN.getObjects()) {
            float energy = hl.getCurrentEnergyAtTimeStep(timeStep);
            // if their production is higher than their consumption
            if (energy > 0) {
                tagTable.put(hl.getId(), energy);
                hl.addTag(hl.getId());
                for (CpsEdge edge : hl.getConnections()) {
                    if (edge.isWorking()) {
                        // set other end of edge as tmp-object
                        // and add this end to the other end's tag-list
                        AbstractCpsObject a = edge.getA();
                        AbstractCpsObject b = edge.getB();
                        if (a.getId() == hl.getId()) {
                            b.addTag(hl.getId());
                            tmp = b;
                        }
                        if (b.getId() == hl.getId()) {
                            a.addTag(hl.getId());
                            tmp = a;
                        }

                        edge.setFlow(edge.getFlow() + energy);
                        edge.calculateState();
                        edge.addTag(hl.getId());
                        if (edge.isWorking() && !producers.contains(tmp)) {
                            if (tmp instanceof HolonSwitch) {
                                if (((HolonSwitch) tmp).getState(timeStep)) {
                                    producers.add(tmp);
                                }
                            } else if (!(tmp instanceof CpsUpperNode)) {
                                producers.add(tmp);
                            }
                        }
                    }
                }
            }
        }
        setFlowSimRec(producers, 0);
    }

    /**
     * Set Flow Simulation Rec.
     *
     * @param nodes the nodes
     * @param iter  the Iteration
     */
    private void setFlowSimRec(ArrayList<AbstractCpsObject> nodes, int iter) {
        ArrayList<AbstractCpsObject> newNodes = new ArrayList<>();
        ArrayList<CpsEdge> changedEdges = new ArrayList<>();
        AbstractCpsObject tmp;
        if (nodes.size() != 0) {
            for (AbstractCpsObject cps : nodes) {
                // check whether the cps is in a legit state if it is a switch
                if (legitState(cps)) {
                    for (CpsEdge edge : cps.getConnections()) {
                        // is edge working
                        // and does the edge's tag-list not (yet) contain all tags of the cps
                        if (edge.isWorking()
                                && (!(edge.containsTags(edge.getTags(), cps.getTag())))) {
                            if (edge.getA().getId() == cps.getId()) {
                                tmp = edge.getB();
                            } else {
                                tmp = edge.getA();
                            }
                            for (Integer tag : cps.getTag()) {
                                if (!(edge.getTags().contains(tag))
                                        && !(edge.getPseudoTags().contains(tag))) {
                                    edge.setFlow(edge.getFlow() + tagTable.get(tag));
                                    edge.addTag(tag);
                                }
                            }
                            // uppernodes do not spread energy
                            if (!(tmp instanceof CpsUpperNode)) {
                                for (Integer tag : tmp.getTag()) {
                                    if (!(edge.getTags().contains(tag))
                                            && tagTable.get(tag) != null
                                            && !(edge.getPseudoTags().contains(tag))) {
                                        edge.setFlow(edge.getFlow() + tagTable.get(tag));
                                        edge.addPseudoTag(tag);
                                        changedEdges.add(edge);
                                    }
                                }
                            }
                            edge.calculateState();
                            if (edge.isWorking()
                                    && !(tmp instanceof CpsUpperNode)) {
                                tmp.addAllPseudoTags(cps.getTag());
                                if (!newNodes.contains(tmp)) {
                                    newNodes.add(tmp);
                                }
                            }
                        }
                    }
                }
            }
            setPseudoTags(newNodes, changedEdges);
            setFlowSimRec(newNodes, iter + 1);
        }
    }

    /**
     * Set the Pseudo Tags.
     *
     * @param nodes Array of AbstractCpsObjects
     */
    private void setPseudoTags(ArrayList<AbstractCpsObject> nodes, ArrayList<CpsEdge> edges) {
        for (AbstractCpsObject node : nodes) {
            node.recalculateTags();
            node.setPseudoTags(new ArrayList<>());
        }
        for (CpsEdge edge : edges) {
            edge.recalculateTags();
            edge.setPseudoTag(new ArrayList<>());
        }
    }

    /**
     * Reset the Connection.
     *
     * @param cps          CpsObject
     * @param visitedObj   the visited Objects
     * @param visitedEdges the visited Edges
     */
    private void resetConnections(AbstractCpsObject cps, ArrayList<Integer> visitedObj,
                                  ArrayList<CpsEdge> visitedEdges) {
        visitedObj.add(cps.getId());
        cps.resetTags();
        for (CpsEdge e : cps.getConnections()) {
            if (!(visitedEdges.contains(e))) {
                e.setFlow(0);
                e.calculateState();
                e.setTags(new ArrayList<>());
                visitedEdges.add(e);
                if (!(visitedObj.contains(e.getA().getId()))) {
                    resetConnections(e.getA(), visitedObj, visitedEdges);
                    e.getA().resetTags();
                }
                if (!(visitedObj.contains(e.getB().getId()))) {
                    resetConnections(e.getB(), visitedObj, visitedEdges);
                    e.getB().resetTags();
                }
            }
        }
    }

    /**
     * calculates the energy of either all producers or consumers.
     *
     * @param type Type
     * @param sN   Subnet
     * @param x    Integer
     * @return The Energy
     */
    private float calculateEnergy(String type, SubNet sN, int x) {
        float energy = 0;
        for (HolonObject hl : sN.getObjects()) {
            if (type.equals("prod")) {
                if (hl.getCurrentEnergyAtTimeStep(x) > 0) {
                    energy = energy + hl.getCurrentEnergyAtTimeStep(x);
                    hl.setState(HolonObject.PRODUCER);
                }
            }
            if (type.equals("cons")) {
                if (hl.getCurrentEnergyAtTimeStep(x) < 0) {
                    energy = energy + hl.getCurrentEnergyAtTimeStep(x);
                    hl.setState(HolonObject.NOT_SUPPLIED);
                }
            }
            if (hl.getCurrentEnergyAtTimeStep(x) == 0) {
                hl.setState(HolonObject.NO_ENERGY);
            }
        }
        return energy;
    }

    /**
     * Calculate the Minimum Energy.
     *
     * @param sN Subnet
     * @param x  Integer
     * @return the Calculated minimum Energy
     */
    private float calculateMinimumEnergy(SubNet sN, int x) {
        float min = 0;
        float minElement = 0;
        for (HolonObject hl : sN.getObjects()) {
            if (hl.getElements().size() > 0 && hl.getElements().get(0).getTotalEnergyAtTimeStep(x) < 0) {
                minElement = hl.getElements().get(0).getTotalEnergyAtTimeStep(x);
            }
            for (HolonElement he : hl.getElements()) {
                if (minElement < he.getTotalEnergyAtTimeStep(x) && he.getTotalEnergyAtTimeStep(x) < 0) {
                    minElement = he.getTotalEnergyAtTimeStep(x);
                }
            }
            min = min + minElement;
        }
        return min;
    }

    /**
     * generates all subNets from all objectsToHandle.
     */
    private void searchForSubNets() {
        subNets = new ArrayList<>();
        brokenEdges.clear();
        boolean end = false;
        int i = 0;
        AbstractCpsObject cps;
        if (objectsToHandle.size() > 0) {
            while (!end) {
                cps = objectsToHandle.get(i);
                SubNet singleSubNet = new SubNet(new ArrayList<>(), new ArrayList<>(),
                        new ArrayList<>());
                singleSubNet = buildSubNet(cps, new ArrayList<>(), singleSubNet);
                if (singleSubNet.getObjects().size() != 0) {
                    subNets.add(singleSubNet);
                }
                if (0 == objectsToHandle.size()) {
                    end = true;
                }
            }
        }
    }

    /**
     * recursivly generates a subnet of all objects, that one specific object is
     * connected to.
     *
     * @param cps     AbstractCpsObject
     * @param visited visited Array of Integer
     * @param sN      Subnets
     * @return Subnet
     */
    private SubNet buildSubNet(AbstractCpsObject cps, ArrayList<Integer> visited, SubNet sN) {
        visited.add(cps.getId());
        if (cps instanceof HolonObject) {
            sN.getObjects().add((HolonObject) cps);
        }
        if (cps instanceof HolonSwitch) {
            sN.getSwitches().add((HolonSwitch) cps);
        }
        removeFromToHandle(cps.getId());
        AbstractCpsObject a;
        AbstractCpsObject b;
        for (CpsEdge edge : cps.getConnections()) {
            if (edge.isWorking()) {
                a = edge.getA();
                b = edge.getB();
                if (!(cps instanceof HolonSwitch)) {
                    if (!(sN.getEdges().contains(edge))) {
                        sN.getEdges().add(edge);
                    }
                }
                if (cps instanceof HolonSwitch && ((HolonSwitch) cps).getState(timeStep)) {
                    if (!(sN.getEdges().contains(edge))) {
                        sN.getEdges().add(edge);
                    }
                }
                if (!visited.contains(a.getId()) && legitState(cps) && !(a instanceof CpsUpperNode)) {
                    sN = buildSubNet(a, visited, sN);
                }
                if (!visited.contains(b.getId()) && legitState(cps) && !(b instanceof CpsUpperNode)) {
                    sN = buildSubNet(b, visited, sN);
                }
                if (a instanceof CpsUpperNode && a.getId() != cps.getId()) {
                    edge.setConnected(CpsEdge.CON_UPPER_NODE_NOT_INSIDE);
                    checkForConnectedStates(b, (CpsUpperNode) a, edge);
                }
                if (b instanceof CpsUpperNode && b.getId() != cps.getId()) {
                    edge.setConnected(CpsEdge.CON_UPPER_NODE_NOT_INSIDE);
                    checkForConnectedStates(a, (CpsUpperNode) b, edge);
                }
            } else {
                brokenEdges.add(edge);
            }
        }
        return sN;
    }

    /**
     * is the Switch in a legitimate State.
     *
     * @param current AbstractCpsObject
     * @return boolean
     */
    private boolean legitState(AbstractCpsObject current) {
        return !(current instanceof HolonSwitch)
                || ((HolonSwitch) current).getState(timeStep);
    }

//    /**
//     * ensures that objectsToHandle only contains HolonObjects.
//     */
//	public void cleanObjectsToHandle() {
//		for (int i = 0; i < objectsToHandle.size(); i++) {
//			if (!(objectsToHandle.get(i) instanceof HolonObject)) {
//				objectsToHandle.remove(i);
//			}
//		}
//	}

    /**
     * removes an Object that already has been handled.
     *
     * @param id the Object ID
     */
    private void removeFromToHandle(int id) {
        for (int i = 0; i < objectsToHandle.size(); i++) {
            if (objectsToHandle.get(i).getId() == id) {
                objectsToHandle.remove(i);
            }
        }
    }

    /**
     * copies the data of an array of Objects.
     *
     * @param toCopy the ArrayList of CpsObjects co Copy
     */
    private void copyObjects(ArrayList<AbstractCpsObject> toCopy) {
        for (AbstractCpsObject cps : toCopy) {
            if (cps instanceof CpsUpperNode) {
                copyObjects(((CpsUpperNode) cps).getNodes());
            } else {
                objectsToHandle.add(cps);
            }
        }
    }

    /**
     * Prints the Components auf all subnets.
     */
    private void printNetsToConsole() {
        for (int i = 0; i < subNets.size(); i++) {
            SubNet subNet = subNets.get(i);
            System.out.println("SUBNET NR:" + i);
            printSingleNetToConsole(subNet);
        }
    }

    private void printSingleNetToConsole(SubNet subNet) {
        System.out.println("  Objects:");
        for (int j = 0; j < subNet.getObjects().size(); j++) {
            HolonObject hl = subNet.getObjects().get(j);
            System.out.println("    " + hl.getName() + " " + hl.getId());
        }
        System.out.println("  Edges:");
        for (int j = 0; j < subNet.getEdges().size(); j++) {
            CpsEdge edge = subNet.getEdges().get(j);
            System.out.println("     " + edge.getA().getName() + " connected To " + edge.getB().getName());
        }
        System.out.println("  Switches:");
        for (int j = 0; j < subNet.getSwitches().size(); j++) {
            HolonSwitch sw = subNet.getSwitches().get(j);
            System.out.println("    " + sw.getName() + " " + sw.getId() + " State:" + sw.getActiveAt()[timeStep]);
        }
    }

    /**
     * Set the Canvas.
     *
     * @param can the Canvas
     */
    public void setCanvas(MyCanvas can) {
        canvas = can;
    }

    /**
     * Reset all Data to the current state of the Model.
     */
    public void reset() {
        objectsToHandle = new ArrayList<>();
        copyObjects(model.getObjectsOnCanvas());
    }

    /**
     * Resets the State of all Edges
     */
    private void resetEdges() {
        for (CpsEdge e : brokenEdges) {
            e.setWorkingState(true);
        }
    }

    /**
     * Resets the State for the whole Simulation Model
     */
    void resetSimulation() {
        reset();
        resetEdges();
    }

    /**
     * Get all Subnets.
     *
     * @return all Subnets
     */
    public ArrayList<SubNet> getSubNets() {
        return subNets;
    }

    /**
     * Get broken Edges
     */
//    public ArrayList<CpsEdge> getBrokenEdges() {
//        return brokenEdges;
//    }

    /**
     * checks whether a given object is connected to an object inside the upperNode.
     * if yes, the state for the edge is changed in "connected" or "not connected"
     */
    private void checkForConnectedStates(AbstractCpsObject cps, CpsUpperNode cUNode, CpsEdge theEdge) {
        AbstractCpsObject tmp;
        for (CpsEdge edge : cps.getConnections()) {
            if (edge.getA().getId() == cps.getId()) {
                tmp = edge.getB();
            } else {
                tmp = edge.getA();
            }
            if (cUNode.getNodes().contains(tmp)) {
                if (tmp instanceof CpsUpperNode) {
                    checkForConnectedStates(cps, (CpsUpperNode) tmp, theEdge);
                } else {
                    theEdge.setConnected(CpsEdge.CON_UPPER_NODE_AND_INSIDE);
                    break;
                }
            }
        }
    }

    public FlexiblePane getFlexiblePane() {
        return flexPane;
    }

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

}