package net.wotonomy.test;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 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.test.DataKeyID;

 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.internal.Duplicator;

 import net.wotonomy.foundation.internal.WotonomyException;

 /**

 * An object store that wraps a datastore

 * for vending test objects.

 */

 public class TestObjectStore extends EOObjectStore

 {

     DataSoup soup;

     /**

     * Constructor specifies path to datastore.

     */

     public TestObjectStore( String aPath )

     {

         soup = new XMLFileSoup( aPath );

     }

     /**

     * This implementation simply returns 

     * objectsWithSourceGlobalID.

     */

     public NSArray arrayFaultWithSourceGlobalID ( 

         EOGlobalID aGlobalID,

         String aRelationship,

         EOEditingContext aContext )

     {

         return objectsForSourceGlobalID( 

             aGlobalID, aRelationship, aContext );

     }

     /**

     * This implementation returns the actual

     * object for the specified id.

     */

     public Object faultForGlobalID ( 

         EOGlobalID aGlobalID,

         EOEditingContext aContext )

     {

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

         return soup.getObjectByKey( 

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

     }

     /**

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

     {

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

         Object original = soup.getObjectByKey( 

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

         EOObserverCenter.notifyObserversObjectWillChange( anObject );

         Duplicator.deepCopy( original, anObject );

         //TODO: need to handle child object registration in aContext

     }

     /**

     * 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        

     }

     /**

     * 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.  Faults are not allowed in the array.

     * All objects should belong to the specified editing context.

     */

     public NSArray objectsForSourceGlobalID ( 

         EOGlobalID aGlobalID,

         String aRelationship,

         EOEditingContext aContext )

     {

         //TODO: relationships are not yet supported

         throw new WotonomyException( 

             "Relationships are not yet supported." );

     }

     /**

     * 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 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( "TestObjectStore: ** querying all objects **" );

         NSMutableArray result = new NSMutableArray();

         Object o;

         Object existing;

         DataKeyID id;

         Iterator it = view.iterator();

         while ( it.hasNext() )

         {

             o = it.next();

             id = new DataKeyID( view.getKeyForObject( o ) );

             existing = aContext.objectForGlobalID( id );

             if ( existing != null )

             {

                 o = existing;    

             }

             else

             {

                 aContext.recordObject( o, id );

             }

             result.addObject( o );

         }

         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;

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

         // process updates

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

         while ( it.hasNext() )

         {

             o = it.next();

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

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

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

         }

         // process deletes

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

         while ( it.hasNext() )

         {

             o = it.next();

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

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

             soup.removeObject( id.getKey() );

             // remove object from editing context

             aContext.forgetObject( o );

         }

         // process inserts

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

         while ( it.hasNext() )

         {   

             o = it.next();

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

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

             // register object in editing context with new id

             aContext.forgetObject( o );

             aContext.recordObject( o, id );

         }

     }

 }