/*
    * Copyright 2012 the original author or authors.
    * 
    * 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 org.callbackparams.internal.template.annotation;
  
  import java.lang.annotation.Annotation;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.lang.reflect.AnnotatedElement;
  import java.lang.reflect.Field;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  import org.callbackparams.ext.WrappingCallbackImpls;
  import org.callbackparams.wrap.legacy.Wrapping;
  
  /**
   * @author Henrik Kaipe
   */
  enum WrappingClassLocator {
  
      IMPL_ON_ENUM_CONSTANT {
          @Override List<Class<? extends Wrapping>[]> locateClasses(Object value) {
              return asWrappingClassList(asEnumConstantField(value)
                      .getAnnotation(WrappingCallbackImpls.class));
          }
      },
  
      @CanBeSubclassedByClassSpecifiedImpl
      IMPL_ON_ENUM_CONSTANT_ANNOTATION {
          @Override List<Class<? extends Wrapping>[]> locateClasses(Object value) {
              List<Class<? extends Wrapping>[]> wrappingList =
                      new ArrayList<Class<? extends Wrapping>[]>();
              for (Annotation a : asEnumConstantField(value).getAnnotations()) {
                  final WrappingCallbackImpls implsOnAnnotation = a
                          .annotationType()
                          .getAnnotation(WrappingCallbackImpls.class);
                  if (null != implsOnAnnotation) {
                      wrappingList.add(implsOnAnnotation.value());
                  }
              }
              return wrappingList;
          }
      },
  
      IMPL_ON_ENUM_CLASS_OR_VALUE_CLASS {
  
          private WrappingCallbackImpls findImplOn(Class<?> c) {
              for (Annotation a : c.getDeclaredAnnotations()) {
                  if (WrappingCallbackImpls.class == a.annotationType()) {
                      return (WrappingCallbackImpls) a;
                  }
              }
              return null;
          }
  
          @Override List<Class<? extends Wrapping>[]> locateClasses(Object value) {
              WrappingCallbackImpls wrappingImpl = findImplOn(value.getClass());
              if (null == wrappingImpl) {
                  AnnotatedElement possibleEnumField = asEnumConstantField(value);
                  if (possibleEnumField instanceof Field) {
                      wrappingImpl = findImplOn(
                              ((Field)possibleEnumField).getDeclaringClass());
                  }
              }
              return asWrappingClassList(wrappingImpl);
          }
      },
  
      @CanBeSubclassedByClassSpecifiedImpl
      IMPL_ON_CLASS_ANNOTATION_OR_IMPL_ON_SUPER_CLASS {
  
          @Override List<Class<? extends Wrapping>[]> locateClasses(Object value) {
              Class<?> c = value.getClass();
              final WrappingCallbackImpls superClassImpl =
                      c.getAnnotation(WrappingCallbackImpls.class);
              final List<Class<? extends Wrapping>[]> wrappingList =
                      new ArrayList<Class<? extends Wrapping>[]>();
  
              LOOP_THROUGH_CLASS_HIERARCY: do {
                  for (Annotation a : c.getDeclaredAnnotations()) {
                      if (a == superClassImpl) {
                          break LOOP_THROUGH_CLASS_HIERARCY;
                      } else {
                          WrappingCallbackImpls annotationImpl = a.annotationType()
                                  .getAnnotation(WrappingCallbackImpls.class);
                         if (null != annotationImpl) {
                             wrappingList.add(annotationImpl.value());
                         }
                     }
                 }
                 if (false == wrappingList.isEmpty()) {
                     return wrappingList;
                 }
             } while (Object.class != (c = c.getSuperclass()));
             return asWrappingClassList(superClassImpl);
         }
     };
 
     private static final AnnotatedElement NOT_AN_ENUM_CONSTANT =
             new AnnotatedElement() {
         private final Annotation[] NO_ANNOTATIONS = {};
 
         public <T extends Annotation> T getAnnotation(
                 Class<T> annotationClass) { return null; }
         public Annotation[] getAnnotations() { return NO_ANNOTATIONS; }
         public Annotation[] getDeclaredAnnotations() { return NO_ANNOTATIONS; }
         public boolean isAnnotationPresent(
                 Class<? extends Annotation> annotationClass) { return false; }
     };
 
     private static AnnotatedElement asEnumConstantField(Object value) {
         if (value instanceof Enum<?>) {
             final Enum<?> enumConstant = (Enum<?>) value;
             try {
                 Field enumConstantField = enumConstant.getDeclaringClass()
                         .getField(enumConstant.name());
                 try {
                     enumConstantField.setAccessible(true);
                 } catch (SecurityException ignoreAndTryToContinueAnyway) {}
                 if (enumConstantField.isEnumConstant()
                         && enumConstant == enumConstantField.get(null)) {
                     return enumConstantField;
                 }
             } catch (Throwable ignore) {
                 /*
                  * This can happen if the specified value is not really an
                  * enum-constant - in spite of being of type Enum<?>.
                  */
             }
         }
         return NOT_AN_ENUM_CONSTANT;
     }
 
     private static List<Class<? extends Wrapping>[]> asWrappingClassList(
             WrappingCallbackImpls possibleImpl) {
         if (null == possibleImpl) {
             return Collections.<Class<? extends Wrapping>[]>emptyList();
         } else {
             return Collections.singletonList(possibleImpl.value());
         }
     }
 
     boolean canBeSubclassedByClassSpecifiedImpl() {
         return asEnumConstantField(this)
                 .isAnnotationPresent(CanBeSubclassedByClassSpecifiedImpl.class);
     }
 
     abstract List<Class<? extends Wrapping>[]> locateClasses(Object value);
 
     @Retention(RetentionPolicy.RUNTIME)
     @interface CanBeSubclassedByClassSpecifiedImpl {}
 }