/*****************************************************************************
 * 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.Collections;
import java.util.List;

import org.eclipse.draw2d.AbsoluteBendpoint;
import org.eclipse.draw2d.Bendpoint;
import org.eclipse.draw2d.Connection;
import org.eclipse.draw2d.ConnectionAnchor;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.RelativeBendpoints;
import org.eclipse.gmf.runtime.notation.datatype.RelativeBendpoint;

/**
 * This class defines when to enable the enhanced link anchors and bendpoints
 * behavior, which implementation is based on storing the fixed bendpoints
 * coordinates instead of their relative locations to anchors.
 * 
 * @since 3.3
 */
public abstract class AbsoluteBendpointsConvention {

	private static AbsoluteBendpointsConvention ourInstance;

	public static AbsoluteBendpointsConvention getInstance() {
		if (ourInstance == null) {
			// ourInstance = new OnlyForNewLinks();
			ourInstance = new ForAllLinks();
		}
		return ourInstance;
	}

	public abstract RelativeBendpoint createAbsoluteBendpointStoredAsRelative(
			Point point);

	public abstract boolean isAbsoluteStoredAsRelative(RelativeBendpoint modelBP);

	public abstract Bendpoint d2dBendpoint(RelativeBendpoint modelBP,
			Connection connection, float weight);

	public abstract boolean hasAbsoluteStoredAsRelativeBendpoints(Edge edge);

	public abstract PointList getPointList(Edge edge, Object linkConstraint);

	private abstract static class ConventionBase extends
			AbsoluteBendpointsConvention {

		private static final int MAGIC = -643984;

		@Override
		public RelativeBendpoint createAbsoluteBendpointStoredAsRelative(
				Point point) {
			return new RelativeBendpoint(point.x, point.y, MAGIC, MAGIC);
		}

		@Override
		public boolean isAbsoluteStoredAsRelative(RelativeBendpoint modelBP) {
			return modelBP.getTargetX() == MAGIC
					&& modelBP.getTargetY() == MAGIC;
		}

		@Override
		public Bendpoint d2dBendpoint(RelativeBendpoint modelBP,
				Connection connection, float weight) {
			if (isAbsoluteStoredAsRelative(modelBP)) {
				return new AbsoluteBendpoint(modelBP.getSourceX(),
						modelBP.getSourceY());
			}
			return null;
		}

		@Override
		public PointList getPointList(Edge edge, Object linkConstraint) {
			PointList result = new PointList();
			List<?> d2dBendpoints = linkConstraint instanceof List<?> ? (List<?>) linkConstraint
					: Collections.emptyList();
			RelativeBendpoints allModelBendpoints = (RelativeBendpoints) edge
					.getBendpoints();
			@SuppressWarnings("unchecked")
			List<RelativeBendpoint> modelBendpoints = allModelBendpoints
					.getPoints();
			for (int i = 0; i < modelBendpoints.size(); i++) {
				RelativeBendpoint nextModel = modelBendpoints.get(i);
				Object nextD2d = d2dBendpoints.size() > i ? d2dBendpoints
						.get(i) : null;

				Point nextPoint = getLocation(nextModel, nextD2d);
				if (nextPoint == null) {
					throw new IllegalStateException(
							"Can't extract location: modelBP: " + nextModel
									+ ", d2dBP: " + nextD2d);
				}
				result.addPoint(nextPoint);
			}
			return result;
		}

		protected static org.eclipse.draw2d.RelativeBendpoint newRelativeBendpointD2d(
				RelativeBendpoint modelBP, Connection connection, float weight) {
			org.eclipse.draw2d.RelativeBendpoint rbp = new org.eclipse.draw2d.RelativeBendpoint(
					connection);
			rbp.setRelativeDimensions(new Dimension(modelBP.getSourceX(),
					modelBP.getSourceY()), //
					new Dimension(modelBP.getTargetX(), modelBP.getTargetY()));
			rbp.setWeight(weight);
			return rbp;
		}

		protected abstract Point getLocation(RelativeBendpoint modelBendpoint,
				Object d2dbendpoint);

	}

	protected static class OnlyForNewLinks extends ConventionBase {

		@Override
		public Bendpoint d2dBendpoint(RelativeBendpoint modelBP,
				Connection connection, float weight) {
			Bendpoint result = super.d2dBendpoint(modelBP, connection, weight);
			if (result == null) {
				result = newRelativeBendpointD2d(modelBP, connection, weight);
			}
			return result;
		}

