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 node = new CpsUpperNode(nodeName);
		node.setPosition(calculatePos());
		connectAdjacent(node);
		makeNodeOfNodes(node);
		cvs.addNewObject(node);
	}

	/**
	 * 
	 * @param node
	 */
	private void makeNodeOfNodes(CpsUpperNode node) {

		ArrayList<AbstractCpsObject> nodes = node.getNodes();
		ArrayList<CpsEdge> nodeEdges = node.getNodeEdges();
		HashMap<Integer, Integer> nodeIdx = node.getNodesIdx();

		for (Iterator<AbstractCpsObject> it = model.getSelectedCpsObjects().iterator(); it.hasNext();) {

			AbstractCpsObject obj = it.next();
			nodeIdx.put(obj.getID(), nodes.size());
			nodes.add(obj);
			cvs.deleteObjectOnCanvas(obj);
		}

		for (Iterator<CpsEdge> it = model.getEdgesOnCanvas().iterator(); it.hasNext();) {

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

		}

	}

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

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

		// 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
				if (!adj.contains(edge.getA()))
					adj.add(edge.getB());
				// 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);
				model.getEdgesOnCanvas().remove(edge);
			}

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

				oldEdges.add(edge);
				model.getEdgesOnCanvas().remove(edge);
			}
		}
		// 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
			cvs.addEdgeOnCanvas(newEdge);
			node.getConnections().add(newEdge);
		}
	}

	private Position calculatePos() {
		
		Position pos = new Position(0, 0);
		
		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;
	}

}