/*
 * Copyright (c) 2014 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.oomph.internal.ui;

import org.eclipse.oomph.base.util.BaseResourceFactoryImpl;

import org.eclipse.emf.common.CommonPlugin;
import org.eclipse.emf.common.EMFPlugin;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.common.util.UniqueEList;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EPackage.Registry;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EStructuralFeature.Setting;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.EPackageRegistryImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.BinaryResourceImpl;
import org.eclipse.emf.ecore.resource.impl.BinaryResourceImpl.EObjectInputStream;
import org.eclipse.emf.ecore.resource.impl.BinaryResourceImpl.EObjectOutputStream;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.BasicInternalEList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.EcoreUtil.Copier;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.emf.ecore.xml.namespace.XMLNamespacePackage;
import org.eclipse.emf.ecore.xml.type.XMLTypePackage;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.ui.dnd.LocalTransfer;

import org.eclipse.core.resources.IResource;
import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.dnd.TransferData;
import org.eclipse.swt.dnd.URLTransfer;

import org.xml.sax.InputSource;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.AbstractSequentialList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

/**
 * @author Ed Merks
 */
public abstract class OomphTransferDelegate
{
  private static final List<OomphTransferDelegate> MODIFIABLE_DELEGATES = new ArrayList<OomphTransferDelegate>();

  public static final List<? extends OomphTransferDelegate> DELEGATES = Collections.unmodifiableList(MODIFIABLE_DELEGATES);

  public static final List<? extends Transfer> TRANSFERS = asTransfers(MODIFIABLE_DELEGATES);

  public static Transfer[] transfers()
  {
    return TRANSFERS.toArray(new Transfer[TRANSFERS.size()]);
  }

  public static List<? extends Transfer> asTransfers(final List<? extends OomphTransferDelegate> delegates)
  {
    return new AbstractSequentialList<Transfer>()
    {
      @Override
      public ListIterator<Transfer> listIterator(final int index)
      {
        return new ListIterator<Transfer>()
        {
          ListIterator<? extends OomphTransferDelegate> delegate = delegates.listIterator(index);

          public boolean hasNext()
          {
            return delegate.hasNext();
          }

          public Transfer next()
          {
            return delegate.next().getTransfer();
          }

          public boolean hasPrevious()
          {
            return delegate.hasPrevious();
          }

          public Transfer previous()
          {
            return delegate.previous().getTransfer();
          }

          public int nextIndex()
          {
            return delegate.nextIndex();
          }

          public int previousIndex()
          {
            return delegate.previousIndex();
          }

          public void remove()
          {
            throw new UnsupportedOperationException();
          }

          public void set(Transfer o)
          {
            throw new UnsupportedOperationException();
          }

          public void add(Transfer o)
          {
            throw new UnsupportedOperationException();
          }
        };
      }

      @Override
      public int size()
      {
        return delegates.size();
      }
    };
  }

  private static void register(OomphTransferDelegate delegate, List<OomphTransferDelegate> delegates)
  {
    int priority = delegate.priority();
    for (ListIterator<OomphTransferDelegate> it = delegates.listIterator(); it.hasNext();)
    {
      if (it.next().priority() > priority)
      {
        it.add(delegate);
        return;
      }
    }

    delegates.add(delegate);
  }

  public static void register(OomphTransferDelegate delegate)
  {
    register(delegate, MODIFIABLE_DELEGATES);
  }

  public static OomphTransferDelegate getDelegate(Transfer transfer, Collection<? extends OomphTransferDelegate> delegates)
  {
    for (OomphTransferDelegate delegate : delegates)
    {
      if (delegate.getTransfer() == transfer)
      {
        return delegate;
      }
    }

    return null;
  }

  public static List<? extends OomphTransferDelegate> merge(Collection<? extends OomphTransferDelegate> delegates,
      Collection<? extends OomphTransferDelegate> overridingDelegates)
  {
    return merge(delegates, overridingDelegates.toArray(new OomphTransferDelegate[overridingDelegates.size()]));
  }

