package ui.controller;

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

import classes.AbstractCpsObject;
import classes.CpsEdge;
import classes.CpsUpperNode;
import classes.Position;
import ui.model.Model;

public class NodeController {

	private Model model;
	private CanvasController cvs;
	private MultiPurposeController mpC;

	public NodeController(Model model, CanvasController cvs, MultiPurposeController mpC) {
		// TODO Auto-generated constructor stub
		this.model = model;
		this.cvs = cvs;
		this.mpC = mpC;
	}

	/**
	 * Add a CpsUpperNode into Canvas
	 * 
	 * @param nodeName
	 */
	public void addNode(String nodeName, CpsUpperNode upperNode) {
		CpsUpperNode node = new CpsUpperNode(nodeName);
		node.setPosition(calculatePos());
		connectAdjacent(node, upperNode);
		makeNodeOfNodes(node, upperNode);
		if (upperNode == null)
			cvs.addNewObject(node);
		else
			addObjectInUpperNode(node, upperNode);

	}

	/**
	 * Add a Object into a CpsUpperNode
	 * 
	 * @param object
	 * @param upperNode
	 */
	public void addObjectInUpperNode(AbstractCpsObject object, CpsUpperNode upperNode) {
		object.setSav("UPPER" + upperNode.getID());
		upperNode.getNodesIdx().put(object.getID(), upperNode.getNodes().size());
		upperNode.getNodes().add(object);
	}

	/**
	 * Delete a CpsUpperNode from the Canvas
	 * 
	 * @param node
	 */
	public void deleteNode(CpsUpperNode node) {

	}

	/**
	 * Delete a AbstactCpsObject from CPSUpperNode
	 * 
	 * @param object
	 * @param upperNode
	 */
	public void deleteObjectInUpperNode(AbstractCpsObject object, CpsUpperNode upperNode) {
		CpsEdge e = null;
		for (AbstractCpsObject cps : upperNode.getNodes()) {
			for (CpsEdge p : cps.getConnections()) {
				if (p.getA() == object || p.getB() == object) {
					e = p;
				}
			}
			if (!model.getClipboradObjects().contains(cps)) {
				cps.getConnectedTo().remove(e);
			}
			model.getEdgesOnCanvas().remove(e);
		}
		mpC.decIdx(object.getID(), upperNode.getNodesIdx());
		upperNode.getNodesIdx().remove(object.getID());
		upperNode.getNodes().remove(object);
	}

	/**
	 * Put selected Nodes inside the Upper Node
	 * 
	 * @param node
	 */
	private void makeNodeOfNodes(CpsUpperNode node, CpsUpperNode upperNode) {

		ArrayList<AbstractCpsObject> nodes = node.getNodes();
		ArrayList<CpsEdge> nodeEdges = node.getNodeEdges();

		// Put all selected Nodes into the Upper Node
		for (Iterator<AbstractCpsObject> it = model.getSelectedCpsObjects().iterator(); it.hasNext();) {

			// füge Neue Objecte in Neuen Node hinzu
			AbstractCpsObject obj = it.next();
			addObjectInUpperNode(obj, node);
		}

		// Füge die Edges die Alle Objekte vorher verbunden hat in neuen Node
		for (Iterator<CpsEdge> it = (upperNode == null ? model.getEdgesOnCanvas() : upperNode.getNodeEdges())
				.iterator(); it.hasNext();) {

			CpsEdge edge = it.next();
			if (nodes.contains(edge.getA()) && nodes.contains(edge.getB())) {
				nodeEdges.add(edge);
			}

		}
		// Lösche dann die Edges aus der nächst höheren schicht
		for (AbstractCpsObject abs : model.getSelectedCpsObjects()) {
			if (upperNode == null)
				cvs.deleteObjectOnCanvas(abs);
			else
				deleteObjectInUpperNode(abs, upperNode);
		}

	}

	/**
	 * 
	 * @return
	 */
	private void connectAdjacent(CpsUpperNode node, CpsUpperNode upperNode) {

		ArrayList<AbstractCpsObject> adj = new ArrayList<>();
		ArrayList<Float> maxCapacity = new ArrayList<>();
		ArrayList<CpsEdge> oldEdges = node.getOldEdges();

		ArrayList<CpsEdge> toDelete = new ArrayList<>();

		// float maxCapacity = 0;

		// für alle Edges auf dem Canvas
		for (Iterator<CpsEdge> it = model.getEdgesOnCanvas().iterator(); it.hasNext();) {

			CpsEdge edge = it.next();

			// if (edge.getCapacity() > maxCapacity)
			// maxCapacity = edge.getCapacity();

			// wenn ausgewählte Objekte in edge und andere auserhalb
			if (model.getSelectedCpsObjects().contains(edge.getA())
					&& !model.getSelectedCpsObjects().contains(edge.getB())) {
				// und wenn in der adj noch nicht vorhanden und füg
				if (!adj.contains(edge.getB())) {
					adj.add(edge.getB());
					maxCapacity.add(edge.getCapacity());
				}
				// wenn vorhanden teste maxCapacity
				else if (maxCapacity.get(adj.indexOf(edge.getB())) < edge.getCapacity()) {
					maxCapacity.set(adj.indexOf(edge.getB()), edge.getCapacity());
				}
				// speichere alte edge
				oldEdges.add(edge);
				toDelete.add(edge);

			}

			// Analog
			else if (!model.getSelectedCpsObjects().contains(edge.getA())
					&& model.getSelectedCpsObjects().contains(edge.getB())) {
				if (!adj.contains(edge.getA())) {
					adj.add(edge.getA());
					maxCapacity.add(edge.getCapacity());
				} else if (maxCapacity.get(adj.indexOf(edge.getA())) < edge.getCapacity()) {
					maxCapacity.set(adj.indexOf(edge.getA()), edge.getCapacity());

				}
				oldEdges.add(edge);
				toDelete.add(edge);
			}
		}

		model.getEdgesOnCanvas().removeAll(toDelete);

		// für alle objekte in adjazenzliste mach
		for (AbstractCpsObject cps : adj) {
			CpsEdge newEdge = new CpsEdge(cps, node, maxCapacity.get(adj.indexOf(cps)));
			// !! Eventuell noch bei getConnections() hinzufügem
			node.getConnections().add(newEdge);
			if (upperNode == null)
				cvs.addEdgeOnCanvas(newEdge);
			else
				upperNode.getNodeEdges().add(newEdge);

		}
	}

	/**
	 * Calculate new Position of the Upper Node
	 * 
	 * @return
	 */
	private Position calculatePos() {

		Position pos = new Position(0, 0);

		// sum(x0 .. xn) / numOfPos, y analog
		for (AbstractCpsObject abs : model.getSelectedCpsObjects()) {
			pos.x += abs.getPosition().x;
			pos.y += abs.getPosition().y;
		}
		pos.x /= model.getSelectedCpsObjects().size();
		pos.y /= model.getSelectedCpsObjects().size();

		return pos;
	}

}