using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Xml;
using System.Xml.Linq;
using Microsoft.Build.Framework;
using OpenTap.Authentication;
using Task = Microsoft.Build.Utilities.Task;


namespace Keysight.OpenTap.Sdk.MSBuild
{
    /// <summary>
    /// MSBuild Task to help install packages. This task is invoked when using 'OpenTapPackageReference' and 'AdditionalOpenTapPackages' in .csproj files
    /// </summary>
    [Serializable]
    public class InstallOpenTapPackages : Task, ICancelableTask
    {
        internal IImageDeployer ImageDeployer { get; set; }
        /// <summary>
        /// Full qualified path to the .csproj file for which packages are being installed
        /// </summary>
        public string SourceFile { get; set; }

        /// <summary>
        /// Array of packages to install, including version and repository
        /// </summary>
        public ITaskItem[] PackagesToInstall { get; set; }

        /// <summary>
        /// Array of package repositories to resolve packages from
        /// </summary>
        public ITaskItem[] Repositories { get; set; }

        /// <summary>
        /// The build directory containing 'tap.exe' and 'OpenTAP.dll'
        /// </summary>
        public string TapDir { get; set; }
        
        /// <summary>
        /// The runtime directory in the OpenTAP nuget package
        /// </summary>
        public string OpenTapRuntimeDir { get; set; }

        /// <summary>
        /// The target platform defined in msbuild
        /// </summary>
        public string PlatformTarget { get; set; }

        private XElement _document;

        internal XElement Document
        {
            get
            {
                if (string.IsNullOrWhiteSpace(SourceFile)) return null;
                if (_document != null)
                    return _document;

                var expander = new BuildVariableExpander(SourceFile);
                // Expand all the build variables in the document to accurately identify which element corresponds to 'item'
                _document = XElement.Parse(expander.ExpandBuildVariables(File.ReadAllText(SourceFile)),
                    LoadOptions.SetLineInfo);
                return _document;
            }
        }

        private int[] GetLineNum(ITaskItem item)
        {
            var lines = new List<int>();

            try
            {
                var packageName = item.ItemSpec;
                var version = item.GetMetadata("Version");
                var repository = item.GetMetadata("Repository");

                var doc = Document;
                if (doc == null) return new[] { 0 };

                foreach (var elem in doc.GetPackageElements(packageName))
                {
                    if (elem is IXmlLineInfo lineInfo && lineInfo.HasLineInfo())
                    {
                        // If there is no exact match, return every possible match
                        lines.Add(lineInfo.LineNumber);

                        var elemVersion = elem.ElemOrAttributeValue("Version", "");
                        var elemRepo = elem.ElemOrAttributeValue("Repository", "");

                        if (elemVersion != version || elemRepo != repository)
                            continue;

                        return new[] {lineInfo.LineNumber};
                    }
                }
            }
            catch
            {
                // Ignore exception
            }

            if (lines.Count > 0)
                return lines.ToArray();
            return new[] {0};
        }

        /// <summary>
        /// Install the packages. This will be invoked by MSBuild
        /// </summary>
        /// <returns></returns>
        public override bool Execute()
        {
            if (PackagesToInstall == null || PackagesToInstall.Length == 0) 
                return true; 

            using (OpenTapContext.Create(TapDir, OpenTapRuntimeDir))
                return InstallPackages();
        }

        private CancellationTokenSource cts = new CancellationTokenSource();

        public void Cancel()
        {
            cts.Cancel();
        }

        /// <summary> Load Authentication tokens from Items into settings. </summary>
        /// <returns>True if successful.</returns>
        bool ProcessAuthTokens()
        {
            var repo2token = new Dictionary<string, string>(); 
            {
                var repoTokens = new List<(string repo, string token)>();

                foreach (var item in Repositories ?? Array.Empty<ITaskItem>())
                {
                    // Read token from <OpenTapRepository Repository="X" Token="Y"/>
                    var repo = item.GetMetadata("Repository")?.Trim();
                    var token = item.GetMetadata("Token").Trim();
                    if (string.IsNullOrWhiteSpace(token))
                        continue;

                    if (string.IsNullOrWhiteSpace(repo))
                    {
                        Log.LogError("When Token is used Repository must be specified.");
                        return false;
                    }
                    repoTokens.Add((repo, token));

                }
                
                foreach (var package in PackagesToInstall)
                {
                    // Read token from <OpenTapPackageReference Include="Z" Version="W" Repository="X" Token="Y"/>
                    // also applies top AdditionalOpenTapPackage.
                    var repo = package.GetMetadata("Repository")?.Trim();
                    var token = package.GetMetadata("Token").Trim();
                    if (string.IsNullOrWhiteSpace(token))
                        continue;

                    if (string.IsNullOrWhiteSpace(repo))
                    {
                        Log.LogError("When Token is used Repository must be specified.");
                        return false;
                    }
                    repoTokens.Add((repo, token));
                }
                foreach (var (repo, token) in repoTokens)
                {
                    if (repo2token.TryGetValue(repo, out var token2))
                    {
                        if (token == token2)
                            continue;
                        Log.LogError($"Repository ({repo}) already specified with a different token.");
                        return false;
                    }
                    repo2token.Add(repo, token);
                }
            }

            
            foreach (var tokenPair in repo2token)
            {
                try
                {
                    var uri = new Uri(tokenPair.Key, UriKind.RelativeOrAbsolute);
                    string host;
                    if (uri.IsAbsoluteUri)
                    {
                        host = uri.Host;
                    }
                    else
                    {
                        host = tokenPair.Key;
                    }


                    AuthenticationSettings.Current.Tokens.Insert(0, new TokenInfo(tokenPair.Value, "", host));
                }
                catch (Exception e)
                {
                    Log.LogError($"Could not parse URI for token: {e.Message}");
                    return false;
                }
            }
            return true;
        } 
        