  public static List<? extends OomphTransferDelegate> merge(Collection<? extends OomphTransferDelegate> delegates, OomphTransferDelegate... overridingDelegates)
  {
    List<OomphTransferDelegate> result = new ArrayList<OomphTransferDelegate>();
    LOOP: for (OomphTransferDelegate delegate : delegates)
    {
      Transfer transfer = delegate.getTransfer();
      for (OomphTransferDelegate overridingDelegate : overridingDelegates)
      {
        if (overridingDelegate.getTransfer() == transfer)
        {
          register(overridingDelegate, result);
          continue LOOP;
        }
      }

      register(delegate, result);
    }

    for (OomphTransferDelegate overridingDelegate : overridingDelegates)
    {
      if (!result.contains(overridingDelegate))
      {
        register(overridingDelegate, result);
      }
    }

    return result;
  }

  public abstract Transfer getTransfer();

  public boolean isSupportedType(TransferData transferData)
  {
    return getTransfer().isSupportedType(transferData);
  }

  public TransferData[] getSupportedTypes()
  {
    return getTransfer().getSupportedTypes();
  }

  public abstract Collection<?> getData(EditingDomain domain, TransferData transferData);

  public abstract Collection<?> getValue(EditingDomain domain, Object data);

  public abstract boolean setSelection(EditingDomain domain, ISelection selection);

  public abstract Object getData();

  public abstract void clear();

  protected int priority()
  {
    return 0;
  }

  @Override
  public String toString()
  {
    return super.toString() + " " + Arrays.asList(getTransfer().getSupportedTypes());
  }

  public abstract static class SelectionTransferDelegate extends OomphTransferDelegate
  {
    protected Collection<?> extractSelectedObjects(Object... objects)
    {
      List<Object> result = new ArrayList<Object>();
      for (Object object : objects)
      {
        Object filteredObject = filter(object);
        if (filteredObject != null)
        {
          result.add(filteredObject);
        }
      }

      return result;
    }

    protected Object filter(Object object)
    {
      if (object instanceof Resource)
      {
        Resource resource = (Resource)object;
        return resource.getURI();
      }
      else if (EMFPlugin.IS_RESOURCES_BUNDLE_AVAILABLE)
      {
        URI uri = EclipseHelper.getURI(object);
        if (uri != null)
        {
          return uri;
        }
      }

      return object;
    }
  }

  public abstract static class ResourceSetTransferDelegate extends OomphTransferDelegate
  {
    protected static final Resource.Factory RESOURCE_FACTORY = new BaseResourceFactoryImpl();

    protected ResourceSet createResourceSet(EditingDomain domain)
    {
      final ResourceSet resourceSet = domain.getResourceSet();
      ResourceSet result = new ResourceSetImpl()
      {
        @Override
        protected Resource delegatedGetResource(URI uri, boolean loadOnDemand)
        {
          Resource result = super.delegatedGetResource(uri, loadOnDemand);
          if (result == null)
          {
            resourceSet.getResource(uri, false);
          }
          return result;
        }
      };

      result.setURIConverter(resourceSet.getURIConverter());
      result.setPackageRegistry(new EPackageRegistryImpl(resourceSet.getPackageRegistry()));
      result.getResourceFactoryRegistry().getExtensionToFactoryMap().put("xmi", RESOURCE_FACTORY);

      return result;
    }
  }

  public static class LocalTransferDelegate extends SelectionTransferDelegate
  {
    protected final LocalTransfer localTransfer = LocalTransfer.getInstance();

    protected ISelection selection;

    @Override
    public Transfer getTransfer()
    {
      return localTransfer;
    }

    @Override
    public Collection<?> getData(EditingDomain domain, TransferData transferData)
    {
      return getValue(domain, localTransfer.nativeToJava(transferData));
    }

    @Override
    public Collection<?> getValue(EditingDomain domain, Object data)
    {
      if (data instanceof IStructuredSelection)
      {
        IStructuredSelection selection = (IStructuredSelection)data;
        return extractSelectedObjects(selection.toArray());
      }

      return Collections.emptyList();
    }

