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;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.eclipse.core.commands.Command;

import org.eclipse.core.commands.ParameterizedCommand;

import org.eclipse.core.commands.common.NotDefinedException;

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

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

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorReference;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.commands.ICommandService;

import org.eclipse.ui.handlers.IHandlerService;

import org.eclipse.ui.navigator.CommonViewer;

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

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

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

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

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

import eu.etaxonomy.cdm.model.description.PolytomousKey;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.TaxonEditorInput;

import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.navigation.internal.TaxeditorNavigationPlugin;

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

import eu.etaxonomy.taxeditor.newWizard.NewClassificationWizard;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;

/**

 * <p>NavigationUtil class.</p>

 *

 * @author n.hoffmann

 * @created 24.03.2009

 * @version 1.0

 */

public class NavigationUtil extends AbstractUtility{

	private static IUndoContext defaultUndoContext;

	/**

	 * <p>openEditor</p>

	 *

	 * @param selectedObject a {@link eu.etaxonomy.cdm.model.common.CdmBase} object.

	 */

	public static void openEditor(UuidAndTitleCache uuidAndTitleCache){

	    Class type = uuidAndTitleCache.getType();

	    ICdmBase cdmBase = null;

	    if(type.equals(Classification.class)){

	        cdmBase = CdmStore.getService(IClassificationService.class).load(uuidAndTitleCache.getUuid());

	    }

	    else if(type.equals(TaxonNode.class)){

	    	cdmBase = CdmStore.getService(ITaxonNodeService.class).load(uuidAndTitleCache.getUuid());

	    }

	    else if(TaxonBase.class.isAssignableFrom(type)){

	    	cdmBase = CdmStore.getService(ITaxonService.class).load(uuidAndTitleCache.getUuid());

	    }

	    else if(type.equals(TaxonNameBase.class)){

	    	cdmBase = CdmStore.getService(INameService.class).load(uuidAndTitleCache.getUuid());

	    }

	    else{

	        MessagingUtils.warningDialog("Unknown type", NavigationUtil.class, "There is no editor available to open this object.");

	    }

	    if(cdmBase!=null){

	    	openEditor(cdmBase);

	    }

	    else{

	    	MessagingUtils.warningDialog("Cdm entity not found", NavigationUtil.class, "CDM entity could not be found in the database.");

	    }

	}

	public static void openEditor(ICdmBase selectedObject){

		UUID entityUuid = selectedObject.getUuid();

		try {

			if(selectedObject instanceof Classification){

		        NewClassificationWizard classificationWizard = new NewClassificationWizard();

		        classificationWizard.init(null, null);

		        classificationWizard.setEntity((Classification) selectedObject);

		        WizardDialog dialog = new WizardDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), classificationWizard);

		        dialog.open();

			}

