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