/*******************************************************************************
 * Copyright (c) 2017 THALES GLOBAL SERVICES.
 * 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.business.internal.migration;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil;
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.figures.BaseSlidableAnchor;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.PointListUtilities;
import org.eclipse.gmf.runtime.notation.Anchor;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.IdentityAnchor;
import org.eclipse.gmf.runtime.notation.Location;
import org.eclipse.gmf.runtime.notation.Node;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.RelativeBendpoints;
import org.eclipse.gmf.runtime.notation.datatype.RelativeBendpoint;
import org.eclipse.sirius.business.api.migration.AbstractRepresentationsFileMigrationParticipant;
import org.eclipse.sirius.diagram.DDiagram;
import org.eclipse.sirius.diagram.DiagramPlugin;
import org.eclipse.sirius.diagram.ui.business.api.query.DDiagramGraphicalQuery;
import org.eclipse.sirius.diagram.ui.business.api.query.NodeQuery;
import org.eclipse.sirius.diagram.ui.business.api.query.ViewQuery;
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.diagram.ui.provider.Messages;
import org.eclipse.sirius.ext.base.Option;
import org.eclipse.sirius.viewpoint.DAnalysis;
import org.eclipse.sirius.viewpoint.DView;
import org.osgi.framework.Version;

import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;

/**
 * A representation file migration to detect labels that are far from their edge
 * and reset them to their default location.
 * 
 * @author lredor
 */
@SuppressWarnings("restriction")
public class SnapBackDistantLabelsMigrationParticipant extends AbstractRepresentationsFileMigrationParticipant {

    /**
     * The Sirius version for which this migration is added.
     */
    public static final Version MIGRATION_VERSION = new Version("10.1.9.201706271200"); //$NON-NLS-1$


    /**
     * The absolute maximum x or y coordinate from which label is considered
     * distant.
     */
    private static final int LABEL_UPPER_LIMIT = 1000;

    /**
     * The absolute minimal x or y coordinate from which label is not considered
     * distant.
     */
    private static final int LABEL_LOWER_LIMIT = 250;

    /**
     * The absolute maximum x or y coordinates from which node is considered
     * with "very huge coordinates".
     */
    private static final int NODES_LIMIT = 1000000;

    /**
     * Nodes with "very huge coordinates" are relocated to location near from
     * it. This value is arbitrary. It allows to "easily" see elements with a
     * zoom of 10%.
     */
    private static final int NODES_LIMIT_MOVE = 5000;

    private static final String NEGATIVE_X_KEY = "-x"; //$NON-NLS-1$

    private static final String POSITIVE_X_KEY = "+x"; //$NON-NLS-1$

    private static final String NEGATIVE_Y_KEY = "-y"; //$NON-NLS-1$

    private static final String POSITIVE_Y_KEY = "+y"; //$NON-NLS-1$

    /**
     * Determines a setter based on an input value and a new value.
     * 
     * @author lredor
     *
     */
    public interface Setter<F, T> {
        /**
         * Set a value of type <code>F</code> with the new value <code>T</code>.
         * 
         * @param input
         *            The object to modify
         * @param newValue
         *            The new value to set one property of <code>input</code>
         */
        void set(F input, T newValue);
    }
    
    @Override
    public Version getMigrationVersion() {
        return MIGRATION_VERSION;
    }

