//            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.IO;
using System.Linq;
using System.Threading;
using System.Xml.Linq;
[assembly:OpenTap.PluginAssembly(true)]

namespace OpenTap.Package
{
    [Display("Test Plan Package Dependencies", Description: "Serializer plugin that inserts package dependencies for a test plan in the test plan itself.")]
    internal class TestPlanPackageDependencySerializer : TapSerializerPlugin
    {
        static readonly XName PackageDependenciesName = "Package.Dependencies";
        static readonly XName PackageDependencyName = "Package";
        static readonly XName TypeDependencyName = "Type";
        static readonly XName FileDependencyName = "File";
        static readonly XName NameName = "Name";
        static readonly XName VersionName = "Version";

        public override double Order => 100; 

        public enum UserRequest
        {
            Install, Ignore
        }

        bool UsePlatformInteraction { get; set; }

        public bool WritePackageDependencies { get; set; } = true;

        class InstallNeedPackage
        {
            public string Name { get; private set; } = "Install needed package?";
            [Browsable(false)]
            public string Message { get; set; }
            [Browsable(true)]
            [Layout(LayoutMode.FullRow)]
            public string Msg => Message;
            [Submit]
            [Layout(LayoutMode.FullRow | LayoutMode.FloatBottom)]
            public UserRequest Response { get; set; }
        }

        // not used at the moment. Consider for TAP 8.6.
        void interactiveInstallPackage(string name, VersionSpecifier version)
        {
            InstallNeedPackage req = new InstallNeedPackage() {
                Message = $"Install package \"{name}\" version {version}?",
                Response = UserRequest.Ignore };
            UserInput.Request(req, true);

            Log.Info("Installing package \"{0}\".", name);

            if (req.Response == UserRequest.Install)
            {
                var ins = new PackageInstallAction() { Packages = new[] { name }, Force = true, Version = version.ToString() };
                try
                {
                    int ok = ins.Execute(new CancellationToken());
                    if (ok == 0)
                    {
                        Log.Info("Installed package. Searching for plugins.");
                        PluginManager.SearchAsync().Wait();
                    }
                    else
                    {
                        Log.Error("Unable to install package.");
                    }
                }
                catch (Exception ex)
                {
                    Log.Error("Unable to install package.");
                    Log.Debug(ex);
                }
            }
        }

        public override bool Deserialize(XElement element, ITypeData t, Action<object> setter)
        {
            var dep = element.Element(PackageDependenciesName);
            if (dep == null) return false;

            dep.Remove();
            if (element.IsEmpty)
                element.Value = ""; // little hack to ensure that the element is not created empty. (leading to null values).

            var plugins = Installation.Current.GetPackages().ToDictionary(x => x.Name);

            List<string> errors = new List<string>();
            var elements = dep.Elements(PackageDependencyName).ToArray();
            foreach (var pkg in elements)
            {
                var nameattr = pkg.Attribute(NameName);
                var versionattr = pkg.Attribute(VersionName);
                if (nameattr == null || versionattr == null)
                    continue;

                var packageName = nameattr.Value;
                var versionString = versionattr.Value;

                // for compatibility with xml files saved by OpenTAP <9.17, we have to treat all package dependencies as "this or compatible" requirements
                if (!versionString.StartsWith("^") && versionString.ToLower() != "any" && !String.IsNullOrEmpty(versionString))
                    versionString = "^" + versionString; 

                if(!VersionSpecifier.TryParse(versionString, out var version))
                {
                    errors.Add($"Version '{versionString}' of dependent package '{packageName}' could not be parsed.");
                    return false;
                }

                if (!plugins.ContainsKey(packageName))
                {
                    string legacyTapBasePackageName = "TAP Base";
                    if (packageName == legacyTapBasePackageName)
                    {
                        Log.Warning($"The saved data depends on an older, incompatible version of OpenTAP. Migrating from OpenTAP {version} to the installed version. Please verify the test plan settings.");
                        continue;
                    }
                    else
                    {
                        errors.Add($"Package '{packageName}' is required to load, but it is not installed.");
                    }

                    if (UsePlatformInteraction)
                    {
                        interactiveInstallPackage(packageName, version);   
                    }

                }
                else if (!(version.IsCompatible(plugins[packageName].Version)))
                {
                    string name = element.Document.Root.Name.ToString();
                    if(!String.IsNullOrWhiteSpace(element.BaseUri))
                        name = element.BaseUri;
                    errors.Add($"Package '{packageName}' version {version} is required to load '{name}' and the installed version ({plugins[packageName].Version}) is not compatible.");
                }
                
                foreach (var file in pkg.Elements(FileDependencyName))
                {
                    var fileNameAttr = file.Attribute(NameName);
                    if (fileNameAttr == null)
                        continue;

                    var fileName = fileNameAttr.Value;

                    if (!File.Exists(fileName))
                    {
                        errors.Add($"File '{fileName}' from package '{packageName}' is required by the test plan, but it could not be found.");
                    }
                }
            }

            foreach (var error in errors)
            {
                Log.Error(error);
                Serializer.PushError(element, error);
            }

            return false;
        }

