using OpenTap.Cli;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Xml;

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

    [Display("show", Group: "package", Description: "Show information about a package.")]
    public class PackageShowAction : LockingPackageAction
    {
        private string Description { get; set; }
        private List<Tuple<string, string>> SubTags { get; } = new List<Tuple<string, string>>();
        private void ParseDescription(string description)
        {
            var doc = new XmlDocument();
            doc.LoadXml($"<Description>{description}</Description>");

            foreach (object tag in doc["Description"])
            {
                if (tag is XmlText t)
                {
                    Description = t.InnerText.Trim();
                }
                else if (tag is XmlElement e)
                {
                    var text = e.InnerText.Trim();
                    if (!string.IsNullOrWhiteSpace(text))
                        SubTags.Add(new Tuple<string, string>(e.Name, text));
                }
            }
        }

        private void AddWritePair(string key, string value)
        {
            if (!string.IsNullOrWhiteSpace(value))
            {
                keys.Add(key);
                values.Add(value);
            }
        }

        private void WritePairs()
        {
            var justify = keys.Max(x => x.Length) + 1;
            int consoleWidth;
            try
            {
                consoleWidth = Console.WindowWidth;
            }
            catch // No handle to a console window -- default to something reasonable
            {
                consoleWidth = 120;
            }

            if (consoleWidth < 10) // assume an error and just use 120 as default.
                consoleWidth = 120;
            var wrapLength = Math.Min(consoleWidth - justify - 3, 100);
            for (int i = 0; i < keys.Count; i++)
            {
                var key = keys[i].PadRight(justify);
                var value = string.Join(Environment.NewLine.PadRight(justify + 2 + Environment.NewLine.Length), WordWrap(values[i], wrapLength).Where(x => !string.IsNullOrWhiteSpace(x)));
                log.Info($"{key}: {value}");
            }
        }

        private List<string> values = new List<string>();
        private List<string> keys = new List<string>();

        [CommandLineArgument("repository", Description = CommandLineArgumentRepositoryDescription, ShortName = "r")]
        public string[] Repository { get; set; }

        [CommandLineArgument("offline", Description = "Don't check http repositories.", ShortName = "o")]
        public bool Offline { get; set; }

        [UnnamedCommandLineArgument("package", Required = true, Description = "The name of the package to show information for. Can be a .TapPackage file, or a package name to be resolved from the specified repositories.")]
        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; }

        [CommandLineArgument("include-files", Description = "List all files included in the package")]
        public bool IncludeFiles { get; set; } = false;

        [CommandLineArgument("include-plugins", Description = "List all plugins included in the package")]
        public bool IncludePlugins { get; set; } = false;

        private List<IPackageRepository> repositories = new List<IPackageRepository>();

        private VersionSpecifier versionSpec { get; set; }

        private void DisableHttpRepositories()
        {
            repositories = new List<IPackageRepository>(repositories.OfType<FilePackageRepository>().ToList());
        }

        private PackageDef GetPackageDef(Installation targetInstallation)
        {
            // Try a number of methods to obtain the PackageDef in order of precedence
            var packageRef = new PackageSpecifier(Name, VersionSpecifier.Parse(Version ?? ""), Architecture, OS);
            PackageDef package;
            // a relative or absolute file path
            if (File.Exists(Name))
            {
                package = PackageDef.FromPackage(Name);

                if (package != null)
                {
                    Offline = true;
                    return package;
                }
            }

            // a currently installed package
            package = targetInstallation.GetPackages().FirstOrDefault(p => p.Name == Name && versionSpec.IsCompatible(p.Version));
            if (package != null)
                return package;

            if (Offline == false)
            {
                try
                {
                    // a release from repositories
                    package = repositories.SelectMany(x => x.GetPackages(packageRef))
                        .FindMax(p => p.Version);
                    if (package != null)
                        return package;
                }
                catch (System.Net.WebException e)
                {
                    // not connected to the internet
                    log.Error(e.Message);
                    log.Warning("Could not connect to repository. Showing results for local install");
                    DisableHttpRepositories();

                    package = repositories.SelectMany(x => x.GetPackages(packageRef))
                        .FindMax(p => p.Version);
                    if (package != null)
                        return package;
                }
            }

            if (Offline == false && string.IsNullOrWhiteSpace(Version))
            {
                // a prerelease from repositories
                packageRef = new PackageSpecifier(Name, VersionSpecifier.Parse("any"), Architecture, OS);
                package = repositories.SelectMany(x => x.GetPackages(packageRef))
                    .FindMax(p => p.Version);
            }

            return package;
        }
        protected override int LockedExecute(CancellationToken cancellationToken)
        {
            repositories = PackageManagerSettings.Current.GetEnabledRepositories(Repository);
            if (Offline)
            {
                DisableHttpRepositories();
            }

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

            if (Target == null)
                Target = FileSystemHelper.GetCurrentInstallationDirectory();

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

            var targetInstallation = new Installation(Target);

            PackageDef package = GetPackageDef(targetInstallation);
            if (package == null)
            {
                var versionString = string.IsNullOrWhiteSpace(Version) ? "" : $" version '{Version}'";
                throw new ExitCodeException((int)ExitCodes.ArgumentError, 
                    $"Package '{Name}'{versionString} not found in specified repositories or local install.");
            }

            var packageVersions = Offline
                ? new List<PackageVersion>()
                : repositories.SelectMany(repo => repo.GetPackageVersions(package.Name, cancellationToken, null))
                    .Where(p => versionSpec.IsCompatible(p.Version));
            // Remove prereleases if found package is a release
            if (string.IsNullOrWhiteSpace(package.Version.PreRelease))
                packageVersions = packageVersions.Where(p => string.IsNullOrWhiteSpace(p.Version.PreRelease));

            if (Architecture != CpuArchitecture.Unspecified)
                packageVersions = packageVersions.Where(p => ArchitectureHelper.CompatibleWith(Architecture, p.Architecture));

            if (!string.IsNullOrWhiteSpace(OS))
                packageVersions = packageVersions.Where(p => p.OS.Contains(OS));


            GetPackageInfo(package, packageVersions.ToList(), targetInstallation);

            return (int)ExitCodes.Success;
        }

        private void GetPackageInfo(PackageDef package, List<PackageVersion> packageVersions,
            Installation installation)
        {
            var allPackages = installation.GetPackages();
            var latestVersion = packageVersions?.Max(p => p.Version);
            var packageInstalled = allPackages.Contains(package);
            if (!packageInstalled)
                allPackages.Add(package);

            var tree = DependencyAnalyzer.BuildAnalyzerContext(allPackages);
            var issues = tree.GetIssues(package);

            ParseDescription(package.Description);

            // Get similar releases to get available platforms and architectures
            var similarReleases = packageVersions.Where(x =>
                x.Version.Major == package.Version.Major && x.Version.Minor == package.Version.Minor).ToList();

            AddWritePair("Package Name", package.Name);

            AddWritePair("Group", package.Group);

            var installedVersion = installation.GetPackages().Where(x => x.Name == package.Name)?.FirstOrDefault()?.Version;
            var installedString = installedVersion == null ? "(not installed)" : $"({installedVersion} installed)";
            AddWritePair("Version", $"{package.Version} {installedString}");

            if (latestVersion != null && installedVersion != null && latestVersion != installedVersion)
                AddWritePair("Newest Version in Repository", $"{latestVersion}");

            AddWritePair("Compatible Architectures", string.Join(Environment.NewLine, similarReleases.Select(x => x.Architecture).Distinct()));

            var platforms = similarReleases
                .SelectMany(x => x.OS.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
                .Distinct(StringComparer.OrdinalIgnoreCase);

            AddWritePair("Compatible Platforms", string.Join(Environment.NewLine, platforms));

            if (packageInstalled == false)
            {
                AddWritePair("Compatibility Issues", issues.Any()
                    ? $"{(string.Join(Environment.NewLine, issues.Select(x => $"{x.PackageName} - {Utils.EnumToReadableString(x.IssueType)}")))}"
                    : "none");
            }

            AddWritePair("Owner", package.Owner);
            AddWritePair("Source License", package.SourceLicense);
            var licenseString = (package.LicenseRequired ?? "").Replace("&", " and ").Replace("|", " or ");
            AddWritePair("License Required", licenseString);
            AddWritePair("SourceUrl", package.SourceUrl);
            if (package.PackageSource is IRepositoryPackageDefSource repoPkg)
                AddWritePair("Repository", repoPkg.RepositoryUrl);
            AddWritePair("Package Type", package.FileType);
            AddWritePair("Package Class", package.Class);
            AddWritePair("Architecture", package.Architecture.ToString());
            AddWritePair("Platform", package.OS ?? "");

            var tags = package.Tags?.Split(new string[] { " ", "," }, StringSplitOptions.RemoveEmptyEntries);
            if (tags?.Length > 0)
                AddWritePair("Package Tags", string.Join(" ", tags));

            if (package.Dependencies.Count > 0)
            {
                var pad = package.Dependencies.Select(x => x.Name.Length).Max();
                var aligned = package.Dependencies.Select(pkg => $"{pkg.Name.PadRight(pad)} - {pkg.Version}");
                
                AddWritePair("Dependencies", string.Join(Environment.NewLine, aligned));
            }

            foreach (var (key, value) in SubTags)
            {
                AddWritePair(key, value);
            }

            AddWritePair("Description", Description);

            if (IncludeFiles)
            {
                if (package.Files.Count > 0)
                {
                    AddWritePair("Files", string.Join(Environment.NewLine, package.Files.Select(x => x.RelativeDestinationPath.Replace("\\", "/"))));
                }
            }

            if (IncludePlugins)
            {
                var plugins = package.Files.Select(x => x.Plugins);

                var sb = new StringBuilder();
                foreach (var plugin in plugins)
                {
                    foreach (var p in plugin)
                    {
                        var name = p.Name;
                        var desc = p.Description;
                        sb.Append(!string.IsNullOrWhiteSpace(desc) ? $"{name} ({desc}){Environment.NewLine}" : $"{name}{Environment.NewLine}");
                    }
                }
                AddWritePair("Plugins", sb.ToString());
            }

            if (package.MetaData.Any())
            {
                foreach (var metadata in package.MetaData)
                    AddWritePair(metadata.Key, metadata.Value);
            }
            
            WritePairs();
        }
        private IEnumerable<string> WordWrap(string input, int breakLength)
        {
            // In addition to whitespace, break on these characters
            var breakableCharacters = new List<char>() { '-', ' ', '\t', '\n' };

            var progress = 0;
            var currentLength = 0;
            var lastBreakableCharacter = -1;

            foreach (var c in input)
            {
                currentLength++;

                if (breakableCharacters.Contains(c))
                    lastBreakableCharacter = currentLength;

                // Break if line length exceeds break length, or if the sentence contains a literal newline
                if (currentLength > breakLength || c == '\n')
                {
                    // Keep reading until we can break
                    if (lastBreakableCharacter == -1)
                        continue;

                    yield return input.Substring(progress, lastBreakableCharacter).Trim();

                    progress += lastBreakableCharacter;
                    currentLength -= lastBreakableCharacter;
                    lastBreakableCharacter = -1;
                }
            }
            yield return input.Substring(progress).Trim();
        }
    }
}