//            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.ComponentModel;
using System.Diagnostics;
using System.Linq;

namespace OpenTap.Cli
{
    /// <summary>
    /// Helper class that enhances the <see cref="ICliAction">ICliAction</see> with extra extensions methods.
    /// </summary>
    internal static class ICliActionExtensions
    {
        /// <summary>
        /// Executes the action with the given parameters.
        /// </summary>
        /// <param name="action">The action to be executed.</param>
        /// <param name="parameters">The parameters for the action.</param>
        /// <returns></returns>
        public static int PerformExecute(this ICliAction action, string[] parameters)
        {
            ArgumentsParser ap = new ArgumentsParser();
            var td = TypeData.GetTypeData(action);
            if (td == null)
                throw new Exception("Type data is null for action: " + action.GetType().Name);
            var props = td.GetMembers();

            ap.AllOptions.Add("help", 'h', false, "Write help information.");
            ap.AllOptions.Add("verbose", 'v', false, "Show verbose/debug-level log messages.");
            ap.AllOptions.Add("color", 'c', false, "Color messages according to their severity.");
            ap.AllOptions.Add("quiet", 'q', false, "Quiet console logging.");
            ap.AllOptions.Add("log", description: "Specify log file location. Default is ./SessionLogs.");

            var argToProp = new Dictionary<string, IMemberData>();
            var unnamedArgToProp = new List<IMemberData>();

            var overrides = new HashSet<string>();

            foreach (var prop in props)
            {
                if (prop.Readable == false || prop.Writable == false)
                    continue;

                if (prop.HasAttribute<UnnamedCommandLineArgument>())
                {
                    unnamedArgToProp.Add(prop);
                    continue;
                }

                if (!prop.HasAttribute<CommandLineArgumentAttribute>())
                    continue;

                var attr = prop.GetAttribute<CommandLineArgumentAttribute>();

                var needsArg = prop.TypeDescriptor != TypeData.FromType(typeof(bool));

                string description = "";
                if (prop.HasAttribute<ObsoleteAttribute>())
                {
                    var obsoleteAttribute = prop.GetAttribute<ObsoleteAttribute>();
                    description = $"[OBSOLETE: {obsoleteAttribute.Message}] {attr.Description}";
                }
                else
                {
                    description = attr.Description;
                }

                if (ap.AllOptions.Contains(attr.Name))
                {
                    overrides.Add(attr.Name);
                }

                if (!string.IsNullOrWhiteSpace(attr.ShortName))
                {
                    var overriden = ap.AllOptions.FirstOrDefault(opt => opt.Value?.ShortName == attr.ShortName[0])
                        .Value;
                    if (overriden != null)
                    {
                        overrides.Add(overriden.ShortName.ToString());
                        // Set the ShortName of the overriden option to '\0' so the argument parser will resolve this ShortName to the overriding option
                        // The overriden option can still be accessed by its LongName, provided that is not also overriden
                        ap.AllOptions.Add(overriden.LongName, '\0', overriden.NeedsArgument, overriden.Description);
                    }
                }

                var arg = ap.AllOptions.Add(attr.Name, attr.ShortName?.FirstOrDefault() ?? '\0', needsArg, description);
                // attr.Visible has been obsoleted but is still considered for backward compatibility.
#pragma warning disable CS0618
                arg.IsVisible = attr.Visible && (prop.GetAttribute<BrowsableAttribute>()?.Browsable ?? true);
#pragma warning restore CS0618
                argToProp.Add(arg.LongName, prop);
            }

            var args = ap.Parse(parameters);

            if (args.MissingArguments.Any())
                throw new Exception(
                    $"Command line argument '{args.MissingArguments.FirstOrDefault().LongName}' is missing an argument.");

            foreach (var @override in overrides)
            {
                if (args.Contains(@override))
                    log.Debug(
                        $"The CLI option '--{@override}' from '{action}' overrides a common CLI option from OpenTAP.");
                else if (@override.Length == 1)
                {
                    var shortName = @override[0];
                    var isUsed = args.Any(a => a.Value?.ShortName == shortName);
                    if (isUsed)
                        log.Debug(
                            $"The CLI option '-{@override}' from '{action}' overrides a common CLI option from OpenTAP.");
                }
            }

            if (!overrides.Contains("help") && args.Contains("help"))
            {
                printOptions(action.GetType().GetDisplayAttribute().Name, ap.AllOptions, unnamedArgToProp);
                return (int)ExitCodes.Success;
            }

            if (!overrides.Contains("log") && args.Contains("log"))
            {
                SessionLogs.Rename(args.Argument("log"));
            }

            foreach (var opts in args)
            {
                if (argToProp.ContainsKey(opts.Key) == false) continue;
                var prop = argToProp[opts.Key];

                if (prop.TypeDescriptor is TypeData propTd)
                {
                    Type propType2 = propTd.Load();

                    object getValue(string src, Type propType)
                    {
                        if (propType == typeof(string)) return src;
                        if (propType == typeof(bool)) return true;
                        if (propType.IsEnum)
                            return parseArbitrary(opts.Key, src, propType);
                        if (propType == typeof(int)
                            || propType == typeof(long)
                            || propType == typeof(uint)
                            || propType == typeof(ushort)
                            || propType == typeof(short)
                            || propType == typeof(byte)
                            || propType == typeof(sbyte)
                            || propType == typeof(ulong)
                            || propType == typeof(double)
                            || propType == typeof(float))
                            return Convert.ChangeType(src, propType);
                        throw new Exception(
                            $"Command line option '{opts.Key}' is of an unsupported type '{propType.Name}'.");
                    }

                    if (propType2 != typeof(string) && propType2.IsArray)
                    {
                        var array = Array.CreateInstance(propType2.GetElementType(), opts.Value.Values.Count);
                        var elemType = propType2.GetElementType();
                        for (int i = 0; i < array.Length; i++)
                            array.SetValue(getValue(opts.Value.Values[i], elemType), i);
                        prop.SetValue(action, array);
                    }
                    else
                    {
                        prop.SetValue(action, getValue(opts.Value.Value, propType2));
                    }
                }
                else
                    throw new Exception(
                        $"Command line option '{opts.Key}' is of an unsupported type '{prop.TypeDescriptor.Name}'.");
            }

            unnamedArgToProp = unnamedArgToProp.OrderBy(p => p.GetAttribute<UnnamedCommandLineArgument>().Order)
                .ToList();
            var requiredArgs = unnamedArgToProp.Where(x => x.GetAttribute<UnnamedCommandLineArgument>().Required)
                .ToHashSet();
            int idx = 0;

            for (int i = 0; i < unnamedArgToProp.Count; i++)
            {
                var p = unnamedArgToProp[i];

                if (p.TypeDescriptor.IsA(typeof(string)))
                {
                    if (idx < args.UnnamedArguments.Length)
                    {
                        p.SetValue(action, args.UnnamedArguments[idx++]);
                        requiredArgs.Remove(p);
                    }
                }
                else if (p.TypeDescriptor.IsA(typeof(string[])))
                {
                    if (idx < args.UnnamedArguments.Length)
                    {
                        p.SetValue(action, args.UnnamedArguments.Skip(idx).ToArray());
                        requiredArgs.Remove(p);
                    }

                    idx = args.UnnamedArguments.Length;
                }
                else if (p.TypeDescriptor is TypeData td2 && td2.Type.IsEnum)
                {
                    if (idx < args.UnnamedArguments.Length)
                    {
                        var name = p.GetAttribute<UnnamedCommandLineArgument>()?.Name ?? p.Name;
                        p.SetValue(action, parseArbitrary($"<{name}>", args.UnnamedArguments[idx++], td2.Type));
                        requiredArgs.Remove(p);
                    }
                }
            }

            if (args.UnknownsOptions.Any() || requiredArgs.Any())
            {
                if (args.UnknownsOptions.Any())
                    Console.WriteLine("Unknown options: " + string.Join(" ", args.UnknownsOptions));

                if (requiredArgs.Any())
                    Console.WriteLine("Missing argument: " + string.Join(" ",
                        requiredArgs.Select(p => p.GetAttribute<UnnamedCommandLineArgument>().Name)));

                printOptions(action.GetType().GetDisplayAttribute().Name, ap.AllOptions, unnamedArgToProp);
                return (int)ExitCodes.ArgumentParseError;
            }

            var actionFullName = td.GetDisplayAttribute().GetFullName();
            bool isUpdate = "package \\ check-updates" == actionFullName;

            if (isUpdate)
            { 
                // Avoid logging debug information for check-updates, since this is potentially confusing.
                return action.Execute(TapThread.Current.AbortToken);
            }
 
            log.Debug($"Executing CLI action: {actionFullName}");
            var sw = Stopwatch.StartNew();
            int exitCode = action.Execute(TapThread.Current.AbortToken);
            log.Debug(sw, "CLI action returned exit code: {0}", exitCode);
            return exitCode;
        }

