package holeg.ui.controller;

import java.awt.Point;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import java.util.stream.Collectors;

import holeg.model.AbstractCanvasObject;
import holeg.model.Edge;
import holeg.model.GroupNode;
import holeg.model.HolonObject;
import holeg.model.HolonSwitch;
import holeg.model.Node;
import holeg.ui.model.GuiSettings;
import holeg.ui.model.Model;
import holeg.ui.view.main.GUI;
import holeg.utility.math.vector.Vec2i;

/**
 * Controller for the Canvas.
 * 
 * @author Gruppe14
 */
//TODO(Tom2022-01-11): remove CanvasController and merge with NodeController
@Deprecated
public class CanvasController {

	private Model model;
    private GUI gui;
	/**
	 * Constructor.
	 * 
	 * @param model
	 *            the Model
	 * @param mp
	 *            the MultipurposeController
	 */
	public CanvasController(Model model) {
		this.model = model;
	}

	/**
	 * Add an CpsObject to the model and notify the ObjectListener for update.
	 * 
	 * @param object
	 *            CpsObject to be added.
	 * @param replace when true objects could be replaced
	 */
	public void addObject(AbstractCanvasObject object, boolean replace) {
		model.getCanvas().add(object);
		/**
		 * check if we should drag & drop replace
		 */
		if(!(object instanceof Node) && replace){
			/** x of the dragged Object */
			int x = object.getPosition().getX();
			
			/** y of the dragged Object */
			int y = object.getPosition().getY();
			
			/** distance treshold for replacement */
			int treshhold = GuiSettings.getPictureScale()/2;
			
			/** number of Objects that might be replaced (should be 1) */
			int replaceCounter = 0;
			
			/** last object that could be replaced */
			AbstractCanvasObject toBeReplaced = null;
			
			/** for each cps on Canvas */
			for (AbstractCanvasObject cps : model.getCanvas().getObjectsInThisLayer().toList()){
				
				/** same object -> ignore */
				if(cps == object)continue;
				
				/** x of object that might get replaced */
				int c_x = cps.getPosition().getX();
				
				/** y of object that might get replaced */
				int c_y = cps.getPosition().getY();
				
				/** if near enough */
				if(Math.abs(x-c_x)<treshhold && Math.abs(y-c_y)<treshhold){
					replaceCounter++;
					toBeReplaced = cps;
				}	
			}
			/** if replacement of exactly one object possible */
			if(replaceCounter == 1 && toBeReplaced != null){
				replaceObjectOnCanvas(toBeReplaced, object);
			}
		}
	}

	/**
	 * Add a new Object.
	 * 
	 * @param object
	 *            the Object
	 */
	public void addNewObject(AbstractCanvasObject object) {
		object.setSav("CVS");
		// object.setConnections(new ArrayList<CpsEdge>());
		addObject(object, true);
	}



	/**
	 * Deletes an CpsObject on the Canvas and its connections.
	 * 
	 * @param obj
	 *            AbstractCpsObject
	 */
	public void deleteObjectOnCanvas(AbstractCanvasObject obj) {
		removeAllConnectionsFromObject(obj);
		model.getCanvas().remove(obj);
	}
	
	public void deleteObjectsOnCanvas(Collection<AbstractCanvasObject> objects) {
		for(AbstractCanvasObject obj: objects) {
			removeAllConnectionsFromObject(obj);
			model.getCanvas().remove(obj);
		}
	}

	/**
     * Replaces {@code toBeReplaced} by {@code by} on the canvas
     * @param toBeReplaced the object that will be replaced
     * @param by the object that will replace it
     */
	public void replaceObjectOnCanvas(AbstractCanvasObject toBeReplaced, AbstractCanvasObject by) {
		
		//Replace edges
		ListIterator<Edge>  iter = model.getEdgesOnCanvas().listIterator();
		while(iter.hasNext() ) {
			Edge edge = iter.next();
			if(edge.getA() == toBeReplaced && edge.getB() != by) {
				edge.setA(by);
			}
			else if( edge.getB() == toBeReplaced && edge.getA() != by) {
				edge.setB(by);
			}
		}
		/**
		 * set Position of by to exactly toBeReplaced
		 */
		by.setPosition(toBeReplaced.getPosition());
		deleteObjectOnCanvas(toBeReplaced);
	}
	
