/*
    * 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.
   */
  package org.apache.commons.el;
  
  import java.beans.BeanInfo;
  import java.beans.EventSetDescriptor;
  import java.beans.IndexedPropertyDescriptor;
  import java.beans.IntrospectionException;
  import java.beans.Introspector;
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.Method;
  import java.lang.reflect.Modifier;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.servlet.jsp.el.ELException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   *
   * <p>Manages the BeanInfo for one class - contains the BeanInfo, and
   * also a mapping from property name to BeanInfoProperty.  There are
   * also static methods for accessing the BeanInfoManager for a class -
   * those mappings are cached permanently so that once the
   * BeanInfoManager is calculated, it doesn't have to be calculated
   * again.
   * 
   * @author Nathan Abramson - Art Technology Group
   * @version $Change: 181181 $$DateTime: 2001/06/26 09:55:09 $$Author: bayard $
   **/
  
  public class BeanInfoManager
  {
      //-------------------------------------
      // Constants
      //-------------------------------------
      private static Log log = LogFactory.getLog(BeanInfoManager.class);
      
    //-------------------------------------
    // Properties
    //-------------------------------------
    // property beanClass
  
    Class mBeanClass;
    public Class getBeanClass ()
    { return mBeanClass; }
  
    //-------------------------------------
    // Member variables
    //-------------------------------------
  
    // The BeanInfo
    BeanInfo mBeanInfo;
  
    // Mapping from property name to BeanInfoProperty
    Map mPropertyByName;
  
    // Mapping from property name to BeanInfoIndexedProperty
    Map mIndexedPropertyByName;
  
    // Mapping from event set name to event set descriptor
    Map mEventSetByName;
  
    // Flag if this is initialized
    boolean mInitialized;
  
    // The global mapping from class to BeanInfoManager
    static Map mBeanInfoManagerByClass = new HashMap ();
  
    //-------------------------------------
    /**
     *
     * Constructor
     **/
    BeanInfoManager (Class pBeanClass)
    {
      mBeanClass = pBeanClass;
    }
  
    //-------------------------------------
    /**
     *
     * Returns the BeanInfoManager for the specified class
    **/
   public static BeanInfoManager getBeanInfoManager (Class pClass)
   {
     BeanInfoManager ret = (BeanInfoManager) 
       mBeanInfoManagerByClass.get (pClass);
     if (ret == null) {
       ret = createBeanInfoManager (pClass);
     }
     return ret;
   }
 
   //-------------------------------------
   /**
    *
    * Creates and registers the BeanInfoManager for the given class if
    * it isn't already registered.
    **/
   static synchronized BeanInfoManager createBeanInfoManager (Class pClass)
   {
     // Because this method is synchronized statically, the
     // BeanInfoManager is not initialized at this time (otherwise it
     // could end up being a bottleneck for the entire system).  It is
     // put into the map in an uninitialized state.  The first time
     // someone tries to use it, it will be initialized (with proper
     // synchronizations in place to make sure it is only initialized
     // once).
 
     BeanInfoManager ret = (BeanInfoManager) 
       mBeanInfoManagerByClass.get (pClass);
     if (ret == null) {
       ret = new BeanInfoManager (pClass);
       mBeanInfoManagerByClass.put (pClass, ret);
     }
     return ret;
   }
 
   //-------------------------------------
   /**
    *
    * Returns the BeanInfoProperty for the specified property in the
    * given class, or null if not found.
    **/
   public static BeanInfoProperty getBeanInfoProperty
     (Class pClass,
      String pPropertyName)
     throws ELException
   {
     return getBeanInfoManager (pClass).getProperty (pPropertyName);
   }
 
   //-------------------------------------
   /**
    *
    * Returns the BeanInfoIndexedProperty for the specified property in
    * the given class, or null if not found.
    **/
   public static BeanInfoIndexedProperty getBeanInfoIndexedProperty
     (Class pClass,
      String pIndexedPropertyName)
     throws ELException
   {
     return getBeanInfoManager 
       (pClass).getIndexedProperty (pIndexedPropertyName);
   }
 
   //-------------------------------------
   /**
    *
    * Makes sure that this class has been initialized, and synchronizes
    * the initialization if it's required.
    **/
   void checkInitialized ()
     throws ELException
   {
     if (!mInitialized) {
       synchronized (this) {
 	if (!mInitialized) {
 	  initialize();
 	  mInitialized = true;
 	}
       }
     }
   }
 
   //-------------------------------------
   /**
    *
    * Initializes by mapping property names to BeanInfoProperties
    **/
   void initialize ()
     throws ELException
   {
     try {
       mBeanInfo = Introspector.getBeanInfo (mBeanClass);
 
       mPropertyByName = new HashMap ();
       mIndexedPropertyByName = new HashMap ();
       PropertyDescriptor [] pds = mBeanInfo.getPropertyDescriptors ();
       for (int i = 0; pds != null && i < pds.length; i++) {
 	// Treat as both an indexed property and a normal property
 	PropertyDescriptor pd = pds [i];
 	if (pd instanceof IndexedPropertyDescriptor) {
 	  IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
 	  Method readMethod = getPublicMethod (ipd.getIndexedReadMethod ());
 	  Method writeMethod = getPublicMethod (ipd.getIndexedWriteMethod ());
 	  BeanInfoIndexedProperty property = new BeanInfoIndexedProperty
 	    (readMethod,
 	     writeMethod,
 	     ipd);
 
 	  mIndexedPropertyByName.put (ipd.getName (), property);
 	}
 
 	Method readMethod = getPublicMethod (pd.getReadMethod ());
 	Method writeMethod = getPublicMethod (pd.getWriteMethod ());
 	BeanInfoProperty property = new BeanInfoProperty
 	  (readMethod,
 	   writeMethod,
 	   pd);
 
 	mPropertyByName.put (pd.getName (), property);
       }
 
       mEventSetByName = new HashMap ();
       EventSetDescriptor [] esds = mBeanInfo.getEventSetDescriptors ();
       for (int i = 0; esds != null && i < esds.length; i++) {
 	EventSetDescriptor esd = esds [i];
 	mEventSetByName.put (esd.getName (), esd);
       }
     }
     catch (IntrospectionException exc) {
         if (log.isWarnEnabled()) {
             log.warn(
                 MessageUtil.getMessageWithArgs(
                     Constants.EXCEPTION_GETTING_BEANINFO, mBeanClass.getName()), exc);
         }     
     }
   }
 
   //-------------------------------------
   /**
    *
    * Returns the BeanInfo for the class
    **/
   BeanInfo getBeanInfo ()
     throws ELException
   {
     checkInitialized();
     return mBeanInfo;
   }
 
   //-------------------------------------
   /**
    *
    * Returns the BeanInfoProperty for the given property name, or null
    * if not found.
    **/
   public BeanInfoProperty getProperty (String pPropertyName)
     throws ELException
   {
     checkInitialized();
     return (BeanInfoProperty) mPropertyByName.get (pPropertyName);
   }
 
   //-------------------------------------
   /**
    *
    * Returns the BeanInfoIndexedProperty for the given property name,
    * or null if not found.
    **/
   public BeanInfoIndexedProperty getIndexedProperty 
     (String pIndexedPropertyName)
     throws ELException
   {
     checkInitialized();
     return (BeanInfoIndexedProperty) 
       mIndexedPropertyByName.get (pIndexedPropertyName);
   }
 
   //-------------------------------------
   /**
    *
    * Returns the EventSetDescriptor for the given event set name, or
    * null if not found.
    **/
   public EventSetDescriptor getEventSet (String pEventSetName)
     throws ELException
   {
     checkInitialized();
     return (EventSetDescriptor) mEventSetByName.get (pEventSetName);
   }
 
   //-------------------------------------
   // Finding the public version of a method - if a PropertyDescriptor
   // is obtained for a non-public class that implements a public
   // interface, the read/write methods will be for the class, and
   // therefore inaccessible.  To correct this, a version of the same
   // method must be found in a superclass or interface.
   //-------------------------------------
   /**
    *
    * Returns a publicly-accessible version of the given method, by
    * searching for a public declaring class.
    **/
   static Method getPublicMethod (Method pMethod)
   {
     if (pMethod == null) {
       return null;
     }
 
     // See if the method is already available from a public class
     Class cl = pMethod.getDeclaringClass ();
     if (Modifier.isPublic (cl.getModifiers ())) {
       return pMethod;
     }
 
     // Otherwise, try to find a public class that declares the method
     Method ret = getPublicMethod (cl, pMethod);
     if (ret != null) {
       return ret;
     }
     else {
       return pMethod;
     }
   }
 
   //-------------------------------------
   /**
    *
    * If the given class is public and has a Method that declares the
    * same name and arguments as the given method, then that method is
    * returned.  Otherwise the superclass and interfaces are searched
    * recursively.
    **/
   static Method getPublicMethod (Class pClass,
 				 Method pMethod)
   {
     // See if this is a public class declaring the method
     if (Modifier.isPublic (pClass.getModifiers ())) {
       try {
         Method m;
         try {
 	  m = pClass.getDeclaredMethod (pMethod.getName (),
 					     pMethod.getParameterTypes ());
         } catch (java.security.AccessControlException ex) {
 	  // kludge to accommodate J2EE RI's default settings
 	  // TODO: see if we can simply replace
           //       getDeclaredMethod() with getMethod() ...?
           m = pClass.getMethod(pMethod.getName (),
                                              pMethod.getParameterTypes ());
         }
 	if (Modifier.isPublic (m.getModifiers ())) {
 	  return m;
 	}
       }
       catch (NoSuchMethodException exc) {}
     }
 
     // Search the interfaces
     {
       Class [] interfaces = pClass.getInterfaces ();
       if (interfaces != null) {
 	for (int i = 0; i < interfaces.length; i++) {
 	  Method m = getPublicMethod (interfaces [i], pMethod);
 	  if (m != null) {
 	    return m;
 	  }
 	}
       }
     }
 
     // Search the superclass
     {
       Class superclass = pClass.getSuperclass ();
       if (superclass != null) {
 	Method m = getPublicMethod (superclass, pMethod);
 	if (m != null) {
 	  return m;
 	}
       }
     }
 
     return null;
   }
 
   //-------------------------------------
 }