using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Threading;

namespace CC_Functions.Commandline
{
    /// <summary>
    /// A class to provide basic parsing for program arguments
    /// </summary>
    public class ArgsParse : IEnumerable<string>
    {
        private readonly string[] _args;
        /// <summary>
        /// Create a new instance based on the specified args
        /// </summary>
        /// <param name="args">The inputted args. Should be a parameter of the main method</param>
        public ArgsParse(string[] args) => _args = args ?? throw new NullReferenceException();
        /// <summary>
        /// Shadowed from the base args
        /// </summary>
        /// <param name="i">The index in the base args</param>
        public string this[int i]
        {
            get => _args[i];
            set => _args[i] = value;
        }
        /// <summary>
        /// Shadowed from the base args
        /// </summary>
        /// <returns>An enumerator for the base args</returns>
        IEnumerator<string> IEnumerable<string>.GetEnumerator() => ((IEnumerable<string>)_args).GetEnumerator();
        /// <summary>
        /// Shadowed from the base args
        /// </summary>
        /// <returns></returns>
        public IEnumerator GetEnumerator() => _args.GetEnumerator();
        /// <summary>
        /// Gets the string specified for this key or null
        /// </summary>
        /// <param name="i">The name of the parameter</param>
        public string? this[string i]
        {
            get
            {
                string? selected = null;
                foreach (string s in _args)
                    if (s.TrimStart('-', '/').ToLower().StartsWith($"{i.ToLower()}:"))
                        selected = string.Join("", s.TrimStart('-', '/').Skip(i.Length + 1));
                return selected;
            }
        }
        /// <summary>
        /// Gets the string specified for this key or null
        /// </summary>
        /// <param name="i">The name of the parameter</param>
        /// <returns>The value or null</returns>
        public string? GetString(string i) => this[i];
        /// <summary>
        /// Gets a boolean value with the specified name. Either specified as --i or --i:true
        /// </summary>
        /// <param name="i">The name of the parameter</param>
        /// <returns>The value</returns>
        public bool GetBool(string i) => _args.Any(s => s.ToLower().TrimStart('-', '/') == i.ToLower()) || bool.TryParse(this[i], out bool res) && res;
        /// <summary>
        /// Gets an arg using a transformer specified by you. The value passed will be the same as this[i]
        /// </summary>
        /// <param name="i">The name of the parameter</param>
        /// <param name="func">A null-safe function to convert a string to the expected type</param>
        /// <typeparam name="T">The type to convert to</typeparam>
        /// <returns>The converted value</returns>
        public T Get<T>(string i, Func<string?, T> func) => func(this[i]);
        /// <summary>
        /// Uses reflection to call the Parse method on types providing it. Use Get() with a func param for other types
        /// This will return null if the type is not found
        /// </summary>
        /// <param name="i">The name of the parameter</param>
        /// <typeparam name="T">The type to convert to</typeparam>
        /// <returns>The converted value</returns>
        public T Get<T>(string i)
        {
            MethodInfo[] parse = typeof(T).GetMethods().Where(s => s.Name.ToLower() == "parse"
                                              && s.GetParameters().Length == 1
                                              && s.GetParameters()[0].ParameterType == typeof(string)
                                              && s.ReturnType == typeof(T)
                                              && !s.IsAbstract && !s.IsPrivate && s.IsStatic).ToArray();
            if (parse.Length == 0)
                throw new InvalidOperationException("Could not find a valid parse method");
            string? v = this[i];
            if (v == null)
                return default;
            return (T) parse[0].Invoke(null, new object[] {v});
        }
    }
}