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

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.core.runtime.NullProgressMonitor;

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.description.DescriptionBase;

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

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

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

import eu.etaxonomy.cdm.model.metadata.EnabledComputedDescription;

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

import eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

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

import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;

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

/**

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

        DescriptionBase<?> description = null;

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

            Object object = iter.next();

            if (object instanceof DescriptionElementBase) {

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

                description = ((DescriptionElementBase) object).getInDescription();

                DescriptionElementBase element ;

                if (((DescriptionElementBase) object).getId() > 0){

                    element = CdmStore.getService(IDescriptionService.class).loadDescriptionElement(uuid, null);

                }else{

                    element = ((DescriptionElementBase) object);

                }

                elements.add(element);

            } else if (object instanceof FeatureNodeContainer) {

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

                    DescriptionElementBase element ;

                    if (de.getId() > 0){

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

                    }else{

                        element = (de);

                    }

                    description = de.getInDescription();

                    elements.add(element);

                }

            }

        }

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

            return;

        }

        if (elements.get(0) != null){

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

            }

        }

        UUID classificationUuid = null;

        if (classification != null){

            classificationUuid = classification.getUuid();

        }

        TaxonNode newAcceptedTaxonNode = TaxonNodeSelectionDialog.select(shell,

                Messages.MoveDescriptionElementsHandler_CHOOSE_ACC_TAXON,

                excludeTaxa,

                null, classificationUuid

                );

        if (newAcceptedTaxonNode != null){

            Taxon targetTaxon = newAcceptedTaxonNode.getTaxon();

            if(targetTaxon == null){

                // canceled

                return;

            }

            newAcceptedTaxonNodeUuid = newAcceptedTaxonNode.getUuid();

            Collection<IE4SavablePart> targetEditors = EditorUtil.checkForTaxonChanges(targetTaxon.getUuid(), partService);

            if (!targetEditors.isEmpty() || this.editor.isDirty()){

                if(MessageDialog.openQuestion(null,Messages.MoveDescriptionToOtherTaxonHandler_SAVE_CHANGES, Messages.MoveDescriptionToOtherTaxonHandler_SAVE_CHANGES_MESSAGE)){

                    this.editor.save(new NullProgressMonitor());

                    targetEditors.forEach(editor->editor.save(new NullProgressMonitor()));

                    return;

                }

                else{

                    return;

                }

            }

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

            AbstractPostTaxonOperation operation = new MoveDescriptionElementsOperation(

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

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

            editor.getEditorInput().addOperation(operation);

            for (DescriptionElementBase element: elements)

            {

                element.getInDescription().removeElement(element);

            }

            editor.redraw();

            editor.setDirty();

            //AbstractUtility.executeOperation(operation, sync);

        }

    }

    @Override

    public boolean postOperation(Object 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();

        boolean isComputedDisabled = PreferencesUtil.isComputedDesciptionHandlingDisabled();

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

        if(e4WrappedPart instanceof TaxonNameEditorE4){

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

            if(selection instanceof IStructuredSelection){

                boolean selectionProviding = factualDataPart.getSelectionProvidingPart().getObject() instanceof TaxonNameEditorE4;

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

                canExecute = ((firstElement instanceof FeatureNodeContainer && !(((FeatureNodeContainer)firstElement).getContainerTree().getDescription() instanceof TaxonNameDescription))

                                    || (firstElement instanceof DescriptionElementBase && !(((DescriptionElementBase)firstElement).getInDescription() instanceof TaxonNameDescription)))

                            && ((firstElement instanceof FeatureNodeContainer && !(((FeatureNodeContainer)firstElement).getDescription().isComputed() && isComputedDisabled))

                                    || (firstElement instanceof DescriptionElementBase && !(((DescriptionElementBase)firstElement).getInDescription().isComputed() && isComputedDisabled))) ;

                menuItem.setVisible(canExecute);

            }

        }

        return canExecute;

    }

}