using OpenTap.Cli;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading;
using OpenTap.Package.PackageInstallHelpers;

#pragma warning disable 1591 // TODO: Add XML Comments in this file, then remove this
namespace OpenTap.Package
{

    [Display("uninstall", Group: "package", Description: "Uninstall one or more packages.")]
    public class PackageUninstallAction : IsolatedPackageAction
    {
        [CommandLineArgument("ignore-missing", Description = "Ignore packages in <package(s)> that are not currently installed.", ShortName = "i")]
        public bool IgnoreMissing { get; set; }


        [UnnamedCommandLineArgument("package(s)", Required = true, Description = "One or more packages to uninstall.")]
        public string[] Packages { get; set; }
        
        /// <summary>
        /// Never prompt for user input.
        /// </summary>
        [CommandLineArgument("non-interactive", Description = "Never prompt for user input.")]
        public bool NonInteractive { get; set; } = false;
        
        /// <summary>
        /// This will be set only if the install action was started by <see cref="PackageInstallStep"/>
        /// This is supposed to solve an issue where OpenTAP fails to detect that the process was elevated.
        /// If one level of elevation was already attempted, it is unlikely that further attempts will cause the check to succeed.
        /// In this instance, it is better to just try the installation with the current privileges, and fail with whatever
        /// error if those privileges are not sufficient.
        /// </summary>
        internal bool AlreadyElevated { get; set; }
        
        private int DoExecute(CancellationToken cancellationToken)
        {
            if (Force == false && Packages.Any(p => p == "OpenTAP") && Target == ExecutorClient.ExeDir)
            {
                log.Error(
                    "Aborting request to uninstall the OpenTAP package that is currently executing as that would brick this installation. Use --force to uninstall anyway.");
                return (int) ExitCodes.ArgumentError;
            }

            // Skip auto-correction if ignore-missing is specified
            if (IgnoreMissing == false && NonInteractive == false) 
                Packages = AutoCorrectPackageNames.Correct(Packages, Array.Empty<IPackageRepository>());

            var installation = new Installation(Target);
            var installedPackages = installation.GetPackages();
            var packagePaths = new List<string>();
            var systemwidePackages = new List<(string path, PackageDef pkg)>();

            bool anyUnrecognizedPlugins = false;
            foreach (string pack in Packages)
            {
                PackageDef package = installedPackages.FirstOrDefault(p => p.Name == pack);

                if (package != null && package.PackageSource is InstalledPackageDefSource source)
                {

                    if (package.IsSystemWide())
                        systemwidePackages.Add((source.PackageDefFilePath, package));
                    else
                    {
                        packagePaths.Add(source.PackageDefFilePath);
                        if (package.IsBundle())
                            packagePaths.AddRange(GetPaths(package, installedPackages));
                    }
                }
                else if (!IgnoreMissing)
                {
                    log.Error("Package '{0}' is not installed", pack);
                    anyUnrecognizedPlugins = true;
                }
            }

            if (anyUnrecognizedPlugins)
                return (int) PackageExitCodes.InvalidPackageName;

            if (!Force)
            {
                List<PackageDef> additionalToRemove = new List<PackageDef>();
                switch (CheckPackageAndDependencies(installedPackages, packagePaths, additionalToRemove))
                {
                    case ContinueResponse.Cancel:
                        log.Info("Uninstall cancelled by user.");
                        return (int) ExitCodes.UserCancelled;
                    case ContinueResponse.RemoveAll:
                        packagePaths.AddRange(additionalToRemove.Select(x =>((InstalledPackageDefSource)x.PackageSource ).PackageDefFilePath));
                        foreach(var pkg in additionalToRemove)
                            log.Info("Also removing {0} {1}.", pkg.Name, pkg.Version);
                        break;
                    case ContinueResponse.Continue:
                        break;
                    case ContinueResponse.Error:
                        return (int) PackageExitCodes.PackageUninstallError;    
                }
            }

            Installer installer = new Installer(Target, cancellationToken) {DoSleep = false};
            installer.PackagePaths.AddRange(packagePaths);
            installer.ProgressUpdate += RaiseProgressUpdate;
            installer.Error += RaiseError;
            
            bool needElevation = !AlreadyElevated && systemwidePackages.Any() && SubProcessHost.IsAdmin() == false;
            
            // Warn the user if elevation was already attempted, and we are not currently running as admin
            if (AlreadyElevated && SubProcessHost.IsAdmin() == false)
            {
                log.Warning($"Process elevation failed. Installation will continue without elevation.");
            }

            // If we need to remove system-wide packages and we are not admin, we should remove them in an elevated sub-process
            if (needElevation)
            {
                RaiseProgressUpdate(10, "Removing system-wide packages.");
                var installStep = new PackageUninstallStep()
                {
                    Packages = systemwidePackages.Select(p => p.pkg.Name).ToArray(),
                    Force = Force,
                    Target = PackageDef.SystemWideInstallationDirectory,
                };
                
                var processRunner = new SubProcessHost
                {
                    ForwardLogs = true,
                    MutedSources =
                    {
                        "CLI", "Session", "Resolver", "AssemblyFinder", "PluginManager", "TestPlan",
                        "UpdateCheck",
                        "Installation"
                    },
                    // The current install action is a locking package action.
                    // Setting this flag lets the child process bypass the lock on the installation.
                    Unlocked = true,
                };
                
                var result = processRunner.Run(installStep, true, cancellationToken);
                if (result != Verdict.Pass)
                {
                    var ex = new Exception(
                        $"Failed installing system-wide packages. Try running the command as administrator.");
                    RaiseError(ex);
                } 
                
                var pct = (double)systemwidePackages.Count / (systemwidePackages.Count + packagePaths.Count) * 100;
                RaiseProgressUpdate((int)pct, "Removed system-wide packages.");
            }
            // Otherwise if we are admin and we need to install system-wide packages, we can install them in the current process
            else if (systemwidePackages.Any())
            {
                installer.PackagePaths.AddRange(systemwidePackages.Select(p => p.path));
            }

            var status = installer.RunCommand(Installer.PrepareUninstall, Force, false);
            if (status == (int) ExitCodes.GeneralException)
                return (int) PackageExitCodes.PackageUninstallError;
            status = installer.RunCommand(Installer.Uninstall, Force, true);
            if (status == (int) ExitCodes.GeneralException)
                return (int) PackageExitCodes.PackageUninstallError;
            return status;
        }
        
