/*******************************************************************************
 * Copyright (c) 2015, 2017 THALES GLOBAL SERVICES 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:
 *    Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.sirius.diagram.ui.internal.edit.parts.locator;

import java.util.List;

import org.eclipse.draw2d.ConnectionLocator;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.Straight;
import org.eclipse.draw2d.geometry.Transform;
import org.eclipse.draw2d.geometry.Vector;
import org.eclipse.gmf.runtime.diagram.ui.editparts.LabelEditPart;
import org.eclipse.gmf.runtime.diagram.ui.internal.util.LabelViewConstants;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.PointListUtilities;
import org.eclipse.gmf.runtime.notation.Bounds;
import org.eclipse.sirius.diagram.ui.business.internal.bracket.locators.BracketLabelLocator;
import org.eclipse.sirius.diagram.ui.internal.edit.parts.DEdgeBeginNameEditPart;
import org.eclipse.sirius.diagram.ui.internal.edit.parts.DEdgeEndNameEditPart;
import org.eclipse.sirius.diagram.ui.internal.edit.parts.DEdgeNameEditPart;
import org.eclipse.sirius.diagram.ui.part.SiriusVisualIDRegistry;
import org.eclipse.sirius.ext.base.Option;
import org.eclipse.sirius.ext.base.Options;

import com.google.common.base.Preconditions;

/**
 * Utility class used to compute the position of a label according to its edge
 * move (old points and new points list).
 *
 * @author <a href="mailto:laurent.fasani@obeo.fr">Laurent Fasani</a>
 * @author <a href="mailto:laurent.redor@obeo.fr">Laurent Redor</a>
 */
public class EdgeLabelQuery {

    private final static double DISTANCE_TOLERANCE = 0.001;

    /** Status for {@link #getSameLineStatus(Vector, LineSeg)} method. */
    private static final int NOT_ON_SAME_LINE = 0;

    /** Status for {@link #getSameLineStatus(Vector, LineSeg)} method. */
    private static final int ON_SAME_LINE_SAME_DIRECTION = 1;

    /** Status for {@link #getSameLineStatus(Vector, LineSeg)} method. */
    private static final int ON_SAME_LINE_OPPOSITE_DIRECTION = 2;

    /** BendPoint list before the edge modification. */
    private PointList oldBendPointList;

    /** BendPoint list corresponding to the edge modification. */
    private PointList newBendPointList;

    /** The routing status of edge on which the label is. */
    private boolean isEdgeWithObliqueRoutingStyle;

    /** The old offset of the label */
    private Point oldLabelOffset;

    /**
     * The keyPoint of the label (
     * {@link org.eclipse.gmf.runtime.diagram.ui.editparts.LabelEditPart#getKeyPoint()}
     * ).
     */
    private Integer keyPoint;

    private List<LineSeg> oldEdgeSegments;

    private List<LineSeg> newEdgeSegments;

    /**
     * True if the parent's label is a bracketEdge (specific locator for center
     * label and possibility to rotate the middle segment), false otherwise.
     */
    private boolean isOnBracketEdge;

    /** The size of the label. */
    private Dimension labelSize;

    /**
     * Return the default snap back position according to the keyPoint of the
     * label.
     *
     * @param keyPoint
     *            The keyPoint of the label (
     *            {@link org.eclipse.gmf.runtime.diagram.ui.editparts.LabelEditPart#getKeyPoint()}
     *            ).
     * @return the default snap back position according to the keyPoint.
     */
    public static Point getSnapBackPosition(Integer keyPoint) {
        int percentage = getLocation(keyPoint);
        Point snapBackPosition;
        if (LabelViewConstants.SOURCE_LOCATION == percentage) {
            snapBackPosition = LabelEditPart.getSnapBackPosition(SiriusVisualIDRegistry.getType(DEdgeBeginNameEditPart.VISUAL_ID));
        } else if (LabelViewConstants.TARGET_LOCATION == percentage) {
            snapBackPosition = LabelEditPart.getSnapBackPosition(SiriusVisualIDRegistry.getType(DEdgeEndNameEditPart.VISUAL_ID));
        } else {
            snapBackPosition = LabelEditPart.getSnapBackPosition(SiriusVisualIDRegistry.getType(DEdgeNameEditPart.VISUAL_ID));
        }
        return snapBackPosition;
    }

