/*******************************************************************************
 * Copyright (c) 2007, 2019 THALES GLOBAL SERVICES and others.
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *    Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.sirius.diagram.ui.edit.api.part;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain;
import org.eclipse.gef.DragTracker;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.Request;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.requests.SelectionRequest;
import org.eclipse.gef.tools.DeselectAllTracker;
import org.eclipse.gmf.runtime.diagram.ui.commands.ICommandProxy;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramRootEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles;
import org.eclipse.gmf.runtime.diagram.ui.requests.ArrangeRequest;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.sirius.business.api.session.Session;
import org.eclipse.sirius.business.api.session.SessionManager;
import org.eclipse.sirius.common.tools.api.util.EqualityHelper;
import org.eclipse.sirius.diagram.DDiagram;
import org.eclipse.sirius.diagram.DDiagramElement;
import org.eclipse.sirius.diagram.DEdge;
import org.eclipse.sirius.diagram.DNodeContainer;
import org.eclipse.sirius.diagram.DSemanticDiagram;
import org.eclipse.sirius.diagram.DiagramPackage;
import org.eclipse.sirius.diagram.business.api.componentization.DiagramComponentizationManager;
import org.eclipse.sirius.diagram.business.api.componentization.DiagramMappingsManager;
import org.eclipse.sirius.diagram.business.api.componentization.DiagramMappingsManagerRegistry;
import org.eclipse.sirius.diagram.business.api.query.CompositeFilterDescriptionQuery;
import org.eclipse.sirius.diagram.business.api.query.DDiagramQuery;
import org.eclipse.sirius.diagram.business.api.query.DMappingBasedQuery;
import org.eclipse.sirius.diagram.business.api.query.EObjectQuery;
import org.eclipse.sirius.diagram.business.internal.metamodel.helper.ContainerMappingHelper;
import org.eclipse.sirius.diagram.business.internal.metamodel.helper.LayerHelper;
import org.eclipse.sirius.diagram.description.ContainerMapping;
import org.eclipse.sirius.diagram.description.DiagramDescription;
import org.eclipse.sirius.diagram.description.DiagramElementMapping;
import org.eclipse.sirius.diagram.description.EdgeMapping;
import org.eclipse.sirius.diagram.description.Layer;
import org.eclipse.sirius.diagram.description.filter.CompositeFilterDescription;
import org.eclipse.sirius.diagram.description.filter.FilterDescription;
import org.eclipse.sirius.diagram.ui.business.api.query.ViewQuery;
import org.eclipse.sirius.diagram.ui.business.internal.view.ShowingViewUtil;
import org.eclipse.sirius.diagram.ui.graphical.edit.policies.SiriusPopupBarEditPolicy;
import org.eclipse.sirius.diagram.ui.tools.api.command.GMFCommandWrapper;
import org.eclipse.sirius.diagram.ui.tools.api.editor.DDiagramEditor;
import org.eclipse.sirius.diagram.ui.tools.api.layout.ordering.AbstractEdgeViewOrdering;
import org.eclipse.sirius.diagram.ui.tools.api.layout.ordering.ViewOrdering;
import org.eclipse.sirius.diagram.ui.tools.api.layout.ordering.ViewOrderingHint;
import org.eclipse.sirius.diagram.ui.tools.api.layout.ordering.ViewOrderingProvider;
import org.eclipse.sirius.diagram.ui.tools.api.permission.EditPartAuthorityListener;
import org.eclipse.sirius.diagram.ui.tools.internal.commands.InitializeHiddenElementsCommand;
import org.eclipse.sirius.diagram.ui.tools.internal.editor.DDiagramEditorImpl;
import org.eclipse.sirius.diagram.ui.tools.internal.editor.SiriusBlankSpacesDragTracker;
import org.eclipse.sirius.diagram.ui.tools.internal.figure.SynchronizeStatusFigure;
import org.eclipse.sirius.diagram.ui.tools.internal.layout.ordering.ViewOrderingProviderRegistry;
import org.eclipse.sirius.ecore.extender.business.api.permission.IPermissionAuthority;
import org.eclipse.sirius.ecore.extender.business.api.permission.PermissionAuthorityRegistry;
import org.eclipse.sirius.ext.base.Option;
import org.eclipse.sirius.ext.base.Options;
import org.eclipse.sirius.ext.gmf.runtime.diagram.ui.tools.RubberbandDragTracker;
import org.eclipse.sirius.ext.gmf.runtime.editpolicies.SiriusSnapFeedbackPolicy;
import org.eclipse.sirius.viewpoint.description.Viewpoint;

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

/**
 * 
 * The base edit part.
 * 
 * @author ymortier
 */
