package net.sf.twip.util;
   
   import java.lang.annotation.Annotation;
   import java.lang.reflect.*;
   import java.util.List;
   
   /**
    * In <code>java.lang.reflect</code> the parameters are not first class citizens: you can only
    * access them by several index methods, and the name is not kept in the class file. This class
   * tries to fill that gap as good as it goes.
   */
  public abstract class Parameter {
  
  	public static List<Parameter> of(Method method) {
  		return MethodParameter.of(method);
  	}
  
  	public static List<Parameter> of(Constructor<?> constructor) {
  		return ConstructorParameter.of(constructor);
  	}
  
  	protected final int index;
  
  	public Parameter(int index) {
  		this.index = index;
  	}
  
  	public int getIndex() {
  		return index;
  	}
  
  	/**
  	 * @return the annotation of that type or <code>null</code> if the parameter is not annotated
  	 *         with that type.
  	 */
  	public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
  		for (final Annotation annotation : getAnnotations()) {
  			if (annotationType.isInstance(annotation)) {
  				return annotationType.cast(annotation);
  			}
  		}
  		return null;
  	}
  
  	public abstract Annotation[] getAnnotations();
  
  	public abstract Class<?> getType();
  
  	public abstract Method getMethod();
  
  	public <T extends Annotation> boolean isAnnotationPresent(Class<T> annotationType) {
  		return getAnnotation(annotationType) != null;
  	}
  
  	/**
  	 * Can that value be passed as this parameter? I.e. is it an instance of the correct type or (if
  	 * it's not really primitive) <code>null</code>; correctly handles primitive types where
  	 * {@link Class#isInstance(Object)} returns <code>false</code> for.
  	 */
  	public boolean isCallable(Object value) {
  		Class<?> parameterType = getType();
  		if (parameterType.isPrimitive()) {
  			if (parameterType == Boolean.TYPE)
  				return value.getClass() == Boolean.class;
  			if (parameterType == Byte.TYPE)
  				return value.getClass() == Byte.class;
  			if (parameterType == Character.TYPE)
  				return value.getClass() == Character.class;
  			if (parameterType == Short.TYPE)
  				return value.getClass() == Short.class;
  			if (parameterType == Integer.TYPE)
  				return value.getClass() == Integer.class;
  			if (parameterType == Long.TYPE)
  				return value.getClass() == Long.class;
  			if (parameterType == Float.TYPE)
  				return value.getClass() == Float.class;
  			if (parameterType == Double.TYPE)
  				return value.getClass() == Double.class;
  			throw new AssertionError("unsupported primitive type: " + parameterType);
  		} else {
  			return value == null || parameterType.isInstance(value);
  		}
  	}
  
  	@Override
  	public String toString() {
  		return Parameter.class.getSimpleName() + "#" + getIndex() + " of "
  				+ getMethod().toGenericString();
  	}
  
  }