using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using AMWD.Common.Cli;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTests.Common.Cli
{
	[TestClass]
	public class CommandLineParserTests
	{
		[TestMethod]
		public void ShouldParseStringToArgs()
		{
			// arrange

			// act
			string[] result = CommandLineParser.ParseArgsString("Option1 \"Option 2\" \"Some \"\" Option\" Foo=Bar \\ /help \\\\backslash \\\"escapedquote \\test");

			// assert
			Assert.IsNotNull(result);
			Assert.AreEqual(9, result.Length);

			Assert.AreEqual("Option1", result[0]);
			Assert.AreEqual("Option 2", result[1]);
			Assert.AreEqual("Some \" Option", result[2]);
			Assert.AreEqual("Foo=Bar", result[3]);
			Assert.AreEqual("\\", result[4]);
			Assert.AreEqual("/help", result[5]);
			Assert.AreEqual("\\backslash", result[6]);
			Assert.AreEqual("\"escapedquote", result[7]);
			Assert.AreEqual("\\test", result[8]);
		}

		[TestMethod]
		public void ShouldReadArgs()
		{
			// arrange
			var parser = new CommandLineParser();

			// act
			parser.ReadArgs("Option1 \"Option 2\"");
			string[] args = parser.GetType().GetField("args", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(parser) as string[];

			// assert
			Assert.IsNotNull(args);
			Assert.AreEqual(2, args.Length);

			Assert.AreEqual("Option1", args[0]);
			Assert.AreEqual("Option 2", args[1]);
		}

		[TestMethod]
		public void ShouldRegisterOptions()
		{
			// arrange
			var parser = new CommandLineParser();

			// act
			parser.RegisterOption("opt1");
			parser.RegisterOption("opt2", 1);
			parser.RegisterOption("opt3", 2).Required().Single();
			parser.RegisterOption("opt4").Alias("option4");

			var options = parser.GetType().GetField("options", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(parser) as List<Option>;

			// assert
			Assert.IsNotNull(options);
			Assert.AreEqual(4, options.Count);

			Assert.AreEqual(1, options.ElementAt(0).Names.Count);
			Assert.AreEqual("opt1", options.ElementAt(0).Names.First());
			Assert.AreEqual(0, options.ElementAt(0).ParameterCount);
			Assert.IsFalse(options.ElementAt(0).IsSingle);
			Assert.IsFalse(options.ElementAt(0).IsRequired);

			Assert.AreEqual(1, options.ElementAt(1).Names.Count);
			Assert.AreEqual("opt2", options.ElementAt(1).Names.First());
			Assert.AreEqual(1, options.ElementAt(1).ParameterCount);
			Assert.IsFalse(options.ElementAt(1).IsSingle);
			Assert.IsFalse(options.ElementAt(1).IsRequired);

			Assert.AreEqual(1, options.ElementAt(2).Names.Count);
			Assert.AreEqual("opt3", options.ElementAt(2).Names.First());
			Assert.AreEqual(2, options.ElementAt(2).ParameterCount);
			Assert.IsTrue(options.ElementAt(2).IsSingle);
			Assert.IsTrue(options.ElementAt(2).IsRequired);

			Assert.AreEqual(2, options.ElementAt(3).Names.Count);
			Assert.AreEqual("opt4", options.ElementAt(3).Names.First());
			Assert.AreEqual("option4", options.ElementAt(3).Names.Last());
			Assert.AreEqual(0, options.ElementAt(3).ParameterCount);
			Assert.IsFalse(options.ElementAt(3).IsSingle);
			Assert.IsFalse(options.ElementAt(3).IsRequired);
		}

		[TestMethod]
		public void ShouldParse()
		{
			// arrange
			string argString = "/opt1 /opt2:two -opt3=three1 three2 --opt4:four /test:done -- foo bar";

			var parser = new CommandLineParser();
			parser.RegisterOption("opt1");
			parser.RegisterOption("opt2", 1);
			parser.RegisterOption("opt3", 2);
			parser.RegisterOption("opt4", 1);
			var opt = parser.RegisterOption("notUsed");
			parser.RegisterOption("testing", 1);

			parser.ReadArgs(argString);

			// act
			parser.Parse();

			// assert
			Assert.IsFalse(opt.IsSet);
			Assert.AreEqual(7, parser.Arguments.Length);
			Assert.AreEqual(2, parser.FreeArguments.Length);

			Assert.AreEqual("foo", parser.FreeArguments.First());
			Assert.AreEqual("bar", parser.FreeArguments.Last());

			Assert.IsTrue(parser.Arguments.ElementAt(0).Option.IsSet);
			Assert.IsNull(parser.Arguments.ElementAt(0).Option.Value);
			Assert.AreEqual(0, parser.Arguments.ElementAt(0).Values.Length);

			Assert.IsTrue(parser.Arguments.ElementAt(1).Option.IsSet);
			Assert.AreEqual("two", parser.Arguments.ElementAt(1).Option.Value);
			Assert.AreEqual(1, parser.Arguments.ElementAt(1).Values.Length);
			Assert.AreEqual("two", parser.Arguments.ElementAt(1).Values.First());

			Assert.IsTrue(parser.Arguments.ElementAt(2).Option.IsSet);
			Assert.AreEqual("three1", parser.Arguments.ElementAt(2).Option.Value);
			Assert.AreEqual(2, parser.Arguments.ElementAt(2).Values.Length);
			Assert.AreEqual("three1", parser.Arguments.ElementAt(2).Values.First());
			Assert.AreEqual("three2", parser.Arguments.ElementAt(2).Values.Last());

			Assert.IsTrue(parser.Arguments.ElementAt(3).Option.IsSet);
			Assert.AreEqual("four", parser.Arguments.ElementAt(3).Option.Value);
			Assert.AreEqual(1, parser.Arguments.ElementAt(3).Values.Length);
			Assert.AreEqual("four", parser.Arguments.ElementAt(3).Values.First());

			Assert.IsTrue(parser.Arguments.ElementAt(4).Option.IsSet);
			Assert.AreEqual("testing", parser.Arguments.ElementAt(4).Option.Names.First());
			Assert.AreEqual("done", parser.Arguments.ElementAt(4).Option.Value);
			Assert.AreEqual(1, parser.Arguments.ElementAt(4).Values.Length);
			Assert.AreEqual("done", parser.Arguments.ElementAt(4).Values.First());

			Assert.IsNull(parser.Arguments.ElementAt(5).Option);
			Assert.AreEqual("foo", parser.Arguments.ElementAt(5).Value);
			Assert.AreEqual(1, parser.Arguments.ElementAt(5).Values.Length);

			Assert.IsNull(parser.Arguments.ElementAt(6).Option);
			Assert.AreEqual("bar", parser.Arguments.ElementAt(6).Value);
			Assert.AreEqual(1, parser.Arguments.ElementAt(6).Values.Length);
		}

		[TestMethod]
		public void ShouldExecuteOptionActionOnParse()
		{
			// arrange
			Argument actionArgument = null;

			string[] args = new[] { "/run", "--opt" };
			var parser = new CommandLineParser();
			parser.RegisterOption("opt").Required();
			parser.RegisterOption("run").Do(arg => actionArgument = arg);

			// act
			parser.Parse(args);

			// assert
			Assert.IsNotNull(actionArgument);
			Assert.IsNotNull(actionArgument.Option);
			Assert.AreEqual("run", actionArgument.Option.Names.First());
		}

		[TestMethod]
		public void ShouldReturnSetOptions()
		{
			// arrange
			string argString = "/Opt1 --opt3";

			var parser = new CommandLineParser();
			parser.ReadArgs(argString);

			parser.RegisterOption("opt1");
			parser.RegisterOption("opt2");
			parser.RegisterOption("opt3");

			// act
			var opts = parser.SetOptions;

			// assert
			Assert.AreEqual(2, opts.Length);

			Assert.AreEqual("opt1", opts.First().Names.First());
			Assert.AreEqual("opt3", opts.Last().Names.First());
		}

		[TestMethod]
		[ExpectedException(typeof(ArgumentNullException))]
		public void ShouldThrowExceptionOnNullArgs()
		{
			string[] args = null;
			var parser = new CommandLineParser();

			// act
			parser.Parse(args);

			// assert - ArgumentNullException
			Assert.Fail();
		}

		[TestMethod]
		[ExpectedException(typeof(Exception))]
		public void ShouldThrowExceptionOnMultipleAutocomplete()
		{
			// arrange
			string[] args = new[] { "/Opt:on" };
			var parser = new CommandLineParser
			{
				IsCaseSensitive = true
			};
			parser.RegisterOption("Option1", 1);
			parser.RegisterOption("Option2", 1);

			// act
			parser.Parse(args);

			// assert - Exception
			Assert.Fail();
		}

		[TestMethod]
		[ExpectedException(typeof(Exception))]
		public void ShouldThrowExceptionOnMissingOption()
		{
			// arrange
			string[] args = new[] { "/Option:on" };
			var parser = new CommandLineParser
			{
				AutoCompleteOptions = false
			};
			parser.RegisterOption("Opt1", 1);
			parser.RegisterOption("Opt2", 1);

			// act
			parser.Parse(args);

			// assert - Exception
			Assert.Fail();
		}

		[TestMethod]
		[ExpectedException(typeof(Exception))]
		public void ShouldTrhowExceptionOnDuplicateOption()
		{
			// arrange
			string[] args = new[] { "/Opt:on", "--opt=off" };
			var parser = new CommandLineParser();
			parser.RegisterOption("opt", 1).Single();

			// act
			parser.Parse(args);

			// assert - Exception
			Assert.Fail();
		}

		[TestMethod]
		[ExpectedException(typeof(Exception))]
		public void ShouldThrowExceptionOnMissingArgument()
		{
			// arrange
			string[] args = new[] { "/Option" };
			var parser = new CommandLineParser();
			parser.RegisterOption("option", 1);

			// act
			parser.Parse(args);

			// assert - Exception
			Assert.Fail();
		}

		[TestMethod]
		[ExpectedException(typeof(Exception))]
		public void ShouldThrowExceptionForMissingRequiredOption()
		{
			// arrange
			string[] args = new[] { "/opt" };
			var parser = new CommandLineParser();
			parser.RegisterOption("opt").Required();
			parser.RegisterOption("foo").Required();

			// act
			parser.Parse(args);

			// assert - Exception
			Assert.Fail();
		}
	}
}