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 static java.lang.System.getSecurityManager;
  import static java.lang.reflect.Modifier.isPublic;
  import static java.security.AccessController.doPrivileged;
  import static org.apache.commons.beanutils2.Assertions.checkArgument;
  import static org.apache.commons.beanutils2.TypeUtils.checkTypesCompatible;
  import static org.apache.commons.beanutils2.TypeUtils.getPrimitiveWrapper;
  import static org.apache.commons.beanutils2.TypeUtils.isAssignmentCompatible;
  
  import java.lang.reflect.AccessibleObject;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Member;
  import java.lang.reflect.Method;
  import java.security.PrivilegedAction;
  import java.util.Arrays;
  import java.util.Map;
  import java.util.WeakHashMap;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  abstract class AccessibleObjectsRegistry<AO extends AccessibleObject & Member>
  {
  
      // extracted from BeanUtils1
      private static final float NON_FOUND_COST = 1.5f;
  
      // extracted from BeanUtils1
      private static final float SUPERCLASS_COST = 1.0f;
  
      // extracted from BeanUtils1
      private static final float INTERFACE_COST = 0.25f;
  
      // extracted from BeanUtils1
      private static final float WRAPPER_COST = 0.25f;
  
      private static final AccessibleObjectsRegistry<Constructor<?>> CONSTRUCTORS_REGISTRY = new ConstructorsRegistry();
  
      private static final AccessibleObjectsRegistry<Method> METHODS_REGISTRY = new MethodsRegistry();
  
      public static AccessibleObjectsRegistry<Constructor<?>> getConstructorsRegistry()
      {
          return CONSTRUCTORS_REGISTRY;
      }
  
      public static AccessibleObjectsRegistry<Method> getMethodsRegistry()
      {
          return METHODS_REGISTRY;
      }
  
      private final Map<AccessibleObjectDescriptor, AO> cache = new WeakHashMap<AccessibleObjectDescriptor, AO>();
  
      private AccessibleObjectsRegistry()
      {
          // this class cannot be instantiated
      }
  
      public final AO get( boolean exact, Class<?> type, Class<?>... parameterTypes )
      {
          return get( exact, type, null, parameterTypes );
      }
  
      public final AO get( boolean exact, Class<?> type, String name, Class<?>... parameterTypes )
      {
          AccessibleObjectDescriptor key = new AccessibleObjectDescriptor( exact, type, name, parameterTypes );
  
          final Lock lock = new ReentrantLock();
          lock.lock();
          try
          {
              AO accessibleObject = cache.get( key );
              if ( accessibleObject != null )
              {
                  return accessibleObject;
              }
  
              // see if we can find the accessible object directly
              // most of the time this works and it's much faster
              try
              {
                 accessibleObject = resolveDirectly( type, name, parameterTypes );
                 if ( exact || accessibleObject != null )
                 {
                     return makeAccessible( accessibleObject );
                 }
             }
             catch ( NoSuchMethodException e )
             {
                 /* SWALLOW */
                 if ( exact )
                 {
                     return null;
                 }
             }
 
             // start calculating the best matching
 
             int paramSize = parameterTypes.length;
             AO bestMatch = null;
             AO[] accessibleObjectsArray = getAccessibleObjectsArray( type );
             float bestMatchCost = Float.MAX_VALUE;
             float myCost = Float.MAX_VALUE;
             for ( int i = 0, size = accessibleObjectsArray.length; i < size; i++ )
             {
                 if ( matches( accessibleObjectsArray[i], name ) )
                 {
                     // compare parameters
                     Class<?>[] methodsParams = getParameterTypes( accessibleObjectsArray[i] );
                     int methodParamSize = methodsParams.length;
                     if ( methodParamSize == paramSize )
                     {
                         boolean match = checkTypesCompatible( methodsParams, parameterTypes );
 
                         if ( match )
                         {
                             // get accessible version of method
                             AO current = resolveAccessible( type, accessibleObjectsArray[i] );
                             if ( current != null )
                             {
                                 // determine which method the compiler would chose
                                 myCost = getTotalTransformationCost( parameterTypes, getParameterTypes( current ) );
                                 if ( myCost < bestMatchCost )
                                 {
                                     bestMatch = current;
                                     bestMatchCost = myCost;
                                 }
                             }
                         }
                     }
                 }
             }
 
             if ( bestMatch != null )
             {
                 bestMatch = makeAccessible( bestMatch );
             }
             cache.put( key, bestMatch );
             return bestMatch;
         }
         finally
         {
             lock.unlock();
         }
     }
 
     protected abstract AO resolveDirectly( Class<?> type, String name, Class<?>... parameterTypes )
         throws NoSuchMethodException;
 
     protected abstract AO[] getAccessibleObjectsArray( Class<?> type );
 
     protected abstract boolean matches( AO accessibleObject, String name );
 
     protected abstract Class<?>[] getParameterTypes( AO accessibleObject );
 
     protected abstract AO resolveAccessible( Class<?> type, AO accessibleObject );
 
     /**
      * Returns the sum of the object transformation cost for each class in the source argument list.
      *
      * @param srcArgs The source arguments
      * @param destArgs The destination arguments
      * @return The total transformation cost
      */
     private static float getTotalTransformationCost( Class<?>[] srcArgs, Class<?>[] destArgs )
     {
         float totalCost = 0.0f;
         for ( int i = 0; i < srcArgs.length; i++ )
         {
             Class<?> srcClass, destClass;
             srcClass = srcArgs[i];
             destClass = destArgs[i];
             totalCost += getObjectTransformationCost( srcClass, destClass );
         }
         return totalCost;
     }
 
     /**
      * Determines the costs of turning the source class into the destination class. This represents the weighted number
      * of steps in the object hierarchy graph.
      *
      * @param srcClass The source class
      * @param destClass The destination class
      * @return The cost of transforming an object
      */
     private static float getObjectTransformationCost( Class<?> srcClass, Class<?> destClass )
     {
         float cost = 0.0f;
         while ( srcClass != null && !destClass.equals( srcClass ) )
         {
             if ( destClass.isPrimitive() )
             {
                 Class<?> destClassWrapperClazz = getPrimitiveWrapper( destClass );
                 if ( destClassWrapperClazz != null && destClassWrapperClazz.equals( srcClass ) )
                 {
                     cost += WRAPPER_COST;
                     break;
                 }
             }
             if ( destClass.isInterface() && isAssignmentCompatible( destClass, srcClass ) )
             {
                 // slight penalty for interface match.
                 // we still want an exact match to override an interface match, but
                 // an interface match should override anything where we have to get a
                 // superclass.
                 cost += INTERFACE_COST;
                 break;
             }
             cost += SUPERCLASS_COST;
             srcClass = srcClass.getSuperclass();
         }
 
 
         // If the destination class is null, we've travelled all the way up to an Object match.
         if ( srcClass == null )
         {
             cost += NON_FOUND_COST;
         }
 
         return cost;
     }
 
     private AO makeAccessible( AO accessibleObject )
     {
         PrivilegedAction<AO> action = new MakeAccessiblePrivilegedAction<AO>( accessibleObject );
         if ( getSecurityManager() != null )
         {
             return doPrivileged( action );
         }
         return action.run();
     }
 
     /**
      * Constructors registry implementation.
      */
     private static class ConstructorsRegistry extends AccessibleObjectsRegistry<Constructor<?>>
     {
 
         @Override
         protected Constructor<?> resolveDirectly( Class<?> type, String name, Class<?>...parameterTypes )
             throws NoSuchMethodException
         {
             return type.getConstructor( parameterTypes );
         }
 
         @Override
         protected Constructor<?>[] getAccessibleObjectsArray( Class<?> type )
         {
             return type.getConstructors();
         }
 
         @Override
         protected boolean matches( Constructor<?> accessibleObject, String name )
         {
             return true;
         }
 
         @Override
         protected Class<?>[] getParameterTypes( Constructor<?> accessibleObject )
         {
             return accessibleObject.getParameterTypes();
         }
 
         @Override
         protected Constructor<?> resolveAccessible( Class<?> type, Constructor<?> accessibleObject )
         {
             if ( accessibleObject == null )
             {
                 return null;
             }
 
             if ( !isPublic( accessibleObject.getModifiers() ) )
             {
                 return null;
             }
 
             // If the declaring class is public, we are done
             Class<?> beanClass = accessibleObject.getDeclaringClass();
             if ( isPublic( beanClass.getModifiers() ) )
             {
                 return accessibleObject;
             }
 
             // what else can we do?
             return null;
         }
 
     }
 
     /**
      * Methods registry
      */
     private static final class MethodsRegistry extends AccessibleObjectsRegistry<Method>
     {
 
         @Override
         protected Method resolveDirectly( Class<?> type, String name, Class<?>...parameterTypes )
             throws NoSuchMethodException
         {
             return type.getMethod( name, parameterTypes );
         }
 
         @Override
         protected Method[] getAccessibleObjectsArray( Class<?> type )
         {
             return type.getMethods();
         }
 
         @Override
         protected boolean matches( Method accessibleObject, String name )
         {
             return name.equals( accessibleObject.getName() );
         }
 
         @Override
         protected Class<?>[] getParameterTypes( Method accessibleObject )
         {
             return accessibleObject.getParameterTypes();
         }
 
         @Override
         protected Method resolveAccessible( Class<?> type, Method method )
         {
             // Make sure we have a method to check
             if ( method == null )
             {
                 return null;
             }
 
             // If the requested method is not public we cannot call it
             if ( !isPublic( method.getModifiers() ) )
             {
                 return null;
             }
 
             if ( type == null )
             {
                 type = method.getDeclaringClass();
             }
             else
             {
                 checkArgument( method.getDeclaringClass().isAssignableFrom( type ),
                                "%s is not assignable from ", type.getName(), method.getDeclaringClass().getName() );
             }
 
             // If the class is public, we are done
             if ( isPublic( type.getModifiers() ) )
             {
                 return method;
             }
 
             String methodName = method.getName();
             Class<?>[] parameterTypes = method.getParameterTypes();
 
             // Check the implemented interfaces and subinterfaces
             method = getAccessibleMethodFromInterfaceNest( type, methodName, parameterTypes );
 
             // Check the superclass chain
             if ( method == null )
             {
                 method = getAccessibleMethodFromSuperclass( type, methodName, parameterTypes );
             }
 
             return method;
         }
 
         /**
          * <p>Return an accessible method (that is, one that can be invoked via
          * reflection) by scanning through the superclasses. If no such method
          * can be found, return <code>null</code>.</p>
          *
          * @param clazz Class to be checked
          * @param methodName Method name of the method we wish to call
          * @param parameterTypes The parameter type signatures
          */
         private static Method getAccessibleMethodFromSuperclass( Class<?> clazz, String methodName,
                                                                  Class<?>... parameterTypes )
         {
             Class<?> parentClazz = clazz.getSuperclass();
             while ( parentClazz != null )
             {
                 if ( isPublic( parentClazz.getModifiers() ) )
                 {
                     try
                     {
                         return parentClazz.getMethod( methodName, parameterTypes );
                     }
                     catch ( NoSuchMethodException e )
                     {
                         // go ahead until found or parentClazz == null
                     }
                 }
                 parentClazz = parentClazz.getSuperclass();
             }
             return null;
         }
 
         /**
          * <p>Return an accessible method (that is, one that can be invoked via
          * reflection) that implements the specified method, by scanning through
          * all implemented interfaces and subinterfaces.  If no such method
          * can be found, return <code>null</code>.</p>
          *
          * <p> There isn't any good reason why this method must be private.
          * It is because there doesn't seem any reason why other classes should
          * call this rather than the higher level methods.</p>
          *
          * @param clazz Parent class for the interfaces to be checked
          * @param methodName Method name of the method we wish to call
          * @param parameterTypes The parameter type signatures
          */
         private static Method getAccessibleMethodFromInterfaceNest( Class<?> clazz, String methodName,
                                                                     Class<?>... parameterTypes )
         {
             Method method = null;
 
             // Search up the superclass chain
             while ( clazz != null )
             {
                 // Check the implemented interfaces of the parent class
                 for ( Class<?> interfaceType : clazz.getInterfaces() )
                 {
                     // Is this interface public?
                     if ( !isPublic( interfaceType.getModifiers() ) )
                     {
                         continue;
                     }
 
                     // Does the method exist on this interface?
                     try
                     {
                         method = interfaceType.getDeclaredMethod( methodName, parameterTypes );
                     }
                     catch ( NoSuchMethodException e )
                     {
                         /*
                          * Swallow, if no method is found after the loop then this method returns null.
                          */
                     }
                     if ( method != null )
                     {
                         return method;
                     }
 
                     // Recursively check our parent interfaces
                     method = getAccessibleMethodFromInterfaceNest( interfaceType, methodName, parameterTypes );
                     if ( method != null )
                     {
                         return method;
                     }
                 }
 
                 clazz = clazz.getSuperclass();
             }
 
             // We did not find anything
             return null;
         }
 
     }
 
     /**
      * Represents the key to looking up an AccessibleObject by reflection.
      */
     private static final class AccessibleObjectDescriptor
     {
 
         private final Class<?> type;
 
         private final String methodName;
 
         private final Class<?>[] parameterTypes;
 
         private final boolean exact;
 
         private final int hashCode;
 
         /**
          * The sole constructor.
          *
          * @param type  the class to reflect, must not be null
          * @param methodName  the method name to obtain
          * @param parameterTypes the array of classes representing the parameter types
          * @param exact whether the match has to be exact.
          */
         public AccessibleObjectDescriptor( boolean exact, Class<?> type, String methodName, Class<?>... parameterTypes )
         {
             final int prime = 31;
             int hashCode = 1;
 
             this.exact = exact;
             hashCode = prime * hashCode + ( exact ? 1231 : 1237 );
 
             this.type = type;
             hashCode = prime * hashCode + ( ( type == null ) ? 0 : type.getName().hashCode() );
 
             this.methodName = methodName;
             hashCode = prime * hashCode + ( ( methodName == null ) ? 0 : methodName.hashCode() );
 
             this.parameterTypes = parameterTypes;
             hashCode = prime * hashCode + Arrays.hashCode( parameterTypes );
 
             this.hashCode = hashCode;
         }
 
         @Override
         public int hashCode()
         {
             return hashCode;
         }
 
         @Override
         public boolean equals( Object obj )
         {
             if ( this == obj )
             {
                 return true;
             }
             if ( obj == null )
             {
                 return false;
             }
 
             AccessibleObjectDescriptor other = (AccessibleObjectDescriptor) obj;
 
             if ( type != other.type )
             {
                 return false;
             }
 
             if ( exact != other.exact )
             {
                 return false;
             }
 
             /* methodName can  */
             if ( methodName == null )
             {
                 if ( other.methodName != null )
                 {
                     return false;
                 }
             }
             else if ( !methodName.equals( other.methodName ) )
             {
                 return false;
             }
 
             if ( !Arrays.equals( parameterTypes, other.parameterTypes ) )
             {
                 return false;
             }
 
             return true;
         }
 
     }
 
     private static class MakeAccessiblePrivilegedAction<T extends AccessibleObject>
         implements PrivilegedAction<T>
     {
 
         private final T accessibleObject;
 
         /**
          * hidden constructor, this class cannot be instantiated directly
          */
         private MakeAccessiblePrivilegedAction( T accessibleObject )
         {
             this.accessibleObject = accessibleObject;
         }
 
         /**
          * {@inheritDoc}
          */
         public T run()
         {
             try
             {
                 accessibleObject.setAccessible( true );
             }
             catch ( SecurityException se )
             {
                 /*
                  * Swallow SecurityException TODO: Why?
                  */
             }
             return accessibleObject;
         }
 
     }
 
 }