package net.sf.twip.internal;
   
   import static org.junit.Assert.assertEquals;
   
   import java.lang.reflect.Method;
   import java.util.*;
   
   import net.sf.twip.parameterhandler.ParameterHandler;
   import net.sf.twip.util.*;
  
  import org.junit.runners.model.FrameworkMethod;
  
  /**
   * A {@link FrameworkMethod} that knows about a fixed set of parameters passed into
   * {@link FrameworkMethod#invokeExplosively(Object, Object...)}
   */
  public class FrameworkMethodWithArgs extends FrameworkMethod {
  
  	/**
  	 * @return the list of all permutations of {@link FrameworkMethodWithArgs} that need to be
  	 *         called for this method.
  	 */
  	public static List<FrameworkMethodWithArgs> of(Method method) {
  		List<FrameworkMethodWithArgs> result = new ArrayList<FrameworkMethodWithArgs>();
  		result.add(new FrameworkMethodWithArgs(method));
  		for (final Parameter parameter : ReverseIterable.create(Parameter.of(method))) {
  			final List<FrameworkMethodWithArgs> next = new ArrayList<FrameworkMethodWithArgs>();
  			final ParameterHandler parameterHandler = ParameterHandler.of(parameter);
  			for (final Object value : parameterHandler.getParameterValues()) {
  				for (final FrameworkMethodWithArgs old : result) {
  					next.add(new FrameworkMethodWithArgs(old, parameter, value));
  				}
  			}
  			result = next;
  		}
  		return result;
  	}
  
  	private final List<Parameter> parameters;
  	private final List<Object> parameterValues;
  
  	/**
  	 * Constructor that takes a method, defines the description to be its name, and define no
  	 * parameterValues; you'll have to call the other constructor to derive a new instance with
  	 * additional parameterValues, or invokeExplosively will fail.
  	 */
  	private FrameworkMethodWithArgs(Method method) {
  		super(method);
  		this.parameterValues = Collections.emptyList();
  		this.parameters = Collections.emptyList();
  	}
  
  	/**
  	 * Copy-Constructor that appends one parameter value.
  	 */
  	private FrameworkMethodWithArgs(FrameworkMethodWithArgs old, Parameter parameter,
  			Object parameterValue) {
  		super(old.getMethod());
  
  		if (!parameter.isCallable(parameterValue))
  			throw new TwipConfigurationErrorInvalidParameterType(parameter, parameterValue);
  
  		this.parameters = new ArrayList<Parameter>(old.parameters);
  		this.parameters.add(0, parameter);
  		this.parameterValues = new ArrayList<Object>(old.parameterValues);
  		this.parameterValues.add(0, parameterValue);
  	}
  
  	@Override
  	public Object invokeExplosively(Object target, Object... parameterValues) throws Throwable {
  		assertEquals("don't call this with parameters; I know them already!",
  				parameterValues.length, 0);
  		assertEquals("you didn't specify all parameters for the method", getMethod()
  				.getParameterTypes().length, this.parameterValues.size());
  		return super.invokeExplosively(target, this.parameterValues.toArray());
  	}
  
  	@Override
  	public String toString() {
  		StringBuilder out = new StringBuilder();
  		out.append(getMethod().getName());
  		out.append("[");
  		boolean first = true;
  		for (Object parameterValue : parameterValues) {
  			if (first)
  				first = false;
  			else
  				out.append(", ");
  			out.append(toString(parameterValue));
  		}
  		out.append("]");
  		return out.toString();
  	}
  
  	/**
  	 * @return the toString() of a parameter suitable as a method name suffix, i.e. with returns and
  	 *         unicode characters replaced by harmless escape sequences.
  	 */
  	private String toString(Object parameterValue) {
 		final StringBuilder out = new StringBuilder();
 		for (final char c : String.valueOf(parameterValue).toCharArray()) {
 			switch (c) {
 			case '\n':
 				out.append("\\n");
 				break;
 			case '\r':
 				out.append("\\r");
 				break;
 			case '\t':
 				out.append("\\t");
 				break;
 			case '(':
 				out.append("[");
 				break;
 			case ')':
 				out.append("]");
 				break;
 			default:
 				if (c > 256) {
 					out.append("\\u");
 					out.append(String.format("%04X", Integer.valueOf(c)));
 				} else {
 					out.append(c);
 				}
 			}
 		}
 		return out.toString();
 	}
 }