using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;

namespace OpenTap.Package
{
    /// <summary>
    /// An <see cref="ImageSpecifier"/> defines an OpenTAP installation. The specifier can be resolved to an
    /// <see cref="ImageIdentifier"/> which can be deployed to an actual OpenTAP installation.
    /// </summary>
    public class ImageSpecifier
    {
        static readonly TraceSource log = Log.CreateSource("image");
        
        /// <summary>
        /// Optional name of the ImageSpecifier. Used for debugging purposes.
        /// </summary>
        public string Name { get; set; } = "";

        /// <summary>
        /// Desired packages in the installation
        /// </summary>
        public List<PackageSpecifier> Packages { get; set; } = new List<PackageSpecifier>();

        /// <summary> Installed specifiers. </summary>
        internal PackageSpecifier[] FixedPackages { get; set; } = Array.Empty<PackageSpecifier>();
        
        /// <summary> The installed packages. </summary>
        internal ImmutableArray<PackageDef> InstalledPackages { get; set; } = ImmutableArray<PackageDef>.Empty;

        /// <summary> Creates a new instance. </summary>
        public ImageSpecifier(List<PackageSpecifier> packages, string name = "")
        {
            Packages = packages;
            Name = name;
        }

        /// <summary> Creates a new instance. </summary>
        public ImageSpecifier()
        {
            
        } 
        
        private static bool IsZipFile(string path)
        {
            using var fs = File.OpenRead(path);
            byte[] fileSignature = new byte[4];
            int read = fs.Read(fileSignature, 0, 4);
            if (read != 4) return false;
            // Check for presence of magic header
            var zipSignature = "PK\x03\x04"u8.ToArray();
            return fileSignature.SequenceEqual(zipSignature);
        }
        internal static ImageSpecifier FromAddedPackages(Installation installation, IEnumerable<PackageSpecifier> newPackages)
        {
            var toInstall = new List<PackageSpecifier>();
            var installed = installation.GetPackages(true).ToList();
            var additionalPackages = new List<PackageDef>();

            foreach (var package in newPackages)
            {
                var existing = installed.FirstOrDefault(x => x.Name == package.Name);
                if (existing != null)
                { 
                    installed.Remove(existing);
                    additionalPackages.Add(existing);
                }

                // IsZipFile handles the special case where there exists a file on disk
                // with the same name as a package which is not a zip file.
                if (File.Exists(package.Name) && IsZipFile(package.Name))
                {
                    if (PackageDef.TryFromPackage(package.Name, out var package2))
                    {
                        toInstall.Add(new PackageSpecifier(package2.Name, package2.Version.AsExactSpecifier()));
                        installed.Add(package2);
                        continue;
                    }
                    else 
                    {
                        var extension = Path.GetExtension(package.Name);
                        var expectedExtensions = new string[] { ".zip", ".tappackage" };
                        if (extension != null && expectedExtensions.Any(e => string.Equals(e, extension, StringComparison.OrdinalIgnoreCase)))
                        {
                            throw new Exception($"Package {package.Name} could not be installed. The file is not a valid tap package.");
                        }
                    }
                }

                toInstall.Add(package);
            }

            var fixedPackages = installed.Where(x => toInstall.Any(y => y.Name == x.Name) == false)
                .Select(x => new PackageSpecifier(x.Name, x.Version.AsCompatibleSpecifier(), x.Architecture, x.OS))
                .ToArray();

            toInstall.AddRange(fixedPackages);

            return new ImageSpecifier
            {
                Packages = toInstall,
                AdditionalPackages = additionalPackages,
                InstalledPackages = installed.ToImmutableArray(),
                FixedPackages = fixedPackages
            };
        }


        /// <summary>
        /// OpenTAP repositories to fetch the desired packages from
        /// These should be well formed URIs and will be interpreted relative to the BaseAddress set in AuthenticationSettings.
        /// </summary>
        public List<string> Repositories { get; set; } = new List<string>();

        internal List<PackageDef> AdditionalPackages { get; set; } = new List<PackageDef>();
        
        /// <summary> The OS this image specifier targets. </summary>
        public string OS { get; set; } = Installation.Current.OS;
        