    /**
     * Calculates the label offset from the reference point given the label
     * center and a points list.<BR>
     * This is another implementation of
     * {@link org.eclipse.gmf.runtime.diagram.ui.internal.figures.LabelHelper#offsetFromRelativeCoordinate(org.eclipse.draw2d.IFigure, org.eclipse.draw2d.geometry.Rectangle, Point)}
     *
     * @param labelCenter
     *            the label center for the <code>IFigure</code> to calculate the
     *            offset for
     * @param points
     *            the <code>PointList</code> of the edge that contains the
     *            label. The label offset is relative to this
     *            <code>PointList</code>.
     * @param ref
     *            the <code>Point</code> that is the reference point that the
     *            offset is based on.
     * @return a <code>Point</code> which represents a value offset from the
     *         <code>ref</code> point oriented based on the nearest line
     *         segment.
     */
    public static Point offsetFromRelativeCoordinate(Point labelCenter, PointList points, Point ref) {
        Vector fromAnchorToLabelCenterPointVector = new Vector(labelCenter.x - ref.x, labelCenter.y - ref.y);
        @SuppressWarnings("rawtypes")
        List lineSegments = PointListUtilities.getLineSegments(points);
        LineSeg segmentContainingLabelAnchor = PointListUtilities.getNearestSegment(lineSegments, ref.x, ref.y);
        Vector rotatedVector = getRotatedVector(fromAnchorToLabelCenterPointVector, segmentContainingLabelAnchor, false);

        return new PrecisionPoint(rotatedVector.x, rotatedVector.y);
    }

    /**
     * Calculates the relative coordinate that is equivalent to the offset from
     * the reference point, that can be used to set the label center location.
     * <BR>
     *
     * This is another implementation of
     * {@link org.eclipse.gmf.runtime.diagram.ui.internal.figures.LabelHelper#relativeCoordinateFromOffset(org.eclipse.draw2d.IFigure, Point, Point)}
     * . See bugzilla 476305 for more detail.
     *
     * @param points
     *            the <code>PointList</code> of the edge that contains the
     *            label. The label offset is relative to this
     *            <code>PointList</code>.
     * @param ref
     *            a <code>Point</code> located on the parent which the offset
     *            value is relative to.
     * @param offset
     *            a <code>Point</code> which represents a value offset from the
     *            <code>ref</code> point oriented based on the nearest line
     *            segment.
     * @return a <code>Point</code> that is the relative coordinate of the label
     *         that can be used to set it's center location.
     */
    public static Point relativeCenterCoordinateFromOffset(PointList points, Point ref, Point offset) {
        Vector fromAnchorToLabelCenterPointVector = new Vector(offset.x, offset.y);
        @SuppressWarnings("rawtypes")
        List lineSegments = PointListUtilities.getLineSegments(points);
        LineSeg segmentContainingLabelAnchor = PointListUtilities.getNearestSegment(lineSegments, ref.x, ref.y);
        Vector rotatedVector = getRotatedVector(fromAnchorToLabelCenterPointVector, segmentContainingLabelAnchor, true);

        return new PrecisionPoint(ref.x + rotatedVector.x, ref.y + rotatedVector.y);
    }

    /**
     * Default constructor.
     *
     * @param oldBendPointList
     *            Bendpoint list before the edge modification
     * @param newBendPointList
     *            Bendpoint list after the edge modification
     * @param isEdgeWithObliqueRoutingStyle
     *            status of the edge from which to get the previous position of
     *            the bendpoints and from which to get the three labels
     * @param oldLabelOffset
     *            The old offset.
     * @param labelSize
     *            The size of the label
     * @param keyPoint
     *            The keyPoint of the label (
     *            {@link org.eclipse.gmf.runtime.diagram.ui.editparts.LabelEditPart#getKeyPoint()}
     *            )
     * @param isOnBracketEdge
     *            True if the parent's label is a bracketEdge (specific locator
     *            for center label and possibility to rotate the middle
     *            segment), false otherwise.
     */
    // @SuppressWarnings("unchecked")
    public EdgeLabelQuery(PointList oldBendPointList, PointList newBendPointList, boolean isEdgeWithObliqueRoutingStyle, Point oldLabelOffset, Dimension labelSize, Integer keyPoint,
            boolean isOnBracketEdge) {
        this.isEdgeWithObliqueRoutingStyle = isEdgeWithObliqueRoutingStyle;

        this.oldBendPointList = oldBendPointList;
        Preconditions.checkState(newBendPointList.size() > 0);
        this.newBendPointList = newBendPointList;
        this.oldLabelOffset = oldLabelOffset;
        this.labelSize = labelSize;
        this.keyPoint = keyPoint;
        this.isOnBracketEdge = isOnBracketEdge;

        // compute lineSegments from bendPoints
        oldEdgeSegments = PointListUtilities.getLineSegments(oldBendPointList);
        newEdgeSegments = PointListUtilities.getLineSegments(newBendPointList);
    }

