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.editor.view.descriptive.e4.handler;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

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.api.service.IDescriptionService;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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.Taxon;

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.MoveDescriptionElementsOperation;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.FeatureNodeContainer;

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.store.CdmStore;

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

import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;

/**

 *

 * @author pplitzner

 * @date 15.08.2017

 *

 */

public class MoveDescriptionElementsHandlerE4 implements IPostOperationEnabled{

    private UUID newAcceptedTaxonNodeUuid;

    private UUID oldAcceptedTaxonNodeUuid;

    private TaxonNameEditorE4 editor;

    private MApplication application;

    private EModelService modelService;

    private EPartService partService;

    @Execute

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

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

        IStructuredSelection viewselection = (IStructuredSelection) factualDataPart.getViewer().getSelection();

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

        if(e4WrappedPart instanceof TaxonNameEditorE4){

            editor = (TaxonNameEditorE4) e4WrappedPart;

        }

        Taxon actualTaxon= null;

        List<DescriptionElementBase> elements = new ArrayList<DescriptionElementBase>();

        for (Iterator iter = viewselection.iterator(); iter.hasNext();) {

            Object object = iter.next();

            if (object instanceof DescriptionElementBase) {

                UUID uuid = ((DescriptionElementBase) object).getUuid();

                elements.add(CdmStore.getService(IDescriptionService.class).loadDescriptionElement(uuid, null));

            } else if (object instanceof FeatureNodeContainer) {

                for (DescriptionElementBase de : ((FeatureNodeContainer) object).getDescriptionElements()) {

                    elements.add(

                            CdmStore.getService(IDescriptionService.class).loadDescriptionElement(de.getUuid(), null));

                }

            }

        }

        if(elements.size() == 0){

            return;

        }

        DescriptionBase description = elements.get(0).getInDescription();

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

        if (description!=null && description.isInstanceOf(TaxonDescription.class)){

            TaxonDescription taxonDescription = HibernateProxyHelper.deproxy(description, TaxonDescription.class);

            actualTaxon = taxonDescription.getTaxon();

        }

        Classification classification = null;

        TaxonNode actualNode = null;

        if (actualTaxon != null){

            if (!actualTaxon.getTaxonNodes().isEmpty() && actualTaxon.getTaxonNodes().size() ==1){

                actualNode = actualTaxon.getTaxonNodes().iterator().next();

                oldAcceptedTaxonNodeUuid = actualNode.getUuid();

                excludeTaxa.add(oldAcceptedTaxonNodeUuid);

                classification = actualNode.getClassification();

            }

        }

        TaxonNode newAcceptedTaxonNode = TaxonNodeSelectionDialog.select(shell,

//                editor.getConversationHolder(),

                Messages.MoveDescriptionElementsHandler_CHOOSE_ACC_TAXON,

                excludeTaxa,

                null, classification.getUuid()

                );

        if (newAcceptedTaxonNode != null){

            Taxon targetTaxon = newAcceptedTaxonNode.getTaxon();

            if(targetTaxon == null){

                // canceled

                return;

            }

            newAcceptedTaxonNodeUuid = newAcceptedTaxonNode.getUuid();

            MPart targetEditor = EditorUtil.checkForChanges(targetTaxon.getUuid(), 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;

                }

            }

            String moveMessage = String.format(Messages.MoveDescriptionElementsHandler_ELEMENTS_MOVED, editor.getTaxon());

            AbstractPostOperation operation = new MoveDescriptionElementsOperation(

                    menuItem.getLocalizedLabel(), EditorUtil.getUndoContext(),

                    targetTaxon.getUuid(), moveMessage, elements, false, this, null);

            AbstractUtility.executeOperation(operation, sync);

        }

    }

    /** {@inheritDoc} */

    @Override

    public boolean postOperation(CdmBase objectAffectedByOperation) {

        editor.getConversationHolder().bind();

        editor.getConversationHolder().commit(true);

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

            @Override

            public void run() {

                //AbstractUtility.close(editor.getMultiPageTaxonEditor());

                    //FIXME E4 migrate

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

//                    if(possibleOpenEditor != null){

//                        AbstractUtility.close(possibleOpenEditor);

//                    }

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

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

            }

        });

        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 = firstElement instanceof FeatureNodeContainer

                        || firstElement instanceof DescriptionElementBase;

                menuItem.setVisible(canExecute);

            }

        }

        return canExecute;

    }

}