package net.wotonomy.control;

import java.util.Collection;
import java.util.Iterator;

import net.wotonomy.foundation.NSArray;
import net.wotonomy.foundation.NSMutableArray;

/**
* A data source that automates the process of 
* creating a child editing context and copying
* objects from a parent context into it. 
* Attach this data source to a display group
* that represents a "detail" or "drill-down" 
* view. <br><br>
* 
* Once created, editingContext() will return the 
* child context, and fetch() will return the objects 
* that were copied into the child context.
*/
public class ChildDataSource extends EODataSource
{
    private EODataSource parent;
    private EOEditingContext context;
    private EOClassDescription classDescription;
    private NSMutableArray objects;
    
    /**
    * Creates a child editing context for the
    * specified parent's context and copies the 
    * specified object into the child context.
    * The object must exist in the parent context.
    * fetch() will return the child's object.
    */
	public ChildDataSource( 
        EODataSource aParentSource,
        Object anObject )
	{
        this( aParentSource, new NSArray( (Object) anObject ) );
	}
    
    /**
    * Creates a child editing context for the
    * specified parent's context and copies the 
    * specified objects into the child context.
    * The objects must exist in the parent context.
    * The order of the parent's objects in the
    * collection will determine the order in 
    * which the child objects are returned from 
    * fetch().
    */
	public ChildDataSource( 
        EODataSource aParentSource,
        Collection anObjectList )
	{
        EOEditingContext parentContext = 
            aParentSource.editingContext();

        parent = aParentSource;
        context = new EOEditingContext( parentContext );
//!new net.wotonomy.ui.swing.util.ObjectInspector( context );        
        objects = new NSMutableArray();
        classDescription = null;

        Object o;        
        Object copy;
        boolean allSameClass = true;
        Iterator it = anObjectList.iterator();
        while ( it.hasNext() )
        {
            o = it.next();
            
            // determine class
            if ( allSameClass == true )
            {
                Class c = o.getClass();
                if ( classDescription == null ) 
                {
                    classDescription = 
                        EOClassDescription.classDescriptionForClass( c );   
                }
                else
                {
                    if ( c != classDescription.getDescribedClass() )
                    {
                        allSameClass = false;  
                        classDescription = null;
                    }
                }
            }
            
            // copy and add to list
            objects.addObject( parentContext.faultForGlobalID(
                parentContext.globalIDForObject( o ), context ) );
        }
	}
    
    /**
    * Returns the editing context for this data source,
    * which was created in the constructor and whose 
    * parent is the editing context specified in the
    * constructor.
    */
    public EOEditingContext editingContext()
    {
        return context;
    }
	
    /**
    * This implementation does nothing.
    */
    public void insertObject ( Object anObject )
	{

	}

    /**
    * This implementation does nothing.
    */
    public void deleteObject ( Object anObject )
	{

	}

    /**
    * Returns a List containing the objects in this
    * data source.  This implementation returns all
	* TestObjects that have been persisted to the 
	* datastore in the data directory.
    */
    public NSArray fetchObjects ()
    {
        return new NSArray( (Collection) objects );
    }

    /**
    * Returns a data source that is capable of
    * manipulating objects of the type returned by 
    * applying the specified key to objects 
    * vended by this data source.
    * This implementation forwards the call to
    * the parent data source.
    * @see #qualifyWithRelationshipKey
    */
    public EODataSource 
        dataSourceQualifiedByKey ( String aKey )
	{
        //FIXME: This is fundamentally broken.
        // Objects vended from the returned source
        // are not registered in our editing context.
        // We probably need yet another utility data
        // source class that would wrap another source
        // and convert vended objects into a different
        // context.
        
        return parent.dataSourceQualifiedByKey( aKey );
	}

    /**
    * Restricts this data source to vend those 
    * objects that are associated with the specified 
    * key on the specified object.
    * This implementation forwards the call to
    * the parent data source.
    */
    public void 
        qualifyWithRelationshipKey ( 
        String aKey, Object anObject )
	{
		parent.qualifyWithRelationshipKey( aKey, anObject );	
	}

    /**
    * Returns the description of the class of the
    * objects that is vended by this data source,
    * or null if this cannot be determined.
	* This implementation returns the class of the
    * objects passed to the constructor if they are
    * all the same class, otherwise returns null.
    */
    public EOClassDescription
        classDescriptionForObjects ()
    {
        return classDescription;
    }

}