EDIT

// $Id$

/**

* Copyright (C) 2014 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.derivate;

import org.eclipse.jface.util.LocalSelectionTransfer;

import org.eclipse.jface.viewers.TreeNode;

import org.eclipse.jface.viewers.ViewerDropAdapter;

import org.eclipse.swt.dnd.TransferData;

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

import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;

import eu.etaxonomy.cdm.model.molecular.DnaSample;

import eu.etaxonomy.cdm.model.molecular.Sequence;

import eu.etaxonomy.cdm.model.molecular.SingleRead;

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.view.derivateSearch.DerivateLabelProvider;

/**

 * @author pplitzner

 * @date 18.03.2014

 *

 */

public class DerivateDropListener extends ViewerDropAdapter {

    private final DerivateView derivateView;

    /**

     * @param derivateView

     */

    protected DerivateDropListener(DerivateView derivateView) {

        super(derivateView.getViewer());

        this.derivateView = derivateView;

    }

    /* (non-Javadoc)

     * @see org.eclipse.jface.viewers.ViewerDropAdapter#performDrop(java.lang.Object)

     */

    @Override

    public boolean performDrop(Object data) {

        if(derivateView.isDirty()){

            AbstractUtility.warningDialog("View has unsaved changes", this, "You need to save before performing this action");

            return false;

        }

        Object target = getCurrentTarget();

        if(target instanceof TreeNode && data instanceof DerivateViewSelection){

            DerivateViewSelection derivateViewSelection = (DerivateViewSelection)data;

            TreeNode targetNode = (TreeNode) target;

            TreeNode draggednode = EditorUtil.getTreeNodeOfSelection(derivateViewSelection.getSelection());

            if(draggednode!=null){

                if(moveTreeNode(draggednode, targetNode)){

                    //update DerivateView

                    derivateView.getConversationHolder().commit();

                    derivateView.refreshTree();

                    // update source DerivateView if dragging between different views occured

                    DerivateView sourceDerivateView = derivateViewSelection.getDerivateView();

                    if(sourceDerivateView!=derivateView){

                        sourceDerivateView.getConversationHolder().commit();

                        sourceDerivateView.refreshTree();

                    }

                    //FIXME: way too much overhead for just refreshing the other DerivateView

//                    CdmStore.getContextManager().notifyContextRefresh();

                    LocalSelectionTransfer.getTransfer().setSelection(null);

                    return true;

                }

                else{

                    AbstractUtility.warningDialog("Moving derivate not possible!", derivateView, "Moving \""+DerivateLabelProvider.getDerivateText(draggednode)+"\" to \""+DerivateLabelProvider.getDerivateText(targetNode)+"\" is not possible!");

                }

            }

        }

        return false;

    }

    /* (non-Javadoc)

     * @see org.eclipse.jface.viewers.ViewerDropAdapter#validateDrop(java.lang.Object, int, org.eclipse.swt.dnd.TransferData)

     */

    @Override

    public boolean validateDrop(Object target, int operation, TransferData transferType) {

        return LocalSelectionTransfer.getTransfer().isSupportedType(transferType) && target instanceof TreeNode;

    }

    /**

     * @param value

     * @return

     */

    private boolean moveTreeNode(TreeNode draggedNode, TreeNode targetNode) {

        Object draggedNodeValue = draggedNode.getValue();

        Object targetNodeValue = targetNode.getValue();

        TreeNode fromParentNode = draggedNode.getParent();

        Object fromParentSpecimen = fromParentNode.getValue();

        // drag'n'drop for SpecimenOrObservationBase

        IOccurrenceService occurrenceService = CdmStore.getService(IOccurrenceService.class);

        if(draggedNodeValue instanceof DerivedUnit && targetNodeValue instanceof SpecimenOrObservationBase<?>){

            DerivedUnit draggedSpecimen = (DerivedUnit) draggedNodeValue;

            SpecimenOrObservationBase<?> targetSpecimen = (SpecimenOrObservationBase<?>) targetNodeValue;

            //check if type is a sub derivate type

            if(!fromParentNode.equals(targetNode)//don't drag on direct parent node

                    && fromParentSpecimen instanceof SpecimenOrObservationBase<?>){

                return occurrenceService.moveDerivate((SpecimenOrObservationBase<?>)fromParentSpecimen, targetSpecimen, draggedSpecimen);

            }

        }

        // drag'n'drop for SingleRead

        else if(draggedNodeValue instanceof SingleRead && targetNodeValue instanceof Sequence){

            SingleRead singleRead = (SingleRead) draggedNodeValue;

            if(fromParentSpecimen instanceof Sequence){

                return CdmStore.getService(ISequenceService.class).moveSingleRead((Sequence)fromParentSpecimen, (Sequence)targetNodeValue, singleRead);

            }

        }

        // drag'n'drop for Sequence

        else if(draggedNodeValue instanceof Sequence && targetNodeValue instanceof DnaSample ){

            Sequence sequence = (Sequence)draggedNodeValue;

            if(fromParentSpecimen instanceof DnaSample){

                return occurrenceService.moveSequence((DnaSample)fromParentSpecimen, (DnaSample)targetNodeValue, sequence);

            }

        }

        return false;

    }

}