	/**
	 * Add an edge to the Canvas.
	 * 
	 * @param edge
	 *            the edge
	 */
	public void addEdgeOnCanvas(Edge edge) {
		model.getEdgesOnCanvas().add(edge);
	}

	/**
	 * Removes an Edge from the Canvas.
	 * 
	 * @param edge
	 *            the edge to remove
	 */
	public void removeEdgesOnCanvas(Edge edge) {
		model.getEdgesOnCanvas().remove(edge);
	}

	/**
	 * Paste all Selected Objects.
	 * 
	 * @param p
	 *            the mouse Position
	 */
	public void pasteObjects(Point p) {
		GuiSettings.getSelectedObjects().clear();
		AbstractCanvasObject tCps = null;
		int x = Integer.MAX_VALUE, y = Integer.MAX_VALUE;

		// Location whre to copy the Elements
		for (AbstractCanvasObject cps : GuiSettings.getClipboardObjects()) {
			if (cps.getPosition().getX() < x) {
				x = cps.getPosition().getX();
			}
			if (cps.getPosition().getY() < y) {
				y = cps.getPosition().getY();
			}
		}

		// Objects
		for (AbstractCanvasObject cps : GuiSettings.getClipboardObjects()) {
			if (cps instanceof HolonObject hO) {
				tCps = new HolonObject(hO);
			} else if (cps instanceof HolonSwitch sw) {
				tCps = new HolonSwitch(sw);
			} else {
				tCps = new Node("Node");
			}
			tCps.setPosition(new Vec2i(p.x + (cps.getPosition().getX() - x), p.y + (cps.getPosition().getY() - y)));
			tCps.setSav(cps.getSav());
			addObject(tCps, false);
		}

		

	}

	/**
	 * Cut all Selected Objects.
	 */
	public void cutObjects() {
		GuiSettings.setClipboardObjects(GuiSettings.getSelectedObjects().stream().collect(Collectors.toSet()));
		for (AbstractCanvasObject cps : GuiSettings.getClipboardObjects()) {
			deleteObjectOnCanvas(cps);
		}

		GuiSettings.getSelectedObjects().clear();
	}

	
	/**
	 * Some cleaning Algorithm which traverses the UpperNode through BFS Can be
	 * extended with other cleaning stuff No need for coloring since there tree
	 * is only directed in one direction
	 * 
	 * @param node
	 */
	public void deleteAllObjectsInGroupNode(GroupNode node) {
		List<AbstractCanvasObject> objectsInGroupNode = node.getAllObjectsRecursive().toList();
		ListIterator<Edge>  iter = model.getEdgesOnCanvas().listIterator();
		while(iter.hasNext() ) {
			Edge edge = iter.next();
			if(objectsInGroupNode.contains(edge.getA()) || objectsInGroupNode.contains(edge.getB())) {
				iter.remove();
			}
		}
	}

	public void removeAllConnectionsFromObject(AbstractCanvasObject obj) {
		ListIterator<Edge>  iter = model.getEdgesOnCanvas().listIterator();
		while(iter.hasNext() ) {
			Edge edge = iter.next();
			if(edge.getA() == obj || edge.getB() == obj) {
				iter.remove();
			}
		}
	}
	
	public void updateCanvas() {
		gui.repaintCanvas();
	}
	public GUI getGui() {
		return gui;
	}

	public void guiDisable(boolean state) {
		gui.guiDisable(state);
	}
	
	public void setGui(GUI gui) {
		this.gui = gui;
	}
	
}