    @Override
    protected void postLoad(DAnalysis dAnalysis, Version loadedVersion) {
        if (loadedVersion.compareTo(MIGRATION_VERSION) < 0) {
            initializeSnapBackPositionMap();

            boolean isModified = false;
            StringBuilder sb = new StringBuilder(Messages.SnapBackDistantLabelsMigrationParticipant_title);
            List<Node> distantEdgeLabels = new ArrayList<Node>();

            for (DView dView : dAnalysis.getOwnedViews()) {
                for (DDiagram dDiagram : Iterables.filter(dView.getOwnedRepresentations(), DDiagram.class)) {
                    // Search distant edge labels
                    List<Node> currentDistantEdgeLabels = getDistantEdgeLabels(dDiagram);
                    distantEdgeLabels.addAll(currentDistantEdgeLabels);

                    if (currentDistantEdgeLabels.size() > 0) {
                        isModified = true;
                        // Add information to be logged
                        if (currentDistantEdgeLabels.size() > 1) {
                            sb.append(MessageFormat.format(Messages.SnapBackDistantLabelsMigrationParticipant_severalLabelsSnapBacked, currentDistantEdgeLabels.size(), dDiagram.getName()));
                        } else {
                            sb.append(MessageFormat.format(Messages.SnapBackDistantLabelsMigrationParticipant_oneLabelSnapBacked, dDiagram.getName()));
                        }

                        // Search and fix nodes with huge coordinates.
                        boolean nodesMoved = false;
                        Map<String, Map<Node, Integer>> currentnodesWithExtremeLocation = getNodesWithExtremeLocation(dDiagram);
                        for (String key : currentnodesWithExtremeLocation.keySet()) {
                            if (NEGATIVE_X_KEY.equals(key)) {
                                nodesMoved = moveNodesX(currentnodesWithExtremeLocation.get(key), false);
                            } else if (POSITIVE_X_KEY.equals(key)) {
                                nodesMoved = moveNodesX(currentnodesWithExtremeLocation.get(key), true);
                            } else if (NEGATIVE_Y_KEY.equals(key)) {
                                nodesMoved = moveNodesY(currentnodesWithExtremeLocation.get(key), false);
                            } else {
                                nodesMoved = moveNodesY(currentnodesWithExtremeLocation.get(key), true);
                            }
                        }

                        if (nodesMoved) {
                            // Add information to be logged
                            sb.append(Messages.SnapBackDistantLabelsMigrationParticipant_nodesMoved);
                        }
                    }
                }
            }

            // Fix distant edge labels
            for (Node distantEdgeLabel : distantEdgeLabels) {
                Point offset = LabelEditPart.getSnapBackPosition(distantEdgeLabel.getType());
                if (offset != null) {
                    ViewUtil.setStructuralFeatureValue(distantEdgeLabel, NotationPackage.eINSTANCE.getLocation_X(), Integer.valueOf(offset.x));
                    ViewUtil.setStructuralFeatureValue(distantEdgeLabel, NotationPackage.eINSTANCE.getLocation_Y(), Integer.valueOf(offset.y));
                }
            }

            if (isModified) {
                DiagramPlugin.getDefault().logInfo(sb.toString());
            }
        }
    }

    /**
     * Move all nodes to a more readable location.
     * 
     * @param nodesWithExtremeLocation
     *            List of couple, node with extreme location and corresponding
     *            huge coordinate.
     * @param isPositive
     *            true if the above list of nodes concerns nodes with positive
     *            X, false if it concerns negative X
     * @return true if at least one node has been moved, false otherwise
     */
    protected boolean moveNodesX(Map<Node, Integer> nodesWithExtremeLocation, boolean isPositive) {
        return moveNodes(nodesWithExtremeLocation, isPositive, new Setter<Location, Integer>() {
            @Override
            public void set(Location input, Integer newValue) {
                input.setX(newValue);
            }
        });
    }

    /**
     * Move all nodes to a more readable location.
     * 
     * @param nodesWithExtremeLocation
     *            List of couple, node with extreme location and corresponding
     *            huge coordinate.
     * @param isPositive
     *            true if the above list of nodes concerns nodes with positive
     *            X, false if it concerns negative X
     * @return true if at least one node has been moved, false otherwise
     */
    protected boolean moveNodesY(Map<Node, Integer> nodesWithExtremeLocation, boolean isPositive) {
        return moveNodes(nodesWithExtremeLocation, isPositive, new Setter<Location, Integer>() {
            @Override
            public void set(Location input, Integer newValue) {
                input.setY(newValue);
            }
        });
    }

    /**
     * Move all nodes to a more readable location.
     * 
     * @param nodesWithExtremeLocation
     *            List of couple, node with extreme location and corresponding
     *            location.
     * @param isPositive
     *            true if the above list of nodes concerns nodes with positive X
     *            or Y, false if it concerns negative X or Y
     * @param setter
     *            A setter to set new X or Y coordinate
     * @return true if at least one node has been moved, false otherwise
     */
    protected boolean moveNodes(Map<Node, Integer> nodesWithExtremeLocation, boolean isPositive, Setter<Location, Integer> setter) {
        boolean nodesMoved = false;
        int min = -NODES_LIMIT;
        int max = Integer.MIN_VALUE;
        if (isPositive) {
            min = Integer.MAX_VALUE;
            max = NODES_LIMIT;
        }
        // Get min and max values
        for (Integer coordinate : nodesWithExtremeLocation.values()) {
            nodesMoved = true;
            if (coordinate < min) {
                min = coordinate;
            }
            if (coordinate > max) {
                max = coordinate;
            }
        }
        // Get delta between min and max
        int delta = max - min;
        if (delta < NODES_LIMIT) {
            // Moves all nodes with the same delta
            for (Entry<Node, Integer> entry : nodesWithExtremeLocation.entrySet()) {
                if (isPositive) {
                    setter.set((Location) entry.getKey().getLayoutConstraint(), entry.getValue() - max - NODES_LIMIT_MOVE);
                } else {
                    setter.set((Location) entry.getKey().getLayoutConstraint(), entry.getValue() - min + NODES_LIMIT_MOVE);
                }
            }
        } else {
            // Move all nodes to the same location (-NODES_LIMIT)
            for (Entry<Node, Integer> entry : nodesWithExtremeLocation.entrySet()) {
                if (isPositive) {
                    setter.set((Location) entry.getKey().getLayoutConstraint(), -NODES_LIMIT_MOVE);
                } else {
                    setter.set((Location) entry.getKey().getLayoutConstraint(), NODES_LIMIT_MOVE);
                }
            }
        }
        return nodesMoved;
    }

