EDIT

// $Id$

/**

 * 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;

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 org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.TreePath;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.IViewSite;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.navigator.CommonNavigator;

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

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

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

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.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.model.DataChangeBridge;

import eu.etaxonomy.taxeditor.model.IDataChangeBehavior;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.navigation.NavigationUtil;

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;

/**

 * Taxonomic tree implementation using Common Navigator Framework.

 *

 * @author p.ciardelli

 * @author n.hoffmann

 * @created 02.06.2009

 * @version 1.0

 */

public class TaxonNavigator extends CommonNavigator implements

		IPostOperationEnabled, IConversationEnabled, Observer,

		ICdmEntitySessionEnabled, ICdmChangeListener {

	/**

	 * Constant

	 * <code>ID="eu.etaxonomy.taxeditor.navigation.navig"{trunked}</code>

	 */

	public static final String ID = "eu.etaxonomy.taxeditor.navigation.navigator"; //$NON-NLS-1$

	private static final String TREE_PATH = "treepath";

	private static final String TREE_PATHS = "treepaths";

	private ConversationHolder conversation;

	private ICdmEntitySession cdmEntitySession;

	private String partNameCache;

	private IDataChangeBehavior dataChangeBehavior;

	private Root root;

	/*

	 * (non-Javadoc)

	 *

	 * @see org.eclipse.ui.navigator.CommonNavigator#getInitialInput()

	 */

	/** {@inheritDoc} */

	@Override

	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);

		this.getCommonViewer().setComparator(viewerComparator);

        setLinkingEnabled(true);

//		this.getCommonViewer().addSelectionChangedListener(new ISelectionChangedListener() {

//

//			@Override

//			public void selectionChanged(SelectionChangedEvent arg0) {

//				IStructuredSelection selection = (IStructuredSelection) getCommonViewer().getSelection();

//

//				Object firstElement =  selection.getFirstElement();

//				//

//				if (!(firstElement instanceof Classification)){

//					//NavigationUtil.selectInNavigator(firstElement, null);

//					NavigationUtil.openEditor(firstElement);

//				}

//

//			}

