package test;

import java.util.List;

import org.testng.Assert;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

import com.beust.jcommander.IStringConverter;
import com.beust.jcommander.IStringConverterFactory;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;

public class JCommanderTest {

	public static class Args {
                //this works
		@Parameter(names = "-single")
		HostPort single;

                 //this works because i define converter explicitly
		@Parameter(names = "-explicit", converter = HostPortConverter.class)
		List<HostPort> explicitConverter;

		//i would expect this to work but...
		@Parameter(names = "-implicit")
		List<HostPort> implicitConverter;
	}

	public static class HostPort {
		public String host;
		public Integer port;
	}

	public static class HostPortConverter implements IStringConverter<HostPort> {
		public HostPort convert(String value) {
			HostPort result = new HostPort();
			String[] s = value.split(":");
			result.host = s[0];
			result.port = Integer.parseInt(s[1]);

			return result;
		}
	}

	public static class Factory implements IStringConverterFactory {
		public Class<? extends IStringConverter<?>> getConverter(Class forType) {
			if (forType.equals(HostPort.class)) return HostPortConverter.class;
			else return null;
		}
	}

	public Args args;
	public JCommander jc;

	@BeforeTest
	public void setUp() {
		args = new Args();
		jc = new JCommander(args);
		jc.addConverterFactory(new Factory());
	}

	@Test
	public void testSingle() {
		jc.parse("-single", "localhost:80");
		Assert.assertEquals(args.single.host, "localhost");
		Assert.assertEquals(args.single.port.intValue(), 80);
		Assert.assertEquals(args.single.getClass(), HostPort.class);
	}

	@Test
	public void testExplicit() {
		jc.parse("-explicit", "localhost:80", "-explicit", "foo:80");
                // :s how to check it is a List<HostPort> ??
		Assert.assertTrue(args.explicitConverter instanceof List<?>);
		for (HostPort h : args.explicitConverter) {
			Assert.assertTrue(h instanceof HostPort);
		}
	}

	@Test
	public void testImplicit() {
		jc.parse("-implicit", "localhost:80", "-explicit", "foo:80");
		Assert.assertTrue(args.implicitConverter instanceof List<?>);
		//this fails!
		for (HostPort h : args.implicitConverter) {
			Assert.assertTrue(h instanceof HostPort);
		}
	}

}