using OpenTap.Cli;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

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

    [Display("list", Group: "package", Description: "List locally installed packages and browse the online package repository.")]
    public class PackageListAction : LockingPackageAction
    {
        [CommandLineArgument("repository", Description = CommandLineArgumentRepositoryDescription, ShortName = "r")]
        public string[] Repository { get; set; }

        [CommandLineArgument("no-cache", Description = CommandLineArgumentNoCacheDescription)]
        public bool NoCache { get; set; }

        [CommandLineArgument("all", Description = "List all versions of <package> even if the OS or the CPU architecture\nare not compatible with the current machine.", ShortName = "a")]
        public bool All { get; set; }

        [CommandLineArgument("installed", Description = "Show only installed packages.", ShortName = "i")]
        public bool Installed { get; set; }

        [UnnamedCommandLineArgument("package", Description = "The name of the package to list versions for. If omitted, all packages will be listed.")]
        public string Name { get; set; }

        [CommandLineArgument("version", Description = CommandLineArgumentVersionDescription)]
        public string Version { get; set; }

        [CommandLineArgument("os", Description = CommandLineArgumentOsDescription)]
        public string OS { get; set; }

        [CommandLineArgument("architecture", Description = CommandLineArgumentArchitectureDescription)]
        public CpuArchitecture Architecture { get; set; }

        public PackageListAction()
        {
            Architecture = ArchitectureHelper.GuessBaseArchitecture;
            OS = null;
        }

        protected override int LockedExecute(CancellationToken cancellationToken)
        {
            // OS was explicitly specified. This is interpreted as: Show only packages compatible with that OS. 
            bool checkOs = OS != null;
            OS ??= GuessHostOS();

            if (NoCache) PackageManagerSettings.Current.UseLocalPackageCache = false;
            Repository = ExtractRepositoryTokens(Repository, true);
            List<IPackageRepository> repositories = new List<IPackageRepository>();

            if (Installed == false)
            {
                repositories = PackageManagerSettings.Current.GetEnabledRepositories(Repository);
            }

            Name = AutoCorrectPackageNames.Correct(new[] { Name }, repositories)[0];

            if (Target == null)
                Target = FileSystemHelper.GetCurrentInstallationDirectory();
            
            HashSet<PackageDef> installed = new Installation(Target).GetPackages().ToHashSet();
            if (checkOs)
                installed = installed.Where(pkg => pkg.IsOsCompatible(OS)).ToHashSet();

            VersionSpecifier versionSpec = VersionSpecifier.Parse("^");
            if (!String.IsNullOrWhiteSpace(Version))
            {
                versionSpec = VersionSpecifier.Parse(Version);
            }

            if (string.IsNullOrEmpty(Name))
            {
                var packages = installed.ToList();
                packages.AddRange(PackageRepositoryHelpers.GetPackageNameAndVersionFromAllRepos(repositories, new PackageSpecifier("", versionSpec, Architecture, OS)));

                if (Installed)
                    packages = packages.Where(p => installed.Any(i => i.Name == p.Name)).ToList();

                PrintReadable(packages, installed);
            }
            else
            {
                IPackageIdentifier package = installed.FirstOrDefault(p => p.Name == Name);

                if (Installed)
                {
                    if (package is null)
                    {
                        log.Info($"{Name} is not installed");
                        return (int)ExitCodes.ArgumentError;
                    }

                    log.Info(package.Version.ToString());
                    return (int)ExitCodes.Success;
                }


                List<PackageVersion> versions = null;

                if (All)
                {
                    versions = PackageRepositoryHelpers.GetAllVersionsFromAllRepos(repositories, Name).Where(v => v.IsUnlisted == false).Distinct().ToList();
                    var versionsCount = versions.Count;
                    if (versionsCount == 0) // No versions
                    {
                        log.Info($"No versions of '{Name}'.");
                        return (int)ExitCodes.Success;
                    }

                    if (Version != null) // Version is specified by user
                        versions = versions.Where(v => versionSpec.IsCompatible(v.Version)).ToList();
                    if(checkOs)
                        versions = versions.Where(v => v.IsOsCompatible(OS)).ToList();

                    if (versions.Any() == false && versionsCount > 0)
                    {
                        log.Info($"Package '{Name}' does not exists with version '{Version}'.");
                        log.Info($"Package '{Name}' exists in {versionsCount} other versions, please specify a different version.");
                        return (int)ExitCodes.Success;
                    }
                }
                else
                {
                    var opentap = new Installation(Target).GetOpenTapPackage();
                    versions = PackageRepositoryHelpers.GetAllVersionsFromAllRepos(repositories, Name, opentap).Where(v => v.IsUnlisted == false).Distinct().ToList();

                    versions = versions.Where(s => s.IsUnlisted == false && s.IsPlatformCompatible(Architecture, OS)).ToList();

                    if (versions.Any() == false) // No compatible versions
                    {
                        versions = PackageRepositoryHelpers.GetAllVersionsFromAllRepos(repositories, Name).Where(v => v.IsUnlisted == false).ToList();
                        if (versions.Any())
                        {
                            log.Warning($"There are no compatible versions of '{Name}'.");
                            log.Info($"There are {versions.Count} incompatible versions available. Use '--all' to show these.");
                        }
                        else
                            log.Warning($"Package '{Name}' could not be found in any repository.");

                        return (int)ExitCodes.Success;
                    }


                    var allVersion = versions;
                    versions = versions.Where(v => versionSpec.IsCompatible(v.Version)).ToList();
                    if (versions.Any() == false) // No versions that are compatible
                    {
                        if (string.IsNullOrEmpty(Version))
                            log.Warning($"There are no released versions of '{Name}'. Showing pre-releases instead.");
                        else
                            log.Warning($"Package '{Name}' does not exists with version '{Version}'.");

                        var anyPrereleaseSpecifier = new VersionSpecifier(versionSpec.Major, versionSpec.Minor, versionSpec.Patch, versionSpec.PreRelease, versionSpec.BuildMetadata, VersionMatchBehavior.AnyPrerelease | versionSpec.MatchBehavior);
                        versions = allVersion.Where(v => anyPrereleaseSpecifier.IsCompatible(v.Version)).ToList();
                        if (versions.Any())
                            PrintVersionsReadable(package, versions);

                        return (int)ExitCodes.Success;
                    }
                }
                PrintVersionsReadable(package, versions);
            }
            return (int)ExitCodes.Success;
        }

        private void PrintVersionsReadable(IPackageIdentifier package, List<PackageVersion> versions)
        {
            var verLen = versions.Select(p => p.Version?.ToString().Length).Max() ?? 0;
            var arcLen = versions.Select(p => p?.Architecture.ToString().Length).Max() ?? 0;
            var osLen = versions.Select(p => p.OS?.Length).Max() ?? 0;
            foreach (var version in versions.OrderBy(x => x.Version))
            {
                // string interpolate + format complex to add padding.
                log.Info(string.Format($"{{0,-{verLen}}} - {{1,-{arcLen}}} - {{2,-{osLen}}} - {{3}}", version.Version, version.Architecture, version.OS ?? "Unknown", package != null && package.Equals(version) ? "installed" : ""));
            }
        }

        private void PrintReadable(List<PackageDef> packages, HashSet<PackageDef> installed)
        {
            var packageList = packages.GroupBy(p => p.Name).Select(x => x.OrderByDescending(p => p.Version).First()).OrderBy(x => x.Name).ToList();

            if (packageList.Count == 0)
            {
                log.Info("Selected directory has no packages installed.");
                return;
            }

            var nameLen = packageList.Select(p => p.Name?.Length).Max() ?? 0;
            var verLen = packageList.Select(p => p.Version?.ToString().Length).Max() ?? 0;
            verLen = Math.Max(verLen, installed.Select(p => p.Version?.ToString().Length).Max() ?? 0);
            
            foreach (var plugin in packageList)
            {
                var installedPackage = installed.FirstOrDefault(p => p.Name == plugin.Name);
                var latestPackage = packages.Where(p => p.Name == plugin.Name).OrderByDescending(p => p.Version).FirstOrDefault();

                bool isInstalled = installedPackage != null;
                bool isSystemWide = installedPackage?.IsSystemWide() ?? false;
                bool isValid = installedPackage?.IsValid() ?? false;
                string installedString = "";
                if (isInstalled)
                {
                    installedString = "-";
                    if (isValid)
                        installedString += " installed";
                    if(isSystemWide)
                        installedString += " system-wide";
                    if (!isValid)
                    {
                        if (installedString != "-")
                            installedString += " -";
                        installedString += " needs reinstall";
                    }
                }

                // string interpolate + format complex to add padding.
                string logMessage = string.Format($"{{0,-{nameLen}}} - {{1,-{verLen}}} {{2}}", plugin.Name, (installedPackage ?? plugin).Version, installedString);

                if (installedPackage != null && installedPackage?.Version?.CompareTo(latestPackage.Version) < 0)
                    logMessage += $" - update available ({latestPackage.Version})";

                // assuming that all dlls in the package requires has the same or distinct license requirements. 
                // Duplicates are made if one file requires X|Y and the other X|Z or even Y|X.
                var licensesRequiredStrings = plugin.Files.Select(p => p.LicenseRequired).Where(l => string.IsNullOrWhiteSpace(l) == false).Select(l => LicenseBase.FormatFriendly(l)).Distinct();

                var licenses = string.Join(" & ", licensesRequiredStrings);

                if (licenses != "")
                    logMessage += " - requires license " + licenses;

                log.Info(logMessage);
            }
        }

    }

}