/*
   Wotonomy: OpenStep design patterns for pure Java applications.
   Copyright (C) 2000 Michael Powers
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, see http://www.gnu.org
  */
  
  package net.wotonomy.datastore;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Observable;
  
  public class DefaultDataView extends Observable 
  	implements DataView
  {
      protected DataSoup backingSoup;
      protected List objectList;
      protected List keyList;
      protected List addedObjectList;
      protected List removedObjectList;
      protected List addedKeyList;
      protected List removedKeyList;
      protected Collection updatedObjects;
      protected boolean fullyLoaded;
      
  	DefaultDataView( DataSoup aSoup, Collection aKeyList )
  	{
  		backingSoup = aSoup;
  		objectList = new ArrayList();
  		keyList = new ArrayList();
  		addedObjectList = new ArrayList();
  		removedObjectList = new ArrayList();
  		addedKeyList = new ArrayList();
  		removedKeyList = new ArrayList();
  		updatedObjects = new LinkedList();
  		fullyLoaded = false;
  
  		setKeyList( aKeyList );
  	}
  	
  	void setKeyList( Collection aCollection )
  	{
  		fullyLoaded = false;
  		addedObjectList.clear();
  		removedObjectList.clear();
  		addedKeyList.clear();
  		removedKeyList.clear();
  		updatedObjects.clear();
  		keyList.clear();
  		objectList.clear();
  		if ( ( aCollection == null ) || ( aCollection.size() == 0 ) )
  		{
  			return;
  		}
  		keyList.addAll( aCollection );
  		for ( int i = 0; i < keyList.size(); i++ )
  		{
  			objectList.add( null );
  		}
  	}
  
  	public Object get( int i )
  	{
  		if ( i > keyList.size() ) return null;
  
  		Object o = objectList.get( i );
  		if ( o == null )
  		{
  			Object key = keyList.get( i );
  			if ( key == null ) return null; // FIXME!!
  
              //NOTE: this is the gateway for getting object from the soup
  			o = backingSoup.getObjectByKey( (DataKey) key );
  
  			objectList.set( i, o );
  		}
  		return o;
  	}
  
      public int indexOf( Object o )
      {
          if ( o == null ) return -1;
          for ( int i = 0; i < size(); i++ )
         {
             if ( o.equals( get( i ) ) )
             {
                 return i;
             }
         }
         return -1;
     }
 
     private int indexOfIdenticalObject( Object o )
     {
         if ( o == null ) return -1;
         for ( int i = 0; i < size(); i++ )
         {
             if ( o == get( i ) )
             {
                 return i;
             }
         }
         return -1;
     }
 
     public int lastIndexOf( Object o )
     {
         if ( o == null ) return -1;
         int lastIndex = -1;
         for ( int i = 0; i < size(); i++ )
         {
             if ( o.equals( get( i ) ) )
             {
                 lastIndex = i;
             }
         }
         return lastIndex;
     }
 
 	protected void loadAllObjects()
 	{
 		if ( fullyLoaded ) return;
 		for ( int i = 0; i < keyList.size(); i++ )
 		{
 			get( i );
 		}
 		fullyLoaded = true;
 	}
 	
     // convenience to return the first object, or null.
     public Object getObject()
     {
     	return get( 0 );
 	} 
 	
 	// marked object as updated
 	public void update( Object anObject )
 	{		
 		if ( contains( anObject ) )
 		{
 			if ( ! addedObjectList.contains( anObject ) )
 			{
 				updatedObjects.add( anObject );
         	}
 		}
 
         // notification
         setChanged();
         notifyObservers( anObject );
 	}
 
     // DefaultDataViews know their parent soup to perform the query
 	//	and take the subset
     public DataView query(
     	String aProperty, Object beginKey, Object endKey ) { return this; }
 
 	public boolean commit()
 	{
         int index;
         Object o;
         DataKey key;
 		for ( int i = 0; i < addedObjectList.size(); i++ )
 		{
             o = addedObjectList.get(i);
 			key = backingSoup.addObject( o );
             index = indexOfIdenticalObject( o );
             keyList.set( index, key );
 		}
 		addedObjectList.clear();
 		addedKeyList.clear();
 		for ( int i = 0; i < removedObjectList.size(); i++ )
 		{
     		backingSoup.removeObject( (DataKey) removedKeyList.get(i) );
 		}
 		removedObjectList.clear();
 		removedKeyList.clear();
 
 		int i;
 		Iterator it = updatedObjects.iterator();
 		while ( it.hasNext() )
 		{
 			i = objectList.indexOf( it.next() );
 			backingSoup.updateObject(
 				(DataKey) keyList.get(i), objectList.get(i) );
 		}
 		updatedObjects.clear();
 
         // notification
         setChanged();
         notifyObservers( this );
 
 		return true;
 	}
 
     public DataKey getKeyForObject( Object anObject )
     {
         int index = indexOfIdenticalObject( anObject );
         if ( index == -1 ) return null;
         return (DataKey) keyList.get( index );
     }
 
     public Object getObjectForKey( DataKey aKey )
     {
         int index = keyList.indexOf( aKey );
         if ( index == -1 ) return null;
         return get( index );
     }
 
 	// interface Collection
 
     public int size () { return keyList.size(); }
     public boolean isEmpty () { return keyList.isEmpty(); }
     public void clear () { setKeyList( null ); };
     public int hashCode() { return keyList.hashCode(); };
 
     public boolean equals (Object o)
     {
     	if ( ! ( o instanceof DefaultDataView ) ) return false;
 	    return keyList.equals( ((DefaultDataView)o).keyList );
 	}
 
     public boolean contains (Object o)
 	{
 		loadAllObjects();
 		return objectList.contains(o);
 	}
 
     public boolean containsAll (Collection c)
     {
     	loadAllObjects();
 	    return objectList.containsAll( c );
     }
 
     public boolean add (Object o)
     {
     	// if previously removed, restore to list
     	if ( removedObjectList.contains( o ) )
 	    {
 	    	int index = removedObjectList.indexOf( o );
 		    removedObjectList.remove( index );
 		    Object key = removedKeyList.remove( index );
 		    objectList.add( o );
 		    keyList.add( key );
 
             // notification
             setChanged();
             notifyObservers( o );
 		    return true;
 	    }
 
 	    // register and add to lists
 	    Object key = backingSoup.registerTemporaryObject( o );
 	    addedObjectList.add( o );
 	    addedKeyList.add( key );
 	    objectList.add( o );
 	    keyList.add( key );
 
         // notification
         setChanged();
         notifyObservers( o );
 	    return true;
     }
 
     public Object remove( int index )
     {
         Object result = get( index );
         if ( remove( result ) )
         {
             return result;
         }
         return null;
     }
 
     public boolean remove (Object o)
     {
     	loadAllObjects();
 
 	    int index = objectList.indexOf( o );
 	    if ( index == -1 ) return false;
 
 	    objectList.remove( index );
 	    Object key = keyList.remove( index );
 
 	    if ( updatedObjects.contains( o ) )
 	    {
 	    	updatedObjects.remove( o );
 	    }
 
     	// if not previously added, track removal
 	    if ( ! ( removedObjectList.contains( o ) ) )
 	    {
 	    	removedObjectList.add( o );
 		    removedKeyList.add( key );
 	    }
 
         // notification
         setChanged();
         notifyObservers( o );
 
 	    return true;
     }
 
     /***
     * Set completely replaces the object at the specified
     * index with the specified object.  The new object is not
     * marked as inserted, and the old object is not marked
     * as deleted: the new object will be stored in the soup
     * with the same key.  The old object is returned.
     */ 
     public Object set( int index, Object element )
     {
         Object result = objectList.set( index, element );
         update( element );
         return result;
     }
 
     public void add( int index, Object o )
     {
     	// if previously removed, restore to list
     	if ( removedObjectList.contains( o ) )
 	    {
 	    	int i = removedObjectList.indexOf( o );
 		    removedObjectList.remove( i );
 		    Object key = removedKeyList.remove( i );
 		    objectList.add( index, o );
 		    keyList.add( index, key );
 
             // notification
             setChanged();
             notifyObservers( o );
 		    return;
 	    }
 
 	    // register and add to lists
 	    Object key = backingSoup.registerTemporaryObject( o );
 	    addedObjectList.add( o );
 	    addedKeyList.add( key );
 	    objectList.add( index, o );
 	    keyList.add( index, key );
 
         // notification
         setChanged();
         notifyObservers( o );
     }
 
     public boolean addAll (Collection c)
     {
     	boolean result = true;
     	Iterator it = c.iterator();
 	    while ( it.hasNext() )
 	    {
 	    	result = result && add( it.next() );
 	    }
 	    return result;
     }
 
     public boolean addAll (int index, Collection c)
     {
         int originalSize = size();
     	boolean result = true;
     	Iterator it = c.iterator();
 	    while ( it.hasNext() )
 	    {
 	    	add( index, it.next() );
 	    }
 	    return ( originalSize + c.size() == size() );
     }
 
     public boolean removeAll (Collection c)
     {
     	boolean result = true;
     	Iterator it = c.iterator();
 	    while ( it.hasNext() )
 	    {
 	    	result = result && remove( it.next() );
 	    }
 	    return result;
     }
 
     public boolean retainAll (Collection c)
     {
     	removeAll( new ArrayList( objectList ) );
 	    return addAll( c );
 	}
 
     public List subList( int fromIndex, int toIndex )
     {
         List result = new LinkedList();
         for ( int i = fromIndex; i < toIndex; i++ )
         {
             result.add( get( i ) );
         }
         return result;
     }
 
     public Iterator iterator()
     {
     	loadAllObjects();
 	    return objectList.iterator();
 
 /*	// uncomment to enable on-demand loading
 		return new Iterator()
         {
 			int index = 0;
             public boolean hasNext() { return ( index + 1 < keyList.size() ); }
             public Object next() {
 	    		return get( index++ ); }
             public void remove()
             {
                 Object o = get( index );
             	if ( o != null ) DefaultDataView.this.remove( o );
             }
         };
 */
     }
 
     public ListIterator listIterator()
     {
         return new DataViewIterator( this );
     }
 
     public ListIterator listIterator( int index )
     {
         return new DataViewIterator( this, index );
     }
 
     public Object[] toArray ()
     {
     	loadAllObjects();
 	    return objectList.toArray();
     }
     public java.lang.Object[] toArray (Object[] array)
     {
     	loadAllObjects();
 	    return objectList.toArray( array );
     }
 
     protected class DataViewIterator implements ListIterator
     {
         DataView theView;
         int currentIndex;
 
         //TODO: should track current object in addition to index
         // to track external changes to the view. (or should be listener)
         Object currentObject;
 
         public DataViewIterator( DataView aView )
         {
             this( aView, 0 );
         }
 
         public DataViewIterator( DataView aView, int index )
         {
             theView = aView;
             if ( theView.size() > index )
             {
                 currentIndex = index;
                 currentObject = theView.get( currentIndex );
             }
             else
             {
                 index = -1;
                 currentObject = null;
             }
         }
 
         public void add( Object o )
         {
             currentIndex++;
             theView.add( currentIndex, o );
         }
 
         public boolean hasNext()
         {
             return ( theView.size() > currentIndex + 1 );
         }
 
         public boolean hasPrevious()
         {
             return ( currentIndex > -1 );
         }
 
         public Object next()
         {
             return theView.get( ++currentIndex );
         }
 
         public int nextIndex()
         {
             return currentIndex + 1;
         }
 
         public Object previous()
         {
             return theView.get( currentIndex-- );
         }
 
         public int previousIndex()
         {
             return currentIndex;
         }
 
         public void remove()
         {
             theView.remove( currentIndex-- );
         }
 
         public void set( Object o )
         {
             theView.set( currentIndex, o );
         }
 
     }
 }
 
 /*
  * $Log$
  * Revision 1.2  2006/02/19 16:26:19  cgruber
  * Move non-unit-test code to tests project
  * Fix up code to work with proper imports
  * Fix maven dependencies.
  *
  * Revision 1.1  2006/02/16 13:18:56  cgruber
  * Check in all sources in eclipse-friendly maven-enabled packages.
  *
  * Revision 1.2  2001/02/15 21:12:41  mpowers
  * Added accessors for key throughout the api.  This breaks compatibility.
  * insertObject now returns the permanent key for the newly created object.
  * The old way returned a copy of the object which was an additional read
  * that was often ignored.  Now you can read it only if you need it.
  * Furthermore, there was not other way of getting the permanent key.
  *
  * Revision 1.1.1.1  2000/12/21 15:47:14  mpowers
  * Contributing wotonomy.
  *
  * Revision 1.2  2000/12/20 16:25:36  michael
  * Added log to all files.
  *
  *
  */