			else if(selectedObject instanceof TaxonNode){

				EditorUtil.openTaxonNode(entityUuid);

			}else if(selectedObject instanceof TaxonBase){

				TaxonBase taxonBase = (TaxonBase)selectedObject;

				if(taxonBase.isOrphaned()){

					openInBulkEditor(taxonBase);

				}

				else{

					EditorUtil.openTaxonBase(entityUuid);

				}

			}else if(selectedObject instanceof TaxonNameBase){

				openInBulkEditor(selectedObject);

			}else if(selectedObject instanceof PolytomousKey){

				EditorUtil.openPolytomousKey(entityUuid);

			}else{

				MessagingUtils.warningDialog("Unsupported Type", NavigationUtil.class, "No editor exists for the current selection: " + selectedObject);

			}

		} catch (PartInitException e) {

			MessagingUtils.error(NavigationUtil.class, "Error opening the editor", e);

		} catch (Exception e) {

		    MessagingUtils.errorDialog("Could not create Taxon",

		            NavigationUtil.class,

		            e.getMessage(), TaxeditorStorePlugin.PLUGIN_ID,

		            e,

		            true);

		}

	}

	private static void openInBulkEditor(ICdmBase selectedObject) {

		ICommandService commandService = (ICommandService)PlatformUI.getWorkbench().getService(ICommandService.class);

		IHandlerService handlerService = (IHandlerService)PlatformUI.getWorkbench().getService(IHandlerService.class);

		String openInBulkEditorCommand = "eu.etaxonomy.taxeditor.bulkeditor.openBulkEditorForIdentifiableEntity";

		Command command = commandService.getCommand(openInBulkEditorCommand);

		if(command.isDefined()){

			Map<String, UUID> params = new HashMap<String, UUID>();

			params.put(openInBulkEditorCommand+".uuid", ((ICdmBase) selectedObject).getUuid()); //$NON-NLS-1$

			ParameterizedCommand parameterizedCommand = ParameterizedCommand.generateCommand(command, params);

			try {

				if(parameterizedCommand!=null){

					handlerService.executeCommand(parameterizedCommand, null);

					return;

				}

				else{

					handlerService.executeCommand(command.getId(), null);

					return;

				}

			} catch (NotDefinedException nde) {

				throw new RuntimeException("Could not find open command: " + command.getId()); //$NON-NLS-1$

			} catch (Exception exception) {

				MessagingUtils.error(NavigationUtil.class, "An exception occured while trying to execute "+command.getId(), exception); //$NON-NLS-1$

			}

		}

	}

	/**

	 * <p>openEmpty</p>

	 *

	 * @param parentNodeUuid a {@link java.util.UUID} object.

	 */

	public static void openEmpty(UUID parentNodeUuid) {

		try {

			EditorUtil.openEmpty(parentNodeUuid);

		} catch (PartInitException e) {

			MessagingUtils.error(NavigationUtil.class, "Error opening the editor", e);

		}

	}

	/**

	 * <p>getShell</p>

	 *

	 * @return a {@link org.eclipse.swt.widgets.Shell} object.

	 */

	public static Shell getShell() {

		return getActiveWindow().getShell();

	}

	/**

	 * <p>getActiveWindow</p>

	 *

	 * @return a {@link org.eclipse.ui.IWorkbenchWindow} object.

	 */

	public static IWorkbenchWindow getActiveWindow() {

		return TaxeditorNavigationPlugin.getDefault().getWorkbench().

				getActiveWorkbenchWindow();

	}

	/**

	 * <p>getWorkbenchUndoContext</p>

	 *

	 * @return a {@link org.eclipse.core.commands.operations.IUndoContext} object.

	 */

	public static IUndoContext getWorkbenchUndoContext() {

		return TaxeditorEditorPlugin.getDefault().getWorkbench().

					getOperationSupport().getUndoContext();

	}

	/**

	 * <p>getUndoContext</p>

	 *

	 * @return a {@link org.eclipse.core.commands.operations.IUndoContext} object.

	 */

	public static IUndoContext getUndoContext() {

		// FIXME this has to be more specific. Every widget has to have its own undo context

//		return IOperationHistory.GLOBAL_UNDO_CONTEXT;

		// Plug-ins that wish their operations to be undoable from workbench views

		// such as the Navigator or Package Explorer should assign the workbench

		// undo context to their operations.

		if (defaultUndoContext == null) {

			defaultUndoContext = new UndoContext();

		}

		return defaultUndoContext;

	}

	/**

	 * Whether a taxonNode has unsaved changes.

	 *

	 * @param taxonNode a {@link eu.etaxonomy.cdm.model.taxon.TaxonNode} object.

	 * @return a boolean.

	 */

	public static boolean isDirty(TaxonNode taxonNode){

		for (IEditorReference reference : getActivePage().getEditorReferences()) {

			try {

				if (reference.getEditorInput() instanceof TaxonEditorInput) {

					TaxonEditorInput editorInput = (TaxonEditorInput) reference.getEditorInput();

					if(editorInput.getTaxonNode().equals(taxonNode) && reference.isDirty()){

						return true;

					}

				}

			} catch (PartInitException e) {

				MessagingUtils.error(NavigationUtil.class, e.getMessage(), e);

				throw new RuntimeException(e);

			}

		}

		return false;

	}

	/**

	 * <p>selectInNavigator</p>

	 *

	 * @param element a {@link java.lang.Object} object.

	 * @param parentElement a {@link java.lang.Object} object.

	 */

	public static void selectInNavigator(final Object element, final Object parentElement) {

		Display.getDefault().asyncExec(new Runnable(){

			@Override

            public void run() {

				TaxonNavigator navigator = showNavigator();

				if (navigator != null) {

					CommonViewer viewer = navigator.getCommonViewer();

					if (viewer != null) {

						if (parentElement != null) {

							viewer.setExpandedState(parentElement, true);

						}

						viewer.setSelection(new StructuredSelection(element));

					}

				}

			}

		});

	}

	/**

	 * <p>openSearch</p>

	 *

	 * @param selection a {@link java.lang.Object} object.

	 */

	public static void openSearch(Object selection) {

		if(selection instanceof Taxon){

			Taxon taxon = (Taxon) selection;

			handleOpeningOfMultipleTaxonNodes(taxon.getTaxonNodes());

		}else if(selection instanceof Synonym){

			Synonym synonym = (Synonym) selection;

			Set<Taxon> accTaxa = new HashSet<Taxon>();

			if (synonym.getAcceptedTaxon() != null){

				accTaxa.add(synonym.getAcceptedTaxon());

			}

			handleOpeningOfMultipleTaxa(accTaxa);

		}else{

			MessagingUtils.warningDialog("Not implemented yet", NavigationUtil.class, "You chose to open a name that has no connection to a taxon. The Editor does not support editing of such a content type at the moment.");

		}

	}

	private static void handleOpeningOfMultipleTaxa(Set<Taxon> acceptedTaxa) {

		if(acceptedTaxa.size() == 1){

			openEditor(acceptedTaxa.iterator().next());

		}else if(acceptedTaxa.size() > 1){

			// FIXME implement a dialog that shows all possible taxa and let the user choose which he wants to open.

			MessagingUtils.warningDialog("Not implemented yet", NavigationUtil.class, "The accepted taxon is in multiple taxonomic trees. We currently do not know which one you want to open." +

					" This case is not handled yet by the software.");

		}else if(acceptedTaxa.size() == 0){

			// this is an undesired state

			MessagingUtils.warningDialog("Not implemented yet", NavigationUtil.class, "This taxon is not connected to a classification. Currently editing of such taxa is not supported yet.");

		}

	}

	/**

	 * @param taxonNodes

	 */

	private static void handleOpeningOfMultipleTaxonNodes(

			Set<TaxonNode> taxonNodes) {

		if(taxonNodes.size() == 1){

			openEditor(taxonNodes.iterator().next());

		}else if(taxonNodes.size() > 1){

			// FIXME implement a dialog that shows all possible taxa and let the user choose which he wants to open.

			MessagingUtils.warningDialog("Not implemented yet", NavigationUtil.class, "The accepted taxon is in multiple taxonomic trees. We currently do not know which one you want to open." +

					" This case is not handled yet by the software.");

		}else if(taxonNodes.size() == 0){

			// this is an undesired state

			MessagingUtils.warningDialog("Incorrect state", NavigationUtil.class, "The accepted taxon is not in a taxonomic view. This should not have happened.");

		}

	}

	/**

	 * <p>showNavigator</p>

	 *

	 * @return the TaxonNavigator instance if present

	 */

	public static TaxonNavigator showNavigator() {

		return (TaxonNavigator) showView(TaxonNavigator.ID);

	}

	/**

	 * <p>getNavigator</p>

	 *

	 * @param restore a boolean.

	 * @return a {@link eu.etaxonomy.taxeditor.navigation.navigator.TaxonNavigator} object.

	 */

	public static TaxonNavigator getNavigator(boolean restore) {

		return (TaxonNavigator) getView(TaxonNavigator.ID, restore);

	}

	/**

	 * <p>getOpenEditors</p>

	 *

	 * @return a {@link java.util.Set} object.

	 */

	public static Set<IEditorPart> getOpenEditors() {

		return EditorUtil.getOpenEditors();

	}

	/**

	 * <p>getPluginId</p>

	 *

	 * @return a {@link java.lang.String} object.

	 */

	public static String getPluginId(){

		return TaxeditorNavigationPlugin.PLUGIN_ID;

	}

}