/*******************************************************************************
 * Copyright (c) 2017 Obeo.
 * 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.ui.tools.internal.viewpoint;

import java.text.MessageFormat;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.stream.Collectors;

import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.sirius.business.api.componentization.ViewpointRegistry;
import org.eclipse.sirius.business.api.session.Session;
import org.eclipse.sirius.business.api.session.SessionListener;
import org.eclipse.sirius.business.internal.metamodel.description.spec.ViewpointSpec;
import org.eclipse.sirius.common.tools.api.util.EqualityHelper;
import org.eclipse.sirius.ui.business.api.viewpoint.ViewpointSelection;
import org.eclipse.sirius.ui.tools.internal.wizards.pages.IViewpointStateListener;
import org.eclipse.sirius.ui.tools.internal.wizards.pages.ViewpointStateChangeEvent;
import org.eclipse.sirius.viewpoint.description.Viewpoint;
import org.eclipse.sirius.viewpoint.provider.Messages;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.PlatformUI;

import com.google.common.collect.Maps;
import com.google.common.collect.Sets;

/**
 * Component providing dynamic activation/deactivation behavior for the graphic component
 * {@link ViewpointsSelectionGraphicalHandler} and session synchronization. I.e any viewpoint check state change from
 * graphical component and triggered by user will be feed through to the session. And in the other way any change of
 * viewpoint activation/deactivation or presence change in the session will be feed through to the graphic component to
 * update viewpoints available and their check state status.
 * 
 * @author <a href="mailto:pierre.guilet@obeo.fr">Pierre Guilet</a>
 *
 */
public class DynamicViewpointsSelectionComponent {

    /**
     * The session from which viewpoint will be available for activation/deactivation.
     */
    private Session session;

    /**
     * Contains all viewpoints available in the current runtime registry.
     */
    private Collection<Viewpoint> availableViewpoints;

    /**
     * Listen to any change regarding viewpoints or semantic models available to the session and refresh the list of
     * viewpoint available in the graphic component with their check status if needed.
     */
    private SessionChangeListener sessionChangelistener;

    /**
     * The graphic component containing checkbox for each viewpoint activable/deactivable and a browser allowing to see
     * a description for each.
     */
    private ViewpointsSelectionGraphicalHandler viewpointsSelectionGraphicalHandler;

    /**
     * Listener updating the session accordingly to changes triggered by user when checking /unchecking viewpoint from
     * graphical component {@link ViewpointsSelectionGraphicalHandler}.
     */
    private DefaultViewpointStateListener viewpointStateListener;

    /**
     * The last viewpoints activation status for the current editor session.
     */
    private Set<Viewpoint> lastSelectedViewpoints;

    /**
     * Listener delegating to the {@link DefaultViewpointStateListener} listener when a check state change occurs (I.e a
     * viewpoint has been checked or unchecked).
     */
    private ICheckStateListener checkStateListener;

    /**
     * Check if selected viewpoint is missing dependencies to be activated. If so it show an error message above the
     * viewpoint description browser.
     */
    private ISelectionChangedListener selectionListener;

    /**
     * This listener allows viewpoint activation/deactivation by a double click.
     */
    private IDoubleClickListener doubleClickListener;

    /**
     * Listener updating the session accordingly to changes triggered by user when checking /unchecking viewpoint from
     * graphical component {@link ViewpointsSelectionGraphicalHandler}.
     * 
     * @author <a href="mailto:pierre.guilet@obeo.fr">Pierre Guilet</a>
     *
     */
    private class DefaultViewpointStateListener implements IViewpointStateListener {