        protected override int LockedExecute(CancellationToken cancellationToken)
        {
            if (Packages == null)
                throw new Exception("No packages specified.");
            
            var currentInterface = UserInput.GetInterface();
            if (NonInteractive)
                UserInput.SetInterface(new NonInteractiveUserInputInterface());

            try
            {
                return DoExecute(cancellationToken);
            }
            finally
            {
                IncrementChangeId(Target);
                UserInput.SetInterface(currentInterface);
            }
        }

        private List<string> GetPaths(PackageDef package, List<PackageDef> installedPackages)
        {
            if (NonInteractive)
            {
                var bundledPackages = string.Join("\n", package.Dependencies.Select(d => d.Name));
                log.Warning(
                    $"Package '{package.Name}' is a bundle and has installed:\n{bundledPackages}\n\nThese packages must be uninstalled separately.\n");
                log.Info($"Run the uninstall without the 'non-interactive' flag to interactively decide whether to keep or remove each package.");
                return new List<string>();
            }

            var result = new List<string>(package.Dependencies.Count);

            // Get the names of all dependencies including the name of the bundle containing them
            var depNames = package.Dependencies.Select(d => d.Name).ToHashSet();
            depNames.Add(package.Name);
            // Get all currently installed packages that are NOT part of this bundle
            var currentlyInstalled = installedPackages
                .Where(p => depNames.Contains(p.Name) == false).ToArray();

            foreach (var dependency in package.Dependencies)
            {
                // Never offer to uninstall OpenTAP as this will lead to a broken install.
                if (dependency.Name == "OpenTAP") continue;
                // Detect if any other package depends on a package from this bundle
                // If another package depends on it, don't offer to uninstall itg
                var otherDepender =
                    currentlyInstalled.FirstOrDefault(c =>
                        c.Dependencies.Any(d => d.Name == dependency.Name));

                if (otherDepender != null)
                {
                    log.Info(
                        $"Package '{dependency.Name}' will not be uninstalled because '{otherDepender.Name}' still depends on it.");
                    continue;
                }

                var dependencyPackage = installedPackages.FirstOrDefault(p => p.Name == dependency.Name);

                if (dependencyPackage?.PackageSource is XmlPackageDefSource source2)
                {
                    var question =
                        $"Package '{dependency.Name}' is a member of the bundle '{package.Name}'.\n" +
                        $"Do you wish to uninstall '{dependency.Name}'?";

                    var req = new UninstallRequest(question) {Response = UninstallResponse.No};
                    UserInput.Request(req, true);

                    if (req.Response == UninstallResponse.Yes)
                        result.Add(source2.PackageDefFilePath);
                }
            }

            return result;
        }

