/*
    * Copyright 2007-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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 de.smartics.exceptions.i18n.message;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.text.ChoiceFormat;
  import java.text.MessageFormat;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.MissingResourceException;
  import java.util.ResourceBundle;
  
  import ognl.OgnlContext;
  import ognl.OgnlException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import de.smartics.exceptions.i18n.ConfigurationException;
  import de.smartics.exceptions.i18n.MessageComposer;
  import de.smartics.exceptions.i18n.MethodAccessConfigurationException;
  import de.smartics.exceptions.i18n.PropertyAccessConfigurationException;
  import de.smartics.exceptions.i18n.app.ConfigurationExceptionCode;
  import de.smartics.exceptions.i18n.message.MessageParamParser.MessageParamInfo;
  import de.smartics.exceptions.ognl.OgnlExpression;
  
  /**
   * The message composer creates messages from message templates by replacing the
   * place holders with localized parameter values.
   * <p>
   * The message composer is an utility class to be instantiated without internal
   * state.
   * </p>
   *
   * @deprecated Use {@link IcuMessageComposer}. Will be removed with version 1.0.
   *             To switch to this version please reformat your compound messages,
   *             using <a href=
   *             "http://icu-project.org/apiref/icu4j/com/ibm/icu/text/MessageFormat.html"
   *             >ICU MessageFormat</a>.
   */
  @Deprecated
  public class DefaultMessageComposer implements MessageComposer
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private final Log log = LogFactory.getLog(DefaultMessageComposer.class);
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     */
    public DefaultMessageComposer()
    {
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    @Override
    public String composeMessage(final Object exception, final Locale locale,
        final ResourceBundle bundle, final String keyPrefix,
        final MessageType messageType)
    {
      if (messageType == null)
      {
        throw new NullPointerException(
           "Message type to compose a message must not be 'null'.");
     }
 
     final String key = messageType.createKey(keyPrefix);
     final String messageTemplate = bundle.getString(key);
 
     final byte maxIndex = MessageTemplateAnalyser.maxIndex(messageTemplate);
     if (maxIndex > -1)
     {
       final Object[] messageArguments = new Object[maxIndex + 1];
 
       final MessageFormat formatter =
           new MessageFormat(messageTemplate, locale);
       Class<?> currentClass = exception.getClass();
       do
       {
         supplyParentPropertyValues(exception, key, bundle, formatter,
             messageType, messageArguments);
 
         final Field[] declaredFields = currentClass.getDeclaredFields();
         supplyPropertyValues(exception, key, bundle, formatter, messageType,
             messageArguments, declaredFields);
 
         final Method[] declaredMethods = currentClass.getDeclaredMethods();
         supplyPropertyValues(exception, key, bundle, formatter, messageType,
             messageArguments, declaredMethods);
 
         currentClass = currentClass.getSuperclass();
       }
       while (currentClass != null && currentClass != Exception.class
              && !isAllInformationProvided(messageArguments));
 
       replaceMissingInformationDefaults(messageArguments);
 
       final String output = formatter.format(messageArguments);
       return output;
     }
     else
     {
       return messageTemplate;
     }
   }
 
   /**
    * Adds the information provided at class level for the properties of the
    * parent exception.
    *
    * @param exception the exception to supply parent information.
    * @param key the key to the message template for compound messages.
    * @param bundle the bundle to access for compound messages.
    * @param formatter the formatter to configure for compound messages.
    * @param messageType the message type to supply information for.
    * @param messageArguments the message arguments to add information to.
    */
   private void supplyParentPropertyValues(final Object exception,
       final String key, final ResourceBundle bundle,
       final MessageFormat formatter, final MessageType messageType,
       final Object[] messageArguments)
   {
     final Class<?> clazz = exception.getClass();
     final ParentMessageParam annotation =
         clazz.getAnnotation(ParentMessageParam.class);
     if (annotation != null)
     {
       final Map<String, List<MessageParamInfo>> map =
           messageType.getParentMessageParamInfos(annotation);
       for (final Map.Entry<String, List<MessageParamInfo>> entry : map
           .entrySet())
       {
         final String attribute = entry.getKey(); // NOPMD
         final List<MessageParamInfo> infos = entry.getValue();
 
         for (final MessageParamInfo info : infos)
         {
           final int index = Integer.parseInt(info.getPlaceholderId());
           if (index < messageArguments.length)
           {
             Object value = getProperty(exception, attribute);
             if (value != null)
             {
               value = applyOgnl(exception, attribute, info, value);
               applyCompoundMessageInfo(exception, key, bundle, formatter,
                   attribute, index);
               messageArguments[index] = value;
             }
           }
         }
       }
     }
   }
 
   /**
    * This helper checks the OGNL and compound message annotation attribute and
    * applies the information (if found) to the value and the formatter
    * configuration.
    *
    * @param exception the exception instance whose attributes are in question.
    * @param attribute the name of the attribute to fetch.
    * @param info the message info to fetch further information (OGNL path
    *          value).
    * @param value the current value used as a base for the OGNL path.
    * @return the new value with OGNL path applied or the old value if no OGNL
    *         information is provided.
    * @throws PropertyAccessConfigurationException on any property configuration
    *           problem.
    */
   private Object applyOgnl(final Object exception, final String attribute,
       final MessageParamInfo info, final Object value)
     throws PropertyAccessConfigurationException
   {
     final Object newValue;
     final String ognlPath = info.getOgnlPath();
     if (ognlPath != null)
     {
       newValue = evaluateOgnl(exception, attribute, value, ognlPath);
     }
     else
     {
       newValue = value;
     }
 
     return newValue;
   }
 
   /**
    * This helper checks compound message context and applies the information (if
    * found) to the formatter configuration.
    *
    * @param exception the exception instance whose attributes are in question.
    * @param key the key of the message resource for compound messages.
    * @param bundle the bundle for compound messages.
    * @param formatter the formatter to set the format for compound messages.
    * @param attribute the name of the attribute to fetch.
    * @param index the index of the place holder currently processed.
    * @throws PropertyAccessConfigurationException on any property configuration
    *           problem.
    */
   private void applyCompoundMessageInfo(final Object exception,
       final String key, final ResourceBundle bundle,
       final MessageFormat formatter, final String attribute, final int index)
     throws PropertyAccessConfigurationException
   {
     final String[] limitStrings =
         createLimitStrings(exception, attribute, key, index, bundle);
     if (limitStrings != null)
     {
       final ChoiceFormat choiceFormat =
           new ChoiceFormat(new double[] { 0d, 1d, 2d }, limitStrings);
       formatter.setFormat(index, choiceFormat);
     }
   }
 
   /**
    * Checks if all slots in the array are not <code>null</code>.
    *
    * @param messageArguments the array to check.
    * @return <code>true</code> if all elements of the message arguments array
    *         are not <code>null</code>, <code>false</code> otherwise.
    */
   private static boolean isAllInformationProvided(
       final Object[] messageArguments)
   {
     for (final Object element : messageArguments)
     {
       if (element == null)
       {
         return false;
       }
     }
     return true;
   }
 
   private static void replaceMissingInformationDefaults(
       final Object[] messageArguments)
   {
     for (int i = messageArguments.length - 1; i >= 0; i--)
     {
       if (messageArguments[i] == null)
       {
         messageArguments[i] = "-/-";
       }
     }
   }
 
   /**
    * Adds values from the exception's properties to the message arguments.
    *
    * @param bean the bean whose properties are read. Usually an exception
    *          instance.
    * @param key the key prefix for the for the compound message to fetch.
    * @param bundle the bundle to access if there is a compound message.
    * @param formatter the formatter to configure with a choice formatter.
    * @param messageType the type of message to fill with values.
    * @param messageArguments the message arguments to collect.
    * @param fields the fields from the exception to access for values.
    * @throws PropertyAccessConfigurationException if the OGNL expression is
    *           present, but cannot be parsed or a compound message lacks
    *           properties in the resource bundle.
    */
   private void supplyPropertyValues(final Object bean, final String key,
       final ResourceBundle bundle, final MessageFormat formatter,
       final MessageType messageType, final Object[] messageArguments,
       final Field[] fields) throws PropertyAccessConfigurationException
   {
     String fieldName;
     for (final Field field : fields)
     {
       fieldName = field.getName(); // NOPMD
       if (log.isTraceEnabled())
       {
         log.trace("Processing annotations for field '" + fieldName + "'...");
       }
 
       final MessageParam messageParam = field.getAnnotation(MessageParam.class);
       if (messageParam != null)
       {
         final List<MessageParamInfo> infos =
             messageType.getMessageParamInfos(fieldName, messageParam);
         for (final MessageParamInfo info : infos)
         {
           final int index = Integer.parseInt(info.getPlaceholderId());
           if (index < messageArguments.length)
           {
             Object value = getValue(bean, field);
             if (value != null)
             {
               value = applyOgnl(bean, fieldName, info, value);
               applyCompoundMessageInfo(bean, key, bundle, formatter, fieldName,
                   index);
               messageArguments[index] = value;
             }
           }
         }
       }
     }
   }
 
   /**
    * Adds values from the exception's properties to the message arguments.
    *
    * @param bean the bean whose properties are read. Usually an exception
    *          instance.
    * @param key the key prefix for the for the compound message to fetch.
    * @param bundle the bundle to access if there is a compound message.
    * @param formatter the formatter to configure with a choice formatter.
    * @param messageType the type of message to fill with values.
    * @param messageArguments the message arguments to collect.
    * @param methods the methods from the exception to access for values.
    * @throws PropertyAccessConfigurationException if the OGNL expression is
    *           present, but cannot be parsed or a compound message lacks
    *           properties in the resource bundle.
    */
   private void supplyPropertyValues(final Object bean, final String key,
       final ResourceBundle bundle, final MessageFormat formatter,
       final MessageType messageType, final Object[] messageArguments,
       final Method[] methods) throws PropertyAccessConfigurationException
   {
     String methodName;
     for (final Method method : methods)
     {
       methodName = method.getName(); // NOPMD
       if (log.isTraceEnabled())
       {
         log.trace("Processing annotations for method '" + methodName + "'...");
       }
 
       final MessageParam messageParam =
           method.getAnnotation(MessageParam.class);
       if (messageParam != null)
       {
         final String propertyName = calcPropertyName(methodName);
         final List<MessageParamInfo> infos =
             messageType.getMessageParamInfos(propertyName, messageParam);
         for (final MessageParamInfo info : infos)
         {
           final int index = Integer.parseInt(info.getPlaceholderId());
           if (index < messageArguments.length)
           {
             Object value = getValue(bean, method);
             if (value != null)
             {
               value = applyOgnl(bean, propertyName, info, value);
               applyCompoundMessageInfo(bean, key, bundle, formatter,
                   methodName, index);
               messageArguments[index] = value;
             }
           }
         }
       }
     }
   }
 
   private static String calcPropertyName(final String methodName)
   {
     return methodName.startsWith("get") && methodName.length() > 3 ? methodName
         .substring(3) : methodName;
   }
 
   /**
    * Internal helper to create the array of compound messages that allows to
    * formulate different messages for plurals.
    *
    * @param bean the bean whose properties are read. Usually an exception
    *          instance.
    * @param fieldName the name of the field currently processed.
    * @param key the key to the message template.
    * @param index the index of the current place holder (as provided by the
    *          annotation to the currently processed field).
    * @param bundle the bundle to access the templates for the plurals.
    * @return <code>null</code> if there is no plural or the array of compound
    *         messages for the plurals.
    * @throws PropertyAccessConfigurationException if a compound message lacks
    *           properties in the resource bundle.
    */
   private static String[] createLimitStrings(final Object bean,
       final String fieldName, final String key, final int index,
       final ResourceBundle bundle) throws PropertyAccessConfigurationException
   {
     try
     {
       final String compoundKeyPrefix = key + '.' + index;
 
       final String key0 = compoundKeyPrefix + ".0";
       final String key1 = compoundKeyPrefix + ".1";
       final String keyM = compoundKeyPrefix + ".m";
 
       // final boolean isCompoundMessage = bundle.containsKey(key0)
       // || bundle.containsKey(key1)
       // || bundle.containsKey(keyM);
       final boolean isCompoundMessage =
           containsKey(bundle, key0) || containsKey(bundle, key1)
               || containsKey(bundle, keyM);
       final String[] limitStrings;
       if (isCompoundMessage)
       {
         limitStrings =
             new String[] { bundle.getString(key0), bundle.getString(key1),
                           bundle.getString(keyM) };
       }
       else
       {
         limitStrings = null;
       }
       return limitStrings;
     }
     catch (final MissingResourceException e)
     {
       throw new PropertyAccessConfigurationException(e,
           ConfigurationExceptionCode.COMPOUND_MESSAGE_MISSING, fieldName,
           bean.getClass());
     }
   }
 
   /**
    * Mimics the JSE 1.6 feature to check if a resource bundle contains a key.
    *
    * @param bundle the bundle to check for the key.
    * @param key the key to check.
    * @return <code>true</code> if the bundle contains a value for the given key,
    *         <code>false</code> otherwise.
    */
   private static boolean containsKey(final ResourceBundle bundle,
       final String key)
   {
     try
     {
       bundle.getString(key);
       return true;
     }
     catch (final Exception e)
     {
       return false;
     }
   }
 
   /**
    * Evaluates the OGNL expression.
    *
    * @param bean the instance required for debugging.
    * @param fieldName the name of the field of the instance required for
    *          debugging.
    * @param value the value to derive the requested value for the OGNL.
    * @param ognlPath the OGNL path.
    * @return the OGNL evaluated value.
    * @throws PropertyAccessConfigurationException if the OGNL has an syntax
    *           error.
    */
   private Object evaluateOgnl(final Object bean, final String fieldName,
       final Object value, final String ognlPath)
     throws PropertyAccessConfigurationException
   {
     try
     {
       final OgnlExpression expression = new OgnlExpression(ognlPath);
       final OgnlContext context = new OgnlContext();
       return expression.getValue(context, value);
     }
     catch (final OgnlException e)
     {
       throw new PropertyAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_OGNL_SYNTAX_ERROR,
           fieldName, bean.getClass());
     }
   }
 
   /**
    * Returns the value of the given field by either calling the getter method
    * specified in the annotation {@link PropertyInfo} to the given field, by
    * accessing the field directly (if accessible) or by deriving the getter
    * method's name from the name of the property.
    *
    * @param bean the instance whose value is requested.
    * @param field the field the value is requested.
    * @return the value of the field.
    * @throws ConfigurationException if there is a problem using the method to
    *           access the requested method.
    */
   private static Object getValue(final Object bean, final Field field)
     throws ConfigurationException
   {
     final PropertyInfo propertyInfo = field.getAnnotation(PropertyInfo.class);
     final Object value;
     if (propertyInfo != null && !"".equals(propertyInfo.getter()))
     {
       final String getter = propertyInfo.getter();
       value = getValue(bean, field.getName(), getter);
     }
     else
     {
       final boolean accessible = field.isAccessible();
       try
       {
         field.setAccessible(true);
         value = getFieldValue(bean, field);
       }
       finally
       {
         field.setAccessible(accessible);
       }
 
       // if (field.isAccessible())
       // {
       // }
       // else
       // {
       // final String fieldName = field.getName();
       // value = getProperty(bean, fieldName);
       // }
     }
 
     return value;
   }
 
   private static Object getValue(final Object bean, final Method method)
     throws ConfigurationException
   {
     try
     {
       final Object value = method.invoke(bean, new Object[0]);
       return value;
     }
     catch (final SecurityException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_SECURITY,
           calcPropertyName(method.getName()), bean.getClass(), method.getName());
     }
     catch (final IllegalArgumentException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_NOARG,
           calcPropertyName(method.getName()), bean.getClass(), method.getName());
     }
     catch (final IllegalAccessException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_MISSING_GETTER,
           calcPropertyName(method.getName()), bean.getClass(), method.getName());
     }
     catch (final InvocationTargetException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_RUNTIME_ACCESS,
           calcPropertyName(method.getName()), bean.getClass(), method.getName());
     }
   }
 
   /**
    * Returns the value of the given field.
    * <p>
    * The method assumes the the field is accessible. If not an configuration
    * exception is thrown.
    *
    * @param bean the instance whose field value is requested.
    * @param field the field whose value is requested.
    * @return the requested value fetched from the field.
    */
   private static Object getFieldValue(final Object bean, final Field field)
   {
     try
     {
       final Object value = field.get(bean);
       return value;
     }
     catch (final IllegalArgumentException e)
     {
       assert false : "The field '" + field.getName()
                      + "' is not a member of the class '" + bean.getClass()
                      + "': " + e.getMessage();
     }
     catch (final IllegalAccessException e)
     {
       assert false : "The field '" + field.getName() + "' in class '"
                      + bean.getClass() + "' is not accessible: "
                      + e.getMessage();
     }
     // Unfortunately the compiler does not see that we will raise an assertion
     // exception if one of the caught exceptions is thrown.
     assert false : "The system should never reach this point.";
     return null;
   }
 
   /**
    * Returns the value returned by calling the getter method with the given
    * name.
    *
    * @param bean the instance whose method is invoked.
    * @param propertyName the name of the property to get the value for.
    * @param methodName the name of the method to invoke. It is expected that the
    *          method requires no arguments and returns a value (is a getter).
    * @return the value returned by calling the method.
    * @throws MethodAccessConfigurationException if there is a problem using the
    *           method to access the requested method.
    */
   private static Object getValue(final Object bean, final String propertyName,
       final String methodName) throws MethodAccessConfigurationException
   {
     try
     {
       final Method method = bean.getClass().getMethod(methodName, new Class[0]);
       final Object value = method.invoke(bean, new Object[0]);
       return value;
     }
     catch (final SecurityException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_SECURITY, propertyName,
           bean.getClass(), methodName);
     }
     catch (final NoSuchMethodException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_MISSING_GETTER,
           propertyName, bean.getClass(), methodName);
     }
     catch (final IllegalArgumentException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_NOARG, propertyName,
           bean.getClass(), methodName);
     }
     catch (final IllegalAccessException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_MISSING_GETTER,
           propertyName, bean.getClass(), methodName);
     }
     catch (final InvocationTargetException e)
     {
       throw new MethodAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_RUNTIME_ACCESS,
           propertyName, bean.getClass(), methodName);
     }
   }
 
   /**
    * Returns the property value. The getter method derived from the property
    * name is called to access the value.
    *
    * @param bean the instance whose property value is requested.
    * @param propertyName the name of the property.
    * @return the value of the property.
    * @throws PropertyAccessConfigurationException if there is a problem using
    *           the method to access the requested property.
    */
   private static Object getProperty(final Object bean, final String propertyName)
     throws PropertyAccessConfigurationException
   {
     try
     {
       // final Object value = PropertyUtils.getProperty(instance, propertyName);
       final String methodName = "get" + Helper.capitalize(propertyName);
       final Method method = bean.getClass().getMethod(methodName, new Class[0]);
       final Object value = method.invoke(bean, new Object[0]);
       return value;
     }
     catch (final IllegalAccessException e)
     {
       throw new PropertyAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_INACCESSIBLE_PROPERTY,
           propertyName, bean.getClass());
     }
     catch (final InvocationTargetException e)
     {
       throw new PropertyAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_PROPERTY_RUNTIME_ACCESS,
           propertyName, bean.getClass());
     }
     catch (final NoSuchMethodException e)
     {
       throw new PropertyAccessConfigurationException(e,
           ConfigurationExceptionCode.CONFIGURATION_NO_GETTER_FOR_PROPERTY,
           propertyName, bean.getClass());
     }
   }
 
   // --- object basics --------------------------------------------------------
 }