public abstract class AbstractDDiagramEditPart extends DiagramEditPart implements IDDiagramEditPart {

    /** The authority listener. */
    protected EditPartAuthorityListener authListener = new EditPartAuthorityListener(this);

    /**
     * Creates a new <code>AbstractDDiagramEditPart</code>.
     * 
     * @param diagramView
     *            the GMF view.
     */
    public AbstractDDiagramEditPart(final View diagramView) {
        super(diagramView);
    }

    @Override
    public final Option<DDiagram> resolveDDiagram() {
        final EObject resolveSemanticElement = resolveSemanticElement();

        if (resolveSemanticElement instanceof DDiagram) {
            return Options.newSome((DDiagram) resolveSemanticElement);
        }
        return Options.newNone();
    }

    @Override
    protected void createDefaultEditPolicies() {
        super.createDefaultEditPolicies();
        this.installEditPolicy(EditPolicyRoles.POPUPBAR_ROLE, new SiriusPopupBarEditPolicy());
        // Replace the feedback policy to have a lighter color for guides
        installEditPolicy(EditPolicyRoles.SNAP_FEEDBACK_ROLE, new SiriusSnapFeedbackPolicy());
    }

    @Override
    protected List getModelChildren() {
        return ShowingViewUtil.getModelChildren(getModel());
    }

    @Override
    protected void addNotationalListeners() {
        super.addNotationalListeners();
        if (hasNotationView()) {
            ViewQuery viewQuery = new ViewQuery((View) getModel());
            Optional<DDiagram> diagram = viewQuery.getDDiagram();
            if (diagram.isPresent()) {
                addListenerFilter("ShowingMode", this, diagram.get(), DiagramPackage.eINSTANCE.getDDiagram_IsInShowingMode()); //$NON-NLS-1$
            }
        }
    }

