package net.sf.crispy.util;
   
   import java.lang.reflect.Method;
   import java.security.AccessController;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.Vector;
  
  
  /**
   * Work with reflection API.
   * 
   * @author Linke
   *
   */
  public final class Invoker {
  
  	private Invoker() { super(); }
  	
  	private static Map compatibleTypes = new HashMap();
  	
  	/**
  	 * Invoke method from pvObject with the method-name (pvMethodName) and parameter (pvPrams) via reflection.
  	 * @param pvObject object for the method call
  	 * @param pvMethodName name of method
  	 * @param pvParams parameter for method
  	 * @return the return value from the method call 
  	 * @throws Exception
  	 */
  	public static Object invokeWithConverter (Object pvObject, String pvMethodName, Vector pvParams, Converter pvConverter) throws Exception {
  		return invoke (pvObject, pvMethodName, pvParams, true, pvConverter);
  	}
  	
  	public static Object invoke (String pvClassName, String pvMethodName, Vector pvParams, boolean pvWithConverter, Converter pvConverter) throws Exception {
  		Class lvClass = Class.forName(pvClassName);
  		Object lvObject = lvClass.newInstance();
  		return invoke (lvObject, pvMethodName, pvParams, pvWithConverter, pvConverter);
  	}
  	
  	public static Object invoke (Object pvObject, String pvMethodName, Vector pvParams, boolean pvWithConverter, Converter pvConverter) throws Exception {
  		Class clazz = pvObject.getClass();
         	Method lvMethod = findMethod(clazz, pvMethodName, pvParams);
         	Converter lvConverter = (pvWithConverter == true ? pvConverter : null);
         	Object[] lvArgs = vector2Array(pvParams, lvMethod, lvConverter);
         	AccessController.doPrivileged(new MethodAccessiblePrivilegedAction(lvMethod));
     	   	Object lvMethodResult = null; 
     	   	try {
     	   		lvMethodResult = lvMethod.invoke(pvObject, lvArgs);
     	   	} catch (IllegalArgumentException e) {
     	   		throw new IllegalArgumentException("Illegal argument by method: " + lvMethod + " and args: " + pvParams + " with object: " + pvObject);
     	   	}
          if (pvWithConverter == true) {
          	lvMethodResult = lvConverter.makeSimple (lvMethodResult);
         	}
          return lvMethodResult;
  	}
  	
  	public static Object[] vector2Array(Vector pvVector, Method pvMethod, Converter pvConverter) throws Exception {
     	   	Object[] lvArgs = new Object[pvVector.size()];
     	   	int lvMethodParamsLength = pvMethod.getParameterTypes().length;
     	   	int lvVectorSize = pvVector.size();
     	   	for (int j = 0; j < lvArgs.length; j++) {
     	   		if (pvConverter != null) {
     	   			if (lvMethodParamsLength == lvVectorSize) {
  //   	   			if (pvMethod.getParameterTypes().length > j) {
  	   	   			Class lvParamType = pvMethod.getParameterTypes()[j];
  	   	   			if (lvParamType.isArray()) {
  	   	   				Class lvType = lvParamType.getComponentType(); 
  	   	   	   			lvArgs[j] = pvConverter.makeComplex (pvVector.get(j), lvParamType, lvType);
  	   	   			} else {
  	   	   				lvArgs[j] = pvConverter.makeComplex (pvVector.get(j), lvParamType);	
  	   	   			}
     	   			} 
     	   			// pvVector.size > pvMethod.getParameterTypes().length
     	   			// ??? Critical Point ???
     	   			else {
     	   				lvArgs[j] = pvConverter.makeComplex (pvVector.get(j));
     	   			}
     	   		} 
     	   		// Converter == null
     	   		else {
     	   			lvArgs[j] = pvVector.get(j);
     	   		}
     	   	}    
  		return lvArgs;
  	}
  	
  	public static boolean isCompatibleType (Class pvType1, Class pvType2) {
  		if (compatibleTypes.size() == 0) {
  			compatibleTypes.put(byte.class, Byte.class);
  			compatibleTypes.put(short.class, Short.class);
  			compatibleTypes.put(int.class, Integer.class);
  			compatibleTypes.put(long.class, Long.class);
  			compatibleTypes.put(float.class, Float.class);
  			compatibleTypes.put(double.class, Double.class);
  			compatibleTypes.put(char.class, Character.class);
  			compatibleTypes.put(boolean.class, Boolean.class);
 			
 			compatibleTypes.put(Long.class, long.class);
 		}
 		Class lvType = (Class) compatibleTypes.get(pvType1);
 		boolean lvReturn = false;
 		if (lvType != null) {
 			lvReturn = (compatibleTypes.get(pvType1).equals(pvType2));
 		}
 		return lvReturn;
 	}
 	
 	public static Method findMethod(Class pvClass, String pvMethodName, List pvParams) throws Exception {
 		List lvParams = pvParams;
 		if (lvParams == null) { lvParams = new ArrayList(0); }
 		Method[] lvMethods = findAllMethods(pvClass, pvMethodName);
         Method lvMerkMethod = null;
         for (int i = 0; i < lvMethods.length; i++) {
        		Class lvParamTypes[] = lvMethods[i].getParameterTypes();
 
        		// Methoden-Parameter und pvParams muessen gleiche Anzahl haben
        		if (lvParamTypes.length == lvParams.size()) {
        			// wenn Name und Anzahl Parameter uebereinstimmen, dann Methode merken
        			lvMerkMethod = lvMethods[i];
         			
        			boolean lvParamOk = true;
        			for (int j = 0; j < lvParamTypes.length; j++) {
 					if (lvParamTypes[j].isArray()) {
 						Class lvParamArrayType = Converter.getArrayType(lvParams.get(j));
 						// Typen im Array stimmen NICHT ueberein
 						if (!lvParamTypes[j].getComponentType().equals(lvParamArrayType)) {
 							lvParamOk = false;
 							break;
 						}
 					} else {
 						Class lvParamClass = (lvParams.get(j) == null ? null : lvParams.get(j).getClass());
 						if ((!lvParamTypes[j].equals(lvParamClass)) && (!isCompatibleType(lvParamTypes[j], lvParamClass))) {
 							lvParamOk = false;
 							break;
 						}
 					}
 				}
            		// Methodenname und Parameter stimmen ueberein
            		if (lvParamOk) {
            			return lvMethods[i]; 
            		}
        		}
         }
         
         if (lvMerkMethod != null) {
         	return lvMerkMethod; 
         } 
         // ???  if the method has the right name, but the size of parameters is not correct ???
         // ??? by overloading can the chois from this method false ???
         else if (lvMethods.length > 0) {
         	return lvMethods[0];
         }
         throw new NoSuchMethodException("For class: " + pvClass 
         		+ " with method: " + pvMethodName + " with parameter: " + lvParams);
 	}
 
 	public static Method[] findAllMethods(Class pvClass, String pvMethodName) throws Exception {
         Method[] lvMethods = pvClass.getMethods();
         ArrayList lvFindedMethods = new ArrayList();
         for (int i = 0; i < lvMethods.length; i++) {
         	if (lvMethods[i].getName().equals(pvMethodName)){
         		lvFindedMethods.add(lvMethods[i]);
         	}
         }
         return (Method[]) lvFindedMethods.toArray(new Method [lvFindedMethods.size()]);
 	}
 
 	public static Vector array2Vector (Object [] pvArray) throws Exception {
         Vector param = new Vector(); 
         if (pvArray != null){
         	for (int i = 0; i < pvArray.length; i++) {
         		param.add(pvArray[i]);
         	}
         }
 		return param;
 	}
 	
 	public static Vector array2SimpleVector (Object [] pvArray) throws Exception {
         Vector param = new Vector(); 
         if (pvArray != null){
         	Converter lvConverter = new Converter();
         	for (int i = 0; i < pvArray.length; i++) {
                param.add(lvConverter.makeSimple(pvArray[i]));
         	}
          }
 		return param;
 	}
 	
 	public static Object[] array2SimpleArray (Object [] pvArray, Converter pvConverter) throws Exception {
         Object ret[] = null; 
         if (pvArray != null){
            ret = new Object[pvArray.length];
            for (int i = 0; i < pvArray.length; i++) {
                ret[i] = pvConverter.makeSimple(pvArray[i]);
            }
          }
 		return ret;
 	}
 	
 }