/*

 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(