        private void UpdateMarkerFiles()
        {
            // This is to avoid the following scenario:
            // 1. Install foo version 1.0.0, creating a marker file
            // 2. Install foo version 1.0.1, creating a marker file
            // 3. Downgrade foo to version 1.0.0. If marker file exists, this will be skipped
            foreach (var pkg in PackagesToInstall)
            {
                var name = pkg.ItemSpec; 
                var path = Path.Combine(TapDir, "Packages", name);
                if (!Directory.Exists(path))
                    Directory.CreateDirectory(path);
                var markerFiles = Directory.GetFiles(path, ".v*.marker");
                foreach (var f in markerFiles)
                {
                    try
                    {
                        File.Delete(f);
                    }
                    catch
                    {
                        // ignore. Not a big deal
                    }
                }
                var version = pkg.GetMetadata("Version") ?? "";
                var fs = File.Create(Path.Combine(path, $".v{version}.marker"));
                fs.Close();
            }
        }
        
        /// <summary>
        /// We *must* be in an OpenTapContext before calling this method because
        /// it depends on OpenTAP DLLs.
        /// </summary>
        /// <returns></returns>
        private bool InstallPackages()
        {
            if (!ProcessAuthTokens())
                return false;
            
            var repos = Repositories?.SelectMany(r =>
                    r.ItemSpec.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries))
                .ToList() ?? new List<string>();

            repos.AddRange(PackagesToInstall.Select(p => p.GetMetadata("Repository"))
                .Where(m => string.IsNullOrWhiteSpace(m) == false));

            repos = repos.Distinct(StringComparer.OrdinalIgnoreCase).ToList();

            using (var imageInstaller = new OpenTapImageInstaller(TapDir, OpenTapRuntimeDir, cts.Token))
            {
                imageInstaller.LogMessage += OnInstallerLogMessage;
                imageInstaller.ImageDeployer = ImageDeployer;

                try
                {
                    var success = imageInstaller.InstallImage(PackagesToInstall, repos); 
                    if (success)
                        UpdateMarkerFiles(); 
                    return success;
                }
                catch (Exception ex)
                {
                    Log.LogError(ex.Message);
                    return false;
                }
            }
        }

        private void OnInstallerLogMessage(string message, int logEventType, ITaskItem item)
        {
            // This mirrors the LogEventType enum from OpenTAP, but this class must not depend on OpenTAP being already
            // resolved. Special care is given to resolving the correct OpenTAP dll in the Execute method.
            var logLevelMap = new Dictionary<int, string>()
            {
                [10] = "Error",
                [20] = "Warning",
                [30] = "Information",
                [40] = "Debug",
            };

            var logLevel = logLevelMap[logEventType];

            var numbers = item == null ? Array.Empty<int>() : GetLineNum(item);
            var lineNumber = numbers.Any() ? numbers.First() : 0;

            // Log the messages with line number and source file information
            // A line number of '0' causes the line number to be emitted by the MSBuild logger
            var source = "OpenTAP Install";
            switch (logLevel)
            {
                case "Error":
                    Log.LogError(null, source, null, SourceFile, lineNumber, 0, 0, 0, message);
                    break;
                case "Warning":
                    Log.LogWarning(null, source, null, SourceFile, lineNumber, 0, 0, 0, message);
                    break;
                case "Information":
                    Log.LogMessage(null, source, null, SourceFile, lineNumber, 0, 0, 0, MessageImportance.Normal, message);
                    break;
                case "Debug":
                    Log.LogMessage(null, source, null, SourceFile, lineNumber, 0, 0, 0, MessageImportance.Low, message);
                    break;
            }
        }
    }
}