/*
    * 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.format;
  // end Kuali Foundation modification
  
  import java.io.Serializable;
  import java.lang.reflect.Array;
  import java.math.BigDecimal;
  import java.sql.Date;
  import java.sql.Timestamp;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.servlet.http.HttpServletRequest;
  
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.commons.lang.StringUtils;
  import org.kuali.rice.kns.util.AbstractKualiDecimal;
  import org.kuali.rice.kns.util.KualiDecimal;
  import org.kuali.rice.kns.util.KualiInteger;
  import org.kuali.rice.kns.util.KualiPercent;
  import org.kuali.rice.kns.web.struts.pojo.ArrayUtils;
  
  
  // begin Kuali Foundation modification
  /**
   * This is the base class for all other Formatters.
   */
  /**
   * It provides default formatting and conversion behavior for most value types, including primitives, arrays, and instances of most
   * {@link Collection}types. <code>Formatter</code> and its subclasses were designed primarily to be used by web app framework
   * components, though they can also be used in other contexts.
   * <p>
   * During request processing, the {@link PojoActionForm}uses <code>Formatter</code> instances to convert inbound request values
   * to JavaBean property types. Whenever a given value cannot be converted to its target type, the conversion method
   * {@link PropertyUtils#getProperty(Object, String)}throws a {@link FormatException}to signal this condition to the
   * calling code.
   * <p>
   * During the response phase, Struts tags make calls to the {@link PojoRequestProcessor}in order to access bean property values.
   * The <code>PojoRequestProcessor</code> then uses <code>Formatter</code> instances to format the bean values for presentation
   * in the user interface.
   * <p>
   * In either case, <code>Formatter</code> instances are obtained by calling {@link #getFormatter(Class)}, which looks in an
   * internal registry to determine which <code>Formatter</code> class to instantiate, and returns a new instance. The StrutsLive
   * framework includes a number of <code>Formatter</code> classes that are registered statically; additional
   * <code>Formatter classes can be registered at compile
   * time or at run time. 
   * <p>
   * Subclasses of <code>Formatter</code> typically override the callback methods
   * {@link #convertToObject(String)} and {@link #formatObject(Object)}, which
   * otherwise provide default conversion and formmating behavior needed for
   * atomic values (i.e., an ordinary bean property such as a <code>String</code>
   * or <code>Integer</code>, or else an element of a property typed as
   * array or Collection).
   * 
   * @see PojoActionForm#populate(HttpServletRequest)
   * @see PojoPropertyUtilsBean#getProperty(Object, String)
   */
  // end Kuali Foundation modification
  public class Formatter implements Serializable {
  	// begin Kuali Foundation modification
  	// removed serialVersionUID and logger members
  	// end Kuali Foundation modification
  	
      static final String CREATE_MSG = "Couldn't create an instance of class ";
      // begin Kuali Foundation modification
      // registry changed from AppLocal instance to a Map
      private static Map registry = Collections.synchronizedMap(new HashMap());
      // end Kuali Foundation modification
      
      protected Map settings;
      
      // begin Kuali Foundation modification
      // removed keypath and rootObject variables
      // end Kuali Foundation modification
      
      protected Class propertyType;
  
      static { 
     	// begin Kuali Foundation modification
         registerFormatter(String.class, Formatter.class);
         registerFormatter(String[].class, Formatter.class);
         registerFormatter(AbstractKualiDecimal.class, BigDecimalFormatter.class);
         registerFormatter(KualiDecimal.class, CurrencyFormatter.class); 
         registerFormatter(KualiInteger.class, KualiIntegerCurrencyFormatter.class);
         registerFormatter(KualiPercent.class, PercentageFormatter.class);
         registerFormatter(BigDecimal.class, BigDecimalFormatter.class);
         registerFormatter(Date.class, DateFormatter.class);
         registerFormatter(Integer.class, IntegerFormatter.class);
         registerFormatter(int.class, IntegerFormatter.class);
         registerFormatter(int[].class, IntegerFormatter.class);
         registerFormatter(Boolean.class, BooleanFormatter.class);
         registerFormatter(Boolean.TYPE, BooleanFormatter.class);
         registerFormatter(boolean[].class, BooleanFormatter.class);
         registerFormatter(Long.class, LongFormatter.class);
         registerFormatter(Timestamp.class, DateViewTimestampObjectFormatter.class);
         registerFormatter(boolean.class, LittleBooleanFormatter.class);
         registerFormatter(Collection.class, ArrayFormatter.class);
         // end Kuali Foundation modification
     }
 
     public static Formatter getFormatter(Class aType) {
         return getFormatter(aType, null);
     }
 
     // begin Kuali Foundation modification
     // param aType was valueType, comment changes, major code changes
     /**
      * Returns an instance of the Formatter class to be used to format the provided value type.
      * 
      * @param type the class of the value to be formatted
      * @param settings parameters used by subclasses to customize behavior
      * @return an instance of Formatter or one of its subclasses
      */
     public static Formatter getFormatter(Class aType, Map settings) {
     	// original code: return createFormatter(formatterForType(valueType), valueType, settings);
 			
         Class type = formatterForType(aType);
         Formatter formatter = null;
         try {
             formatter = (Formatter) type.newInstance();
         }
         catch (InstantiationException e) {
             throw new FormatException(CREATE_MSG + type, e);
         }
         catch (IllegalAccessException e) {
             throw new FormatException(CREATE_MSG + type, e);
         }
 
         if (settings != null)
             formatter.setSettings(Collections.unmodifiableMap(settings));
         formatter.propertyType = aType;
 
         return formatter;
     }
 
     // removed getFormatterByName, formatterClassForName, createFormatter methods
     // end Kuali Foundation modification
 
     /**
      * Binds the provided value type to a Formatter type. Note that a single Formatter class can be associated with more than one
      * type.
      * 
      * @param type a value type
      * @param formatterType a Formatter type
      */
     public static void registerFormatter(Class type, Class formatterType) {
         registry.put(type, formatterType);
     }
 
     /**
      * Returns <code>true</code> if the provided class is an array type, implements either the {@link List}or {@link Set}
      * interfaces, or is one of the Formatter classes currently registered.
      * 
      * @see registerFormatter(Class, Class)
      */
     public static boolean isSupportedType(Class type) {
         // begin Kuali Foundation modification
         if (type == null)
             return false;
         // end Kuali Foundation modification
         if (List.class.isAssignableFrom(type))
             return true;
         if (Set.class.isAssignableFrom(type))
             return true;
 
         return findFormatter(type) != null;
     }
 
     /**
      * Return the Formatter associated with the given type, by consulting an internal registry. Additional associations can be made
      * by calling {@link registerFormatter(Class, Class)}.
      * 
      * @return a new Formatter instance
      */
     public static Class formatterForType(Class type) {
         if (type == null)
             throw new IllegalArgumentException("Type can not be null");
 
         Class formatterType = findFormatter(type);
 
         return formatterType == null ? Formatter.class : formatterType;
     }
 
 	// Kuali Foundation modification: comment removed
     public static Class findFormatter(Class type) {
     	// begin Kuali Foundation modification
         if (type == null)
             return null;
 
         if (registry.containsKey(type)) {
             return (Class) registry.get(type);
         }
 
 
         Iterator typeIter = registry.keySet().iterator();
         while (typeIter.hasNext()) {
             Class currType = (Class) typeIter.next();
             if (currType.isAssignableFrom(type)) {
                 Class currFormatter = (Class) registry.get(currType);
                 registerFormatter(type, currFormatter);
                 return currFormatter;
             }
         }
 
         return null;
         // end Kuali Foundation modification
     }
 
 	// begin Kuali Foundation modification
     public String getImplementationClass() {
         return this.getClass().getName();
     }
     // end Kuali Foundation modification
 
     public Class getPropertyType() {
         return propertyType;
     }
 
     public void setPropertyType(Class propertyType) {
         this.propertyType = propertyType;
     }
 
     public Map getSettings() {
         return settings;
     }
 
     public void setSettings(Map settings) {
         this.settings = settings;
     }
 
 	// begin Kuali Foundation modification
 	// removed getKeypath, setKeyPath, getRootObject, setRootObject, hasSettingForKey, settingForKey, typeForKey, getErrorKey
 	// end Kuali Foundation modification
 	
     /**
      * begin Kuali Foundation modification
      * Returns a String representation of the given value. May be overridden by subclasses to provide customized behavior for
      * different types, though generally the callback method {@link #format(Object)}provides a better customization hook.
      * <p>
      * Provides default handling for properties typed as array or Collection. Subclass implementations of this method must invoke
      * <code>super.formatForPresentation()</code> to take advantage of this built-in behavior.
      * <p>
      * Delegates to callback method {@link formatObject}for all other types. This method in turn invokes the callback method
      * <code>format</code>, which serves as an extension point for subclasses; the default implementation simply returns its
      * argument. Overriding <code>format</code> allows subclasses to take advantage of all of the array, primitive type, and
      * Collection handling functionality provided by the base class.
      * 
      * @param value the object to be formatted
      * @return a formatted string representation of the given object
      * @see #formatObject(Object)
      * end Kuali Foundation modification
      */
     public Object formatForPresentation(Object value) {
         if (isNullValue(value))
             return formatNull();
 
 		// begin Kuali Foundation modification
 		// removed code
 		/*
 	    // TODO: add registry for non-navigable classes so there's a way to
         // disable formatting selectively for given types contained in arrays
         // or Collections.
         if (Collection.class.isAssignableFrom(value.getClass()))
             return formatCollection((Collection) value);
         
         if (propertyType != null && propertyType.isArray())
             return formatArray(value);
 		*/
 		// end Kuali Foundation modification
 		
         return formatObject(value);
     }
 
     /**
      * May be overridden by subclasses to provide special handling for <code>null</code> values when formatting a bean property
      * value for presentation. The default implementation simply returns <code>null</code>
      */
     protected Object formatNull() {
         return null;
     }
 
     /**
      * May be overridden by subclasses to provide custom formatting behavior. Provides default formatting implementation for
      * primitive types. (Note that primitive types are will always be wrapped in an array in order to be passed as an argument of
      * type <code>Object</code>).
      */
     public Object formatObject(Object value) {
         if (value == null)
             return formatNull();
 
         // Collections and arrays have already been handled at this point, so
         // if value is an array, assume it's a wrapper for a primitive type.
         Class type = value.getClass();
         if (type.isArray())
         	// begin Kuali Foundation modification
             return ArrayUtils.toString(value, type.getComponentType());
             // end begin Kuali Foundation modification
 
         if (!(isSupportedType(value.getClass())))
             // begin Kuali Foundation modification
             formatBean(value);
             // end Kuali Foundation modification
 
         return format(value);
     }
 
     /**
      * If an element of the Collection isn't a supported type, assume it's a JavaBean, and format each of its properties. Returns a
      * Map containing the formatted properties keyed by property name.
      */
     protected Object formatBean(Object bean) {
         Map properties = null;
         try {
         	// begin Kuali Foundation modification
             properties = PropertyUtils.describe(bean);
             // end Kuali Foundation modification
         }
         catch (Exception e) {
             throw new FormatException("Unable to format values for bean " + bean, e);
         }
 
         Map formattedVals = new HashMap();
         // begin Kuali Foundation modification
         Iterator propIter = properties.entrySet().iterator();
 
         while (propIter.hasNext()) {
             Map.Entry entry = (Map.Entry) propIter.next();
             Object value = entry.getValue();
             if (value != null && isSupportedType(value.getClass())) {
                 Formatter formatter = getFormatter(value.getClass());
                 formattedVals.put(entry.getKey(), formatter.formatForPresentation(value));
             }
         }
         // end Kuali Foundation modification
         return formattedVals;
     }
 
     public Object format(Object value) {
         return value;
     }
 
     public Object formatArray(Object value) {
     	// begin Kuali Foundation modification
         Class elementType = value.getClass().getComponentType();
         if (!isSupportedType(elementType))
             return value;
 
         int length = Array.getLength(value);
         Object[] formattedVals = new String[length];
 
         for (int i = 0; i < length; i++) {
             Object element = Array.get(value, i);
             Object objValue = ArrayUtils.toObject(element);
             Formatter elementFormatter = getFormatter(elementType);
             formattedVals[i] = elementFormatter.formatForPresentation(objValue);
         }
 
         return formattedVals;
         // end Kuali Foundation modification
     }
 
     public Object formatCollection(Collection value) {
         List stringVals = new ArrayList();
         Iterator iter = value.iterator();
         while (iter.hasNext()) {
             Object obj = iter.next();
             Formatter formatter = getFormatter(obj.getClass());
             // begin Kuali Foundation modification
             stringVals.add(formatter.formatForPresentation(obj));
             // end Kuali Foundation modification
         }
         return stringVals.toArray();
     }
 
     /**
      * Returns an object representation of the provided string after first removing any extraneous formatting characters. If the
      * argument is a native array wrapping the actual value, the value is removed (unwrapped) from the array prior to invoking the
      * callback method {@link #convertToObject(String)}, which performs the actual conversion.
      * <p>
      * If the provided object is <code>null</code>, a blank <code>String</code>, or a <code>String[]</code> of length <b>0
      * </b> or that has <code>null</code> or a blank <code>String</code> in the first position, returns <code>null</code>.
      * Otherwise, If the destination property is a <code>Collection</code>, returns an instance of that type containing the
      * string values of the array elements.
      * <p>
      * If the provided object is an array, uses a Formatter corresponding to the array's component type to convert each of its
      * elements, and returns a new array containing the converted values.
      * 
      * May be overidden by subclasses to customize conversion, though ordinarily {@link #convertToObject(String)}is a better choice
      * since it takes advantage of <code>convertFromPresentationFormat</code>'s built-in behavior.
      * 
      * @param value the string value to be converted
      * @return the object value corresponding to the provided string value
      * @see convertToObject(String)
      */
     public Object convertFromPresentationFormat(Object value) {
         if (isEmptyValue(value))
             return getNullObjectValue();
 
         Class type = value.getClass();
         boolean isArray = propertyType != null && propertyType.isArray();
         boolean isCollection = propertyType != null && Collection.class.isAssignableFrom(propertyType);
 
         if (!(isArray || isCollection)) {
             value = unwrapString(value);
             return convertToObject((String) value);
         }
 
         String[] strings = type.isArray() ? (String[]) value : new String[] { (String) value };
 
         return isArray ? convertToArray(strings) : convertToCollection(strings);
     }
 
     /**
      * May be overridden by subclasses to provide special handling for <code>null</code> values when converting from presentation
      * format to a bean property type. The default implementation simply returns <code>null</code>
      */
     protected Object getNullObjectValue() {
         return null;
     }
 
     /**
      * May be orverridden by subclasses to customize its behavior. The default implementation simply trims and returns the provided
      * string.
      */
     protected Object convertToObject(String string) {
         return string == null ? null : string.replace( "\r\n", "\n" ).trim();        
     }
 
     /**
      * Converts an array of strings to a Collection type corresponding to the value of <code>propertyType</code>. Since we don't
      * have type information for the elements of the collection, no attempt is made to convert the elements from <code>String</code>
      * to other types. However, subclasses can override this method if they need to provide the ability to convert the elements to a
      * given type.
      */
     protected Collection convertToCollection(String[] strings) {
         Collection collection = null;
         Class type = propertyType;
 
         if (propertyType.isAssignableFrom(List.class))
             type = ArrayList.class;
         else if (propertyType.isAssignableFrom(Set.class))
             type = HashSet.class;
 
         try {
             collection = (Collection) type.newInstance();
         }
         catch (Exception e) {
             throw new FormatException(CREATE_MSG + propertyType, e);
         }
 
         for (int i = 0; i < strings.length; i++)
             collection.add(strings[i]);
 
         return collection;
     }
 
     /**
      * Converts an array of strings to an array of objects by calling {@link #convertToObject(String)}on each element of the
      * provided array in turn, using instances of a Formatter class that corresponds to this Formatter's property type.
      * 
      * @see #propertyType
      */
     protected Object convertToArray(String[] strings) {
         Class type = propertyType.getComponentType();
         // begin Kuali Foundation modification
         Formatter formatter = getFormatter(type);
         // end Kuali Foundation modification
         Object array = null;
         try {
             array = Array.newInstance(type, strings.length);
         }
         catch (Exception e) {
             throw new FormatException(CREATE_MSG + type, e);
         }
 
         for (int i = 0; i < strings.length; i++) {
             Object value = formatter.convertToObject(strings[i]);
             // begin Kuali Foundation modification
             ArrayUtils.setArrayValue(array, type, value, i);
             // end Kuali Foundation modification
         }
 
         return array;
     }
 
     public static String unwrapString(Object target) {
 
         if (target.getClass().isArray()) {
             String wrapper[] = (String[]) target;
             return wrapper.length > 0 ? wrapper[0] : null;
         }
 		// begin Kuali Foundation modification
         // if target object is null, return a null String
         else if (target == null) {
             return new String();
         }
 
         // otherwise, return the string value of the object, with the hope
         // that the toString() has been meaningfully overriden
         else {
             return target.toString();
         }
         // end Kuali Foundation modification
     }
 
     public static boolean isNullValue(Object obj) {
         if (obj == null)
             return true;
 
 		// begin Kuali Foundation modification
         if ((obj instanceof String) && StringUtils.isEmpty((String) obj))
             return true;
         // end Kuali Foundation modification
 
         return false;
     }
 
     public static boolean isEmptyValue(Object obj) {
         if (obj == null)
             return true;
         // begin Kuali Foundation modification
         if ((obj instanceof String) && StringUtils.isEmpty((String) obj))
             return true;
         // end Kuali Foundation modification
         Class type = obj.getClass();
         if (type.isArray()) {
             Class compType = type.getComponentType();
             if (compType.isPrimitive())
                 return false;
             if (((Object[]) obj).length == 0)
                 return true;
             if (((Object[]) obj)[0] == null)
                 return true;
             if (String.class.isAssignableFrom(compType)) {
             	// begin Kuali Foundation modification
                 return StringUtils.isEmpty(((String[]) obj)[0]);
                 // end Kuali Foundation modification
             }
         }
         return false;
     }
 
     protected String trimString(Object target) {
         String stringValue = null;
         try {
             stringValue = (String) target;
         }
         catch (ClassCastException e) {
             throw new FormatException("Can't cast " + target + " to String", e);
         }
         return stringValue == null ? null : stringValue.trim();
     }
 
     /**
      * @deprecated in favor of {@link StringUtils#isEmptyString(String)}
      */
     protected boolean isBlank(String string) {
         return string == null || string.trim().length() == 0;
     }
 }