        @Override
        public void viewpointStateChange(ViewpointStateChangeEvent viewpointStateChangeEvent) {
            final SortedMap<Viewpoint, Boolean> originalViewpointsMap = Maps.newTreeMap(new ViewpointRegistry.ViewpointComparator());
            for (final Viewpoint viewpoint : availableViewpoints) {
                boolean selected = false;

                for (Viewpoint selectedViewpoint : lastSelectedViewpoints) {
                    if (EqualityHelper.areEquals(selectedViewpoint, viewpoint)) {
                        selected = true;
                        break;
                    }
                }
                originalViewpointsMap.put(viewpoint, Boolean.valueOf(selected));
            }
            SortedMap<Viewpoint, Boolean> newViewpointToSelectionStateMap = Maps.newTreeMap(new ViewpointRegistry.ViewpointComparator());
            newViewpointToSelectionStateMap.putAll(originalViewpointsMap);
            newViewpointToSelectionStateMap.put(viewpointStateChangeEvent.getViewpoint(), viewpointStateChangeEvent.shouldBeActivated());

            // we also deselect viewpoint that will be missing a dependency if such element exists.
            Set<Viewpoint> viewpointsMissingDependencies = ViewpointHelper.getViewpointsMissingDependencies(
                    newViewpointToSelectionStateMap.keySet().stream().filter(viewpoint -> newViewpointToSelectionStateMap.get(viewpoint)).collect(Collectors.toSet()));
            for (Viewpoint viewpointsMissingDependency : viewpointsMissingDependencies) {
                newViewpointToSelectionStateMap.put(viewpointsMissingDependency, false);
            }

            ViewpointHelper.applyNewViewpointSelection(originalViewpointsMap, newViewpointToSelectionStateMap, session, true);

            // If deselection has been cancelled we update the last selected viewpoints set to reflect this deselection
            // in the cache.
            boolean viewpointSelected = session.getSelectedViewpoints(true).stream().anyMatch(viewpoint -> EqualityHelper.areEquals(viewpointStateChangeEvent.getViewpoint(), viewpoint));
            newViewpointToSelectionStateMap.put(viewpointStateChangeEvent.getViewpoint(), viewpointSelected);
            for (Viewpoint viewpointsMissingDependency : viewpointsMissingDependencies) {
                viewpointSelected = session.getSelectedViewpoints(true).stream().anyMatch(viewpoint -> EqualityHelper.areEquals(viewpointsMissingDependency, viewpoint));
                newViewpointToSelectionStateMap.put(viewpointsMissingDependency, viewpointSelected);
            }

            lastSelectedViewpoints = new HashSet<Viewpoint>(
                    newViewpointToSelectionStateMap.keySet().stream().filter(viewpoint -> newViewpointToSelectionStateMap.get(viewpoint)).collect(Collectors.toSet()));
            viewpointsSelectionGraphicalHandler.getViewer().setCheckedElements(lastSelectedViewpoints.toArray(new Object[0]));
            viewpointsSelectionGraphicalHandler.getViewer().setSelection(new StructuredSelection(viewpointStateChangeEvent.getViewpoint()));

            updateGrayedOutElement();
            viewpointsSelectionGraphicalHandler.getViewer().refresh();
        }

    }

    /**
     * Create an instance of a graphic component allowing to activate/deactivate viewpoint from a session.
     *
     * @param theSession
     *            the session from which viewpoint will be available for activation/deactivation.
     */
    public DynamicViewpointsSelectionComponent(final Session theSession) {
        this.session = theSession;
        viewpointsSelectionGraphicalHandler = new ViewpointsSelectionGraphicalHandler();
        availableViewpoints = viewpointsSelectionGraphicalHandler.getAvailableViewpoints(theSession);
        viewpointStateListener = new DefaultViewpointStateListener();
        lastSelectedViewpoints = new HashSet<Viewpoint>();
    }

    private void updateGrayedOutElement() {
        for (Viewpoint viewpoint : availableViewpoints) {
            String missingDependencyErrorMessage = getMissingDependencyErrorMessage(viewpoint, lastSelectedViewpoints);
            if (missingDependencyErrorMessage != null) {
                viewpointsSelectionGraphicalHandler.getViewer().setGrayed(viewpoint, true);
            } else {
                viewpointsSelectionGraphicalHandler.getViewer().setGrayed(viewpoint, false);
            }
        }

    }

    /**
     * Listen to any change regarding viewpoints or semantic models available to the session and refresh the list of
     * viewpoint available in the graphic component with their check status if needed. Viewpoint can be made unavailable
     * for the session when closing the project containing it and model semantic models can be removed for example.
     * 
     * @author <a href="mailto:pierre.guilet@obeo.fr">Pierre Guilet</a>
     *
     */
    private final class SessionChangeListener implements SessionListener {
        @Override
        public void notify(int changeKind) {
            switch (changeKind) {
            case SessionListener.SELECTED_VIEWS_CHANGE_KIND:
            case SessionListener.VSM_UPDATED:
            case SessionListener.SEMANTIC_CHANGE:
                availableViewpoints = viewpointsSelectionGraphicalHandler.getAvailableViewpoints(session);
                setViewpoints(getAvailableViewpoints());
                break;
            default:
                break;
            }

        }
    }

