/*

 Wotonomy: OpenStep design patterns for pure Java applications.

 Copyright (C) 2001 Intersect Software Corporation

 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.control;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.ObjectInputStream;

 import java.io.ObjectOutputStream;

 import java.io.ObjectStreamClass;

 import java.io.OutputStream;

 import java.io.Serializable;

 import java.util.Iterator;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Map;

 import net.wotonomy.foundation.NSDictionary;

 import net.wotonomy.foundation.NSMutableDictionary;

 import net.wotonomy.foundation.internal.Duplicator;

 import net.wotonomy.foundation.internal.WotonomyException;

 /**

 * KeyValueCodingUtilities implements what 

 * EOKeyValueCodingSupport leaves out.  Importantly,

 * this class implements the deep clone and deep copy 

 * operations that are essential to the functioning of 

 * nested editing contexts.

 *

 * @author michael@mpowers.net

 * @author $Author: cgruber $

 * @version $Revision: 900 $

 */

 public class KeyValueCodingUtilities

 {

     /**

     * Returns a Map of the specified keys to their values,

     * each of which is obtained by calling valueForKey

     * on the specified object if it implements EOKeyValueCoding,

     * and otherwise falling back on EOKeyValueCodingSupport.

     * Null values must be represented by NSNull.nullValue().

     */

     static public NSDictionary valuesForKeys( 

         Object anObject, List aKeyList )

     {

         return valuesForKeys( anObject, aKeyList, false );

     }

     /**

     * Returns a Map of the specified keys to their values,

     * each of which is obtained by calling storedValueForKey

     * on the specified object if it implements EOKeyValueCoding,

     * and otherwise falling back on EOKeyValueCodingSupport.

     * Null values must be represented by NSNull.nullValue().

     */

     static public NSDictionary storedValuesForKeys( 

         Object anObject, List aKeyList )

     {

         return valuesForKeys( anObject, aKeyList, true );

     }

     /**

     * Called by valuesForKeys and storedValuesForKeys.

     * This uses storedValueForKey if isStored is true,

     * otherwise uses valueForKey.

     */

     static private NSDictionary valuesForKeys( 

         Object anObject, List aKeyList, boolean isStored )

     {

         EOKeyValueCoding coding;

         if ( anObject instanceof EOKeyValueCoding )

         {

             coding = (EOKeyValueCoding) anObject;

         }

         else

         {

             coding = null;   

         }

         String key;

         Object value;

         NSMutableDictionary result = new NSMutableDictionary();

         Iterator it = aKeyList.iterator();

         while ( it.hasNext() )

         {

             //TODO: get rid of this try/catch - exceptions should be fatal (?) 

             try

             {

                 key = it.next().toString();            

                 if ( coding != null )

                 {

                     if ( isStored )

                         value = coding.storedValueForKey( key );

                     else

                         value = coding.valueForKey( key );

                 }

                 else

                 {

                     if ( isStored )

                         value = EOKeyValueCodingSupport.storedValueForKey( anObject, key );

                     else

                         value = EOKeyValueCodingSupport.valueForKey( anObject, key );

                 }

                 if ( value == null )

                 {

                     value = EONullValue.nullValue();   

                 }

                 result.setObjectForKey( value, key );

             }

             catch ( RuntimeException exc )

             {

                 System.out.println( 

                 "KeyValueCodingUtilities.valuesForKeys: " 

                 + isStored + " : " + exc );   

             }

         }

         return result;

     }

     /**

     * Takes the keys from the specified Map as properties

     * and applies the corresponding values, each of which

     * might be set by calling takeValueForKey on the 

     * specified object if it implements EOKeyValueCoding,

     * and otherwise falling back on EOKeyValueCodingSupport.

     * Null values must be represented by NSNull.nullValue().

     */

     static public void takeValuesFromDictionary( 

         Object anObject, Map aMap )

     {

         takeStoredValuesFromDictionary( anObject, aMap, false );

     }

     /**

     * Takes the keys from the specified Map as properties

     * and applies the corresponding values, each of which

     * might be set by calling takeStoredValueForKey on the 

     * specified object if it implements EOKeyValueCoding,

     * and otherwise falling back on EOKeyValueCodingSupport.

     * Null values must be represented by NSNull.nullValue().

     */

     static public void takeStoredValuesFromDictionary( 

         Object anObject, Map aMap )

     {

         takeStoredValuesFromDictionary( anObject, aMap, true );    

     }

     /**

     * Called by takeValuesFromDictionary and takeStoredValuesFromDictionary.

     * This uses takeStoredValueForKey if isStored is true,

     * otherwise uses takeValueForKey.

     */

     static private void takeStoredValuesFromDictionary( 

         Object anObject, Map aMap, boolean isStored )

     {

         EOKeyValueCoding coding;

         if ( anObject instanceof EOKeyValueCoding )

         {

             coding = (EOKeyValueCoding) anObject;

         }

         else

         {

             coding = null;   

         }

         String key;

         Object value;

         NSMutableDictionary result = new NSMutableDictionary();

         Iterator it = aMap.keySet().iterator();

         while ( it.hasNext() )

         {

             //TODO: get rid of this try/catch - exceptions should be fatal (?) 

             try

             {

                 key = it.next().toString();

                 value = aMap.get( key );

                 if ( value instanceof EONullValue ) 

                 // can't use == nullValue() because of cloning/serialization

                 {

                     value = null;   

                 }

                 if ( coding != null )

                 {

                     if ( isStored )

                         coding.takeStoredValueForKey( value, key );

                     else

                         coding.takeValueForKey( value, key );

                 }

                 else

                 {

                     if ( isStored )

                         EOKeyValueCodingSupport.takeStoredValueForKey( 

                             anObject, value, key );

                     else

                         EOKeyValueCodingSupport.takeValueForKey( 

                             anObject, value, key );

                 }

             }

             catch ( WotonomyException exc )

             {

                 System.out.println( 

                     "KeyValueCodingUtilities.takeStoredValuesFromDictionary: " 

                     + isStored + " : " + exc );

             }

         }

     }

     /**

     * Creates a deep clone of the specified object.

     * (Object.clone() only creates a shallow clone.)

     * Returns null if operation fails.

     */ 

     static public Object clone( Object aSource )

     {

         return Duplicator.deepClone( aSource );

     }

     /**

     * Creates a deep clone of the specified object,

     * registered in the specified source editing context,

     * transposing it into the specified destination

     * editing context.

     * Returns null if operation fails.

     */ 

     static public Object clone( 

         EOEditingContext aSourceContext, Object aSource,

         EOEditingContext aDestinationContext )

     {

         return clone( aSourceContext, aSource, aDestinationContext, aSource );    

     }

     /**

     * Called by clone and copy.

     * The specified root object will not be replaced

     * by an object in the destination editing context:

     * this should be the same as the source object for

     * cloning, but should be null for copying.

     * Returns null if operation fails.

     */ 

     static private Object clone( 

         EOEditingContext aSourceContext, Object aSource,

         EOEditingContext aDestinationContext,

         Object aRootObject )

     {

 //System.out.println();

 //System.out.println( "clone: " + aSourceContext );

 //System.out.println( "     : " + aSource );

 //System.out.println( "     : " + aDestinationContext );

 //System.out.println();

         // the only known way to deep copy in

         // java without native code is serialization

         return thaw( 

             freeze( aSource, aSourceContext, aRootObject, true ), 

             aDestinationContext, true );

     }

     /**

     * Serializes an object to a byte array containing

     * GlobalIDMarkers in place of references to other objects 

     * registered in the specified context.

     * The specified root object will be serialized, 

     * even if it is registered in the specified context:

     * this is typically the root object you're trying to

     * serialize.

     * Package access, as this method is used by editing

     * context for snapshots.

     */

     static public byte[] freeze( 

         Object anObject, EOEditingContext aContext, Object aRootObject, boolean transpose )

     {

         try

         {

 //long t = System.currentTimeMillis();            

             ByteArrayOutputStream byteOutput =

                 new ByteArrayOutputStream();// CloneBufferSize );

             ObjectOutputStream objectOutput;

             if ( transpose )

             {

                 objectOutput =

                     new TransposingContextObjectOutputStream( 

                         byteOutput, aContext, aRootObject );

             }

             else

             {

                 objectOutput =

                     new ContextObjectOutputStream( 

                         byteOutput, aContext );

             }

             objectOutput.writeObject( anObject );

             objectOutput.flush();

             objectOutput.close();

             return byteOutput.toByteArray();

 // profiling

 /*

 byte[] result = byteOutput.toByteArray();

 long size = result.length;

 long time = ( System.currentTimeMillis() - t );

 maxSize = Math.max( size, maxSize );

 minSize = Math.min( size, minSize );

 totSize += size;

 maxTime = Math.max( time, maxTime );

 minTime = Math.min( time, minTime );

 totTime += time;

 nTime++;

 System.out.println( "freeze: size = [ " + size + " : " + minSize + " : " + ( (float)totSize / (float)nTime ) + " : " + maxSize 

 + " ]  time = [ " + time + " : " + minTime + " : " + ( (float)totTime / (float)nTime ) + " : " + maxTime + " ]" );

 return result;            

 */

 // end profiling

         } 

         catch ( Exception exc )

         {

             throw new WotonomyException( exc );

         }

     }

 //static long maxTime, minTime, totTime, nTime, maxSize, minSize, totSize;    

 //static long maxTimeThaw, minTimeThaw, totTimeThaw, nTimeThaw;

     /**

     * De-serializes an object from the specified byte

     * array, replacing GlobalIDMarkers with reference

     * to objects registered in the specified editing

     * context.

     * Package access, as this method is used by editing

     * context for snapshots.

     */

     static public Object thaw( 

         byte[] aByteArray, EOEditingContext aContext, boolean transpose )

     {

         return thaw( aByteArray, aContext, null, transpose );

     }

     /**

     * De-serializes an object from the specified byte

     * array, replacing GlobalIDMarkers with reference

     * to objects registered in the specified editing

     * context.

     * Package access, as this method is used by editing

     * context for snapshots.

     */

     static public Object thaw( 

         byte[] aByteArray, EOEditingContext aContext, ClassLoader aLoader, boolean transpose )

     {

         try

         {

 //long t = System.currentTimeMillis();            

             ByteArrayInputStream byteInput =

                 new ByteArrayInputStream( aByteArray );

             ObjectInputStream objectInput;

             if ( transpose )

             {

                 objectInput =

                     new TransposingContextObjectInputStream( 

                         byteInput, aContext, aLoader );

             }

             else

             {

                 objectInput =

                     new ContextObjectInputStream( 

                         byteInput, aContext, aLoader );

             }

             return objectInput.readObject();

 // profiling

 /*

 Object result = objectInput.readObject();

 long timeThaw = ( System.currentTimeMillis() - t );

 maxTimeThaw = Math.max( timeThaw, maxTimeThaw );

 minTimeThaw = Math.min( timeThaw, minTimeThaw );

 totTimeThaw += timeThaw;

 nTimeThaw++;

 System.out.println( "thaw: size = " + aByteArray.length + ", time = [ " + timeThaw + " : " + minTimeThaw + " : " + ( (float)totTimeThaw / (float)nTimeThaw ) + " : " + maxTimeThaw + " ]" );

 return result;

 */

 // end profiling

         } 

         catch ( Exception exc )

         {

             throw new WotonomyException( exc );

         }

     }

     /**

     * Copies values from one object registered in the

     * specified origin context to the specified destination

     * object 

     * The values themselves are cloned, so this is a deep copy.

     * Returns the destination object, or throws exception

     * if operation fails.

     */ 

     static public Object copy( Object aSource, Object aDestination )

     {

         NSDictionary values = (NSDictionary) 

             clone( valuesForKeys( aSource, 

                 EOClassDescription.classDescriptionForClass( 

                     aSource.getClass() ).attributeKeys() ) );

         takeStoredValuesFromDictionary( aDestination, values );        

         return aDestination;

     }

     /**

     * Copies values from one object registered in the

     * specified origin context to the specified destination

     * object 

     * The values themselves are cloned, so this is a deep copy.

     * Returns the destination object, or throws exception

     * if operation fails.

     */ 

     static public Object copy( 

         EOEditingContext aSourceContext, Object aSource, 

         EOEditingContext aDestinationContext, Object aDestination )

     {

         // get all keys for this object

         EOClassDescription classDesc =

             EOClassDescription.classDescriptionForClass( aSource.getClass() );            

         List keys = new LinkedList();

         keys.addAll( classDesc.attributeKeys() ); 

         keys.addAll( classDesc.toOneRelationshipKeys() ); 

         keys.addAll( classDesc.toManyRelationshipKeys() ); 

         // transpose all objects registered in source context

         NSDictionary values = storedValuesForKeys( aSource, keys );

         values = (NSDictionary)

             clone( aSourceContext, values, aDestinationContext, null );

         // apply to destination object

         takeStoredValuesFromDictionary( aDestination, values );        

         return aDestination;

     }

     // inner classes

     /**

     * An ObjectOutputStream that serializes objects with references

     * to an editing context.  The specified context will not be

     * serialized but referenced, so that a ContextObjectInputStream

     * can replace the reference with another editing context.

     */

     static private class ContextObjectOutputStream extends ObjectOutputStream

     {

         private EditingContextMarker marker = new EditingContextMarker();

         protected EOEditingContext editingContext;

         /**

         * Specifies the output stream to wrap,

         * and the source context that should be 

         * referenced but not serialized.

         */

         public ContextObjectOutputStream( 

             OutputStream anOutputStream,

             EOEditingContext aContext )

         throws IOException

         {

             super( anOutputStream );

             editingContext = aContext;

             try

             {

                 enableReplaceObject(true);

             }

             catch ( Exception exc )

             {

                 exc.printStackTrace();   

             }

         }

         protected Object replaceObject(Object anObject) throws IOException

         {

 //            if ( anObject == editingContext ) return marker;

 //FIXME: this should be more strict as above

             if ( anObject instanceof EOEditingContext ) return marker;

             return anObject;

         }

     }

     /**

     * A ContextObjectOutputStream that replaces any objects registered

     * in the source editing context with markers to be used in

     * ContextObjectInputStream.

     */

     static private class TransposingContextObjectOutputStream 

         extends ContextObjectOutputStream

     {

         protected Object rootObject;

         /**

         * Specifies the output stream to wrap,

         * the source context containing objects that

         * should be replaced if found, 

         * and the object which should not be re-registered,

         * which is typically the object being cloned, but

         * may be null.

         */

         public TransposingContextObjectOutputStream( 

             OutputStream anOutputStream,

             EOEditingContext aContext, 

             Object anObject )

         throws IOException

         {

             super( anOutputStream, aContext );

             rootObject = anObject;

         }

         protected Object replaceObject(Object anObject) throws IOException

         {

             if ( anObject == rootObject ) return anObject;

             if ( editingContext != null )

             {

                 EOGlobalID id = editingContext.globalIDForObject( anObject );

                 if ( id != null ) 

                 {

                     Object result = new GlobalIDMarker( id );

     //System.out.println( "KeyValueCodingUtilities.replaceObject: returning: " + result );

                     return result;

                 }

             }

             return super.replaceObject( anObject );

         }

     }

     /**

     * A marker class so references to objects registered in editing 

     * contexts get transposed rather than cloned.

     */

     static private class GlobalIDMarker implements Serializable

     {

         private EOGlobalID id;

         public GlobalIDMarker( EOGlobalID anID )

         {

             id = anID;   

         }

         public EOGlobalID getID() 

         {

             return id;   

         }

         public String toString()

         {

             return "[GlobalIDMarker:"+id+"]";   

         }

     }

     /**

     * A marker class so references an object's editing context

     * gets transposed rather than cloned.

     */

     static private class EditingContextMarker implements Serializable

     {

         // just a marker class - no implementation necessary

     }

     /**

     * An ObjectInputStream that replaces any markers from

     * ContextObjectOutputStream with objects registered

     * in the destination editing context.

     */

     static private class ContextObjectInputStream extends ObjectInputStream

     {

         protected EOEditingContext editingContext;

         protected ClassLoader classLoader;

         /**

         * Specifies the output stream to wrap,

         * the source context containing objects that

         * should be to replace any markers.

         * The class loader may be null.

         */

         public ContextObjectInputStream( 

             InputStream anInputStream,

             EOEditingContext aContext,

             ClassLoader aClassLoader )

         throws IOException

         {

             super( anInputStream );

             editingContext = aContext;

             classLoader = aClassLoader;

             if ( classLoader == null )

             {

                 classLoader = 

                     KeyValueCodingUtilities.class.getClassLoader();

             }

             try

             {

                 enableResolveObject(true);

             }

             catch ( Exception exc )

             {

                 exc.printStackTrace();   

             }

         }

         protected Object resolveObject(Object anObject) throws IOException

         {

             if ( anObject instanceof EditingContextMarker )

             {

                 return editingContext;

             }

             return anObject;

         }

         protected Class resolveClass(ObjectStreamClass v)

              throws IOException, ClassNotFoundException 

         {

             return classLoader.loadClass( v.getName() );

         }

     }

     /**

     * A ContextObjectInputStream that replaces any markers from

     * TransposingContextObjectOutputStream with objects registered

     * in the destination editing context.

     */

     static private class TransposingContextObjectInputStream 

         extends ContextObjectInputStream

     {

         /**

         * Specifies the output stream to wrap,

         * the source context containing objects that

         * should be to replace any markers.

         */

         public TransposingContextObjectInputStream( 

             InputStream anInputStream,

             EOEditingContext aContext,

             ClassLoader aClassLoader )

         throws IOException

         {

             super( anInputStream, aContext, aClassLoader );

         }

         protected Object resolveObject(Object anObject) throws IOException

         {

             if ( anObject instanceof GlobalIDMarker )

             {

                 return editingContext.faultForGlobalID( 

                     ((GlobalIDMarker)anObject).getID(), editingContext );

             }

             return super.resolveObject( anObject );

         }

     }

 }

 /*

  * $Log$

  * Revision 1.3  2006/02/18 22:46:44  cgruber

  * Add Surrogate map from .util into control's internal package, and fix imports.

  *

  * Revision 1.2  2006/02/16 16:47:14  cgruber

  * Move some classes in to "internal" packages and re-work imports, etc.

  *

  * Also use UnsupportedOperationExceptions where appropriate, instead of WotonomyExceptions.

  *

  * Revision 1.1  2006/02/16 13:19:57  cgruber

  * Check in all sources in eclipse-friendly maven-enabled packages.

  *

  * Revision 1.15  2003/01/21 22:30:10  mpowers

  * thaw() now allows you to pass in a class loader.

  *

  * Revision 1.14  2002/05/15 13:46:35  mpowers

  * Exposed freeze and thaw as public.

  *

  * Revision 1.13  2001/08/22 19:25:13  mpowers

  * Added (and commented out) profiling code for freeze.

  *

  * Revision 1.12  2001/05/06 18:27:10  mpowers

  * More broadly catching editing contexts for now.

  *

  * Revision 1.11  2001/05/05 13:18:49  mpowers

  * Fixed: transposing output stream was not returning the object to replace.

  *

  * Revision 1.10  2001/05/04 16:57:56  mpowers

  * Now correctly transposing references to editing contexts when

  * cloning/copying between editing contexts.

  *

  * Revision 1.9  2001/05/04 14:42:58  mpowers

  * Now getting stored values in KeyValueCoding.

  * MasterDetail now marks dirty based on whether it's an attribute

  * or relation.

  * Implemented editing context marker.

  *

  * Revision 1.8  2001/05/02 15:47:40  mpowers

  * Fixed the pernicious problem with reverts: recordObject was recording

  * a snapshot of the clone before the transposition-copy happened,

  * so the revert object would lose all of its transposed relationships.

  *

  * Revision 1.7  2001/04/30 12:33:17  mpowers

  * Fixed problem with use of EONullValue.nullValue(), which can't be used

  * when we're serializably duplicating objects.

  *

  * Revision 1.6  2001/04/30 02:14:25  mpowers

  * Copying should call takeStoredValueForKeys.

  *

  * Revision 1.5  2001/04/29 22:02:45  mpowers

  * Work on id transposing between editing contexts.

  *

  * Revision 1.4  2001/04/29 02:29:31  mpowers

  * Debugging relationship faulting.

  *

  * Revision 1.3  2001/04/28 16:18:44  mpowers

  * Implementing relationships.

  *

  * Revision 1.2  2001/04/28 14:12:23  mpowers

  * Refactored cloning/copying into KeyValueCodingUtilities.

  *

  * Revision 1.1  2001/04/27 23:41:12  mpowers

  * Contributing file for KeyValueCodingUtilities.

  *

  *

  */