        static TraceSource log = Log.CreateSource("CLI");

        private static void printOptions(string passName, ArgumentCollection options, List<IMemberData> unnamed)
        {
            var namedArguments = string.Join(" ", options.Values.Where(x => x.IsVisible)
                .Select(x =>
                {
                    var str = x.ShortName != 0 ? $"-{x.ShortName}" : "--" + x.LongName;
                    if (x.NeedsArgument)
                        str += " <arg>";

                    return '[' + str + ']';
                }));
            var unnamedArguments = string.Join(" ", unnamed.Select(x =>
            {
                var attr = x.GetAttribute<UnnamedCommandLineArgument>();
                var str = attr.Name;

                if (attr.Required == false)
                    str = "[<" + str + ">]";
                else
                    str = "<" + str + ">";

                return str;
            }));
            Console.WriteLine($"Usage: {passName} {namedArguments} {unnamedArguments}"); 
            options.UnnamedArgumentData = unnamed;
            Console.Write(options);
        }

        private static object parseArbitrary(string name, string value, Type propertyType)
        {
            var obj = StringConvertProvider.FromString(value, TypeData.FromType(propertyType), null,
                System.Globalization.CultureInfo.InvariantCulture);

            if (obj == null)
                throw new Exception(string.Format(
                    "Could not parse argument '{0}'. Argument given: '{1}'. Valid arguments: {2}", name, value,
                    string.Join(", ", propertyType.GetEnumNames())));

            return obj;
        }
    }
}