    /**
     * Calculate the new GMF label offset: the label offset defines the position
     * of the label compared to labelAnchor point. <br>
     * The new Label offset is computed taking into account:<br>
     * <ul>
     * <li>the label anchor point move (start, center or end)</li>
     * <li>the orientation of the segment owning the label anchor. Indeed, the
     * label offset is displayed by draw2D relatively to the direction of the
     * edge segment including the anchor of the label</li>
     * <li>the expected move of the label according to the functional
     * specification</li>
     * </ul>
     * .
     *
     * @return the new offset of the label
     */
    public Point calculateGMFLabelOffset() {
        if (areBendpointsIdentical() && areSegmentsValid()) {
            return oldLabelOffset;
        } else {
            int anchorPointRatio = getLocation(keyPoint);
            Point oldAnchorPoint = getAnchorPoint(oldBendPointList, anchorPointRatio);
            Point oldLabelCenter = relativeCenterCoordinateFromOffset(oldBendPointList, oldAnchorPoint, oldLabelOffset);

            Point newAnchorPoint = getAnchorPoint(newBendPointList, anchorPointRatio);

            Point newLabelCenter = calculateNewCenterLocation(oldLabelCenter, getStandardLabelCenterLocation(newBendPointList, keyPoint));
            return offsetFromRelativeCoordinate(newLabelCenter, newBendPointList, newAnchorPoint);
        }
    }

    private Point getAnchorPoint(PointList pointList, int anchorPointRatio) {
        if (isOnBracketEdge && LabelViewConstants.MIDDLE_LOCATION == anchorPointRatio) {
            return BracketLabelLocator.getReferencePoint(pointList);
        } else {
            return PointListUtilities.calculatePointRelativeToLine(pointList, 0, anchorPointRatio, true);
        }
    }

    /**
     * Check if all segments of new and old points are valid (no segment with
     * same origin and terminus).
     *
     * @return true if segments are valid, false otherwise.
     */
    private boolean areSegmentsValid() {
        boolean areSegmentsValid = true;
        for (LineSeg lineSeg : newEdgeSegments) {
            if (lineSeg.getOrigin().equals(lineSeg.getTerminus())) {
                areSegmentsValid = false;
                break;
            }
        }

        if (areSegmentsValid) {
            for (LineSeg lineSeg : oldEdgeSegments) {
                if (lineSeg.getOrigin().equals(lineSeg.getTerminus())) {
                    areSegmentsValid = false;
                    break;
                }
            }
        }
        return areSegmentsValid;
    }

    /**
     * Check if the old points and the new one are the same.
     *
     * @return true if the old points are the same as the new, false otherwise.
     */
    private boolean areBendpointsIdentical() {
        boolean areBendpointsIdentical = true;
        if (newBendPointList.size() == oldBendPointList.size()) {
            for (int i = 0; i < newBendPointList.size(); i++) {
                Point newPoint = newBendPointList.getPoint(i);
                Point oldPoint = oldBendPointList.getPoint(i);
                if (!newPoint.equals(oldPoint)) {
                    areBendpointsIdentical = false;
                    break;
                }
            }
        } else {
            areBendpointsIdentical = false;
        }

        return areBendpointsIdentical;
    }