    @Override
    protected void removeNotationalListeners() {
        super.removeNotationalListeners();
        removeListenerFilter("ShowingMode"); //$NON-NLS-1$
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.gmf.runtime.diagram.ui.editparts.GraphicalEditPart#setVisibility(boolean)
     */
    @Override
    protected void setVisibility(boolean vis) {
        ShowingViewUtil.setVisibility(this, vis, SELECTED_NONE, getFlag(FLAG__AUTO_CONNECTIONS_VISIBILITY));
    }

    @Override
    protected void handleNotificationEvent(final Notification notification) {
        /*
         * This guard is here to prevent node deletion when a diagram is opened
         */
        // if (!(notification.getEventType() == Notification.REMOVE)
        // && (notification.getEventType() == Notification.UNSET &&
        // !((EStructuralFeature)
        // notification.getFeature()).getName().equals("element")))
        super.handleNotificationEvent(notification);

        // Edge Show/Hide failure, saving and closing the diagram
        // If the visibility of an Edge as been modified
        if (NotationPackage.Literals.VIEW__VISIBLE.equals(notification.getFeature())) {
            if (notification.getNotifier() instanceof Edge) {
                // We create an edit part to handle the revealed Edge (if
                // necessary)
                createEditPartForRevealedEdge(notification);
            }
        }

        /*
         * If the notification is a REMOVE of an NoteAttachment, we want to refresh the editpart.
         */
        if (NotationPackage.eINSTANCE.getDiagram_PersistedEdges().equals(notification.getFeature()) || NotationPackage.eINSTANCE.getDiagram_TransientEdges().equals(notification.getFeature())) {
            if (notification.getOldValue() instanceof Edge) {
                final Edge oldValue = (Edge) notification.getOldValue();
                if ("NoteAttachment".equals(oldValue.getType())) { //$NON-NLS-1$
                    refresh();
                }
            }
        }

        /*
         * Special case for activatedFilters
         */
        if (DiagramPackage.eINSTANCE.getDDiagram_ActivatedFilters().equals(notification.getFeature())) {
            refresh();
            refreshSourceAndTargetOfRevealedEdges(notification);
        } else if (DiagramPackage.eINSTANCE.getDDiagram_ActivatedTransientLayers().equals(notification.getFeature())
                || DiagramPackage.eINSTANCE.getDDiagram_ActivatedLayers().equals(notification.getFeature())) {
            // We don't launch a refresh if the notification is an addition of
            // a layer that has only tools
            if (!(notification.getNewValue() instanceof Layer && LayerHelper.containsOnlyTools((Layer) notification.getNewValue()))) {
                refresh();
            }
        } else {
            /**
             * If the notification is an ADD we want to refresh the editpart as it may mean that some elements are
             * filtered.
             * 
             * We don't want to refresh on a REMOVE event or it would make the element deletion fail if a diagram is
             * open.
             */
            if (notification.getEventType() == Notification.SET || notification.getEventType() == Notification.UNSET || notification.getEventType() == Notification.ADD) {
                refresh();
            }
        }
    }

    /**
     * Creates an Edit Part for a newly revealed Edge (if necessary), by refresh its source and target.
     * 
     * @param notification
     *            A notification of feature NotationPackage.Literals.VIEW__VISIBLE
     */
    protected void createEditPartForRevealedEdge(Notification notification) {
        // Step 1 : determine if an edit part needs to be created for this edge
        Option<Edge> edgeToRefresh = Options.newNone();

        // If the visibility of an edge as changed from false to true
        if (Notification.SET == notification.getEventType()) {
            if (!notification.getOldBooleanValue() && notification.getNewBooleanValue()) {
                // Then an Edit part has to be created for this edge
                edgeToRefresh = Options.newSome((Edge) notification.getNotifier());
            }
        }

        // Step 2 : create the edit part for the revealed edge if needed
        if (edgeToRefresh.some()) {
            // To do so, we refresh the source and the target of the revealed
            // edge
            List<IGraphicalEditPart> editPartsToRefresh = new ArrayList<IGraphicalEditPart>();
            Edge edge = edgeToRefresh.get();
            Option<IGraphicalEditPart> sourcePart = getEditPartFor(edge.getSource());
            if (sourcePart.some()) {
                editPartsToRefresh.add(sourcePart.get());
            }
            Option<IGraphicalEditPart> targetPart = getEditPartFor(edge.getTarget());
            if (targetPart.some() && !editPartsToRefresh.contains(targetPart.get())) {
                editPartsToRefresh.add(targetPart.get());
            }
            for (IGraphicalEditPart editPartToRefresh : editPartsToRefresh) {
                editPartToRefresh.refresh();
            }
        }
    }

    /**
     * Launch a refresh on the SourceEditPart and TargetEditPart of all edges revealed with the deactivation of a
     * filter.<BR>
     * This is usefull if the edge is created when the filter is activated and so it has been never created (no
     * corresponding editpart)
     * 
     * @param notification
     *            A notification of feature DiagramPackage.eINSTANCE.getDDiagram_ActivatedFilters()
     */
    protected void refreshSourceAndTargetOfRevealedEdges(Notification notification) {
        EList<Edge> edgesToRefresh = new BasicEList<Edge>();
        if (Notification.REMOVE == notification.getEventType()) {
            FilterDescription test = (FilterDescription) notification.getOldValue();
            if (test instanceof CompositeFilterDescription) {
                CompositeFilterDescription compositeFilterDescription = (CompositeFilterDescription) test;
                CompositeFilterDescriptionQuery query = new CompositeFilterDescriptionQuery(compositeFilterDescription);
                if (query.isHideCompositeFilter()) {
                    EList<DiagramElementMapping> mappings = query.getHiddenMappings();
                    edgesToRefresh = getEdges(Lists.newArrayList(Iterables.filter(mappings, EdgeMapping.class)));
                }
            }
        }
        // List all edges extremity to refresh
        List<IGraphicalEditPart> editPartsToRefresh = new ArrayList<IGraphicalEditPart>();
        for (Edge edge : edgesToRefresh) {
            Option<IGraphicalEditPart> sourcePart = getEditPartFor(edge.getSource());
            if (sourcePart.some() && !editPartsToRefresh.contains(sourcePart.get())) {
                editPartsToRefresh.add(sourcePart.get());
            }
            Option<IGraphicalEditPart> targetPart = getEditPartFor(edge.getTarget());
            if (targetPart.some() && !editPartsToRefresh.contains(targetPart.get())) {
                editPartsToRefresh.add(targetPart.get());
            }
        }
        for (IGraphicalEditPart editPartToRefresh : editPartsToRefresh) {
            editPartToRefresh.refresh();
        }
    }

    /**
     * Get all GMF edges of this diagram which have a DEdge with mapping contains in <code>edgeMappingsKindOf<code>
     * 
     * @param edgeMappingsKindOf
     *            The edges must have a mapping contained in this list.
     * @return a list of GMF edges.
     */
    private EList<Edge> getEdges(Collection<EdgeMapping> edgeMappingsKindOf) {
        EList<Edge> result = new BasicEList<Edge>();
        Diagram gmfDiagram = this.getDiagramView();
        for (Edge edge : Iterables.filter(gmfDiagram.getEdges(), Edge.class)) {
            EObject element = edge.getElement();
            if (element instanceof DEdge) {
                if (new DMappingBasedQuery((DEdge) element).isFromAnyMapping(edgeMappingsKindOf)) {
                    result.add(edge);
                }
            }
        }
        return result;
    }

    private Option<IGraphicalEditPart> getEditPartFor(View view) {
        Map<?, ?> registry = this.getViewer().getEditPartRegistry();
        if (view != null && registry.containsKey(view) && registry.get(view) instanceof IGraphicalEditPart) {
            return Options.newSome((IGraphicalEditPart) registry.get(view));
        } else {
            return Options.newNone();
        }
    }

    public EditPartAuthorityListener getEditPartAuthorityListener() {
        return this.authListener;
    }

    @Override
    public void activate() {
        super.activate();
        DDiagram dDiagram = resolveDDiagram().get();
        Session session = new EObjectQuery(dDiagram).getSession();

        // List of hidden diagramElement (or diagramElement from which label is
        // hidden).
        List<DDiagramElement> hiddenElements = new ArrayList<DDiagramElement>();
        if (session != null && dDiagram != null) {
            DiagramMappingsManager mappingManager = null;
            if (dDiagram.eAdapters().contains(DiagramMappingsManagerRegistry.INSTANCE)) {
                // Enable the cache only if the mapping manager has already been created.
                mappingManager = DiagramMappingsManagerRegistry.INSTANCE.getDiagramMappingsManager(session, dDiagram);
            }
            try {
                EqualityHelper.setUriFragmentCacheEnabled(true);
                if (mappingManager != null) {
                    LayerHelper.setActiveParentLayersCacheEnabled(mappingManager, true);
                }
               
                DDiagramQuery dDiagramQuery = new DDiagramQuery(dDiagram);
                for (final DDiagramElement diagramElement : dDiagram.getDiagramElements()) {
                    if (dDiagramQuery.isHidden(session, diagramElement)) {
                        hiddenElements.add(diagramElement);
                    } else if (dDiagramQuery.isLabelHidden(session, diagramElement)) {
                        hiddenElements.add(diagramElement);
                    }
                }
            } finally {
                EqualityHelper.setUriFragmentCacheEnabled(false);
                if (mappingManager != null) {
                    LayerHelper.setActiveParentLayersCacheEnabled(mappingManager, false);
                }
            }
        }

        if (!hiddenElements.isEmpty()) {
            // Execute command if there are hidden elements to add to transient
            // reference hiddenElements
            // Memory leak : do not open a new command if a transaction is being
            // executed
            if ((getEditingDomain() instanceof InternalTransactionalEditingDomain) && ((InternalTransactionalEditingDomain) getEditingDomain()).getActiveTransaction() == null) {
                final org.eclipse.emf.common.command.Command command = new InitializeHiddenElementsCommand(getEditingDomain(), dDiagram, hiddenElements);
                if (command != null) {
                    executeCommand(new ICommandProxy(new GMFCommandWrapper(getEditingDomain(), command)));
                }
            } else {
                dDiagram.getHiddenElements().addAll(hiddenElements);
            }
            // Refresh the tabbar because at least one element is hidden.
            final DDiagramEditorImpl diagramEditor = (DDiagramEditorImpl) this.getViewer().getProperty(DDiagramEditor.EDITOR_ID);
            if (diagramEditor != null && diagramEditor.getTabbar() != null) {
                diagramEditor.getTabbar().reinitToolBar(diagramEditor.getDiagramGraphicalViewer().getSelection());
            }
        }

        final IPermissionAuthority auth = PermissionAuthorityRegistry.getDefault().getPermissionAuthority(getEditingDomain().getResourceSet());
        auth.addAuthorityListener(this.getEditPartAuthorityListener());
        this.getEditPartAuthorityListener().refreshEditMode();

        // refresh synchronized status decorator
        SynchronizeStatusFigure.updateNotification((DiagramRootEditPart) this.getRoot());
    }

    @Override
    public void deactivate() {
        if (!isActive()) {
            return;
        }
        final IPermissionAuthority auth = PermissionAuthorityRegistry.getDefault().getPermissionAuthority(getEditingDomain().getResourceSet());
        auth.removeAuthorityListener(this.getEditPartAuthorityListener());
        super.deactivate();
    }

    /**
     * Populate the view ordering. {@inheritDoc}
     * 
     * @see org.eclipse.gmf.runtime.diagram.ui.editparts.GraphicalEditPart#getCommand(org.eclipse.gef.Request)
     */
    @Override
    public Command getCommand(final Request request) {
        Command originalCommand = super.getCommand(request);
        if (request instanceof ArrangeRequest && originalCommand != null) {
            Command populateViewOrder = new Command(originalCommand.getLabel()) {

                @Override
                public void execute() {
                    populateViewOrderings();
                }

            };
            originalCommand = populateViewOrder.chain(originalCommand);
        }
        return originalCommand;
    }

    /**
     * Populate the {@link ViewOrderingHint} for a future Arrange command.
     */
    protected void populateViewOrderings() {

        final EObject element = this.resolveSemanticElement();
        if (element instanceof DDiagram) {
            final DDiagram dDiagram = (DDiagram) element;
            if (dDiagram.getDescription() != null) {
                final DiagramDescription desc = dDiagram.getDescription();
                final List<DiagramElementMapping> allMappings = new LinkedList<DiagramElementMapping>();

                Collection<Viewpoint> selectedViewpoints = Collections.emptyList();
                if (dDiagram instanceof DSemanticDiagram) {
                    Session session = SessionManager.INSTANCE.getSession(((DSemanticDiagram) dDiagram).getTarget());
                    if (session != null) {
                        selectedViewpoints = session.getSelectedViewpoints(false);
                    }
                }

                allMappings.addAll(new DiagramComponentizationManager().getAllContainerMappings(selectedViewpoints, desc));
                allMappings.addAll(new DiagramComponentizationManager().getAllNodeMappings(selectedViewpoints, desc));
                allMappings.addAll(new DiagramComponentizationManager().getAllEdgeMappings(selectedViewpoints, desc));
                final Iterator<DiagramElementMapping> iterAllMappings = allMappings.iterator();
                while (iterAllMappings.hasNext()) {
                    final DiagramElementMapping diagramElementMapping = iterAllMappings.next();
                    final ViewOrderingProvider provider = ViewOrderingProviderRegistry.getInstance().getProvider(diagramElementMapping);
                    if (provider != null) {
                        final ViewOrdering viewOrdering = provider.getViewOrdering(diagramElementMapping);
                        if (viewOrdering instanceof AbstractEdgeViewOrdering) {
                            ViewOrderingHint.getInstance().putEdgeViewOrdering(getNotationView(), (AbstractEdgeViewOrdering) viewOrdering);
                        } else if (viewOrdering != null) {
                            ViewOrderingHint.getInstance().putViewOrdering(getNotationView(), viewOrdering);
                        }
                    }
                }
            }
        }
        for (IGraphicalEditPart part : Iterables.filter(getChildren(), IGraphicalEditPart.class)) {
            this.populateViewOrderings(part);
        }
    }

    /**
     * Recursively populate orderings.
     * 
     * @param editPart
     *            the current edit part.
     */
    private void populateViewOrderings(final IGraphicalEditPart editPart) {

        final EObject element = editPart.resolveSemanticElement();

        if (element instanceof DNodeContainer) {
            final ContainerMapping containerMapping = ((DNodeContainer) element).getActualMapping();
            if (containerMapping != null) {
                final Iterator<DiagramElementMapping> iterAllMappings = ContainerMappingHelper.getAllMappings(containerMapping).iterator();
                while (iterAllMappings.hasNext()) {
                    final DiagramElementMapping diagramElementMapping = iterAllMappings.next();
                    final ViewOrderingProvider provider = ViewOrderingProviderRegistry.getInstance().getProvider(diagramElementMapping);
                    if (provider != null) {
                        final ViewOrdering viewOrdering = provider.getViewOrdering(diagramElementMapping);
                        if (viewOrdering != null) {
                            ViewOrderingHint.getInstance().putViewOrdering(editPart.getNotationView(), viewOrdering);
                        }
                    }
                }
            }
        }
        for (IGraphicalEditPart part : Iterables.filter(editPart.getChildren(), IGraphicalEditPart.class)) {
            this.populateViewOrderings(part);
        }
    }

    /**
     * {@inheritDoc} Override to use specific MarqueeSelectionTool (GEf name) or RubberbandDragTracker (GMF name) to
     * allow ports selection.
     * 
     * @see org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart#getDragTracker(org.eclipse.gef.Request)
     */
    @Override
    public DragTracker getDragTracker(final Request req) {
        DragTracker result = SiriusBlankSpacesDragTracker.getDragTracker(this, (GraphicalViewer) getViewer(), req, true, true);
        if (result == null && req instanceof SelectionRequest && ((SelectionRequest) req).getLastButtonPressed() == 3) {
            result = new DeselectAllTracker(this);
        } else if (result == null) {
            result = new RubberbandDragTracker();
        }
        return result;
    }
}