/*
    * 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.constraint.jsr303;
  
  import static de.smartics.util.lang.StaticAnalysis.UNCHECKED;
  
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Method;
  import java.util.List;
  import java.util.Locale;
  
  import javax.validation.ConstraintValidator;
  import javax.validation.ConstraintValidatorContext;
  import javax.validation.MessageInterpolator;
  import javax.validation.MessageInterpolator.Context;
  import javax.validation.Validation;
  import javax.validation.ValidatorFactory;
  import javax.validation.constraints.NotNull;
  import javax.validation.groups.Default;
  import javax.validation.metadata.ConstraintDescriptor;
  
  import org.hibernate.validator.constraints.NotBlank;
  import org.hibernate.validator.internal.engine.MessageInterpolatorContext;
  import org.hibernate.validator.internal.metadata.core.ConstraintHelper;
  
  import de.smartics.properties.spi.core.constraint.AbstractPropertyConstraint;
  import de.smartics.util.lang.Arg;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * Generic wrapper for JSR-303 constraints.
   *
   * @param <A> the constraint annotation.
   * @param <T> the type of the property that is validated.
   */
  public class GenericPropertyConstraint<A extends Annotation, T> extends
      AbstractPropertyConstraint<T>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The class version identifier.
     * <p>
     * The value of this constant is {@value}.
     */
    private static final long serialVersionUID = 1L;
  
    /**
     * Helper to fetch validators for default constraints.
     */
    private static final ConstraintHelper CONSTRAINTS = new ConstraintHelper();
  
    // --- members --------------------------------------------------------------
  
    /**
     * The validator factory to access for message interpolation.
     */
    private static final ValidatorFactory FACTORY = Validation
        .buildDefaultValidatorFactory();
  
    /**
     * The validator to validate values.
     */
    private transient ConstraintValidator<A, T> validator;
  
    // FIXME: Support list of validators.
  
    /**
     * The JSR-303 constraint annotation.
     *
     * @serial
     */
    private final A constraintAnnotation;
  
    /**
     * Stores the validator class for serialization.
     *
     * @serial
     */
    private final Class<? extends ConstraintValidator<A, T>> validatorClass;
  
    // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Convenience constructor if the validator can be derived from the
    * {@code constraintAnnotation}.
    *
    * @param constraintAnnotation the JSR-303 constraint annotation.
    * @param propertyType the type of the property selects the validator if more
    *          than on validator is referenced by the constraint annotation.
    * @throws NullArgumentException if {@code constraintAnnotation} is
    *           <code>null</code>.
    */
   @SuppressWarnings(UNCHECKED)
   public GenericPropertyConstraint(final A constraintAnnotation,
       final Class<?> propertyType) throws NullArgumentException
   {
     this((ConstraintValidator<A, T>) createValidator(constraintAnnotation,
         propertyType), constraintAnnotation);
   }
 
   /**
    * Default constructor.
    *
    * @param validator the validator to validate values.
    * @param constraintAnnotation the JSR-303 constraint annotation.
    * @throws NullArgumentException if either {@code validator} or
    *           {@code constraintAnnotation} is <code>null</code>.
    */
   @SuppressWarnings(UNCHECKED)
   public GenericPropertyConstraint(final ConstraintValidator<A, T> validator,
       final A constraintAnnotation) throws NullArgumentException
   {
     this.validator = Arg.checkNotNull("validator", validator);
     this.constraintAnnotation =
         Arg.checkNotNull("constraintAnnotation", constraintAnnotation);
     this.validatorClass =
         (Class<? extends ConstraintValidator<A, T>>) validator.getClass();
 
     validator.initialize(constraintAnnotation);
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private static <A extends Annotation, T> ConstraintValidator<A, T> createValidator(
       final A constraintAnnotation, final Class<?> propertyType)
     throws IllegalArgumentException
   {
     final javax.validation.Constraint annotation =
         constraintAnnotation.annotationType().getAnnotation(
             javax.validation.Constraint.class);
     if (annotation != null)
     {
       final Class<? extends ConstraintValidator<?, ?>>[] validatorClass =
           annotation.validatedBy();
       if (validatorClass.length == 1)
       {
         return selectValidator(validatorClass);
       }
       if (validatorClass.length > 0)
       {
         return selectValidator(validatorClass, propertyType);
       }
       else
       {
         final Class<? extends Annotation> annotationType =
             constraintAnnotation.annotationType();
         final List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> validators =
             CONSTRAINTS.getBuiltInConstraints(annotationType);
         if (validators.size() == 1)
         {
           return selectValidator(validators);
         }
         if (!validators.isEmpty())
         {
           return selectValidator(validators, propertyType);
         }
       }
     }
 
     throw new IllegalArgumentException(
         "Cannot derive constraint validator from annotation: "
             + constraintAnnotation);
   }
 
   @SuppressWarnings({ UNCHECKED })
   private static <A extends Annotation, T> ConstraintValidator<A, T> selectValidator(
       final Class<? extends ConstraintValidator<?, ?>>[] validatorClass)
   {
     final Class<? extends ConstraintValidator<A, T>> type =
         (Class<? extends ConstraintValidator<A, T>>) validatorClass[0];
     final ConstraintValidator<A, T> validator = createValidator(type);
     return validator;
   }
 
   @SuppressWarnings({ UNCHECKED, "rawtypes" })
   private static <T, A extends Annotation> ConstraintValidator<A, T> selectValidator(
       final List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> validators)
   {
     final Class<? extends ConstraintValidator<A, T>> type =
         (Class<? extends ConstraintValidator<A, T>>) validators.get(0);
     final ConstraintValidator validator = createValidator(type);
     return validator;
   }
 
   @SuppressWarnings(UNCHECKED)
   private static <A extends Annotation, T> ConstraintValidator<A, T> selectValidator(
       final List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> validators,
       final Class<?> propertyType)
   {
     final Class<? extends ConstraintValidator<?, ?>>[] x =
         validators.toArray(new Class[validators.size()]);
     return selectValidator(x, propertyType);
   }
 
   @SuppressWarnings(UNCHECKED)
   private static <A extends Annotation, T> ConstraintValidator<A, T> selectValidator(
       final Class<? extends ConstraintValidator<?, ?>>[] validatorClass,
       final Class<?> propertyType)
   {
     Class<? extends ConstraintValidator<A, T>> bestMatch =
         (Class<? extends ConstraintValidator<A, T>>) validatorClass[0];
 
     for (final Class<? extends ConstraintValidator<A, T>> type : (Class<ConstraintValidator<A, T>>[]) validatorClass)
     {
       for (final Method method : type.getMethods())
       {
         if ("isValid".equals(method.getName()))
         {
           final Class<?>[] types = method.getParameterTypes();
           if (types.length > 0)
           {
             final Class<?> paramType = types[0];
             if (isArrayOrPrimitive(propertyType, paramType)
                 || isObjectButNotAnArray(propertyType, paramType))
             {
               final ConstraintValidator<A, T> validator = createValidator(type);
               return validator;
             }
             else
             {
               if (Object.class.equals(paramType.getComponentType()))
               {
                 bestMatch = type;
               }
             }
           }
         }
       }
     }
 
     final ConstraintValidator<A, T> validator = createValidator(bestMatch);
     return validator;
   }
 
   private static boolean isObjectButNotAnArray(final Class<?> propertyType,
       final Class<?> paramType)
   {
     return !propertyType.isArray() && paramType.isAssignableFrom(propertyType);
   }
 
   private static boolean isArrayOrPrimitive(final Class<?> propertyType,
       final Class<?> paramType)
   {
     return (propertyType.isArray() || propertyType.isPrimitive())
            && paramType.equals(propertyType);
   }
 
   private static <A extends Annotation, T> ConstraintValidator<A, T> createValidator(
       final Class<? extends ConstraintValidator<A, T>> validatorClass)
     throws IllegalArgumentException
   {
     Throwable cause = null;
     try
     {
       final ConstraintValidator<A, T> validator = validatorClass.newInstance();
       return validator;
     }
     catch (final InstantiationException e)
     {
       cause = e;
       // Fail at the end
     }
     catch (final IllegalAccessException e)
     {
       cause = e;
       // Fail at the end
     }
 
     throw new IllegalArgumentException(
         "Cannot instantiate constraint validator: " + validatorClass.getName(),
         cause);
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    * <p>
    * Override to provide more specific information the the string representation
    * of the constraint annotation.
    * </p>
    *
    * @see de.smartics.properties.api.core.domain.PropertyConstraint#getDescription(java.util.Locale)
    */
   // CHECKSTYLE:OFF
   @Override
   public String getDescription(final Locale locale) // CHECKSTYLE:ON
   {
     return new ConstraintPrettifier(constraintAnnotation).toString();
   }
 
   @Override
   public String getViolationMessage(final Locale locale,
       final Object actualValue)
   {
     final MessageInterpolator mi = FACTORY.getMessageInterpolator();
     final ConstraintDescriptor<A> desc =
         new PropertyConstraintDescriptor<A>(constraintAnnotation);
     final Context messageContext =
         new MessageInterpolatorContext(desc, actualValue);
     final String messageTemplate = extractMessageTemplate();
     final String message =
         mi.interpolate(messageTemplate, messageContext, locale);
     return message;
   }
 
   @Override
   public final boolean isValid(final T value, final Class<?> group)
   {
     if (isConstraintActivated(group))
     {
       final ConstraintValidatorContext context =
           new PropertyConstraintValidatorContext();
       final boolean valid = validator.isValid(value, context);
       return valid;
     }
     return true;
   }
 
   private boolean isConstraintActivated(final Class<?> group)
   {
     try
     {
       final Class<?>[] groups =
           (Class<?>[]) constraintAnnotation.annotationType()
               .getMethod("groups").invoke(constraintAnnotation);
       return ((group == null || group == Default.class) && hasNoGroups(groups))
              || (group != null && group != Default.class && isInGroup(groups,
                  group));
     }
     catch (final Exception e)
     {
       return true;
     }
   }
 
   private boolean hasNoGroups(final Class<?>[] groups)
   {
     try
     {
       return groups == null || groups.length == 0
              || (groups.length == 1 && groups[0] == Default.class);
     }
     catch (final Exception e)
     {
       return true;
     }
   }
 
   private boolean isInGroup(final Class<?>[] groups, final Class<?> group)
   {
     assert (group != null);
     try
     {
       for (final Class<?> current : groups)
       {
         if (current.isAssignableFrom(group))
         {
           return true;
         }
       }
     }
     catch (final Exception e)
     {
       // Defaults to returning false.
     }
     return false;
   }
 
   private String extractMessageTemplate()
   {
     try
     {
       return String.valueOf(constraintAnnotation.annotationType()
           .getMethod("message").invoke(constraintAnnotation));
     }
     catch (final Exception e)
     {
       return "";
     }
   }
 
   @Override
   public final boolean isMandatoryConstraint()
   {
     final Class<? extends Annotation> type =
         constraintAnnotation.annotationType();
     return NotNull.class == type || NotBlank.class == type;
   }
 
   // --- object basics --------------------------------------------------------
 
   /**
    * Reads the object from the given stream.
    *
    * @param in the stream to read from.
    * @throws IOException on read problems.
    * @throws ClassNotFoundException if a class cannot be found.
    */
   private void readObject(final ObjectInputStream in) throws IOException,
     ClassNotFoundException
   {
     in.defaultReadObject();
 
     try
     {
       this.validator = validatorClass.newInstance();
     }
     catch (final Exception e)
     {
       throw new IOException("Cannot deserialize validator.", e);
     }
   }
 }