    /**
     * Calculate the new center location of the label according to functional
     * specification.
     *
     * @param oldCenterLabel
     *            The old center location of the label.
     * @param newDefaultLocation
     *            The standard center location according to the label keyPoint (
     *            {@link org.eclipse.gmf.runtime.diagram.ui.editparts.LabelEditPart#getKeyPoint()}
     *            and the default snap back position (
     *            {@link LabelEditPart#getSnapBackPosition(String)}.
     * @return
     */
    private Point calculateNewCenterLocation(Point oldCenterLabel, Point newDefaultLocation) {
        Vector fromOldToNewCenterVector = null;

        // Step 1 : Calculate old reference point (the nearest point on the edge
        // from the center of the label).
        LineSeg oldNearestSeg = PointListUtilities.getNearestSegment(oldEdgeSegments, oldCenterLabel.x, oldCenterLabel.y);
        Point oldNearestPoint = oldNearestSeg.perpIntersect(oldCenterLabel.x, oldCenterLabel.y);

        // Step 2 : Is there a new segment and an old segment on the same line?
        // Case of segment increased or decreased (and eventually inverted)
        Option<Vector> fromOldToNewRefPoint = getVectorFromOldToNewForSegmentsOnSameLine(oldNearestSeg, oldNearestPoint, oldCenterLabel);
        if (fromOldToNewRefPoint.some()) {
            // In this case the vector for the reference point is the same than
            // for the label center.
            fromOldToNewCenterVector = fromOldToNewRefPoint.get();
        } else { // No identical segment line has been found
            // RECTILINEAR and TREE routing
            if (!isEdgeWithObliqueRoutingStyle) {
                // Get projection of oldNearestPoint on newSegments along
                // oldRefVector
                LineSeg oldRefVectorIntoSegment = null;
                if (oldCenterLabel.equals(oldNearestPoint)) {
                    // Get a segment perpendicular to oldRefSegment going
                    // through oldNearestPoint
                    oldRefVectorIntoSegment = new LineSeg(oldNearestPoint, new PrecisionPoint(oldNearestPoint.x + (oldNearestSeg.getOrigin().y - oldNearestSeg.getTerminus().y),
                            oldNearestPoint.y - (oldNearestSeg.getOrigin().x - oldNearestSeg.getTerminus().x)));
                } else {
                    oldRefVectorIntoSegment = new LineSeg(oldCenterLabel, oldNearestPoint);
                }

                // Is there a new segment at the same index as old segment and
                // with same axis? Case of rectilinear segment move.
                fromOldToNewCenterVector = getVectorForSegmentMoveCase(oldNearestSeg, oldNearestPoint, oldCenterLabel);
                if (fromOldToNewCenterVector == null && isOnBracketEdge) {
                    // Is there a new segment at the same index as old segment
                    // and with opposite axis? Case of change orientation of the
                    // bracket edge
                    fromOldToNewCenterVector = getVectorForBracketEdgeOrientationChangeCase(oldNearestSeg, oldNearestPoint, oldCenterLabel);
                }
                if (fromOldToNewCenterVector == null) {
                    for (LineSeg lineSeg : newEdgeSegments) {
                        PointList linesIntersections = oldRefVectorIntoSegment.getLinesIntersections(lineSeg);
                        // intersection should be, at more, one point
                        if (linesIntersections.size() == 1 && lineSeg.distanceToPoint(linesIntersections.getPoint(0).x, linesIntersections.getPoint(0).y) <= Math.sqrt(2)) {
                            Vector tempLabelMove = new Vector(linesIntersections.getPoint(0).x - oldNearestPoint.x, linesIntersections.getPoint(0).y - oldNearestPoint.y);
                            if (fromOldToNewCenterVector == null || tempLabelMove.getLength() < fromOldToNewCenterVector.getLength()) {
                                fromOldToNewCenterVector = tempLabelMove;
                            }
                        }
                    }
                    // Compare the minimalLabelMove with the default location.
                    // If the default location is nearer reset the labelMove.
                    Vector fromOldNearestPointToStandardLocation = new Vector(newDefaultLocation.x - oldNearestPoint.x, newDefaultLocation.y - oldNearestPoint.y);
                    if (fromOldToNewCenterVector == null || fromOldNearestPointToStandardLocation.getLength() < fromOldToNewCenterVector.getLength()) {
                        fromOldToNewCenterVector = null;
                    }
                }
            } else if (newEdgeSegments.size() == oldEdgeSegments.size()) {
                // The newNearestSegment as the same index in
                // newEdgeSegments than oldNearestSegment in oldEdgeSegments
                LineSeg newRefSeg = newEdgeSegments.get(oldEdgeSegments.indexOf(oldNearestSeg));
                // Keep ratio on segment for newRefPoint
                double oldRatio = oldNearestSeg.projection(oldCenterLabel.x, oldCenterLabel.y);
                Point newRefPoint = new PrecisionPoint(newRefSeg.getOrigin().x + oldRatio * (newRefSeg.getTerminus().x - newRefSeg.getOrigin().x),
                        newRefSeg.getOrigin().y + oldRatio * (newRefSeg.getTerminus().y - newRefSeg.getOrigin().y));
                fromOldToNewCenterVector = new Vector(newRefPoint.x - oldNearestPoint.x, newRefPoint.y - oldNearestPoint.y);

            }
        }
        if (fromOldToNewCenterVector == null) {
            return newDefaultLocation;
        } else {
            return oldCenterLabel.getTranslated(fromOldToNewCenterVector.x, fromOldToNewCenterVector.y);
        }
    }

    /**
     * Check if we are in case of a rectilinear segment move: there is a new
     * segment at the same index as old nearest segment and with the same axis.
     * Return the corresponding vector from old to new center in this case, null
     * otherwise.
     *
     * @param oldNearestSeg
     *            The segment that is the nearest from the center of the label
     *            in the old points list.
     * @return the corresponding vector from old to new center in case of
     *         rectilinear segment move, null otherwise.
     */
    private Vector getVectorForSegmentMoveCase(LineSeg oldNearestSeg, Point oldNearestPoint, Point oldCenterLabel) {
        Vector fromOldToNewCenterVector = null;
        if (newEdgeSegments.size() == oldEdgeSegments.size()) {
            int index = oldEdgeSegments.indexOf(oldNearestSeg);
            LineSeg newNearestSegment = newEdgeSegments.get(index);
            if (oldNearestSeg.isHorizontal() == newNearestSegment.isHorizontal()) {
                Vector oldVector = new Vector(oldNearestSeg.getTerminus().x - oldNearestSeg.getOrigin().x, oldNearestSeg.getTerminus().y - oldNearestSeg.getOrigin().y);
                Vector newVector = new Vector(newNearestSegment.getTerminus().x - newNearestSegment.getOrigin().x, newNearestSegment.getTerminus().y - newNearestSegment.getOrigin().y);
                boolean oppositeDirection = false;
                if (oldVector.getLength() != 0 && newVector.getLength() != 0) {
                    oppositeDirection = oldVector.getAngle(newVector) == 180;
                }
                fromOldToNewCenterVector = applyOldRatioOnNewSegment(oldNearestSeg, oldNearestPoint, oldCenterLabel, newNearestSegment, oppositeDirection, false);
            }
        }
        return fromOldToNewCenterVector;
    }