        private ContinueResponse CheckPackageAndDependencies(List<PackageDef> installed, List<string> packagePaths, List<PackageDef> removeAdditional)
        {
            var packages = packagePaths.Select(str =>
            {
                var pkg = PackageDef.FromXml(str);
                pkg.PackageSource = new XmlPackageDefSource{PackageDefFilePath = str};
                return pkg;
            }).ToList();
            installed.RemoveIf(i => packages.Any(u => u.Name == i.Name && u.Version == i.Version));
            var analyzer = DependencyAnalyzer.BuildAnalyzerContext(installed);
            var packagesWithIssues = new List<PackageDef>();

            foreach (var inst in installed)
            {
                if (analyzer.GetIssues(inst).Any(i => packages.Any(p => p.Name == i.PackageName)))
                    packagesWithIssues.Add(inst);
            }

            if (packages.Any(p => p.Files.Any(f => f.FileName.ToLower().EndsWith("OpenTap.dll"))))
            {
                log.Error("OpenTAP cannot be uninstalled.");
                return ContinueResponse.Error;
            }

            if (packagesWithIssues.Any())
            {
                log.Warning("Plugin Dependency Conflict.");

                var question = string.Format("One or more installed packages depend on {0}. Uninstalling might cause these packages to break:\n{1}",
                    string.Join(" and ", packages.Select(p => p.Name)),
                    string.Join("\n", packagesWithIssues.Select(p => p.Name + " " + p.Version)));

                var req = new ContinueRequest { message = question, Response = ContinueResponse.Cancel };
                UserInput.Request(req, true);
                if (req.Response == ContinueResponse.RemoveAll)
                {
                    removeAdditional.AddRange(packagesWithIssues);
                }
                return req.Response;
            }

            return ContinueResponse.Continue;
        }
    }

    enum ContinueResponse
    {
        [Display("Remove all the packages")]
        RemoveAll,
        // This will break the installation, so lets not present this as an option to the user.
        // --force can be used to force remove packages.
        [Browsable(false)] 
        Continue,
        Cancel,
        [Browsable(false)]
        Error,

    }

    class ContinueRequest
    {
        [Browsable(true)]
        [Layout(LayoutMode.FullRow | LayoutMode.WrapText)]
        public string Message => message;
        internal string message;
        public string Name { get; private set; } = "Continue?";

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

    enum UninstallResponse
    {
        Yes,
        No,
    }

    [Display("Uninstall bundled package?")]
    class UninstallRequest
    {
        public UninstallRequest(string message)
        {
            Message = message;
        }

        [Browsable(true)]
        [Layout(LayoutMode.FullRow | LayoutMode.WrapText)]
        public string Message { get; }
        
        [Layout(LayoutMode.FullRow | LayoutMode.FloatBottom)]
        [Submit] public UninstallResponse Response { get; set; }
    }
}