package org.andromda.core.common;
   
   import java.beans.IntrospectionException;
   import java.beans.PropertyDescriptor;
   import java.lang.reflect.Method;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.Map;
   import java.util.regex.Pattern;
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.lang.exception.ExceptionUtils;
  import org.apache.log4j.Logger;
  
  /**
   * A simple class providing the ability to manipulate properties on java bean objects.
   *
   * @author Chad Brandon
   * @author Bob Fields
   */
  public final class Introspector
  {
      /**
       * The shared instance.
       */
      private static Introspector instance = null;
  
      /**
       * Gets the shared instance.
       *
       * @return the shared introspector instance.
       */
      public static Introspector instance()
      {
          if (instance == null)
          {
              instance = new Introspector();
          }
          return instance;
      }
  
      /**
       * The logger instance.
       */
      private static final Logger logger = Logger.getLogger(Introspector.class);
  
      /**
       * <p> Indicates whether or not the given <code>object</code> contains a
       * valid property with the given <code>name</code> and <code>value</code>.
       * </p>
       * <p>
       * A valid property means the following:
       * <ul>
       * <li>It exists on the object</li>
       * <li>It is not null on the object</li>
       * <li>If its a boolean value, then it evaluates to <code>true</code></li>
       * <li>If value is not null, then the property matches the given </code>.value</code></li>
       * </ul>
       * All other possibilities return <code>false</code>
       * </p>
       *
       * @param object the object to test for the valid property.
       * @param name the name of the property for which to test.
       * @param value the value to evaluate against.
       * @return true/false
       */
      public boolean containsValidProperty(
          final Object object,
          final String name,
          final String value)
      {
          boolean valid;
  
          try
          {
              final Object propertyValue = this.getProperty(
                      object,
                      name);
              valid = propertyValue != null;
  
              // if valid is still true, and the propertyValue
              // is not null
              if (valid)
              {
                  // if it's a collection then we check to see if the
                  // collection is not empty
                  if (propertyValue instanceof Collection)
                  {
                      valid = !((Collection)propertyValue).isEmpty();
                  }
                  else
                  {
                      final String valueAsString = String.valueOf(propertyValue);
                      if (StringUtils.isNotBlank(value))
                      {
                          valid = valueAsString.equals(value);
                      }
                      else if (propertyValue instanceof Boolean)
                      {
                          valid = Boolean.valueOf(valueAsString);
                     }
                 }
             }
         }
         catch (final Throwable throwable)
         {
             valid = false;
         }
         return valid;
     }
 
     /**
      * Sets the property having the given <code>name</code> on the <code>object</code>
      * with the given <code>value</code>.
      *
      * @param object the object on which to set the property.
      * @param name the name of the property to populate.
      * @param value the value to give the property.
      */
     public void setProperty(
         final Object object,
         final String name,
         final Object value)
     {
         this.setNestedProperty(
             object,
             name,
             value);
     }
 
     /**
      * The delimiter used for separating nested properties.
      */
     private static final char NESTED_DELIMITER = '.';
 
     /**
      * Attempts to set the nested property with the given
      * name of the given object.
      * @param object the object on which to populate the property.
      * @param name the name of the object.
      * @param value the value to populate.
      */
     private void setNestedProperty(
         final Object object,
         String name,
         final Object value)
     {
         if (object != null && StringUtils.isNotBlank(name))
         {
             final int dotIndex = name.indexOf(NESTED_DELIMITER);
             if (dotIndex >= name.length())
             {
                 throw new IntrospectorException("Invalid property call --> '" + name + '\'');
             }
             String[] names = name.split("\\" + NESTED_DELIMITER);
             Object objectToPopulate = object;
             for (int ctr = 0; ctr < names.length; ctr++)
             {
                 name = names[ctr];
                 if (ctr == names.length - 1)
                 {
                     break;
                 }
                 objectToPopulate = this.internalGetProperty(
                         objectToPopulate,
                         name);
             }
             this.internalSetProperty(
                 objectToPopulate,
                 name,
                 value);
         }
     }
 
     /**
      * Attempts to retrieve the property with the given <code>name</code> on the <code>object</code>.
      *
      * @param object the object to which the property belongs.
      * @param name the name of the property
      * @return the value of the property.
      */
     public final Object getProperty(
         final Object object,
         final String name)
     {
         Object result;
 
         try
         {
             result = this.getNestedProperty(
                     object,
                     name);
         }
         catch (final NullPointerException ex)
         {
             return "null";
         }
         catch (final StackOverflowError ex)
         {
             return "StackOverflowError";
         }
         catch (final IntrospectorException throwable)
         {
             // Don't catch our own exceptions.
             // Otherwise get Exception/Cause chain which
             // can hide the original exception.
             throw throwable;
         }
         catch (Throwable throwable)
         {
             throwable = ExceptionUtils.getRootCause(throwable);
 
             // If cause is an IntrospectorException re-throw that exception
             // rather than creating a new one.
             if (throwable instanceof IntrospectorException)
             {
                 throw (IntrospectorException)throwable;
             }
             throw new IntrospectorException(throwable);
         }
         return result;
     }
 
     /**
      * Gets a nested property, that is it gets the properties
      * separated by '.'.
      *
      * @param object the object from which to retrieve the nested property.
      * @param name the name of the property
      * @return the property value or null if one couldn't be retrieved.
      */
     private Object getNestedProperty(
         final Object object,
         final String name)
     {
         Object property = null;
         if (object != null && StringUtils.isNotBlank(name))
         {
             int dotIndex = name.indexOf(NESTED_DELIMITER);
             if (dotIndex == -1)
             {
                 property = this.internalGetProperty(
                         object,
                         name);
             }
             else
             {
                 if (dotIndex >= name.length())
                 {
                     throw new IntrospectorException("Invalid property call --> '" + name + '\'');
                 }
                 final Object nextInstance = this.internalGetProperty(
                         object,
                         name.substring(
                             0,
                             dotIndex));
                 property = getNestedProperty(
                         nextInstance,
                         name.substring(dotIndex + 1));
             }
         }
         return property;
     }
 
     /**
      * Cache for a class's write methods.
      */
     private final Map<Class, Map<String, Method>> writeMethodsCache = new HashMap<Class, Map<String, Method>>();
 
     /**
      * Gets the writable method for the property.
      *
      * @param object the object from which to retrieve the property method.
      * @param name the name of the property.
      * @return the property method or null if one wasn't found.
      */
     private Method getWriteMethod(
         final Object object,
         final String name)
     {
         Method writeMethod = null;
         final Class objectClass = object.getClass();
         Map<String, Method> classWriteMethods = this.writeMethodsCache.get(objectClass);
         if (classWriteMethods == null)
         {
             classWriteMethods = new HashMap<String, Method>();
         }
         else
         {
             writeMethod = classWriteMethods.get(name);
         }
         if (writeMethod == null)
         {
             final PropertyDescriptor descriptor = this.getPropertyDescriptor(
                     object.getClass(),
                     name);
             writeMethod = descriptor != null ? descriptor.getWriteMethod() : null;
             if (writeMethod != null)
             {
                 classWriteMethods.put(
                     name,
                     writeMethod);
                 this.writeMethodsCache.put(
                     objectClass,
                     classWriteMethods);
             }
         }
         return writeMethod;
     }
 
     /**
      * Indicates if the <code>object</code> has a property that
      * is <em>readable</em> with the given <code>name</code>.
      *
      * @param object the object to check.
      * @param name the property to check for.
      * @return this.getReadMethod(object, name) != null
      */
     public boolean isReadable(
         final Object object,
         final String name)
     {
         return this.getReadMethod(
             object,
             name) != null;
     }
 
     /**
      * Indicates if the <code>object</code> has a property that
      * is <em>writable</em> with the given <code>name</code>.
      *
      * @param object the object to check.
      * @param name the property to check for.
      * @return this.getWriteMethod(object, name) != null
      */
     public boolean isWritable(
         final Object object,
         final String name)
     {
         return this.getWriteMethod(
             object,
             name) != null;
     }
 
     /**
      * Cache for a class's read methods.
      */
     private final Map<Class, Map<String, Method>> readMethodsCache = new HashMap<Class, Map<String, Method>>();
 
     /**
      * Gets the readable method for the property.
      *
      * @param object the object from which to retrieve the property method.
      * @param name the name of the property.
      * @return the property method or null if one wasn't found.
      */
     private Method getReadMethod(
         final Object object,
         final String name)
     {
         Method readMethod = null;
         final Class objectClass = object.getClass();
         Map<String, Method> classReadMethods = this.readMethodsCache.get(objectClass);
         if (classReadMethods == null)
         {
             classReadMethods = new HashMap<String, Method>();
         }
         else
         {
             readMethod = classReadMethods.get(name);
         }
         if (readMethod == null)
         {
             final PropertyDescriptor descriptor = this.getPropertyDescriptor(
                     object.getClass(),
                     name);
             readMethod = descriptor != null ? descriptor.getReadMethod() : null;
             if (readMethod != null)
             {
                 classReadMethods.put(
                     name,
                     readMethod);
                 this.readMethodsCache.put(
                     objectClass,
                     classReadMethods);
             }
         }
         return readMethod;
     }
 
     /**
      * The cache of property descriptors.
      */
     private final Map<Class, Map<String, PropertyDescriptor>> propertyDescriptorsCache = new HashMap<Class, Map<String, PropertyDescriptor>>();
 
     /**
      * The pattern for property names.
      */
     private Pattern propertyNamePattern = Pattern.compile("\\p{Lower}\\p{Upper}.*");
 
     /**
      * Retrieves the property descriptor for the given type and name of
      * the property.
      *
      * @param type the Class of which we'll attempt to retrieve the property
      * @param name the name of the property.
      * @return the found property descriptor
      */
     private PropertyDescriptor getPropertyDescriptor(
         final Class type,
         final String name)
     {
         PropertyDescriptor propertyDescriptor = null;
         Map<String, PropertyDescriptor> classPropertyDescriptors = this.propertyDescriptorsCache.get(type);
         if (classPropertyDescriptors == null)
         {
             classPropertyDescriptors = new HashMap<String, PropertyDescriptor>();
         }
         else
         {
             propertyDescriptor = classPropertyDescriptors.get(name);
         }
 
         if (propertyDescriptor == null)
         {
             try
             {
                 final PropertyDescriptor[] descriptors =
                     java.beans.Introspector.getBeanInfo(type).getPropertyDescriptors();
                 final int descriptorNumber = descriptors.length;
                 for (int ctr = 0; ctr < descriptorNumber; ctr++)
                 {
                     final PropertyDescriptor descriptor = descriptors[ctr];
 
                     // - handle names that start with a lowercased letter and have an uppercase as the second letter
                     final String compareName =
                         propertyNamePattern.matcher(name).matches() ? StringUtils.capitalize(name) : name;
                     if (descriptor.getName().equals(compareName))
                     {
                         propertyDescriptor = descriptor;
                         break;
                     }
                 }
                 if (propertyDescriptor == null && name.indexOf(NESTED_DELIMITER) != -1)
                 {
                     int dotIndex = name.indexOf(NESTED_DELIMITER);
                     if (dotIndex >= name.length())
                     {
                         throw new IntrospectorException("Invalid property call --> '" + name + '\'');
                     }
                     final PropertyDescriptor nextInstance =
                         this.getPropertyDescriptor(
                             type,
                             name.substring(
                                 0,
                                 dotIndex));
                     propertyDescriptor =
                         this.getPropertyDescriptor(
                             nextInstance.getPropertyType(),
                             name.substring(dotIndex + 1));
                 }
             }
             catch (final IntrospectionException exception)
             {
                 throw new IntrospectorException(exception);
             }
             classPropertyDescriptors.put(
                 name,
                 propertyDescriptor);
             this.propertyDescriptorsCache.put(
                 type,
                 classPropertyDescriptors);
         }
         return propertyDescriptor;
     }
 
     /**
      * Prevents stack-over-flows by storing the objects that
      * are currently being evaluated within {@link #internalGetProperty(Object, String)}.
      */
     private final Map<Object, String> evaluatingObjects = new HashMap<Object, String>();
 
     /**
      * Attempts to get the value of the property with <code>name</code> on the
      * given <code>object</code> (throws an exception if the property
      * is not readable on the object).
      *
      * @param object the object from which to retrieve the property.
      * @param name the name of the property
      * @return the resulting property value
      */
     private Object internalGetProperty(
         final Object object,
         final String name)
     {
         Object property = null;
 
         // - prevent stack overflows by checking to make sure
         //   we aren't entering any circular evaluations
         final Object value = this.evaluatingObjects.get(object);
         if (value == null || !value.equals(name))
         {
             this.evaluatingObjects.put(
                 object,
                 name);
             if (object != null || StringUtils.isNotBlank(name))
             {
                 final Method method = this.getReadMethod(
                         object,
                         name);
                 if (method == null)
                 {
                     throw new IntrospectorException("No readable property named '" + name + "', exists on object '" +
                         object + '\'');
                 }
                 try
                 {
                     property = method.invoke(
                             object,
                             (Object[])null);
                 }
                 catch (Throwable throwable)
                 {
                     if (throwable.getCause()!=null)
                     {
                         throwable = throwable.getCause();
                     }
                     // At least output the location where the error happened, not the entire stack trace.
                     StackTraceElement[] trace = throwable.getStackTrace();
                     String location = " AT " + trace[0].getClassName() + '.' + trace[0].getMethodName() + ':' + trace[0].getLineNumber();
                     if (throwable.getMessage()!=null)
                     {
                         location += ' ' + throwable.getMessage();
                     }
                     logger.error("Introspector " + throwable + " invoking " + object + " METHOD " + method + " WITH " + name + location);
                     // Unrecoverable errors may result in infinite loop, in particular StackOverflowError
                     if (throwable instanceof Exception)
                     {
                         throw new IntrospectorException(throwable);
                     }
                 }
             }
             this.evaluatingObjects.remove(object);
         }
         return property;
     }
 
     /**
      * Attempts to sets the value of the property with <code>name</code> on the
      * given <code>object</code> (throws an exception if the property
      * is not writable on the object).
      *
      * @param object the object from which to retrieve the property.
      * @param name the name of the property to set.
      * @param value the value of the property to set.
      */
     private void internalSetProperty(
         final Object object,
         final String name,
         Object value)
     {
         if (object != null || (StringUtils.isNotBlank(name)))
         {
             Class expectedType = null;
             if (value != null && object != null)
             {
                 final PropertyDescriptor descriptor = this.getPropertyDescriptor(
                         object.getClass(),
                         name);
                 if (descriptor != null)
                 {
                     expectedType = this.getPropertyDescriptor(
                             object.getClass(),
                             name).getPropertyType();
                     value = Converter.convert(
                             value,
                             expectedType);
                 }
             }
             final Method method = this.getWriteMethod(
                     object,
                     name);
             if (method == null)
             {
                 throw new IntrospectorException("No writeable property named '" + name + "', exists on object '" +
                     object + '\'');
             }
             try
             {
                 method.invoke(
                     object,
                     value);
             }
             catch (final Throwable throwable)
             {
                 throw new IntrospectorException(throwable);
             }
         }
     }
 
     /**
      * Shuts this instance down and reclaims
      * any resources used by this instance.
      */
     public void shutdown()
     {
         this.propertyDescriptorsCache.clear();
         this.writeMethodsCache.clear();
         this.readMethodsCache.clear();
         this.evaluatingObjects.clear();
         Introspector.instance = null;
     }
 
     /**
      * @see java.lang.Object#toString()
      */
     @Override
     public String toString()
     {
         StringBuilder builder = new StringBuilder();
         builder.append(super.toString()).append(" [writeMethodsCache=").append(this.writeMethodsCache)
                 .append(", readMethodsCache=").append(this.readMethodsCache)
                 .append(", propertyDescriptorsCache=").append(this.propertyDescriptorsCache)
                 .append(", propertyNamePattern=").append(this.propertyNamePattern)
                 .append(", evaluatingObjects=").append(this.evaluatingObjects).append("]");
         return builder.toString();
     }
 }