/*

 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.util.Collection;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Map;

 import net.wotonomy.foundation.NSArray;

 import net.wotonomy.foundation.NSMutableArray;

 import net.wotonomy.foundation.NSMutableDictionary;

 import net.wotonomy.foundation.NSNotification;

 import net.wotonomy.foundation.NSNotificationCenter;

 import net.wotonomy.foundation.NSNotificationQueue;

 import net.wotonomy.foundation.NSSelector;

 import net.wotonomy.foundation.internal.WotonomyException;

 /**

 * An abstract implementation of object store that 

 * implements common functionality.  Subclasses must

 * implement data object creation, initialization, and

 * refault logic, as well as logic to commit an editing 

 * context.

 */

 public abstract class AbstractObjectStore extends EOObjectStore

 {

     private NSMutableArray insertedIDsBuffer;

     private NSMutableArray updatedIDsBuffer;

     private NSMutableArray deletedIDsBuffer;

     private NSMutableArray invalidatedIDsBuffer;

     private Map snapshots;

     private List exceptionList;

     /**

     * Constructs a new instance of this object store.

     */

     public AbstractObjectStore()

     {

         snapshots = new HashMap();

         exceptionList = null;

         insertedIDsBuffer = new NSMutableArray();

         updatedIDsBuffer = new NSMutableArray();

         deletedIDsBuffer = new NSMutableArray();

         invalidatedIDsBuffer = new NSMutableArray();

         // register for notifications

         NSSelector handleNotification =

             new NSSelector( "handleNotification",

                 new Class[] { NSNotification.class } );

         NSNotificationCenter.defaultCenter().addObserver(

             this,

             handleNotification,

             EOClassDescription.ClassDescriptionNeededForEntityNameNotification,

             null );

     }

     /**

     * This implementation returns an appropriately configured array fault.

     */

     public NSArray arrayFaultWithSourceGlobalID( EOGlobalID aGlobalID,

                             String aRelationship, EOEditingContext aContext )

     { // System.out.println( "arrayFaultWithSourceGlobalID: " + aGlobalID + " : " + aRelationship );

         return new ArrayFault(

             aGlobalID, aRelationship, aContext );

     }

     /**

     * This implementation returns the actual object for the specified id.

     */

     public /*EOEnterpriseObject*/Object faultForGlobalID( EOGlobalID aGlobalID,

                                     EOEditingContext aContext )

     { // System.out.println( "faultForGlobalID: " + aGlobalID );

         return /*(EOEnterpriseObject)*/createInstanceWithEditingContext( aGlobalID, aContext );

     }

     /**

     * 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.

     * NOTE: Faults are not supported yet.

     */

     public /*EOEnterpriseObject*/Object faultForRawRow( Map aDictionary, String anEntityName,

                                   EOEditingContext aContext )

     {

         //TODO: raw rows are not yet supported

         throw new WotonomyException( "Faults are not yet supported." );

     }

     /**

     * Given a newly instantiated object, this method initializes its

     * properties to values appropriate for the specified id.  The object

     * should belong to the specified editing context. This method is called

     * to populate faults.

     */

     public void initializeObject( Object anObject, EOGlobalID aGlobalID,

                                   EOEditingContext aContext )

     { //System.out.println( "initializeObject: " + aGlobalID );

         try

         {

             String entity = entityForGlobalIDOrObject( aGlobalID, null );

             EOClassDescription classDesc = 

                 EOClassDescription.classDescriptionForEntityName( entity );

             if ( classDesc == null )

             {

                 throw new WotonomyException( "Unknown entity type: " + entity );   

             }

             Collection attributes = classDesc.attributeKeys();

             Map data = readFromCache( aGlobalID, attributes );

             String key;

             Iterator iterator = attributes.iterator();

             while ( iterator.hasNext() )

             {

                 key = iterator.next().toString();

                 // write the snapshot's reference into the object

                 if ( anObject instanceof EOKeyValueCoding )

                 {

                     ((EOKeyValueCoding)anObject).takeStoredValueForKey( data.get( key ), key );

                 }

                 else

                 {

                     EOKeyValueCodingSupport.takeStoredValueForKey( anObject, data.get( key ), key );

                 }

                 //NOTE: our objects are expected to make a copy

                 // of their data before it is modified, so it's okay

                 // to return them our copy of the data: 

                 // we trust that they will not modify it.

             }

         }

         catch ( Exception exc )

         {        

             exc.printStackTrace();

         }

     }

     /**

     * Reads the local data snapshot for the specified id.

     * If no snapshot exists, a new snapshot is created.

     * If the specified keys are not in the snapshot,

     * new data is fetched into the snapshot.

     * If null is specified, all known keys are returned.

     * Will not return null.  

     * Result will have values for those keys and only

     * those keys requested.  Missing keys indicate an

     * error occurred.

     */

     protected Map readFromCache( EOGlobalID aGlobalID, Collection keys )

     {

         Map snapshot = (Map) snapshots.get( aGlobalID );

         // if no snapshot for this id, create an empty one

         if ( snapshot == null )

         {

             snapshot = new HashMap();

             snapshots.put( aGlobalID, snapshot );

         }

         // if we don't have all the necessary keys

         if ( ( keys == null ) || ( ! snapshot.keySet().containsAll( keys ) ) )

         {

             // we need to make a server call

             try

             {

                 Map data = readObject( aGlobalID, keys );

                 // compare timestamps 

                 Comparable localTimestamp = (Comparable) timestampForData( snapshot );

                 // if our local snapshot has an timestamp (new snapshots don't have timestamp)

                 if ( localTimestamp != null )

                 {

                     Comparable incomingTimestamp = (Comparable) timestampForData( data );

                     if ( incomingTimestamp == null )

                     {

                         // not allowed to happen

                         new RuntimeException( "Server returned data without an timestamp" ).printStackTrace();

                         // however, we can just assume it's a newer timestamp and continue

                     }

                     // if timestamps don't match

                     if ( ( incomingTimestamp == null ) || ( ! incomingTimestamp.equals( localTimestamp ) ) )

                     {

                         // dump our existing snapshot's data

                         snapshot.clear();

                         // queue for a notification on this oid as updated

                         //TODO: implement this

                     }

                 }

                 // copy new data into our local snapshot

                 snapshot.putAll( data );

             }

             catch ( Exception exc )

             {        

                 exc.printStackTrace();

             }

         }

         // return just the requested keys from our updated snapshot

         Map result = new HashMap();

         if ( keys == null )

         {

             result.putAll( snapshot );

         }

         else

         {

             Object key;

             Iterator iterator = keys.iterator();

             while ( iterator.hasNext() )

             {

                 key = iterator.next();

                 result.put( key, snapshot.get( key ) );

             }

         }

         return snapshot;

     }

     /**

     * Returns a comparable object (typically a Date or Long) for

     * the given data map or snapshot.  This is used to determine

     * whether a local snapshot should be dumped in favor of fetched

     * data from the server.

     * Returns null if no timestamp can be determined, in which

     * case the fetched data will assumed to be more recent than

     * any local snapshot.

     */

     abstract protected Comparable timestampForData( Map aDataMap );

     /**

     * Extracts the global id for the fetched data or snapshot.

     * Some entities have multi-attribute keys that would be 

     * assembled into a single instance of EOGlobalID.

     */

     abstract protected EOGlobalID globalIDForData( Map aDataMap );

     /**

     * Returns the entity that corresponds to the specified global id

     * and/or object.  Either may be null, but both will not be null.

     * //FIXME: This is less than elegant.

     */

     abstract protected String entityForGlobalIDOrObject( 

         EOGlobalID aGlobalID, Object anObject );

     /**

     * Returns the keys that have changed on the specified object.

     * If null, all keys are presumed changed, including relationships.

     */

     abstract protected Collection changedKeysForObject( Object anObject );

     /**

     * Returns the data for the row corresponding to the specified id

     * containing at least the specified keys.  Implementations are allowed

     * to return more data than requested, and callers are advised to take

     * advantage of the returned data.

     */

     abstract protected Map readObject( EOGlobalID aGlobalID, Collection keys );

     /**

     * Returns the data for the row corresponding to the specified id.

     * //TODO: Need a better return value?  How to return invalidated list?

     */

     abstract protected Map insertObject( EOGlobalID aGlobalID, Map aDataMap );

     /**

     * Returns the data for the row corresponding to the specified id.

     * //TODO: Need a better return value?  How to return invalidated list?

     */

     abstract protected Object updateObject( EOGlobalID aGlobalID, Map aDataMap );

     /**

     * Returns the data for the row corresponding to the specified id.

     * //TODO: Need a better return value?  How to return invalidated list?

     */

     abstract protected Object deleteObject( EOGlobalID aGlobalID );

     /**

     * Creates a new instance of an object that corresponds to the

     * specified global id and is registered in the specified context.

     * This implementation extracts the entity type from getEntityForGlobaID

     * and construct a new instance from the class description that 

     * corresponds to the entity type.  Override to change this behavior.

     */

     protected Object createInstanceWithEditingContext( 

         EOGlobalID aGlobalID, EOEditingContext aContext )

     {

         String entity = entityForGlobalIDOrObject( aGlobalID, null );

         EOClassDescription classDesc = 

             EOClassDescription.classDescriptionForEntityName( entity );

         if ( classDesc == null )

         {

              throw new WotonomyException( "Unknown entity type: " + entity );   

         }

         Object result = classDesc.createInstanceWithEditingContext( aContext, aGlobalID );

         if ( result instanceof EOFaulting )

         {

             ((EOFaulting)result).turnIntoFault( null );

         }

         return result;

     }

     /**

     * Dumps the snapshot corresponding to the specified id.

     */

     protected void invalidateObject( EOGlobalID aGlobalID )

     {

         snapshots.remove( aGlobalID );

     }

     /**

     * Dumps all snapshots.

     */

     protected void invalidateAllCache()

     {

         snapshots.clear();

     }

     /**

     * Remove all values from all objects in memory, turning them into faults,

     * and posts a notification that all objects have been invalidated.

     */

     public void invalidateAllObjects()

     {

         invalidateAllCache();

         // post notification

         NSNotificationQueue.defaultQueue().enqueueNotification(

             new NSNotification(

                 InvalidatedAllObjectsInStoreNotification, this ),

             NSNotificationQueue.PostNow );

     }

     /**

     * Removes values with the specified ids from memory, turning them into

     * faults, and posts a notification that those objects have been invalidated.

     */

     public void invalidateObjectsWithGlobalIDs( List aList )

     {

         NSArray empty = new NSArray();

         NSMutableArray invalidated = new NSMutableArray();

         Object object;

         Iterator iterator = aList.iterator();

         while ( iterator.hasNext() )

         {

             object = iterator.next();

             invalidateObject( (EOGlobalID) object );

             invalidated.addObject( object );

         }

         NSMutableDictionary info = new NSMutableDictionary();

         info.setObjectForKey( empty, InsertedKey );

         info.setObjectForKey( empty, UpdatedKey );

         info.setObjectForKey( empty, DeletedKey );

         info.setObjectForKey( invalidated, InvalidatedKey );

         // post notification

         NSNotificationQueue.defaultQueue().

             enqueueNotificationWithCoalesceMaskForModes( new NSNotification(

                 ObjectsChangedInStoreNotification, this, info ),

             NSNotificationQueue.PostNow,

             NSNotificationQueue.NotificationNoCoalescing, null );

     }

     /**

     * Returns false because locking is not currently permitted.

     */

     public boolean isObjectLockedWithGlobalID( EOGlobalID aGlobalID,

                                                EOEditingContext aContext )

     {

         return false;

     }

     /**

     * Does nothing because locking is not currently permitted.

     */

     public void lockObjectWithGlobalID( EOGlobalID aGlobalID,

                                         EOEditingContext aContext )

     {

         // does nothing

     }

     /**

     * Returns a 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 aRelationship, EOEditingContext aContext )

     { // System.out.println( "objectsForSourceGlobalID: " + aGlobalID + " : " + aRelationship + " : " ); 

         Map snapshot = readFromCache( aGlobalID, new NSArray( aRelationship ) );

         Object value = snapshot.get( aRelationship );

         if ( value == null ) value = new NSArray(); // empty list

         if ( ! ( value instanceof Collection ) )

         {

             throw new RuntimeException( "Specified relationship is not a collection: " 

                 + aRelationship + " : " + aGlobalID + " : " + value );

         }

         NSArray result = new NSMutableArray();

         // get fault for each id

         EOGlobalID id;

         Object fault;

         Iterator iterator = ((Collection)value).iterator();

         while ( iterator.hasNext() )

         {

             id = (EOGlobalID) iterator.next();

             // get registered fault

             fault = aContext.faultForGlobalID( id, aContext );

             // assert fault

             if ( fault == null )

             {

                 // this should never happen

                 throw new RuntimeException(

                     "Could not find fault for ID: " + id );

             }

             result.add( fault );

         }

         fireObjectsChangedInStore();

 //System.out.println( "done" );

         return result;

     }

     /**

     * Returns a List of objects the meet the criteria of

     * the supplied specification.  Faults are not allowed in the array.

     * Each object is registered with the specified editing context.

     * If any object is already fetched in the specified context,

     * it is not refetched and that object should be used in the array.

     */

     public NSArray objectsWithFetchSpecification(

                 EOFetchSpecification aFetchSpec, EOEditingContext aContext )

     {

         NSMutableArray result = new NSMutableArray();

         //TODO: implement this

         return result;

     }

     /**

     * Fires ObjectsChangedInStoreNotification

     * with contents of buffers and then clears buffers.

     * If buffers are empty, does nothing.

     */

     private void fireObjectsChangedInStore()

     {

         // check for changes to broadcast

         if ( insertedIDsBuffer.size() + updatedIDsBuffer.size() +

              deletedIDsBuffer.size() + invalidatedIDsBuffer.size() == 0 )

         {

             return;

         }

         // broadcast ObjectsChangedInStoreNotification

         // for the benefit of child editing contexts

         NSMutableDictionary storeInfo = new NSMutableDictionary();

         storeInfo.setObjectForKey(

             new NSArray( (Collection) insertedIDsBuffer ),

             EOObjectStore.InsertedKey );

         storeInfo.setObjectForKey(

             new NSArray( (Collection) updatedIDsBuffer ),

             EOObjectStore.UpdatedKey );

         storeInfo.setObjectForKey(

             new NSArray( (Collection) deletedIDsBuffer ),

             EOObjectStore.DeletedKey );

         storeInfo.setObjectForKey(

             new NSArray( (Collection) invalidatedIDsBuffer ),

             EOObjectStore.InvalidatedKey );

         // clear buffers

         insertedIDsBuffer.removeAllObjects();

         updatedIDsBuffer.removeAllObjects();

         deletedIDsBuffer.removeAllObjects();

         invalidatedIDsBuffer.removeAllObjects();

         // post notification

         NSNotificationQueue.defaultQueue().

             enqueueNotificationWithCoalesceMaskForModes( new NSNotification(

                 ObjectsChangedInStoreNotification, this, storeInfo ),

             NSNotificationQueue.PostNow,

             NSNotificationQueue.NotificationNoCoalescing, null );

     }

     /**

     * Removes all values from the specified object,

     * converting it into a fault for the specified id.

     * New or deleted objects should not be refaulted.

     */

     public void refaultObject( Object anObject, EOGlobalID aGlobalID,

                                EOEditingContext aContext )

     {

 //System.out.println( "refaultObject: " + aGlobalID ); 

 //new net.wotonomy.ui.swing.util.StackTraceInspector();

         if ( anObject instanceof EOFaulting )

         {

             ((EOFaulting)anObject).turnIntoFault( null );

         }

     }

     /**

     * Writes all changes in the specified editing context

     * to the respository.

     */

     public void saveChangesInEditingContext ( EOEditingContext aContext )

     {

         Object result; // need a container result?

         Map updateMap;

         Object object;

         EOGlobalID id;

         Iterator iterator;

         //TODO: the ordering of operations here 

         // needs to be a lot more sophisticated.

         // process deletes first

         iterator = aContext.deletedObjects().iterator();

         while ( iterator.hasNext() )

         {

             object = iterator.next();

             id = aContext.globalIDForObject( object );

             try

             {

                 result = deleteObject( id );

             }

             catch ( Exception exc )

             {

                 System.out.println( "Error deleting object: " + id );

                 exc.printStackTrace();

             }

         }

         // process inserts next

         iterator = aContext.insertedObjects().iterator();

         while ( iterator.hasNext() )

         {

             object = iterator.next();

             processInsert( aContext, object );

         }

         // process updates last

         iterator = aContext.updatedObjects().iterator();

         while ( iterator.hasNext() )

         {

             object = iterator.next();

             id = aContext.globalIDForObject( object );

             try

             {

                 updateMap = getUpdateMap( aContext, object );

                 result = updateObject( id, updateMap );

             }

             catch ( Exception exc )

             {

                 System.out.println( "Error updating object: " + id );

                 exc.printStackTrace();

             }

         }

         //aContext.invalidateAllObjects();

     }

     protected Object processInsert( EOEditingContext aContext, Object object )

     {

         Map result = null; 

         EOGlobalID id = aContext.globalIDForObject( object );

         try

         {

             Map updateMap;

             updateMap = getUpdateMap( aContext, object ); 

             result = insertObject( id, updateMap );

             id = globalIDForData( result ); // read new permanent id

             // broadcast that the global id has changed.

             NSMutableDictionary userInfo = new NSMutableDictionary();

             userInfo.setObjectForKey( id, aContext.globalIDForObject( object ) );

             NSNotificationQueue.defaultQueue().enqueueNotification(

                 new NSNotification( EOGlobalID.GlobalIDChangedNotification,

                 null , userInfo ), NSNotificationQueue.PostNow );

         }

         catch ( Exception exc )

         {

             System.out.println( "Error inserting object: " + id );