package application;

import javafx.application.Platform;
import javafx.event.EventHandler;
import javafx.geometry.Point2D;
import javafx.scene.Cursor;
import javafx.scene.Node;
import javafx.scene.effect.DropShadow;
import javafx.scene.input.DragEvent;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.Region;

public class Utitlities {

	/**
	 * This code section is for making a node resizeable only when moouse is coming from the outside
	 */
	
	private final static Object resizableFeatureKey = new Object();

	private static class NodeResizableHandlersHolder {

		EventHandler<MouseEvent> mouseClickedDownHandler, mouseClickedUpHandler, mouseMovedHandler, mouseEnteredHandler,
				mouseExitedHandler, mouseDraggedHandler;

		private boolean enteredState = false;
		private boolean dragState = false;

		private Region nodeInQuestion = null;
		private final double resizeBorderThickness = 20.0;
		private Point2D lastKnownPointerValue = null;
		private final DropShadow dropShadow = new DropShadow();

		public NodeResizableHandlersHolder() {
			this(null);
		}

		public NodeResizableHandlersHolder(Region n) {
			initializeEventHandlers();
			if (n != null) {
				installHandlersOnNode(n);
			}
		}

		private final void initializeEventHandlers() {
			mouseClickedDownHandler = new EventHandler<MouseEvent>() {

				@Override
				public void handle(MouseEvent arg0) {
					Node n = nodeInQuestion;
					dragState = (n.getCursor() == Cursor.E_RESIZE || n.getCursor() == Cursor.H_RESIZE
							|| n.getCursor() == Cursor.N_RESIZE || n.getCursor() == Cursor.NE_RESIZE
							|| n.getCursor() == Cursor.NW_RESIZE || n.getCursor() == Cursor.S_RESIZE
							|| n.getCursor() == Cursor.SE_RESIZE || n.getCursor() == Cursor.SW_RESIZE
							|| n.getCursor() == Cursor.V_RESIZE || n.getCursor() == Cursor.W_RESIZE)
					/* && arg0.isPrimaryButtonDown() */;

					if (dragState) {
						// System.out.println("is drag state activated");
					}

				}
			};

			mouseClickedUpHandler = new EventHandler<MouseEvent>() {

				@Override
				public void handle(MouseEvent arg0) {
					// if(dragState){
					dragState = false;
					// System.out.println("drag state de-activated");
					// }
					//since we need it to be later. as mouseMoved events are still being propagated
					//Platform.runLater(() -> enteredState = false);
				}
			};

			mouseEnteredHandler = new EventHandler<MouseEvent>() {

				@Override
				public void handle(MouseEvent arg0) {
					nodeInQuestion.setCursor(getCursorFromPoint(arg0.getSceneX(), arg0.getSceneY()));
					nodeInQuestion.setEffect(dropShadow);
					//since we need it to be later. as mouseMoved events are still being propagated
					Platform.runLater(() -> enteredState = true);
				}
			};

			mouseExitedHandler = new EventHandler<MouseEvent>() {

				@Override
				public void handle(MouseEvent arg0) {
					enteredState = false;
					nodeInQuestion.setEffect(null);
				}
			};

			mouseMovedHandler = new EventHandler<MouseEvent>() {

				@Override
				public void handle(MouseEvent arg0) {
					if (enteredState) {
						boolean changeCursor = (lastKnownPointerValue.getX() > 0
								&& Math.abs(lastKnownPointerValue.getX() - arg0.getSceneX()) > resizeBorderThickness)
								|| (lastKnownPointerValue.getY() > 0 && Math
										.abs(lastKnownPointerValue.getY() - arg0.getSceneY()) > resizeBorderThickness);

						if (changeCursor) {
							nodeInQuestion.setCursor(Cursor.DEFAULT);
							enteredState = false;
							lastKnownPointerValue = null;
						}
					}
				}
			};

			mouseDraggedHandler = new EventHandler<MouseEvent>() {

				@Override
				public void handle(MouseEvent arg0) {
					if (dragState) {
						/*
						 * System.out.println("Moving in dragstate ");
						 * System.out.println("screen x " +
						 * String.valueOf(arg0.getScreenX()) +"  screen y " +
						 * arg0.getScreenY()); System.out.println("sceen x " +
						 * String.valueOf(arg0.getSceneX()) +"  sceen y " +
						 * arg0.getSceneY());
						 */

						nodeInQuestion.setEffect(null);
						double width = nodeInQuestion.getBoundsInLocal().getMinX() + arg0.getSceneX();
						double height = nodeInQuestion.getBoundsInLocal().getMinY() + arg0.getSceneY();

						if (nodeInQuestion.getCursor() == Cursor.H_RESIZE) { // only horizontal
							nodeInQuestion.setPrefWidth(width);
						} else if (nodeInQuestion.getCursor() == Cursor.V_RESIZE) { // only vertical
							nodeInQuestion.setPrefHeight(height);
						} else {
							nodeInQuestion.setPrefSize(width, height);
						}
					}

				}
			};
		}

