/*
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.foundation.internal;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

/**
* A utility class to convert objects to a desired class.
*
* @author michael@mpowers.net
* @author $Author: cgruber $
* @version $Revision: 893 $
*/
public class ValueConverter
{
    /**
    * Returns the specified object as converted to an instance of the 
    * specified class, or null if the conversion could not be performed.
    */
    static public Object convertObjectToClass( Object anObject, Class aClass )
    { 
    	if ( aClass == String.class )
        {
            return getString( anObject );
        }
    	if ( aClass == Short.class )
        {
            return getShort( anObject );
        }
    	if ( aClass == short.class )
        {
            return getShort( anObject );
        }
    	if ( aClass == Integer.class )
        {
            return getInteger( anObject );
        }
    	if ( aClass == int.class )
        {
            return getInteger( anObject );
        }
    	if ( aClass == Long.class )
        {
            return getLong( anObject );
        }
    	if ( aClass == long.class )
        {
            return getLong( anObject );
        }
    	if ( aClass == Float.class )
        {
            return getFloat( anObject );
        }
    	if ( aClass == float.class )
        {
            return getFloat( anObject );
        }
    	if ( aClass == Double.class )
        {
            return getDouble( anObject );
        }
    	if ( aClass == double.class )
        {
            return getDouble( anObject );
        }
    	if ( aClass == java.util.Date.class )
        {
            return getDate( anObject );
        }
    	if ( aClass == Boolean.class )
        {
            return getBoolean( anObject );
        }
    	if ( aClass == boolean.class )
        {
            return getBoolean( anObject );
        }
    	if ( aClass == Character.class )
        {
            return getCharacter( anObject );
        }
    	if ( aClass == char.class )
        {
            return getCharacter( anObject );
        }
    	if ( aClass == Byte.class )
        {
            return getByte( anObject );
        }
    	if ( aClass == byte.class )
        {
            return getByte( anObject );
        }
    	if ( Collection.class.isAssignableFrom( aClass ) )
        {
            return getCollection( anObject, aClass );
        }
    	if ( aClass.isArray() )
        {
            return getArray( anObject, aClass );
        }

        return convert( anObject, aClass );
    }
    
    /**
    * Called by convertObjectToClass() when we need to 
    * convert to an unrecognized type.
    * This implementation scans the constructors of the 
    * specified class for the best fit to the object.
    * and returns a new instance with that constructor.
    * Subclasses can override to directly support specific
    * types.
    */
    static protected Object convert( Object anObject, Class aClass )
    {
        Constructor[] ctors = aClass.getConstructors();
        
        Class[] types;
        for ( int i = 0; i < ctors.length; i++ )
        {
            types = ctors[i].getParameterTypes();
            if ( types.length == 1 )
            {
                if ( types[0].equals( anObject.getClass() ) )
                {
                    try
                    {
                        return ctors[i].newInstance( new Object[] { anObject } );
                    }
                    catch ( Exception exc )
                    {
                        // fall through
                    }
                }
            }
        }
        
        for ( int i = 0; i < ctors.length; i++ )
        {
            types = ctors[i].getParameterTypes();
            if ( types.length == 1 )
            {
                if ( anObject.getClass().isAssignableFrom( types[0] ) )
                {
                    try
                    {
                        return ctors[i].newInstance( new Object[] { anObject } );
                    }
                    catch ( Exception exc )
                    {
                        // fall through
                    }
                }
            }
        }
        
        return null;
    }
        
    /**
    * Tries to convert all objects to either Numbers or objects
    * that will produce a parsable toString result.
    */
    static protected Object preprocess( Object anObject )
    {
        if ( anObject instanceof Boolean )
        {
            if ( ((Boolean)anObject).booleanValue() )
            {
                return new Double( 1.0 );
            }
            return new Double( 0.0 );
        }

        if ( anObject instanceof Character )
        {
            return anObject.toString();
        }

        return anObject;	
    }
    
