/*****************************************************************************
 * Copyright (c) 2014-15 CEA LIST, Montages AG and others.
 * 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Michael Golubev (Montages) - Initial API and implementation
 *   
 *****************************************************************************/
package org.eclipse.gmf.tooling.runtime.linklf;

import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.PrecisionRectangle;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gmf.runtime.draw2d.ui.figures.FigureUtilities;
import org.eclipse.gmf.runtime.gef.ui.figures.NodeFigure;
import org.eclipse.gmf.runtime.gef.ui.figures.SlidableAnchor;

/**
 * Extends {@link SlidableAnchor} with ability to snap to the intersection
 * points between the host anchorable bounds and the active diagram grid.
 * 
 * @since 3.3
 */
public class SlidableSnapToGridAnchor extends SlidableAnchor {

	private EditPartViewer myGridProvider;

	public SlidableSnapToGridAnchor(NodeFigure f, PrecisionPoint p) {
		super(f, p);
	}

	public void setEditPartViewer(EditPartViewer viewer) {
		myGridProvider = viewer;
	}

	@Override
	public Point getOrthogonalLocation(Point orthoReference) {
		Point result = getOrthogonalLocationNoSnap(orthoReference);
		if (result != null) {
			Rectangle gridSpecAbs = getAbsoluteGridSpec();
			LinkedList<Point> onVerticalGrid = new LinkedList<Point>();
			LinkedList<Point> onHorizontalGrid = new LinkedList<Point>();
			computeAnchorablePointsOnGrid(gridSpecAbs, onVerticalGrid,
					onHorizontalGrid);

			if (!onHorizontalGrid.isEmpty() || !onVerticalGrid.isEmpty()) {
				return pickClosestPointToSet(result, onHorizontalGrid,
						onVerticalGrid);
			}
		}
		return result;
	}

	private boolean myGetLocationReentryLock = false;

	@Override
	public Point getLocation(Point reference) {
		Rectangle gridSpecAbs = getAbsoluteGridSpec();
		if (gridSpecAbs != null && !myGetLocationReentryLock) {
			myGetLocationReentryLock = true;
			try {
				List<Point> onVerticalGrid = new LinkedList<Point>();
				List<Point> onHorizontalGrid = new LinkedList<Point>();

				computeAnchorablePointsOnGrid(gridSpecAbs, onVerticalGrid,
						onHorizontalGrid);

				if (!onVerticalGrid.isEmpty() || !onVerticalGrid.isEmpty()) {
					return pickClosestPointToSet(getReferencePoint(),
							onHorizontalGrid, onVerticalGrid);
				}
			} finally {
				myGetLocationReentryLock = false;
			}
		}

		Point result = super.getLocation(reference);
		return result;
	}

	/**
	 * @see bug #451604, we don't want anchor to move even if the resulting line
	 *      is close to straight
	 *      <p/>
	 *      So we will block the normalization for instances of this class.
	 */
	@Override
	protected Point normalizeToStraightlineTolerance(Point foreignReference,
			Point ownReference, int tolerance) {
		final int NO_TOLERANCE = 0;
		return super.normalizeToStraightlineTolerance(foreignReference,
				ownReference, NO_TOLERANCE);
	}

	@Override
	public String toString() {
		return "SSTGA:" + "terminal: " + getTerminal() + ", terminalLoc: "
				+ getReferencePoint() + ", box: " + getBox();
	}

	/**
	 * Returns the position of the closest edge of the rectangle closest to the
	 * point
	 * 
	 * @param p
	 *            the point
	 * @param r
	 *            the rectangle
	 * @return position of the closest edge
	 * @deprecated copy-pasted from super class, [GMFRT] make protected
	 */
	@Deprecated
	public static int getClosestSide2(Point p, Rectangle r) {
		double diff = Math.abs(r.preciseX() + r.preciseWidth() - p.preciseX());
		int side = PositionConstants.RIGHT;
		double currentDiff = Math.abs(r.preciseX() - p.preciseX());
		if (currentDiff < diff) {
			diff = currentDiff;
			side = PositionConstants.LEFT;
		}
		currentDiff = Math.abs(r.preciseY() + r.preciseHeight() - p.preciseY());
		if (currentDiff < diff) {
			diff = currentDiff;
			side = PositionConstants.BOTTOM;
		}
		currentDiff = Math.abs(r.preciseY() - p.preciseY());
		if (currentDiff < diff) {
			diff = currentDiff;
			side = PositionConstants.TOP;
		}
		return side;
	}

	/**
	 * If grid provider had been set up and has grid enabled then returns active
	 * grid specification in absolute coordinates. Otherwise returns null.
	 * 
	 * @return <code>null</code> if no active grid or grid provider had not been
	 *         set up.
	 */
	protected Rectangle getAbsoluteGridSpec() {
		return myGridProvider == null ? null : DiagramGridSpec
				.getAbsoluteGridSpec(myGridProvider);
	}

	protected static Point pickClosestPointToSet(Point source,
			Collection<? extends Point> set1, Collection<? extends Point> set2) {
		double bestDistSquared = Double.MAX_VALUE;
		Point result = null;
		for (Point next : set1) {
			double nextDistSquared = source.getDistance(next);
			if (nextDistSquared < bestDistSquared) {
				result = next;
				bestDistSquared = nextDistSquared;
			}
		}
		for (Point next : set2) {
			double nextDistSquared = source.getDistance(next);
			if (nextDistSquared < bestDistSquared) {
				result = next;
				bestDistSquared = nextDistSquared;
			}
		}
		return result;
	}

