/*
    * Copyright 2012-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.properties.spi.config.proxy;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Method;
  
  import org.apache.commons.lang.WordUtils;
  
  import de.smartics.properties.api.core.annotations.PropertyMetaDataMethod;
  
  /**
   * Helper.
   */
  public final class PropertyMethodNameUtilities
  { // NOPMD
  
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The "get" string prefix for getter methods.
     */
    private static final String GET_PREFIX = "get";
  
    /**
     * The default naming convention suffix used to indicate that the method that
     * ends with this string is a method to get the property descriptor.
     */
    private static final String PROPERTY_DESCRIPTOR_SUFFIX = "PropertyDescriptor";
  
    /**
     * The default naming convention suffix used to indicate that the method that
     * ends with this string is a method to get the property key.
     */
    private static final String PROPERTY_KEY_SUFFIX = "PropertyKey";
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    private PropertyMethodNameUtilities()
    {
  
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Helper that determines the property method that belongs to the method
     * given.
     *
     * @param m the method whose property method shall be determined.
     * @return the property method for the given method.
     */
    public static Method fetchPropertyMethod(final Method m)
    {
      final Method propertyMethod;
      if (isMethodAnnotatedWithAnnotation(PropertyMetaDataMethod.class, m))
      {
        propertyMethod = fetchPropertyMethodUsingAnnotation(m);
      }
      else
      {
        propertyMethod = fetchPropertyMethodUsingNamingConvention(m);
      }
      return propertyMethod;
    }
  
    /**
     * Determine whether or not the given method is annotated with a special
     * annotation.
     *
     * @param annotation the annotation that shall be detected.
     * @param m the method whose annotation shall be checked.
    * @param <T> to limit the parameter to Annotations.
    * @return true if the given method is annotated wit the given annotation,
    *         false otherwise.
    */
   public static <T extends Annotation> boolean isMethodAnnotatedWithAnnotation(
       final Class<T> annotation, final Method m)
   {
     return fetchAnnotation(annotation, m) != null;
   }
 
   private static Method fetchPropertyMethodUsingNamingConvention(final Method m)
   {
     // TODO HERE AND Immediately Tests for all
     final String methodName = m.getName();
     final String propertyMethodName =
         calculateMethodNameUsingNamingConvention(methodName);
     final Class<?> propertyClass = m.getDeclaringClass();
     Method propertyMethod = null;
     try
     {
       final Method[] methods = propertyClass.getDeclaredMethods();
       propertyMethod = lookupMethod(propertyMethodName, methods);
 
       if (propertyMethod == null)
       {
         propertyMethod = lookupGetterMethod(propertyMethodName, methods);
       }
 
       if (propertyMethod == null)
       {
         throw new PropertyMethodNotFoundException(
             "Method :'" // NOPMD
                 + propertyMethodName
                 + "' or its getter type method could not be found in interface: "
                 + propertyClass.getCanonicalName());
       }
     }
     catch (final SecurityException e)
     {
       throw new PropertyMethodNotFoundException(
           "Method :'" + methodName + "' could not be found in interface: " // NOPMD
               + propertyClass.getCanonicalName(), e);
     }
     return propertyMethod;
   }
 
   private static Method lookupGetterMethod(final String propertyMethodName,
       final Method[] methods)
   {
     Method propertyMethod;
     final String getter = GET_PREFIX + WordUtils.capitalize(propertyMethodName);
     propertyMethod = lookupMethod(getter, methods);
     return propertyMethod;
   }
 
   private static Method lookupMethod(final String propertyMethodName,
       final Method[] methods)
   {
     for (int i = 0; i < methods.length; i++)
     {
       final String name = methods[i].getName();
       if (name.equals(propertyMethodName))
       {
         return methods[i];
       }
     }
     return null;
   }
 
   private static String calculateMethodNameUsingNamingConvention(
       final String methodName)
   {
     String propertyMethodName;
     if (methodName.endsWith(PROPERTY_KEY_SUFFIX))
     {
       propertyMethodName = eliminateSuffix(methodName, PROPERTY_KEY_SUFFIX);
     }
     else if (methodName.endsWith(PROPERTY_DESCRIPTOR_SUFFIX))
     {
       propertyMethodName =
           eliminateSuffix(methodName, PROPERTY_DESCRIPTOR_SUFFIX);
     }
     else
     {
       throw new PropertyMethodNotFoundException(
           "Method :'"
               + methodName // NOPMD
               + "' is not a valid name for a property metadata method. "
               + "Property metadata methods for keys must end with '"
               + PROPERTY_KEY_SUFFIX + "' and for property descriptors with '"
               + PROPERTY_DESCRIPTOR_SUFFIX
               + "'. They may start with \"get\" but must not.");
     }
 
     if (propertyMethodName.startsWith(GET_PREFIX))
     {
       propertyMethodName = eliminatePrefix(propertyMethodName, GET_PREFIX);
     }
     return propertyMethodName;
   }
 
   private static String eliminatePrefix(
       final String propertyMethodNameWithPrefix, final String prefix)
   {
     final String methodNameWithoutGet =
         propertyMethodNameWithPrefix.substring(prefix.length());
     final String propertyMethodName =
         WordUtils.uncapitalize(methodNameWithoutGet);
     return propertyMethodName;
   }
 
   private static String eliminateSuffix(final String methodName,
       final String suffix)
   {
     String propertyMethodName;
     propertyMethodName =
         methodName.substring(0, methodName.length() - suffix.length());
     return propertyMethodName;
   }
 
   private static Method fetchPropertyMethodUsingAnnotation(final Method m)
   {
     final PropertyMetaDataMethod annotation =
         fetchAnnotation(PropertyMetaDataMethod.class, m);
     final String methodName = annotation.value();
     final Method propertyMethod =
         fetchMethodByName(m.getDeclaringClass(), methodName);
     return propertyMethod;
   }
 
   private static Method fetchMethodByName(final Class<?> class1,
       final String methodName)
   {
     try
     {
       return class1.getDeclaredMethod(methodName, (Class<?>[]) null);
     }
     catch (final SecurityException e)
     {
       throw new PropertyMethodNotFoundException("Method :'" + methodName
                                                 + "' not found in interface: "
                                                 + class1.getCanonicalName(), e);
     }
     catch (final NoSuchMethodException e)
     {
       throw new PropertyMethodNotFoundException("Method :'" + methodName
                                                 + "' not found in interface: "
                                                 + class1.getCanonicalName(), e);
     }
   }
 
   private static <T extends Annotation> T fetchAnnotation(
       final Class<T> annotationClass, final Method m)
   {
     final T annotation = m.getAnnotation(annotationClass);
     return annotation;
   }
 
   // --- object basics --------------------------------------------------------
 
 }