    static public short getShortValue( Object anObject )
    {
    	Short result = getShort( anObject );
        return ( result == null ) ? (short) 0 : result.shortValue();
    }
    static public Short getShort( Object anObject )
    {
        if ( anObject == null ) return new Short( (short) 0 );
        if ( "".equals( anObject ) ) return new Short( (short) 0 );
		if ( anObject instanceof Short ) return (Short) anObject;

		anObject = preprocess( anObject );

        if ( anObject instanceof Number )
        {
            return new Short( ((Number)anObject).shortValue() );
        }

		try
        {
            return Short.valueOf( anObject.toString() );
        }
        catch ( Exception exc )
        {
            return null;
        }
    }	
    
    static public int getIntValue( Object anObject )
    {
    	Integer result = getInteger( anObject );
        return ( result == null ) ? 0 : result.intValue();
    }
    static public Integer getInteger( Object anObject )
    {
        if ( anObject == null ) return new Integer( 0 );
        if ( "".equals( anObject ) ) return new Integer( 0 );
    	if ( anObject instanceof Integer ) return (Integer) anObject;
    
    	anObject = preprocess( anObject );

        if ( anObject instanceof Number )
        {
            return new Integer( ((Number)anObject).intValue() );
        }

        try
        {
            return Integer.valueOf( anObject.toString() );
        }
        catch ( Exception exc )
        {
            return null;
        }
    }	
    
    static public long getLongValue ( Object anObject )
    {
    	Long result = getLong( anObject );
        return ( result == null ) ? (long) 0 : result.longValue();
    }
    static public Long getLong( Object anObject )
    {
        if ( anObject == null ) return new Long( 0 );
        if ( "".equals( anObject ) ) return new Long( 0 );
    	if ( anObject instanceof Long ) return (Long) anObject;
    
    	anObject = preprocess( anObject );

        if ( anObject instanceof Number )
        {
            return new Long( ((Number)anObject).longValue() );
        }

        try
        {
            return Long.valueOf( anObject.toString() );
        }
        catch ( Exception exc )
        {
            return null;
        }
    }	
    
    static public double getDoubleValue ( Object anObject )
    {
    	Double result = getDouble( anObject );
        return ( result == null ) ? 0.0f : result.doubleValue();
    }
    static public Double getDouble( Object anObject )
    {
        if ( anObject == null ) return new Double( 0.0 );
        if ( "".equals( anObject ) ) return new Double( 0 );
    	if ( anObject instanceof Double ) return (Double) anObject;
    
    	anObject = preprocess( anObject );

        if ( anObject instanceof Number )
        {
            return new Double( ((Number)anObject).doubleValue() );
        }
	
        try
        {
            return Double.valueOf( anObject.toString() );
        }
        catch ( Exception exc )
        {
            return null;
        }
    }	
    
    static public float getFloatValue( Object anObject )
    {
    	Float result = getFloat( anObject );
        return ( result == null ) ? 0.0f : result.floatValue();
    }
    static public Float getFloat( Object anObject )
    {
        if ( anObject == null ) return new Float( 0.0 );
        if ( "".equals( anObject ) ) return new Float( 0.0 );
    	if ( anObject instanceof Float ) return (Float) anObject;
    
    	anObject = preprocess( anObject );

        if ( anObject instanceof Number )
        {
            return new Float( ((Number)anObject).floatValue() );
        }
	
    	try
        {
            return Float.valueOf( anObject.toString() );
        }
        catch ( Exception exc )
        {
            return null;
        }
    }	
        
    static public char getCharValue( Object anObject )
    {
    	Character result = getCharacter( anObject );
        return ( result == null ) ? (char) 0 : result.charValue();
    }
    static public Character getCharacter( Object anObject )
    {
        if ( anObject == null ) return new Character( (char) 0 );
    	if ( anObject instanceof Character ) return (Character) anObject;
    
    	anObject = preprocess( anObject );

        if ( anObject instanceof Number )
        {
            return new Character( (char) ((Number)anObject).byteValue() );
        }

        try
        {
            return new Character( anObject.toString().charAt( 0 ) );
        }
        catch ( Exception exc )
        {
            return null;
        }
    }

