package org.kite9.framework.model;
   
   import java.lang.reflect.Field;
   import java.lang.reflect.Method;
   import java.util.LinkedHashSet;
   import java.util.Set;
   
   import org.kite9.framework.common.Kite9ProcessingException;
   
  /***
   * Handle to a class member (method or field).
   * Also contains static utility functions for converting from string name of class back into
   * Class object, and doing the same with methods and fields.
   * 
   * @author moffatr
   * 
   */
  public class MemberHandle implements Comparable<MemberHandle> {
  
  	public enum MemberType {
  		FIELD, METHOD
  	};
  
  	public MemberHandle(String className, String memberName, MemberType mt, String params) {
  		super();
  		this.className = className;
  		this.methodName = memberName;
  		this.memberType = mt;
  		this.params = params;
  	}
  
  	public MemberHandle(Method m) {
  		super();
  		this.className = convertClass(m.getDeclaringClass());
  		this.methodName = m.getName();
  		this.memberType = MemberType.METHOD;
  		this.params = Type.getMethodDescriptor(m);
  	}
  
  	public MemberHandle(Field f) {
  		super();
  		this.className = convertClass(f.getDeclaringClass());
  		this.methodName = f.getName();
  		this.memberType = MemberType.FIELD;
  		this.params = null;
  	}
  
  	public static String convertClass(Class<?> clazz) {
  		return clazz.getName().replace(".", "/");
  	}
  
  	public static String convertParams(Class<?>[] params2) {
  		StringBuffer sb = new StringBuffer(100);
  		for (int i = 0; i < params2.length; i++) {
  			sb.append(convertClass(params2[i]));
  			if (i < params2.length - 1) {
  				sb.append(";");
  			}
  		}
  
  		return sb.toString();
  	}
  
  	private String className;
  	private String methodName;
  	private MemberType memberType;
  	private String params;
  
  	public String getClassName() {
  		return className;
  	}
  
  	public String getMethodName() {
  		return methodName;
  	}
  
  	public String getParams() {
  		return params;
  	}
  
  	@Override
  	public String toString() {
  		return className + "/" + methodName;
  	}
  
  	public MemberType getMemberType() {
  		return memberType;
  	}
  
  	@Override
  	public int hashCode() {
  		final int prime = 31;
  		int result = 1;
  		result = prime * result + ((className == null) ? 0 : className.hashCode());
  		result = prime * result + ((memberType == null) ? 0 : memberType.hashCode());
  		result = prime * result + ((methodName == null) ? 0 : methodName.hashCode());
  		result = prime * result + ((params == null) ? 0 : params.hashCode());
  		return result;
  	}
 
 	@Override
 	public boolean equals(Object obj) {
 		if (this == obj)
 			return true;
 		if (obj == null)
 			return false;
 		if (getClass() != obj.getClass())
 			return false;
 		MemberHandle other = (MemberHandle) obj;
 		if (className == null) {
 			if (other.className != null)
 				return false;
 		} else if (!className.equals(other.className))
 			return false;
 		if (memberType == null) {
 			if (other.memberType != null)
 				return false;
 		} else if (!memberType.equals(other.memberType))
 			return false;
 		if (methodName == null) {
 			if (other.methodName != null)
 				return false;
 		} else if (!methodName.equals(other.methodName))
 			return false;
 		if (params == null) {
 			if (other.params != null)
 				return false;
 		} else if (!params.equals(other.params))
 			return false;
 		return true;
 	}
 
 	public static Set<Class<?>> hydrateClasses(Set<String> classNames, ClassLoader cl) {
 		Set<Class<?>> out = new LinkedHashSet<Class<?>>(classNames.size());
 		for (String n : classNames) {
 			out.add(hydrateClass(n, cl));
 		}
 
 		return out;
 	}
 
 	public static Set<Method> hydrateMethods(Set<MemberHandle> methods, ClassLoader cl) {
 		Set<Method> out = new LinkedHashSet<Method>(methods.size());
 		for (MemberHandle n : methods) {
 			out.add(hydrateMethod(n, cl));
 		}
 
 		return out;
 	}
 
 	public static Set<Field> hydrateFields(Set<MemberHandle> fields, ClassLoader cl) {
 		Set<Field> out = new LinkedHashSet<Field>(fields.size());
 		for (MemberHandle n : fields) {
 			out.add(hydrateField(n, cl));
 		}
 
 		return out;
 	}
 
 	
 	public static Class<?> hydrateClass(String className, ClassLoader cl) {
 		try {
 			String name = className.replace("/", ".");
 			Class<?> c = cl.loadClass(name);
 
 			return c;
 		} catch (ClassNotFoundException e) {
 			throw new Kite9ProcessingException("Could not load class: ", e);
 		}
 	}
 
 	public static Class<?>[] hydrateParams(Type[] types, ClassLoader cl) {
 		if ((types == null) || (types.length == 0)) {
 			return new Class<?>[0];
 		}
 		
 		Class<?>[] out = new Class<?>[types.length];
 		for (int i = 0; i < types.length; i++) {
 			out[i] = hydrateClass(types[i].getClassName(), cl);
 		}
 
 		return out;
 	}
 
 	public static Method hydrateMethod(MemberHandle method, ClassLoader cl) {
 		try {
 			Type[] args = Type.getArgumentTypes(method.getParams());
 			Class<?> c = hydrateClass(method.getClassName(), cl);
 			Class<?>[] params = hydrateParams(args, cl);
 			Method m = c.getDeclaredMethod(method.getMethodName(), params);
 			return m;
 		} catch (NoSuchMethodException e) {
 			throw new Kite9ProcessingException("Could not find method: ", e);
 		}
 	}
 	
 	public static Field hydrateField(MemberHandle field, ClassLoader cl) {
 		try {
 			Class<?> c = hydrateClass(field.getClassName(), cl);
 			Field f = c.getDeclaredField(field.getMethodName());
 			return f;
 		} catch (NoSuchFieldException e) {
 			throw new Kite9ProcessingException("Could not find field: ", e);
 		}
 	}
 
 	public static String convertClassName(Class<?> c) {
 		return c.getName().replace(".", "/");
 	}
 
 	public static String convertPackageName(Package p) {
 		return p.getName().replace(".", "/");
 	}
 
 	public int compareTo(MemberHandle o) {
 		int res = this.getMethodName().compareTo(o.getMethodName());
 		if (res==0) {
 			if (this.getParams()!=null) {
 				return (this.getParams().compareTo(o.getParams()));
 			} else if (o.getParams()==null) {
 				return 0;
 			} else {
 				return 1;
 			}
 			
 		}
 		
 		return res;
 	}
 }