/*
   Wotonomy: OpenStep design patterns for pure Java applications.
   Copyright (C) 2001 Michael Powers
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, see http://www.gnu.org
  */
  
  package net.wotonomy.control;
  
  import java.lang.ref.WeakReference;
  import java.util.Collection;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import net.wotonomy.foundation.NSArray;
  import net.wotonomy.foundation.NSDictionary;
  import net.wotonomy.foundation.NSMutableArray;
  import net.wotonomy.foundation.NSMutableDictionary;
  import net.wotonomy.foundation.NSNotification;
  import net.wotonomy.foundation.NSNotificationCenter;
  import net.wotonomy.foundation.NSRunLoop;
  import net.wotonomy.foundation.NSSelector;
  import net.wotonomy.foundation.internal.WotonomyException;
  
  // swing dependency for undo manager
  //import javax.swing.undo.UndoManager;
  
  /***
  * EOEditingContext provides transactional support for 
  * fetching, editing, and committing changes made on a 
  * collection of objects to a parent object store. <br><br>
  *
  * EOEditingContext is itself a subclass of EOObjectStore,
  * and this means that EOEditingContexts can use other 
  * EOEditingContexts as their parent.  However, there
  * still must exist an EOObjectStore as the root of the 
  * editing hierarchy that can maintain persistent state.
  *
  * @author michael@mpowers.net
  * @author $Author: cgruber $
  * @version $Revision: 894 $
  */
  public class EOEditingContext 
      extends EOObjectStore 
      implements EOObserving
  {
      /***
      * Key for the NSNotification posted after this editing context
      * saves changes.  Object of the notification will be this editing 
      * context, and user info will contain InsertedKey, UpdatedKey,
      * and DeletedKey (keys are defined in EOObjectStore).
      */
      public static final String 
          EditingContextDidSaveChangesNotification = 
          "EOEditingContextDidSaveChangesNotification";
  
      /***
      * Key for the NSNotification posted after this editing context
      * observes changes.  Object of the notification will be this editing 
      * context, and user info will contain InsertedKey, UpdatedKey, InvalidatedKey,
      * and DeletedKey (keys are defined in EOObjectStore), however
      * the objects in the corresponding Lists will be the actual
      * objects, not their ids.
      */
      public static final String 
          ObjectsChangedInEditingContextNotification = 
          "EOObjectsChangedInEditingContextNotification";
          
      /***
      * The default run loop ordering processes recent changes
      * before delayed observers are notified and before dispatching 
      * the AWT event queue.
      */
      public static int 
          EditingContextFlushChangesRunLoopOrdering = 300000;
  
      private static NSSelector runLaterSelector = 
          new NSSelector( "flushRecentChanges",
              new Class[] { Object.class } );
  
      private static EOObjectStore defaultParentObjectStore = null;
      private static double defaultFetchTimestampLag = 0;
      private static boolean retainsRegisteredObjects = true;
         
     private EOObjectStore parentStore;        
     private WeakReference delegate;
     private WeakReference messageHandler;
     private List editorSet;
     private double fetchTimestamp;
     private boolean lockBeforeModify;
     private boolean propagateDeletesAfterEvent;
     private boolean stopValidationAfterError;
     private NSMutableArray insertedObjects;
     private NSMutableArray insertedObjectsBuffer;
     private NSArray insertedObjectsProxy;
     private NSMutableArray updatedObjects;
     private NSMutableArray updatedObjectsBuffer;
     private NSArray updatedObjectsProxy;
     private NSMutableArray deletedObjects;
     private NSMutableArray deletedObjectsBuffer;
     private NSArray deletedObjectsProxy;
     private NSMutableArray deletedIDsBuffer;
     private NSMutableArray invalidatedObjectsBuffer;
     private NSMutableArray invalidatedIDsBuffer;
     private Registrar registrar;
 //    private UndoManager undoManager;
 
     // so we don't have to trouble EOObserverCenter
     private boolean ignoreChanges;
     
     // for delayed handling of processRecentChanges
     private boolean willRunLater;
     
     // for handling of notifications posted 
     //   while we're in the saveChanges method
     private boolean isInvalidating;
 
     // for i18n or other customization
     static protected String MessageChangeConflict =
         "Another user changed an object you are editing: ";
  
     /***
     * Default constructor creates a new editing context
     * that uses the default object store.  If the default
     * object store has not been set, an exception is thrown.
     */ 
     public EOEditingContext()
     {
         this( defaultParentObjectStore() );
     }
 
     /***
     * Creates a new editing context that uses the specified
     * object store as its parent object store.
     */
     public EOEditingContext( EOObjectStore anObjectStore )
     {
         if ( anObjectStore == null ) 
         {
             throw new IllegalArgumentException(
                 "A parent object store must be specified." );
         }
         
         parentStore = anObjectStore;
         delegate = null;
         messageHandler = null;
         editorSet = new LinkedList();
         fetchTimestamp = 0;
         lockBeforeModify = false;
         propagateDeletesAfterEvent = true;
         stopValidationAfterError = true;
         insertedObjects = new NSMutableArray();
         insertedObjectsBuffer = new NSMutableArray();
         insertedObjectsProxy = NSArray.arrayBackedByList( insertedObjects );
         updatedObjects = new NSMutableArray();
         updatedObjectsBuffer = new NSMutableArray();
         updatedObjectsProxy = NSArray.arrayBackedByList( updatedObjects );
         deletedObjects = new NSMutableArray();
         deletedObjectsBuffer = new NSMutableArray();
         deletedObjectsProxy = NSArray.arrayBackedByList( deletedObjects );
         deletedIDsBuffer = new NSMutableArray();
         invalidatedObjectsBuffer = new NSMutableArray();
         invalidatedIDsBuffer = new NSMutableArray();
         
         if ( instancesRetainRegisteredObjects() )
         {
             registrar = new Registrar( this );
         }
         else
         {
             registrar = new WeakRegistrar( this );
         }
         
         ignoreChanges = false;
         willRunLater = false;
         isInvalidating = false;
 
         // create undo manager
         //TODO: this should be NSUndoManager
 //        undoManager = new UndoManager();
 
         // register for notifications
         NSSelector handleNotification = 
             new NSSelector( "handleNotification",
                 new Class[] { NSNotification.class } );
         // any from parent store
         NSNotificationCenter.defaultCenter().addObserver(
             this, handleNotification, null, parentStore );
         // global id change from any
         NSNotificationCenter.defaultCenter().addObserver(
             this, handleNotification, EOGlobalID.GlobalIDChangedNotification, null );
 //new net.wotonomy.ui.swing.NotificationInspector( null, parentStore );                
     }
 
     /***
     * Registers the specified object as an editor for this
     * context.  The object is expected to implement
     * EOEditingContext.Editor.
     */
     public void addEditor ( Object anEditor )
     {
         if ( anEditor == null ) return;
         editorSet.add( new WeakReference( anEditor ) );
     }
 
     /***
     * Returns a read-only List of objects associated with the object 
     * with the specified id for the specified property 
     * relationship, or may return a placeholder array that
     * will defer the fetch until needed (aka an array fault).
     * All objects must be registered in the specified editing context.
     * This implementation calls to its parent object store's
     * implementation if the requested source object is not 
     * registered in this editing context.
     * The specified relationship key must produce a result of
     * type Collection for the source object or an exception is thrown.
     */
     public NSArray arrayFaultWithSourceGlobalID ( 
         EOGlobalID aGlobalID,
         String aRelationshipKey,
         EOEditingContext aContext )
     {
         NSArray result = null;
         Object source = registrar.objectForGlobalID( aGlobalID );
         
         // if not registered in our context
         if ( source == null )
         {
             // get the object registered into our context
             result = parentStore.arrayFaultWithSourceGlobalID( 
                 aGlobalID, aRelationshipKey, this );
         }
         else // source is registered in our context
         {
             // get existing value
             Object value;
             if ( source instanceof EOKeyValueCoding )
             {
                 value = ((EOKeyValueCoding)source).storedValueForKey( 
                     aRelationshipKey );
             }
             else // handle directly
             {
                 value = EOKeyValueCodingSupport.storedValueForKey( 
                     source, aRelationshipKey );
             }
             
             if ( value == null )
             {
                 // do the same as if the source was null
                 result = parentStore.arrayFaultWithSourceGlobalID( 
                     aGlobalID, aRelationshipKey, this );
             }
             else
             if ( value instanceof NSArray )
             {
                 result = (NSArray) value;
             }
             else // not NSArray
             if ( value instanceof Collection )
             {
                 // convert to NSArray
                 result = new NSArray( (Collection) value );
             }
             else
             {
                 throw new WotonomyException( 
                     "Relationship key did not return a collection: " 
                     + aGlobalID + " : " + aRelationshipKey );   
             }
         }
         
         // if our context is not the specified context
         if ( aContext != this ) 
         {
             result = (NSArray) clone( this, result, aContext );
         }
         
         return result;
     }
  
     /***
     * Returns a snapshot of the specified object as it
     * existed when it was last read or committed to the
     * parent object store.
     */
     public NSDictionary committedSnapshotForObject ( 
         Object anObject )
     {
         byte[] snapshot = (byte[])
             registrar.getCommitSnapshot( anObject );
         if ( snapshot == null )
         {
             // this object not modified: take a current snapshot
             snapshot = takeSnapshot( anObject );
         }                
         return convertSnapshotToDictionary( snapshot );
     }
 
     /***
     * Returns a snapshot of the specified object as it
     * existed before the edits triggered by the current
     * event loop were processed.
     */
     public NSDictionary currentEventSnapshotForObject ( 
         Object anObject )
     {
         byte[] result = (byte[])
             registrar.getCurrentSnapshot( anObject );
         if ( result == null )
         {
             return committedSnapshotForObject( anObject );   
         }
         return convertSnapshotToDictionary( result );
     }
     
     /***
     * Returns the delegate for this editing context,
     * or null if no delegate has been set.
     */
     public Object delegate ()
     {
         if ( delegate == null ) return null;
         return delegate.get();
     }
 
     /***
     * Deletes the specified object from this editing context.
     * The editing context marks the object as deleted and
     * will notify the parent store when changes are committed.
     */
     public void deleteObject ( 
         Object anObject )
     {
         willChange();
 
 		int i;
 		// remove from added objects if necessary
 		i = insertedObjects.indexOfIdenticalObject( anObject );
 		if ( i != NSArray.NotFound )
 		{
 			insertedObjects.removeObjectAtIndex( i );
                         
             // if in the inserted objects buffer
             int index = insertedObjectsBuffer.indexOfIdenticalObject( anObject );
             if ( index != NSArray.NotFound )
             {
                 // remove from inserted objects buffer
                 insertedObjectsBuffer.removeObjectAtIndex( index );
             }
 
             // now forget the object ever existed.
             forgetObject( anObject );
 
             // we're done
             return;
 		}
 		else // otherwise add to deleted objects list
 		{
 			deletedObjects.addObject( anObject );
 		}
 		
 		// remove from updated objects if necessary
 		i = updatedObjects.indexOfIdenticalObject( anObject );
 		if ( i != NSArray.NotFound )
         {
             updatedObjects.removeObjectAtIndex( i );
         }
 
         // add to buffer
         deletedObjectsBuffer.addObject( anObject );            
         deletedIDsBuffer.addObject( globalIDForObject( anObject ) );            
     }
 
     /***
     * Returns a read-only List of all objects marked as deleted
     * in this editing context.
     */
     public NSArray deletedObjects ()
     {
         return deletedObjectsProxy;
     }
 
     /***
     * Called by child editing contexts when they no longer
     * need to track the specified id.
     * This implementation forwards the call to the parent store.
     */
     public void editingContextDidForgetObjectWithGlobalID ( 
         EOEditingContext aContext,
         EOGlobalID aGlobalID )
     {
         parentStore.editingContextDidForgetObjectWithGlobalID(
             aContext, aGlobalID );
     }
 
     /***
     * Returns a read-only List of registered editors of this
     * editing context.
     */
     public NSArray editors ()
     {
         NSMutableArray result = new NSMutableArray();
         Object o;
         Iterator i = editorSet.iterator();
         while ( i.hasNext() )
         {
             o = ((WeakReference)i.next()).get();
             if ( o != null )
             {
                 result.addObject( o );
             }
             else
             {
                 i.remove();
             }
         }
         return result;
     }
     
 /*
     public static void encodeObjectWithCoder ( 
         Object anObject,
         NSCoder aCoder )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
 
     /***
     * Returns the object for the specified id.
     * If the object is registered in in this context
     * but not in the specified context, 
     * this implementation will create a copy of the object 
     * and register it in the specified context.
     * Otherwise it will forward the call to the parent
     * object store.
     */
     public /*EOEnterpriseObject*/ Object faultForGlobalID ( 
         EOGlobalID aGlobalID,
         EOEditingContext aContext )
     {
         Object result = registrar.objectForGlobalID( aGlobalID );
         
         // if not registered in our context
         if ( result == null )
         {
             // get the object registered into our context
             result = parentStore.faultForGlobalID( aGlobalID, this );
         }
         
         // if our context is not the specified context
         if ( aContext != this ) 
         {
             result = registerClone( aGlobalID, this, result, aContext );
         }
         
         return result;
     }
 
     /***
     * Returns a fault representing an object of 
     * the specified entity type with values from 
     * the specified dictionary.  
     * This implementation calls faultForRawRow 
     * on the parent store.
     */
     public Object faultForRawRow ( 
         Map aDictionary,
         String anEntityName )
     {
         return parentStore.faultForRawRow(
             aDictionary, anEntityName, this );
     }
 
     /***
     * Returns a fault representing an object of 
     * the specified entity type with values from 
     * the specified dictionary.  The fault should
     * belong to the specified editing context.
     * This implementation forwards the call to
     * the parent store.
     */
     public /*EOEnterpriseObject*/ Object faultForRawRow ( 
         Map aDictionary,
         String anEntityName,
         EOEditingContext aContext )
     {
         return parentStore.faultForRawRow(
             aDictionary, anEntityName, aContext );
     }
 
     /***
     * Returns the fetch timestamp for this editing context.
     */
     public double fetchTimestamp ()
     {
         return fetchTimestamp;
     }
 
     /***
     * Unregisters the specified object from this editing context,
     * removing all references to it.  Use this method to remove
     * an object from the context without marking it for deletion.
     */ 
     public void forgetObject ( 
         Object anObject )
     {
         EOGlobalID id = registrar.globalIDForObject( anObject );
         if ( id == null ) 
         {
             System.err.println( 
                 "EOEditingContext.forgetObject: not registered: " + anObject );
             return;
         }
         
         // unregister object
         registrar.forgetObject( anObject );   
         
         // remove from all, inserted, updated, and deleted lists
         int index;
         index = updatedObjects.indexOfIdenticalObject( anObject );
         if ( index != NSArray.NotFound )
         {
             updatedObjects.removeObjectAtIndex( index );   
         }
         index = insertedObjects.indexOfIdenticalObject( anObject );
         if ( index != NSArray.NotFound )
         {
             insertedObjects.removeObjectAtIndex( index );   
             return;
         }
         index = deletedObjects.indexOfIdenticalObject( anObject );
         if ( index != NSArray.NotFound )
         {
             deletedObjects.removeObjectAtIndex( index );   
             return;
         }
 
         // notify parent context
         parentStore.editingContextDidForgetObjectWithGlobalID( this, id );
     }
 
     /***
     * Returns the id for the specified object, or null
     * if the object is not registered in this context.
     */
     public EOGlobalID globalIDForObject ( 
         Object anObject )
     {
         return registrar.globalIDForObject( anObject );
     }
     
     /***
     * Returns an array of ids for an array of objects.
     */
     private NSArray globalIDsForObjects( 
         List anObjectList )
     {
         NSMutableArray result = new NSMutableArray();
         Iterator it = anObjectList.iterator();
         while ( it.hasNext() )
         {
             result.add( globalIDForObject( it.next() ) );
         }
         return result;
     }
 
     /***
     * Returns whether this editing context has changes that
     * have not yet been committed to the parent object store.
     */
     public boolean hasChanges ()
     {
         if ( updatedObjects.count() > 0 ) return true;
         if ( insertedObjects.count() > 0 ) return true;
         if ( deletedObjects.count() > 0 ) return true;
         return false;
     }
 
     /***
     * Given a newly instantiated object, this method 
     * initializes its properties to values appropriate
     * for the specified id.  The object should already
     * belong to the specified editing context.  
     * This method is called to populate faults.
     * This implementation will try to apply the values
     * from an object with a matching id in this editing 
     * context if possible, calling to the parent object 
     * store only if such an object is not found.
     */
     public void initializeObject ( 
         /*EOEnterpriseObject*/ Object anObject,
         EOGlobalID aGlobalID,
         EOEditingContext aContext )
     {
         Object existingObject = registrar.objectForGlobalID( aGlobalID );
         
         // if not registered in our context
         if ( existingObject == null )
         {
             // get the object registered into our context
             existingObject = parentStore.faultForGlobalID( aGlobalID, this );
         }
         
         if ( aContext == this )
         {
             // initialize the object
             parentStore.initializeObject(
                 /*(EOEnterpriseObject)*/existingObject, aGlobalID, this );
         }
         else // ( aContext != this )
         {
             // translates child relationships
             copy( this, existingObject, aContext, anObject );
         }
 
         aContext.registrar.setCommitSnapshot( anObject, null );
         aContext.registrar.setCurrentSnapshot( anObject, null );
     }
 
     /***
     * Inserts the specified object into this editing context.
     * This implementation calls insertObjectWithGlobalID
     * with an EOTemporaryGlobalID.
     */
     public void insertObject ( Object anObject )
     {
         insertObjectWithGlobalID( 
             anObject, new EOTemporaryGlobalID() );
     }
 
     /***
     * Inserts the specified object into this editing context
     * with the specified id, which is expected to be a
     * temporary id.
     */
     public void insertObjectWithGlobalID ( 
         Object anObject,
         EOGlobalID aGlobalID )
     {
         willChange();
         
         // if this object was marked for deletion
         int index = deletedObjects.indexOfIdenticalObject( anObject );
         if ( index != NSArray.NotFound )
         {
              // don't need to re-register: just update the lists
             
              // remove from deleted list
              deletedObjects.removeObjectAtIndex( index );
     
              // if in the deleted ids buffer         
              index = deletedIDsBuffer.indexOfIdenticalObject( anObject );
              if ( index != NSArray.NotFound )
              {
                  // remove from deleted ids buffer
                  deletedIDsBuffer.removeObjectAtIndex( index );
              }
     
              // if in the deleted objects buffer         
              index = deletedObjectsBuffer.indexOfIdenticalObject( anObject );
              if ( index != NSArray.NotFound )
              {
                  // remove from deleted objects buffer
                  deletedObjectsBuffer.removeObjectAtIndex( index );
              }
              else // not in the deleted objects buffer
              {
                  // add to the inserted objects buffer
                  insertedObjectsBuffer.addObject( anObject );
              }
              
              // we're done
              return;
         }
 
         // make sure object is not already in editing context
         if ( objectForGlobalID( aGlobalID ) != null )
         {
             throw new WotonomyException( 
                 "Tried to insert but object was already registered:" 
                 + aGlobalID );
         }
         
         // register object
         recordObject( anObject, aGlobalID );
         
         // add to inserted list
         insertedObjects.addObject( anObject );
         // add to buffer
         insertedObjectsBuffer.addObject( anObject );
     }
 
     /***
     * Returns a read-only List of the objects that have been 
     * inserted into this editing context.
     */
     public NSArray insertedObjects ()
     {
         return insertedObjectsProxy;
     }
 
     /***
     * Turn all objects in this editing context into faults,
     * so that they will be fetched the next time they are 
     * accessed, and calls invalidateObjectsWithGlobalIDs
     * on the parent object store.
     */
     public void invalidateAllObjects ()
     {
         // register change so processRecentChanges is called
         willChange();
         
         invalidateAllObjectsQuietly();
         
         // post notification
         NSNotificationCenter.defaultCenter().postNotification(
             new NSNotification(
                 InvalidatedAllObjectsInStoreNotification, this ) );
     }
     
     /***
     * Only refaults all objects, does not notify will change
     * nor post notification, but does call parent store.
     * Called by invalidateAllObjects() and handleNotification().
     */ 
     private void invalidateAllObjectsQuietly()
     {
         // remember the ids
         NSMutableArray ids = new NSMutableArray( registrar.registeredGlobalIDs() );
 
         // track of discarded IDs (from inserted objects)
         NSMutableArray discardedIDs = new NSMutableArray();
 
         // refault all objects
         EOGlobalID id;
         Object o;
         Enumeration e = ids.objectEnumerator();
         while ( e.hasMoreElements() )
         {
             id = (EOGlobalID) e.nextElement();
             o = objectForGlobalID( id );
 
             // some objects may have been manually discarded
             if ( o != null )
             {
                 // don't refault newly inserted objects
                 if ( insertedObjects.indexOfIdenticalObject( o ) == NSArray.NotFound )
                 {
                     refaultObject( o, id, this );
                 }
                 else
                 {
                     // discard inserted objects
                     forgetObject( o );
                     discardedIDs.add( id );
                 }
                 invalidatedObjectsBuffer.add( o );
             }
             invalidatedIDsBuffer.add( id );
         }
         ids.removeAll( discardedIDs );
         
         // call to parent store (should call this after posting instead?)
         isInvalidating = true;        
         parentStore.invalidateObjectsWithGlobalIDs( ids );
         isInvalidating = false;        
     }
 
     /***
     * Turns the objects with the specified ids into faults,
     * so that they will be fetched the next time they are
     * accessed, and forwards the call to the parent object store.
     */
     public void invalidateObjectsWithGlobalIDs ( 
         List anArray )
     {
         // register change so processRecentChanges is called
         willChange();
 
         // call to parent to invalidate objects
         parentStore.invalidateObjectsWithGlobalIDs( anArray );
 
         Object o;
         EOGlobalID id;
         Iterator it = anArray.iterator();
         while ( it.hasNext() )
         {
             id = (EOGlobalID) it.next();
             if ( id != null )
             {
                 o = objectForGlobalID( id );
                 if ( o != null )
                 {
                     Object result = notifyDelegate(
                         "editingContextShouldInvalidateObject",
                         new Class[] { EOEditingContext.class, Object.class, EOGlobalID.class },
                         new Object[] { this, o, id } );
                     if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )
                     {
                         // refault the object
                         refaultObject( o, id, this );
                         invalidatedObjectsBuffer.add( o );
                         invalidatedIDsBuffer.add( id );
                     }
                 }
             }
             else
             {
                 throw new WotonomyException(
                     "Attempted to invalidate a null global id: " + anArray );
             }
         }
         
     }
 /*
     public boolean invalidatesObjectsWhenFinalized (  )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 
     public boolean invalidatesObjectsWhenFreed (  )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
     /***
     * Returns whether the object referenced by the 
     * specified id is locked.  
     * This implementation simply forwards the call to
     * the parent object store.
     */
     public boolean isObjectLockedWithGlobalID ( 
         EOGlobalID aGlobalID,
         EOEditingContext aContext)
     {
         return parentStore.isObjectLockedWithGlobalID(
             aGlobalID, aContext );
     }
 
 /*    
     public void lock ()
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
     /***
     * Locks the specified object in this editing context
     * by calling lockObjectWithGlobalID on the parent store.
     */
     public void lockObject ( 
         Object anObject )
     {
         parentStore.lockObjectWithGlobalID( 
             globalIDForObject( anObject ), this );
     }
 
     /***
     * Locks the object referenced by the specified id
     * in the specified editing context.
     * This implementation simply forwards the call to
     * the parent object store.
     */
     public void lockObjectWithGlobalID ( 
         EOGlobalID aGlobalID,
         EOEditingContext aContext)
     {
         parentStore.lockObjectWithGlobalID(
             aGlobalID, aContext );
     }
 
     /***
     * Returns whether this editing context attempts to
     * lock objects when they are first modified.
     */
     public boolean locksObjectsBeforeFirstModification ()
     {
         return lockBeforeModify;
     }
 
     /***
     * Returns the message handler for this editing context,
     * or null if no message handler has been set.
     */
     public Object messageHandler ()
     {
         if ( messageHandler == null ) return null;
         return messageHandler.get();
     }
 
     /***
     * Returns the object registered in this editing context
     * for the specified id, or null if that id is not 
     * registered.
     */
     public Object objectForGlobalID ( 
         EOGlobalID aGlobalID )
     {
         return registrar.objectForGlobalID( aGlobalID );
     }
 
     /***
     * Returns a read-only List of objects associated with the object 
     * with the specified id for the specified property 
     * relationship.  This method may not return an array fault
     * because array faults call this method to fetch on demand.
     * All objects must be registered the specified editing context.
     * The specified relationship key must produce a result of
     * type Collection for the source object or an exception is thrown.
     */
     public NSArray objectsForSourceGlobalID ( 
         EOGlobalID aGlobalID,
         String aRelationshipKey,
         EOEditingContext aContext )
     {
 //System.out.println( "EOEditingContext.objectsForSourceGlobalID: " 
 //+ aGlobalID + " : " + aRelationshipKey );        
     
         NSArray result = null;
         
 if ( aContext == this )
 {
     throw new WotonomyException( "Assert failed: calling objectsForSourceGlobalID on ourself." );   
 }
         Object source = registrar.objectForGlobalID( aGlobalID );
         
         // if not registered in our context
         if ( source == null )
         {
             // get the object registered into our context
             result = parentStore.objectsForSourceGlobalID( 
                 aGlobalID, aRelationshipKey, this );
         }
         else // source is registered in our context
         {
             // get existing value
             Object value;
             if ( source instanceof EOKeyValueCoding )
             {
                 value = ((EOKeyValueCoding)source).storedValueForKey( 
                     aRelationshipKey );
             }
             else // handle directly
             {
                 value = EOKeyValueCodingSupport.storedValueForKey( 
                     source, aRelationshipKey );
             }
             
             // if we don't have a valid value on our object
             if ( ( value == null ) 
             || ( ( value instanceof ArrayFault ) 
               && ( !((ArrayFault)value).isFetched() ) ) )
             {
                 // do the same as if the source was null
                 result = parentStore.objectsForSourceGlobalID( 
                     aGlobalID, aRelationshipKey, this );
                     
                 // set our value since we have it
                 if ( source instanceof EOKeyValueCoding )
                 {
                     ((EOKeyValueCoding)source).takeStoredValueForKey( 
                         result, aRelationshipKey );
                 }
                 else // handle directly
                 {
                     EOKeyValueCodingSupport.takeStoredValueForKey( 
                         source, result, aRelationshipKey );
                 }
             }
             else
             if ( ( value instanceof ArrayFault ) 
               && ( !((ArrayFault)value).isFetched() ) )
             {
                 // do the same as if the source was null
                 result = parentStore.objectsForSourceGlobalID( 
                     aGlobalID, aRelationshipKey, this );
             }
             else
             if ( value instanceof NSArray )
             {
                 result = (NSArray) value;
             }
             else // not NSArray
             if ( value instanceof Collection )
             {
                 // convert to NSArray
                 result = new NSArray( (Collection) value );
             }
             else
             {
                 throw new WotonomyException( 
                     "Relationship key did not return a collection: " 
                     + aGlobalID + " : " + aRelationshipKey );   
             }
         }
             
         // if our context is not the specified context
         if ( aContext != this ) 
         {
             result = (NSArray) clone( this, result, aContext );
         }
         
         return result;
     }
 
     /***
     * Returns a read-only List of objects the meet the criteria of
     * the supplied specification.  This method simply calls
     * objectsWithFetchSpecification on this editing context 
     * with this editing context as the parameter.
     */
     public NSArray objectsWithFetchSpecification ( 
         EOFetchSpecification aFetchSpec )
     {
         return objectsWithFetchSpecification( aFetchSpec, this );
     }
 
     /***
     * Returns a read-only List of objects the meet the criteria of
     * the supplied specification.  Faults are not allowed in the array.
     * If any objects are already fetched, they should not be
     * refetched. All objects should belong to the specified editing context.
     * This implementation forwards the call to the parent object
     * store, which will register each object in the specified editing
     * context only if it does not already exist.
     */
     public NSArray objectsWithFetchSpecification ( 
         EOFetchSpecification aFetchSpec,
         EOEditingContext aContext)
     {
         if ( aContext == this )
         {
             Object result = notifyDelegate(
                 "editingContextShouldFetchObjects",
                 new Class[] { EOEditingContext.class, EOFetchSpecification.class },
                 new Object[] { aContext, aFetchSpec } );
             if ( result instanceof NSArray ) return (NSArray) result;
         }
         return parentStore.objectsWithFetchSpecification( aFetchSpec, aContext );
     }
 
     /***
     * Returns the parent object store for this editing context.
     * The result will not be null.
     */
     public EOObjectStore parentObjectStore ()
     {
         return parentStore;
     }
 
     /***
     * Updates the inserted, updated, and deleted objects lists,
     * and posts notifications about which objects have been changed.
     * This method is called at the end of an event loop in which
     * objects were modified.  This method is additionally called
     * by saveChanges() so that any changes in the same event loop
     * will be processed correctly before calling to the parent
     * object store.
     * This implementation updates those lists immediately, but
     * only posts notifications when this method is called.
     */
     public void processRecentChanges ()
     { // System.out.println( "EOEditingContext.processRecentChanges: " + invalidatedObjectsBuffer );
         
     /*
     * This implementation actually updates those lists immediately,
     * but keeps a separate buffer of changes in the current event 
     * loop for the purposes of posting a notification.
     * NOTE: to reenable buffering, uncomment lines from this method
     * body and reenable the RecentChangesObserver in the constructor.
     */
 
         // broadcast ObjectsChangedInStoreNotification
         // for the benefit of child editing contexts
         
         boolean postStoreInfo = 
             ( insertedObjectsBuffer.size() + 
               updatedObjectsBuffer.size() +
               deletedIDsBuffer.size() +
               invalidatedIDsBuffer.size() > 0 );
         
         NSMutableDictionary storeInfo = new NSMutableDictionary();
         if ( postStoreInfo )
         {
             storeInfo.setObjectForKey( 
                 globalIDsForObjects( insertedObjectsBuffer ), 
     //            globalIDsForObjects( insertedObjects ), 
                 EOObjectStore.InsertedKey );
             storeInfo.setObjectForKey( 
                 globalIDsForObjects( updatedObjectsBuffer ), 
     //            globalIDsForObjects( updatedObjects ), 
                 EOObjectStore.UpdatedKey );
             storeInfo.setObjectForKey( 
                 new NSArray( (Collection) deletedIDsBuffer ), 
     //            globalIDsForObjects( deletedObjects ), 
                 EOObjectStore.DeletedKey );
             storeInfo.setObjectForKey( 
                 new NSArray( (Collection) invalidatedIDsBuffer ), 
                 EOObjectStore.InvalidatedKey );
         }
 
         // broadcast ObjectsChangedInEditingContextNotification
         // for the benefit of attached display groups
         
         boolean postContextInfo = 
             ( insertedObjectsBuffer.size() + 
               updatedObjectsBuffer.size() +
               deletedObjectsBuffer.size() +
               invalidatedObjectsBuffer.size() > 0 );
         
         NSMutableDictionary contextInfo = new NSMutableDictionary();
 
         if ( postContextInfo )
         {
                 
             contextInfo.setObjectForKey( 
                new NSArray( (Collection) insertedObjectsBuffer ), 
     //            new NSArray( (Collection) insertedObjects ), 
                 EOObjectStore.InsertedKey );
             contextInfo.setObjectForKey( 
                 new NSArray( (Collection) updatedObjectsBuffer ),  
     //            new NSArray( (Collection) updatedObjects ),  
                 EOObjectStore.UpdatedKey );
             contextInfo.setObjectForKey( 
                 new NSArray( (Collection) deletedObjectsBuffer ),  
     //            new NSArray( (Collection) deletedObjects ),  
                 EOObjectStore.DeletedKey );
             contextInfo.setObjectForKey( 
                 new NSArray( (Collection) invalidatedObjectsBuffer ),  
                 EOObjectStore.InvalidatedKey );
         }
     
         // update the current snapshots
         
         Object o;
         Iterator it;
         it = insertedObjectsBuffer.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             registrar.setCurrentSnapshot( o, takeSnapshot( o ) );
         }
         it = updatedObjectsBuffer.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             registrar.setCurrentSnapshot( o, takeSnapshot( o ) );
         }
 
         // clear buffers
         
         insertedObjectsBuffer.removeAllObjects();
         updatedObjectsBuffer.removeAllObjects();
         deletedObjectsBuffer.removeAllObjects();
         deletedIDsBuffer.removeAllObjects();
         invalidatedObjectsBuffer.removeAllObjects();
         invalidatedIDsBuffer.removeAllObjects();
 
         // post notifications (does order matter?)
         
         if ( postStoreInfo )
         {
             NSNotificationCenter.defaultCenter().postNotification(
                 new NSNotification(
                     ObjectsChangedInStoreNotification, this, storeInfo ) );
         }
         
         if ( postContextInfo )
         {
             NSNotificationCenter.defaultCenter().postNotification( 
                 new NSNotification(
                     ObjectsChangedInEditingContextNotification, this, contextInfo ) );
         }
 
     }
 
     /***
     * Returns whether this editing context propagates deletes
     * immediately after the event that triggered the delete.
     * Otherwise, propagation occurs only before commit.
     */
     public boolean propagatesDeletesAtEndOfEvent ()
     {
         return propagateDeletesAfterEvent;
     }
 
     /***
     * Registers the specified object in this editing context 
     * for the specified id.  This method is called by an object
     * store when fetching objects for a display group, or when
     * objects are inserted into a display group.
     * This implementation will re-register the object under the
     * new id if it is already registered under a different id.
     */
     public void recordObject ( 
         Object anObject,
         EOGlobalID aGlobalID )
     { 
         // find state for re-registration
         boolean inserted = false;
         boolean updated = false;
         boolean deleted = false;
 
         // is the object already registered?
         EOGlobalID existingID = globalIDForObject( anObject );
         if ( existingID != null )
         {
             // remember object state
             int index;
             index = insertedObjects.indexOfIdenticalObject( anObject );
             if ( index != NSArray.NotFound ) inserted = true;    
             index = updatedObjects.indexOfIdenticalObject( anObject );
             if ( index != NSArray.NotFound ) updated = true;    
             index = deletedObjects.indexOfIdenticalObject( anObject );
             if ( index != NSArray.NotFound ) deleted = true;    
             // forget the object
             forgetObject( anObject );
         }
 
         // is the global id already in use?
         Object existingObject = objectForGlobalID( aGlobalID );
         if ( existingObject != null )
         {
             // forget it (don't worry about state?)
             forgetObject( existingObject );
         }
 
         registrar.registerObject( anObject, aGlobalID );
         
         // restore state if necessary
         if ( inserted ) insertedObjects.addObject( anObject );
         if ( updated ) updatedObjects.addObject( anObject );
         if ( deleted ) deletedObjects.addObject( anObject );
     }
 
     /***
     * Undoes the last undo operation.
     */
     public void redo ()
     {
         //TODO: not supported yet
         throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /***
     * Refaults this editing context, turning all unmodified
     * objects into faults.  This implementation calls
     * editingContextWillSaveChanges() on all editors, and
     * then calls refaultObjects().
     */
     public void refault ()
     {
         fireWillSaveChanges();
         refaultObjects();
     }
 
     /***
     * Refaults the specified object, turning it into a fault
     * for the specified global id in the specified context.
     */
     public void refaultObject ( 
         Object anObject,
         EOGlobalID aGlobalID,
         EOEditingContext aContext)
     {
         aContext.registrar.setCurrentSnapshot( anObject, null );
 
         ignoreChanges = true;
         parentStore.refaultObject( anObject, aGlobalID, aContext );
         ignoreChanges = false;
         
 		// remove from updated objects if necessary
 		int i = updatedObjects.indexOfIdenticalObject( anObject );
 		if ( i != NSArray.NotFound )
         {
             updatedObjects.removeObjectAtIndex( i );
         }
 
         // add to invalidated notification queue
         invalidatedObjectsBuffer.addObject( anObject );
         invalidatedIDsBuffer.addObject( aGlobalID );
     }
 
     /***
     * Turns all unmodified objects into faults, calling
     * processRecentChanges() and then refaultObject() for
     * each unmodified object.
     */
     public void refaultObjects ()
     {
         // is this call really needed?
         // processRecentChanges();
         
         Object o;
         EOGlobalID id;
         Iterator it = registeredObjects().iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             if ( ( updatedObjects.indexOfIdenticalObject( o ) == NSArray.NotFound )
             &&   ( insertedObjects.indexOfIdenticalObject( o ) == NSArray.NotFound )
             &&   ( deletedObjects.indexOfIdenticalObject( o ) == NSArray.NotFound ) )
             {
                 id = globalIDForObject( o );
                 refaultObject( o, id, this );
             }
         }
     }
 
     /*** 
     * Calls editingContextWillSaveChanges() on all editors,
     * and then calls invalidateAllObjects().
     */ 
     public void refetch ()
     {
         fireWillSaveChanges();
         invalidateAllObjects();
     }
 
     /***
     * Returns a read-only List of all objects registered in this
     * editing context.
     */
     public NSArray registeredObjects ()
     {
         return registrar.registeredObjects();
     }
 
     /***
     * Unregisters the specified editor with this editing context.
     */
     public void removeEditor ( Object anObject )
     {
         if ( anObject == null ) return;
         
         Object o;
         Iterator i = editorSet.iterator();
         while ( i.hasNext() )
         {
             o = ((WeakReference)i.next()).get();
             if ( ( o == null ) || ( o == anObject ) )
             {
                 i.remove();
             }
         }
     }
 
     /***
     * Unregisters all objects from this editing context,
     * and resets the fetch timestamp.
     */
     public void reset ()
     {
         Iterator it = registeredObjects().iterator();
         while ( it.hasNext() )
         {
             forgetObject( it.next() );   
         }
         fetchTimestamp = 0; //FIXME: reset timestamp properly
     }
 
     /***
     * Reverts the objects in this editing context to
     * their original state.
     * Calls editingContextWillSaveChanges on all editors,
     * discards all inserted objects, restores deleted
     * objects, and applies the fetch snapshot to all
     * registered objects.
     */
     public void revert ()
     {
         willChange();
         fireWillSaveChanges();
 
         Iterator it;
         
         // forget inserted objects
         it = new NSArray( insertedObjects ).iterator();
         while ( it.hasNext() )
         {
             forgetObject( it.next() );
         }
 
         EOGlobalID id;
         Object o;
         byte[] snapshot;
 
         // re-initialize updated objects
         it = new NSArray( updatedObjects ).iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             snapshot = (byte[]) registrar.getCommitSnapshot( o );
             if ( snapshot != null )
             {
                 applySnapshot( snapshot, o );
             }
             registrar.setCommitSnapshot( o, null );
             updatedObjectsBuffer.addObject( o );
         }
 
         // re-initialize deleted objects
         it = new NSArray( deletedObjects ).iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             snapshot = (byte[]) registrar.getCommitSnapshot( o );
             if ( snapshot != null )
             {
                 applySnapshot( snapshot, o );
             }
             registrar.setCommitSnapshot( o, null );
             updatedObjectsBuffer.addObject( o );
         }
 
         // reset lists
         insertedObjects.removeAllObjects(); // unneccessary?
         deletedObjects.removeAllObjects();
         updatedObjects.removeAllObjects();
 
         // post notification
         processRecentChanges();        
     }
 
     /***
     * Returns the root object store, which is the parent
     * of all parent object stores of this editing context.
     */
     public EOObjectStore rootObjectStore ()
     {
         EOObjectStore parent = parentObjectStore();
         while ( parent instanceof EOEditingContext )
         {
             parent = ((EOEditingContext)parent).parentObjectStore();   
         }
         return parent;
     }
 
     /***
     * Calls editingContextWillSaveChanges on all editors,
     * and commits all changes in this editing context to 
     * the parent editing context by calling 
     * saveChangesInEditingContext to the parent.
     * Then posts EditingContextDidSaveChangeNotification.
     */
     public void saveChanges ()
     {
 //System.out.println( "EOEditingContext.saveChanges: " + this );        
         willChange();
 
         // process any changes
         processRecentChanges();
         
         // set up user info for notification to be posted.
         NSMutableDictionary userInfo = new NSMutableDictionary();
         userInfo.setObjectForKey( 
             new NSArray( (Collection) insertedObjects ), 
             EOObjectStore.InsertedKey );
         userInfo.setObjectForKey( 
             new NSArray( (Collection) updatedObjects ),  
             EOObjectStore.UpdatedKey );
         userInfo.setObjectForKey( 
             new NSArray( (Collection) deletedObjects ),  
             EOObjectStore.DeletedKey );
         
         // notify the editors
         fireWillSaveChanges();
 
         // notify the delegate
         notifyDelegate(
             "editingContextWillSaveChanges",
             new Class[] { EOEditingContext.class },
             new Object[] { this } );
 
         // needed for notification handling
         isInvalidating = true;
         try
         {
             // ask parent to save us
             parentStore.saveChangesInEditingContext( this );
         }
         catch ( RuntimeException e )
         {
             // unset save flag and rethrow
             isInvalidating = false;
             throw e;
         }
         isInvalidating = false;
         
         // no exceptions: proceed!
         
         Object o, key;
         Iterator it;
         
         // update the committed snapshots
         it = insertedObjects.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             registrar.setCommitSnapshot( o, null );
             registrar.setCurrentSnapshot( o, null );
         }
         it = updatedObjects.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             registrar.setCommitSnapshot( o, null );
             registrar.setCurrentSnapshot( o, null );
         }
         
         // clear the lists
         updatedObjects.removeAllObjects();
         insertedObjects.removeAllObjects();
         it = new NSArray( deletedObjects() ).iterator();
         while ( it.hasNext() )
         {   // parent is doing this as well?
             forgetObject( it.next() );   
         }
         
         // post notification
         NSNotificationCenter.defaultCenter().postNotification(
             new NSNotification(
                 EditingContextDidSaveChangesNotification, this, userInfo ) );
     }
 
     /***
     * Commits all changes in the specified editing context
     * to this one.  Called by child editing contexts in
     * their saveChanges() method.
     */
     public void saveChangesInEditingContext ( 
         EOEditingContext aContext)
     {
         Object o;
         Iterator it;
         
         // process deletes
         List deletes = new NSArray( aContext.deletedObjects() );
         it = deletes.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             EOGlobalID id = aContext.globalIDForObject( o );
             Object localVersion = objectForGlobalID( id );
             if ( localVersion == null )
             {
                 // make a local copy and register it
                 localVersion = registerClone( id, aContext, o, this );
                 if ( localVersion == null )
                 {
                     throw new WotonomyException(
                         "Deleted object could not be serialized: " 
                         + id + " : " + o );
                 }
             }
             else // we have a local version, copy changes
             {
                 copy( aContext, o, this, localVersion );
                 // copy marks the object as updated: will be on both lists
             }
             // delete our copy -- marks context as changed
             deleteObject( localVersion );
         }
 
         // process inserts - all inserts are new objects
         List inserts = new NSArray( aContext.insertedObjects() );
         it = inserts.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             // make a local copy and register it
             EOGlobalID id = aContext.globalIDForObject( o );
             willChange(); // need to mark editing context as changed
             Object localVersion = registerClone( id, aContext, o, this );
             if ( localVersion == null )
             {
                 throw new WotonomyException(
                     "Inserted object could not be