package org.apache.onami.validation;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import static java.lang.String.format;
  import static java.util.Arrays.deepToString;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Method;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.Set;
  
  import javax.inject.Inject;
  import javax.validation.ConstraintViolation;
  import javax.validation.ConstraintViolationException;
  import javax.validation.Validator;
  import javax.validation.ValidatorFactory;
  
  import org.aopalliance.intercept.MethodInterceptor;
  import org.aopalliance.intercept.MethodInvocation;
  import org.apache.bval.jsr303.extensions.MethodValidator;
  
  /**
   * Method interceptor for {@link Validate} annotation.
   */
  final class ValidateMethodInterceptor
      implements MethodInterceptor
  {
  
      private static final Class<?>[] CAUSE_TYPES = new Class[] { Throwable.class };
  
      private static final Class<?>[] MESSAGE_CAUSE_TYPES = new Class[] { String.class, Throwable.class };
  
      /**
       * The {@link ValidatorFactory} reference.
       */
      @Inject
      private ValidatorFactory validatorFactory;
  
      /**
       * {@inheritDoc}
       */
      public Object invoke( MethodInvocation invocation )
          throws Throwable
      {
          Validate validate = invocation.getMethod().getAnnotation( Validate.class );
  
          Validator validator = validatorFactory.getValidator();
          MethodValidator methodValidator = validator.unwrap( MethodValidator.class );
  
          Set<ConstraintViolation<?>> constraintViolations = new HashSet<ConstraintViolation<?>>();
          Class<?> clazz = invocation.getMethod().getDeclaringClass();
          Method method = invocation.getMethod();
          Object[] arguments = invocation.getArguments();
          Class<?>[] groups = validate.groups();
  
          constraintViolations.addAll( methodValidator.validateParameters( clazz, method, arguments, groups ) );
  
          if ( !constraintViolations.isEmpty() )
          {
              throw getException( new ConstraintViolationException( format( "Validation error when calling method '%s' with arguments %s",
                                                                            method,
                                                                            deepToString( arguments ) ),
                                                                    constraintViolations ),
                                  validate.rethrowExceptionsAs(),
                                  validate.exceptionMessage(),
                                  arguments );
          }
  
          Object returnedValue = invocation.proceed();
  
          if ( validate.validateReturnedValue() )
          {
              constraintViolations.addAll( methodValidator.validateReturnedValue( clazz, method, returnedValue, groups ) );
  
              if ( !constraintViolations.isEmpty() )
              {
                  throw getException( new ConstraintViolationException( format( "Method '%s' returned a not valid value %s",
                                                                                method,
                                                                                returnedValue ),
                                                                        constraintViolations ),
                                     validate.rethrowExceptionsAs(),
                                     validate.exceptionMessage(),
                                     arguments );
             }
         }
 
         return returnedValue;
     }
 
     /**
      * Define the {@link Throwable} has to be thrown when a validation error occurs and the user defined the custom
      * error wrapper.
      *
      * @param exception the occurred validation error.
      * @param exceptionWrapperClass the user defined custom error wrapper.
      * @return the {@link Throwable} has o be thrown.
      */
     private static Throwable getException( ConstraintViolationException exception,
                                            Class<? extends Throwable> exceptionWrapperClass,
                                            String exceptionMessage,
                                            Object[] arguments )
     {
         // check the thrown exception is of same re-throw type
         if ( exceptionWrapperClass == ConstraintViolationException.class )
         {
             return exception;
         }
 
         // re-throw the exception as new exception
         Throwable rethrowEx = null;
 
         String errorMessage;
         Object[] initargs;
         Class<?>[] initargsType;
 
         if ( exceptionMessage.length() != 0 )
         {
             errorMessage = format( exceptionMessage, arguments );
             initargs = new Object[] { errorMessage, exception };
             initargsType = MESSAGE_CAUSE_TYPES;
         }
         else
         {
             initargs = new Object[] { exception };
             initargsType = CAUSE_TYPES;
         }
 
         Constructor<? extends Throwable> exceptionConstructor = getMatchingConstructor( exceptionWrapperClass,
                                                                                         initargsType );
         if ( exceptionConstructor != null )
         {
             try
             {
                 rethrowEx = exceptionConstructor.newInstance( initargs );
             }
             catch ( Exception e )
             {
                 errorMessage = format( "Impossible to re-throw '%s', it needs the constructor with %s argument(s).",
                                        exceptionWrapperClass.getName(),
                                        Arrays.toString( initargsType ) );
                 rethrowEx = new RuntimeException( errorMessage, e );
             }
         }
         else
         {
             errorMessage = format( "Impossible to re-throw '%s', it needs the constructor with %s or %s argument(s).",
                                    exceptionWrapperClass.getName(), Arrays.toString( CAUSE_TYPES ),
                                    Arrays.toString( MESSAGE_CAUSE_TYPES ) );
             rethrowEx = new RuntimeException( errorMessage );
         }
 
         return rethrowEx;
     }
 
     @SuppressWarnings( "unchecked" )
     private static <E extends Throwable> Constructor<E> getMatchingConstructor( Class<E> type, Class<?>[] argumentsType )
     {
         Class<? super E> currentType = type;
         while ( Object.class != currentType )
         {
             for ( Constructor<?> constructor : currentType.getConstructors() )
             {
                 if ( Arrays.equals( argumentsType, constructor.getParameterTypes() ) )
                 {
                     return (Constructor<E>) constructor;
                 }
             }
             currentType = currentType.getSuperclass();
         }
         return null;
     }
 
 }