    /**
     * Check if we are in case of a orientation segment change: there is a new
     * segment at the same index as old nearest segment and with apposite axis.
     * Return the corresponding vector from old to new center in this case, null
     * otherwise.
     *
     * @param oldNearestSeg
     *            The segment that is the nearest from the center of the label
     *            in the old points list.
     * @return the corresponding vector from old to new center in case of
     *         orientation segment change, null otherwise.
     */
    private Vector getVectorForBracketEdgeOrientationChangeCase(LineSeg oldNearestSeg, Point oldNearestPoint, Point oldCenterLabel) {
        Vector fromOldToNewCenterVector = null;
        if (newEdgeSegments.size() == oldEdgeSegments.size()) {
            int index = oldEdgeSegments.indexOf(oldNearestSeg);
            LineSeg newNearestSegment = newEdgeSegments.get(index);
            if (oldNearestSeg.isHorizontal() != newNearestSegment.isHorizontal()) {
                Vector oldVector = new Vector(oldNearestSeg.getTerminus().x - oldNearestSeg.getOrigin().x, oldNearestSeg.getTerminus().y - oldNearestSeg.getOrigin().y);
                Vector newVector = new Vector(newNearestSegment.getTerminus().x - newNearestSegment.getOrigin().x, newNearestSegment.getTerminus().y - newNearestSegment.getOrigin().y);
                double angleInDegree = Math.toDegrees(angleBetween2Lines(oldVector, newVector));
                fromOldToNewCenterVector = applyOldRatioOnNewOrthogonalSegment(oldNearestSeg, oldNearestPoint, oldCenterLabel, newNearestSegment, angleInDegree == 90 || angleInDegree == -270);
            }
        }
        return fromOldToNewCenterVector;
    }

    private Option<Vector> getVectorFromOldToNewForSegmentsOnSameLine(LineSeg oldRefSeg, Point oldRefPoint, Point oldCenterLabel) {
        Option<Vector> result = Options.newNone();
        LineSeg newSegmentOnSameLineWithSameDirection = null;
        LineSeg newSegmentOnSameLineWithOppositeDirection = null;
        // Firstly, for points lists with same nb of segments, search if the
        // vector, at
        // the same index, is on the same line
        int sameLineStatus = NOT_ON_SAME_LINE;
        if (newEdgeSegments.size() == oldEdgeSegments.size()) {
            LineSeg newSegAtSameIndex = newEdgeSegments.get(oldEdgeSegments.indexOf(oldRefSeg));
            sameLineStatus = getSameLineStatus(oldRefSeg, newSegAtSameIndex);
            if (ON_SAME_LINE_SAME_DIRECTION == sameLineStatus) {
                newSegmentOnSameLineWithSameDirection = newSegAtSameIndex;
            } else if (ON_SAME_LINE_OPPOSITE_DIRECTION == sameLineStatus) {
                newSegmentOnSameLineWithOppositeDirection = newSegAtSameIndex;
            }
        }
        if (NOT_ON_SAME_LINE == sameLineStatus) {
            // If this is not the case search on all new segments.
            for (LineSeg newSeg : newEdgeSegments) {
                sameLineStatus = getSameLineStatus(oldRefSeg, newSeg);
                if (ON_SAME_LINE_SAME_DIRECTION == sameLineStatus) {
                    newSegmentOnSameLineWithSameDirection = newSeg;
                    break;
                } else if (ON_SAME_LINE_OPPOSITE_DIRECTION == sameLineStatus) {
                    newSegmentOnSameLineWithOppositeDirection = newSeg;
                    // Continue to search a potential segment in the same
                    // direction.
                }
            }
        }

        LineSeg newRefSeg = newSegmentOnSameLineWithSameDirection;
        if (newRefSeg == null) {
            newRefSeg = newSegmentOnSameLineWithOppositeDirection;
        }

        if (newRefSeg != null) {
            result = Options.newSome(applyOldRatioOnNewSegment(oldRefSeg, oldRefPoint, oldCenterLabel, newRefSeg, newSegmentOnSameLineWithOppositeDirection != null, true));
        }
        return result;
    }

