/*
    * Copyright 2010 The Kuali Foundation
    * 
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    * 
   * 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.kuali.rice.core.versions;
  
  import org.kuali.rice.core.versions.annotations.DeprecatedSince;
  import org.kuali.rice.core.versions.annotations.SupportedSince;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.AnnotatedElement;
  import java.lang.reflect.Field;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  public class VersionHelper {
      public static boolean areVersionsCompatible(Object source, Object target) {
          double sourceVer = getHighestVersion(source);
          double targetVer = getHighestVersion(target);
          return targetVer <= sourceVer;
      }
  
      public static boolean isVersionCompatible(Object obj, double ver) {
          return ver <= getHighestVersion(obj);
      }
  
      public static double getHighestVersion(Object obj) {
          // TODO: Could be more efficient using an Array Copy
          Class clazz = obj.getClass();
          Method[] methods = clazz.getMethods();
          Field[] fields = clazz.getFields();
          List<AnnotatedElement> elements;
          elements = new ArrayList<AnnotatedElement>(methods.length + fields.length + 1);
          elements.add(clazz);
          elements.addAll(Arrays.asList(methods));
          elements.addAll(Arrays.asList(fields));
          return getHighestVersion(elements);
      }
  
      protected static double getHighestVersion(List<AnnotatedElement> elements) {
          double highestVersion = 1.0;
          for ( AnnotatedElement element : elements ) {
              DeprecatedSince deprecated = element.getAnnotation(DeprecatedSince.class);
              SupportedSince supported = element.getAnnotation(SupportedSince.class);
              double compareVersion = getHighestVersion(
                      new Annotation[] {deprecated, supported});
              if ( highestVersion < compareVersion )
                  highestVersion = compareVersion;
          }
          return highestVersion;
      }
  
      protected static double getHighestVersion(Annotation[] annotations) {
          double highestVersion = 1.0;
          for ( Annotation annotation : annotations ) {
              double compareVersion = 1.0;
              if ( annotation instanceof DeprecatedSince )
                  compareVersion = ((DeprecatedSince)annotation).version();
              else if ( annotation instanceof DeprecatedSince )
                  compareVersion = ((SupportedSince)annotation).version();
              if ( highestVersion < compareVersion )
                  highestVersion = compareVersion;
          }
          return highestVersion;
      }
  
      public static boolean isMethodSupported(Object obj, String methodName,
                                              double ver) {
          Method[] methods = obj.getClass().getMethods();
          for ( Method method : methods ) {
              if ( method.getName().equals(methodName) ) {
                  // TODO: Do this better, prefer methods with annotations
                  //       to those without
                  return isMethodSupported(method, ver);
              }
          }
          return false;
      }
  
      public static boolean isMethodSupported(Method method, double ver) {
          SupportedSince supported = method.getAnnotation(SupportedSince.class);
          DeprecatedSince deprecated = method.getAnnotation(DeprecatedSince.class);
          return isVersionValid(supported, deprecated, ver);
      }
  
      public static boolean isFieldSupported(Object obj, String fieldName,
                                            double ver) {
         try {
             Field field = obj.getClass().getField(fieldName);
             return isFieldSupported(field, ver);
         }
         catch ( NoSuchFieldException e ) {
             return false;
         }
     }
 
     public static boolean isFieldSupported(Field field, double ver) {
         SupportedSince supported = field.getAnnotation(SupportedSince.class);
         DeprecatedSince deprecated = field.getAnnotation(DeprecatedSince.class);
         return isVersionValid(supported, deprecated, ver);
     }
 
     public static boolean isClassSupported(Object obj, double ver) {
         SupportedSince supported = obj.getClass().getAnnotation(SupportedSince.class);
         DeprecatedSince deprecated = obj.getClass().getAnnotation(DeprecatedSince.class);
         return isVersionValid(supported, deprecated, ver);
     }
 
     protected static boolean isVersionValid(SupportedSince supported,
                                             DeprecatedSince deprecated,
                                             double ver) {
         double supportedVersion = supported != null ? supported.version() : 1.0;
         if ( supported == null || supported.version() <= ver )
             return ( deprecated == null || ver < deprecated.version() );
         else
             return false;
     }
 }