package net.sf.twip.parameterhandler;
   
   import java.lang.reflect.*;
   import java.util.*;
   
   import net.sf.twip.*;
   import net.sf.twip.internal.*;
   import net.sf.twip.util.Parameter;
   
  /**
   * Produces all the values to call for one {@link Parameter}, including only those that match the
   * {@link Assume} or {@link NotNull} annotations.
   * 
   * @see AbstractNumberParameterHandler for the expessions allowed for numbers
   */
  public abstract class ParameterHandler {
  
  	public static ParameterHandler of(Parameter parameter) {
  		final Class<?> type = parameter.getType();
  		if (type.isEnum()) {
  			return new EnumParameterHandler(parameter);
  		} else if (Boolean.class.isAssignableFrom(type) || Boolean.TYPE.equals(type)) {
  			return new BooleanParameterHandler(parameter);
  		} else if (Byte.class.isAssignableFrom(type) || Byte.TYPE.equals(type)) {
  			return new ByteParameterHandler(parameter);
  		} else if (Character.class.isAssignableFrom(type) || Character.TYPE.equals(type)) {
  			return new CharacterParameterHandler(parameter);
  		} else if (Double.class.isAssignableFrom(type) || Double.TYPE.equals(type)) {
  			return new DoubleParameterHandler(parameter);
  		} else if (Float.class.isAssignableFrom(type) || Float.TYPE.equals(type)) {
  			return new FloatParameterHandler(parameter);
  		} else if (Integer.class.isAssignableFrom(type) || Integer.TYPE.equals(type)) {
  			return new IntegerParameterHandler(parameter);
  		} else if (Long.class.isAssignableFrom(type) || Long.TYPE.equals(type)) {
  			return new LongParameterHandler(parameter);
  		} else if (Short.class.isAssignableFrom(type) || Short.TYPE.equals(type)) {
  			return new ShortParameterHandler(parameter);
  		} else if (String.class.isAssignableFrom(type)) {
  			return new StringParameterHandler(parameter);
  		} else {
  			return new AutoTwipParameterHandler(parameter);
  		}
  	}
  
  	protected final Parameter parameter;
  
  	public ParameterHandler(Parameter parameter) {
  		this.parameter = parameter;
  	}
  
  	/**
  	 * Get the values from the method or field specified in the {@link Values} annotation... with a
  	 * lot of collecting useful error information.
  	 */
  	private Object[] getAnnotatedValues() {
  		final String name = parameter.getAnnotation(Values.class).value();
  		try {
  			final Field field = parameter.getMethod().getDeclaringClass().getField(name);
  			if (!Modifier.isStatic(field.getModifiers()))
  				throw new TwipConfigurationErrorNonStatic("the field '" + name
  						+ "' named in the @Values annotation of " + parameter + " must be static.");
  			if (field.getType().isArray()) {
  				if (field.getType().getComponentType().isPrimitive())
  					throw new TwipConfigurationErrorNonPrimitive("the values of the field '" + name
  							+ "' named in the @Values annotation of " + parameter
  							+ " must not be primitives.");
  				final Object[] result = (Object[]) field.get(null);
  				if (result == null)
  					throw new TwipConfigurationErrorNullPointer("the field '" + name
  							+ "' named in the @Values annotation of " + parameter + " is null");
  				return result;
  			} else if (Collection.class.isAssignableFrom(field.getType())) {
  				final Collection<?> result = (Collection<?>) field.get(null);
  				if (result == null)
  					throw new TwipConfigurationErrorNullPointer("the field '" + name
  							+ "' named in the @Values annotation of " + parameter + " is null");
  				return result.toArray();
  			} else {
  				throw new TwipConfigurationErrorNotArrayOrCollection("the field '" + name
  						+ "' named in the @Values annotation of " + parameter
  						+ " must be an array or collection.");
  			}
  		} catch (final IllegalAccessException e) {
  			throw new TwipConfigurationErrorGettingField("can't access field '" + name
  					+ "' named in the @Values annotation of " + parameter, e);
  		} catch (final NoSuchFieldException ex) {
  			try {
  				final Method method = parameter.getMethod().getDeclaringClass().getMethod(name);
  				if (!Modifier.isStatic(method.getModifiers()))
  					throw new TwipConfigurationErrorNonStatic("the method '" + name
  							+ "' named in the @Values annotation of " + parameter
  							+ " must be static.");
  				if (method.getReturnType().isArray()) {
  					if (method.getReturnType().getComponentType().isPrimitive())
  						throw new TwipConfigurationErrorNonPrimitive(
  								"the values returned by the method '" + name
  										+ "' named in the @Values annotation of " + parameter
  										+ " must not be primitives.");
  					final Object[] result = (Object[]) method.invoke(null);
 					if (result == null)
 						throw new TwipConfigurationErrorNullPointer("the method '" + name
 								+ "' named in the @Values annotation of " + parameter
 								+ " returns null");
 					return result;
 				} else if (Collection.class.isAssignableFrom(method.getReturnType())) {
 					final Collection<?> collection = (Collection<?>) method.invoke(null);
 					if (collection == null)
 						throw new TwipConfigurationErrorNullPointer("the method '" + name
 								+ "' named in the @Values annotation of " + parameter
 								+ " returns null.");
 					return collection.toArray();
 				} else {
 					throw new TwipConfigurationErrorNotArrayOrCollection("the method '" + name
 							+ "' named in the @Values annotation of " + parameter
 							+ " must return an array or collection.");
 				}
 			} catch (final IllegalAccessException e) {
 				throw new TwipConfigurationErrorCallingMethod("can't access the method '" + name
 						+ "' named in the @Values annotation of " + parameter, e);
 			} catch (final NoSuchMethodException e) {
 				throw new TwipConfigurationErrorNoSuchMethod("there is no method or field '" + name
 						+ "' named in the @Values annotation of " + parameter, e);
 			} catch (final InvocationTargetException e) {
 				throw new TwipConfigurationErrorCallingMethod("can't invoke method '" + name
 						+ "' named in the @Values annotation of " + parameter, e);
 			}
 		}
 	}
 
 	protected abstract Object[] getDefaultParameterValues();
 
 	public Object[] getParameterValues() {
 		final Object[] values = (parameter.isAnnotationPresent(Values.class)) ? getAnnotatedValues()
 				: getDefaultParameterValues();
 		if (!parameter.isAnnotationPresent(Assume.class))
 			return values;
 		final List<Object> result = new ArrayList<Object>();
 		for (final Object value : values) {
 			if (test(value)) {
 				result.add(value);
 			}
 		}
 		if (!parameter.isAnnotationPresent(NotNull.class) && !parameter.getType().isPrimitive()) {
 			result.add(null);
 		}
 		return result.toArray();
 	}
 
 	/**
 	 * Should this value go into the parameter values?
 	 * 
 	 * @param value
 	 *            the value to check
 	 */
 	protected boolean test(Object value) {
 		return true;
 	}
 }