package org.apache.commons.beanutils2;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * EXTRACTED FROM BeanUtils1
 *
 * A MappedPropertyDescriptor describes one mapped property. Mapped properties are multivalued properties like indexed
 * properties but that are accessed with a String key instead of an index. Such property values are typically stored in
 * a Map collection. For this class to work properly, a mapped value must have getter and setter methods of the form
 * <p>
 * <code>get<strong>Property</strong>(String key)<code> and
 * <p><code>set<strong>Property</strong>(String key, Object value)<code>,
 * <p>where <code><strong>Property</strong></code> must be replaced by the name of the property.
 *
 * @see java.beans.PropertyDescriptor
 * @author Rey Francois
 * @author Gregor Rayman
 * @version $Revision: 806915 $ $Date: 2009-08-23 02:50:23 +0200 (Sun, 23 Aug 2009) $
 */

public class MappedPropertyDescriptor
    extends PropertyDescriptor
{
    // ----------------------------------------------------- Instance Variables

    /**
     * The underlying data type of the property we are describing.
     */
    private Reference<Class<?>> mappedPropertyTypeRef;

    /**
     * The reader method for this property (if any).
     */
    private MappedMethodReference mappedReadMethodRef;

    /**
     * The writer method for this property (if any).
     */
    private MappedMethodReference mappedWriteMethodRef;

    /**
     * The parameter types array for the reader method signature.
     */
    @SuppressWarnings( "unchecked" )
    // we can not create a generic array
    private static final Class<String>[] STRING_CLASS_PARAMETER = new Class[] { String.class };

    // ----------------------------------------------------------- Constructors

    /**
     * Constructs a MappedPropertyDescriptor for a property that follows the standard Java convention by having getFoo
     * and setFoo accessor methods, with the addition of a String parameter (the key). Thus if the argument name is
     * "fred", it will assume that the writer method is "setFred" and the reader method is "getFred". Note that the
     * property name should start with a lower case character, which will be capitalized in the method names.
     *
     * @param propertyName The programmatic name of the property.
     * @param beanClass The Class object for the target bean. For example sun.beans.OurButton.class.
     * @exception IntrospectionException if an exception occurs during introspection.
     */
    public MappedPropertyDescriptor( String propertyName, Class<?> beanClass )
        throws IntrospectionException
    {

        super( propertyName, null, null );

        if ( propertyName == null || propertyName.length() == 0 )
        {
            throw new IntrospectionException( "bad property name: " + propertyName + " on class: "
                + beanClass.getClass().getName() );
        }

        setName( propertyName );
        String base = capitalizePropertyName( propertyName );

        // Look for mapped read method and matching write method
        Method mappedReadMethod = null;
        Method mappedWriteMethod = null;
        try
        {
            try
            {
                mappedReadMethod = getMethod( beanClass, "get" + base, STRING_CLASS_PARAMETER );
            }
            catch ( IntrospectionException e )
            {
                mappedReadMethod = getMethod( beanClass, "is" + base, STRING_CLASS_PARAMETER );
            }
            Class<?>[] params = { String.class, mappedReadMethod.getReturnType() };
            mappedWriteMethod = getMethod( beanClass, "set" + base, params );
        }
        catch ( IntrospectionException e )
        {
            /*
             * Swallow IntrospectionException TODO: Why?
             */
        }

        // If there's no read method, then look for just a write method
        if ( mappedReadMethod == null )
        {
            mappedWriteMethod = getMethod( beanClass, "set" + base, 2 );
        }

        if ( ( mappedReadMethod == null ) && ( mappedWriteMethod == null ) )
        {
            throw new IntrospectionException( "Property '" + propertyName + "' not found on " + beanClass.getName() );
        }
        mappedReadMethodRef = new MappedMethodReference( mappedReadMethod );
        mappedWriteMethodRef = new MappedMethodReference( mappedWriteMethod );

        findMappedPropertyType();
    }

    /**
     * This constructor takes the name of a mapped property, and method names for reading and writing the property.
     *
     * @param propertyName The programmatic name of the property.
     * @param beanClass The Class object for the target bean. For example sun.beans.OurButton.class.
     * @param mappedGetterName The name of the method used for reading one of the property values. May be null if the
     *            property is write-only.
     * @param mappedSetterName The name of the method used for writing one of the property values. May be null if the
     *            property is read-only.
     * @exception IntrospectionException if an exception occurs during introspection.
     */
    public MappedPropertyDescriptor( String propertyName, Class<?> beanClass, String mappedGetterName,
                                     String mappedSetterName )
        throws IntrospectionException
    {

        super( propertyName, null, null );

        if ( propertyName == null || propertyName.length() == 0 )
        {
            throw new IntrospectionException( "bad property name: " + propertyName );
        }
        setName( propertyName );

        // search the mapped get and set methods
        Method mappedReadMethod = null;
        Method mappedWriteMethod = null;
        mappedReadMethod = getMethod( beanClass, mappedGetterName, STRING_CLASS_PARAMETER );

        if ( mappedReadMethod != null )
        {
            Class<?>[] params = { String.class, mappedReadMethod.getReturnType() };
            mappedWriteMethod = getMethod( beanClass, mappedSetterName, params );
        }
        else
        {
            mappedWriteMethod = getMethod( beanClass, mappedSetterName, 2 );
        }
        mappedReadMethodRef = new MappedMethodReference( mappedReadMethod );
        mappedWriteMethodRef = new MappedMethodReference( mappedWriteMethod );

        findMappedPropertyType();
    }

    /**
     * This constructor takes the name of a mapped property, and Method objects for reading and writing the property.
     *
     * @param propertyName The programmatic name of the property.
     * @param mappedGetter The method used for reading one of the property values. May be be null if the property is
     *            write-only.
     * @param mappedSetter The method used for writing one the property values. May be null if the property is
     *            read-only.
     * @exception IntrospectionException if an exception occurs during introspection.
     */
    public MappedPropertyDescriptor( String propertyName, Method mappedGetter, Method mappedSetter )
        throws IntrospectionException
    {

        super( propertyName, mappedGetter, mappedSetter );

        if ( propertyName == null || propertyName.length() == 0 )
        {
            throw new IntrospectionException( "bad property name: " + propertyName );
        }

        setName( propertyName );
        mappedReadMethodRef = new MappedMethodReference( mappedGetter );
        mappedWriteMethodRef = new MappedMethodReference( mappedSetter );
        findMappedPropertyType();
    }

    // -------------------------------------------------------- Public Methods

    /**
     * Gets the Class object for the property values.
     *
     * @return The Java type info for the property values. Note that the "Class" object may describe a built-in Java
     *         type such as "int". The result may be "null" if this is a mapped property that does not support non-keyed
     *         access.
     *         <p>
     *         This is the type that will be returned by the mappedReadMethod.
     */
    public Class<?> getMappedPropertyType()
    {
        return mappedPropertyTypeRef.get();
    }

    /**
     * Gets the method that should be used to read one of the property value.
     *
     * @return The method that should be used to read the property value. May return null if the property can't be read.
     */
    public Method getMappedReadMethod()
    {
        return mappedReadMethodRef.get();
    }

    /**
     * Sets the method that should be used to read one of the property value.
     *
     * @param mappedGetter The mapped getter method.
     * @throws IntrospectionException If an error occurs finding the mapped property
     */
    public void setMappedReadMethod( Method mappedGetter )
        throws IntrospectionException
    {
        mappedReadMethodRef = new MappedMethodReference( mappedGetter );
        findMappedPropertyType();
    }

    /**
     * Gets the method that should be used to write one of the property value.
     *
     * @return The method that should be used to write one of the property value. May return null if the property can't
     *         be written.
     */
    public Method getMappedWriteMethod()
    {
        return mappedWriteMethodRef.get();
    }

    /**
     * Sets the method that should be used to write the property value.
     *
     * @param mappedSetter The mapped setter method.
     * @throws IntrospectionException If an error occurs finding the mapped property
     */
    public void setMappedWriteMethod( Method mappedSetter )
        throws IntrospectionException
    {
        mappedWriteMethodRef = new MappedMethodReference( mappedSetter );
        findMappedPropertyType();
    }

    // ------------------------------------------------------- Private Methods

    /**
     * Introspect our bean class to identify the corresponding getter and setter methods.
     */
    private void findMappedPropertyType()
        throws IntrospectionException
    {
        try
        {
            Method mappedReadMethod = getMappedReadMethod();
            Method mappedWriteMethod = getMappedWriteMethod();
            Class<?> mappedPropertyType = null;
            if ( mappedReadMethod != null )
            {
                if ( mappedReadMethod.getParameterTypes().length != 1 )
                {
                    throw new IntrospectionException( "bad mapped read method arg count" );
                }
                mappedPropertyType = mappedReadMethod.getReturnType();
                if ( mappedPropertyType == Void.TYPE )
                {
                    throw new IntrospectionException( "mapped read method " + mappedReadMethod.getName()
                        + " returns void" );
                }
            }

            if ( mappedWriteMethod != null )
            {
                Class<?>[] params = mappedWriteMethod.getParameterTypes();
                if ( params.length != 2 )
                {
                    throw new IntrospectionException( "bad mapped write method arg count" );
                }
                if ( mappedPropertyType != null && mappedPropertyType != params[1] )
                {
                    throw new IntrospectionException( "type mismatch between mapped read and write methods" );
                }
                mappedPropertyType = params[1];
            }
            mappedPropertyTypeRef = new SoftReference<Class<?>>( mappedPropertyType );
        }
        catch ( IntrospectionException ex )
        {
            throw ex;
        }
    }

    /**
     * Return a capitalized version of the specified property name.
     *
     * @param s The property name
     */
    private static String capitalizePropertyName( String s )
    {
        if ( s.length() == 0 )
        {
            return s;
        }

        char[] chars = s.toCharArray();
        chars[0] = Character.toUpperCase( chars[0] );
        return new String( chars );
    }

    /**
     * Find a method on a class with a specified number of parameters.
     */
    private static Method internalGetMethod( Class<?> initial, String methodName, int parameterCount )
    {
        // For overridden methods we need to find the most derived version.
        // So we start with the given class and walk up the superclass chain.
        for ( Class<?> clazz = initial; clazz != null; clazz = clazz.getSuperclass() )
        {
            Method[] methods = clazz.getDeclaredMethods();
            for ( int i = 0; i < methods.length; i++ )
            {
                Method method = methods[i];
                if ( method == null )
                {
                    continue;
                }
                // skip static methods.
                int mods = method.getModifiers();
                if ( !Modifier.isPublic( mods ) || Modifier.isStatic( mods ) )
                {
                    continue;
                }
                if ( method.getName().equals( methodName ) && method.getParameterTypes().length == parameterCount )
                {
                    return method;
                }
            }
        }

        // Now check any inherited interfaces. This is necessary both when
        // the argument class is itself an interface, and when the argument
        // class is an abstract class.
        Class<?>[] interfaces = initial.getInterfaces();
        for ( int i = 0; i < interfaces.length; i++ )
        {
            Method method = internalGetMethod( interfaces[i], methodName, parameterCount );
            if ( method != null )
            {
                return method;
            }
        }

        return null;
    }

    /**
     * Find a method on a class with a specified number of parameters.
     */
    private static Method getMethod( Class<?> clazz, String methodName, int parameterCount )
        throws IntrospectionException
    {
        if ( methodName == null )
        {
            return null;
        }

        Method method = internalGetMethod( clazz, methodName, parameterCount );
        if ( method != null )
        {
            return method;
        }

        // No Method found
        throw new IntrospectionException( "No method \"" + methodName + "\" with " + parameterCount + " parameter(s)" );
    }

    /**
     * Find a method on a class with a specified parameter list.
     */
    private static Method getMethod( Class<?> clazz, String methodName, Class<?>[] parameterTypes )
        throws IntrospectionException
    {
        if ( methodName == null )
        {
            return null;
        }

        Method method = AccessibleObjectsRegistry.getMethodsRegistry().get( true, clazz, methodName, parameterTypes );
        if ( method != null )
        {
            return method;
        }

        int parameterCount = ( parameterTypes == null ) ? 0 : parameterTypes.length;

        // No Method found
        throw new IntrospectionException( "No method \"" + methodName + "\" with " + parameterCount
            + " parameter(s) of matching types." );
    }

    /**
     * Holds a {@link Method} in a {@link SoftReference} so that it it doesn't prevent any ClassLoader being garbage
     * collected, but tries to re-create the method if the method reference has been released. See
     * http://issues.apache.org/jira/browse/BEANUTILS-291
     */
    private static class MappedMethodReference
    {
        private String className;

        private String methodName;

        private Reference<Method> methodRef;

        private Reference<Class<?>> classRef;

        private Reference<Class<?>> writeParamTypeRef0;

        private Reference<Class<?>> writeParamTypeRef1;

        private String[] writeParamClassNames;

        MappedMethodReference( Method m )
        {
            if ( m != null )
            {
                className = m.getDeclaringClass().getName();
                methodName = m.getName();
                methodRef = new SoftReference<Method>( m );
                classRef = new WeakReference<Class<?>>( m.getDeclaringClass() );
                Class<?>[] types = m.getParameterTypes();
                if ( types.length == 2 )
                {
                    writeParamTypeRef0 = new WeakReference<Class<?>>( types[0] );
                    writeParamTypeRef1 = new WeakReference<Class<?>>( types[1] );
                    writeParamClassNames = new String[2];
                    writeParamClassNames[0] = types[0].getName();
                    writeParamClassNames[1] = types[1].getName();
                }
            }
        }

        private Method get()
        {
            if ( methodRef == null )
            {
                return null;
            }
            Method m = methodRef.get();
            if ( m == null )
            {
                Class<?> clazz = classRef.get();
                if ( clazz == null )
                {
                    clazz = reLoadClass();
                    if ( clazz != null )
                    {
                        classRef = new WeakReference<Class<?>>( clazz );
                    }
                }
                if ( clazz == null )
                {
                    throw new RuntimeException( "Method " + methodName + " for " + className
                        + " could not be reconstructed - class reference has gone" );
                }
                Class<?>[] paramTypes = null;
                if ( writeParamClassNames != null )
                {
                    paramTypes = new Class[2];
                    paramTypes[0] = writeParamTypeRef0.get();
                    if ( paramTypes[0] == null )
                    {
                        paramTypes[0] = reLoadClass( writeParamClassNames[0] );
                        if ( paramTypes[0] != null )
                        {
                            writeParamTypeRef0 = new WeakReference<Class<?>>( paramTypes[0] );
                        }
                    }
                    paramTypes[1] = writeParamTypeRef1.get();
                    if ( paramTypes[1] == null )
                    {
                        paramTypes[1] = reLoadClass( writeParamClassNames[1] );
                        if ( paramTypes[1] != null )
                        {
                            writeParamTypeRef1 = new WeakReference<Class<?>>( paramTypes[1] );
                        }
                    }
                }
                else
                {
                    paramTypes = STRING_CLASS_PARAMETER;
                }
                try
                {
                    m = clazz.getMethod( methodName, paramTypes );
                    // Un-comment following line for testing
                    // System.out.println("Recreated Method " + methodName + " for " + className);
                }
                catch ( NoSuchMethodException e )
                {
                    throw new RuntimeException( "Method " + methodName + " for " + className
                        + " could not be reconstructed - method not found" );
                }
                methodRef = new SoftReference<Method>( m );
            }
            return m;
        }

        /**
         * Try to re-load the class
         */
        private Class<?> reLoadClass()
        {
            return reLoadClass( className );
        }

        /**
         * Try to re-load the class
         */
        private Class<?> reLoadClass( String name )
        {

            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

            // Try the context class loader
            if ( classLoader != null )
            {
                try
                {
                    return classLoader.loadClass( name );
                }
                catch ( ClassNotFoundException e )
                {
                    // ignore
                }
            }

            // Try this class's class loader
            classLoader = MappedPropertyDescriptor.class.getClassLoader();
            try
            {
                return classLoader.loadClass( name );
            }
            catch ( ClassNotFoundException e )
            {
                return null;
            }
        }
    }
}