/*
    * Copyright 2002-2004 The Apache Software Foundation
    *
    * 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 org.apache.commons.clazz.reflect;
  
  import java.beans.BeanInfo;
  import java.beans.IndexedPropertyDescriptor;
  import java.beans.Introspector;
  import java.beans.PropertyDescriptor;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.clazz.Clazz;
  import org.apache.commons.clazz.ClazzInstanceFactory;
  import org.apache.commons.clazz.ClazzLoader;
  import org.apache.commons.clazz.ClazzOperation;
  import org.apache.commons.clazz.ClazzProperty;
  import org.apache.commons.clazz.reflect.common.ReflectedListProperty;
  import org.apache.commons.clazz.reflect.common.ReflectedScalarProperty;
  
  /**
   * This implementation of Clazz is based on Java reflection. 
   * 
   * @author <a href="mailto:dmitri@apache.org">Dmitri Plotnikov</a>
   * @version $Id: ReflectedClazz.java 155436 2005-02-26 13:17:48Z dirkv $
   */
  public abstract class ReflectedClazz extends Clazz {
  
      private Class instanceClass;
      private boolean superClazzKnown;
      private Clazz superClazz;
  
      /**
       * This map includes all properties, declared and inherited
       */
      private Map propertyMap;
      private List propertyList;
      private List declaredPropertyList;
  
      /**
       * This map includes all operations, declared and inherited
       */
      private Map operationMap;
      private List operationList;
      private List declaredOperationList;
  
      /**
       * This map includes all factories
       */
      private Map factoryMap;
      private List factoryList;
      
      private boolean hasLookedForBeanInfo = false;
      private BeanInfo beanInfo;
  
      /**
       * 
       * @param loader
       * @param instanceClass
       */
      public ReflectedClazz(ClazzLoader loader, Class instanceClass) {
          super(loader, getCanonicalClassName(instanceClass));
          this.instanceClass = instanceClass;
      }
  
      public Class getInstanceClass() {
          return instanceClass;
      }
  
      /**
       * The order of introspectors is significant, they are invoked sequencially.
       * Once a property has been recoginzed by an introspector, it will not be
       * overridden by subsequently invoked ones.
       */
      protected abstract ReflectedPropertyIntrospector[] 
              getPropertyIntrospectors();
  
      /**
       * @see #getPropertyIntrospectors()
       */
      protected abstract ReflectedOperationIntrospector[] 
              getOperationIntrospectors();
  
     /**
      * @see #getPropertyIntrospectors()
      */
     protected abstract ReflectedInstanceFactoryIntrospector[] 
             getInstanceFactoryIntrospectors();
 
     /**
      * Returns true if diagnostic is enabled for this clazz
      */
     public boolean isLoggingEnabled() {
         return getClazzLoader().isLoggingEnabled(getName());
     }
 
     /**
      * Returns the class this ReflectedClazz is based upon.
      * @return Class
      */
     public Class getReflectedClass() {
         return instanceClass;
     }
 
     /**
      * @see Clazz#getSuperclazz()
      */
     public Clazz getSuperclazz() {
         if (!superClazzKnown) {
             superClazzKnown = true;
             Class superclass = instanceClass.getSuperclass();
             if (superclass == null) {
                 superClazz = null;
             }
             else {
                 superClazz =
                     getClazzLoader().getClazzForName(superclass.getName());
             }
         }
         return superClazz;
     }
 
     /**
      * Returns properties introduced by this clazz as compared 
      * to the superclazz.  Note, that some of the methods comprizing
      * a property may be declared on the superclass. This makes it
      * impossible to build a list of declared properties by looking
      * exclusively at the current class - we have to reflected all
      * properties of this clazz, then all properties of the superclazz
      * and then subtract the latter from the former.
      */
     public List getDeclaredProperties() {
         if (declaredPropertyList == null) {
             if (instanceClass.getSuperclass() == null) {
                 declaredPropertyList = getProperties();
             }
             else {
                 List superProperties = getSuperclazz().getProperties();
                 if (superProperties.size() == 0) {
                     declaredPropertyList = getProperties();
                 }
                 else {
                     HashSet superNames = new HashSet();
                     for (int i = 0; i < superProperties.size(); i++) {
                         ClazzProperty property =
                             (ClazzProperty) superProperties.get(i);
                         superNames.add(property.getName());
                     }
 
                     List properties = getProperties();
                     declaredPropertyList = new ArrayList();
                     for (int i = 0; i < properties.size(); i++) {
                         ClazzProperty property =
                             (ClazzProperty) properties.get(i);
                         String name = property.getName();
                         if (!superNames.contains(name)) {
                             declaredPropertyList.add(property);
                         }
                     }
                 }
             }
         }
         return declaredPropertyList;
     }
 
     /**
      */
     public List getProperties() {
         if (propertyList == null) {
             introspectProperties();
             if (isLoggingEnabled()) {
                 logPropertyParseResults();
             }
         }
         return propertyList;
     }
 
     /**
      */
     public ClazzProperty getProperty(String name) {
         if (propertyMap == null) {
             introspectProperties();
             if (isLoggingEnabled()) {
                 logPropertyParseResults();
             }
         }
         return (ClazzProperty) propertyMap.get(name);
     }
 
     protected void addProperty(ClazzProperty property) {
         propertyMap.put(property.getName(), property);
         if (property instanceof ReflectedProperty) {
             String[] aliases = ((ReflectedProperty) property).getAliases();
             for (int i = 0; i < aliases.length; i++) {
                 propertyMap.put(aliases[i], property);
             }
         }
         propertyList.add(property);
     }
 
     /**
      */
     public List getOperations() {
         if (operationList == null) {
             introspectOperations();
 //          if (isLoggingEnabled()) {
 //              logOperationParseResults();
 //          }
         }
         return operationList;
     }
 
     /**
      * @see Clazz#getDeclaredOperations()
      */
     public List getDeclaredOperations() {
         if (declaredOperationList == null) {
             introspectOperations();
 //          if (isLoggingEnabled()) {
 //              logOperationParseResults();
 //          }
         }
         return declaredOperationList;
     }
 
     /**
      * @see Clazz#getOperation(java.lang.String)
      */
     public ClazzOperation getOperation(String signature) {
         if (operationMap == null) {
             introspectOperations();
 //          if (isLoggingEnabled()) {
 //              logOperationParseResults();
 //          }
         }
         return (ClazzOperation) operationMap.get(signature);
     }
 
     protected void addOperation(ClazzOperation operation) {
         operationMap.put(operation.getSignature(), operation);
         declaredOperationList.add(operation);
     }
 
     /**
      * Returns all InstanceFactories for this clazz.
      */
     public List getInstanceFactories() {
         if (factoryList == null) {
             introspectInstanceFactories();
 //          if (isLoggingEnabled()) {
 //              logInstanceFactoryParseResults();
 //          }
         }
         return factoryList;
     }
 
     /**
      * Returns the InstanceFactories that match the Predicate.
      */
     //    public List getInstanceFactories(Predicate predicate);
 
     /**
      * @see org.apache.commons.clazz.Clazz#getInstanceFactory(java.lang.String)
      */
     public ClazzInstanceFactory getInstanceFactory(String signature) {
         if (factoryMap == null) {
             introspectInstanceFactories();
 //          if (isLoggingEnabled()) {
 //              logInstanceFactoryParseResults();
 //          }
         }
         if (signature == null) {
             signature = "()";
         }
         return (ClazzInstanceFactory) factoryMap.get(signature);
     }
 
     protected void addInstanceFactory(ClazzInstanceFactory factory) {
         factoryMap.put(factory.getSignature(), factory);
         factoryList.add(factory);
     }
 
     /**
      * Overrides the default implementation, checks if the supplied clazz is
      * also a ReflectedClazz and if so invokes isAssignableFrom on the
      * corresponding java classes.
      */
     public boolean isAssignableFrom(Clazz clazz) {
         if (clazz == this) {
             return true;
         }
         if (clazz instanceof ReflectedClazz) {
             return getReflectedClass().isAssignableFrom(
                 ((ReflectedClazz) clazz).getReflectedClass());
         }
         return super.isAssignableFrom(clazz);
     }
 
     /**
      * Override this method to provide an alternate way of mapping
      * fields and methods to properties.
      */
     protected void introspectProperties() {
         propertyList = new ArrayList();
         propertyMap = new HashMap();
 
         BeanInfo beanInfo = getBeanInfo();
         
         if (beanInfo != null) {
             PropertyDescriptor pds[] = beanInfo.getPropertyDescriptors();
             if (pds != null) {
                 for (int i = 0; i < pds.length; i++) {
                     PropertyDescriptor pd = pds[i];
                     if (pd instanceof IndexedPropertyDescriptor) {
                         IndexedPropertyDescriptor ipd =
                             (IndexedPropertyDescriptor) pd;
                         ReflectedListProperty prop =
                             new ReflectedListProperty(this, ipd.getName());
                         prop.setType(ipd.getPropertyType());
                         prop.setContentType(ipd.getIndexedPropertyType());
                         prop.setReadMethod(ipd.getReadMethod());
                         prop.setWriteMethod(ipd.getWriteMethod());
                         prop.setGetMethod(ipd.getIndexedReadMethod());
                         prop.setSetMethod(ipd.getIndexedWriteMethod());
                         addProperty(prop);
                     }
                     else {
                         ReflectedScalarProperty prop =
                             new ReflectedScalarProperty(this, pd.getName());
                         prop.setType(pd.getPropertyType());
                         prop.setReadMethod(pd.getReadMethod());
                         prop.setWriteMethod(pd.getWriteMethod());
                         addProperty(prop);
                     }
                 }
             }
         }
         else {
             ReflectedPropertyIntrospector introspectors[] =
                 getPropertyIntrospectors();
     
             if (introspectors != null) {
                 for (int i = 0; i < introspectors.length; i++) {
                     List properties =
                         introspectors[i].introspectProperties(
                             this,
                             instanceClass);
                     for (int j = 0; j < properties.size(); j++) {
                         ClazzProperty property =
                             (ClazzProperty) properties.get(j);
                         addProperty(property);
                     }
                 }
             }
         }
     }
     
     /**
      * Performs BeanInfo lookup in the same manner as the standard
      * java.beans.Introspector.
      */
     protected BeanInfo getBeanInfo() {
         if (!hasLookedForBeanInfo) {
             hasLookedForBeanInfo = true;            
             beanInfo = lookupBeanInfo();
         }
         return beanInfo;
     }
 
     /**
      * Search for a custom implementation of BeanInfo according to
      * the JavaBeans standard definition.
      */
     private BeanInfo lookupBeanInfo() {
         ClassLoader classLoader = instanceClass.getClassLoader();
         
         String name = instanceClass.getName() + "BeanInfo";
         try {
             return (BeanInfo) instantiate(classLoader, name);
         }
         catch (Exception ex) {
             // Just drop through
         }
         
         // Now try checking if the bean is its own BeanInfo.
         try {
             if (BeanInfo.class.isAssignableFrom(instanceClass)) {
                 return (BeanInfo) instanceClass.newInstance();
             }
         }
         catch (Exception ex) {
             // Just drop through
         }
         
         // Now try looking for <searchPath>.fooBeanInfo
         while (name.indexOf('.') > 0) {
             name = name.substring(name.indexOf('.') + 1);
         }
         
         String[] searchPath = Introspector.getBeanInfoSearchPath();
         for (int i = 0; i < searchPath.length; i++) {
             try {
                 String fullName = searchPath[i] + "." + name;
                 return (BeanInfo) instantiate(classLoader, fullName);
             }
             catch (Exception ex) {
                 // Silently ignore any errors.
             }
         }
         return null;
     }
     
     static Object instantiate(ClassLoader classLoader, String className)
         throws
             InstantiationException,
             IllegalAccessException,
             ClassNotFoundException 
     {
         if (classLoader != null) {
             try {
                 Class cls = classLoader.loadClass(className);
                 return cls.newInstance();
             }
             catch (Exception ex) {
                 // Just drop through and try the system classloader.
             }
         }
         
         // Now try the default classloader.
         Class cls = Class.forName(className);
         return cls.newInstance();
     }
 
     /**
      * Override this method to provide an alternate way of mapping
      * methods (and possibly fields) to Operations.
      */
     protected void introspectOperations() {
         declaredOperationList = new ArrayList();
         operationMap = new HashMap();
         operationList = new ArrayList();
 
         Clazz superClazz = getSuperclazz();
         if (superClazz != null) {
             List superOps = superClazz.getOperations();
             for (int i = 0; i < superOps.size(); i++) {
                 ClazzOperation operation = (ClazzOperation) superOps.get(i);
                 operationMap.put(operation.getSignature(), operation);
             }
         }
 
         ReflectedOperationIntrospector introspectors[] =
             getOperationIntrospectors();
 
         if (introspectors != null) {
             for (int i = 0; i < introspectors.length; i++) {
                 List operations =
                     introspectors[i].introspectOperations(this, instanceClass);
                 for (int j = 0; j < operations.size(); j++) {
                     ClazzOperation operation =
                         (ClazzOperation) operations.get(j);
                     addOperation(operation);
                 }
             }
         }
         operationList.addAll(operationMap.values());
     }
 
     /**
      * Override this method to provide an alternate way of mapping
      * constructors, methods (and possibly fields) to InstanceFactories.
      */
     protected void introspectInstanceFactories() {
         factoryMap = new HashMap();
         factoryList = new ArrayList();
 
         ReflectedInstanceFactoryIntrospector introspectors[] =
             getInstanceFactoryIntrospectors();
 
         if (introspectors != null) {
             for (int i = 0; i < introspectors.length; i++) {
                 List factories =
                     introspectors[i].introspectInstanceFactories(
                         this,
                         instanceClass);
                 for (int j = 0; j < factories.size(); j++) {
                     ClazzInstanceFactory factory =
                         (ClazzInstanceFactory) factories.get(j);
                     addInstanceFactory(factory);
                 }
             }
         }
     }
 
     private List propertyParseResults;
 
     /**
      * Called by ReflectedPropertyIntrospector's to log results of
      * introspection, successful or not.
      */
     public void logPropertyParseResults(Object parseResults) {
         if (propertyParseResults == null) {
             propertyParseResults = new ArrayList();
         }
         propertyParseResults.add(parseResults);
     }
 
     /**
      * Prints diagnostics of property introspection.
      */
     protected void logPropertyParseResults() {
         if (propertyParseResults == null) {
             return;
         }
 
         // PropertyParseResults are supposed to implement Comparable
         Collections.sort(propertyParseResults);
 
         // @todo: use a logger
         System.err.println("[Clazz: " + getName());
         for (int i = 0; i < propertyParseResults.size(); i++) {
             System.err.println(propertyParseResults.get(i));
         }
         System.err.println("]");
     }
 }