/*

  * 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);

     }

   }

 }