EDIT

/**

 *

 */

package eu.etaxonomy.taxeditor.editor.view.descriptive.e4.handler;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import javax.inject.Named;

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

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

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

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.model.application.ui.menu.MHandledMenuItem;

import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;

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

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

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

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.EditorUtil;

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

import eu.etaxonomy.taxeditor.editor.name.e4.TaxonNameEditorE4;

import eu.etaxonomy.taxeditor.editor.view.descriptive.e4.FactualDataPartE4;

import eu.etaxonomy.taxeditor.editor.view.descriptive.operation.MoveDescriptionToOtherTaxonOperation;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.FeatureNodeContainer;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.ui.dialog.selection.TaxonNodeSelectionDialog;

import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;

/**

 *

 * @author pplitzner

 * @date 15.08.2017

 *

 */

public class MoveDescriptionToOtherTaxonHandlerE4 implements IPostOperationEnabled {

    private MoveDescriptionToOtherTaxonOperation operation;

    private UUID newAcceptedTaxonNodeUuid;

    private UUID oldAcceptedTaxonNodeUuid;

    private UUID newAcceptedTaxonUuid;

    private UUID oldAcceptedTaxonUuid;

    private TaxonNameEditorE4 editor;

    private MApplication application;

    private EModelService modelService;

    private EPartService partService;

    @Execute

    public void execute(@Named(IServiceConstants.ACTIVE_PART) MPart activePart,

            @Optional @Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection,

            @Named(IServiceConstants.ACTIVE_SHELL) Shell shell, MMenuItem menuItem, EPartService partService,

            EModelService modelService, MApplication application, UISynchronize sync) {

        this.modelService = modelService;

        this.application = application;

        this.partService = partService;

        FactualDataPartE4 factualDataPart = (FactualDataPartE4) activePart.getObject();

        Object e4WrappedPart = WorkbenchUtility.getE4WrappedPart(factualDataPart.getSelectionProvidingPart());

        if(e4WrappedPart instanceof TaxonNameEditorE4){

            editor = (TaxonNameEditorE4) e4WrappedPart;

        }

        List<TaxonDescription> descriptions = new ArrayList<TaxonDescription>();

        TaxonDescription description = null;

        Object selectedElement = selection.getFirstElement();

        if (selectedElement instanceof FeatureNodeContainer){

        	FeatureNodeContainer container = (FeatureNodeContainer)selectedElement;

        	description = (TaxonDescription) container.getDescription();

        }else if (selectedElement instanceof TaxonDescription){

        	description = (TaxonDescription)selectedElement;

        }

        descriptions.add(description);

        // Choose the target taxon

        //get current taxon node

        TaxonNode node = null;

        Classification classification = null;

        if(editor!=null){

            node = editor.getEditorInput().getTaxonNode();

            oldAcceptedTaxonUuid = editor.getTaxon().getUuid();

            oldAcceptedTaxonNodeUuid = node.getUuid();

            classification = node.getClassification();

        }

        Set<UUID> excludeTaxa = new HashSet<>();

        excludeTaxa.add(oldAcceptedTaxonNodeUuid);

        TaxonNode newAcceptedTaxonNode = TaxonNodeSelectionDialog.select(shell,

//                editor.getConversationHolder(),

                Messages.MoveDescriptionToOtherTaxonHandler_CHOOSE_ACC_TAXON,

                excludeTaxa,

                node,

                classification.getUuid());

        if (newAcceptedTaxonNode == null) {

            return ;

        }

        newAcceptedTaxonNodeUuid = newAcceptedTaxonNode.getUuid();

        newAcceptedTaxonUuid = newAcceptedTaxonNode.getTaxon().getUuid();

        MPart targetEditor = EditorUtil.checkForChanges(newAcceptedTaxonUuid, partService);

        if ((targetEditor != null && targetEditor.getElementId().equals("eu.etaxonomy.taxeditor.editor.name.e4.TaxonNameEditorE4")) || this.editor.isDirty()){

            boolean proceed = MessageDialog.openQuestion(null,

                    Messages.MoveDescriptionToOtherTaxonHandler_SAVE_CHANGES, Messages.MoveDescriptionToOtherTaxonHandler_SAVE_CHANGES_MESSAGE);

            if (proceed) {

                if (targetEditor != null){

                    e4WrappedPart = WorkbenchUtility.getE4WrappedPart(targetEditor);

                    ((TaxonNameEditorE4)e4WrappedPart).save(AbstractUtility.getMonitor());

                }

                if (editor.isDirty()){

                    editor.save(AbstractUtility.getMonitor());

                }

            } else {

                return;

            }

        }

        for(TaxonDescription taxonDescription : descriptions){

            operation = new MoveDescriptionToOtherTaxonOperation(menuItem.getLocalizedLabel(),

                    editor.getUndoContext(),

                    taxonDescription,

                    newAcceptedTaxonNode,

                    this,

                    editor,

                    editor.getEditorInput());

            AbstractUtility.executeOperation(operation, sync);

        }

    }

    /** {@inheritDoc} */

    @Override

    public boolean postOperation(CdmBase objectAffectedByOperation) {

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

            @Override

            public void run() {

                //FIXME E4 migrate

//                AbstractUtility.close(editor);

//

                try {

//                    MultiPageTaxonEditor possibleOpenEditor = (MultiPageTaxonEditor) EditorUtil.findEditorByTaxonNodeUuid(newAcceptedTaxonNodeUuid);

//                    if(possibleOpenEditor != null){

//                        AbstractUtility.close(possibleOpenEditor);

//                    }

//                    EventUtility.postEvent(WorkbenchEventConstants.REFRESH_NAME_EDITOR, oldAcceptedTaxonNodeUuid);

//                    EventUtility.postEvent(WorkbenchEventConstants.REFRESH_NAME_EDITOR, newAcceptedTaxonNodeUuid);

                    EditorUtil.openTaxonNodeE4(newAcceptedTaxonNodeUuid, modelService, partService, application);

                    EditorUtil.openTaxonNodeE4(oldAcceptedTaxonNodeUuid, modelService, partService, application);

//                } catch (PartInitException e) {

//                    MessagingUtils.error(this.getClass(), e);

//                    throw new RuntimeException(e);

                } catch (Exception e) {

                    MessagingUtils.warningDialog(Messages.MoveDescriptionToOtherTaxonHandler_CREATE_FAILED, this, e.getMessage());

                }

            }

        });

        return true;

    }

    @Override

    public boolean onComplete() {

        return false;

    }

    @CanExecute

    public boolean canExecute(@Optional @Named(IServiceConstants.ACTIVE_PART) MPart activePart,

            MHandledMenuItem menuItem){

        boolean canExecute = false;

        FactualDataPartE4 factualDataPart = (FactualDataPartE4) activePart.getObject();

        Object e4WrappedPart = WorkbenchUtility.getE4WrappedPart(factualDataPart.getSelectionProvidingPart());

        if(e4WrappedPart instanceof TaxonNameEditorE4){

            ISelection selection = factualDataPart.getViewer().getSelection();

            if(selection instanceof IStructuredSelection){

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

                canExecute = ((IStructuredSelection) selection).size()==1

                        &&

                        (firstElement instanceof FeatureNodeContainer

                        || firstElement instanceof DescriptionElementBase

                        || firstElement instanceof DescriptionBase);

                menuItem.setVisible(canExecute);

            }

        }

        return canExecute;

    }

}