//            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 OpenTap.Cli;
using OpenTap.Package;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Threading;
using System.Xml.Linq;
using Newtonsoft.Json.Linq;

namespace OpenTap.Sdk.New
{
    [Display("project", "OpenTAP C# Project (.csproj). Including a new TestStep, solution file (.sln) and package.xml.", Groups: new[] { "sdk", "new" })]
    public class GenerateProject : GenerateType
    {
        enum CreateProjectResponse
        {
            Yes,
            No,
        } 
        
        class CreateProjectQuestion 
        {
            public string Name { get; }

            [Browsable(true)]
            [Layout(LayoutMode.FullRow)]
            public string Message { get; } 


            [Layout(LayoutMode.FullRow | LayoutMode.FloatBottom)]
            [Submit]
            public CreateProjectResponse Response { get; set; } = CreateProjectResponse.Yes;

            public CreateProjectQuestion(string name, string message)
            {
                Name = name;
                Message = message;
            }
        }

        #region ExitCodes

        // Exit codes are documented here: https://github.com/dotnet/templating/wiki/Exit-Codes
        private const int TemplateNotFound = 103;

        #endregion

        [CommandLineArgument("out", ShortName = "o", Description = "Destination directory for generated files.")]
        public override string output
        {
            get => base.output;
            set => base.output = value;
        }

        [UnnamedCommandLineArgument("name", Required = true, Description = "The name of the project.")]
        public string Name { get; set; }

        private static bool IsAncestor(DirectoryInfo root, DirectoryInfo dest)
        {
            while (dest != null)
            {
                if (root.FullName.Equals(dest.FullName))
                    return true;
                dest = dest.Parent;
            }

            return false;
        }
        
        [CommandLineArgument("DUT", Description = "Include a DUT in the project.", ShortName = "D")]
        public bool DUT { get; set; } 
        [CommandLineArgument("Instrument", Description = "Include an Instrument in the project.", ShortName = "I")]
        public bool Instrument { get; set; }
        [CommandLineArgument("ComponentSettings", Description = "Include a Component Setting in the project.", ShortName = "S")]
        public bool ComponentSettings { get; set; }
        [CommandLineArgument("ResultListener", Description = "Include a Result Listener in the project.", ShortName = "R")]
        public bool ResultListener { get; set; }
        [CommandLineArgument("CliAction", Description = "Include a CLI Action in the project.", ShortName = "C")]
        public bool CliAction { get; set; } 
        [CommandLineArgument("Editor", Description = "The default Editor to install.", ShortName = "E")]
        public string Editor { get; set; } = "TUI";
        
        private int DotnetNew(string projectName, DirectoryInfo directory, string template,
            CancellationToken token)
        {
            var args = $"new {template} --name \"{projectName}\" --output \"{directory.FullName}\" --Editor {Editor}";
            if (DUT)
                args += " --DUT";
            if (Instrument)
                args += " --Instrument";
            if (ComponentSettings)
                args += " --ComponentSettings";
            if (ResultListener)
                args += " --ResultListener";
            if (CliAction)
                args += " --CliAction";
            return RunDotnet(args, token);
        }
        
