/**
    * This file Copyright (c) 2013-2015 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.i18nsystem.util;
  
  import com.google.common.base.Predicate;
  import org.reflections.ReflectionUtils;
  import java.lang.annotation.Annotation;
  import java.lang.reflect.AnnotatedElement;
  import java.lang.reflect.Method;
  import java.lang.reflect.TypeVariable;
  import java.util.Set;
  
  /**
   * Utility methods to retrieve annotations.
   * TODO : Cache ?
   */
  public class AnnotationUtils {
      private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(AnnotationUtils.class);
  
      public static boolean hasAnnotationOn(AnnotatedElement annotatedElement, final Class<? extends Annotation> annotationType) {
          if (annotatedElement instanceof Class) {
              return getAllAnnotationsOfType((Class) annotatedElement, annotationType).size() > 0;
          } else if (annotatedElement instanceof Method) {
              return isMethodAnnotatedWith((Method) annotatedElement, annotationType);
          } else if (annotatedElement instanceof TypeVariable) {
              log.debug("Looks like we're running on Java 8. Ignoring annotations on TypeVariable, skipping {}.", annotatedElement);
              return false;
          } else {
              throw new IllegalArgumentException("Only supports Class and Method, can't deal with " + annotatedElement + " (" + annotatedElement.getClass() + ")");
          }
      }
  
      public static <A extends Annotation> A getAnnotationOn(Class annotatedElement, final Class<A> annotationType) {
          final Set<A> allAnnotations = getAllAnnotationsOfType(annotatedElement, annotationType);
          if (allAnnotations.isEmpty()) {
              throw new IllegalStateException(annotatedElement + " is not annotated with @" + annotationType.getSimpleName());
          }
          if (allAnnotations.size() > 1) {
              // TODO figure out what to do in this case
              throw new IllegalStateException();
          }
  
          return allAnnotations.iterator().next();
      }
  
      private static <A extends Annotation> Set<A> getAllAnnotationsOfType(Class clazz, Class<A> annotationType) {
          // ReflectionUtils.getAllAnnotations only really works on classes. If passed a Method, it does not walk up the class hierarchy
          return (Set<A>) ReflectionUtils.getAllAnnotations(clazz, new AnnotationTypePredicate(annotationType));
      }
  
      /**
       * Checks if the given method or one of its superclass/interface definition is annotated with the given annotation.
       */
      private static boolean isMethodAnnotatedWith(Method method, Class<? extends Annotation> annotation) {
          final Set<Class<?>> clazzes = ReflectionUtils.getAllSuperTypes(method.getDeclaringClass());
          for (Class clazz : clazzes) {
              try {
                  final Method m = clazz.getDeclaredMethod(method.getName(), method.getParameterTypes());
                  if (m.isAnnotationPresent(annotation)) {
                      return true;
                  }
              } catch (NoSuchMethodException e) {
              }
          }
  
          return false;
      }
  
     private static class AnnotationTypePredicate implements Predicate<Annotation> {
         private final Class<? extends Annotation> annotationType;
 
         public AnnotationTypePredicate(Class<? extends Annotation> annotationType) {
             this.annotationType = annotationType;
         }
 
         @Override
         public boolean apply(Annotation input) {
             return annotationType.isInstance(input);
         }
     }
 }