/*
 * Copyright (c) 2004 - 2011 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
 *    Simon McDuff - maintenance
 */
package org.eclipse.emf.cdo.eresource.impl;

import org.eclipse.emf.cdo.CDOObject;
import org.eclipse.emf.cdo.CDOState;
import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.common.id.CDOIDUtil;
import org.eclipse.emf.cdo.eresource.CDOResource;
import org.eclipse.emf.cdo.eresource.EresourcePackage;
import org.eclipse.emf.cdo.transaction.CDOTransaction;
import org.eclipse.emf.cdo.util.CDOModificationTrackingAdapter;
import org.eclipse.emf.cdo.util.CDOURIUtil;
import org.eclipse.emf.cdo.util.CDOUtil;
import org.eclipse.emf.cdo.util.CommitException;
import org.eclipse.emf.cdo.util.ReadOnlyException;
import org.eclipse.emf.cdo.view.CDOView;
import org.eclipse.emf.cdo.view.CDOViewProvider;
import org.eclipse.emf.cdo.view.CDOViewProviderRegistry;

import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.emf.internal.cdo.view.CDOStateMachine;

import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.collection.Pair;
import org.eclipse.net4j.util.transaction.TransactionException;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.notify.impl.NotificationChainImpl;
import org.eclipse.emf.common.notify.impl.NotificationImpl;
import org.eclipse.emf.common.notify.impl.NotifyingListImpl;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.URIConverter;
import org.eclipse.emf.ecore.resource.impl.ExtensibleURIConverterImpl;
import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.emf.ecore.xmi.XMIResource;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.impl.XMIHelperImpl;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
import org.eclipse.emf.spi.cdo.FSMUtil;
import org.eclipse.emf.spi.cdo.InternalCDOObject;
import org.eclipse.emf.spi.cdo.InternalCDOTransaction;
import org.eclipse.emf.spi.cdo.InternalCDOView;
import org.eclipse.emf.spi.cdo.InternalCDOViewSet;

import org.eclipse.core.runtime.IProgressMonitor;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;

/**
 * <!-- begin-user-doc --> An implementation of the model object '<em><b>CDO Resource</b></em>'.
 * 
 * @extends Resource.Internal
 * @noextend This interface is not intended to be extended by clients. <!-- end-user-doc -->
 *           <p>
 *           The following features are implemented:
 *           <ul>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getResourceSet <em>Resource Set</em>}</li>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getURI <em>URI</em>}</li>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getContents <em>Contents</em>}</li>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#isModified <em>Modified</em>}</li>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#isLoaded <em>Loaded</em>}</li>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#isTrackingModification <em>Tracking
 *           Modification</em>}</li>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getErrors <em>Errors</em>}</li>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getWarnings <em>Warnings</em>}</li>
 *           <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getTimeStamp <em>Time Stamp</em>}</li>
 *           </ul>
 *           </p>
 * @generated
 */
public class CDOResourceImpl extends CDOResourceLeafImpl implements CDOResource, Resource.Internal
{
  private static final EReference CDO_RESOURCE_CONTENTS = EresourcePackage.eINSTANCE.getCDOResource_Contents();

  /**
   * The default URI converter when there is no resource set.
   * 
   * @ADDED
   */
  private static URIConverter defaultURIConverter;

  /**
   * @ADDED
   */
  private boolean root;

  /**
   * @ADDED
   */
  private URI initialURI;

  /**
   * TODO Set to true in commit()?
   * 
   * @ADDED
   */
  private boolean existing;

  /**
   * @ADDED
   */
  private boolean loading;

  /**
   * @ADDED
   */
  private boolean loaded;

  /**
   * @ADDED
   */
  private boolean modified;

  /**
   * @ADDED
   */
  private EList<Diagnostic> errors;

  /**
   * @ADDED
   */
  private EList<Diagnostic> warnings;

  /**
   * @ADDED
   */
  private transient CDOViewProvider viewProvider;

