package net.wotonomy.test;

 import java.util.Iterator;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Map;

 import net.wotonomy.control.ArrayFault;

 import net.wotonomy.control.EOEditingContext;

 import net.wotonomy.control.EOFetchSpecification;

 import net.wotonomy.control.EOGlobalID;

 import net.wotonomy.control.EOObjectStore;

 import net.wotonomy.control.EOObserverCenter;

 import net.wotonomy.control.KeyValueCodingUtilities;

 import net.wotonomy.datastore.DataKey;

 import net.wotonomy.datastore.DataSoup;

 import net.wotonomy.datastore.DataView;

 import net.wotonomy.datastore.XMLFileSoup;

 import net.wotonomy.foundation.NSArray;

 import net.wotonomy.foundation.NSMutableArray;

 import net.wotonomy.foundation.NSMutableDictionary;

 import net.wotonomy.foundation.NSNotification;

 import net.wotonomy.foundation.NSNotificationQueue;

 import net.wotonomy.foundation.internal.WotonomyException;

 /**

 * An object store that wraps a datastore for vending test objects.

 */

 public class DataObjectStore extends EOObjectStore

 {

     DataSoup soup;

     /**

     * Constructor specifies path to datastore.

     */

     public DataObjectStore( String aPath )

     {

         soup = new XMLFileSoup( aPath );

     }

     /**

     * This implementation returns an appropriately configured array fault.

     */

     public NSArray arrayFaultWithSourceGlobalID ( 

         EOGlobalID aGlobalID,

         String aRelationship,

         EOEditingContext aContext )

     {

         return new ArrayFault( 

             aGlobalID, aRelationship, aContext );

     }

     /**

     * This implementation returns the actual

     * object for the specified id.

     */

     public Object faultForGlobalID ( 

         EOGlobalID aGlobalID,

         EOEditingContext aContext )

     {

 System.out.println( "DataObjectStore.faultForGlobalID: * reading object * : " + aGlobalID );

         Object result = soup.getObjectByKey( 

             ((DataKeyID)aGlobalID).getKey() );

         if ( result == null ) return null;

         //! transpose keys to objects

         convertRelationKeysToObjects( aContext, result, aGlobalID );

         //!

         aContext.recordObject( result, aGlobalID );

         return result;

     }

     /**

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

     */        

     public Object faultForRawRow ( 

         Map aDictionary,

         String anEntityName,

         EOEditingContext aContext )

     {

         //TODO: faults 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) {

                 if (aGlobalID.isTemporary()) {

                         // TODO: this should never happen, but it does now until we get

                         // faults.

                         // do not reinit an uncommitted object

                         return;

                 }

                 System.out.println("DataObjectStore.initializeObject: * reading object * : "

                                                 + aGlobalID);

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

                 Object original = soup.getObjectByKey(((DataKeyID) aGlobalID).getKey());

                 // ! transpose keys to objects

                 convertRelationKeysToObjects(aContext, original, aGlobalID);

                 // !

                 EOObserverCenter.notifyObserversObjectWillChange(anObject);

                 KeyValueCodingUtilities.copy(aContext, original, aContext, anObject);

         }

     /**

          * 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 ()

     {

         // does nothing except 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 )

     {

         // does nothing

     }

     /**

     * Returns false because locking is not permitted.

     */

     public boolean isObjectLockedWithGlobalID ( 

         EOGlobalID aGlobalID,

         EOEditingContext aContext )

     {

         return false;

     }

     /**

     * Does nothing because locking is not 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( "DataObjectStore.objectsForSourceGlobalID: * reading object * : " + aGlobalID );

         Object object = soup.getObjectByKey(((DataKeyID)aGlobalID).getKey() );

         if ( object == null ) return null;

         Object fault;

         EOGlobalID id;

         NSMutableArray result = new NSMutableArray();

         Iterator it = ((TestObject)object).getChildList().iterator();

         while ( it.hasNext() )

         {

             id = new DataKeyID((DataKey)it.next());

             fault = aContext.faultForGlobalID( id, aContext );

             // if key still exists

             if ( fault != null ) 

             {

 //System.out.println( "objectsForSourceGlobalID: found: " + id + " : " + fault ); 

                 result.add( fault );

 // for testing purposes                

 ((TestObject)fault).setParent( (TestObject) object );

             }

             else // key no longer exists

             {

                 // do not add

 System.out.println( "objectsForSourceGlobalID: could not find fault for id: " + id ); 

             }

         }

         return result;

     }

     /**

     * Returns a List of objects the meet the criteria of

     * the supplied specification.  

     * Each object is registered with the specified editing context.

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

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

     */

     public NSArray objectsWithFetchSpecification ( 

         EOFetchSpecification aFetchSpec,

         EOEditingContext aContext )

     {

         //TODO: fetch specs are not yet supported

         DataView view = soup.queryObjects( null, null );

 System.out.println( "DataObjectStore: ** querying all objects **" );

         // we've changed this implementation so that 

         // it simply calls faultForGlobalID on the context

         // for each id in the result set.

         // this way, child contexts inherit parent's state.

         // however, it's unclear if the specification allows

         // faults in the resulting array.  sounds like it doesn't.

         NSMutableArray result = new NSMutableArray();

         DataKeyID id;

         Iterator it = view.iterator();

         while ( it.hasNext() )

         {

             id = new DataKeyID( view.getKeyForObject( it.next() ) );

             result.addObject( aContext.faultForGlobalID( id, aContext ) );

         }

         return result;

     }

     /**

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

     {

         //TODO: faults are not yet supported

         // just re-initialize the object

         initializeObject( anObject, aGlobalID, aContext );

     }

     /**

     * Writes all changes in the specified editing context

     * to the respository.

     */

     public void saveChangesInEditingContext ( 

         EOEditingContext aContext )

     {

         Object o;

         DataKeyID id;

         Iterator it;

         // process deletes

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

         while ( it.hasNext() )

         {

             o = it.next();

             id = (DataKeyID) aContext.globalIDForObject( o );

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

             soup.removeObject( id.getKey() );

             // remove object from editing context

             aContext.forgetObject( o );

         }

         // process inserts

         NSMutableDictionary userInfo = null;

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

         while ( it.hasNext() )

         {   

             o = it.next();

             EOGlobalID oldId = aContext.globalIDForObject( o );

             //! transpose objects to keys

             convertRelationObjectsToKeys( aContext, (TestObject) o );

             id = new DataKeyID( soup.addObject( o ) );

             convertRelationKeysToObjects( aContext, (TestObject) o, oldId );

             //!

 System.out.println( "DataObjectStore: * adding object * : " + id );

             // save mapping of old id to new id

             if ( userInfo == null ) 

             {

                 userInfo = new NSMutableDictionary();   

             }

             userInfo.setObjectForKey( id, oldId );

         }

         // broadcast inserted objects' new ids if necessary

         if ( userInfo != null )

         {

             NSNotificationQueue.defaultQueue().enqueueNotification(

                 new NSNotification(

                     EOGlobalID.GlobalIDChangedNotification, null, userInfo ),

                 NSNotificationQueue.PostNow );

         }

         System.out.println( aContext.updatedObjects() );

         // process updates

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

         while ( it.hasNext() )

         {

 //if ( true ) // test validation error message handling

 //throw new RuntimeException( "Update not allowed." );            

             o = it.next();

             id = (DataKeyID) aContext.globalIDForObject( o );

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

             //! transpose objects to keys

             convertRelationObjectsToKeys( aContext, (TestObject) o );

             soup.updateObject( id.getKey(), o );

             convertRelationKeysToObjects( aContext, (TestObject) o, id );

             //!

         }

     }

     private void convertRelationKeysToObjects( 

         EOEditingContext aContext, Object anObject, EOGlobalID aGlobalID )

     { // System.out.println( "convertRelationKeysToObjects: " + anObject );        

 // set editing context for testing

 ((TestObject)anObject).editingContext = aContext;

         Object fault;

         DataKeyID id;

         List result = new LinkedList();

         Iterator it = ((TestObject)anObject).getChildList().iterator();

         while ( it.hasNext() )

         {

             id = new DataKeyID((DataKey)it.next());

             fault = aContext.faultForGlobalID( id, aContext );

             // if key still exists

             if ( fault != null ) 

             {

 //System.out.println( "convertRelationObjectsToKeys: found: " + id + " : " + fault ); 

                 result.add( fault );

 // for testing purposes                

 ((TestObject)fault).setParent( (TestObject) anObject );

             }

             else // key no longer exists

             {

                 // do not add

 System.out.println( "convertRelationObjectsToKeys: could not find fault for id: " + id ); 

             }

         }

         // this tests loading manually on-demand

 //        ((TestObject)anObject).setChildList( null );

         // this tests loading immediately

         ((TestObject)anObject).setChildList( result );

         // this tests loading array faults

 //        ((TestObject)result).setChildList( null );

         ((TestObject)anObject).setChildList( 

             aContext.arrayFaultWithSourceGlobalID( 

                 aGlobalID, "childList", aContext ) );

     }

     private void convertRelationObjectsToKeys( 

         EOEditingContext aContext, Object anObject )

     { // System.out.println( "convertRelationObjectsToKeys: " + anObject );        

         Object o;

         DataKeyID id;

         List result = new LinkedList();

         Iterator it = ((TestObject)anObject).getChildList().iterator();

 // for testing purposes                

 ((TestObject)anObject).setParent( null );

 ((TestObject)anObject).editingContext = null;

         while ( it.hasNext() )

         {

             o = it.next();

 //System.out.println( "convertRelationObjectsToKeys: " + o + " : " + aContext.globalIDForObject( o ) ); 

             id = (DataKeyID)aContext.globalIDForObject( o );            

             // if object still exists in context

             if ( id != null ) 

             {

                 result.add( id.getKey() );

             }

             else // object was deleted

             {

                 // do not add  

 System.out.println( "convertRelationObjectsToKeys: could not find id for object: " + o ); 

 System.out.println( aContext.registeredObjects() ); 

             }

         }

         ((TestObject)anObject).setChildList( result );

     }

 /*

  * $Log$

  * Revision 1.1  2006/02/19 16:30:25  cgruber

  * Update imports and maven dependencies.

  *

  * Revision 1.1  2006/02/16 13:18:56  cgruber

  * Check in all sources in eclipse-friendly maven-enabled packages.

  *

  * Revision 1.18  2002/03/11 03:18:39  mpowers

  * Now properly handling ObserverChangesLater.

  *

  * Revision 1.17  2001/10/26 18:39:44  mpowers

  * Posting notifications immediately, rather than delayed.

  *

  * Revision 1.16  2001/05/06 18:27:10  mpowers

  * More broadly catching editing contexts for now.

  *

  * Revision 1.15  2001/05/05 23:05:43  mpowers

  * Implemented Array Faults.

  *

  * Revision 1.14  2001/05/05 15:00:06  mpowers

  * Tested load-on-demand: still works.

  * Now using registerClone for consistency.

  * Editing context is temporarily posting notification on objectWillChange.

  *

  * Revision 1.13  2001/05/04 23:24:30  mpowers

  * Changes to test code.

  *

  * Revision 1.12  2001/05/04 16:57:56  mpowers

  * Now correctly transposing references to editing contexts when

  * cloning/copying between editing contexts.

  *

  * Revision 1.11  2001/05/02 17:33:28  mpowers

  * More changes for testing.

  *

  * Revision 1.10  2001/04/30 13:15:24  mpowers

  * Child contexts re-initializing objects invalidated in parent now

  * propery transpose relationships.

  *

  * Revision 1.9  2001/04/29 22:02:45  mpowers

  * Work on id transposing between editing contexts.

  *

  * Revision 1.8  2001/04/29 02:29:31  mpowers

  * Debugging relationship faulting.

  *

  * Revision 1.7  2001/04/28 22:17:51  mpowers

  * Revised PropertyDataSource to be EOClassDescription-aware.

  *

  * Revision 1.6  2001/04/28 16:18:44  mpowers

  * Implementing relationships.

  *

  * Revision 1.5  2001/04/13 16:33:36  mpowers

  * Now broadcasting notifications.

  *

  * Revision 1.4  2001/04/08 21:00:54  mpowers

  * Changes to support new objectsForFetchSpecification scheme.

  *

  * Revision 1.3  2001/03/22 21:37:52  mpowers

  * Testing new features.

  *

  * Revision 1.2  2001/03/15 21:10:41  mpowers

  * Implemented global id re-registration for newly saved inserts.

  *

  * Revision 1.1  2001/03/05 22:12:11  mpowers

  * Created the control package for a datastore-specific implementation

  * of EOObjectStore.

  *

  * 

  */

 }