/*

  * 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 java.io.IOException;

 import java.io.ObjectInputStream;

 import java.lang.annotation.Annotation;

 import java.util.List;

 import java.util.Locale;

 import javax.validation.ConstraintValidator;

 import javax.validation.ConstraintValidatorContext;

 import javax.validation.constraints.NotNull;

 import org.hibernate.validator.constraints.NotBlank;

 import org.hibernate.validator.internal.metadata.core.ConstraintHelper;

 import de.smartics.properties.spi.core.constraint.AbstractPropertyConstraint;

 import de.smartics.util.lang.Arguments;

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

   /**

    * Appease PMD.

    */

   private static final String UNCHECKED = "unchecked";

   /**

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

    * @throws NullArgumentException if {@code constraintAnnotation} is

    *           <code>null</code>.

    */

   @SuppressWarnings(UNCHECKED)

   public GenericPropertyConstraint(final A constraintAnnotation)

     throws NullArgumentException

   {

     this((ConstraintValidator<A, T>) createValidator(constraintAnnotation),

         constraintAnnotation);

   }

   // /**

   // * Convenience constructor if to provide the validator as a class.

   // *

   // * @param validatorClass the class of the validator to validate values.

   // * @param constraintAnnotation the JSR-303 constraint annotation.

   // * @throws NullArgumentException if {@code constraintAnnotation} is

   // * <code>null</code>.

   // */

   // public GenericPropertyConstraint(

   // final Class<ConstraintValidator<A, T>> validatorClass,

   // final A constraintAnnotation) throws NullArgumentException

   // {

   // this((ConstraintValidator<A, T>) createValidator(validatorClass),

   // 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

   {

     Arguments.checkNotNull("validator", validator);

     Arguments.checkNotNull("constraintAnnotation", constraintAnnotation);

     this.validator = validator;

     this.constraintAnnotation = constraintAnnotation;

     this.validatorClass =

         (Class<? extends ConstraintValidator<A, T>>) validator.getClass();

     validator.initialize(constraintAnnotation);

   }

   // ****************************** Inner Classes *****************************

   // ********************************* Methods ********************************

   // --- init -----------------------------------------------------------------

   @SuppressWarnings({ UNCHECKED, "rawtypes" })

   private static <A extends Annotation, T> ConstraintValidator<A, T> createValidator(

       final A constraintAnnotation) 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 > 0)

       {

         final Class<? extends ConstraintValidator<A, T>> type =

             (Class<ConstraintValidator<A, T>>) validatorClass[0];

         final ConstraintValidator validator =

             (ConstraintValidator) createValidator(type);

         return validator;

       }

       else

       {

         final Class<? extends Annotation> annotationType =

             constraintAnnotation.annotationType();

         final List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> validators =

             CONSTRAINTS.getBuiltInConstraints(annotationType);

         if (!validators.isEmpty())

         {

           final Class<? extends ConstraintValidator<A, T>> type =

               (Class<? extends ConstraintValidator<A, T>>) validators.get(0);

           final ConstraintValidator validator =

               (ConstraintValidator) createValidator(type);

           return validator;

         }

       }

     }

     throw new IllegalArgumentException(

         "Cannot derive constraint validator from annotation: "

             + constraintAnnotation);

   }

   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 =

           (ConstraintValidator<A, T>) 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 final boolean isValid(final T value)

   {

     // Unsure if the context may be null, therefore we fake it:

     final ConstraintValidatorContext context =

         new PropertyConstraintValidatorContext();

     // new ConstraintValidatorContextImpl(PathImpl.createRootPath(),

     // new ConstraintDescriptorImpl<A>(constraintAnnotation,

     // new ConstraintHelper(), ElementType.FIELD,

     // ConstraintOrigin.DEFINED_LOCALLY));

     final boolean valid = validator.isValid(value, context);

     return valid;

   }

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

     }

   }

 }