	/**
	 * Computes possible anchorable points on grid for given gridSpec. Results
	 * are pushed into the given lists, separately for points computed for
	 * vertical and horizontal grid.
	 * <p/>
	 * As results of this method depends only on the owner location and the
	 * gridspec, they may be cached to improve performance.
	 * 
	 * @param gridSpecAbs
	 *            absolute grid specification, if <code>null</code> then method
	 *            does nothing
	 * @param onVerticalGridLocs
	 *            output list to store points of vertical grid
	 * @param onHorizontalGridLocs
	 *            output list to store points on horizontal grid
	 */
	protected void computeAnchorablePointsOnGrid(Rectangle gridSpecAbs,
			List<Point> onVerticalGridLocs, List<Point> onHorizontalGridLocs) {
		if (gridSpecAbs == null) {
			return;
		}
		double gridX = gridSpecAbs.preciseWidth();
		double gridY = gridSpecAbs.preciseWidth();
		Point gridOrigin = gridSpecAbs.getLocation();

		PrecisionRectangle bounds = new PrecisionRectangle(
				FigureUtilities.getAnchorableFigureBounds(getOwner()));
		getOwner().translateToAbsolute(bounds);

		Point notOnGrid = bounds.getCenter();

		PrecisionPoint fakeRefAbove = new PrecisionPoint(notOnGrid);
		PrecisionPoint fakeRefBelow = new PrecisionPoint(notOnGrid);
		fakeRefAbove
				.setPreciseY(bounds.preciseY() - bounds.preciseHeight() / 2);
		fakeRefBelow.setPreciseY(bounds.preciseY() + bounds.preciseHeight() / 2
				+ bounds.preciseHeight());

		double reminderX = Math.IEEEremainder(
				notOnGrid.preciseX() - gridOrigin.preciseX(), gridX);
		if (reminderX < 0) {
			reminderX += gridX;
		}
		for (double nextX = notOnGrid.preciseX() - reminderX; nextX >= bounds
				.preciseX(); nextX -= gridX) {
			fakeRefAbove.setPreciseX(nextX);
			fakeRefBelow.setPreciseX(nextX);
			Point onGridForAboveRef = getOrthogonalLocationNoSnap(fakeRefAbove);
			Point onGridForBelowRef = getOrthogonalLocationNoSnap(fakeRefBelow);
			onVerticalGridLocs.add(onGridForAboveRef);
			if (!onGridForBelowRef.equals(onGridForAboveRef)) {
				onVerticalGridLocs.add(onGridForBelowRef);
			}
		}
		for (double nextX = gridX + notOnGrid.preciseX() - reminderX; nextX <= bounds
				.preciseX() + bounds.preciseWidth(); nextX += gridX) {
			fakeRefAbove.setPreciseX(nextX);
			fakeRefBelow.setPreciseX(nextX);
			Point onGridForAboveRef = getOrthogonalLocationNoSnap(fakeRefAbove);
			Point onGridForBelowRef = getOrthogonalLocationNoSnap(fakeRefBelow);
			onVerticalGridLocs.add(onGridForAboveRef);
			if (!onGridForBelowRef.equals(onGridForAboveRef)) {
				onVerticalGridLocs.add(onGridForBelowRef);
			}
		}

		PrecisionPoint fakeRefLeft = new PrecisionPoint(notOnGrid);
		PrecisionPoint fakeRefRight = new PrecisionPoint(notOnGrid);
		fakeRefLeft.setPreciseX(bounds.preciseX() - bounds.preciseWidth() / 2);
		fakeRefRight.setPreciseX(bounds.preciseX() + bounds.preciseWidth()
				+ bounds.preciseWidth() / 2);
		double reminderY = Math.IEEEremainder(
				notOnGrid.preciseY() - gridOrigin.preciseY(), gridY);
		if (reminderY < 0) {
			reminderY += gridY;
		}
		for (double nextY = notOnGrid.preciseY() - reminderY; nextY >= bounds
				.preciseY(); nextY -= gridY) {
			fakeRefLeft.setPreciseY(nextY);
			fakeRefRight.setPreciseY(nextY);
			Point onGridForLeftRef = getOrthogonalLocationNoSnap(fakeRefLeft);
			Point onGridForRightRef = getOrthogonalLocationNoSnap(fakeRefRight);
			onHorizontalGridLocs.add(onGridForLeftRef);
			if (!onGridForLeftRef.equals(onGridForRightRef)) {
				onHorizontalGridLocs.add(onGridForRightRef);
			}
		}
		for (double nextY = gridY + notOnGrid.preciseY() - reminderY; nextY <= bounds
				.preciseY() + bounds.preciseHeight(); nextY += gridY) {
			fakeRefLeft.setPreciseY(nextY);
			fakeRefRight.setPreciseY(nextY);
			Point onGridForLeftRef = getOrthogonalLocationNoSnap(fakeRefLeft);
			Point onGridForRightRef = getOrthogonalLocationNoSnap(fakeRefRight);
			onHorizontalGridLocs.add(onGridForLeftRef);
			if (!onGridForLeftRef.equals(onGridForRightRef)) {
				onHorizontalGridLocs.add(onGridForRightRef);
			}
		}

		// System.err.println("Found: on horizontal grid: " +
		// onHorizontalGridLocs);
		// System.err.println("Found: on vertical grid: " + onVerticalGridLocs);
	}

	protected Point getOrthogonalLocationNoSnap(Point refPoint) {
		return super.getOrthogonalLocation(refPoint);
	}

}