  /**
   * @ADDED
   * @since 2.0
   */
  public CDOResourceImpl(URI initialURI)
  {
    this.initialURI = initialURI;
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated
   */
  protected CDOResourceImpl()
  {
    super();
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated
   */
  @Override
  protected EClass eStaticClass()
  {
    return EresourcePackage.Literals.CDO_RESOURCE;
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   * @since 2.0
   */
  @Override
  public Resource.Internal eDirectResource()
  {
    if (isRoot())
    {
      return this;
    }

    return super.eDirectResource();
  }

  @Override
  public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass)
  {
    if (baseClass == CDOResource.class)
    {
      return baseFeatureID;
    }

    if (baseClass == Resource.class)
    {
      return baseFeatureID + EresourcePackage.CDO_RESOURCE_NODE_FEATURE_COUNT;
    }

    return super.eBaseStructuralFeatureID(baseFeatureID, baseClass);
  }

  @Override
  public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass)
  {
    if (baseClass == CDOResource.class)
    {
      return derivedFeatureID;
    }

    if (baseClass == Resource.class)
    {
      return derivedFeatureID - EresourcePackage.CDO_RESOURCE_NODE_FEATURE_COUNT;
    }

    return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
  }

  /**
   * @since 2.0
   */
  public boolean isRoot()
  {
    return root;
  }

  /**
   * @since 3.0
   */
  public void setRoot(boolean root)
  {
    this.root = root;
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated
   */
  public ResourceSet getResourceSet()
  {
    return (ResourceSet)eGet(EresourcePackage.Literals.CDO_RESOURCE__RESOURCE_SET, true);
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated
   */
  public void setResourceSet(ResourceSet newResourceSet)
  {
    eSet(EresourcePackage.Literals.CDO_RESOURCE__RESOURCE_SET, newResourceSet);
  }

  /**
   * <!-- begin-user-doc -->
   * 
   * @since 2.0 <!-- end-user-doc -->
   * @generated
   */
  public URI getURIGen()
  {
    return (URI)eGet(EresourcePackage.Literals.CDO_RESOURCE__URI, true);
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  @Override
  public URI getURI()
  {
    if (cdoID() == null && initialURI != null)
    {
      return initialURI;
    }

    if (viewProvider != null)
    {
      URI uri = viewProvider.getResourceURI(cdoView(), getPath());
      if (uri != null)
      {
        return uri;
      }
    }

    return super.getURI();
  }

  /**
   * <!-- begin-user-doc -->
   * 
   * @since 2.0 <!-- end-user-doc -->
   * @generated
   */
  public void setURIGen(URI newURI)
  {
    eSet(EresourcePackage.Literals.CDO_RESOURCE__URI, newURI);
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  public void setURI(URI newURI)
  {
    String newPath = CDOURIUtil.extractResourcePath(newURI);
    setPath(newPath);
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  @SuppressWarnings("unchecked")
  public EList<EObject> getContents()
  {
    return (EList<EObject>)eGet(EresourcePackage.Literals.CDO_RESOURCE__CONTENTS, true);
  }

  /**
   * @since 2.0
   */
  @Override
  public void cdoInternalPostDetach(boolean remote)
  {
    super.cdoInternalPostDetach(remote);
    if (remote)
    {
      existing = false;
    }

    removeFromResourceSet();
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  public boolean isModified()
  {
    return modified;
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  public void setModified(boolean newModified)
  {
    boolean oldModified = modified;
    modified = newModified;
    if (oldModified != newModified && eNotificationRequired())
    {
      Notification notification = new NotificationImpl(Notification.SET, oldModified, newModified)
      {
        @Override
        public Object getNotifier()
        {
          return CDOResourceImpl.this;
        }

        @Override
        public int getFeatureID(Class<?> expectedClass)
        {
          return RESOURCE__IS_MODIFIED;
        }
      };

      eNotify(notification);
    }
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  public boolean isLoaded()
  {
    return loaded;
  }

  /**
   * @see ResourceImpl#setLoaded(boolean)
   * @ADDED
   */
  private Notification setLoaded(boolean isLoaded)
  {
    boolean oldIsLoaded = loaded;
    loaded = isLoaded;

    if (eNotificationRequired())
    {
      Notification notification = new NotificationImpl(Notification.SET, oldIsLoaded, isLoaded)
      {
        @Override
        public Object getNotifier()
        {
          return CDOResourceImpl.this;
        }

        @Override
        public int getFeatureID(Class<?> expectedClass)
        {
          // TODO FIX bug 265136
          return Resource.RESOURCE__IS_LOADED;
        }
      };

      return notification;
    }

    return null;
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated
   */
  public boolean isTrackingModification()
  {
    return (Boolean)eGet(EresourcePackage.Literals.CDO_RESOURCE__TRACKING_MODIFICATION, true);
  }

  /**
   * <!-- begin-user-doc -->
   * 
   * @since 4.0 <!-- end-user-doc -->
   * @generated
   */
  public void setTrackingModificationGen(boolean newTrackingModification)
  {
    eSet(EresourcePackage.Literals.CDO_RESOURCE__TRACKING_MODIFICATION, newTrackingModification);
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  public void setTrackingModification(boolean newTrackingModification)
  {
    if (cdoView().isReadOnly())
    {
      throw new ReadOnlyException("Underlying view is read-only");
    }

    if (newTrackingModification == isTrackingModification())
    {
      return;
    }

    EList<Adapter> adapters = eAdapters();
    if (newTrackingModification)
    {
      adapters.add(new CDOModificationTrackingAdapter(this));
    }
    else
    {
      for (Adapter adapter : adapters)
      {
        if (adapter instanceof CDOModificationTrackingAdapter)
        {
          adapters.remove(adapter);
          break;
        }
      }
    }

    setTrackingModificationGen(newTrackingModification);
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  public EList<Diagnostic> getErrors()
  {
    if (errors == null)
    {
      errors = new NotifyingListImpl<Diagnostic>()
      {
        private static final long serialVersionUID = 1L;

        @Override
        protected boolean isNotificationRequired()
        {
          return CDOResourceImpl.this.eNotificationRequired();
        }

        @Override
        public Object getNotifier()
        {
          return CDOResourceImpl.this;
        }

        @Override
        public int getFeatureID()
        {
          return EresourcePackage.CDO_RESOURCE__ERRORS;
        }
      };
    }

    return errors;
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated NOT
   */
  public EList<Diagnostic> getWarnings()
  {
    if (warnings == null)
    {
      warnings = new NotifyingListImpl<Diagnostic>()
      {
        private static final long serialVersionUID = 1L;

        @Override
        protected boolean isNotificationRequired()
        {
          return CDOResourceImpl.this.eNotificationRequired();
        }

        @Override
        public Object getNotifier()
        {
          return CDOResourceImpl.this;
        }

        @Override
        public int getFeatureID()
        {
          return EresourcePackage.CDO_RESOURCE__WARNINGS;
        }
      };
    }

    return warnings;
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated
   */
  public long getTimeStamp()
  {
    return (Long)eGet(EresourcePackage.Literals.CDO_RESOURCE__TIME_STAMP, true);
  }

  /**
   * <!-- begin-user-doc --> <!-- end-user-doc -->
   * 
   * @generated
   */
  public void setTimeStamp(long newTimeStamp)
  {
    eSet(EresourcePackage.Literals.CDO_RESOURCE__TIME_STAMP, newTimeStamp);
  }

  /**
   * @ADDED
   * @see ResourceImpl#getAllContents()
   */
  public TreeIterator<EObject> getAllContents()
  {
    return new AbstractTreeIterator<EObject>(this, false)
    {
      private static final long serialVersionUID = 1L;

      @Override
      public Iterator<EObject> getChildren(Object object)
      {
        return object == CDOResourceImpl.this ? CDOResourceImpl.this.getContents().iterator() : ((EObject)object)
            .eContents().iterator();
      }
    };
  }

  /**
   * <b>Note:</b> URI from temporary objects are going to changed when we commit the CDOTransaction. Objects will not be
   * accessible from their temporary URI once CDOTransaction is committed.
   * <p>
   * <b>Note:</b> This resource is not actually used to lookup the resulting object in CDO. Only the CDOView is used for
   * this lookup! This means that this resource can be used to resolve <em>any</em> fragment with a CDOID of the
   * associated CDOView.
   * 
   * @ADDED
   */
  public EObject getEObject(String uriFragment)
  {
    if (uriFragment == null)
    {
      return null;
    }

    try
    {
      EObject eObjectByFragment = getEObjectByFragment(uriFragment);

      if (eObjectByFragment != null)
      {
        return eObjectByFragment;
      }

      CDOID id = CDOIDUtil.read(uriFragment);
      InternalCDOView view = cdoView();
      if (CDOIDUtil.isNull(id) || view.isObjectNew(id) && !view.isObjectRegistered(id))
      {
        return null;
      }

      if (id.isObject())
      {
        CDOObject object = view.getObject(id, true);
        return CDOUtil.getEObject(object);
      }
    }
    catch (Exception ex)
    {
      // Do nothing
      // Return null if the object cannot be resolved.
    }

    // If it doesn't match to anything we return null like ResourceImpl.getEObject
    return null;
  }

  private EObject getEObjectByFragment(String uriFragment)
  {
    int length = uriFragment.length();
    if (length > 0)
    {
      if (uriFragment.charAt(0) == '/')
      {
        ArrayList<String> uriFragmentPath = new ArrayList<String>(4);
        int start = 1;
        for (int i = 1; i < length; ++i)
        {
          if (uriFragment.charAt(i) == '/')
          {
            uriFragmentPath.add(start == i ? "" : uriFragment.substring(start, i));
            start = i + 1;
          }
        }

        uriFragmentPath.add(uriFragment.substring(start));
        return getEObject(uriFragmentPath);
      }
      else if (uriFragment.charAt(length - 1) == '?')
      {
        int index = uriFragment.lastIndexOf('?', length - 2);
        if (index > 0)
        {
          uriFragment = uriFragment.substring(0, index);
        }
      }
    }

    return null;
  }

  private EObject getEObject(List<String> uriFragmentPath)
  {
    int size = uriFragmentPath.size();
    EObject eObject = getEObjectForURIFragmentRootSegment(size == 0 ? "" : uriFragmentPath.get(0));
    for (int i = 1; i < size && eObject != null; ++i)
    {
      eObject = ((InternalEObject)eObject).eObjectForURIFragmentSegment(uriFragmentPath.get(i));
    }

    return eObject;
  }

  private EObject getEObjectForURIFragmentRootSegment(String uriFragmentRootSegment)
  {
    int position = 0;
    if (uriFragmentRootSegment.length() > 0)
    {
      try
      {
        position = Integer.parseInt(uriFragmentRootSegment);
      }
      catch (NumberFormatException exception)
      {
        throw new RuntimeException(exception);
      }
    }

    List<EObject> contents = getContents();
    if (position < contents.size() && position >= 0)
    {
      return contents.get(position);
    }

    return null;
  }

  /**
   * @ADDED
   */
  public String getURIFragment(EObject object)
  {
    // TODO if object == this ??? what we do. Is it wanted ? How we handle them ?
    InternalCDOObject internalCDOObject = FSMUtil.adapt(object, cdoView());
    StringBuilder builder = new StringBuilder();
    CDOIDUtil.write(builder, internalCDOObject.cdoID());
    return builder.toString();
  }

  /**
   * @since 2.0
   */
  @Override
  public void cdoInternalPreLoad()
  {
    try
    {
      load(null);
    }
    catch (IOException ex)
    {
      throw WrappedException.wrap(ex);
    }
  }

  /**
   * @ADDED
   */
  public void load(InputStream inputStream, Map<?, ?> options) throws IOException
  {
    // final String baseURI = getBaseURIOption(options);
    // final Map<Resource, CDOResource> resourceMappings = new HashMap<Resource, CDOResource>();
    //
    // class ImportResource extends XMIResourceImpl
    // {
    // private CDOResource delegate;
    //
    // public ImportResource(CDOResource delegate)
    // {
    // super(URI.createURI(baseURI + delegate.getPath()));
    // this.delegate = delegate;
    // }
    //
    // @Override
    // public EList<EObject> getContents()
    // {
    // return delegate.getContents();
    // }
    //
    // @Override
    // public String getURIFragment(EObject eObject)
    // {
    // String id = EcoreUtil.getID(eObject);
    // if (id != null)
    // {
    // return id;
    // }
    //
    // InternalEObject internalEObject = (InternalEObject)eObject;
    // if (getMappedResource(internalEObject.eDirectResource()) == this)
    // {
    // return "/" + getURIFragmentRootSegment(eObject);
    // }
    //
    // List<String> uriFragmentPath = new ArrayList<String>();
    // boolean isContained = false;
    // for (InternalEObject container = internalEObject.eInternalContainer(); container != null; container =
    // internalEObject
    // .eInternalContainer())
    // {
    // uriFragmentPath.add(container.eURIFragmentSegment(internalEObject.eContainingFeature(), internalEObject));
    // internalEObject = container;
    // if (getMappedResource(container.eDirectResource()) == this)
    // {
    // isContained = true;
    // break;
    // }
    // }
    //
    // if (!isContained)
    // {
    // return "/-1";
    // }
    //
    // StringBuilder result = new StringBuilder("/");
    // result.append(getURIFragmentRootSegment(internalEObject));
    //
    // for (int i = uriFragmentPath.size() - 1; i >= 0; --i)
    // {
    // result.append('/');
    // result.append(uriFragmentPath.get(i));
    // }
    //
    // return result.toString();
    // }
    //
    // @Override
    // protected XMLHelper createXMLHelper()
    // {
    // return new XMIHelperImpl(this)
    // {
    // @Override
    // public String getHREF(EObject obj)
    // {
    // InternalEObject o = (InternalEObject)obj;
    //
    // URI objectURI = o.eProxyURI();
    // if (objectURI == null)
    // {
    // Resource otherResource = obj.eResource();
    // otherResource = getMappedResource(otherResource);
    // objectURI = getHREF(otherResource, obj);
    // }
    //
    // objectURI = deresolve(objectURI);
    // return objectURI.toString();
    // }
    //
    // @Override
    // protected URI getHREF(Resource otherResource, EObject obj)
    // {
    // String uriFragment = getURIFragment(otherResource, obj);
    // if (otherResource == ImportResource.this)
    // {
    // return URI.createURI(uriFragment);
    // }
    //
    // return otherResource.getURI().appendFragment(uriFragment);
    // }
    // };
    // }
    //
    // private Resource getMappedResource(Resource otherResource)
    // {
    // Resource resource = resourceMappings.get(otherResource);
    // if (resource != null)
    // {
    // return resource;
    // }
    //
    // if (otherResource instanceof CDOResource)
    // {
    // CDOResource cdoResource = (CDOResource)otherResource;
    // otherResource = new ImportResource(cdoResource);
    // resourceMappings.put(cdoResource, otherResource);
    // }
    //
    // return otherResource;
    // }
    // }
    //
    // XMIResource xmiResource = new ImportResource(this);
    // resourceMappings.put(this, xmiResource);
    // xmiResource.save(outputStream, options);

    throw new UnsupportedOperationException();
  }

  /**
   * @ADDED
   */
  public void load(Map<?, ?> options) throws IOException
  {
    if (!isLoaded())
    {
      InternalCDOView view = cdoView();
      if (!FSMUtil.isTransient(this))
      {
        CDOID id = cdoID();
        if (id == null)
        {
          registerProxy(view);
        }
        else
        {
          synchronized (view)
          {
            if (!view.isObjectRegistered(id))
            {
              registerProxy(view);
            }
          }
        }
      }

      Notification notification = setLoaded(true);
      if (notification != null)
      {
        eNotify(notification);
      }

      // URIConverter uriConverter = getURIConverter();
      //
      // // If an input stream can't be created, ensure that the resource is still considered loaded after the failure,
      // // and do all the same processing we'd do if we actually were able to create a valid input stream.
      // //
      // InputStream inputStream = null;
      //
      // try
      // {
      // inputStream = uriConverter.createInputStream(getURI(), options);
      // }
      // catch (IOException exception)
      // {
      // Notification notification = setLoaded(true);
      // loading = true;
      // if (errors != null)
      // {
      // errors.clear();
      // }
      //
      // if (warnings != null)
      // {
      // warnings.clear();
      // }
      //
      // loading = false;
      // if (notification != null)
      // {
      // eNotify(notification);
      // }
      //
      // setModified(false);
      // throw exception;
      // }
      //
      // try
      // {
      // load(inputStream, options);
      // }
      // finally
      // {
      // inputStream.close();
      // // TODO Handle timeStamp
      // // Long timeStamp = (Long)response.get(URIConverter.RESPONSE_TIME_STAMP_PROPERTY);
      // // if (timeStamp != null)
      // // {
      // // setTimeStamp(timeStamp);
      // // }
      // }
    }
  }

  private void registerProxy(InternalCDOView view) throws IOWrappedException
  {
    try
    {
      view.registerProxyResource(this);
    }
    catch (Exception ex)
    {
      OM.LOG.error(ex);
      setExisting(false);
      cdoInternalSetState(CDOState.TRANSIENT);
      throw new IOWrappedException(ex);
    }
  }

  /**
   * Returns the URI converter. This typically gets the {@link ResourceSet#getURIConverter converter} from the
   * {@link #getResourceSet containing} resource set, but it calls {@link #getDefaultURIConverter} when there is no
   * containing resource set.
   * 
   * @return the URI converter.
   * @ADDED
   */
  @SuppressWarnings("unused")
  private URIConverter getURIConverter()
  {
    return getResourceSet() == null ? getDefaultURIConverter() : getResourceSet().getURIConverter();
  }

  /**
   * Returns the default URI converter that's used when there is no resource set.
   * 
   * @return the default URI converter.
   * @see #getURIConverter
   * @ADDED
   */
  private static synchronized URIConverter getDefaultURIConverter()
  {
    if (defaultURIConverter == null)
    {
      defaultURIConverter = new ExtensibleURIConverterImpl();
    }

    return defaultURIConverter;
  }

  /**
   * @ADDED
   */
  public void save(Map<?, ?> options) throws IOException
  {
    CDOTransaction transaction = getTransaction(options);
    IProgressMonitor progressMonitor = options != null ? (IProgressMonitor)options
        .get(CDOResource.OPTION_SAVE_PROGRESS_MONITOR) : null;

    try
    {
      transaction.commit(progressMonitor);
    }
    catch (CommitException ex)
    {
      throw new TransactionException(ex);
    }

    setModified(false);
  }

  /**
   * @ADDED
   */
  private CDOTransaction getTransaction(Map<?, ?> options)
  {
    CDOTransaction transaction = options != null ? (CDOTransaction)options
        .get(CDOResource.OPTION_SAVE_OVERRIDE_TRANSACTION) : null;

    if (transaction == null)
    {
      CDOView view = cdoView();
      if (view instanceof CDOTransaction)
      {
        transaction = (CDOTransaction)view;
      }
      else
      {
        throw new IllegalStateException("No transaction available");
      }
    }

    return transaction;
  }

  /**
   * @ADDED
   */
  public void save(OutputStream outputStream, Map<?, ?> options) throws IOException
  {
    final String baseURI = getBaseURIOption(options);
    final Map<CDOResource, Resource> resourceMappings = new HashMap<CDOResource, Resource>();

    class ExportResource extends XMIResourceImpl
    {
      private CDOResource delegate;

      public ExportResource(CDOResource delegate)
      {
        super(URI.createURI(baseURI + delegate.getPath()));
        this.delegate = delegate;
      }

      @Override
      public EList<EObject> getContents()
      {
        return delegate.getContents();
      }

      // @Override
      // public String getURIFragment(EObject eObject)
      // {
      // String id = EcoreUtil.getID(eObject);
      // if (id != null)
      // {
      // return id;
      // }
      //
      // InternalEObject internalEObject = (InternalEObject)eObject;
      // if (getMappedResource(internalEObject.eDirectResource()) == this)
      // {
      // return "/" + getURIFragmentRootSegment(eObject);
      // }
      //
      // List<String> uriFragmentPath = new ArrayList<String>();
      // boolean isContained = false;
      // for (InternalEObject container = internalEObject.eInternalContainer(); container != null; container =
      // internalEObject
      // .eInternalContainer())
      // {
      // uriFragmentPath.add(container.eURIFragmentSegment(internalEObject.eContainingFeature(), internalEObject));
      // internalEObject = container;
      // if (getMappedResource(container.eDirectResource()) == this)
      // {
      // isContained = true;
      // break;
      // }
      // }
      //
      // if (!isContained)
      // {
      // return "/-1";
      // }
      //
      // StringBuilder result = new StringBuilder("/");
      // result.append(getURIFragmentRootSegment(internalEObject));
      //
      // for (int i = uriFragmentPath.size() - 1; i >= 0; --i)
      // {
      // result.append('/');
      // result.append(uriFragmentPath.get(i));
      // }
      //
      // return result.toString();
      // }

      @Override
      protected boolean useUUIDs()
      {
        return true;
      }

      @Override
      protected boolean useIDAttributes()
      {
        return false;
      }

      @Override
      public String getID(EObject eObject)
      {
        CDOObject cdoObject = CDOUtil.getCDOObject(eObject);
        StringBuilder builder = new StringBuilder();
        CDOIDUtil.write(builder, cdoObject.cdoID());
        return builder.toString();
      }

      @Override
      protected XMLHelper createXMLHelper()
      {
        return new XMIHelperImpl(this)
        {
          @Override
          public String getHREF(EObject obj)
          {
            InternalEObject o = (InternalEObject)obj;

            URI objectURI = o.eProxyURI();
            if (objectURI == null)
            {
              Resource otherResource = obj.eResource();
              otherResource = getMappedResource(otherResource);
              objectURI = getHREF(otherResource, obj);
            }

            objectURI = deresolve(objectURI);
            return objectURI.toString();
          }

          @Override
          protected URI getHREF(Resource otherResource, EObject obj)
          {
            String uriFragment = getURIFragment(otherResource, obj);
            if (otherResource == ExportResource.this)
            {
              return URI.createURI(uriFragment);
            }

            return otherResource.getURI().appendFragment(uriFragment);
          }
        };
      }

      private Resource getMappedResource(Resource otherResource)
      {
        Resource resource = resourceMappings.get(otherResource);
        if (resource != null)
        {
          return resource;
        }

        if (otherResource instanceof CDOResource)
        {
          CDOResource cdoResource = (CDOResource)otherResource;
          otherResource = new ExportResource(cdoResource);
          resourceMappings.put(cdoResource, otherResource);
        }

        return otherResource;
      }
    }

    XMIResource xmiResource = new ExportResource(this);
    resourceMappings.put(this, xmiResource);
    xmiResource.save(outputStream, options);
  }

  private String getBaseURIOption(Map<?, ?> options)
  {
    if (options != null)
    {
      String uri = (String)options.get(OPTION_SAVE_BASE_URI);
      if (uri != null)
      {
        return uri;
      }
    }

    return "cdo://";
  }

  /**
   * @ADDED
   */
  public void unload()
  {
    // Do nothing
  }

  /**
   * @ADDED
   */
  public void delete(Map<?, ?> options) throws IOException
  {
    if (FSMUtil.isTransient(this))
    {
      removeFromResourceSet();
    }
    else
    {
      if (isRoot())
      {
        throw new UnsupportedOperationException();
      }

      if (getFolder() == null)
      {
        InternalCDOView view = cdoView();
        view.getRootResource().getContents().remove(this);
      }
      else
      {
        basicSetFolder(null, false);
      }
    }
  }

  private void removeFromResourceSet()
  {
    final ResourceSet resourceSet = getResourceSet();
    if (resourceSet != null)
    {
      InternalCDOViewSet viewSet = (InternalCDOViewSet)CDOUtil.getViewSet(resourceSet);
      viewSet.executeWithoutNotificationHandling(new Callable<Boolean>()
      {
        public Boolean call() throws Exception
        {
          resourceSet.getResources().remove(CDOResourceImpl.this);
          return true;
        }
      });
    }
  }

  /**
   * @ADDED
   */
  public void attached(EObject object)
  {
    if (!FSMUtil.isTransient(this))
    {
      InternalCDOTransaction transaction = cdoView().toTransaction();
      InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction);

      if (CDOUtil.isLegacyObject(cdoObject) && FSMUtil.isClean(cdoObject))
      {
        // Bug 352204
        return;
      }

      attached(cdoObject, transaction);
    }
  }

  /**
   * @ADDED
   */
  private void attached(InternalCDOObject cdoObject, InternalCDOTransaction transaction)
  {
    CDOStateMachine.INSTANCE.attach(cdoObject, transaction);
  }

  /**
   * @ADDED
   */
  public void detached(EObject object)
  {
    if (!FSMUtil.isTransient(this))
    {
      InternalCDOObject cdoObject = FSMUtil.adapt(object, cdoView());
      CDOStateMachine.INSTANCE.detach(cdoObject);
    }
  }

  /**
   * @ADDED
   * @see ResourceImpl#basicSetResourceSet(ResourceSet, NotificationChain)
   */
  public NotificationChain basicSetResourceSet(ResourceSet resourceSet, NotificationChain notifications)
  {
    final ResourceSet oldResourceSet = getResourceSet();
    if (oldResourceSet != null)
    {
      final NotificationChain finalNotifications = notifications;

      InternalCDOViewSet viewSet = (InternalCDOViewSet)CDOUtil.getViewSet(oldResourceSet);
      notifications = viewSet.executeWithoutNotificationHandling(new Callable<NotificationChain>()
      {
        public NotificationChain call() throws Exception
        {
          return ((InternalEList<Resource>)oldResourceSet.getResources()).basicRemove(this, finalNotifications);
        }
      });
    }

    setResourceSet(resourceSet);

    if (resourceSet != null)
    {
      InternalCDOView view = cdoView();
      if (view == null)
      {
        URI uri = getURI();
        Pair<CDOView, CDOViewProvider> pair = CDOViewProviderRegistry.INSTANCE.provideViewWithInfo(uri, resourceSet);
        if (pair != null)
        {
          view = (InternalCDOView)pair.getElement1();
          view.attachResource(this);

          viewProvider = pair.getElement2();
        }
      }
    }

    if (eNotificationRequired())
    {
      if (notifications == null)
      {
        notifications = new NotificationChainImpl(2);
      }

      notifications.add(new NotificationImpl(Notification.SET, oldResourceSet, resourceSet)
      {
        @Override
        public Object getNotifier()
        {
          return CDOResourceImpl.this;
        }

        @Override
        public int getFeatureID(Class<?> expectedClass)
        {
          return RESOURCE__RESOURCE_SET;
        }
      });
    }

    return notifications;
  }

  /**
   * @ADDED
   */
  public boolean isLoading()
  {
    return loading;
  }

  /**
   * @ADDED
   */
  public boolean isExisting()
  {
    return existing;
  }

  /**
   * @ADDED
   * @since 3.0
   */
  protected void setExisting(boolean existing)
  {
    this.existing = existing;
  }

  /**
   * @ADDED
   */
  @Override
  protected EList<?> createList(EStructuralFeature eStructuralFeature)
  {
    if (eStructuralFeature == CDO_RESOURCE_CONTENTS)
    {
      return new ContentsCDOList(CDO_RESOURCE_CONTENTS);
      // return new _ContentsCDOList<EObject>();
    }

    return super.createList(eStructuralFeature);
  }

  // /**
  // * A notifying list implementation for supporting {@link Resource#getContents}.
  // */
  // protected class _ContentsCDOList<E extends Object & EObject> extends ResourceContentsEList<E>
  // {
  // private static final long serialVersionUID = 1L;
  //
  // @Override
  // public int getFeatureID()
  // {
  // return CDO_RESOURCE_CONTENTS.getFeatureID();
  // }
  //
  // @Override
  // protected CDOResourceImpl getResource()
  // {
  // return CDOResourceImpl.this;
  // }
  //
  // @Override
  // protected Notification setLoaded(boolean loaded)
  // {
  // return getResource().setLoaded(loaded);
  // }
  //
  // @Override
  // protected boolean isNotificationRequired()
  // {
  // return getResource().eNotificationRequired();
  // }
  //
  // @Override
  // public NotificationChain inverseAdd(E object, NotificationChain notifications)
  // {
  // if (FSMUtil.isTransient(getResource()))
  // {
  // InternalEObject eObject = (InternalEObject)object;
  // return eObject.eSetResource(CDOResourceImpl.this, notifications);
  // // return super.inverseAdd(object, notifications);
  // }
  //
  // InternalCDOTransaction transaction = cdoView().toTransaction();
  // InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction);
  // notifications = cdoObject.eSetResource(getResource(), notifications);
  //
  // // Attach here instead of in CDOObjectImpl.eSetResource because EMF does it also here
  // if (FSMUtil.isTransient(cdoObject))
  // {
  // attached(cdoObject, transaction);
  // }
  //
  // return notifications;
  // }
  //
  // @Override
  // public NotificationChain inverseRemove(E object, NotificationChain notifications)
  // {
  // if (FSMUtil.isTransient(getResource()))
  // {
  // InternalEObject eObject = (InternalEObject)object;
  // return eObject.eSetResource(null, notifications);
  // // return super.inverseRemove(object, notifications);
  // }
  //
  // InternalEObject eObject = (InternalEObject)object;
  // detached(eObject);
  // return eObject.eSetResource(null, notifications);
  // }
  // }

  /**
   * An implementation of a CDO specific '<em><b>contents</b></em>' list.
   * 
   * @ADDED
   * @author Eike Stepper
   * @since 2.0
   */
  protected class ContentsCDOList extends BasicEStoreEList<Object>
  {
    private static final long serialVersionUID = 1L;

    public ContentsCDOList(EStructuralFeature eStructuralFeature)
    {
      super(CDOResourceImpl.this, eStructuralFeature);
    }

    /**
     * Optimization taken from ResourceImpl.EContentList.contains.
     * 
     * @since 2.0
     */
    @Override
    public boolean contains(Object object)
    {
      if (size() <= 4)
      {
        return super.contains(object);
      }

      return object instanceof InternalEObject && ((InternalEObject)object).eDirectResource() == CDOResourceImpl.this;
    }

    /**
     * @since 2.0
     */
    @Override
    public NotificationChain inverseAdd(Object object, NotificationChain notifications)
    {
      if (FSMUtil.isTransient(CDOResourceImpl.this))
      {
        InternalEObject eObject = (InternalEObject)object;
        notifications = eObject.eSetResource(CDOResourceImpl.this, notifications);
      }
      else
      {
        InternalCDOTransaction transaction = cdoView().toTransaction();
        InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction);
        notifications = cdoObject.eSetResource(CDOResourceImpl.this, notifications);

        // Attach here instead of in CDOObjectImpl.eSetResource because EMF does it also here
        if (FSMUtil.isTransient(cdoObject))
        {
          attached(cdoObject, transaction);
        }
      }

      return notifications;
    }

    /**
     * @since 2.0
     */
    @Override
    public NotificationChain inverseRemove(Object object, NotificationChain notifications)
    {
      if (FSMUtil.isTransient(CDOResourceImpl.this))
      {
        InternalEObject eObject = (InternalEObject)object;
        notifications = eObject.eSetResource(null, notifications);
      }
      else
      {
        InternalEObject eObject = (InternalEObject)object;
        detached(eObject);
        notifications = eObject.eSetResource(null, notifications);
      }

      return notifications;
    }

    /**
     * @since 2.0
     */
    protected void loaded()
    {
      Notification notification = setLoaded(true);
      if (notification != null)
      {
        eNotify(notification);
      }
    }

    /**
     * @since 2.0
     */
    protected void modified()
    {
      if (isTrackingModification())
      {
        setModified(true);
      }
    }

    /**
     * @since 2.0
     */
    @Override
    protected boolean useEquals()
    {
      return false;
    }

    /**
     * @since 2.0
     */
    @Override
    protected boolean hasInverse()
    {
      return true;
    }

    /**
     * @since 2.0
     */
    @Override
    protected boolean isUnique()
    {
      return true;
    }

    /**
     * @since 4.0
     */
    @Override
    protected void didAdd(int index, Object newObject)
    {
      super.didAdd(index, newObject);

      if (!isExisting() && !isLoaded())
      {
        loaded();
      }
    }

    /**
     * @since 4.0
     */
    @Override
    protected void didClear(int size, Object[] oldObjects)
    {
      super.didClear(size, oldObjects);

      if (!isExisting() && !isLoaded())
      {
        loaded();
      }
    }
  }
} // CDOResourceImpl