    @Override
    public boolean setSelection(EditingDomain domain, ISelection selection)
    {
      if (!selection.isEmpty())
      {
        this.selection = selection;
        return true;
      }

      return false;
    }

    @Override
    public Object getData()
    {
      return selection;
    }

    @Override
    public void clear()
    {
      selection = null;
    }
  }

  static
  {
    register(new LocalTransferDelegate());
  }

  public static class LocalSelectionTransferDelegate extends SelectionTransferDelegate
  {
    protected final LocalSelectionTransfer localSelectionTransfer = LocalSelectionTransfer.getTransfer();

    @Override
    public Transfer getTransfer()
    {
      return localSelectionTransfer;
    }

    @Override
    public Collection<?> getData(EditingDomain domain, TransferData transferData)
    {
      return getValue(domain, localSelectionTransfer.nativeToJava(transferData));
    }

    @Override
    public Collection<?> getValue(EditingDomain domain, Object data)
    {
      if (data instanceof IStructuredSelection)
      {
        IStructuredSelection selection = (IStructuredSelection)data;
        return extractSelectedObjects(selection.toArray());
      }

      return Collections.emptyList();
    }

    @Override
    public boolean setSelection(EditingDomain domain, ISelection selection)
    {
      if (!selection.isEmpty())
      {
        localSelectionTransfer.setSelection(selection);
        localSelectionTransfer.setSelectionSetTime(System.currentTimeMillis());
        return true;
      }

      return false;
    }

    @Override
    public Object getData()
    {
      return localSelectionTransfer.getSelection();
    }

    @Override
    public void clear()
    {
      localSelectionTransfer.setSelection(null);
    }
  }

  static
  {
    register(new LocalSelectionTransferDelegate());
  }

  public static class OomphBinaryTransferDelegate extends ResourceSetTransferDelegate
  {
    protected final OomphBinaryTransfer oomphBinaryTransfer = OomphBinaryTransfer.getInstance();

    protected Set<EObject> eObjects;

    protected byte[] data;

    @Override
    public Transfer getTransfer()
    {
      return oomphBinaryTransfer;
    }

    @Override
    public Collection<?> getData(EditingDomain domain, TransferData transferData)
    {
      return getValue(domain, oomphBinaryTransfer.nativeToJava(transferData));
    }

    @Override
    public Collection<?> getValue(EditingDomain domain, Object data)
    {
      if (data instanceof byte[])
      {
        byte[] bytes = (byte[])data;
        try
        {
          final ResourceSet transferResourceSet = createResourceSet(domain);

          // Create a stream to load the binary representation.
          ByteArrayInputStream in = new ByteArrayInputStream(bytes);
          EObjectInputStream eObjectInputStream = new BinaryResourceImpl.EObjectInputStream(in, null)
          {
            {
              resourceSet = transferResourceSet;
            }
          };

          // Read all the packages first.
          InternalEList<InternalEObject> ePackages = new BasicInternalEList<InternalEObject>(EPackage.class);
          eObjectInputStream.loadEObjects(ePackages);

          // Process the packages, putting each one in a resource in a resource set.
          Registry packageRegistry = transferResourceSet.getPackageRegistry();
          for (EPackage ePackage : ePackages.toArray(new EPackage[ePackages.size()]))
          {
            Resource resource = transferResourceSet.createResource(URI.createURI("*.ecore"));
            resource.getContents().add(ePackage);
            resource.setURI(ePackage.eResource().getURI());

            // Check if there is a registered package available already.
            String nsURI = ePackage.getNsURI();
            EPackage registeredEPackage = packageRegistry.getEPackage(nsURI);
            if (registeredEPackage == null)
            {
              // If not, register this dynamic package.
              packageRegistry.put(nsURI, ePackage);
            }
            else
            {
              // If so, convert all the objects to proxies and so dynamic packages will extend the generated packages.
              Map<EObject, String> fragments = new LinkedHashMap<EObject, String>();
              for (Iterator<EObject> it = resource.getAllContents(); it.hasNext();)
              {
                EObject eObject = it.next();
                fragments.put(eObject, resource.getURIFragment(eObject));
              }

              URI uri = URI.createURI(nsURI);
              for (Map.Entry<EObject, String> entry : fragments.entrySet())
              {
                ((InternalEObject)entry.getKey()).eSetProxyURI(uri.appendFragment(entry.getValue()));
              }
            }
          }

          // Read in all the objects, which will use the appropriate registered packages.
          InternalEList<InternalEObject> eObjects = new BasicInternalEList<InternalEObject>(EObject.class);
          eObjectInputStream.loadEObjects(eObjects);
          Resource resource = transferResourceSet.createResource(URI.createURI("*.xmi"));
          resource.getContents().addAll(eObjects);

          return eObjects;
        }
        catch (IOException ex)
        {
          SWTException swtException = new SWTException(DND.ERROR_INVALID_DATA, ex.getMessage());
          swtException.initCause(ex);
          throw swtException;
        }
      }

      return Collections.emptyList();
    }

