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 );
        }
        
    }
}