/*

 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.io.File;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Map;

 import net.wotonomy.foundation.internal.Introspector;

 abstract public class FileSoup implements DataSoup

 {

     public static final String INDEX_SUFFIX = ".idx";

     public static final String MAP_SUFFIX = ".map";

     private static final String ID_ID = "id";

     private static final String IDENTITY_PROPERTY = "__SELF__";

     protected DataKey nextUniqueIdentifier;

     protected File homeDirectory;

     protected Map indices;

     public FileSoup( String aPath )

     {

             homeDirectory = new File( aPath );

         // if specified directory does not exist

         if ( ! homeDirectory.exists() )

         {

             homeDirectory.mkdirs();

         }

         // if existing path is a file, exit with error

         if ( homeDirectory.isDirectory() )

         {

             new RuntimeException( "DataStore: Specified directory is a file." );

         }

         // read indices

         DataIndex index;

         indices = new HashMap();

             String[] files = getHomeDirectory().list();

         for ( int i = 0; i < files.length; i++ )

         {

             if ( files[i].endsWith( INDEX_SUFFIX ) )

             {

                 index = (DataIndex) readFile( files[i] );

                 if ( index != null )

                 {        

                     indices.put( index.getName(), index );

                 }

             }

         }

         // read unique identifier

         nextUniqueIdentifier = (DataKey) readFile( ID_ID );

         if ( nextUniqueIdentifier == null )

             nextUniqueIdentifier = new DataKey( "1" );

     }

     public File getHomeDirectory()

     {

             return homeDirectory;

     }

     // index management

     public void addIndex( String aName, String aProperty ) 

     {

             DataIndex index = new DefaultDataIndex( aName, aProperty );

             indices.put( index.getName(), index );

                 buildIndex( index );

                 writeIndices();

     }

     public void removeIndex( String aName ) 

     {

             indices.remove( aName );

                 writeIndices();

     }

     public Collection getAllIndices() 

     {

             return indices.values();

     }

 //    public void addIndex( String aName, Index anIndex ) {}

 //    public void removeIndex( String aName ) {}

 //    public void addTaggedObject( String aKey, Serializable anObject )

 //    public Object getTaggedObject( String aKey );

 //    public void removeTaggedObject( String aKey );

 //    public void setMetaData( 

 //        String aMetaProperty, Serializable aValue, Serializable anObject );

     protected void buildIndex( DataIndex anIndex )

     {

 //System.out.print( "FileSoup.buildIndex: " + anIndex.getName() + " : " );

 long millis = System.currentTimeMillis();

         anIndex.clear();

         int count = 0;

                 DataKey key;

         Object o;

         Object value;

                 String property = anIndex.getProperty();

         String[] files = getHomeDirectory().list();

         for ( int i = 0; i < files.length; i++ )

         {

             if ( ( ! files[i].equals( ID_ID.toString() ) 

                         && ( ! files[i].endsWith( INDEX_SUFFIX ) ) ) )

             {

                             key = new DataKey( files[i] );

                 o = getObjectByKey( key );

                 value = getValueFromObject( o, property );

                 anIndex.addObject( key, value );

                 count++;

             }

         }

 //System.out.print( count + " objects: " );

 //System.out.println( System.currentTimeMillis() - millis + " milliseconds" );

     }    

     protected void writeIndices()

     {

             DataIndex index;

             Iterator it = getAllIndices().iterator();

         while ( it.hasNext() )

         {

             index = (DataIndex) it.next();

             writeFile( index.getName() + INDEX_SUFFIX, index );

         }

     }

         // object management

         // this implementation currently uses up a valid key increment

         public DataKey registerTemporaryObject( Object anObject )

         {

                 DataKey id = getNextKey();

                 if ( anObject instanceof UniquelyIdentifiable )

                 {

             ((UniquelyIdentifiable)anObject).setUniqueIdentifier( id );

                 }

                 return id;

         }

     /**

     * Adds the specified object to the soup and returns the key

     * for the new object by which it may be subsequently retrieved.

     * Null indicates an error, probably due to serialization.

     */

     public DataKey addObject( Object anObject ) 

     {

             DataKey id = getNextKey();

         if ( anObject instanceof UniquelyIdentifiable )

         { // set id if necessary

             ((UniquelyIdentifiable)anObject).setUniqueIdentifier( id );

         }

         writeFile( id.toString(), anObject );

                 // update indices        

                 DataIndex index;

                 Iterator it = indices.values().iterator();

                 while ( it.hasNext() )

                 {

                         index = (DataIndex)it.next();

                         index.addObject( id, 

                                 getValueFromObject( anObject, index.getProperty() ) ); 

                 }

                 writeIndices();

                 return id;

     }

     /**

     * Removes the specified object from the soup and returns

     * the removed object as read from the soup (which is the

     * original copy of the object).  Null indicates object not found.

     */

     public Object removeObject( DataKey aKey )

     {

         Object existing = getObjectByKey( aKey );

         if ( existing != null )

         {        

             if ( ! deleteFile( aKey.toString() ) )

             {

                 existing = null; // return error

             }

                         else

                         {

                 // update indices        

                 DataIndex index;

                 Iterator it = indices.values().iterator();

                 while ( it.hasNext() )

                 {

                     index = (DataIndex)it.next();

                     index.removeObject( aKey,

                         getValueFromObject( existing, index.getProperty() ) );

                 }

                 writeIndices();

                         }

         }

         return existing;

     }

     /**

     * Updates the specified object and returns the object

     * as updated.  Null indicates an error writing the object.

     */

     public Object updateObject( DataKey aKey, Object updatedObject ) 

     {

         Object existing = getObjectByKey( aKey );

         if ( existing == null )

         {

             System.err.println( "FileSoup.updateObject: " +

                 "existing object could not be found with id: " + aKey );

                     return null;

         }

             Object result = null;

         if ( updatedObject instanceof UniquelyIdentifiable )

         {

                         // update key if changed

                         ((UniquelyIdentifiable)updatedObject).setUniqueIdentifier( aKey );

         }

         if ( writeFile( aKey.toString(), updatedObject ) )

         {

             result = updatedObject;

             // update indices        

             DataIndex index;

             Iterator it = indices.values().iterator();

             while ( it.hasNext() )

             {

                 index = (DataIndex)it.next();

                 index.updateObject( aKey,

                     getValueFromObject( existing, index.getProperty() ),

                     getValueFromObject( updatedObject, index.getProperty() ) );

             }

             writeIndices();

         }

 //System.out.println( "FileSoup.updateObject: " + updatedObject + " -> " + result );

             return getObjectByKey( aKey );        

     }

     protected DataKey getNextKey()

     {

                 DataKey id = (DataKey) nextUniqueIdentifier.clone();

         // while ( id isn't yet in use by the soup ) increment();

                 nextUniqueIdentifier.increment();

         writeFile( ID_ID.toString(), nextUniqueIdentifier );

             return id;

     }

     protected DataKey getNextTempKey()

     {

             return getNextKey();

     }

     /**

     * Gets object from data store whose identifier is equal

     * to the specified object.

     */

     public Object getObjectByKey( DataKey aKey )

     {

         return readFile( aKey.toString() );

     }

     // queries

         /**

         * Returns an empty data view, suitable for creating

         * new entries in the soup.

         * @return A DataView containing no entries.

         */

         public DataView createView()

         {

                 return new DefaultDataView( this, new LinkedList() );

         }

     /**

     * Queries by the specified pre-generated index, if it exists.

     * Otherwise, falls through to queryByProperty.

     */

     public DataView queryByIndex( 

             String anIndexName, Object beginKey, Object endKey ) 

     {

             DataIndex index = (DataIndex) indices.get( anIndexName );

         if ( index == null )

         {

             return queryByProperty( anIndexName, beginKey, endKey );

         }

         return queryByKeys( index.query( beginKey, endKey ) );

     }

     /**

     * Generates an index based on the specified property

     * and then executes the query.

     */

     public DataView queryByProperty( 

             String aPropertyName, Object beginKey, Object endKey ) 

     {

             if ( aPropertyName == null ) aPropertyName = IDENTITY_PROPERTY;

             DataIndex index = new DefaultDataIndex( "temporary", aPropertyName );

         buildIndex( index );

         return queryByKeys( index.query( beginKey, endKey ) );

     }

     /**

     * Generates an index based on the specified property

     * and then executes the query.

     */

     public DataView queryObjects( Object beginKey, Object endKey ) 

     {

             return queryByProperty( IDENTITY_PROPERTY, beginKey, endKey );

     }

     /**

     * Returns a view containing the objects for the specified keys.

     */

     public DataView queryByKeys( Collection aKeyList ) 

     {

         return new DefaultDataView( this, aKeyList );

     }

     /**

     * As queryByIndex, but with objects returned in reverse order.

     * @param anIndexName The index to be queried.

     * @param beginValue The beginning value, or null for all values

     * up to an including the end key.

     * @param endValue The ending value, or null for all values

     * since and including the begin key.

     * @return A DataView containing the query results, or null 

     * for invalid query parameters.

     */

     public DataView reverseQueryByIndex( 

             String anIndexName, Object beginKey, Object endKey )

         {

             DataIndex index = (DataIndex) indices.get( anIndexName );

         if ( index == null )

         {

             return reverseQueryByProperty( anIndexName, beginKey, endKey );

         }

                 List items = index.query( endKey, beginKey );

                 Collections.reverse( items );

         return queryByKeys( items );

         }

     /**

     * As queryByProperty, but with objects returned in reverse order.

     * @param aPropertyName The property to be queried.  If null,

     * will query the objects directly with queryObjects().

     * @param beginValue The beginning value, or null for all values

     * up to an including the end key.

     * @param endValue The ending value, or null for all values

     * since and including the begin key.

     * @return A DataView containing the query results, or null 

     * for invalid query parameters.

     */

     public DataView reverseQueryByProperty( 

             String aPropertyName, Object beginKey, Object endKey )

         {

             if ( aPropertyName == null ) aPropertyName = IDENTITY_PROPERTY;

             DataIndex index = new DefaultDataIndex( "temporary", aPropertyName );

         buildIndex( index );

                 List items = index.query( endKey, beginKey );

                 Collections.reverse( items );

         return queryByKeys( items );

         }

     /**

     * As queryObjects, but with objects returned in reverse order.

     * @param beginValue The beginning value, or null for all values

     * up to an including the end key.

     * @param endValue The ending value, or null for all values

     * since and including the begin key.

     * @return A DataView containing the query results, or null 

     * for invalid query parameters.

     */

     public DataView reverseQueryObjects( Object beginKey, Object endKey )

     {

             return queryByProperty( IDENTITY_PROPERTY, beginKey, endKey );

     }

     public Object getValueFromObject( Object anObject, String aProperty )

     {

             if ( IDENTITY_PROPERTY.equals( aProperty ) ) return anObject;

                 return Introspector.getValueForObject( anObject, aProperty );

         }

     // file access methods    

     abstract protected boolean writeFile( String name, Object anObject );

     abstract protected Object readFile( String name );

     abstract protected boolean deleteFile( String name );

 }

 /*

  * $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.4  2003/08/14 19:29:38  chochos

  * minor cleanup (imports, static method calls, etc)

  *

  * Revision 1.3  2001/03/05 22:12:11  mpowers

  * Created the control package for a datastore-specific implementation

  * of EOObjectStore.

  *

  * 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:20  mpowers

  * Contributing wotonomy.

  *

  * Revision 1.3  2000/12/20 16:25:36  michael

  * Added log to all files.

  *

  *

  */