        /// <summary> The CPU architecture that this image specifier targets. </summary>
        public CpuArchitecture Architecture { get; set; } = Installation.Current.Architecture;

        
        /// <summary>
        /// Resolve the desired packages from the specified repositories. This will check if the packages are available, compatible and can successfully be deployed as an OpenTAP installation
        /// </summary>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <exception cref="ImageResolveException">The exception thrown if the image could not be resolved</exception>
        public ImageIdentifier Resolve(CancellationToken cancellationToken)
        {
            List<IPackageRepository> repositories = Repositories.Distinct()
                .Select(PackageRepositoryHelpers.DetermineRepositoryType)
                .GroupBy(p => p.Url)
                .Select(g => g.First())
                .ToList();

            var cache = new PackageDependencyCache(OS, Architecture, Repositories);
            cache.LoadFromRepositories();
            cache.AddPackages(InstalledPackages);
            cache.AddPackages(AdditionalPackages);
            var sw = Stopwatch.StartNew();
            
            var resolver = new ImageResolver(cancellationToken);
            
            var image = resolver.ResolveImage(this, cache.Graph);
            if (image.Success == false)
            {
                throw new ImageResolveException(image, this, InstalledPackages);
            }
            
            log.Debug(sw, "Resolved image: {0}", this);
            
            var packages = image.Packages.Select(x => cache.GetPackageDef(x)).ToArray();
            if (packages.Any(x => x == null))
                throw new InvalidOperationException("Unable to lookup resolved package");
            ImageIdentifier image2 = new ImageIdentifier(packages, repositories.Select(s => s.Url));

            return image2;
        }

        /// <summary>
        /// Merges and resolves the packages for a number of images. May throw an exception if the packages cannot be resolved.
        /// </summary>
        /// <param name="images">The images to merge.</param>
        /// <param name="cancellationToken">A cancellation token to cancel the operation before time. This will cause an OperationCancelledException to be thrown.</param>
        /// <returns></returns>
        /// <exception cref="ImageResolveException">The exception thrown if the image could not be resolved</exception>
        public static ImageIdentifier MergeAndResolve(IEnumerable<ImageSpecifier> images, CancellationToken cancellationToken)
        {
            
            var img = new ImageSpecifier(images.SelectMany(x =>x.Packages).Distinct().ToList());
            img.Repositories = images.SelectMany(x => x.Repositories).Distinct().ToList();
            return img.Resolve(cancellationToken);
        }

        /// <summary>
        /// Like Resolve, but includes the current installation as a base. In this case, packages can be upgraded and downgraded,
        /// but not removed if they do not exist in the image specification.
        /// </summary>
        internal ImageIdentifier MergeAndResolve(Installation deploymentInstallation, CancellationToken cancellationToken)
        {
            var imageSpecifier2 = FromAddedPackages(deploymentInstallation, Packages);
            imageSpecifier2.Name = Name;
            if (imageSpecifier2.Repositories?.Any() != true)
                imageSpecifier2.Repositories = Repositories;
            imageSpecifier2.OS = OS;
            imageSpecifier2.Architecture = Architecture;

            var image = imageSpecifier2.Resolve(cancellationToken);
            return image;
        }

        /// <summary>
        /// Resolve specified packages in the ImageSpecifier with respect to the target installation.
        /// Specified packages will take precedence over already installed packages
        /// Already installed packages, which are not specified in the imagespecifier, will remain installed.
        /// </summary>
        /// <param name="deploymentInstallation">OpenTAP installation to merge with and deploy to.</param>
        /// <param name="cancellationToken">Standard CancellationToken</param>
        /// <returns>A new Installation</returns>
        /// <exception cref="ImageResolveException">In case of resolve errors, this method will throw ImageResolveExceptions.</exception>
        public Installation MergeAndDeploy(Installation deploymentInstallation, CancellationToken cancellationToken)
        {
            var image = MergeAndResolve(deploymentInstallation, cancellationToken);
            image.Deploy(deploymentInstallation.Directory, cancellationToken);
            return new Installation(deploymentInstallation.Directory);
        }

        /// <summary>
        /// Create an <see cref="ImageSpecifier"/> from JSON or XML value. Throws <see cref="InvalidOperationException"/> if value is not valid JSON or XML
        /// </summary>
        /// <param name="value">JSON or XML formatted <see cref="ImageSpecifier"/></param>
        /// <returns>An <see cref="ImageSpecifier"/></returns>
        public static ImageSpecifier FromString(string value)
        {
            return ImageHelper.GetImageFromString(value);
        }

        /// <summary> Turns an image into a readable string.</summary>
        /// <returns></returns>
        public override string ToString() => string.Join(", ", Packages.Select(x => $"{x.Name}:{x.Version}"));
    }
}