    /**
     * Reinitialize the viewer containing all the checkbox for available viewpoints for the session with their check
     * status.
     * 
     * @param theAvailableViewpoints
     *            all the viewpoints available to the session that need to be made visible for activation/deactivation
     *            to the user in the graphic component.
     */
    private void setViewpoints(Collection<Viewpoint> theAvailableViewpoints) {
        PlatformUI.getWorkbench().getDisplay().syncExec(() -> {
            lastSelectedViewpoints.clear();
            CheckboxTableViewer viewer = viewpointsSelectionGraphicalHandler.getViewer();
            viewer.setInput(theAvailableViewpoints);
            // case were activated viewpoint are the one corresponding to the session.
            Collection<Viewpoint> selectedViewpoints = session.getSelectedViewpoints(false);
            for (int i = 0; i < viewer.getTable().getItemCount(); i++) {
                Object object = viewer.getElementAt(i);
                if (object instanceof Viewpoint) {
                    Viewpoint viewerViewpoint = (Viewpoint) object;
                    for (Viewpoint selectedViewpoint : selectedViewpoints) {
                        if (EqualityHelper.areEquals(viewerViewpoint, selectedViewpoint)) {
                            lastSelectedViewpoints.add(viewerViewpoint);
                        }
                    }
                }
            }
            if (!lastSelectedViewpoints.isEmpty()) {
                // Check all the default viewpoints
                viewer.setCheckedElements(lastSelectedViewpoints.toArray(new Object[0]));
                // Set the focus on the first one
                viewer.setSelection(new StructuredSelection(lastSelectedViewpoints.stream().findFirst().get()));
            } else {
                viewpointsSelectionGraphicalHandler.getBrowser().setText(""); //$NON-NLS-1$
            }

            // For all no selected viewpoints we check if they have missing dependencies among activated ones and if
            // they do we gray out
            // those.
            for (Viewpoint viewpoint : availableViewpoints) {
                Set<Viewpoint> viewpoints = new HashSet<Viewpoint>(lastSelectedViewpoints);
                viewpoints.add(viewpoint);
                Set<Viewpoint> viewpointsMissingDependencies = ViewpointHelper.getViewpointsMissingDependencies(viewpoints);
                if (viewpointsMissingDependencies.contains(viewpoint)) {
                    viewer.setGrayed(viewpoint, true);
                } else {
                    viewer.setGrayed(viewpoint, false);
                }
            }
            viewpointsSelectionGraphicalHandler.getRootComposite().layout();
        });

    }

    /**
     * Returns all registered viewpoints that define editors for metamodel of loaded session's semantic models.
     * 
     * @return all registered viewpoints that define editors for metamodel of loaded session's semantic models.
     */
    public Collection<Viewpoint> getAvailableViewpoints() {
        return availableViewpoints;
    }

