// There is no license for this code. You are free to modify and redistribute it. Also, you can delete this comment.
// Original source code: https://github.com/wertrain/command-line-parser-cs (Version 0.2)
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;

namespace CommandLineParser
{
    /// <summary>
    /// Option attribute
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public sealed class Option : Attribute
    {
        public Option() { }
        public Option(string longName) => LongName = longName;
        public Option(char shortName) => ShortName = shortName;
        public Option(char shortName, string longName)
        {
            ShortName = shortName;
            LongName = longName;
        }

        /// <summary>long name command option</summary>
        public string LongName { get; private set; } = string.Empty;

        /// <summary>short name command option</summary>
        public char ShortName { get; private set; }

        /// <summary>command option</summary>
        public string HelpText { get; set; } = string.Empty;

        /// <summary>command option</summary>
        public bool Required { get; set; }
    }

    /// <summary>
    /// Results type of parse
    /// </summary>
    public enum ParserResultType
    {
        Parsed = 0,
        NotParsed
    }

    /// <summary>
    /// Results of parse
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ParserResult<T>
    {
        internal ParserResult(ParserResultType tag, T value)
        {
            Tag = tag;
            Value = value;
            Message = string.Empty;
        }

        internal ParserResult(ParserResultType tag, T value, string message)
        {
            Tag = tag;
            Value = value;
            Message = message;
        }

        public ParserResultType Tag { get; }
        public T Value { get; }
        public string Message { get; }
    }

    /// <summary>
    /// Utility for parser
    /// </summary>
    static class ParserUtility
    {
        /// <summary>
        /// Convert string to object using TypeConverter with nullable support
        /// </summary>
        public static object ConvertToType(string input, Type targetType)
        {
            if (targetType == typeof(string)) return input;

            var nonNullableType = Nullable.GetUnderlyingType(targetType) ?? targetType;

            if (nonNullableType == typeof(bool))
            {
                if (string.IsNullOrEmpty(input)) return true; // flag only => true
                if (bool.TryParse(input, out var b)) return b;
                // 1/0 を解釈する
                if (input.Equals("1")) return true;
                if (input.Equals("0")) return false;
                throw new FormatException($"'{input}' cannot be converted to Boolean.");
            }

            var converter = TypeDescriptor.GetConverter(nonNullableType);

            if (converter != null && converter.CanConvertFrom(typeof(string)))
            {
                var result = converter.ConvertFromString(input);
                if (result == null)
                {
                    throw new FormatException($"'{input}' cannot be converted to {nonNullableType.Name}.");
                }
                return result;
            }

            // fallback
            return Convert.ChangeType(input, nonNullableType);
        }

        /// <summary>
        /// Set value to a property on the target instance based on the incoming token text.
        /// Returns true if a value token was consumed (for non-bool) or successfully set.
        /// </summary>
        public static bool SetValueToProperty<T>(PropertyInfo property, T target, string? param)
        {
            var propertyType = property.PropertyType;
            var underlyingType = Nullable.GetUnderlyingType(propertyType) ?? propertyType;
            var isBool = underlyingType == typeof(bool);

            // Bool: if no explicit value or next token is another option, set true.
            if (isBool)
            {
                if (string.IsNullOrEmpty(param))
                {
                    property.SetValue(target, true);
                    return false; // no next token consumed
                }

                // explicit true/false
                if (bool.TryParse(param, out var b))
                {
                    property.SetValue(target, b);
                    return true; // consumed param
                }

                // If the next token looks like an option (starts with '-' or '--'), treat this as flag only.
                if (IsOptionToken(param))
                {
                    property.SetValue(target, true);
                    return false;
                }

                throw new FormatException($"'{param}' cannot be converted to Boolean.");
            }

            // Non-bool types require a value. If missing or next is option, it's an error.
            if (string.IsNullOrEmpty(param) || IsOptionToken(param))
            {
                throw new FormatException($"Option '{property.Name}' requires a value.");
            }

            var converted = ConvertToType(param!, propertyType);
            property.SetValue(target, converted);
            return true;
        }

        public static bool IsOptionToken(string? s)
        {
            if (s == null || string.IsNullOrEmpty(s) || s == "-") return false;

            return s.StartsWith("--", StringComparison.Ordinal) ||
                   (s.StartsWith("-", StringComparison.Ordinal) && s.Length > 1 && !char.IsDigit(s[1]));
        }
    }

    /// <summary>
    /// Arguments parser
    /// </summary>
    public class Parser
    {
        private const string HelpLongName = "help";

        /// <summary>
        /// Parse from a single string (whitespace split)
        /// </summary>
        public static ParserResult<T> Parse<T>(string args) where T : new()
        {
            var enumerable = string.IsNullOrWhiteSpace(args)
                ? Array.Empty<string>()
                : args.Split((string[]?)null, StringSplitOptions.RemoveEmptyEntries);
            return Parse<T>(enumerable);
        }

