/*

  * 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.annotations.PropertyUse.UseType;

 import de.smartics.properties.api.core.annotations.PropertyValueSecured;

 import de.smartics.properties.api.core.domain.PropertiesContext;

 import de.smartics.properties.api.core.domain.PropertyCategories;

 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.Arg;

 /**

  * 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

   {

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

   {

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

   {

     Arg.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, key);

     addComments(builder);

     addSecured(builder, method);

     addCategories(builder, method);

     addUseType(builder, method);

     return builder.build();

   }

   private static void addSecured(final Builder builder, final Method method)

   {

     final boolean secured = readSecured(method);

     builder.setSecured(secured);

   }

   private static boolean readSecured(final Method method)

   {

     final PropertyValueSecured secured =

         method.getAnnotation(PropertyValueSecured.class);

     final boolean value;

     if (secured != null)

     {

       value = secured.decrypt();

     }

     else

     {

       value = false;

     }

     return value;

   }

   /**

    * 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, method.getReturnType());

           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, method.getReturnType()); // FIXME:

                                                                                  // ===????

           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 PropertyKey key)

   {

     final DocumentMetaDataProxy proxy =

         new MetaInfDocumentMetaDataProxy(key, context, method);

     builder.with(proxy);

   }

   private void addComments(final Builder builder)

   {

     final PropertyCommentProxy commentProxy = new PropertyCommentProxy(context);

     builder.with(commentProxy);

   }

   private void addCategories(final Builder builder, final Method method)

   {

     final List<Class<?>> categories = readCategories(method);

     if (!categories.isEmpty())

     {

       final PropertyCategories.Builder catBuilder =

           new PropertyCategories.Builder();

       for (final Class<?> category : categories)

       {

         catBuilder.with(category);

       }

       final PropertyCategories propertyCategories = catBuilder.build();

       builder.with(propertyCategories);

     }

   }

   private static List<Class<?>> readCategories(final Method method)

   {

     final List<Class<?>> categories = new ArrayList<Class<?>>();

     final de.smartics.properties.api.core.annotations.PropertyCategories methodAnnotation =

         method

             .getAnnotation(de.smartics.properties.api.core.annotations.PropertyCategories.class);

     addCategoriesFromAnnotation(categories, methodAnnotation);

     final Class<?> type = method.getDeclaringClass();

     final de.smartics.properties.api.core.annotations.PropertyCategories typeAnnotation =

         type.getAnnotation(de.smartics.properties.api.core.annotations.PropertyCategories.class);

     addCategoriesFromAnnotation(categories, typeAnnotation);

     return categories;

   }

   private static void addCategoriesFromAnnotation(

       final List<Class<?>> categories,

       final de.smartics.properties.api.core.annotations.PropertyCategories typeAnnotation)

   {

     if (typeAnnotation != null)

     {

       final Class<?>[] categoryTypes = typeAnnotation.value();

       for (final Class<?> categoryType : categoryTypes)

       {

         categories.add(categoryType);

       }

     }

   }

   private void addUseType(final Builder builder, final Method method)

   {

     final Class<?> type = method.getDeclaringClass();

     final de.smartics.properties.api.core.annotations.PropertyUse typeAnnotation =

         type.getAnnotation(de.smartics.properties.api.core.annotations.PropertyUse.class);

     if (typeAnnotation != null)

     {

       final UseType useType = typeAnnotation.value();

       if (useType != null)

       {

         builder.with(useType);

       }

     }

   }

   // --- object basics --------------------------------------------------------

 }