    /**
     * Check if the <code>segment</code> is on the same line as the
     * <code>referenceSegment</code> and if it is in the same direction or not.
     *
     * @param referenceSegment
     *            The reference segment.
     * @param segment
     *            The segment to test
     * @return one of these statuses {@link #NOT_ON_SAME_LINE},
     *         {@link #ON_SAME_LINE_SAME_DIRECTION} or
     *         {@link #ON_SAME_LINE_OPPOSITE_DIRECTION}.
     */
    private int getSameLineStatus(LineSeg referenceSegment, LineSeg segment) {
        int result = NOT_ON_SAME_LINE;
        if (segment.length() != 0) {
            Vector referenceVector = new Vector(referenceSegment.getTerminus().x - referenceSegment.getOrigin().x, referenceSegment.getTerminus().y - referenceSegment.getOrigin().y);
            Vector vector = new Vector(segment.getTerminus().x - segment.getOrigin().x, segment.getTerminus().y - segment.getOrigin().y);
            if (referenceVector.getLength() == 0 || vector.getLength() == 0) {
                result = ON_SAME_LINE_SAME_DIRECTION;
            } else {
                double angle = referenceVector.getAngle(vector);
                if (angle == 0 || angle == 180) {
                    Straight straight = new Straight(new PrecisionPoint(segment.getOrigin()), new PrecisionPoint(segment.getTerminus()));
                    double distToInfiniteLine = straight.getDistance(new Vector(referenceSegment.getOrigin().x, referenceSegment.getOrigin().y));
                    if (distToInfiniteLine < DISTANCE_TOLERANCE) {
                        if (angle == 180) {
                            result = ON_SAME_LINE_OPPOSITE_DIRECTION;
                        } else {
                            result = ON_SAME_LINE_SAME_DIRECTION;
                        }
                    }
                }
            }
        }
        return result;
    }

    private Vector applyOldRatioOnNewSegment(LineSeg oldRefSeg, Point oldRefPoint, Point oldCenterLabel, LineSeg newRefSeg, boolean oppositeDirection, boolean sameLine) {
        Vector result;
        double newRatio = newRefSeg.projection(oldCenterLabel.x, oldCenterLabel.y);
        if (sameLine && newRatio >= 0 && newRatio <= 1) {
            // If the orthogonal projection is inside segment (between 0 and
            // 1), the reference point does not move.
            result = new Vector(0, 0);
        } else {
            Point newRefPoint;
            double oldRatio = oldRefSeg.projection(oldCenterLabel.x, oldCenterLabel.y);
            if (!oppositeDirection) {
                newRefPoint = new PrecisionPoint(newRefSeg.getOrigin().x + oldRatio * (newRefSeg.getTerminus().x - newRefSeg.getOrigin().x),
                        newRefSeg.getOrigin().y + oldRatio * (newRefSeg.getTerminus().y - newRefSeg.getOrigin().y));
            } else {
                newRefPoint = new PrecisionPoint(newRefSeg.getOrigin().x - oldRatio * (newRefSeg.getOrigin().x - newRefSeg.getTerminus().x),
                        newRefSeg.getOrigin().y - oldRatio * (newRefSeg.getOrigin().y - newRefSeg.getTerminus().y));
            }
            if (!sameLine && newRatio >= 0 && newRatio <= 1) {
                // If the orthogonal projection is inside segment (between 0 and
                // 1), we keep the oldRefPoint one axis
                if (newRefSeg.isHorizontal()) {
                    newRefPoint.setX(oldRefPoint.x);
                } else {
                    newRefPoint.setY(oldRefPoint.y);
                }
            }
            Vector vectorFromOldToNewRefPoint = new Vector(newRefPoint.x - oldRefPoint.x, newRefPoint.y - oldRefPoint.y);
            if (oldRatio >= 0 && oldRatio <= 1) {
                // Keep ratio on segment for newRefPoint (if it was
                // previously inside segment)
                result = vectorFromOldToNewRefPoint;
            } else {
                // If the label is previously outside of the segment, we
                // keep the shortest point (new or old one).
                Point potentialNewCenter = oldCenterLabel.getTranslated(vectorFromOldToNewRefPoint.x, vectorFromOldToNewRefPoint.y);
                if ((newRatio > 1 && newRatio < newRefSeg.projection(potentialNewCenter.x, potentialNewCenter.y))
                        || (newRatio < 0 && newRatio > newRefSeg.projection(potentialNewCenter.x, potentialNewCenter.y))) {
                    result = new Vector(0, 0);
                } else {
                    result = vectorFromOldToNewRefPoint;
                }
            }
        }
        return result;
    }

