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.beans.Introspector.getBeanInfo;
  
  import java.beans.BeanInfo;
  import java.beans.IndexedPropertyDescriptor;
  import java.beans.IntrospectionException;
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.WeakHashMap;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  /**
   *
   */
  final class PropertyDescriptorsRegistry
  {
  
      private static final PropertyDescriptorsRegistry INSTANCE = new PropertyDescriptorsRegistry();
  
      public static PropertyDescriptorsRegistry getInstance()
      {
          return INSTANCE;
      }
  
      private final AccessibleObjectsRegistry<Method> methodsRegistry = AccessibleObjectsRegistry.getMethodsRegistry();
  
      private final Map<Class<?>, Map<String, PropertyDescriptor>> cache =
          new WeakHashMap<Class<?>, Map<String, PropertyDescriptor>>();
  
      /**
       * This class can not be instantiated.
       */
      private PropertyDescriptorsRegistry()
      {
          // do nothing
      }
  
      public Map<String, PropertyDescriptor> getPropertiesIndex( Class<?> beanType )
          throws IntrospectionException
      {
          final Lock lock = new ReentrantLock();
          lock.lock();
          try
          {
              Map<String, PropertyDescriptor> propertiesIndex = cache.get( beanType );
              if ( propertiesIndex != null )
              {
                  return propertiesIndex;
              }
  
              propertiesIndex = new HashMap<String, PropertyDescriptor>();
              BeanInfo beanInfo = getBeanInfo( beanType );
  
              List<PropertyDescriptor> propertyDescriptors =
                  new ArrayList<PropertyDescriptor>( Arrays.asList( beanInfo.getPropertyDescriptors() ) );
              propertyDescriptors.addAll( getMappedPropertyDescriptors( beanType ) );
              for ( PropertyDescriptor propertyDescriptor : propertyDescriptors )
              {
                  makeMethodsAccessible( beanType, propertyDescriptor );
                  propertiesIndex.put( propertyDescriptor.getName(), propertyDescriptor );
              }
  
              cache.put( beanType, propertiesIndex );
  
              return propertiesIndex;
          }
          finally
          {
              lock.unlock();
          }
      }
  
     private Collection<PropertyDescriptor> getMappedPropertyDescriptors( Class<?> beanType )
         throws IntrospectionException
     {
         Map<String, PropertyDescriptor> mappedPropertyDescirptors = new HashMap<String, PropertyDescriptor>();
         for ( Method method : beanType.getMethods() )
         {
             if ( MethodUtils.isMappedGetter( method ) || MethodUtils.isMappedSetter( method ) )
             {
                 String propertyName = method.getName().substring( 3 );
                 propertyName = Character.toLowerCase( propertyName.charAt( 0 ) ) + propertyName.substring( 1 );
                 if ( !mappedPropertyDescirptors.containsKey( propertyName ) )
                 {
                     mappedPropertyDescirptors.put( propertyName, new MappedPropertyDescriptor( propertyName, beanType ) );
                 }
             }
         }
         return mappedPropertyDescirptors.values();
     }
 
     private void makeMethodsAccessible( Class<?> beanType, PropertyDescriptor propertyDescriptor )
         throws IntrospectionException
     {
         // we need to make sure that methods are accessible for anonymous types
         // see https://issues.apache.org/jira/browse/BEANUTILS-157
         if ( propertyDescriptor.getReadMethod() != null )
         {
             Method readMethod = propertyDescriptor.getReadMethod();
             readMethod = methodsRegistry.get( true, beanType, readMethod.getName() );
             propertyDescriptor.setReadMethod( readMethod );
         }
         if ( propertyDescriptor.getWriteMethod() != null )
         {
             Method writeMethod = propertyDescriptor.getWriteMethod();
             writeMethod = methodsRegistry.get( true, beanType, writeMethod.getName(), writeMethod.getParameterTypes() );
             propertyDescriptor.setWriteMethod( writeMethod );
         }
 
         // indexed property
 
         if ( propertyDescriptor instanceof IndexedPropertyDescriptor )
         {
             IndexedPropertyDescriptor indexedPropertyDescriptor = (IndexedPropertyDescriptor) propertyDescriptor;
 
             if ( indexedPropertyDescriptor.getIndexedReadMethod() != null )
             {
                 Method indexedReadMethod = indexedPropertyDescriptor.getIndexedReadMethod();
                 indexedReadMethod = methodsRegistry.get( true,
                                                          beanType,
                                                          indexedReadMethod.getName(),
                                                          indexedReadMethod.getParameterTypes() );
                 indexedPropertyDescriptor.setIndexedReadMethod( indexedReadMethod );
             }
             if ( indexedPropertyDescriptor.getIndexedWriteMethod() != null )
             {
                 Method indexedWriteMethod = indexedPropertyDescriptor.getIndexedWriteMethod();
                 indexedWriteMethod = methodsRegistry.get( true,
                                                           beanType,
                                                           indexedWriteMethod.getName(),
                                                           indexedWriteMethod.getParameterTypes() );
                 indexedPropertyDescriptor.setIndexedWriteMethod( indexedWriteMethod );
             }
         }
     }
 
     public PropertyDescriptor getPropertyDescriptor( Class<?> beanType, String propertyName )
         throws IntrospectionException
     {
         Map<String, PropertyDescriptor> propertiesIndex = getPropertiesIndex( beanType );
         return propertiesIndex.get( propertyName );
     }
 
 }