// Copyright 2006 Daniel Gredler

 //

 // Licensed under the Apache License, Version 2.0 (the "License");

 // you may not use this file except in compliance with the License.

 // You may obtain a copy of the License at

 //

 //     http://www.apache.org/licenses/LICENSE-2.0

 //

 // Unless required by applicable law or agreed to in writing, software

 // distributed under the License is distributed on an "AS IS" BASIS,

 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 // See the License for the specific language governing permissions and

 // limitations under the License.

 package net.sf.beanform.util;

 import java.beans.BeanInfo;

 import java.beans.IntrospectionException;

 import java.beans.Introspector;

 import java.beans.PropertyDescriptor;

 import java.io.IOException;

 import java.io.InputStream;

 import java.lang.reflect.Field;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.apache.hivemind.ApplicationRuntimeException;

 import org.apache.hivemind.util.Defense;

 import org.apache.tapestry.request.IUploadFile;

 /**

  * Utility class for reflection-related operations.

  *

  * @author Daniel Gredler

  */

 public final class ReflectionUtils {

     private final static Log LOG = LogFactory.getLog( ReflectionUtils.class );

     ReflectionUtils() {

         // Empty.

     }

     public static void setFieldValue( Object object, String fieldName, Object value )

     throws NoSuchFieldException, IllegalAccessException {

         Defense.notNull( object, "object" );

         Defense.notNull( fieldName, "fieldName" );

         for( Class clazz = object.getClass(); clazz != null; clazz = clazz.getSuperclass() ) {

             for( Field field : clazz.getDeclaredFields() ) {

                 if( field.getName().equals( fieldName ) ) {

                     field.setAccessible( true );

                     field.set( object, value );

                     return;

                 }

             }

         }

         throw new NoSuchFieldException( "Unable to find field '" + object.getClass().getName() + "#" + fieldName + "'." );

     }

     public static Object getFieldValue( Object object, String fieldName )

     throws NoSuchFieldException, IllegalAccessException {

         Defense.notNull( object, "object" );

         Defense.notNull( fieldName, "fieldName" );

         for( Class clazz = object.getClass(); clazz != null; clazz = clazz.getSuperclass() ) {

             for( Field field : clazz.getDeclaredFields() ) {

                 if( field.getName().equals( fieldName ) ) {

                     field.setAccessible( true );

                     Object value = field.get( object );

                     return value;

                 }

             }

         }

         throw new NoSuchFieldException( "Unable to find field '" + object.getClass().getName() + "#" + fieldName + "'." );

     }

     public static Field getField( Class clazz, String... names )

     throws NoSuchFieldException {

         return getFieldRecursive( clazz, names, 0 );

     }

     private static Field getFieldRecursive( Class clazz, String[] names, int level )

     throws NoSuchFieldException {

         Field f = clazz.getDeclaredField( names[ level ] );

         boolean lastLevel = ( names.length == level + 1 );

         if( lastLevel ) return f;

         else return getFieldRecursive( f.getType(), names, level + 1 );

     }

     public static Object getPropertyValue( Object object, String... names )

     throws IllegalAccessException, InvocationTargetException {

         return getPropertyValueRecursive( object, names, 0 );

     }

     private static Object getPropertyValueRecursive( Object object, String[] names, int level )

     throws IllegalAccessException, InvocationTargetException {

         if( object == null ) return null;

         Class clazz = object.getClass();

         PropertyDescriptor pd = getDescriptor( clazz, names[ level ] );

         object = pd.getReadMethod().invoke( object );

         boolean lastLevel = ( names.length == level + 1 );

         if( lastLevel ) return object;

         else return getPropertyValueRecursive( object, names, level + 1 );

     }

     public static void setPropertyValue( Object value, Object object, String... names )

     throws IllegalAccessException, InvocationTargetException, InstantiationException {

         setPropertyValueRecursive( value, object, names, 0 );

     }

     private static void setPropertyValueRecursive( Object value, Object object, String[] names, int level )

     throws IllegalAccessException, InvocationTargetException, InstantiationException {

         Class clazz = object.getClass();

         PropertyDescriptor pd = getDescriptor( clazz, names[ level ] );

         boolean lastLevel = ( names.length == level + 1 );

         if( lastLevel ) {

             Method setter = pd.getWriteMethod();

             Class type = setter.getParameterTypes()[ 0 ];

             value = convertToType( value, type );

             setter.invoke( object, value );

         }

         else {

             Object nextObject = pd.getReadMethod().invoke( object );

             if( nextObject == null ) {

                 if( value != null ) {

                     nextObject = pd.getReadMethod().getReturnType().newInstance();

                     pd.getWriteMethod().invoke( object, nextObject );

                 }

                 else {

                     if( LOG.isDebugEnabled() ) {

                         StringBuilder msg = new StringBuilder( "Aborting attempt to set property '" );

                         for( String name : names ) msg.append( name ).append( '.' );

                         msg.deleteCharAt( msg.length() - 1 );

                         msg.append( "' to null: the '" ).append( names[ level ] );

                         msg.append( "' portion of the property is null." );

                         LOG.debug( msg );

                     }

                     return;

                 }

             }

             setPropertyValueRecursive( value, nextObject, names, level + 1 );

         }

     }

     public static PropertyDescriptor getPropertyDescriptor( Class clazz, String... names ) {

         return getPropertyDescriptorRecursive( clazz, names, 0 );

     }

     private static PropertyDescriptor getPropertyDescriptorRecursive( Class clazz, String[] names, int level ) {

         PropertyDescriptor pd = getDescriptor( clazz, names[ level ] );

         boolean lastLevel = ( names.length == level + 1 );

         if( lastLevel ) return pd;

         else return getPropertyDescriptorRecursive( pd.getPropertyType(), names, level + 1 );

     }

     private static PropertyDescriptor getDescriptor( Class clazz, String name ) {

         try {

             BeanInfo info = Introspector.getBeanInfo( clazz, errorTrigger );

             PropertyDescriptor[] descriptors = info.getPropertyDescriptors();

             for( PropertyDescriptor descriptor : descriptors ) {

                 if( descriptor.getName().equals( name ) ) {

                     return descriptor;

                 }

             }

         }

         catch( IntrospectionException e ) {

             String msg = ReflectionUtilsMessages.cantFindProperty( name, clazz );

             throw new ApplicationRuntimeException( msg, e );

         }

         String msg = ReflectionUtilsMessages.cantFindProperty( name, clazz );

         throw new ApplicationRuntimeException( msg );

     }

     /**

      * Converts the specified value to the specified type. Our current use case only

      * requires that we convert from strings to numbers and from IUploadFile's to byte[]'s,

      * so this is <b>not</b> a generic type conversion method. If this method is given

      * a conversion that it is not meant to handle, it just returns the original value.

      */

     private static Object convertToType( Object value, Class type ) {

         if( value != null && type.isInstance( value ) == false ) {

             // x -> y

             if( value instanceof String ) {

                 // string -> y

                 String s = (String) value;

                 if( Short.class.equals( type ) || short.class.equals( type ) ) {

                     // string -> short

                     value = Short.parseShort( s );

                 }

                 else if( Integer.class.equals( type ) || int.class.equals( type ) ) {

                     // string -> integer

                     value = Integer.parseInt( s );

                 }

                 else if( Long.class.equals( type ) || long.class.equals( type ) ) {

                     // string -> long

                     value = Long.parseLong( s );

                 }

                 else if( Float.class.equals( type ) || float.class.equals( type ) ) {

                     // string -> float

                     value = Float.parseFloat( s );

                 }

                 else if( Double.class.equals( type ) || double.class.equals( type ) ) {

                     // string -> double

                     value = Double.parseDouble( s );

                 }

             }

             else if( value instanceof IUploadFile && byte[].class.equals( type ) ) {

                 // IUploadFile -> byte[]

                 IUploadFile file = (IUploadFile) value;

                 long size = file.getSize();

                 if( size < 1 ) {

                     value = null;

                 }

                 else if( size > Integer.MAX_VALUE ) {

                     String msg = "File is too large; the maximum allowable size is " + Integer.MAX_VALUE + " bytes.";

                     throw new ApplicationRuntimeException( msg );

                 }

                 else {

                     byte[] bytes = new byte[ (int) size ];

                     InputStream input = file.getStream();

                     try {

                         int read = input.read( bytes );

                         if( read != size ) {

                             String msg = "Error reading file; expected " + size + " bytes, but got " + read + ".";

                             throw new ApplicationRuntimeException( msg );

                         }

                     }

                     catch( IOException e ) {

                         String msg = "Error reading file: " + e.getMessage();

                         throw new ApplicationRuntimeException( msg, e );

                     }

                     value = bytes;

                 }

             }

         }

         return value;

     }

     // ------------------------------------------------------------------------------------------------------------ //

     // ------------------------------------------- unit testing support ------------------------------------------- //

     // ------------------------------------------------------------------------------------------------------------ //

     private static Class errorTrigger = null;

     /**

      * Calling this method will cause subsequent {@link #getDescriptor(Class, String)} calls to result

      * in <tt>IntrospectionException</tt>s that will allow us to test error-handling functionality.

      */

     static void triggerIntrospectionException() {

         if( errorTrigger != null ) errorTrigger = null;

         else errorTrigger = BeanInfo.class;

     }

 }