        /// <summary>
        /// Parse from enumerable of tokens
        /// </summary>
        public static ParserResult<T> Parse<T>(IEnumerable<string> args) where T : new()
        {
            var tokens = (args ?? Enumerable.Empty<string>()).ToArray();

            if (tokens.Length == 0)
            {
                ShowHelp<T>();
                return new ParserResult<T>(ParserResultType.NotParsed, new T());
            }

            var value = new T();
            var resultTag = ParserResultType.Parsed;

            // Prepare property maps only once
            var props = typeof(T)
                .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Select(p => new { Prop = p, Opt = p.GetCustomAttribute<Option>(true) })
                .Where(x => x.Opt != null)
                .Select(x => new { x.Prop, Opt = x.Opt! })
                .ToArray();

            var longNameMap = new Dictionary<string, (PropertyInfo Prop, Option Opt)>(StringComparer.Ordinal);
            var shortNameMap = new Dictionary<char, (PropertyInfo Prop, Option Opt)>();

            foreach (var x in props)
            {
                if (string.IsNullOrEmpty(x.Opt.LongName) && x.Opt.ShortName == '\0')
                {
                    throw new InvalidOperationException($"Option on '{x.Prop.Name}' must have a name.");
                }
                if (!string.IsNullOrWhiteSpace(x.Opt.LongName))
                {
                    longNameMap[x.Opt.LongName] = (x.Prop, x.Opt);
                }
                if (x.Opt.ShortName != '\0')
                {
                    shortNameMap[x.Opt.ShortName] = (x.Prop, x.Opt);
                }
            }

            var setProps = new HashSet<PropertyInfo>();

            for (int i = 0; i < tokens.Length; i++)
            {
                var arg = tokens[i];

                // Long option: --name
                if (arg.StartsWith("--", StringComparison.Ordinal))
                {
                    var command = arg.Substring(2);

                    if (command.Equals(HelpLongName, StringComparison.Ordinal))
                    {
                        ShowHelp<T>();
                        return new ParserResult<T>(ParserResultType.Parsed, new T());
                    }

                    if (!longNameMap.TryGetValue(command, out var entry))
                    {
                        return new ParserResult<T>(
                            ParserResultType.NotParsed,
                            value,
                            $"Unknown option: --{command}");
                    }

                    var next = (i + 1) < tokens.Length ? tokens[i + 1] : null;

                    try
                    {
                        var consumed = ParserUtility.SetValueToProperty(entry.Prop, value, next);
                        setProps.Add(entry.Prop);
                        if (consumed) i++;
                    }
                    catch (Exception ex)
                    {
                        return new ParserResult<T>(
                            ParserResultType.NotParsed,
                            value,
                            ex.Message);
                    }

                    continue;
                }

                // Short option: -n
                if (arg.StartsWith("-", StringComparison.Ordinal) && !arg.StartsWith("--", StringComparison.Ordinal))
                {
                    var command = arg.Substring(1);

                    if (command.Length != 1)
                    {
                        return new ParserResult<T>(
                            ParserResultType.NotParsed,
                            value,
                            $"-{command} is invalid format");
                    }

                    if (!shortNameMap.TryGetValue(command[0], out var entry))
                    {
                        return new ParserResult<T>(
                            ParserResultType.NotParsed,
                            value,
                            $"-{command} is unknown option");
                    }

                    var next = (i + 1) < tokens.Length ? tokens[i + 1] : null;

                    try
                    {
                        var consumed = ParserUtility.SetValueToProperty(entry.Prop, value, next);
                        setProps.Add(entry.Prop);
                        if (consumed) i++;
                    }
                    catch (Exception ex)
                    {
                        return new ParserResult<T>(
                            ParserResultType.NotParsed,
                            value,
                            ex.Message);
                    }

                    continue;
                }

                // 非オプション引数は無視
            }

            // Required チェック
            foreach (var x in props)
            {
                if (x.Opt.Required && !setProps.Contains(x.Prop))
                {
                    var displayName = !string.IsNullOrEmpty(x.Opt.LongName) ? $"--{x.Opt.LongName}" : $"-{x.Opt.ShortName}";
                    return new ParserResult<T>(
                        ParserResultType.NotParsed,
                        value,
                        $"Missing required option: {displayName}");
                }
            }

            return new ParserResult<T>(resultTag, value);
        }

        /// <summary>
        /// Show help
        /// </summary>
        public static void ShowHelp<T>()
        {
            const int SpacePaddingSize = 12;

            var asm = Assembly.GetExecutingAssembly();
            var moduleName = System.IO.Path.GetFileName(Process.GetCurrentProcess().MainModule?.FileName ?? "App");
            Console.WriteLine("{0} {1}", moduleName, asm.GetName().Version);

            var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);

            foreach (var property in props)
            {
                var opt = property.GetCustomAttribute<Option>(true);
                if (opt is null) continue;

                Console.Write("-{0}, --{1,-" + SpacePaddingSize + "} ",
                    opt.ShortName == '\0' ? ' ' : opt.ShortName,
                    opt.LongName);

                if (opt.Required) Console.Write("[Required]");

                Console.WriteLine("{0}", opt.HelpText ?? string.Empty);
            }

            Console.WriteLine("--{0,-" + (SpacePaddingSize + HelpLongName.Length) + "} {1}",
                HelpLongName,
                "Display this help screen.");
        }
    }
}