EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.navigation.navigator.e4;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Observable;

import java.util.Observer;

import java.util.Set;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.eclipse.core.commands.operations.UndoContext;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.e4.core.commands.ECommandService;

import org.eclipse.e4.core.di.annotations.Optional;

import org.eclipse.e4.ui.di.Focus;

import org.eclipse.e4.ui.di.UIEventTopic;

import org.eclipse.e4.ui.di.UISynchronize;

import org.eclipse.e4.ui.model.application.MApplication;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.services.EMenuService;

import org.eclipse.e4.ui.workbench.modeling.EModelService;

import org.eclipse.e4.ui.workbench.modeling.EPartService;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.jface.util.LocalSelectionTransfer;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreePath;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.IMemento;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

import eu.etaxonomy.cdm.api.application.CdmChangeEvent;

import eu.etaxonomy.cdm.api.application.ICdmChangeListener;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;

import eu.etaxonomy.cdm.api.service.IClassificationService;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.ICdmBase;

import eu.etaxonomy.cdm.model.common.ITreeNode;

import eu.etaxonomy.cdm.model.taxon.Classification;

import eu.etaxonomy.cdm.model.taxon.TaxonNaturalComparator;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.cdm.model.taxon.TaxonNodeByNameComparator;

import eu.etaxonomy.cdm.model.taxon.TaxonNodeByRankAndNameComparator;

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.editor.ITaxonEditor;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.model.DataChangeBridge;

import eu.etaxonomy.taxeditor.model.IContextListener;

import eu.etaxonomy.taxeditor.model.IDataChangeBehavior;

import eu.etaxonomy.taxeditor.navigation.NavigationUtil;

import eu.etaxonomy.taxeditor.navigation.l10n.Messages;

import eu.etaxonomy.taxeditor.navigation.navigator.EmptyRoot;

import eu.etaxonomy.taxeditor.navigation.navigator.Root;

import eu.etaxonomy.taxeditor.navigation.navigator.TaxonNodeNavigatorComparator;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.LoginManager;

import eu.etaxonomy.taxeditor.ui.element.LayoutConstants;

import eu.etaxonomy.taxeditor.workbench.part.ICollapsableExpandable;

/**

 *

 * @author pplitzner

 * @since Sep 7, 2017

 *

 */

