using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace sharp.extensions.commandline
{
	public class UnknownArgumentException : Exception {
		public UnknownArgumentException(string argument)
			:base(string.Format("Argument {0} is not known",argument))
		{			
		}
	}

	public class Option
	{
		public char Short { get; private set; }
		public string Long { get; private set; }

		public bool WasFound { get; set; }

		protected Option(char shortoption, string longOption,bool needsArgument)
		{
			this.Long = longOption;
			this.Short = shortoption;
		}


		public Option(char shortoption, string longOption)
		{
			this.Long = longOption;
			this.Short = shortoption;
		}

		public Option(char shortOption)
			: this(shortOption, null)
		{
		}
		public Option(string longOption)
			: this((char)0, longOption)
		{
		}

		public virtual void OptionFound(ArgumentReader reader)
		{
			WasFound = true;
		}

	}

	public class OptionWithArgument : Option
	{
		public string Argument { get; private set; }

		public OptionWithArgument(char shortoption, string longOption, string defaultArgument = null)
					: base(shortoption, longOption, true)
		{
			Argument = defaultArgument;
		}
		public OptionWithArgument(string longOption, string defaultArgument = null)
			: this((char)0, longOption, defaultArgument)
		{
		}

		public override void OptionFound(ArgumentReader reader)
		{
			base.OptionFound(reader);
			this.Argument = reader.PopArgument();
		}
	}

	public class OptionForEnum<T> : Option where T: struct,IConvertible
	{
		public T Argument { get; private set; }

		public OptionForEnum(char shortoption, string longOption, T defaultArgument = default(T))
					: base(shortoption, longOption, true)
		{
			Argument = defaultArgument;
		}
		public OptionForEnum(string longOption, T defaultArgument = default(T))
			: this((char)0, longOption, defaultArgument)
		{
		}

		public override void OptionFound(ArgumentReader reader)
		{
			base.OptionFound(reader);
			Argument = (T)Enum.Parse(typeof(T), reader.PopArgument());
		}
	}

	public static class OptionExtensions {

		public static void ApplyLong(Option[] options, ArgumentReader reader)
		{
			foreach (Option option in options)
			{
				if (reader.CurrentOption.Equals(option.Long))
				{
					option.OptionFound(reader);
					return;
				}
			}
			throw new UnknownArgumentException(reader.CurrentOption);
		}
		public static void ApplyShort(Option[] options, ArgumentReader reader)
		{
			foreach (Option option in options)
			{
				if (reader.CurrentOption[0] == option.Short)
				{
					option.OptionFound(reader);
					return;
				}
			}
			throw new UnknownArgumentException(reader.CurrentOption);
		}

		public static string[] Apply(this Option[] options, string[] args)
		{
			List<string> rest = new List<string>();
			ArgumentReader reader = new ArgumentReader(args);

			while (reader.Next()){
				if (reader.CurrentIsLong){
					ApplyLong(options, reader);
				} else if (reader.CurrentIsShort){
					ApplyShort(options,reader);
				} else {
					rest.Add(reader.CurrentOption);
				}
			}
			return rest.ToArray();
		}

	}

}