    @Override
    public boolean setSelection(EditingDomain domain, ISelection selection)
    {
      if (!selection.isEmpty() && selection instanceof IStructuredSelection)
      {
        eObjects = new LinkedHashSet<EObject>();
        for (Object object : ((IStructuredSelection)selection).toArray())
        {
          gather(domain, object);
        }

      }

      return !eObjects.isEmpty();
    }

    protected void gather(EditingDomain domain, Object object)
    {
      Object unwrappedObject = AdapterFactoryEditingDomain.unwrap(object);
      if (unwrappedObject instanceof EObject)
      {
        EObject eObject = (EObject)unwrappedObject;
        eObjects.add(eObject);
      }
    }

    @Override
    public Object getData()
    {
      if (!eObjects.isEmpty())
      {
        // Determine the packages of all the instances that will be copied.
        EList<EPackage> ePackages = new UniqueEList<EPackage>();
        for (Iterator<EObject> it = EcoreUtil.getAllContents(eObjects); it.hasNext();)
        {
          EObject eObject = it.next();
          ePackages.add(eObject.eClass().getEPackage());
        }

        // Determine the closure of all packages.
        for (int i = 0; i < ePackages.size(); ++i)
        {
          EPackage ePackage = ePackages.get(i);
          for (Iterator<EObject> it = ePackage.eAllContents(); it.hasNext();)
          {
            EObject eObject = it.next();
            for (EObject eCrossReference : eObject.eCrossReferences())
            {
              EObject rootContainer = EcoreUtil.getRootContainer(eCrossReference);
              if (rootContainer instanceof EPackage)
              {
                ePackages.add((EPackage)rootContainer);
              }
            }
          }
        }

        // Ignore the ubiquitously available packages.
        ePackages.remove(EcorePackage.eINSTANCE);
        ePackages.remove(XMLTypePackage.eINSTANCE);
        ePackages.remove(XMLNamespacePackage.eINSTANCE);

        // Create a specialized copier for copying the packages and the EObjects.
        class Copier extends EcoreUtil.Copier
        {
          private static final long serialVersionUID = 1L;

          Map<EObject, EObject> packageCopies;

          public Copier()
          {
            super(true, true);
          }

          @Override
          protected EClass getTarget(EClass eClass)
          {
            // Map to the copied package metadata.
            if (packageCopies != null)
            {
              return (EClass)packageCopies.get(eClass);
            }

            return eClass;
          }

          @Override
          protected EStructuralFeature getTarget(EStructuralFeature eStructuralFeature)
          {
            // Map to the copied package metadata.
            if (packageCopies != null)
            {
              return (EStructuralFeature)packageCopies.get(eStructuralFeature);
            }

            return eStructuralFeature;
          }

          @Override
          protected void copyAttribute(EAttribute eAttribute, EObject eObject, EObject copyEObject)
          {
            if (eAttribute.getEAttributeType().isSerializable())
            {
              super.copyAttribute(eAttribute, eObject, copyEObject);
            }
          }

          @Override
          protected void copyAttributeValue(EAttribute eAttribute, EObject eObject, Object value, Setting setting)
          {
            if (value != null)
            {
              // Do data conversion to a string representation.
              EDataType eAttributeType = eAttribute.getEAttributeType();
              EDataType eType = (EDataType)setting.getEStructuralFeature().getEType();
              Class<?> instanceClass = eType.getInstanceClass();
              Class<?> instanceClass2 = eAttributeType.getInstanceClass();
              if (instanceClass != instanceClass2 || instanceClass == null)
              {
                if (eAttribute.isMany())
                {
                  List<Object> values = new ArrayList<Object>();
                  for (Object element : (Collection<?>)value)
                  {
                    values.add(EcoreUtil.createFromString(eType, EcoreUtil.convertToString(eAttributeType, element)));
                  }

                  value = values;
                }
                else
                {
                  value = EcoreUtil.createFromString(eType, EcoreUtil.convertToString(eAttributeType, value));
                }
              }
            }

            super.copyAttributeValue(eAttribute, eObject, value, setting);
          }

          public Collection<EPackage> copyEPackages(Collection<? extends EPackage> ePackages)
          {
            // Copy all the packages.
            Collection<EPackage> result = new BasicInternalEList<EPackage>(EPackage.class, copyAll(ePackages));
            copyReferences();

            // Remember the state of the map at this time.
            packageCopies = new HashMap<EObject, EObject>(this);

            return result;
          }

          public Collection<EObject> copyEObjects(Collection<? extends EObject> eObjects)
          {
            // Don't use original references for the copied objects.
            useOriginalReferences = false;

            // Copy all the objects.
            Collection<EObject> result = new BasicInternalEList<EObject>(InternalEObject.class, copyAll(eObjects));

            // Remove the already-processed references from the map, before processing the references for the copied objects.
            keySet().removeAll(packageCopies.keySet());
            copyReferences();

            return result;
          }
        }

        Copier copier = new Copier();

        // Copy all the packages.
        Collection<EPackage> ePackageCopies = copier.copyEPackages(ePackages);

        // Transform all the data types to be java.lang.String.
        for (EPackage ePackage : ePackageCopies)
        {
          for (EClassifier eClassifier : ePackage.getEClassifiers())
          {
            String instanceClassName = eClassifier.getInstanceClassName();
            if (instanceClassName != null)
            {
              if (eClassifier instanceof EDataType)
              {
                eClassifier.setInstanceClass(String.class);
              }
              else
              {
                eClassifier.setInstanceClassName(null);
                eClassifier.setInstanceClass(null);
              }
            }
          }
        }

        // Copy the objects to be instances of the dynamic packages.
        Collection<EObject> eObjectCopies = copier.copyEObjects(eObjects);

        try
        {
          // Create a stream for producing a binary representation.
          ByteArrayOutputStream out = new ByteArrayOutputStream();
          EObjectOutputStream eObjectOutputStream = new BinaryResourceImpl.EObjectOutputStream(out, null, BinaryResourceImpl.BinaryIO.Version.VERSION_1_1);

          // Save all the packages.
          @SuppressWarnings("unchecked")
          InternalEList<? extends InternalEObject> internalEPackages = (InternalEList<? extends InternalEObject>)(InternalEList<?>)ePackageCopies;
          eObjectOutputStream.saveEObjects(internalEPackages, BinaryResourceImpl.EObjectOutputStream.Check.CONTAINER);

          // Save all the objects.
          @SuppressWarnings("unchecked")
          InternalEList<? extends InternalEObject> internalEObjects = (InternalEList<? extends InternalEObject>)(InternalEList<?>)eObjectCopies;
          eObjectOutputStream.saveEObjects(internalEObjects, BinaryResourceImpl.EObjectOutputStream.Check.CONTAINER);

          eObjectOutputStream.flush();

          // Convert the bytes to a native representation.
          return out.toByteArray();
        }
        catch (IOException ex)
        {
          SWTException swtException = new SWTException(DND.ERROR_INVALID_DATA, ex.getMessage());
          swtException.initCause(ex);
          throw swtException;
        }
      }

      return null;
    }