		@Override
		public boolean hasAbsoluteStoredAsRelativeBendpoints(Edge edge) {
			List<?> bendpoints = ((RelativeBendpoints) edge.getBendpoints())
					.getPoints();
			for (Object o : bendpoints) {
				if (o instanceof RelativeBendpoint
						&& isAbsoluteStoredAsRelative((RelativeBendpoint) o)) {
					return true;
				}
			}
			return false;
		}

		@Override
		protected Point getLocation(RelativeBendpoint modelBendpoint,
				Object d2dbendpoint) {
			if (isAbsoluteStoredAsRelative(modelBendpoint)) {
				return new Point(modelBendpoint.getSourceX(),
						modelBendpoint.getSourceY());
			}
			if (d2dbendpoint instanceof Bendpoint) {
				return ((Bendpoint) d2dbendpoint).getLocation();
			}
			return null;
		}

	}

	protected static class ForAllLinks extends ConventionBase {

		@Override
		public Bendpoint d2dBendpoint(RelativeBendpoint modelBP,
				Connection connection, float weight) {
			Bendpoint result = super.d2dBendpoint(modelBP, connection, weight);
			if (result == null) {
				org.eclipse.draw2d.RelativeBendpoint rbp = newRelativeBendpointD2d(
						modelBP, connection, weight);
				// if(connection.getSourceAnchor() != null &&
				// connection.getTargetAnchor() != null) {
				result = new RelativeBendpointWrapper(rbp, connection);
				// }
			}
			return result;
		}

		@Override
		public boolean hasAbsoluteStoredAsRelativeBendpoints(Edge edge) {
			List<?> bendpoints = ((RelativeBendpoints) edge.getBendpoints())
					.getPoints();
			return !bendpoints.isEmpty();
		}

		@Override
		protected Point getLocation(RelativeBendpoint modelBendpoint,
				Object d2dBendpoint) {
			if (isAbsoluteStoredAsRelative(modelBendpoint)) {
				return new Point(modelBendpoint.getSourceX(),
						modelBendpoint.getSourceY());
			}
			if (d2dBendpoint instanceof AbsoluteBendpoint) {
				AbsoluteBendpoint wrapper = (AbsoluteBendpoint) d2dBendpoint;
				return wrapper.getLocation();
			}
			throw new IllegalStateException(
					"I had to create AbsoluteBendpointWrapper for this: "
							+ modelBendpoint + ", " + d2dBendpoint);
		}

		/**
		 * Provides implicit migration of the diagrams created before the
		 * LinksLF.
		 * <p/>
		 * Idea is to create the same "absolute" bendpoints for the old relative
		 * bendpoints created with previous version, and only update the
		 * persistence on the first modification of the link.
		 * <p/>
		 * However, positions of the {@link RelativeBendpoint} depends on the
		 * anchors and, more generally on the bounds of link ends, so they can't
		 * be computed immediately at the time of creation. This class
		 * introduced the deferred replacement, that is, once the
		 * {@link RelativeBendpoint} can compute its positions, their
		 * coordinates are saved and don't depend on the source or target
		 * anchors anymore.
		 */
		@SuppressWarnings("serial")
		private static class RelativeBendpointWrapper extends AbsoluteBendpoint {

			private Point myLocation = null;

			private org.eclipse.draw2d.RelativeBendpoint myRelativeBendpoint;

			private Connection myConnection;

			/**
			 * Wraps the {@link RelativeBendpoint} and defers computation of its
			 * positions until it is ready.
			 * 
			 * @param relativeBendpoint
			 * @param conn
			 */
			public RelativeBendpointWrapper(
					org.eclipse.draw2d.RelativeBendpoint relativeBendpoint,
					Connection conn) {
				super(new Point());
				myRelativeBendpoint = relativeBendpoint;
				myConnection = conn;
			}

			@Override
			public Point getLocation() {
				if (myLocation == null && isReadyToComputeLocation()) {
					myLocation = new Point(myRelativeBendpoint.getLocation());
					myRelativeBendpoint = null;
					myConnection = null;
				}
				return myLocation != null ? myLocation : myRelativeBendpoint
						.getLocation();
			}

			private boolean isReadyToComputeLocation() {
				if (myConnection == null) {
					return false;
				}
				ConnectionAnchor source = myConnection.getSourceAnchor();
				ConnectionAnchor target = myConnection.getTargetAnchor();
				if (source == null || target == null) {
					return false;
				}
				return hasLocation(source.getReferencePoint())
						&& hasLocation(target.getReferencePoint());
			}

			private boolean hasLocation(Point point) {
				return point != null && (point.x() != 0 || point.y() != 0);
			}

			@Override
			public int x() {
				return getLocation().x();
			}

			@Override
			public int y() {
				return getLocation().y();
			}
		}
	}
}