    /**
     * Create dummy edge name edit part to initialize the
     * registerSnapBackPosition() method of each kind of edit part. Without this
     * initialization, when using
     * {@link LabelEditPart#getSnapBackPosition(String)}, the returned value is
     * null.
     */
    private void initializeSnapBackPositionMap() {
        new DEdgeNameEditPart(null);
        new DEdgeBeginNameEditPart(null);
        new DEdgeEndNameEditPart(null);
    }

    private List<Node> getDistantEdgeLabels(DDiagram dDiagram) {
        List<Node> distantEdgeLabels = new ArrayList<Node>();
        for (Edge edge : getEdges(dDiagram)) {
            for (Object child : edge.getChildren()) {
                if (child instanceof Node && new ViewQuery((Node) child).isForEdgeNameEditPart()) {
                    if (isLabelDistant(edge, (Node) child)) {
                        distantEdgeLabels.add((Node) child);
                    }
                }
            }
        }
        return distantEdgeLabels;
    }

    /**
     * Get all nodes with huge coordinates for this <code>dDiagram</code>. The
     * nodes are grouped by nodes with negative X, positive X, negative Y and
     * positive Y (using key {@link #NEGATIVE_X_KEY}, {@link #POSITIVE_X_KEY},
     * {@link #NEGATIVE_Y_KEY}, {@link #POSITIVE_Y_KEY}).
     * 
     * @param dDiagram
     *            The diagram in which to search.
     * @return a list of nodes with the "huge coordinate" group by type.
     */
    private Map<String, Map<Node, Integer>> getNodesWithExtremeLocation(DDiagram dDiagram) {
        Map<Node, Integer> nodesWithExtremeNegativeXLocation = new HashMap<Node, Integer>();
        Map<Node, Integer> nodesWithExtremePositiveXLocation = new HashMap<Node, Integer>();
        Map<Node, Integer> nodesWithExtremeNegativeYLocation = new HashMap<Node, Integer>();
        Map<Node, Integer> nodesWithExtremePositiveYLocation = new HashMap<Node, Integer>();
        for (Node node : getNodes(dDiagram)) {
            if (node.getLayoutConstraint() instanceof Location) {
                Location location = (Location) node.getLayoutConstraint();
                Point point = new Point(location.getX(), location.getY());
                // Do not deal with label between -lowerLimit and lowerLimit.
                if (Math.abs(location.getX()) > NODES_LIMIT) {
                    if (location.getX() > 0) {
                        nodesWithExtremePositiveXLocation.put(node, point.x());
                    } else {
                        nodesWithExtremeNegativeXLocation.put(node, point.x());
                    }
                }
                if (Math.abs(location.getY()) > NODES_LIMIT) {
                    if (location.getY() > 0) {
                        nodesWithExtremePositiveYLocation.put(node, point.y());
                    } else {
                        nodesWithExtremeNegativeYLocation.put(node, point.y());
                    }
                }
            }
        }
        Map<String, Map<Node, Integer>> result = new HashMap<String, Map<Node, Integer>>();
        result.put(NEGATIVE_X_KEY, nodesWithExtremeNegativeXLocation);
        result.put(POSITIVE_X_KEY, nodesWithExtremePositiveXLocation);
        result.put(NEGATIVE_Y_KEY, nodesWithExtremeNegativeYLocation);
        result.put(POSITIVE_Y_KEY, nodesWithExtremePositiveYLocation);
        return result;
    }

