EDIT

/**

* Copyright (C) 2015 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.operation;

import java.util.Set;

import java.util.UUID;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.swt.widgets.Display;

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

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

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

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

import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;

import eu.etaxonomy.taxeditor.event.EventUtility;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

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

import eu.etaxonomy.taxeditor.navigation.navigator.e4.TaxonNavigatorE4;

import eu.etaxonomy.taxeditor.navigation.navigator.e4.TreeNodeDropAdapterE4.MovingType;

import eu.etaxonomy.taxeditor.operation.IPostMoniteredOperationEnabled;

import eu.etaxonomy.taxeditor.operation.RemotingCdmUpdateOperation;

/**

 * @author cmathew

 * @date 19 Jun 2015

 *

 */

public class RemotingMoveTaxonOperation extends RemotingCdmUpdateOperation implements IPostMoniteredOperationEnabled {

    private final static String LABEL = Messages.RemotingMoveTaxonOperation_MOVE_OP;

    private Set<UUID> taxonNodesToMoveUuid;

    private final UUID newParentTreeNodeUuid;

    private final MovingType moveToParentNode;

    private TaxonNavigatorE4 taxonNavigator;

    public RemotingMoveTaxonOperation(Object source,

            boolean async,

            Set<UUID> taxonNodeToMoveUuid,

            UUID newParentTreeNodeUuid,

            MovingType moveToParentNode) {

        super(LABEL, Action.Update, source,async);

        taxonNodesToMoveUuid = taxonNodeToMoveUuid;

        this.newParentTreeNodeUuid = newParentTreeNodeUuid;

        this.moveToParentNode = moveToParentNode;

    }

//    public RemotingMoveTaxonOperation(Object source,

//            boolean async,

//            List<TaxonNode> taxonNodeToMove,

//            TaxonNode newParentTreeNode,

//            MovingType moveToParentNode) {

//        super(LABEL, Action.Update, source,async);

//

//        taxonNodesToMoveUuid=taxonNodeToMove;

//        this.newParentTreeNodeUuid = newParentTreeNode.getUuid();

//        this.moveToParentNode = moveToParentNode;

//    }

//    /**

//     * @param source

//     * @param async

//     * @param uuids

//     * @param uuid

//     * @param child

//     */

//    public RemotingMoveTaxonOperation(Object source, boolean async, Set<UUID> uuids, UUID uuid,

//            MovingType child) {

//        super(LABEL, Action.Update, source,async);

//        this.taxonNodesToMoveUuid = uuids;

//        this.newParentTreeNodeUuid = uuid;

//        this.moveToParentNode = child;

//    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.operation.RemotingCdmUpdateOperation#doUpdateExecute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)

     */

    @Override

    protected UpdateResult doUpdateExecute(IProgressMonitor monitor, IAdaptable info) throws Exception {

//        switch (this.moveToParentNode) {

//            case CHILD:

//                return CdmApplicationState.getService(ITaxonNodeService.class).moveTaxonNodes(taxonNodesToMoveUuid,

//                        newParentTreeNodeUuid, 0);

//            case BEHIND:

//                runMoniteredOperation();

//                return updateResult;

//             default:

//                    UpdateResult result = new UpdateResult();

//                    result.setAbort();

//                    result.addException(new Exception("The moving type is invalid.")); //$NON-NLS-1$

//                    return result;

//        }

        runMoniteredOperation();

//        taxonNavigator.refresh();

        return updateResult;

    }

    public void runMoniteredOperation() {

        ITaxonNodeService nodeService;

        final UUID uuid;

        int movingTypeInt = -1;

        switch (this.moveToParentNode) {

        case CHILD:

            movingTypeInt = 0;

            break;

        case BEHIND:

            movingTypeInt = 2;

            break;

         default:

                updateResult = new UpdateResult();

                updateResult.setAbort();

                updateResult.addException(new Exception("The moving type is invalid.")); //$NON-NLS-1$

         }

        if (movingTypeInt >-1){

            uuid = CdmApplicationState.getLongRunningTasksService().monitLongRunningTask(taxonNodesToMoveUuid,

                newParentTreeNodeUuid, movingTypeInt);

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

                    @Override

                    public void run() {

                        AbstractUtility.executeMoniteredOperation("Move Taxon to new parent: ",

                                uuid,

                                1000,

                                false,

                                RemotingMoveTaxonOperation.this,

                                null);

                    }

                });

        }

//        monitor.done();

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void postOperation(IRemotingProgressMonitor monitor) {

        monitor.done();

        EventUtility.postEvent(WorkbenchEventConstants.REFRESH_NAVIGATOR, true);

    }

}