    /**
     * Create the control allowing to select/deselect viewpoints with checkbox and to see in a browser a description of
     * each viewpoint.
     * 
     * @param parent
     *            the parent composite to attached to this graphic component.
     */
    public void createControl(final Composite parent) {
        viewpointsSelectionGraphicalHandler.createControl(parent, false);
        viewpointsSelectionGraphicalHandler.setBrowserMinWidth(200);
        viewpointsSelectionGraphicalHandler.setHeight(304);
        checkStateListener = event -> {
            String errorMessage = null;

            if (event.getElement() instanceof Viewpoint) {
                Viewpoint viewpointChecked = (Viewpoint) event.getElement();
                viewpointsSelectionGraphicalHandler.getViewer().setSelection(new StructuredSelection(viewpointChecked));
                if (!lastSelectedViewpoints.isEmpty()) {
                    errorMessage = getMissingDependencyErrorMessage(viewpointChecked, lastSelectedViewpoints);
                }
                if (errorMessage == null) {
                    viewpointsSelectionGraphicalHandler.clearBrowserErrorMessageText();
                    if (!viewpointsSelectionGraphicalHandler.getViewer().getGrayed(viewpointChecked)) {
                        if (event.getChecked()) {
                            viewpointStateListener.viewpointStateChange(new ViewpointStateChangeEvent(viewpointChecked, true));
                        } else {
                            viewpointStateListener.viewpointStateChange(new ViewpointStateChangeEvent(viewpointChecked, false));
                        }
                    }
                } else {
                    viewpointsSelectionGraphicalHandler.setBrowserErrorMessageText(errorMessage);
                }
            }
        };
        viewpointsSelectionGraphicalHandler.getViewer().addCheckStateListener(checkStateListener);

        selectionListener = event -> {
            if (event.getSelection() instanceof StructuredSelection) {
                StructuredSelection selection = (StructuredSelection) event.getSelection();
                if (selection.getFirstElement() instanceof Viewpoint) {
                    Viewpoint viewpoint = (Viewpoint) selection.getFirstElement();
                    String errorMessage = getMissingDependencyErrorMessage(viewpoint, lastSelectedViewpoints);
                    if (errorMessage != null) {
                        viewpointsSelectionGraphicalHandler.setBrowserErrorMessageText(errorMessage);
                    } else {
                        viewpointsSelectionGraphicalHandler.clearBrowserErrorMessageText();
                    }
                }
            }
        };
        viewpointsSelectionGraphicalHandler.getViewer().addSelectionChangedListener(selectionListener);

        doubleClickListener = (event) -> {
            event.getSelection();
            if (event.getSelection() instanceof StructuredSelection) {
                StructuredSelection selection = (StructuredSelection) event.getSelection();
                if (selection.getFirstElement() instanceof ViewpointSpec) {
                    ViewpointSpec viewpoint = (ViewpointSpec) selection.getFirstElement();
                    if (!viewpointsSelectionGraphicalHandler.getViewer().getGrayed(viewpoint)) {
                        viewpointStateListener.viewpointStateChange(new ViewpointStateChangeEvent(viewpoint, !viewpointsSelectionGraphicalHandler.getViewer().getChecked(viewpoint)));
                    } else {
                        viewpointsSelectionGraphicalHandler.getViewer().setChecked(viewpoint, !viewpointsSelectionGraphicalHandler.getViewer().getChecked(viewpoint));
                    }

                }
            }
        };
        viewpointsSelectionGraphicalHandler.getViewer().addDoubleClickListener(doubleClickListener);

        setViewpoints(availableViewpoints);
        sessionChangelistener = new SessionChangeListener();
        session.addListener(sessionChangelistener);
    }

    /**
     * Return an error message referencing all missing dependencies for the given viewpoint or null if no missing
     * dependencies exists.
     * 
     * @param viewpoint
     *            the viewpoint from which we check if it has missing dependencies among activated viewpoints.
     * @param selectedViewpoints
     *            the current activated viewpoints.
     * @return an error message referencing all missing dependencies for the given viewpoint or null if no missing
     *         dependencies exists.
     */
    protected String getMissingDependencyErrorMessage(Viewpoint viewpoint, Set<Viewpoint> selectedViewpoints) {
        Set<Viewpoint> viewpoints = Sets.newHashSet(selectedViewpoints);
        viewpoints.add(viewpoint);
        Map<String, Collection<String>> missingDependencies = ViewpointSelection.getMissingDependencies(viewpoints);
        if (missingDependencies != null && missingDependencies.get(viewpoint.getName()) != null) {
            return MessageFormat.format(Messages.DynamicViewpointsSelectionComponent_missingDependencies_requirements, viewpoint.getName(),
                    missingDependencies.get(viewpoint.getName()).stream().collect(Collectors.joining(", "))); //$NON-NLS-1$
        }
        return null;
    }

    /**
     * Dispose any listeners added by this instance.
     */
    public void dispose() {
        if (session != null && sessionChangelistener != null) {
            session.removeListener(sessionChangelistener);
        }
        if (viewpointsSelectionGraphicalHandler != null) {
            if (selectionListener != null) {
                viewpointsSelectionGraphicalHandler.getViewer().removeSelectionChangedListener(selectionListener);
            }
            if (checkStateListener != null) {
                viewpointsSelectionGraphicalHandler.getViewer().removeCheckStateListener(checkStateListener);
            }
            if (doubleClickListener != null) {
                viewpointsSelectionGraphicalHandler.getViewer().removeDoubleClickListener(doubleClickListener);
            }
        }
        viewpointStateListener = null;
        selectionListener = null;
        sessionChangelistener = null;
        session = null;
    }
}