    @Override
    public void clear()
    {
      eObjects.clear();
    }
  }

  static
  {
    register(new OomphBinaryTransferDelegate());
  }

  public static class FileTransferDelegate extends OomphTransferDelegate
  {
    protected final FileTransfer fileTransfer = FileTransfer.getInstance();

    protected Set<String> files;

    @Override
    public Transfer getTransfer()
    {
      return fileTransfer;
    }

    @Override
    public Collection<?> getData(EditingDomain domain, TransferData transferData)
    {
      return getValue(domain, fileTransfer.nativeToJava(transferData));
    }

    @Override
    public Collection<?> getValue(EditingDomain domain, Object data)
    {
      if (data instanceof String[])
      {
        List<URI> result = new ArrayList<URI>();
        for (String file : (String[])data)
        {
          result.add(URI.createFileURI(file));
        }
        return result;
      }

      return Collections.emptyList();
    }

    @Override
    public boolean setSelection(EditingDomain domain, ISelection selection)
    {
      files = new LinkedHashSet<String>();
      if (!selection.isEmpty() && selection instanceof IStructuredSelection)
      {
        for (Object object : ((IStructuredSelection)selection).toArray())
        {
          gather(domain, object);
        }
      }

      return !files.isEmpty();
    }

    protected void gather(EditingDomain domain, Object object)
    {
      Object unwrappedObject = AdapterFactoryEditingDomain.unwrap(object);
      if (unwrappedObject instanceof EObject)
      {
        EObject eObject = (EObject)unwrappedObject;
        Resource resource = eObject.eResource();
        if (resource != null)
        {
          gather(domain, resource.getURI());
        }
      }
      else if (unwrappedObject instanceof Resource)
      {
        Resource resource = (Resource)unwrappedObject;
        gather(domain, resource.getURI());
      }
    }

