//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace OpenTap.Cli
{
    /// <summary>
    /// Parser for command line arguments. Supports --,-,/ based argument options 
    /// as well as unnamed options mixed with named ones.
    /// </summary>
    internal class ArgumentsParser
    {
        public ArgumentCollection AllOptions = new ArgumentCollection();

        struct optionFindResult
        {
            public Argument FoundOption;
            public bool IsUnknown;
            public string InlineArg;
        }

        optionFindResult findOption(string st, ArgumentCollection options)
        {
            optionFindResult opt = new optionFindResult { IsUnknown = false };
            int len = 0;
            if (st.StartsWith("--"))
            {
                len = 2;
            }
            else if (st.StartsWith("-")) // Removed check for starting with '\'. It breaks installing a package from network drive because it starts with \\.
            {
                len = 1;
            }
            if (len == 0)
            {
                return opt;
            }

            st = st.Substring(len);
            var idx = st.IndexOf('=');
            if (idx > 0)
            {
                opt.InlineArg = st.Substring(idx + 1);
                st = st.Substring(0, idx);
            }
            opt.FoundOption = options
                .FirstOrDefault(o => o.Value.CompareTo(st)).Value;

            if (opt.FoundOption == null)
            {
                opt.FoundOption = AllOptions
                    .FirstOrDefault(o => o.Value.CompareTo(st)).Value;
            }

            if (opt.FoundOption == null)
            {
                opt.IsUnknown = true;
            }
            else
            {
                opt.FoundOption = opt.FoundOption.Clone();
            }
            return opt;
        }

        public ArgumentCollection Parse(string[] rawArgs)
        {
            ArgumentCollection options = AllOptions.CreateDefault();
            List<string> restList = options.UnnamedArguments.ToList();
            for (int i = 0; i < rawArgs.Length; i++)
            {
                string arg = rawArgs[i];
                optionFindResult optResult = findOption(arg, options);
                Argument opt = optResult.FoundOption;
                if (opt == null)
                {
                    if (optResult.IsUnknown == false)
                    {
                        restList.Add(arg);
                    }
                    else
                    {
                        options.UnknownsOptions.Add(arg);
                    }
                    continue;
                }

                if (opt.NeedsArgument)
                {
                    if (optResult.InlineArg != null)
                    {
                        opt.Values.Add(optResult.InlineArg);
                    }
                    else if (i + 1 < rawArgs.Length)
                    {
                        opt.Values.Add(rawArgs[++i]);
                    }
                    else
                    {
                        options.MissingArguments.Add(opt);
                        continue;
                    }
                }
                else
                {
                    if (optResult.InlineArg != null)
                    {
                        // Add the value of the inline arg, even if NeedsArgument was not specified
                        opt.Values.Add(optResult.InlineArg);
                    }
                }
                options.Add(opt);
            }
            options.UnnamedArguments = restList.ToArray();
            return options;
        }
    }

    internal class Argument
    {
        /// <summary>
        /// Optional. Used with one '-' or a '/'.
        /// </summary>
        public char ShortName { get; private set; }
        /// <summary>
        /// Non optional. used with '--' or '/'. Also used for argument lookup.
        /// </summary>
        public string LongName { get; private set; }
        /// <summary>
        /// If an argument is required for this option.
        /// </summary>
        public bool NeedsArgument { get; private set; }
        /// <summary>
        /// Argument given to this option.
        /// </summary>
        public string Value { get { return Values.FirstOrDefault(); } }
        /// <summary>
        /// Argument given to this option. Also used as a default.
        /// </summary>
        public List<string> Values { get; private set; }
        /// <summary>
        /// Short description for this option.
        /// </summary>
        public string Description { get; set; }
        /// <summary>
        /// Indicates if an argument should be shown in "--help" output.
        /// </summary>
        public bool IsVisible { get; set; } = true;
        /// <summary>
        /// Initializes a new instance of the Option class.
        /// </summary>
        public Argument(string longName, char shortName = default(char), bool needsArgument = true, string description = "", string defaultArg = null)
        {
            ShortName = shortName;
            LongName = longName;
            NeedsArgument = needsArgument;
            Description = description;
            Values = new List<string>();
            if (String.IsNullOrWhiteSpace(defaultArg) == false)
            {
                Values.Add(defaultArg);
            }
        }

        /// <summary>
        /// Clones the option with a new argument
        /// </summary>
        /// <param name="argument"></param>
        /// <returns></returns>
        public Argument Clone(string argument)
        {
            var opt = Clone();
            opt.Values = new List<string> { argument };
            return opt;
        }

        public Argument Clone()
        {
            return new Argument(LongName, ShortName, NeedsArgument)
            {
                Values = new List<string>(Values),
                Description = Description
            };
        }

        public bool CompareTo(string arg)
        {
            if (arg.Length == 1 && ShortName != default(char))
            {
                return arg[0] == ShortName;
            }
            return arg == LongName;
        }
    }

    /// <summary>
    /// A collection of options optionally with arguments.
    /// Also includes Unnamed arguments and in case of errors unknown options and missing arguments
    /// This class is used both as and input and output to option parsing.
    /// </summary>
    internal class ArgumentCollection : Dictionary<string, Argument>
    {
        public string[] UnnamedArguments { get; set; }
        public List<IMemberData> UnnamedArgumentData { get; set; }

        public List<string> UnknownsOptions { get; set; }
        public List<Argument> MissingArguments { get; set; }

        public ArgumentCollection()
        {
            UnnamedArguments = new string[0];
            UnknownsOptions = new List<string>();
            MissingArguments = new List<Argument>();
        }

        public Argument Add(Argument option)
        {
            this[option.LongName] = option;
            return option;
        }

        public Argument Add(string longName, char shortName = default(char),
            bool needsArgument = true, string description = "", string defaultArgument = null)
        {
            var option = new Argument(longName, shortName, needsArgument, description, defaultArgument);
            return Add(option);
        }

        public bool Contains(string optionName)
        {
            return ContainsKey(optionName);
        }

        public Argument GetOrDefault(string optionLongName)
        {
            if (Contains(optionLongName))
            {
                return this[optionLongName];
            }
            return null;
        }

        public string Argument(string optionLongName)
        {
            return this[optionLongName].Value;
        }

        public string GetArgumentOrDefault(string optionLongName, string def = default(string))
        {
            var opt = GetOrDefault(optionLongName);
            if (opt != null)
            {
                return opt.Value;
            }
            return def;
        }
        /// <summary>
        /// Transfers an option from one
        /// </summary>
        /// <param name="optionName"></param>
        /// <param name="from"></param>
        /// <returns></returns>
        public Argument TakeOption(string optionName, ArgumentCollection from)
        {
            if (from.Contains(optionName))
            {
                this[optionName] = from[optionName].Clone();
                return this[optionName];
            }
            return null;
        }

        public ArgumentCollection CreateDefault()
        {
            ArgumentCollection opt = new ArgumentCollection { UnnamedArguments = UnnamedArguments };
            foreach (var key in Keys)
            {
                if (this[key].Value != null)
                {
                    opt[key] = this[key];
                }
            }
            return opt;
        }

        /// <summary>
        /// This is a simple abstraction over unnamed and named arguments to simplify output formatting.
        /// </summary>
        /// <returns></returns>
        class OptionWrapper
        {
            public UnnamedCommandLineArgument Positional { get; }
            public Argument Argument { get; }

            public OptionWrapper(Argument argument)
            {
                Argument = argument;
            }

            public OptionWrapper(UnnamedCommandLineArgument positional)
            {
                Positional = positional;
            }

            public string Description()
            {
                return Positional != null ? Positional.Description : Argument.Description;
            }

            public override string ToString()
            {
                if (Positional != null)
                {
                    return "  " + (Positional.Required ? $"<{Positional.Name}>" : $"[{Positional.Name}]");
                }
                else
                {
                    var result = "  ";
                    if (Argument.ShortName != default(char))
                    {
                        result += $"-{Argument.ShortName}, ";
                    }
                    result += $"--{Argument.LongName}";
                    return result;
                }
            }
        }

        /// <summary>
        /// Converts the ArgumentCollection to a help-string.
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            StringBuilder output = new StringBuilder();
            var wrappers = new List<OptionWrapper>();

            if (UnnamedArgumentData?.Any() == true)
            {
                foreach (var u in UnnamedArgumentData)
                {
                    if (u.GetAttribute<UnnamedCommandLineArgument>() is { } a)
                    {
                        wrappers.Add(new OptionWrapper(a));
                    }
                }
            }
            wrappers.AddRange(this.Values.Where(v => v.IsVisible).Select(k => new OptionWrapper(k)));

            // Compute the options' width
            int width = wrappers.Select(w => w.ToString().Length).Max() + 3;

            foreach (var wrapper in wrappers)
            {
                var arg = wrapper.ToString();
                var description = wrapper.Description();
                if (!string.IsNullOrEmpty(description))
                {
                    output.Append(arg);
                    // Offst by the arument length in the first iteration
                    var offset = arg.Length;
                    foreach (var descSplit in description.Split('\n'))
                    {
                        output.AppendLine(descSplit.PadLeft(descSplit.Length + width - offset));
                        offset = 0;
                    }
                }
                else
                {
                    output.AppendLine(arg);
                }
            }
            return output.ToString();
        }
    }
}