        public override int Execute(CancellationToken cancellationToken)
        {
            if (!Validate(name: Name, allowWhiteSpace: false, allowLeadingNumbers: false, allowAlphaNumericOnly: true))
            {
                return (int)ExitCodes.ArgumentError;
            }

            var editors = new string[] { "TUI", "Editor" };
            if (!editors.Contains(Editor))
            {
                log.Error($"Unknown editor '{Editor}'.");
                return 1;
            }

            var dest = string.IsNullOrWhiteSpace(output)
                ? new DirectoryInfo(WorkingDirectory)
                : new DirectoryInfo(output);
            if (!dest.Exists) dest.Create();
            var sln = dest.EnumerateFiles("*.sln").FirstOrDefault();

            if (sln == null)
            {
                // Check if there is a solution file in the working directory, and if the working directory is an ancestor of the destination
                var workingDirectory = new DirectoryInfo(WorkingDirectory);
                if (IsAncestor(workingDirectory, dest))
                    sln = workingDirectory.EnumerateFiles("*.sln").FirstOrDefault();
            }

            bool newSolution = sln == null;

            if (newSolution)
            {
                // Check if the destination directory is inside of an OpenTAP installation.
                var directory = dest;
                while (directory != null)
                {
                    if (directory.EnumerateFiles(".OpenTapIgnore").Any())
                        break;
                    if (directory.EnumerateFiles("OpenTap.dll").Any())
                    {
                        log.Warning($"OpenTAP installation detected in directory '{directory.FullName}'.\n" +
                                    $"Creating a project as a descendant of another OpenTAP installation can cause the installation to stop working correctly.\n");
                        var request = new CreateProjectQuestion("Really create project?",
                            "Are you sure you want to continue?")
                        {
                            Response = CreateProjectResponse.No
                        };
                        UserInput.Request(request, true);
                        if (request.Response == CreateProjectResponse.No)
                            return 1;
                        break;
                    }

                    directory = directory.Parent;
                }
            }

            if (sln == null)
            {
                // create solution file.
                // If an output folder was specified, put the solution file there.
                // If no output folder was specified, create a directory and put the solution there.
                if (string.IsNullOrWhiteSpace(output))
                    dest = dest.CreateSubdirectory(Name);

                int result = DotnetNewSln(Name, dest, cancellationToken);
                sln = dest.EnumerateFiles("*.sln").FirstOrDefault();
                if (result != 0 || sln == null || !sln.Exists)
                {
                    return result;
                } 

                // Create a Directory.Build.Props file for the new solution
                if (dest.EnumerateFiles("Directory.Build.props").Any() == false)
                {
                    using var reader = new StreamReader(Assembly.GetExecutingAssembly()!
                        .GetManifestResourceStream("OpenTap.Sdk.New.Resources.Directory.Build.props.txt")!);
                    var version = GetOpenTapVersion();
                    var content = ReplaceInTemplate(reader.ReadToEnd(), version.ToString());
                    WriteFile(Path.Combine(dest.FullName, "Directory.Build.props"), content);
                    log.Info("'Directory.Build.props' contains solution-wide settings. " +
                             "Its primary purpose is to ensure that all your projects use the same version of OpenTAP, and build into the same directory.\n");
                }
            } 

            // BUG: creating new project with --out location causes
            // solution and project to be created in the same directory 
            
            // If no output directory was requested, or if we just created a new solution in the requested directory,
            // put the project in a directory of the same name in the solution directory
            if (string.IsNullOrWhiteSpace(output) || newSolution || sln.Directory.FullName.Equals(dest.FullName))
                dest = sln.Directory.CreateSubdirectory(Name);

            // Create the new project
            int exitCode = DotnetNew(Name, dest, "opentap", cancellationToken);
            if (exitCode == TemplateNotFound)
            {
                var question = new CreateProjectQuestion("Install OpenTAP Dotnet Templates?", "OpenTAP dotnet new templates are not installed. Do you wish to install the templates?");
                UserInput.Request(question, true);
                if (question.Response == CreateProjectResponse.Yes)
                {
                    exitCode = InstallTemplate(cancellationToken);
                    if (exitCode == 0)
                        exitCode = DotnetNew(Name, dest, "opentap", cancellationToken);
                }
            }

            if (exitCode != 0)
                return exitCode;

            var csproj = dest.EnumerateFiles("*.csproj").First();
            
            // Update the OpenTAP version in the .csproj if a Directory.Build.props file exists.
            if (sln.Directory.EnumerateFiles("Directory.Build.props").Any())
                ReplaceVersion(csproj);
            
            
            // add the new project to the solution
            exitCode = DotnetSlnAdd(sln, csproj, cancellationToken);

            return exitCode;
        }

        private static void ReplaceVersion(FileInfo csproj)
        {
            // The nuget .csproj templates specify an OpenTAP version. The OpenTAP version is already controlled
            // from the build props file. Update OpenTAP versions from the .csproj to use the variable instead.
            var doc = XElement.Load(csproj.FullName);
            var itemgroups = doc.Elements("ItemGroup").ToArray();
            foreach (var grp in itemgroups)
            {
                var refs = grp.Elements("PackageReference").ToArray();
                foreach (var r in refs)
                {
                    if (r?.Attribute("Include")?.Value == "OpenTAP")
                    { 
                        r.SetAttributeValue("Version", "$(OpenTapVersion)");
                    }
                }
            }
            doc.Save(csproj.FullName);
        }