//		} );

		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();

	}

	/** {@inheritDoc} */

	@Override

	public void init(IViewSite site) throws PartInitException {

		super.init(site);

		init();

	}

	/**

	 * <p>

	 * init

	 * </p>

	 */

	public void init() {

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

			conversation = CdmStore.createConversation();

			conversation.registerForDataStoreChanges(TaxonNavigator.this);

		}

		if (CdmStore.isActive()) {

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

		    CdmApplicationState.getCurrentDataChangeService().register(this);

		}

		CdmStore.getLoginManager().addObserver(this);

	}

	/**

	 * 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(!getCommonViewer().getTree().isDisposed()){

		    getCommonViewer().refresh();

		}

	}

	   /**

     * Refresh this navigators viewer

     */

    public void refresh(Set<?> objects) {

        for(Object obj : objects) {

            getCommonViewer().refresh(obj);

        }

    }

	/**

	 * Removes all content

	 */

	public void clear() {

		getCommonViewer().setInput(new EmptyRoot());

	}

	/**

	 * <p>

	 * restore

	 * </p>

	 *

	 * @param memento

	 *            a {@link org.eclipse.ui.IMemento} object.

	 * @param monitor

	 *            a {@link org.eclipse.core.runtime.IProgressMonitor} object.

	 */

	public void restore(IMemento memento, IProgressMonitor monitor) {

	    root = new Root(conversation);

		if (memento == null) {

			getCommonViewer().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(TaxonNavigator.this);

		subProgressMonitor.worked(1);

		getCommonViewer().setInput(root);

		subProgressMonitor.worked(1);

		getCommonViewer().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) {

			TaxonNavigator.this.getCommonViewer().setExpandedTreePaths(

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

			subProgressMonitor.worked(1);

		}

		subProgressMonitor.done();

	}

	/**

	 * @param string

	 * @return

	 */

	private TreePath createTreePathFromString(String string) {

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

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

            return null;

        }

		for (String uuid : string.split(" ")) {

			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 saveState(IMemento aMemento) {

		//

	}

	/**

	 * <p>

	 * saveTreeState

	 * </p>

	 *

	 * @param memento

	 *            a {@link org.eclipse.ui.IMemento} object.

	 * @param progressMonitor

	 *            a {@link org.eclipse.core.runtime.IProgressMonitor} object.

	 */

	public void saveTreeState(IMemento memento, IProgressMonitor progressMonitor) {

		if (memento == null) {

			return;

		}

		IProgressMonitor monitor = NavigationUtil.getSubProgressMonitor(

				progressMonitor, 1);

		super.saveState(memento);

		memento = memento.createChild(TREE_PATHS);

		TreePath[] treePaths = this.getCommonViewer().getExpandedTreePaths();

		monitor.beginTask("Saving Taxon Navigator State", treePaths.length);

		for (TreePath treePath : treePaths) {

			int pathLength = treePath.getSegmentCount();

			String path = "";

			for (int i = 0; i < pathLength; i++) {

				Object segment = treePath.getSegment(i);

				if (segment instanceof CdmBase) {

					path += ((CdmBase) segment).getUuid().toString() + " ";

					monitor.worked(1);

				} else {

					MessagingUtils.warn(getClass(),

							"Non-taxon tree path segment " + segment);

				}

			}

			memento.createChild(TREE_PATH, path.trim());

		}

		monitor.done();

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see

	 * eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder

	 * ()

	 */

	/**

	 * <p>

	 * getConversationHolder

	 * </p>

	 *

	 * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder}

	 *         object.

	 */

	@Override

	public ConversationHolder getConversationHolder() {

		return conversation;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see

	 * eu.etaxonomy.cdm.persistence.hibernate.ICdmPostDataChangeObserver#update

	 * (eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap)

	 */

	/** {@inheritDoc} */

	@Override

	public void update(CdmDataChangeMap changeEvents) {

		if (dataChangeBehavior == null) {

			dataChangeBehavior = new TaxonNavigatorDataChangeBehavior(this);

		}

		DataChangeBridge.handleDataChange(changeEvents, dataChangeBehavior);

	}

	/** {@inheritDoc} */

	@Override

	public String getFrameToolTipText(Object element) {

		if (element instanceof Root) {

			return "Taxonomic Tree";

		}

		return super.getFrameToolTipText(element);

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.eclipse.ui.part.WorkbenchPart#dispose()

	 */

	/** {@inheritDoc} */

	@Override

	public void dispose() {

		super.dispose();

		dataChangeBehavior = null;

		if (conversation != null) {

			conversation.unregisterForDataStoreChanges(this);

		}

		if(cdmEntitySession != null) {

		    cdmEntitySession.dispose();

		}

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

		    CdmApplicationState.getCurrentDataChangeService().unregister(this);

		}

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.eclipse.ui.navigator.CommonNavigator#setFocus()

	 */

	/** {@inheritDoc} */

	@Override

	public void setFocus() {

		// logger.warn("Setting focus to navigator");

		super.setFocus();

		if (getConversationHolder() != null) {

			getConversationHolder().bind();

		}

		if(cdmEntitySession != null) {

		    cdmEntitySession.bind();

		}

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see

	 * eu.etaxonomy.taxeditor.operations.IPostOperationEnabled#postOperation

	 * (eu.etaxonomy.cdm.model.common.CdmBase)

	 */

	/** {@inheritDoc} */

	@Override

	public boolean postOperation(CdmBase objectAffectedByOperation) {

		// nothing to do here

		return true;

	}

	/**

	 * <p>

	 * save

	 * </p>

	 *

	 * @param memento

	 *            a {@link org.eclipse.ui.IMemento} object.

	 * @param monitor

	 *            a {@link org.eclipse.core.runtime.IProgressMonitor} object.

	 */

	public void save(IMemento memento, IProgressMonitor monitor) {

		saveTreeState(memento, monitor);

		if (conversation != null) {

			conversation.unregisterForDataStoreChanges(this);

			conversation = null;

		}

	}

	/** {@inheritDoc} */

	@Override

	protected void handleDoubleClick(DoubleClickEvent event) {

		ISelection selection = event.getSelection();

		if(selection instanceof IStructuredSelection){

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

			if(firstElement instanceof ICdmBase){

				NavigationUtil.openEditor((ICdmBase) firstElement);

			}

		}

		// If the double click is passed up to the super-class it will

		// expand/collapse trees.

		// We do not want that

		// super.handleDoubleClick(anEvent);

	}

	/**

	 * <p>

	 * onComplete

	 * </p>

	 *

	 * @return a boolean.

	 */

	@Override

	public boolean onComplete() {

		return true;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.eclipse.ui.part.WorkbenchPart#showBusy(boolean)

	 */

	/** {@inheritDoc} */

	@Override

	public void showBusy(boolean busy) {

		super.showBusy(busy);

		getCommonViewer().getControl().setEnabled(!busy);

		if (busy) {

			partNameCache = getPartName();

			setPartName("Loading datasources");

		} else {

			if (partNameCache != null) {

				setPartName(partNameCache);

			}

		}

	}

	/* (non-Javadoc)

	 * @see java.util.Observer#update(java.util.Observable, java.lang.Object)

	 */

	@Override

	public void update(Observable o, Object arg) {

		if(o instanceof LoginManager){

			refresh();

		}

	}

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getCdmEntitySession()

     */

    @Override

    public ICdmEntitySession getCdmEntitySession() {

       return cdmEntitySession;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getRootEntities()

     */

    @Override

    public List<Classification> getRootEntities() {

        if(root != null) {

            return root.getParentBeans();

        }

        return null;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.application.ICdmChangeListener#onChange(eu.etaxonomy.cdm.api.application.CdmChangeEvent)

     */

    @Override

    public void onChange(CdmChangeEvent event) {

        if(event.getAction() == Action.Delete && Classification.class.equals(event.getEntityType())) {

            refresh();

            return;

        }

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

            if(cb instanceof TaxonNode) {

                TaxonNode tn = (TaxonNode)cb;

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

                    getCommonViewer().refresh(tn.getClassification());

                } else {

                    getCommonViewer().refresh(cb);

                }

            } else if (cb instanceof Classification) {

                getCommonViewer().refresh();

            }

        }

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getPropertyPathsMap()

     */

    @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"

        });

         propertyPathsMap.put("childNodes", taxonNodePropertyPaths);

        return propertyPathsMap;

    }

}