    protected void gather(EditingDomain domain, URI uri)
    {
      URI normalizedURI = domain.getResourceSet().getURIConverter().normalize(uri);
      URI resolvedURI = CommonPlugin.resolve(normalizedURI);
      if (resolvedURI.isFile())
      {
        files.add(new File(resolvedURI.toFileString()).getAbsolutePath());
      }
    }

    @Override
    public Object getData()
    {
      return files.isEmpty() ? null : files.toArray(new String[files.size()]);
    }

    @Override
    public void clear()
    {
      files = null;
    }
  }

  static
  {
    register(new FileTransferDelegate());
  }

  public static class URLTransferDelegate extends OomphTransferDelegate
  {
    protected final URLTransfer urlTransfer = URLTransfer.getInstance();

    protected String url;

    @Override
    public Transfer getTransfer()
    {
      return urlTransfer;
    }

    @Override
    public Collection<?> getData(EditingDomain domain, TransferData transferData)
    {
      return getValue(domain, urlTransfer.nativeToJava(transferData));
    }

    @Override
    public Collection<?> getValue(EditingDomain domain, Object data)
    {
      if (data instanceof String)
      {
        String value = data.toString().trim();
        try
        {
          return Collections.singleton(URI.createURI(value));
        }
        catch (RuntimeException ex)
        {
          // Ignore.
        }
      }

      return Collections.emptyList();
    }

    @Override
    public boolean setSelection(EditingDomain domain, ISelection selection)
    {
      if (!selection.isEmpty() && selection instanceof IStructuredSelection)
      {
        for (Object object : ((IStructuredSelection)selection).toArray())
        {
          gather(domain, object);

          if (url != null)
          {
            return true;
          }
        }
      }

      return false;
    }

    protected void gather(EditingDomain domain, Object object)
    {
      Object unwrappedObject = AdapterFactoryEditingDomain.unwrap(object);
      if (unwrappedObject instanceof EObject)
      {
        EObject eObject = (EObject)unwrappedObject;
        Resource resource = eObject.eResource();
        if (resource != null)
        {
          gather(domain, resource.getURI());
        }
      }
      else if (unwrappedObject instanceof Resource)
      {
        Resource resource = (Resource)unwrappedObject;
        gather(domain, resource.getURI());
      }
    }

