/*

  * Copyright 2004 Jonathan M. Lehr

  *

  * 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.

  * 

  * MODIFIED BY THE KUALI FOUNDATION

  */

 // begin Kuali Foundation modification

 package org.kuali.rice.kns.web.struts.pojo;

 import java.beans.IntrospectionException;

 import java.beans.PropertyDescriptor;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import org.apache.commons.beanutils.MappedPropertyDescriptor;

 import org.apache.commons.beanutils.NestedNullException;

 import org.apache.commons.beanutils.PropertyUtils;

 import org.apache.commons.beanutils.PropertyUtilsBean;

 import org.apache.commons.collections.FastHashMap;

 import org.apache.log4j.Logger;

 import org.kuali.rice.kns.service.KNSServiceLocator;

 import org.kuali.rice.kns.util.ExternalizableBusinessObjectUtils;

 import org.kuali.rice.kns.util.ObjectUtils;

 import org.kuali.rice.kns.web.format.Formatter;

 /**

  * begin Kuali Foundation modification

  * This class is used to access the properties of a Pojo bean.

  * deleted author tag

  * end Kuali Foundation modification

  */

 // Kuali Foundation modification: class originally SLPropertyUtilsBean

 public class PojoPropertyUtilsBean extends PropertyUtilsBean {

     public static final Logger LOG = Logger.getLogger(PojoPropertyUtilsBean.class.getName());

         // begin Kuali Foundation modification

     public PojoPropertyUtilsBean() {

         super();

     }

     // end Kuali Foundation modification

     public Object getProperty(Object bean, String key) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

         // begin Kuali Foundation modification

         if (!(bean instanceof PojoForm))

             return super.getProperty(bean, key);

         PojoForm form = (PojoForm) bean;

         Map unconvertedValues = form.getUnconvertedValues();

         if (unconvertedValues.containsKey(key))

             return unconvertedValues.get(key);

         Object val = getNestedProperty(bean, key);

         Class type = (val!=null)?val.getClass():null;

         if ( type == null ) {

             try {

                 type = getPropertyType(bean, key);

             } catch ( Exception ex ) {

                 type = String.class;

                 LOG.warn( "Unable to get property type for Class: " + bean.getClass().getName() + "/Property: " + key );

             }

         }

         return (Formatter.isSupportedType(type) ? form.formatValue(val, key, type) : val);

         // end Kuali Foundation modification

     }

         // begin Kuali Foundation modification

     private Map<String,List<Method>> cache = new HashMap<String,List<Method>>();

     private static Map<String,Method> readMethodCache = new HashMap<String, Method>();

     private IntrospectionException introspectionException = new IntrospectionException( "" );

     public Object fastGetNestedProperty(Object obj, String propertyName) throws IntrospectionException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

         //logger.debug("entering fastGetNestedProperty");

         List<Method> methods = (List<Method>) cache.get(propertyName + obj.getClass().getName());

         if (methods == null) {

             methods = new ArrayList<Method>();

             Object currentObj = obj;

             Class<?> currentObjClass = currentObj.getClass();

             for (String currentPropertyName : propertyName.split("\\.") ) {

                 String cacheKey = currentObjClass.getName() + currentPropertyName;

                 Method readMethod = readMethodCache.get( cacheKey );

                 if ( readMethod == null ) {

                         synchronized (readMethodCache) {

                             // if the read method was resolved to an error, repeat the exception

                             // rather than performing the reflection calls below

                             if ( readMethodCache.containsKey(cacheKey) ) {

                                 throw introspectionException;

                             }

                             try {

                                 try {

                                     readMethod = currentObjClass.getMethod("get" + currentPropertyName.substring(0, 1).toUpperCase() + currentPropertyName.substring(1), (Class[])null);

                                 } catch (NoSuchMethodException e) {

                                     readMethod = currentObjClass.getMethod("is" + currentPropertyName.substring(0, 1).toUpperCase() + currentPropertyName.substring(1), (Class[])null);

                                 }

                             } catch ( NoSuchMethodException ex ) {

                                 // cache failures to prevent re-checking of the parameter

                                 readMethodCache.put( cacheKey, null );

                                 throw introspectionException;

         //                        throw new IntrospectionException( currentPropertyName );

         //                        try {

         //                        System.out.println( "using PropertyDescriptor" ); 

         //                        PropertyDescriptor pd = new PropertyDescriptor( currentPropertyName, currentObjClass, "get" + currentPropertyName.substring(0, 1).toUpperCase() + currentPropertyName.substring(1), null );

         //                        readMethod = pd.getReadMethod();

         //                        } catch ( Exception ex2 ) {

         //                            LOG.error( ex2.getMessage() );

         //                        }

         //                        System.out.println( "used PropertyDescriptor to get readMethod for " + currentObjClass.getName() + "." + currentPropertyName + " : " + readMethod );

                                 //LOG.error( "Unable to determine readMethod for " + currentObjClass.getName() + "." + currentPropertyName, ex);

                                 //return null;

                             }

                             readMethodCache.put(cacheKey, readMethod );

                                         }

                 }

                 methods.add(readMethod);

                 currentObj = readMethod.invoke(currentObj, (Object[])null);

                 currentObjClass = currentObj.getClass();

             }

             synchronized (cache) {

                 cache.put(propertyName + obj.getClass().getName(), methods);

                         }

         }

         for ( Method method : methods ) {

             obj = method.invoke(obj, (Object[])null);

         }

         //logger.debug("exiting fastGetNestedProperty");

         return obj;

     }

         // end Kuali Foundation modification

     /**

      * begin Kuali Foundation modification

      * removed comments and @<no space>since javadoc attribute

      * end Kuali Foundation modification

      * @see org.apache.commons.beanutils.PropertyUtilsBean#getNestedProperty(java.lang.Object, java.lang.String)

      */

     public Object getNestedProperty(Object arg0, String arg1) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

                 // begin Kuali Foundation modification

         try {

             try {

                 return fastGetNestedProperty(arg0, arg1);

             }

             catch (Exception e) {

                 return super.getNestedProperty(arg0, arg1);

             }

         }

         catch (NestedNullException e) {

             return "";

         }

         catch (InvocationTargetException e1) {

             return "";

         }

         // removed commented code

         // end Kuali Foundation modification

     }

     // begin Kuali Foundation modification 

     /**

      * begin Kuali Foundation modification

      * Set the value of the (possibly nested) property of the specified name, for the specified bean, with no type conversions.

      *

      * @param bean Bean whose property is to be modified

      * @param name Possibly nested name of the property to be modified

      * @param value Value to which the property is to be set

      *

      * @exception IllegalAccessException if the caller does not have access to the property accessor method

      * @exception IllegalArgumentException if <code>bean</code> or <code>name</code> is null

      * @exception IllegalArgumentException if a nested reference to a property returns null

      * @exception InvocationTargetException if the property accessor method throws an exception

      * @exception NoSuchMethodException if an accessor method for this propety cannot be found

      * end Kuali Foundation modification

      */

     public void setNestedProperty(Object bean, String name, Object value) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

         if (bean == null) {

                 if (LOG.isDebugEnabled()) LOG.debug("No bean specified, name = " + name + ", value = " + value);

                 return;

         }

         if (name == null) {

             throw new IllegalArgumentException("No name specified");

         }

         Object propBean = null;

         int indexOfINDEXED_DELIM = -1;

         int indexOfMAPPED_DELIM = -1;

         while (true) {

             int delim = name.indexOf(PropertyUtils.NESTED_DELIM);

             if (delim < 0) {

                 break;

             }

             String next = name.substring(0, delim);

             indexOfINDEXED_DELIM = next.indexOf(PropertyUtils.INDEXED_DELIM);

             indexOfMAPPED_DELIM = next.indexOf(PropertyUtils.MAPPED_DELIM);

             if (bean instanceof Map) {

                 propBean = ((Map) bean).get(next);

             }

             else if (indexOfMAPPED_DELIM >= 0) {

                 propBean = getMappedProperty(bean, next);

             }

             else if (indexOfINDEXED_DELIM >= 0) {

                 propBean = getIndexedProperty(bean, next);

             }

             else {

                 propBean = getSimpleProperty(bean, next);

             }

             if (ObjectUtils.isNull(propBean)) {

                 Class propertyType = getPropertyType(bean, next);

                 if (propertyType != null) {

                         Object newInstance = ObjectUtils.createNewObjectFromClass(propertyType);

                     setSimpleProperty(bean, next, newInstance);

                     propBean = getSimpleProperty(bean, next);

                 }

             }

             bean = propBean;

             name = name.substring(delim + 1);

         }

         indexOfINDEXED_DELIM = name.indexOf(PropertyUtils.INDEXED_DELIM);

         indexOfMAPPED_DELIM = name.indexOf(PropertyUtils.MAPPED_DELIM);

         if (bean instanceof Map) {

             // check to see if the class has a standard property

             PropertyDescriptor descriptor = getPropertyDescriptor(bean, name);

             if (descriptor == null) {

                 // no - then put the value into the map

                 ((Map) bean).put(name, value);

             }

             else {

                 // yes - use that instead

                 setSimpleProperty(bean, name, value);

             }

         }

         else if (indexOfMAPPED_DELIM >= 0) {

             setMappedProperty(bean, name, value);

         }

         else if (indexOfINDEXED_DELIM >= 0) {

             setIndexedProperty(bean, name, value);

         }

         else {

             setSimpleProperty(bean, name, value);

         }

     }

     // end Kuali Foundation modification

         // begin Kuali Foundation modification

     /**

      * <p>

      * Retrieve the property descriptor for the specified property of the specified bean, or return <code>null</code> if there is

      * no such descriptor. This method resolves indexed and nested property references in the same manner as other methods in this

      * class, except that if the last (or only) name element is indexed, the descriptor for the last resolved property itself is

      * returned.

      * </p>

      *

      * <p>

      * <strong>FIXME </strong>- Does not work with DynaBeans.

      * </p>

      *

      * @param bean Bean for which a property descriptor is requested

      * @param name Possibly indexed and/or nested name of the property for which a property descriptor is requested

      *

      * @exception IllegalAccessException if the caller does not have access to the property accessor method

      * @exception IllegalArgumentException if <code>bean</code> or <code>name</code> is null

      * @exception IllegalArgumentException if a nested reference to a property returns null

      * @exception InvocationTargetException if the property accessor method throws an exception

      * @exception NoSuchMethodException if an accessor method for this propety cannot be found

      */

     public PropertyDescriptor getPropertyDescriptor(Object bean, String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

         if (bean == null) {

                 if (LOG.isDebugEnabled()) LOG.debug("No bean specified, name = " + name);

                 return null;

         }

         if (name == null) {

             throw new IllegalArgumentException("No name specified");

         }

         try {

             // Resolve nested references

             Object propBean = null;

             while (true) {

                 int delim = findNextNestedIndex(name);

                 //int delim = name.indexOf(PropertyUtils.NESTED_DELIM);

                 if (delim < 0) {

                     break;

                 }

                 String next = name.substring(0, delim);

                 int indexOfINDEXED_DELIM = next.indexOf(PropertyUtils.INDEXED_DELIM);

                 int indexOfMAPPED_DELIM = next.indexOf(PropertyUtils.MAPPED_DELIM);

                 if (indexOfMAPPED_DELIM >= 0 && (indexOfINDEXED_DELIM < 0 || indexOfMAPPED_DELIM < indexOfINDEXED_DELIM)) {

                     propBean = getMappedProperty(bean, next);

                 }

                 else {

                     if (indexOfINDEXED_DELIM >= 0) {

                         propBean = getIndexedProperty(bean, next);

                     }

                     else {

                         propBean = getSimpleProperty(bean, next);

                     }

                 }

                 if (ObjectUtils.isNull(propBean)) {

                     Class propertyType = getPropertyType(bean, next);

                     if (propertyType != null) {

                             Object newInstance = ObjectUtils.createNewObjectFromClass(propertyType);

                         setSimpleProperty(bean, next, newInstance);

                         propBean = getSimpleProperty(bean, next);

                     }

                 }

                 bean = propBean;

                 name = name.substring(delim + 1);

             }

             // Remove any subscript from the final name value

             int left = name.indexOf(PropertyUtils.INDEXED_DELIM);

             if (left >= 0) {

                 name = name.substring(0, left);

             }

             left = name.indexOf(PropertyUtils.MAPPED_DELIM);

             if (left >= 0) {

                 name = name.substring(0, left);

             }

             // Look up and return this property from our cache

             // creating and adding it to the cache if not found.

             if ((bean == null) || (name == null)) {

                 return (null);

             }

             PropertyDescriptor descriptors[] = getPropertyDescriptors(bean);

             if (descriptors != null) {

                 for (int i = 0; i < descriptors.length; i++) {

                     if (name.equals(descriptors[i].getName()))

                         return (descriptors[i]);

                 }

             }

             PropertyDescriptor result = null;

             FastHashMap mappedDescriptors = getMappedPropertyDescriptors(bean);

             if (mappedDescriptors == null) {

                 mappedDescriptors = new FastHashMap();

                 mappedDescriptors.setFast(true);

             }

             result = (PropertyDescriptor) mappedDescriptors.get(name);

             if (result == null) {

                 // not found, try to create it

                 try {

                     result = new MappedPropertyDescriptor(name, bean.getClass());

                 }

                 catch (IntrospectionException ie) {

                 }

                 if (result != null) {

                     mappedDescriptors.put(name, result);

                 }

             }

             return result;

         } catch ( RuntimeException ex ) {

             LOG.error( "Unable to get property descriptor for " + bean.getClass().getName() + " . " + name

                     + "\n" + ex.getClass().getName() + ": " + ex.getMessage() );

             throw ex;

         }

     }

     // end Kuali Foundation modification

     private int findNextNestedIndex(String expression)

     {

         // walk back from the end to the start

         // and find the first index that

         int bracketCount = 0;

         for (int i=0, size=expression.length(); i<size ; i++) {

             char at = expression.charAt(i);

             switch (at) {

                 case PropertyUtils.NESTED_DELIM:

                     if (bracketCount < 1) {

                         return i;

                     }

                     break;

                 case PropertyUtils.MAPPED_DELIM:

                 case PropertyUtils.INDEXED_DELIM:

                     // not bothered which

                     ++bracketCount;

                     break;

                 case PropertyUtils.MAPPED_DELIM2:

                 case PropertyUtils.INDEXED_DELIM2:

                     // not bothered which

                     --bracketCount;

                     break;

             }

         }

         // can't find any

         return -1;

     }

     /**

      * Set the value of the specified simple property of the specified bean,

      * with no type conversions.

      *

      * @param bean Bean whose property is to be modified

      * @param name Name of the property to be modified

      * @param value Value to which the property should be set

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception IllegalArgumentException if <code>bean</code> or

      *  <code>name</code> is null

      * @exception IllegalArgumentException if the property name is

      *  nested or indexed

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public void setSimpleProperty(Object bean,

                                          String name, Object value)

             throws IllegalAccessException, InvocationTargetException,

             NoSuchMethodException {

         if (bean == null) {

                 if (LOG.isDebugEnabled()) LOG.debug("No bean specified, name = " + name + ", value = " + value);

                 return;

         }

         if (name == null) {

             throw new IllegalArgumentException("No name specified");

         }

         // Validate the syntax of the property name

         if (name.indexOf(PropertyUtils.NESTED_DELIM) >= 0) {

             throw new IllegalArgumentException

                     ("Nested property names are not allowed");

         } else if (name.indexOf(PropertyUtils.INDEXED_DELIM) >= 0) {

             throw new IllegalArgumentException

                     ("Indexed property names are not allowed");

         } else if (name.indexOf(PropertyUtils.MAPPED_DELIM) >= 0) {

             throw new IllegalArgumentException

                     ("Mapped property names are not allowed");

         }

         // Retrieve the property setter method for the specified property

         PropertyDescriptor descriptor =

                 getPropertyDescriptor(bean, name);

         if (descriptor == null) {

             throw new NoSuchMethodException("Unknown property '" +

                     name + "'");

         }

         Method writeMethod = getWriteMethod(descriptor);

         if (writeMethod == null) {

             //throw new NoSuchMethodException("Property '" + name + "' has no setter method");

                 LOG.warn("Bean: " + bean.getClass().getName() + ", Property '" + name + "' has no setter method");

                 return;

         }

         // Call the property setter method

         Object values[] = new Object[1];

         values[0] = value;

         if (LOG.isDebugEnabled()) {

             String valueClassName =

                 value == null ? "<null>" : value.getClass().getName();

             LOG.debug("setSimpleProperty: Invoking method " + writeMethod

                       + " with value " + value + " (class " + valueClassName + ")");

         }

         invokeMethod(writeMethod, bean, values);

     }

     /** This just catches and wraps IllegalArgumentException. */

     private Object invokeMethod(

                         Method method, 

                         Object bean, 

                         Object[] values) 

                             throws

                                 IllegalAccessException,

                                 InvocationTargetException {

         try {

             return method.invoke(bean, values);

         } catch (IllegalArgumentException e) {

             LOG.error("Method invocation failed.", e);

             throw new IllegalArgumentException(

                 "Cannot invoke " + method.getDeclaringClass().getName() + "." 

                 + method.getName() + " - " + e.getMessage());

         }

     }

 }