        XElement endnode;

        public override bool Serialize(XElement elem, object obj, ITypeData type)
        {
            if (endnode == null)
            {
                endnode = elem;
                bool ok = Serializer.Serialize(elem, obj, type);

                // Allow a serializer further down the stack to disable the <Package.Dependencies> tag
                if (WritePackageDependencies)
                {
                    var pluginsNode = new XElement(PackageDependenciesName);

                    var usedSources = new HashSet<ITypeDataSource>();

                    foreach (var usedType in Serializer.GetUsedTypes())
                    {
                        // a type data might have multiple levels of dependencies.
                        // therefore we iterate to find all of them.
                        // if it is a C# type data, we assume the rest of the dependencies are
                        // taken care of.
                        var type2 = usedType;
                        while (true)
                        {
                            var src = TypeData.GetTypeDataSource(type2);

                            if (src != null)
                            {
                                // Technically base types of type2 might also be a dependency, but
                                // those should be handled by package dependencies (not test plan dependencies).
                                usedSources.Add(src);
                                break;
                            }

                            if (type2 is TypeData)
                                break;
                            
                            type2 = type2.BaseType;
                        }
                    }
                    
                    
                    var allFiles = Serializer.GetUsedFiles().ToArray();

                    var nodes = new Dictionary<PackageDef, XElement>();

                    XElement createValue(PackageDef p)
                    {
                        var ele = new XElement(PackageDependencyName);
                        ele.Add(new XAttribute(NameName, p.Name));
                        if (p.Version != null) ele.Add(new XAttribute(VersionName, $"^{p.Version}"));
                        
                        pluginsNode.Add(ele);

                        return ele;
                    }
                    
                    // Maybe enable this feature in a future release
                    bool addUsedTypes = false;
                    
                    foreach (var src in usedSources)
                    {
                        var source = Installation.Current.FindPackageContainingFile(src.Location);
                        if (source != null)
                        {
                            var node = nodes.GetOrCreateValue(source, createValue);
                            if (addUsedTypes)
                            {
                                var typeNode = new XElement(TypeDependencyName);
                                typeNode.Add(new XAttribute(NameName, src.Name));
                                node.Add(typeNode);
                            }
                        }
                    }

                    foreach (var file in allFiles)
                    {
                        var source = Installation.Current.FindPackageContainingFile(file);
                        if (source != null)
                        {
                            var node = nodes.GetOrCreateValue(source, createValue);

                            var fileNode = new XElement(FileDependencyName);
                            fileNode.Add(new XAttribute(NameName, file));
                            node.Add(fileNode);
                        }
                    }

                    elem.Add(pluginsNode);
                }

                endnode = null;
                return ok;
            }

            return false;
        }
    }
}