    private Vector applyOldRatioOnNewOrthogonalSegment(LineSeg oldRefSeg, Point oldRefPoint, Point oldCenterLabel, LineSeg newRefSeg, boolean is90Angle) {
        double oldRatio = oldRefSeg.projection(oldCenterLabel.x, oldCenterLabel.y);
        Transform rotateTransform = new Transform();
        // Get the new reference point and the rotation to apply
        Point newRefPoint;
        if (is90Angle) {
            // As GMF coordinates system is reversed (y positive orientation is
            // from top to bottom), we reverse the rotation to apply
            rotateTransform.setRotation(Math.toRadians(-90));
            if (0 <= oldRatio && oldRatio <= 1) {
                // Apply same ratio on the new segment to compute the new
                // reference point
                newRefPoint = new PrecisionPoint(newRefSeg.getOrigin().x - oldRatio * (newRefSeg.getOrigin().x - newRefSeg.getTerminus().x),
                        newRefSeg.getOrigin().y - oldRatio * (newRefSeg.getOrigin().y - newRefSeg.getTerminus().y));
            } else if (oldRatio > 1) {
                // Just apply the vector from old terminus to old reference
                // point to the new terminus
                Vector vectorFromOldTerminusToOldRefPoint = new Vector(oldRefPoint.x - oldRefSeg.getTerminus().x, oldRefPoint.y - oldRefSeg.getTerminus().y);
                Point vectorFromNewTerminusToNewRefPoint = rotateTransform.getTransformed(vectorFromOldTerminusToOldRefPoint.toPoint());
                newRefPoint = newRefSeg.getTerminus().getTranslated(vectorFromNewTerminusToNewRefPoint);
            } else {
                Vector vectorFromOldOriginToOldRefPoint = new Vector(oldRefPoint.x - oldRefSeg.getOrigin().x, oldRefPoint.y - oldRefSeg.getOrigin().y);
                Point vectorFromNewOriginToNewRefPoint = rotateTransform.getTransformed(vectorFromOldOriginToOldRefPoint.toPoint());
                newRefPoint = newRefSeg.getOrigin().getTranslated(vectorFromNewOriginToNewRefPoint);
            }
        } else {
            // As GMF coordinates system is reversed (y positive orientation is
            // from top to bottom), we reverse the rotation to apply
            rotateTransform.setRotation(Math.toRadians(90));
            if (0 <= oldRatio && oldRatio <= 1) {
                // Apply same ratio on the new segment to compute the new
                // reference point (but inverse the origin and the terminus)
                newRefPoint = new PrecisionPoint(newRefSeg.getOrigin().x + oldRatio * (newRefSeg.getTerminus().x - newRefSeg.getOrigin().x),
                        newRefSeg.getOrigin().y + oldRatio * (newRefSeg.getTerminus().y - newRefSeg.getOrigin().y));
            } else if (oldRatio > 1) {
                // Just apply the vector from old terminus to old reference
                // point to the new terminus
                Vector vectorFromOldTerminusToOldRefPoint = new Vector(oldRefPoint.x - oldRefSeg.getTerminus().x, oldRefPoint.y - oldRefSeg.getTerminus().y);
                Point vectorFromNewTerminusToNewRefPoint = rotateTransform.getTransformed(vectorFromOldTerminusToOldRefPoint.toPoint());
                newRefPoint = newRefSeg.getTerminus().getTranslated(vectorFromNewTerminusToNewRefPoint);
            } else {
                Vector vectorFromOldOriginToOldRefPoint = new Vector(oldRefPoint.x - oldRefSeg.getOrigin().x, oldRefPoint.y - oldRefSeg.getOrigin().y);
                Point vectorFromNewOriginToNewRefPoint = rotateTransform.getTransformed(vectorFromOldOriginToOldRefPoint.toPoint());
                newRefPoint = newRefSeg.getOrigin().getTranslated(vectorFromNewOriginToNewRefPoint);
            }
        }
        Vector vectorFromOldRefPointToOldCenterLabel = new Vector(oldCenterLabel.x - oldRefPoint.x, oldCenterLabel.y - oldRefPoint.y);
        Point fromNewRefPointToNewCenterLabel = rotateTransform.getTransformed(vectorFromOldRefPointToOldCenterLabel.toPoint());
        // Adjust the vector to apply according to orientation change (width
        // becomes height and conversely)
        if (newRefSeg.isHorizontal()) {
            if (0 <= oldRatio && oldRatio <= 1) {
                int invertedWidthHeight = labelSize.width - labelSize.height;
                if (newRefSeg.getOrigin().x > newRefSeg.getTerminus().x) {
                    invertedWidthHeight = -invertedWidthHeight;
                }
                fromNewRefPointToNewCenterLabel.translate(0, invertedWidthHeight / 2);
            } else if (oldRatio > 1) {
                int invertedWidthHeight = labelSize.width - labelSize.height;
                if (newRefSeg.getOrigin().x > newRefSeg.getTerminus().x) {
                    invertedWidthHeight = -invertedWidthHeight;
                }
                fromNewRefPointToNewCenterLabel.translate(invertedWidthHeight / 2, 0);
            } else {
                fromNewRefPointToNewCenterLabel.translate(0, 0);
                int invertedWidthHeight = labelSize.width - labelSize.height;
                if (newRefSeg.getOrigin().x < newRefSeg.getTerminus().x) {
                    invertedWidthHeight = -invertedWidthHeight;
                }
                fromNewRefPointToNewCenterLabel.translate(invertedWidthHeight / 2, 0);
            }
        } else {
            if (0 <= oldRatio && oldRatio <= 1) {
                int invertedWidthHeight = labelSize.width - labelSize.height;
                if (newRefSeg.getOrigin().y > newRefSeg.getTerminus().y) {
                    invertedWidthHeight = -invertedWidthHeight;
                }
                fromNewRefPointToNewCenterLabel.translate(invertedWidthHeight / 2, 0);
            } else if (oldRatio > 1) {
                int invertedWidthHeight = labelSize.height - labelSize.width;
                if (newRefSeg.getOrigin().y > newRefSeg.getTerminus().y) {
                    invertedWidthHeight = -invertedWidthHeight;
                }
                fromNewRefPointToNewCenterLabel.translate(0, invertedWidthHeight / 2);
            } else {
                int invertedWidthHeight = labelSize.height - labelSize.width;
                if (newRefSeg.getOrigin().y < newRefSeg.getTerminus().y) {
                    invertedWidthHeight = -invertedWidthHeight;
                }
                fromNewRefPointToNewCenterLabel.translate(0, invertedWidthHeight / 2);
            }
        }
        // Apply the rotated vector on new reference point to have the new
        // center
        Point newCenterLabel = newRefPoint.getTranslated(fromNewRefPointToNewCenterLabel);
        // Compute the vector from old center to new center
        return new Vector(newCenterLabel.x - oldCenterLabel.x, newCenterLabel.y - oldCenterLabel.y);
    }