public class TaxonNavigatorE4 implements

		IPostOperationEnabled, IConversationEnabled, Observer,

		ICdmEntitySessionEnabled, ICdmChangeListener, IContextListener,

		ICollapsableExpandable {

    private static final String RESTORING_TAXON_NAVIGATOR = Messages.TaxonNavigator_RESTORE;

	private static final String TREE_PATH = "treepath"; //$NON-NLS-1$

	private static final String TREE_PATHS = "treepaths"; //$NON-NLS-1$

	private final int dndOperations = DND.DROP_MOVE;

	private ConversationHolder conversation;

	private ICdmEntitySession cdmEntitySession;

	private IDataChangeBehavior dataChangeBehavior;

	private Root root;

	private TreeViewer viewer;

    @Inject

    private ESelectionService selService;

    @Inject

    private UISynchronize sync;

    private ISelectionChangedListener selectionChangedListener;

    private UndoContext undoContext;

    @Inject

    private MPart thisPart;

    @Inject

    private MApplication application;

    @Inject

    private EModelService modelService;

    @Inject

    private EPartService partService;

    private boolean linkWithTaxon = false;

    @Inject

    public TaxonNavigatorE4() {

	    undoContext = new UndoContext();

	    CdmStore.getContextManager().addContextListener(this);

    }

	@PostConstruct

	private void create(Composite parent, EMenuService menuService, ECommandService commandService){

	    FillLayout layout = new FillLayout();

	    layout.marginHeight = 0;

	    layout.marginWidth = 0;

	    layout.type = SWT.VERTICAL;

	    parent.setLayout(layout);

	    viewer = new TreeViewer(parent);

	    viewer.getControl().setLayoutData(LayoutConstants.FILL());

	    viewer.setContentProvider(new TaxonNavigatorContentProviderE4());

        viewer.setLabelProvider(new TaxonNavigatorLabelProviderE4());

        viewer.addDoubleClickListener(event->{

            ISelection selection = event.getSelection();

            if(selection instanceof IStructuredSelection){

                Object firstElement = ((IStructuredSelection) selection).getFirstElement();

                if(firstElement instanceof ICdmBase){

                    NavigationUtil.openEditor((ICdmBase) firstElement, viewer.getControl().getShell(), modelService, partService, application);

                }

            }

        });

        //propagate selection

        selectionChangedListener = (event -> selService.setSelection(event.getSelection()));

        viewer.addSelectionChangedListener(selectionChangedListener);

        //create context menu

        menuService.registerContextMenu(viewer.getControl(), "eu.etaxonomy.taxeditor.navigator.popupmenu.taxonnavigator");

        //add drag'n'drop support

        Transfer[] transfers = new Transfer[] {LocalSelectionTransfer.getTransfer()};

        viewer.addDragSupport(dndOperations, transfers, new TreeNodeDragListenerE4(viewer));

        viewer.addDropSupport(dndOperations, transfers, new TreeNodeDropAdapterE4(this));

        //add toolbar

//        MToolBar toolBar = MMenuFactory.INSTANCE.createToolBar();

//        MHandledToolItem linkWithEditor = MMenuFactory.INSTANCE.createHandledToolItem();

//        linkWithEditor.setIconURI("platform:/plugin/eu.etaxonomy.taxeditor.store/icons/synced.gif");

//        Command command = commandService.getCommand("eu.etaxonomy.taxeditor.navigation.command.linkWithTaxon");

//        MCommand mCommand = MCommandsFactory.INSTANCE.createCommand();

//        mCommand.setElementId(command.getId());

//        try {

//            mCommand.setCommandName(command.getName());

//        } catch (NotDefinedException e) {

//            e.printStackTrace();

//        }

//        linkWithEditor.setCommand(mCommand);

//        linkWithEditor.setType(ItemType.CHECK);

//        toolBar.getChildren().add(linkWithEditor);

//        thisPart.setToolbar(toolBar);

	    init();

	}

	/** {@inheritDoc} */

	protected IAdaptable getInitialInput() {

		Comparator<TaxonNode> comparator;

		if (PreferencesUtil.getSortNodesNaturally()){

			comparator = new TaxonNaturalComparator();

		} else if (PreferencesUtil.getSortNodesStrictlyAlphabetically()){

			comparator = new TaxonNodeByNameComparator();

		}else {

			comparator = new TaxonNodeByRankAndNameComparator();

		}

		TaxonNodeNavigatorComparator viewerComparator = new TaxonNodeNavigatorComparator(comparator);

		viewer.setComparator(viewerComparator);

		if (CdmStore.isActive()) {

			// TODO when closing and reopening the taxon navigator

			// we do not preserve state. Closing the view, in contrary to

			// closing the whole application

			// should be handled by the state manager too

		    root = new Root(conversation);

			return root;

		}

		return new EmptyRoot();

	}

	public void init() {

		if (CdmStore.isActive() && conversation == null) {

			conversation = CdmStore.createConversation();

			conversation.registerForDataStoreChanges(TaxonNavigatorE4.this);

		}

		if (CdmStore.isActive()) {

		    cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);

		    CdmApplicationState.getCurrentDataChangeService().register(this);

		}

		CdmStore.getLoginManager().addObserver(this);

        viewer.setInput(getInitialInput());

	}

	//Link with taxon selection

	@Inject

	@Optional

	private void updateCurrentTaxon(@UIEventTopic(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR)ITaxonEditor editor){

	    if(linkWithTaxon){

	        viewer.refresh();

	        TaxonNode taxonNode = null;

	        if(editor.getTaxon()!=null && editor.getTaxon().getTaxonNodes()!=null){

	            taxonNode = editor.getTaxon().getTaxonNodes().iterator().next();

	            viewer.reveal(taxonNode);

	            viewer.setSelection(new StructuredSelection(taxonNode));

	        }

	    }

	}

    public void setLinkWithTaxon(boolean linkWithTaxon) {

        this.linkWithTaxon = linkWithTaxon;

    }

    public boolean isLinkWithTaxon() {

        return linkWithTaxon;

    }

	/**

	 * Refresh this navigators viewer

	 */

	public void refresh() {

		if(getConversationHolder() != null){

			getConversationHolder().bind();

			//FIXME : Need to make sure this is a stable fix (ticket 3822)

			if(!getConversationHolder().isCompleted()){

			    getConversationHolder().commit();

			}

		}

		if(!viewer.getTree().isDisposed()){

		    viewer.refresh();

		}

	}

	/**

     * Refresh this navigators viewer

     */

    public void refresh(Set<?> objects) {

        for(Object obj : objects) {

            viewer.refresh(obj);

        }

    }

	/**

	 * Removes all content

	 */

	public void clear() {

	    viewer.setInput(new EmptyRoot());

	}

	public void restore(IMemento memento, IProgressMonitor monitor) {

	    root = new Root(conversation);

		if (memento == null) {

		    viewer.setInput(root);

			return;

		}

		int mementoWork = 0;

		Set<TreePath> treePaths = new HashSet<TreePath>();

		IMemento[] treePathMementos = null;

		IMemento treePathsMemento = memento.getChild(TREE_PATHS);

		if (treePathsMemento != null) {

			treePathMementos = treePathsMemento.getChildren(TREE_PATH);

			mementoWork = treePathMementos.length;

		}

		// begin the monitor with steps for all tree paths and steps for

		// creating

		// conversation s.o., refreshing the tree and setting the paths

		IProgressMonitor subProgressMonitor = NavigationUtil

				.getSubProgressMonitor(monitor, 1);

		subProgressMonitor.beginTask(RESTORING_TAXON_NAVIGATOR,

				1 + mementoWork + 5);

		subProgressMonitor.subTask(RESTORING_TAXON_NAVIGATOR);

		subProgressMonitor.worked(1);

		conversation = CdmStore.createConversation();

		subProgressMonitor.worked(1);

		conversation.registerForDataStoreChanges(TaxonNavigatorE4.this);

		subProgressMonitor.worked(1);

		viewer.setInput(root);

		subProgressMonitor.worked(1);

		viewer.refresh();

		subProgressMonitor.worked(1);

		if (treePathMementos != null && treePathMementos.length > 0) {

			for (IMemento treePathMemento : treePathMementos) {

				TreePath treePath = createTreePathFromString(treePathMemento

						.getID());

				if (!subProgressMonitor.isCanceled() && treePath != null) {

					treePaths.add(treePath);

					subProgressMonitor.worked(1);

				}

			}

		}

		if (treePaths.size() > 0) {

			TaxonNavigatorE4.this.viewer.setExpandedTreePaths(

					treePaths.toArray(new TreePath[0]));

			subProgressMonitor.worked(1);

		}

		subProgressMonitor.done();

	}

	private TreePath createTreePathFromString(String string) {

		List<CdmBase> pathList = new ArrayList<CdmBase>();

		if (string.length() == 0) {

            return null;

        }

		for (String uuid : string.split(" ")) { //$NON-NLS-1$

			CdmBase cdmBaseObject = CdmStore.getService(

					IClassificationService.class).getTaxonNodeByUuid(

					UUID.fromString(uuid));

			if (cdmBaseObject == null) {

				// is this a tree uuid?

				cdmBaseObject = CdmStore.getService(

						IClassificationService.class).load(

						UUID.fromString(uuid));

				if (cdmBaseObject == null) {

                    return null;

                }

			}

			pathList.add(cdmBaseObject);

		}

		return new TreePath(pathList.toArray());

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public void collapse() {

	    viewer.collapseAll();

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public void expand() {

	    viewer.expandAll();

	}

	@Override

	public ConversationHolder getConversationHolder() {

		return conversation;

	}

	/** {@inheritDoc} */

	@PreDestroy

	public void dispose() {

		dataChangeBehavior = null;

		if (conversation != null) {

			conversation.unregisterForDataStoreChanges(this);

		}

		if(cdmEntitySession != null) {

		    cdmEntitySession.dispose();

		}

		if(CdmApplicationState.getCurrentDataChangeService() != null) {

		    CdmApplicationState.getCurrentDataChangeService().unregister(this);

		}

	}

	/** {@inheritDoc} */

	@Focus

	public void setFocus() {

		if (getConversationHolder() != null) {

			getConversationHolder().bind();

		}

		if(cdmEntitySession != null) {

		    cdmEntitySession.bind();

		}

	}

    public UISynchronize getSync() {

        return sync;

    }

    public TreeViewer getViewer() {

        return viewer;

    }

    public UndoContext getUndoContext() {

        return undoContext;

    }

	/** {@inheritDoc} */

	@Override

	public boolean postOperation(CdmBase objectAffectedByOperation) {

	    viewer.refresh();

		return true;

	}

	@Override

	public boolean onComplete() {

		return true;

	}

	@Override

	public void update(Observable o, Object arg) {

		if(o instanceof LoginManager){

			refresh();

		}

	}

	   /** {@inheritDoc} */

    @Override

    public void update(CdmDataChangeMap changeEvents) {

        if (dataChangeBehavior == null) {

            dataChangeBehavior = new TaxonNavigatorDataChangeBehaviorE4(this);

        }

        DataChangeBridge.handleDataChange(changeEvents, dataChangeBehavior);

    }

    @Override

    public ICdmEntitySession getCdmEntitySession() {

       return cdmEntitySession;

    }

    @Override

    public List<ITreeNode> getRootEntities() {

        if(root != null) {

            return root.getParentBeans();

        }

        return null;

    }

    @Override

    public void onChange(CdmChangeEvent event) {

        refresh();

        for(CdmBase cb : event.getChangedObjects()) {

        	if(cb instanceof TaxonNode) {

                TaxonNode tn = (TaxonNode)cb;

                if(tn.getTaxon() == null) {

                    viewer.refresh(tn.getClassification());

                } else {

                    viewer.refresh(cb);

                }

            } else if (cb instanceof Classification) {

                viewer.refresh();

            }

        }

    }

    @Override

    public Map<Object, List<String>> getPropertyPathsMap() {

        Map<Object, List<String>> propertyPathsMap = new HashMap<Object, List<String>>();

        List<String> taxonNodePropertyPaths = Arrays.asList(new String[] {

                "taxon.name" //$NON-NLS-1$

        });

         propertyPathsMap.put("childNodes", taxonNodePropertyPaths); //$NON-NLS-1$

        return propertyPathsMap;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {

        // TODO Auto-generated method stub

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void contextStop(IMemento memento, IProgressMonitor monitor) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void contextStart(IMemento memento, IProgressMonitor monitor) {

        if(viewer!=null){

            init();

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void contextRefresh(IProgressMonitor monitor) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {

    }

}