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

package ui.controller;

import java.awt.Color;
import java.awt.Point;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.zip.ZipException;

import org.apache.commons.compress.archivers.ArchiveException;

import com.google.gson.JsonParseException;

import api.CpsAlgorithm;
import classes.AbstractCpsObject;
import classes.Category;
import classes.CpsEdge;
import classes.CpsNode;
import classes.CpsUpperNode;
import classes.HolonElement;
import classes.HolonObject;
import interfaces.CategoryListener;
import ui.model.Model;
import ui.view.FlexiblePane;
import ui.view.MyCanvas;
import ui.view.StatisticGraphPanel;

/**
 * The Class represents the controller in the model, controller view Pattern.
 * 
 * @author Gruppe14
 *
 */
public class Control {

	private Model model;

	private final ConsoleController consoleController;
	private final MultiPurposeController multiPurposeController;
	private final CategoryController categoryController;
	private final ObjectController objectController;
	private final CanvasController canvasController;
	private final GlobalController globalController;
	private final SaveController saveController;
	private final LoadController loadController;
	private final AutoSaveController autoSaveController;
	private SimulationManager simulationManager;
	private final StatsController statsController;
	private final NodeController nodeController;
	private final ClipboardController clipboardController;
	private final HolonCanvasController holonCanvasController;
	private String autosaveDir = "";
	private String categoryDir = "";
	private int rand;

