/*
    * AutoDAO - Generic DAO on steroids implementation for Java.
    *
    * Copyright 2008-2012  Marat Radchenko <slonopotamus@users.sourceforge.net>
    *
    * 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 net.sf.autodao.impl;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import net.sf.autodao.Finder;
  import net.sf.autodao.Named;
  import net.sf.autodao.QueryArgumentTransformer;
  import org.aopalliance.intercept.MethodInterceptor;
  import org.aopalliance.intercept.MethodInvocation;
  import org.jetbrains.annotations.NotNull;
  import org.jetbrains.annotations.Nullable;
  import org.springframework.core.annotation.AnnotationUtils;
  import org.springframework.transaction.interceptor.TransactionAspectSupport;
  
  /**
   * Intercepts finder DAO calls and calls execute*Finder methods on dao.
   *
   * <p>NOT FOR PUBLIC USE.
   */
  final class FinderIntroductionInterceptor extends TransactionAspectSupport implements MethodInterceptor {
  
    @NotNull
    private final Map<Class<?>, QueryArgumentTransformer<?, ?>> transformers;
  
    FinderIntroductionInterceptor(@NotNull final Map<Class<?>, QueryArgumentTransformer<?, ?>> transformers) {
      this.transformers = transformers;
    }
  
    /** {@inheritDoc} */
    @Override
    public Object invoke(@NotNull final MethodInvocation invocation) throws Throwable {
      final Method method = invocation.getMethod();
      final Finder finder = AnnotationUtils.getAnnotation(method, Finder.class);
  
      if (finder == null)
        return invocation.proceed();
  
      final Object[] arguments = invocation.getArguments();
      final Integer[] limit = new Integer[1];
      final Integer[] offset = new Integer[1];
      final List<Object> queryArgs = new ArrayList<>(arguments.length);
      final Map<String, Object> namedArgs = new HashMap<>(arguments.length);
      Utils.visitMethodParameters(method, new Utils.ParameterCallback() {
        @Override
        public void visit(final int index, @NotNull final Class<?> type, @NotNull final Annotation[] annotations) {
          boolean processed = false;
          final Object arg = arguments[index];
          if (Utils.getLimit(annotations) != null) {
            limit[0] = (Integer) arg;
            processed = true;
          }
  
          if (Utils.getOffset(annotations) != null) {
            offset[0] = (Integer) arg;
            processed = true;
          }
  
          if (processed)
            return;
  
          final Object queryArg = transformArg(arg, method.getParameterTypes()[index]);
          final Named named = Utils.getNamed(annotations);
          if (named == null) {
            queryArgs.add(queryArg);
          } else {
            namedArgs.put(named.value(), queryArg);
          }
        }
      });
  
      final FinderExecutor dao = (FinderExecutor) invocation.getThis();
      if (Collection.class.isAssignableFrom(invocation.getMethod().getReturnType())) {
        final List<Object> data;
        if (namedArgs.isEmpty()) {
          data = dao.executeListFinder(method, queryArgs.toArray(new Object[queryArgs.size()]), limit[0], offset[0]);
        } else {
         data = dao.executeListFinder(method, namedArgs, limit[0], offset[0]);
       }
       return convertResult(finder, data);
     } else {
       if (namedArgs.isEmpty()) {
         return dao.executeSingleFinder(method, arguments);
       } else {
         return dao.executeSingleFinder(method, namedArgs);
       }
     }
   }
 
   @SuppressWarnings({ "unchecked", "rawtypes" })
   @Nullable
   private Object transformArg(@Nullable final Object arg, @NotNull final Class<?> declaredArgType) {
     if (arg == null)
       return null;
 
     final QueryArgumentTransformer transformer = transformers.get(declaredArgType);
     if (transformer == null)
       return arg;
 
     return transformer.transform(arg);
   }
 
   @SuppressWarnings({ "unchecked", "rawtypes" })
   private static Object convertResult(final Finder finder, final List<Object> data) throws Exception {
     final Class<? extends Collection> returnAs = finder.returnAs();
     if (returnAs == List.class)
       return data;
 
     final Collection<Object> result = returnAs.newInstance();
     result.addAll(data);
     return result;
   }
 }