/*
    * 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.core.metadata;
  
  import static de.smartics.util.lang.StaticAnalysis.RAWTYPES;
  import static de.smartics.util.lang.StaticAnalysis.UNCHECKED;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  
  import javax.validation.constraints.Size;
  
  import org.apache.commons.lang.ArrayUtils;
  
  import de.smartics.properties.api.core.annotations.AccessType;
  import de.smartics.properties.api.core.annotations.PropertyDefinitionTime;
  import de.smartics.properties.api.core.annotations.PropertyElementType;
  import de.smartics.properties.api.core.annotations.PropertyListElementConstraints;
  import de.smartics.properties.api.core.annotations.PropertySet;
  import de.smartics.properties.api.core.domain.PropertiesContext;
  import de.smartics.properties.api.core.domain.PropertyConstraint;
  import de.smartics.properties.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.api.core.domain.PropertyExpression;
  import de.smartics.properties.api.core.domain.PropertyKey;
  import de.smartics.properties.api.core.domain.PropertyType;
  import de.smartics.properties.api.core.domain.PropertyValueRange;
  import de.smartics.properties.spi.core.constraint.jsr303.GenericPropertyConstraint;
  import de.smartics.properties.spi.core.constraints.ListValueConstraint;
  import de.smartics.properties.spi.core.constraints.PropertyRangeConstraint;
  import de.smartics.properties.spi.core.context.PropertyContextProxy;
  import de.smartics.properties.spi.core.metadata.PropertyMetaData.Builder;
  import de.smartics.properties.spi.core.util.PropertyUtils;
  import de.smartics.properties.spi.core.value.CollectionPropertyValueRange;
  import de.smartics.properties.spi.core.value.EnumeratedPropertyValueRange;
  import de.smartics.util.lang.Arguments;
  
  /**
   * Parses runtime annotations to create property metadata.
   */
  public final class PropertyMetaDataParser
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The context to access property metadata.
     */
    private final PropertiesContext context;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor to generate property descriptors with comments.
     *
     * @param context the context to access property metadata. May be
     *          <code>null</code> in which case no comments are generated.
     */
    private PropertyMetaDataParser(final PropertiesContext context)
    {
      this.context = context;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- factory --------------------------------------------------------------
  
    /**
     * Convenience constructor to generate property descriptors without comments.
     *
     * @return the created parser instance.
     */
    public static PropertyMetaDataParser createWithoutContextAccess()
    {
      return new PropertyMetaDataParser(null);
   }
 
   /**
    * Convenience constructor to generate property descriptors with access to
    * property comments.
    *
    * @param context the context to access comment information for properties.
    * @return the created parser instance.
    * @throws NullPointerException if {@code context} is <code>null</code>.
    */
   public static PropertyMetaDataParser create(final PropertiesContext context)
     throws NullPointerException
   {
     Arguments.checkNotNull("context", context);
     return new PropertyMetaDataParser(context);
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Reads the property descriptor information from the type.
    *
    * @param propertySetType the type to read the property descriptor.
    * @return the property descriptor provided by the methods of the type.
    * @throws NullPointerException if {@code propertySetType} is
    *           <code>null</code>.
    * @throws IllegalArgumentException if {@code propertySetType} is not
    *           annotated with {@link PropertySet}.
    */
   public List<PropertyDescriptor> readDescriptors(final Class<?> propertySetType)
     throws NullPointerException, IllegalArgumentException
   {
     Arguments.checkNotNull("propertySetType", propertySetType);
     PropertyUtils.checkPropertySetType(propertySetType);
 
     final Method[] methods = propertySetType.getMethods();
     final List<PropertyDescriptor> descriptors =
         new ArrayList<PropertyDescriptor>(methods.length);
     for (final Method method : methods)
     {
       if (PropertyUtils.isPropertyMethod(method))
       {
         final PropertyDescriptor descriptor = readDescriptor(method);
         descriptors.add(descriptor);
       }
     }
 
     return descriptors;
   }
 
   /**
    * Reads the property descriptor information from the method.
    *
    * @param method the method to read the property descriptor.
    * @return the property descriptor provided by this method.
    * @throws NullPointerException if {@code method} is <code>null</code>.
    */
   public PropertyDescriptor readDescriptor(final Method method)
     throws NullPointerException
   {
     Arguments.checkNotNull("method", method);
 
     final PropertyMetaData.Builder builder = new PropertyMetaData.Builder();
 
     final Class<?> declaringType = method.getDeclaringClass();
     final PropertyKey key = readKey(method);
     final PropertyType type = readType(method);
     builder.with(new PropertyContextProxy(context))
         .withDeclaringType(declaringType).with(key).with(type);
 
     addValueRange(builder, method);
     addExpression(builder, method);
     addLifecycle(builder, method);
     addConstraints(builder, method);
     addDocumentProxy(builder, method);
     addComments(builder);
 
     return builder.build();
   }
 
   /**
    * Reads the property key information from the method.
    *
    * @param method the method to read the property key.
    * @return the property key provided by this method.
    */
   public PropertyKey readKey(final Method method)
   {
     final String set = readPropertySetName(method);
     final String name = readPropertyKeyName(method);
     return PropertyKey.create(set, name);
   }
 
   /**
    * Reads the property set name of the type.
    *
    * @param type the type to read the property set name.
    * @return the property name as specified of defaulted.
    */
   public String readPropertySetName(final Class<?> type)
   {
     String propertySetName = readPropertySetNameInternal(type);
 
     if (" ".equals(propertySetName))
     {
       propertySetName = type.getName();
     }
     else if ("".equals(propertySetName))
     {
       propertySetName = null;
     }
 
     return propertySetName;
   }
 
   private static String readPropertyKeyName(final Method method)
   {
     final String keyName;
 
     final de.smartics.properties.api.core.annotations.PropertyKeyName propertyKey =
         method
             .getAnnotation(de.smartics.properties.api.core.annotations.PropertyKeyName.class);
     if (propertyKey != null)
     {
       keyName = propertyKey.value();
     }
     else
     {
       final String methodName = method.getName();
       if (isGetterMethod(methodName))
       {
         keyName = calcPropertyName(methodName);
       }
       else
       {
         keyName = methodName;
       }
     }
 
     return keyName;
   }
 
   private static String calcPropertyName(final String methodName)
   {
     return Character.toLowerCase(methodName.charAt(3))
            + methodName.substring(4);
   }
 
   private static boolean isGetterMethod(final String methodName)
   {
     return methodName.length() > 3 && methodName.startsWith("get")
            && Character.isUpperCase(methodName.charAt(3));
   }
 
   private static String readPropertySetName(final Method method)
   {
     final String propertySetName;
 
     final PropertySet primaryPropertySet =
         method.getAnnotation(PropertySet.class);
     if (primaryPropertySet != null)
     {
       propertySetName = primaryPropertySet.value();
     }
     else
     {
       final Class<?> type = method.getDeclaringClass();
       propertySetName = readPropertySetNameInternal(type);
     }
 
     if (" ".equals(propertySetName))
     {
       final Class<?> type = method.getDeclaringClass();
       return type.getName();
     }
     else if ("".equals(propertySetName))
     {
       return null;
     }
 
     return propertySetName;
   }
 
   private static String readPropertySetNameInternal(final Class<?> type)
   {
     final String propertySetName;
     final PropertySet propertySet = type.getAnnotation(PropertySet.class);
     if (propertySet != null)
     {
       propertySetName = propertySet.value();
     }
     else
     {
       propertySetName = type.getName();
     }
     return propertySetName;
   }
 
   private static PropertyType readType(final Method method)
   {
     final Class<?> type = method.getReturnType();
     final Class<?> subType = determineSubType(method);
 
     return new PropertyType(type, subType);
   }
 
   private static Class<?> determineSubType(final Method method)
   {
     final PropertyElementType elementType =
         method.getAnnotation(PropertyElementType.class);
     final Class<?> subType;
     if (elementType != null)
     {
       subType = elementType.value();
     }
     else
     {
       subType = null;
     }
     return subType;
   }
 
   @SuppressWarnings({ RAWTYPES, UNCHECKED })
   private static void addValueRange(final Builder builder, final Method method)
   {
     final PropertyValueRange<?> valueRange = calculateValueRange(method);
     if (valueRange != null)
     {
       builder.with(valueRange);
       final PropertyRangeConstraint<?> constraint =
           new PropertyRangeConstraint(valueRange);
       builder.add(constraint);
     }
   }
 
   @SuppressWarnings({ RAWTYPES, UNCHECKED })
   private static PropertyValueRange<?> calculateValueRange(final Method method)
   {
     final Class<?> returnType = method.getReturnType();
     if (returnType.isEnum())
     {
       final PropertyValueRange<?> valueRange =
           new EnumeratedPropertyValueRange(returnType);
       return valueRange;
     }
     else
     {
       final de.smartics.properties.api.core.annotations.PropertyIntValueRange intAnnotation =
           method
               .getAnnotation(de.smartics.properties.api.core.annotations.PropertyIntValueRange.class);
       if (intAnnotation != null)
       {
         final Integer[] values =
             ArrayUtils.toObject(intAnnotation.value());
         final CollectionPropertyValueRange<Integer> valueRange =
             new CollectionPropertyValueRange<Integer>(values);
         return valueRange;
       }
 
       final de.smartics.properties.api.core.annotations.PropertyStringValueRange annotation =
           method
               .getAnnotation(de.smartics.properties.api.core.annotations.PropertyStringValueRange.class);
       if (annotation != null)
       {
         final String[] values = annotation.value();
         final CollectionPropertyValueRange<String> valueRange =
             new CollectionPropertyValueRange<String>(values);
         return valueRange;
       }
     }
 
     return null;
   }
 
   private static void addExpression(final Builder builder, final Method method)
   {
     final de.smartics.properties.api.core.annotations.PropertyExpression annotation =
         method
             .getAnnotation(de.smartics.properties.api.core.annotations.PropertyExpression.class);
     if (annotation != null)
     {
       final String expressionString = annotation.value();
       final PropertyExpression expression =
           PropertyExpression.create(expressionString);
       builder.with(expression);
     }
   }
 
   private void addLifecycle(final Builder builder, final Method method)
   {
     final de.smartics.properties.api.core.annotations.PropertyLifecycle annotation =
         method
             .getAnnotation(de.smartics.properties.api.core.annotations.PropertyLifecycle.class);
     if (annotation != null)
     {
       final PropertyDefinitionTime configurationTime =
           annotation.definitionTime();
       if (configurationTime != null)
       {
         builder.with(configurationTime);
       }
 
       final AccessType accessType = annotation.access();
       if (accessType != null)
       {
         builder.with(accessType);
       }
 
       final long updateInterval = annotation.updateInterval();
       builder.withUpdateIntervalInMs(updateInterval);
     }
   }
 
   @SuppressWarnings({ RAWTYPES, UNCHECKED })
   private void addConstraints(final Builder builder, final Method method)
   {
     final Annotation[] annotations = method.getAnnotations();
     boolean collectionConstraintAdded = false;
 
     for (final Annotation annotation : annotations)
     {
       final javax.validation.Constraint annotationAnnotation =
           annotation.annotationType().getAnnotation(
               javax.validation.Constraint.class);
       if (annotationAnnotation != null)
       {
         if (annotation.annotationType() != Size.class)
         {
           final GenericPropertyConstraint propertyConstraint =
               new GenericPropertyConstraint(annotation);
           builder.add(propertyConstraint);
         }
         else
         {
           checkCollection(builder, method, (Size) annotation);
           collectionConstraintAdded = true;
         }
       }
     }
 
     if (!collectionConstraintAdded)
     {
       checkCollection(builder, method, null);
     }
   }
 
   private void checkCollection(final PropertyMetaData.Builder builder,
       final Method method, final Size size)
   {
     final Class<?> type = builder.getType().getType();
 
     if (Collection.class.isAssignableFrom(type))
     {
       final PropertyElementType elementTypeAnnotation =
           method.getAnnotation(PropertyElementType.class);
 
       final Class<?> elementType = calcElementType(elementTypeAnnotation);
       final List<? extends PropertyConstraint<?>> elementConstraints =
           calcElementConstraints(method);
       Integer min = null;
       Integer max = null;
       if (size != null)
       {
         min = size.min();
         max = size.max();
       }
 
       final PropertyConstraint<?> propertyConstraint =
           new ListValueConstraint(elementType, min, max, elementConstraints);
       builder.add(propertyConstraint);
     }
   }
 
   private Class<?> calcElementType(
       final PropertyElementType elementTypeAnnotation)
   {
     final Class<?> elementType;
     if (elementTypeAnnotation != null)
     {
       elementType = elementTypeAnnotation.value();
     }
     else
     {
       elementType = String.class;
     }
     return elementType;
   }
 
   @SuppressWarnings({ RAWTYPES, UNCHECKED })
   private List<? extends PropertyConstraint<?>> calcElementConstraints(
       final Method method)
   {
     final Annotation[] annotations = calcElementsConstraintsType(method);
     if (annotations != null)
     {
       final List constraints = new ArrayList(annotations.length);
 
       for (final Annotation annotation : annotations)
       {
         final javax.validation.Constraint annotationAnnotation =
             annotation.annotationType().getAnnotation(
                 javax.validation.Constraint.class);
         if (annotationAnnotation != null)
         {
           final GenericPropertyConstraint propertyConstraint =
               new GenericPropertyConstraint(annotation);
           constraints.add(propertyConstraint);
         }
       }
 
       return constraints;
     }
 
     return new ArrayList(0);
   }
 
   private static Annotation[] calcElementsConstraintsType(final Method method) // NOPMD
   {
     final Class<?> enclosingType = method.getDeclaringClass();
     final Class<?>[] nestedClasses = enclosingType.getDeclaredClasses();
     if (nestedClasses != null)
     {
       for (final Class<?> nestedClass : nestedClasses)
       {
         final PropertyListElementConstraints constraintsType =
             nestedClass.getAnnotation(PropertyListElementConstraints.class);
         if (constraintsType != null)
         {
           final String methodName = method.getName();
           return calcElementConstraintMethod(nestedClass, methodName);
         }
       }
     }
 
     return null;
   }
 
   private static Annotation[] calcElementConstraintMethod(
       final Class<?> nestedClass, final String methodName)
   {
     try
     {
       final Method elementConstraintMethod =
           nestedClass.getMethod(methodName, new Class<?>[0]);
       return elementConstraintMethod.getAnnotations();
     }
     catch (final Exception e)
     {
       return null;
     }
   }
 
   private void addDocumentProxy(final Builder builder, final Method method)
   {
     final DocumentMetaDataProxy proxy =
         new MetaInfDocumentMetaDataProxy(context, method);
     builder.with(proxy);
   }
 
   private void addComments(final Builder builder)
   {
     final PropertyCommentProxy commentProxy = new PropertyCommentProxy(context);
     builder.with(commentProxy);
   }
 
   // --- object basics --------------------------------------------------------
 
 }