    /**
     * Get the rotated vector according to the segment orientation.
     *
     * @param vector
     *            vector to be rotated
     * @param segment
     *            reference segment
     * @param inverseRotation
     *            if true, inverse rotation
     * @return the rotated Vector
     */
    private static Vector getRotatedVector(Vector vector, LineSeg segment, boolean inverseRotation) {
        Vector result = new Vector(vector.x, vector.y);
        if (vector.x != 0 || vector.y != 0) {
            double angle = angleBetween2Lines(new LineSeg(new Point(0, 0), new Point(1, 0)), segment) * (inverseRotation ? -1 : 1);
            Transform rotateTransform = new Transform();
            rotateTransform.setRotation(angle);
            Point rotatedPoint = rotateTransform.getTransformed(vector.toPoint());

            result.x = rotatedPoint.x;
            result.y = rotatedPoint.y;
        }
        return result;
    }

    /**
     * Get the signed angle between two segments.
     *
     * @param line1
     * @param line2
     * @return the signed angle in radian.
     */
    private static double angleBetween2Lines(LineSeg line1, LineSeg line2) {
        if (line1 == null || line2 == null) {
            return 0;
        }
        double angle1 = Math.atan2(line1.getOrigin().y - line1.getTerminus().y, line1.getOrigin().x - line1.getTerminus().x);
        double angle2 = Math.atan2(line2.getOrigin().y - line2.getTerminus().y, line2.getOrigin().x - line2.getTerminus().x);
        return angle1 - angle2;
    }

    /**
     * Get the signed angle between two vectors.
     *
     * @param vector1
     *            The first vector
     * @param vector2
     *            The second vector
     * @return the signed angle in radian.
     */
    private static double angleBetween2Lines(Vector vector1, Vector vector2) {
        if (vector1 == null || vector2 == null) {
            return 0;
        }
        double angle1 = Math.atan2(vector1.y, vector1.x);
        double angle2 = Math.atan2(vector2.y, vector2.x);
        return angle1 - angle2;
    }

    /**
     * Get the standard center location according to the label keyPoint (
     * {@link org.eclipse.gmf.runtime.diagram.ui.editparts.LabelEditPart#getKeyPoint()}
     * ) and the default snap back position (
     * {@link LabelEditPart#getSnapBackPosition(String)}
     *
     * @param pointsList
     *            The points of the edge of the label.
     * @param keyPoint
     *            The keyPoint of the label (
     *            {@link org.eclipse.gmf.runtime.diagram.ui.editparts.LabelEditPart#getKeyPoint()}
     *            ).
     * @return The center of the label {@link Bounds} if this label is located
     *         by default.
     */
    private Point getStandardLabelCenterLocation(PointList pointsList, Integer keyPoint) {
        int percentage = getLocation(keyPoint);
        Point newAnchorPoint = getAnchorPoint(pointsList, percentage);
        Point snapBackPosition = getSnapBackPosition(keyPoint);
        Point standardLabelCenter = newAnchorPoint.getTranslated(snapBackPosition);
        return standardLabelCenter;
    }

    /**
     * Get the location among {@link LabelViewConstants} constants where to
     * relocate the label figure.
     *
     * @return the location among {@link LabelViewConstants} constants
     */
    private static int getLocation(Integer keyPoint) {
        int location = LabelViewConstants.MIDDLE_LOCATION;
        switch (keyPoint) {
        case ConnectionLocator.SOURCE:
            location = LabelViewConstants.TARGET_LOCATION;
            break;
        case ConnectionLocator.TARGET:
            location = LabelViewConstants.SOURCE_LOCATION;
            break;
        case ConnectionLocator.MIDDLE:
            location = LabelViewConstants.MIDDLE_LOCATION;
            break;
        default:
            location = LabelViewConstants.MIDDLE_LOCATION;
            break;
        }
        return location;
    }
}