        private static void WaitForExit(Process p, CancellationToken token)
        {
            var evt = new ManualResetEventSlim(false);
            var trd = TapThread.Start(() =>
            {
                while (!p.WaitForExit(100) && !token.IsCancellationRequested)
                {
                    // wait
                }

                evt.Set();
            });

            WaitHandle.WaitAny(new[] { token.WaitHandle, evt.WaitHandle });
            token.ThrowIfCancellationRequested();
        }

        private static int InstallTemplate(CancellationToken token)
        {
            var sdk = Installation.Current.FindPackage("SDK");
            if (sdk == null)
                throw new ExitCodeException(1, "Package SDK is not installed.");
            var template = sdk.Files.FirstOrDefault(f => Path.GetExtension(f.FileName) == ".nupkg");
            if (template == null)
                throw new ExitCodeException(2, "Unable to find template package. Is the SDK package installed?");
            var fn = Path.Combine(Installation.Current.Directory, template.FileName);
            if (!File.Exists(fn))
                throw new ExitCodeException(3,
                    "Template package does not exist. The SDK package may be broken. Please reinstall SDK.");

            var si = new ProcessStartInfo("dotnet", $"new --install \"{fn}\"")
            {
                UseShellExecute = false,
            };

            var p = new Process() { StartInfo = si };
            p.Start();
            WaitForExit(p, token);
            return p.ExitCode;
        }

        private static int RunDotnet(string args, CancellationToken token)
        {
            var si = new ProcessStartInfo("dotnet", args)
            {
                UseShellExecute = false,
            };

            log.Info($"Running dotnet {args}");

            var p = new Process() { StartInfo = si };
            p.Start();

            WaitForExit(p, token);

            return p.ExitCode;

        }

        private static int DotnetNewSln(string projectName, DirectoryInfo directory, CancellationToken token)
        {
            var args = $"new sln --name \"{projectName}\" --output \"{directory.FullName}\"";
            return RunDotnet(args, token);
        } 

        private static int DotnetSlnAdd(FileInfo sln, FileInfo csproj, CancellationToken token)
        {
            // dotnet sln <SLN_FILE> add [<PROJECT_PATH>...] [options]
            var args = $"sln \"{sln.FullName}\" add \"{csproj.FullName}\"";
            return RunDotnet(args, token);
        }

        private static SemanticVersion _opentapVersion = null;
        private SemanticVersion GetOpenTapVersion()
        {
            if (_opentapVersion == null)
                _opentapVersion = NugetInterop.GetLatestNugetVersion();
            
            if (_opentapVersion == null)
            {
                log.Warning("Unable to get an OpenTAP version from Nuget, using the local version instead.");
                // cannot get opentap version. Try something else..
                var v2 = new Installation(Path.GetDirectoryName(typeof(ITestStep).Assembly.Location))
                    .GetOpenTapPackage()?.Version;
                if (v2 == null) // panic?
                    v2 = new SemanticVersion(9, 24, 0, null, null);
                _opentapVersion = new SemanticVersion(v2.Major, v2.Minor, v2.Patch, null, null);
            }

            return _opentapVersion;
        }
    }

    class NugetInterop
    {
        /// <summary> Gets all the available OpenTAP versions from Nuget (api.nuget.org) or returns null on a failure (unable to connect). It never throws. </summary> 
        public static SemanticVersion GetLatestNugetVersion()
        {
            var log = Log.CreateSource("Nuget");

            try
            {
                using (var http = new HttpClient())
                {
                    var sw = Stopwatch.StartNew();
                    var stringTask =
                        http.GetAsync("https://api-v2v3search-0.nuget.org/query?q=packageid:opentap&prerelease=false");
                    log.Debug(
                        "Getting the latest OpenTAP Nuget package version. This can be changed in the project settings.");
                    while (!stringTask.Wait(1000, TapThread.Current.AbortToken))
                    {
                        if (sw.ElapsedMilliseconds > 10000)
                            return null;
                        log.Debug("Waiting for response from nuget... ");
                    }

                    var str = stringTask.Result;

                    log.Debug(sw, "Got response from server");
                    var content = str.Content.ReadAsStringAsync().Result;

                    var j = JObject.Parse(content);
                    log.Debug("Parsed JSON content");
                    if (SemanticVersion.TryParse(j["data"][0]["version"].Value<string>(), out SemanticVersion v))
                        return v;
                    return null;
                }
            }
            catch
            {
                log.Warning("Failed to get a response from Nuget server.");
                return null;
            }
        }
    }
}