    static public byte getByteValue( Object anObject )
    {
    	Byte result = getByte ( anObject );
        return ( result == null ) ? (byte) 0 : result.byteValue();
    }
    static public Byte getByte( Object anObject )
    {
        if ( anObject == null ) return new Byte( Byte.MIN_VALUE );
        if ( "".equals( anObject ) ) return new Byte( Byte.MIN_VALUE );
    	if ( anObject instanceof Byte ) return (Byte) anObject;
    
    	anObject = preprocess( anObject );

        if ( anObject instanceof Number )
        {
            return new Byte( ((Number)anObject).byteValue() );
        }
	
    	try
        {
            return Byte.decode( anObject.toString() );
        }
        catch ( Exception exc )
        {
            // fall through
        }
    	
        try
        {
            return Byte.valueOf( anObject.toString() );
        }
        catch ( Exception exc )
        {
            return null;
        }
    }

	/**
	* Calls getBoolean and converts result to primitive.
	*/
    static public boolean getBooleanValue( Object anObject )
    {
    	Boolean result = getBoolean( anObject );
        return ( result == null ) ? false : result.booleanValue();
    }
	
	/**
	* Numbers equal to zero are true; Strings equal to "yes" are true;
	* Strings are then passed to the Boolean constructor.
	* Other values return null.
	*/
    static public Boolean getBoolean( Object anObject )
    {		
		if ( anObject instanceof Boolean )
		{
			return (Boolean) anObject;
		}
    	if ( anObject instanceof Number )
        {
            return new Boolean( ((Number)anObject).doubleValue() == 0.0 );
        }
    
    	if ( anObject instanceof String )
        {
			if ( anObject.toString().toLowerCase().equals( "yes" ) ) 
			{
				return Boolean.TRUE;
			}
            return new Boolean( (String) anObject );
        }
	
        return null;
    }
    
    /**
    * Get an appropriate String representation for the 
    * object.  Nulls are converted to "null".  Date are
    * formatted according to the current date format.
    * All else uses toString.
    */
    static public String getString( Object anObject )
    {
        if ( anObject == null ) return "null";
        if ( anObject instanceof java.util.Date )
        {
            return dateFormat.format( (java.util.Date) anObject );
        }
        return anObject.toString();
    }

    /**
    * Converts the object into the specified collection class.
    * If unable to convert in any other way, resorts to creating
    * a new collection of the specified type containing the
    * specified object.
    */
    static public Collection getCollection( Object anObject, Class aCollectionClass )
    {
        if ( anObject == null ) return null;
        if ( aCollectionClass.isAssignableFrom( anObject.getClass() ) )
        {
            return (Collection) anObject;
        }
        
        Collection converted = null;
        
        // convert to collection class
        if ( anObject instanceof Collection )
        {
            converted = (Collection) anObject;
        }
        else
        // try to convert an array
        if ( anObject.getClass().isArray() )
        {
            try
            {
                int length = Array.getLength( anObject );
                converted = new LinkedList();
                for ( int i = 0; i < length; i++ )
                {
                    converted.add( Array.get( anObject, i ) );
                }
            }
            catch ( Exception exc )
            {
                // try another approach   
            }
        }
        else
        // convert map values to collection and pass through
        if ( anObject instanceof Map )
        {
            converted = ((Map)anObject).values();
        }

        // fall back on list containing the object
        if ( converted == null )
        {
            converted = new LinkedList();
            converted.add( anObject );
        }
        
        Collection result = null;
        
        if ( converted != null )
        {
            try
            {
                // collections required to have the copy constructor.
                Constructor ctor = aCollectionClass.getConstructor(
                    new Class[] { Collection.class } );        
                result = (Collection) ctor.newInstance( new Object[] { converted } );
            }
            catch ( Exception exc )
            {
                try
                {
                    result = new LinkedList();
                    result.addAll( converted );
                }
                catch ( Exception exc2 )
                {
                    // all attempts failed
                    result = null;
                }
            }
        }
        
        return result;
    }