    protected void gather(EditingDomain domain, URI uri)
    {
      URI normalizedURI = domain.getResourceSet().getURIConverter().normalize(uri);
      URI resolvedURI = CommonPlugin.resolve(normalizedURI);
      url = resolvedURI.toString();
    }

    @Override
    public Object getData()
    {
      return url;
    }

    @Override
    public void clear()
    {
      url = null;
    }
  }

  static
  {
    register(new URLTransferDelegate());
  }

  public static class TextTransferDelegate extends ResourceSetTransferDelegate
  {
    protected final TextTransfer textTransfer = TextTransfer.getInstance();

    protected Set<EObject> eObjects;

    @Override
    public Transfer getTransfer()
    {
      return textTransfer;
    }

    @Override
    public Collection<?> getData(EditingDomain domain, TransferData transferData)
    {
      return getValue(domain, textTransfer.nativeToJava(transferData));
    }

    @Override
    public Collection<?> getValue(EditingDomain domain, Object data)
    {
      if (data instanceof String)
      {
        Collection<? extends EObject> result = fromString(domain, data.toString());
        if (result != null)
        {
          return result;
        }
      }

      return Collections.emptyList();
    }

    /**
     * Looks for a leading XML header tag and the trailing element end tag in a larger string value
     * and calls {@link #fromXML(String) fromXML} for that substring.
     * @param domain
     */
    protected Collection<? extends EObject> fromString(EditingDomain domain, String value)
    {
      if (value != null)
      {
        int start = value.indexOf("<?xml");
        if (start != -1)
        {
          int end = value.lastIndexOf('>');
          if (end != -1)
          {
            Collection<? extends EObject> eObjects = fromXML(domain, value.substring(start, end + 1));
            if (eObjects != null)
            {
              return eObjects;
            }
          }
        }
      }

      return null;
    }

    protected Collection<? extends EObject> fromXML(EditingDomain domain, String xml)
    {
      ResourceSet resourceSet = createResourceSet(domain);
      XMLResource resource = (XMLResource)resourceSet.createResource(URI.createURI("dummy:/*.xmi"));

      try
      {
        resource.load(new InputSource(new StringReader(xml)), null);
        return resource.getContents();
      }
      catch (IOException ex)
      {
        // Ignore.
      }

      return null;
    }

    @Override
    public boolean setSelection(EditingDomain domain, ISelection selection)
    {
      eObjects = new LinkedHashSet<EObject>();
      if (!selection.isEmpty() && selection instanceof IStructuredSelection)
      {
        for (Object object : ((IStructuredSelection)selection).toArray())
        {
          gather(domain, object);
        }
      }

      return !eObjects.isEmpty();
    }

    protected void gather(EditingDomain domain, Object object)
    {
      Object unwrappedObject = AdapterFactoryEditingDomain.unwrap(object);
      if (unwrappedObject instanceof EObject)
      {
        EObject eObject = (EObject)unwrappedObject;
        eObjects.add(eObject);
      }
    }

    @Override
    public Object getData()
    {
      XMLResource resource = (XMLResource)RESOURCE_FACTORY.createResource(URI.createURI("dummy:/*.xmi"));

      Copier copier = new EcoreUtil.Copier(true, false);
      Collection<EObject> eObjectCopies = copier.copyAll(eObjects);
      resource.getContents().addAll(eObjectCopies);

      StringWriter writer = new StringWriter();
      try
      {
        resource.save(writer, null);
        writer.flush();
        return writer.toString();
      }
      catch (IOException ex)
      {
        // Ignore.
      }

      return null;
    }

    @Override
    public void clear()
    {
      eObjects = null;
    }
  }

  static
  {
    register(new TextTransferDelegate());
  }

  private static class EclipseHelper
  {
    public static URI getURI(Object object)
    {
      if (object instanceof IResource)
      {
        IResource resource = (IResource)object;
        return URI.createPlatformResourceURI(resource.getFullPath().toString(), true);
      }

      return null;
    }
  }
}