EDIT

/**

* Copyright (C) 2017 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.featuretree.e4;

import java.net.URI;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.jface.util.LocalSelectionTransfer;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerDropAdapter;

import org.eclipse.swt.dnd.TransferData;

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;

import eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer;

import eu.etaxonomy.taxeditor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.store.CdmStore;

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

import eu.etaxonomy.taxeditor.view.webimport.termimport.parser.ParserUtil;

import eu.etaxonomy.taxeditor.view.webimport.termimport.wrapper.OntologyTermWrapper;

public class FeatureNodeDropAdapter extends ViewerDropAdapter {

    private MDirtyable dirtyable;

    public FeatureNodeDropAdapter(MDirtyable dirtyable, Viewer viewer) {

		super(viewer);

		this.dirtyable = dirtyable;

	}

	@Override

	public boolean performDrop(Object data) {

		Object currentTarget = getCurrentTarget();

		FeatureNode target = null;

		if(currentTarget instanceof FeatureTree){

		    target = ((FeatureTree) currentTarget).getRoot();

		}

		else if(currentTarget instanceof FeatureNode){

		    target = (FeatureNode) currentTarget;

		}

		int position = 0;

		if (target != null) {

			int location = getCurrentLocation();

			FeatureNode parent = target.getParent();

			if(parent!=null){

			    if (location == LOCATION_BEFORE) {

			        position = Math.max(0, parent.getIndex(target) - 1);

			        target = parent;

			    }

			    if (location == LOCATION_AFTER) {

			        position = parent.getIndex(target);

			        target = parent;

			    }

			}

		}

        if(target==null){

            MessagingUtils.warningDialog(Messages.FeatureNodeDropAdapter_INVALID_TARGET, this, Messages.FeatureNodeDropAdapter_INVALID_TARGET_MESSAGE);

            return false;

        }

		Collection<Object> droppedObjects = Collections.emptyList();

		if(data instanceof Object[]){

		    droppedObjects = Arrays.asList((Object[])data);

		}

		else if(data instanceof IStructuredSelection){

		    droppedObjects = ((IStructuredSelection) data).toList();

		}

		TreeViewer viewer = (TreeViewer) getViewer();

		// cannot drop a feature node onto itself

		for (Object droppedObject : droppedObjects) {

			if (droppedObject.equals(target)) {

				return false;

			}

		}

		for (Object droppedObject : droppedObjects) {

		    if(droppedObject instanceof FeatureNode){

		        FeatureNode droppedNode = (FeatureNode) droppedObject;

		        CdmStore.getService(IFeatureNodeService.class).moveFeatureNode(droppedNode.getUuid(), target.getUuid(), position);

		        viewer.reveal(droppedNode);

		    }

		    else if(droppedObject instanceof Feature){

		        Feature droppedFeature = (Feature) droppedObject;

		        CdmStore.getService(IFeatureNodeService.class).addChildFeatureNode(target.getUuid(), droppedFeature.getUuid());

		    }

		    else if(droppedObject instanceof OntologyTermWrapper){

		        OntologyTermWrapper wrapper = (OntologyTermWrapper)droppedObject;

		        TermVocabulary vocabulary = wrapper.getTermVocabulary();

		        if(vocabulary==null){

		            vocabulary =  TermVocabularySelectionDialog.select(

		                    "Choose vocabulary for import", viewer.getControl().getShell(), null);

		            if(vocabulary instanceof OrderedTermVocabulary){

		                MessagingUtils.warningDialog("Import not possible", this,

		                        "The chosen vocabulary is an ordered vocabulary.\n"

		                                + "Importing into ordered vocabularies is currently not supported.");

		                return false;

		            }

		        }

		        if(vocabulary!=null){

		            if(wrapper.getDescription()==null && MessagingUtils.confirmDialog("Load Details?", "Not all details for this term have been loaded yet.\n"

		                    + "Do you want to load the details before adding it?")){

		                ParserUtil.loadDetails(wrapper);

		            }

		            Feature feature = Feature.NewInstance(wrapper.getDescription(), wrapper.getLabel(), null);

		            feature.setUri(URI.create(wrapper.getUri()));

		            vocabulary.addTerm(feature);

		            CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(target, feature);

		        }

		    }

		}

		dirtyable.setDirty(true);

		viewer.refresh();

		return true;

	}

    @Override

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

        boolean isSupported = FeatureNodeTransfer.getInstance().isSupportedType(transferData);

        isSupported |= TermTransfer.getInstance().isSupportedType(transferData);

        isSupported |= LocalSelectionTransfer.getTransfer().isSupportedType(transferData);

        isSupported &= getViewer().getInput()!=null;

        return isSupported;

    }

}