    /**
    * Convert the object to the specified array type.
    */
    static public Object getArray( Object anObject, Class anArrayClass )
    {
        if ( anObject == null ) return null;
        
        // try to convert an array
        if ( anObject.getClass().isArray() )
        {
            try
            {
                int length = Array.getLength( anObject );
                Object result = Array.newInstance( 
                    anArrayClass.getComponentType(), length );
                for ( int i = 0; i < length; i++ )
                {
                    Array.set( result, i, Array.get( anObject, i ) );
                }
                return result;
            }
            catch ( Exception exc )
            {
                // try another approach   
            }
        }
        // convert map values to collection and pass through
        if ( anObject instanceof Map )
        {
            anObject = ((Map)anObject).values();
        }
        // try to convert a collection
        if ( anObject instanceof Collection )
        {
            try
            {
                int length = ((Collection)anObject).size();
                Object result = Array.newInstance( 
                    anArrayClass.getComponentType(), length );
                Iterator it = ((Collection)anObject).iterator();
                for ( int i = 0; i < length; i++ )
                {
                    Array.set( result, i, it.next() ); 
                }
                return result;
            }
            catch ( Exception exc )
            {
                // try another approach   
            }
        }
        // if appropriate type, put the object in a single element array
        if ( anObject.getClass().equals( anArrayClass.getComponentType() ) )
        {
            try
            {
                Object result = Array.newInstance( 
                    anArrayClass.getComponentType(), 1 );
                Array.set( result, 0, anObject ); 
                return result;
            }
            catch ( Exception exc )
            {
                // try another approach   
            }
        }
        return null;
    }

    /**
    * Get an appropriate Date from the given object.
    */
    static public java.util.Date getDate( Object anObject )
    {
        if ( anObject == null ) return new java.util.Date( 0 );
    	if ( anObject instanceof java.util.Date ) 
	    	return (java.util.Date) anObject;
	
        if ( anObject instanceof Number )
        {
            return new java.util.Date( getLongValue( anObject ) );
        }

        try
        {
            return dateFormat.parse( anObject.toString() );
        }
        catch ( Exception exc )
        {
            return null;
        }
    }

    static private java.text.DateFormat dateFormat = 
    	new java.text.SimpleDateFormat();
    static public java.text.DateFormat getDateFormat()
    {
    	return dateFormat;
    }
    static public void setDateFormat( java.text.DateFormat aDateFormat )
    {
    	if ( aDateFormat != null )
        {
            dateFormat = aDateFormat;
        }
    }

    /**
    * Returns the "inverted" value of the specified object.
    * Numbers except for chars and bytes are converted to 
    * their negative representation.  Chars and bytes are
    * treated as booleans.  String are converted to booleans.
    * Booleans are converted to their opposite.
    * All other types return null.
    */    
    public static Object invert( Object anObject )
    {
        if ( anObject == null ) return null;
        Class aClass = anObject.getClass();
        
    	if ( ( ( anObject instanceof Number )
           &&! ( anObject instanceof Byte )
           &&! ( anObject instanceof Character ) )
          || ( aClass == short.class )
          || ( aClass == int.class )
          || ( aClass == long.class )
          || ( aClass == float.class )
          || ( aClass == double.class ) )
        {
            return convertObjectToClass( 
                new Double( getDoubleValue( anObject ) * -1 ), aClass );
        }
        
        Boolean converted = getBoolean( anObject );
        if ( converted != null )
        {
            if ( converted.booleanValue() )
            {
                return convertObjectToClass(
                    Boolean.FALSE, anObject.getClass() );
            }
            else
            {
                return convertObjectToClass(
                    Boolean.TRUE, anObject.getClass() );
            }
        }
        
        return null;
    }
}

/*
 * $Log$
 * Revision 1.2  2006/02/16 13:11:47  cgruber
 * Check in all sources in eclipse-friendly maven-enabled packages.
 *
 * Revision 1.4  2002/10/11 15:33:53  mpowers
 * Now supporting "!" to invert the value of a string property.
 *
 * Revision 1.3  2001/07/02 16:29:08  mpowers
 * XMLRPC decoder was relying on ValueConverter to convert LinkedLists into
 * the appropriate type.  This is now implemented in ValueConverter.
 *
 * Revision 1.2  2001/03/01 20:36:35  mpowers
 * Better error handling and better handling of nulls.
 *
 * Revision 1.1.1.1  2000/12/21 15:52:33  mpowers
 * Contributing wotonomy.
 *
 * Revision 1.8  2000/12/20 16:25:48  michael
 * Added log to all files.
 *
 *
 */