		public final void installHandlersOnNode(Region n) {
			n.setMinSize(Region.USE_COMPUTED_SIZE, Region.USE_COMPUTED_SIZE);
			n.setOnMouseMoved(mouseMovedHandler);
			n.setOnDragDetected(mouseClickedDownHandler);
			n.setOnMouseReleased(mouseClickedUpHandler);
			n.setOnMouseEntered(mouseEnteredHandler);
			n.setOnMouseExited(mouseExitedHandler);
			n.setOnMouseDragged(mouseDraggedHandler);

			n.getProperties().put(resizableFeatureKey, this);

			nodeInQuestion = n;
		}

		private final Cursor getCursorFromPoint(double x, double y) {
			Cursor cursor = Cursor.NONE;
			lastKnownPointerValue = new Point2D(x, y);

			boolean isRightWidthPref = nodeInQuestion.getBoundsInLocal().getMaxX() <= x
					&& nodeInQuestion.getBoundsInLocal().getMinX() < x;

			boolean isLeftWidthPref = nodeInQuestion.getBoundsInLocal().getMinX() >= x
					&& nodeInQuestion.getBoundsInLocal().getMaxX() > x;

			boolean isTopHeightPref = nodeInQuestion.getBoundsInLocal().getMinY() >= y
					&& nodeInQuestion.getBoundsInLocal().getMaxY() > y;

			boolean isBottomHeightPref = nodeInQuestion.getBoundsInLocal().getMaxY() <= y
					&& nodeInQuestion.getBoundsInLocal().getMinY() < y;

			if (isRightWidthPref && isBottomHeightPref) {
				cursor = Cursor.SE_RESIZE;
			} else if (isRightWidthPref && isTopHeightPref) {
				cursor = Cursor.NE_RESIZE;
			} else if (isLeftWidthPref && isBottomHeightPref) {
				cursor = Cursor.SW_RESIZE;
			} else if (isLeftWidthPref && isTopHeightPref) {
				cursor = Cursor.NW_RESIZE;
			} else if (isLeftWidthPref || isRightWidthPref) {
				cursor = Cursor.H_RESIZE;
				lastKnownPointerValue = new Point2D(x, 0);
			} else if (isBottomHeightPref || isTopHeightPref) {
				cursor = Cursor.V_RESIZE;
				lastKnownPointerValue = new Point2D(0, y);
			}

			System.out.println(cursor.toString());

			return cursor;
		}
	}

	public static void addResizableFeatureToNode(Region node) {
		if (!node.getProperties().containsKey(resizableFeatureKey)) {
			NodeResizableHandlersHolder handlersHolder = new NodeResizableHandlersHolder(node);
		}
	}
	
	/**
	 * Node resizeable code flow ends here
	 */

}