    /**
     * Check is the label is considered as distant from its edge:
     * <UL>
     * <LI>If the label is less than 250 pixels away from the reference point on
     * its corresponding edge, the label is not considered as distant.</LI>
     * <LI>If the label is more than 1000 pixels away from the reference point
     * on its corresponding edge, the label is considered as distant.</LI>
     * <LI>Between these 2 limits, the label is considered as distant if the
     * distance between the center of label and edge is highest that
     * "4*the size of the nearest segment".</LI>
     * </UL>
     * 
     * @param edgeLabel
     *            The label to check
     * @return true if the label is considered as distant from its edge, false
     *         otherwise.
     */
    private boolean isLabelDistant(Edge edge, Node edgeLabel) {
        boolean isLabelDistant = false;
        if (edgeLabel.getLayoutConstraint() instanceof Location) {
            Location location = (Location) edgeLabel.getLayoutConstraint();
            // Do not deal with label between -lowerLimit and lowerLimit.
            if (!(Math.abs(location.getX()) <= LABEL_LOWER_LIMIT && Math.abs(location.getY()) <= LABEL_LOWER_LIMIT)) {
                isLabelDistant = Math.abs(location.getX()) > LABEL_UPPER_LIMIT || Math.abs(location.getY()) > LABEL_UPPER_LIMIT;
                if (!isLabelDistant) {
                    try {
                        // Try to be more precise that just using location of
                        // label: Check if the distance between center of label
                        // and edge is highest that "4*the size of the nearest
                        // segment".
                        List<Point> result = Lists.newArrayList();
                        PointList ptList = new PointList();
                        Anchor anchor = edge.getSourceAnchor();
                        // We only handle case with node as source and identity
                        // anchor.
                        if (anchor instanceof IdentityAnchor && edge.getSource() instanceof Node) {
                            PrecisionPoint relativeReference = BaseSlidableAnchor.parseTerminalString(((IdentityAnchor) anchor).getId());
                            Rectangle sourceBounds = new NodeQuery((Node) edge.getSource()).getHandleBounds();
                            PrecisionPoint srcAnchorLoc = new PrecisionPoint(relativeReference.preciseX() * sourceBounds.width() + sourceBounds.x(),
                                    relativeReference.preciseY() * sourceBounds.height() + sourceBounds.y());
                            RelativeBendpoints bp = (RelativeBendpoints) edge.getBendpoints();
                            for (int i = 0; i < bp.getPoints().size(); i++) {
                                RelativeBendpoint rbp = (RelativeBendpoint) bp.getPoints().get(i);
                                Point fromSrc = srcAnchorLoc.getTranslated(rbp.getSourceX(), rbp.getSourceY());
                                result.add(fromSrc);
                                ptList.addPoint(fromSrc);
                            }
                            Point refPoint = PointListUtilities.calculatePointRelativeToLine(ptList, 0, getLocationOfReference(edgeLabel), true);
                            Point labelCenter = org.eclipse.sirius.diagram.ui.internal.edit.parts.locator.EdgeLabelQuery.relativeCenterCoordinateFromOffset(ptList, refPoint,
                                    new Point(location.getX(), location.getY()));

                            @SuppressWarnings("rawtypes")
                            List segments = PointListUtilities.getLineSegments(ptList);
                            LineSeg nearestSegment = PointListUtilities.getNearestSegment(segments, labelCenter.x, labelCenter.y);
                            double distance = nearestSegment.distanceToPoint(labelCenter.x(), labelCenter.y());
                            isLabelDistant = distance > nearestSegment.length() * 4;
                        }
                        // CHECKSTYLE:OFF
                    } catch (Exception e) {
                        // Do nothing, just avoid some specific cases not
                        // handled above.
                    }
                    // CHECKSTYLE:ON
                }
            }
        }
        return isLabelDistant;
    }

    @SuppressWarnings("restriction")
    private int getLocationOfReference(Node edgeLabel) {
        int locationOfRef = LabelViewConstants.MIDDLE_LOCATION;
        int type = SiriusVisualIDRegistry.getVisualID(edgeLabel.getType());
        if (DEdgeBeginNameEditPart.VISUAL_ID == type) {
            locationOfRef = LabelViewConstants.SOURCE_LOCATION;
        } else if (DEdgeEndNameEditPart.VISUAL_ID == type) {
            locationOfRef = LabelViewConstants.TARGET_LOCATION;
        }
        return locationOfRef;
    }

    /**
     * Get the {@link Edge}s with labels contained in the given {@link DDiagram}
     * .
     * 
     * @param dDiagram
     *            the given {@link DDiagram}.
     * @return the {@link Edge}s with labels contained in the given
     *         {@link DDiagram}.
     */
    private Collection<Edge> getEdges(DDiagram dDiagram) {
        DDiagramGraphicalQuery query = new DDiagramGraphicalQuery(dDiagram);
        Option<Diagram> gmfDiagram = query.getAssociatedGMFDiagram();
        if (gmfDiagram.some()) {
            return Lists.newArrayList(Iterables.filter(gmfDiagram.get().getEdges(), Edge.class));
        }
        return new ArrayList<Edge>();
    }
    
    /**
     * Get the {@link Edge}s with labels contained in the given {@link DDiagram}
     * .
     * 
     * @param dDiagram
     *            the given {@link DDiagram}.
     * @return the {@link Edge}s with labels contained in the given
     *         {@link DDiagram}.
     */
    private Collection<Node> getNodes(DDiagram dDiagram) {
        DDiagramGraphicalQuery query = new DDiagramGraphicalQuery(dDiagram);
        Option<Diagram> gmfDiagram = query.getAssociatedGMFDiagram();
        if (gmfDiagram.some()) {
            return Lists.newArrayList(Iterables.filter(gmfDiagram.get().getChildren(), Node.class));
        }
        return new ArrayList<Node>();
    }
}