	/**
	 * Constructor.
	 * 
	 * @param model
	 *            the Model
	 */
	public Control(Model model) {
		this.model = model;

		this.multiPurposeController = new MultiPurposeController(model);
		this.categoryController = new CategoryController(model, multiPurposeController);
		this.objectController = new ObjectController(model, multiPurposeController);
		this.canvasController = new CanvasController(model, multiPurposeController);
		this.globalController = new GlobalController(model);
		this.saveController = new SaveController(model);
		this.nodeController = new NodeController(model, canvasController, multiPurposeController);
		this.loadController = new LoadController(model, categoryController, canvasController, objectController,
				nodeController, multiPurposeController);
		this.simulationManager = new SimulationManager(model);
		this.autoSaveController = new AutoSaveController(model);
		this.consoleController = new ConsoleController(model);
		this.statsController = new StatsController(model);
		this.clipboardController = new ClipboardController(model, saveController, loadController, canvasController,
				objectController, nodeController, multiPurposeController);
		this.holonCanvasController = new HolonCanvasController(model);

		autosaveDir = System.getProperty("user.home") + "/.config/HolonGUI/Autosave/";
		categoryDir = System.getProperty("user.home") + "/.config/HolonGUI/Category/";
		File autoSave = new File(autosaveDir);
		File category = new File(categoryDir);
		// deleteDirectory(dest);
		autoSave.mkdirs();
		category.mkdirs();
		createAutoRandom();
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * Generate random number, so that every instance of the program has unique
	 * save files
	 */
	private void createAutoRandom() {
		rand = (int) (Math.random() * 1000);
		while (new File(autosaveDir + rand + (autoSaveController.getAutoSaveNr())).exists()) {
			rand = (int) Math.random() * 1000;
		}
	}

	/**
	 * Delete a Directory.
	 * 
	 * @param path
	 *            to delete
	 */
	public void deleteDirectory(File path) {
		if (path.exists()) {
			File[] files = path.listFiles();
			for (int i = 0; i < files.length; i++) {
				if (files[i].isDirectory()) {
					deleteDirectory(files[i]);
				} else {
					if (files[i].getName().contains("" + rand))
						files[i].delete();
				}
			}
			// path.delete();
		}
	}

	/* Operations for searching */

	/**
	 * Search for Object by ID.
	 * 
	 * @param id
	 *            the id of the Object
	 * @return the CpsObject
	 */
	public AbstractCpsObject searchByID(int id) {
		return multiPurposeController.searchByID(id);
	}

	/**
	 * Search for Object by ID in upperNode
	 * 
	 * @param id
	 *            the id of the Object
	 * @return the CpsObject
	 */
	public AbstractCpsObject searchByIDUpperNode(int id, CpsUpperNode upperNode) {
		return multiPurposeController.searchByIDUpperNode(id, upperNode);
	}

	public AbstractCpsObject searchTracked(int id) {
		return multiPurposeController.searchByID(id);
	}

	/**
	 * Search for Object in a Category.
	 * 
	 * @param category
	 *            name of the Category
	 * @param object
	 *            Name of the Object
	 * @return The Object
	 */
	public AbstractCpsObject searchCategoryObject(String category, String object) {
		return multiPurposeController.searchCatObj(multiPurposeController.searchCat(category), object);
	}

	/**
	 * search for category.
	 * 
	 * @param cat
	 *            name of the Category
	 * @return the Category
	 */
	public Category searchCategory(String cat) {
		return multiPurposeController.searchCat(cat);
	}

	/* Operations for Categories and Objects */

	/**
	 * init default category and objects.
	 * 
	 * @throws IOException
	 */
	public void resetCategorys() throws IOException {
		categoryController.initCategories();
		objectController.initHolonElements();
		saveCategory();
	}

	/**
	 * Adds New Category into Model.
	 * 
	 * @param cat
	 *            name of the new Category
	 * @throws IOException
	 */
	public void addCategory(String cat) throws IOException {
		categoryController.addNewCategory(cat);
		saveCategory();
	}

	/**
	 * Add new Holon Object to a Category.
	 * 
	 * @param cat
	 *            Category
	 * @param obj
	 *            New Object Name
	 * @param ele
	 *            Array of Elements
	 * @param img
	 *            the image Path
	 * @throws IOException
	 */
	public void addObject(Category cat, String obj, ArrayList<HolonElement> ele, String img) throws IOException {
		categoryController.addNewHolonObject(cat, obj, ele, img);
		saveCategory();
	}

	/**
	 * Add new Holon Transformer to a Category.
	 * 
	 * @param cat
	 *            Category
	 * @param obj
	 *            New Object Name
	 */
	public void addTransformer(Category cat, String obj) {
		categoryController.addNewHolonTransformer(cat, obj, "/Images/transformer-1.png");
	}

	/**
	 * Add new Holon Switch to a Category.
	 * 
	 * @param cat
	 *            Category
	 * @param obj
	 *            New Object Name
	 * @throws IOException
	 */
	public void addSwitch(Category cat, String obj) throws IOException {
		categoryController.addNewHolonSwitch(cat, obj, "/Images/switch-on.png");
		saveCategory();
	}

	/**
	 * delete a given Category.
	 * 
	 * @param cat
	 *            the Category
	 * @throws IOException
	 */
	public void deleteCategory(String cat) throws IOException {
		categoryController.deleteCategory(cat);
		saveCategory();
	}

	/**
	 * Delete an Object from a Category.
	 * 
	 * @param cat
	 *            the Category
	 * @param obj
	 *            the Object
	 * @throws IOException
	 */
	public void delObjectCategory(String cat, String obj) throws IOException {
		categoryController.deleteObject(cat, obj);
		saveCategory();
	}

	/**
	 * deletes a selectedObject.
	 * 
	 * @param obj
	 *            Cpsobject
	 */
	public void deleteSelectedObject(AbstractCpsObject obj) {
		objectController.deleteSelectedObject(obj);
	}

	/**
	 * add an Object to selectedObject.
	 * 
	 * @param obj
	 *            AbstractCpsobject
	 */
	public void addSelectedObject(AbstractCpsObject obj) {
		objectController.addSelectedObject(obj);
	}

	/* Operations for Canvas */

	/**
	 * Add an edge to the Canvas.
	 * 
	 * @param edge
	 *            the edge
	 */
	public void addEdgeOnCanvas(CpsEdge edge) {
		canvasController.addEdgeOnCanvas(edge);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * Removes an Edge from the Canvas.
	 * 
	 * @param edge
	 *            the edge to remove
	 */
	public void removeEdgesOnCanvas(CpsEdge edge) {
		canvasController.removeEdgesOnCanvas(edge);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * Set the selected Edge.
	 * 
	 * @param edge
	 *            that is selected
	 */
	public void setSelecteEdge(CpsEdge edge) {
		model.setSelectedEdge(edge);
	}

	/**
	 * Add a new Object.
	 * 
	 * @param object
	 *            the Object
	 */
	public void addObjectCanvas(AbstractCpsObject object) {
		canvasController.addNewObject(object);
		simulationManager.calculateStateForTimeStep(model.getCurIteration());
		if (!(object instanceof CpsNode)) {
			try {
				autoSave();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	/**
	 * Returns the ID of the selected Object 0 = no Object is selected.
	 * 
	 * @param id
	 *            the ID of the selected Object
	 */
	public void setSelectedObjectID(int id) {
		objectController.setSelectedObjectID(id);
	}

	/**
	 * Deletes an CpsObject on the Canvas and its connections.
	 * 
	 * @param obj
	 *            AbstractCpsObject
	 * @param save
	 */
	public void delCanvasObject(AbstractCpsObject obj, boolean save) {
		canvasController.deleteObjectOnCanvas(obj);
		calculateStateForCurrentTimeStep();
		model.getTrackingObj().remove(obj);
		if (obj instanceof CpsUpperNode)
			canvasController.bfsNodeCleaner((CpsUpperNode) obj);
		if (save)
			try {
				autoSave();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}

	/* Operations for Objects and Elements */

	/**
	 * Add a new Element into a Object on the Canvas.
	 * 
	 * @param id
	 *            the Object ID
	 * @param ele
	 *            the Name of the Element
	 * @param amount
	 *            the Amount
	 * @param energy
	 *            the Energy
	 */
	public void addElementCanvasObject(int id, String ele, int amount, float energy) {
		objectController.addNewElementIntoCanvasObject(id, ele, amount, energy);
	}

	/**
	 * Add a new Element into a Object in Category.
	 * 
	 * @param catName
	 *            the Category
	 * @param objName
	 *            the Object
	 * @param eleName
	 *            the Element Name
	 * @param amount
	 *            the amount
	 * @param energy
	 *            the Energy
	 */
	public void addElementCategoryObject(String catName, String objName, String eleName, int amount, float energy) {
		objectController.addNewElementIntoCategoryObject(catName, objName, eleName, amount, energy);
	}

	/**
	 * deletes a Element from a given Canvas Object.
	 * 
	 * @param id
	 *            the ID
	 * @param elementid
	 *            the Element ID
	 */
	public void deleteElementCanvas(int id, int elementid) {
		objectController.deleteElementInCanvas(id, elementid);
	}

	/* Global Operations */

	/**
	 * Add a SubNetColor.
	 * 
	 * @param c
	 *            the Color
	 */
	public void addSubNetColor(Color c) {
		globalController.addSubNetColor(c);
	}

	/**
	 * Returns SCALE.
	 * 
	 * @return SCALE
	 */
	public int getScale() {
		return globalController.getScale();
	}

	/**
	 * Returns SCALE Divided by 2.
	 * 
	 * @return SCALE Divided by 2
	 */
	public int getScaleDiv2() {
		return globalController.getScaleDiv2();
	}

	/**
	 * Changes the value of SCALE and SCALEDIV2.
	 * 
	 * @param s
	 *            Scale
	 */
	public void setScale(int s) {
		globalController.setScale(s);
	}

	/**
	 * sets the current Iteration.
	 * 
	 * @param curit
	 *            the current Iteration
	 */
	public void setCurIteration(int curit) {
		globalController.setCurIteration(curit);
	}

	/**
	 * Writes the current State of the Modelling into a JSON File which can be
	 * loaded.
	 * 
	 * @param path
	 *            the Path
	 * 
	 * @throws IOException
	 *             exception
	 */
	public void saveFile(String path) throws IOException, ArchiveException {
		saveController.writeSave(path);
	}

	/**
	 * Reads the the Save File and load the state into the Model.
	 * 
	 * @param path
	 *            the Path
	 * @throws IOException
	 *             exception
	 * @throws ArchiveException
	 */
	public void loadFile(String path) throws IOException, ArchiveException, ZipException {
		loadController.readSave(path);
		saveCategory();
		autoSave();
	}

	/**
	 * Reads the Json File from Autosave
	 * 
	 * @param path
	 * @throws IOException
	 */
	public void loadAutoSave(String path) throws IOException {
		loadController.readJson(path);
	}

	/**
	 * Init the CategoryListener.
	 * 
	 * @param catLis
	 *            the CategoryListener
	 */
	public void initListener(CategoryListener catLis) {
		categoryController.addCategoryListener(catLis);
	}

	/**
	 * calculates the flow of the edges and the supply for objects for the
	 * current Timestep.
	 */
	public void calculateStateForCurrentTimeStep() {
		// simulationManager.reset();
		simulationManager.calculateStateForTimeStep(model.getCurIteration());
	}

	/**
	 * calculates the flow of the edges and the supply for objects.
	 * 
	 * @param x
	 *            current Iteration
	 */
	public void calculateStateForTimeStep(int x) {
		// simulationManager.reset();
		simulationManager.calculateStateForTimeStep(x);
	}

	/**
	 * resets the whole State of the simulation including a reset of all Edges
	 * to the default "is working" state
	 */
	public void resetSimulation() {
		setIsSimRunning(false);
		simulationManager.resetSimulation();
	}

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

	/**
	 * make an autosave.
	 * 
	 * @throws IOException
	 *             Exception
	 */
	public void autoSave() throws IOException {
		autoSaveController.increaseAutoSaveNr();
		saveController.writeAutosave(autosaveDir + rand + autoSaveController.getAutoSaveNr());
		if (autoSaveController.allowed()) {
			new File(autosaveDir + rand + (autoSaveController.getAutoSaveNr() - globalController.getNumbersOfSaves()))
					.delete();
		}
	}

	public void saveCategory() throws IOException {
		saveController.writeCategory(categoryDir + "Category.json");
	}

	/**
	 * Returns the undo save.
	 * 
	 * @return the undo save
	 */
	public String getUndoSave() {
		autoSaveController.decreaseAutoSaveNr();
		if (!new File(autosaveDir + rand + (autoSaveController.getAutoSaveNr())).exists()) {
			autoSaveController.increaseAutoSaveNr();
		}
		return autosaveDir + rand + (autoSaveController.getAutoSaveNr());
	}

	/**
	 * Returns the redo save.
	 * 
	 * @return the redo save
	 */
	public String getRedoSave() {
		autoSaveController.increaseAutoSaveNr();
		if (!new File(autosaveDir + rand + (autoSaveController.getAutoSaveNr())).exists()) {
			autoSaveController.decreaseAutoSaveNr();
		}
		return autosaveDir + rand + (autoSaveController.getAutoSaveNr());
	}

	/**
	 * Getter for Model.
	 * 
	 * @return the Model
	 */
	public Model getModel() {
		return model;
	}

	/**
	 * get the Simulation Manager.
	 * 
	 * @return the Simulation Manager
	 */
	public SimulationManager getSimManager() {
		return simulationManager;
	}

	/**
	 * Getter for selected CpsObject.
	 *
	 * @param text
	 *            String the Text
	 * @param color
	 *            the color of the Text
	 * @param p
	 *            size of the Text
	 * @param bold
	 *            bold or not
	 * @param italic
	 *            italic or not
	 * @param nl
	 *            new line or not
	 * 
	 */
	public void addTextToConsole(String text, Color color, int p, boolean bold, boolean italic, boolean nl) {
		consoleController.addTextToConsole(text, color, p, bold, italic, nl);
	}

	/**
	 * Print Text on the console in black and font size 12.
	 *
	 * @param text
	 *            String the Text
	 */
	public void addTextToConsole(String text) {
		consoleController.addTextToConsole(text);
	}

	/**
	 * Clears the console.
	 */
	public void clearConsole() {
		consoleController.clearConsole();
	}

	/**
	 * Set the timerSpeed.
	 * 
	 * @param t
	 *            interval in ms
	 */
	public void setTimerSpeed(int t) {
		globalController.setTimerSpeed(t);
	}

	/**
	 * Set the Canvas X Size.
	 * 
	 * @param canvasX
	 *            the cANVAS_X to set
	 */
	public void setCanvasX(int canvasX) {
		globalController.setCanvasX(canvasX);
	}

	/**
	 * Set the Canvas Y Size.
	 * 
	 * @param canvasY
	 *            the cANVAS_Y to set
	 */
	public void setCanvasY(int canvasY) {
		globalController.setCanvasY(canvasY);
	}

	public void setMaxCapacity(float cap) {
		globalController.setMaxCapacity(cap);
	}

	/**
	 * Set the Algorithm.
	 * 
	 * @param obj
	 *            the Algorithm
	 */
	public void setAlgorithm(Object obj) {
		multiPurposeController.setAlgorithm(obj);
	}

	/**
	 * Run the Algorithm.
	 */
	public void runAlgorithm(Model model, Control controller) {
		if (model.getAlgorithm() != null) {
			((CpsAlgorithm) model.getAlgorithm()).runAlgorithm(model, controller);
		}
	}

	// ========================= MANAGING TRACKED OBJECTS ====================

	public void setTrackingObj(ArrayList<AbstractCpsObject> objArr) {
		statsController.setTrackingObj(objArr);
	}

	public ArrayList<AbstractCpsObject> getTrackingObj() {
		return statsController.getTrackingObj();
	}

	public void addTrackingObj(AbstractCpsObject obj) {
		statsController.addTrackingObj(obj);
	}

	public void removeTrackingObj(AbstractCpsObject obj) {
		statsController.removeTrackingObj(obj);
	}

	// ========================== MANAGING TRACKED OBJECTS END ================

	/**
	 * Controlling Nodes of Nodes
	 */

	public void addUpperNode(String nodeName, CpsUpperNode upperNode, ArrayList<AbstractCpsObject> toGroup) {
		nodeController.doUpperNode(nodeName, upperNode, toGroup);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void delUpperNode(CpsUpperNode node, CpsUpperNode upperNode) {
		nodeController.undoUpperNode(node, upperNode);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void addObjUpperNode(AbstractCpsObject object, CpsUpperNode upperNode) {
		nodeController.addObjectInUpperNode(object, upperNode);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void delObjUpperNode(AbstractCpsObject object, CpsUpperNode upperNode) {
		nodeController.deleteObjectInUpperNode(object, upperNode);
		model.getTrackingObj().remove(object);
		if (object instanceof CpsUpperNode)
			canvasController.bfsNodeCleaner((CpsUpperNode) object);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	public void addEdgeUpperNode(CpsEdge edge, CpsUpperNode upperNode) {
		nodeController.addEdge(edge, upperNode);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void delEdgeUpperNode(CpsEdge edge, CpsUpperNode upperNode) {
		nodeController.deleteEdge(edge, upperNode);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void connectNodes(CpsEdge edge, CpsUpperNode upperNode) {
		nodeController.connectNodes(edge, upperNode);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void disconnectNodes(CpsEdge edge, CpsUpperNode upperNode) {
		nodeController.disconnectNodes(edge, upperNode);
		try {
			autoSave();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * Get the number of HolonObjects in the given List
	 * 
	 * @param list
	 */
	public int getNumberHolonObjects(ArrayList<AbstractCpsObject> list) {
		return objectController.getNumberHolonObjects(list);
	}

	/**
	 * Get the number of HolonObjects with the given state in the given List
	 * 
	 * @param list
	 * @param state
	 */
	public int getNumberStateObjects(ArrayList<AbstractCpsObject> list, int state) {
		return objectController.getNumberStateObjects(list, state);
	}

	/**
	 * Changes the value of HolonBodySCALE
	 * 
	 * @param s
	 *            HolonBodyScale
	 */
	public void setHolonBodyScale(int s) {
		globalController.setHolonBodyScale(s);
	}

	/**
	 * Returns HolonBodySCALE.
	 * 
	 * @return SCALE
	 */
	public int getHolonBodyScale() {
		return globalController.getHolonBodyScale();
	}

	/**
	 * Sets the ID of the selected HolonBody
	 * 
	 * @param i
	 *            ID of the selected HolonBody
	 */
	public void addSelectedHolonBody(int i) {
		objectController.addSelectedHolonBody(i);
	}

	/**
	 * Copy all Selected Objects.
	 */
	public void copy(CpsUpperNode upperNode) {
		clipboardController.copy(upperNode);
	}

	public void paste(CpsUpperNode upperNode, Point point)
			throws JsonParseException, UnsupportedFlavorException, IOException {
		clipboardController.paste(upperNode, point);
	}

	public void cut(CpsUpperNode upperNode) {
		clipboardController.cut(upperNode);
	}

	public void getObjectsInDepth() {
		clipboardController.getObjectsInDepth();
	}

	public float getTotalProduction(ArrayList<AbstractCpsObject> arrayList) {
		return holonCanvasController.getTotalProduction(arrayList);
	}

	public float getTotalConsumption(ArrayList<AbstractCpsObject> arrayList) {
		return holonCanvasController.getTotalConsumption(arrayList);
	}

	public int getTotalElements(ArrayList<AbstractCpsObject> arrayList) {
		return holonCanvasController.getTotalElements(arrayList);
	}

	public int getTotalProducers(ArrayList<AbstractCpsObject> arrayList) {
		return holonCanvasController.getTotalProducers(arrayList);
	}

	public int getActiveElements(ArrayList<AbstractCpsObject> arrayList) {
		return holonCanvasController.getActiveElements(arrayList);
	}

	/**
	 * Set the Background Image;
	 * 
	 * @param imagePath
	 *            Image Path
	 * @param mode
	 *            Image Mode
	 * @param width
	 *            Image custom width
	 * @param height
	 *            Image custom height
	 */
	public void setBackgroundImage(String imagePath, int mode, int width, int height) {
		canvasController.setBackgroundImage(imagePath, mode, width, height);
	}

	public void setFlexiblePane(FlexiblePane fp) {
		simulationManager.setFlexiblePane(fp);
	}

	public void setGraphTable(Hashtable<String, StatisticGraphPanel> gT) {
		model.setGraphTable(gT);
	}

	public Hashtable<String, StatisticGraphPanel> getGraphTable() {
		return model.getGraphTable();
	}

	/**
	 * Sets if the Simulation is running
	 */
	public void setIsSimRunning(boolean isRunning) {
		globalController.setIsSimRunning(isRunning);
	}

	/**
	 * Sets showConsoleLog.
	 * 
	 * @param showConsoleLog
	 */
	public void setShowConsoleLog(boolean showConsoleLog) {
		globalController.setShowConsoleLog(showConsoleLog);
	}

}