package org.sourceforge.jemm.client;
   
   import java.lang.reflect.Method;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
  
  /**
   * A descriptor is a method signature that has the following format: <code>
   *   className#methodName<space>(<methodParameters>)<returnValue>
   *   Where:
   *   methodName - The name of the originating method.
   *   <methodParameters> - meets the JVM spec for types, ie D for double, F for float, L<className>; for objects
   *   <ReturnValues> - meets the JVM spec for types.
   *   
   *   The methodParameters and returnValue will work identically to the javap output.
   * 
   * @author Paul Keeble
   * 
   */
  public class Descriptor {
  	private static final Map<String, Class<?>> PRIMITIVE_TYPES = getPrimtiveTypesMap();
  	private static final Pattern DESCRIPTOR_PATTERN = Pattern.compile("((\\S+)#(\\S+)\\s+\\((.*)\\)(\\S+))");
  	
  	private static final Pattern PARTIAL_PATTERN = Pattern.compile("(\\((.*)\\)(\\S+))");
  
  	private String className;
  	private String methodName;
  	private String[] parameterTypes;
  	private String returnType;
  	
  	public Descriptor(String signature) throws DescriptorParsingException {
  		parse(signature);
  	}
  	
  	public Descriptor(String className, String methodName, String returnType,String... parameters) {
  		this.className =className;
  		this.methodName = methodName;
  		this.returnType = returnType;
  		this.parameterTypes = parameters;
  	}
  	
  	public Descriptor(String className,String methodName, String signature) {
  		this.className =className;
  		this.methodName = methodName;
  		parsePartial(signature);
  	}
  	
  	private void parsePartial(String signature) {
  		try {
  			Matcher m = PARTIAL_PATTERN.matcher(signature);
  			if(m.matches()) {
  				String parameters = m.group(2);
  				parameterTypes = extractTypesFromParameterString(parameters);
  				returnType = m.group(3);
  			} else {
  				throw new DescriptorParsingException("Descriptor (" + signature +") is invalid");
  			}
  		} catch(Exception e) {
  			throw new DescriptorParsingException("Descriptor (" + signature +") is invalid",e);
  		}
  	}
  	
  	private void parse(String signature) {
  		try {
  			Matcher m = DESCRIPTOR_PATTERN.matcher(signature);
  			if(m.matches()) {
  				className =  m.group(2);
  				methodName = m.group(3);
  				String parameters = m.group(4);
  				parameterTypes = extractTypesFromParameterString(parameters);
  				returnType = m.group(5);
  			} else {
  				throw new DescriptorParsingException("Descriptor (" + signature +") is invalid");
  			}
  		} catch(Exception e) {
  			throw new DescriptorParsingException("Descriptor (" + signature +") is invalid",e);
  		}
  	}
  	
  	public String getClassName() {
  		return className;
  	}
  	
  	public Class<?> getClassContainingMethod() throws ClassNotFoundException {
  		return Class.forName(getClassName());
  	}
  	
  	public Method getMethod() throws SecurityException, NoSuchMethodException, ClassNotFoundException {
  		return getClassContainingMethod().getDeclaredMethod(getMethodName(), getParameterClasses());
  	}
  
  	public String getMethodName() {
  		return methodName;
  	}
  
 	private String [] extractTypesFromParameterString(String pString) {
 		List<String> results = new ArrayList<String>();
 
 		int i = 0;
 		
 		while (i < pString.length()) {
 			String array = readArrayBraces(pString, i);
 			String type = readType(pString, i + array.length());
 
 			results.add(array + type);
 			i += array.length() + type.length();
 		}
 		return results.toArray(new String[results.size()]);
 	}
 	
 	public String[] getParameterStrings() {
 		return parameterTypes;
 	}
 
 	/**
 	 * Reads a single type from the starting index.
 	 * 
 	 * @param pString
 	 * @param index
 	 * @return
 	 */
 	private String readType(String pString, int start) {
 		if (pString.charAt(start) == 'L') {
 			int objectNameEndPos = pString.indexOf(";", start);
 			return convertClassName(pString.substring(start,
 					objectNameEndPos + 1));
 		} else {
 			return pString.substring(start, start + 1);
 		}
 	}
 	
 	/**
 	 * If there is a [ at 'start' then all ['s are read until a different
 	 * character is found and the string of ['s is returned.
 	 * 
 	 * @param pString
 	 *            The string to look in
 	 * @param start
 	 *            The index in the String to start with
 	 * @return The String of ['s or an empty String
 	 */
 	private String readArrayBraces(String pString, int start) {
 		int end = start;
 		for (int j = start; j < pString.length(); ++j) {
 			if (pString.charAt(j) != '[') {
 				end = j;
 				break;
 			}
 		}
 		return pString.substring(start, end);
 	}
 
 	/**
 	 * Converts java/lang/Object like class names to a valid class name with
 	 * full stops such as java.lang.Object.
 	 * 
 	 * @param classWithSlashes
 	 * @return
 	 */
 	private String convertClassName(String classWithSlashes) {
 		return classWithSlashes.replace('/', '.');
 	}
 	
 	public String getReturnString() {
 		return returnType;
 	}
 	
 	public Class<?> getReturnClass() throws ClassNotFoundException {
 		return getType(getReturnString());
 	}
 	
 	public Class<?>[] getParameterClasses() throws ClassNotFoundException {
 		String[] pStrings = getParameterStrings();
 		List<Class<?>> results = new ArrayList<Class<?>>();
 		for (int i = 0; i < pStrings.length; ++i) {
 			results.add(getType(pStrings[i]));
 		}
 		if(containsJustVoid(results))
 			return new Class[0];
 		
 		return results.toArray(new Class[results.size()]);
 	}
 	
 	private boolean containsJustVoid(List<Class<?>> results) {
 		if(results.size()>1 || results.size()==0)
 			return false;
 		if(Void.TYPE.equals(results.get(0)))
 			return true;
 
 		return false;
 	}
 	
 	public Class<?> getType(String typeName) throws ClassNotFoundException {
 		if (PRIMITIVE_TYPES.containsKey(typeName)) {
 			return PRIMITIVE_TYPES.get(typeName);
 		} else {
 			Class<?> clazz = Class.forName(cleanClassName(typeName));
 			return clazz;
 		}
 	}
 
 	/**
 	 * If the passed String starts with L and finishes with ; then the L and the
 	 * ; is stripped.
 	 * 
 	 * @param aClassName The classname to clean.
 	 * @return The cleaned class name.
 	 */
 	protected String cleanClassName(String aClassName) {
 		if (aClassName.startsWith("L") && aClassName.endsWith(";"))
 			return aClassName.substring(1, aClassName.length() - 1);
 		else
 			return aClassName;
 	}
 	
 	private String getParameterString() {
 		StringBuffer sb = new StringBuffer();
 		for(int i=0; i<parameterTypes.length; ++i)
 			sb.append(parameterTypes[i]);
 
 		return sb.toString();
 	}
 	
 	public String getDescriptorString() {
 		return className + "#" +methodName+" ("+getParameterString()+")"+returnType;
 	}
 	
 	public int hashCode() {
 		return getDescriptorString().hashCode();
 	}
 	
 	public boolean equals(Object obj) {
 		if(!(obj instanceof Descriptor))
 			return false;
 		
 		Descriptor rhs = (Descriptor)obj;
 		return getDescriptorString().equals(rhs.getDescriptorString());
 	}
 	
 	public String toString() {
 		return getDescriptorString();
 	}
 
 	public static Map<String, Class<?>> getPrimtiveTypesMap() {
 		Map<String, Class<?>> m = new HashMap<String, Class<?>>();
 		m.put("B", Byte.TYPE);
 		m.put("C", Character.TYPE);
 		m.put("D", Double.TYPE);
 		m.put("F", Float.TYPE);
 		m.put("I", Integer.TYPE);
 		m.put("J", Long.TYPE);
 		m.put("S", Short.TYPE);
 		m.put("Z", Boolean.TYPE);
 		m.put("V", Void.TYPE);
 		
 		return m;
 	}
 }