package org.webslinger.ext.bsf.javaclass;

 import java.lang.reflect.Method;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.HashSet;

 import java.util.Set;

 import org.apache.bsf.BSFException;

 public final class ClassTypeUtil {

     public static Method findMostApplicableMethod(Class type, String name, Class[] types) throws NoSuchMethodException {

         Method[] methods = type.getMethods();

         ArrayList<Method> applicable = new ArrayList<Method>(methods.length);

 NEXT_METHOD:

         for (Method method: methods) {

             if (!name.equals(method.getName())) continue;

             Class[] methodParameterTypes = method.getParameterTypes();

             if (methodParameterTypes.length != types.length) continue;

             for (int j = 0; j < types.length; j++) {

                 if (!isMethodInvocationConvertible(types[j], methodParameterTypes[j])) continue NEXT_METHOD;

             }

             applicable.add(method);

         }

         if (applicable.isEmpty()) throw new NoSuchMethodException(name + "(" + Arrays.asList(types) + ")");

         if (applicable.size() == 1) return (Method) applicable.get(0);

         ArrayList<Method> maxApplicable = new ArrayList<Method>(applicable.size());

         for (int i = 0; i < applicable.size(); i++) {

             Method applicableMethod = (Method) applicable.get(i);

             int more = 0, less = 0;

             for (int j = 0; j < maxApplicable.size(); j++) {

                 Method maxMethod = maxApplicable.get(j);

                 if (isMoreSpecificThan(applicableMethod, maxMethod)) {

                     more++;

                 } else if (isLessSpecificThan(applicableMethod, maxMethod)) {

                     less--;

                 }

             }

             if (more == maxApplicable.size()) {

                 maxApplicable.clear();

                 maxApplicable.add(applicableMethod);

             } else if (less < maxApplicable.size()) {

                 maxApplicable.add(applicableMethod);

             }

         }

         if (maxApplicable.size() == 1) return maxApplicable.get(0);

         return null;

     }

     public static boolean isMethodInvocationConvertible(Class sourceType, Class targetType) {

         if (sourceType == targetType) return true;

         if (isWideningPrimitiveConvertible(sourceType, targetType)) return true;

         if (isWideningReferenceConvertible(sourceType, targetType)) return true;

         return false;

     }

     public static boolean isWideningPrimitiveConvertible(Class<?> sourceType, Class<?> targetType) {

         return PRIMITIVE_WIDENING_CONVERSIONS.contains(getDescriptor(sourceType) + getDescriptor(targetType));

     }

     public static boolean isWideningReferenceConvertible(Class<?> sourceType, Class<?> targetType) {

         if (targetType.isPrimitive() || sourceType == targetType) return false;

         return targetType.isAssignableFrom(sourceType);

     }

     public static boolean isMoreSpecificThan(Method me, Method that) {

         if (that.getDeclaringClass().isAssignableFrom(me.getDeclaringClass())) return false;

         Class<?>[] meParameterTypes = me.getParameterTypes();

         Class<?>[] thatParameterTypes = that.getParameterTypes();

         for (int i = 0; i < meParameterTypes.length; i++) {

             if (!thatParameterTypes[i].isAssignableFrom(meParameterTypes[i])) return false;

         }

         return true;

     }

     public static boolean isLessSpecificThan(Method me, Method that) {

         return isMoreSpecificThan(that, me);

     }

     public final static String VOID                 = "V";

     public final static String BYTE                 = "B";

     public final static String CHAR                 = "C";

     public final static String DOUBLE               = "D";

     public final static String FLOAT                = "F";

     public final static String INT                  = "I";

     public final static String LONG                 = "J";

     public final static String SHORT                = "S";

     public final static String BOOLEAN              = "Z";

     public final static String OBJECT               = "Ljava/lang/Object;";

     public final static String STRING               = "Ljava/lang/String;";

     public final static String CLASS                = "Ljava/lang/Class;";

     public final static String THROWABLE            = "Ljava/lang/Throwable;";

     public final static String RUNTIME_EXCEPTION    = "Ljava/lang/RuntimeException;";

     public final static String ERROR                = "Ljava/lang/Error;";

     public final static String CLONEABLE            = "Ljava/lang/Cloneable;";

     public final static String SERIALIZABLE         = "Ljava/io/Serializable;";

     public static final Set<String> PRIMITIVE_WIDENING_CONVERSIONS = new HashSet<String>(

         Arrays.asList(

             new String[] {

                 BYTE  + SHORT,

                 BYTE  + INT,

                 SHORT + INT,

                 CHAR  + INT,

                 BYTE  + LONG,

                 SHORT + LONG,

                 CHAR  + LONG,

                 INT   + LONG,

                 BYTE  + FLOAT,

                 SHORT + FLOAT,

                 CHAR  + FLOAT,

                 INT   + FLOAT,

                 LONG  + FLOAT,

                 BYTE  + DOUBLE,

                 SHORT + DOUBLE,

                 CHAR  + DOUBLE,

                 INT   + DOUBLE,

                 LONG  + DOUBLE,

                 FLOAT + DOUBLE,

             }

         )

     );

     public static String getDescriptor(Class type) {

         String className = type.getName();

         if (className.equals("void"   )) return VOID;

         if (className.equals("byte"   )) return BYTE;

         if (className.equals("char"   )) return CHAR;

         if (className.equals("double" )) return DOUBLE;

         if (className.equals("float"  )) return FLOAT;

         if (className.equals("int"    )) return INT;

         if (className.equals("long"   )) return LONG;

         if (className.equals("short"  )) return SHORT;

         if (className.equals("boolean")) return BOOLEAN;

         if (className.startsWith("[")) return className.replace('.', '/');

         return 'L' + className.replace('.', '/') + ';';

     }

 }