// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

#nullable enable

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using Microsoft.Deployment.DotNet.Releases;
using Microsoft.DotNet.Build.Tasks.Workloads.Msi;
using NuGet.Packaging;
using NuGet.Packaging.Core;
using NuGet.Versioning;

namespace Microsoft.DotNet.Build.Tasks.Workloads
{
    /// <summary>
    /// Serves as a base class for implementing different types of workload packages. The class captures some common
    /// elements related to the underlying NuGet package.
    /// </summary>
    public abstract class WorkloadPackageBase : IWorkloadPackageMetadata
    {
        /// <summary>
        /// The package authors.
        /// </summary>
        public string Authors
        {
            get;
        }

        /// <summary>
        /// The NuGet package copyright.
        /// </summary>
        public string Copyright
        {
            get;
        }

        /// <summary>
        /// The NuGet package description.
        /// </summary>
        public string Description
        {
            get;
        }

        /// <summary>
        /// Determines on the contents of the package is managed.
        /// </summary>
        public abstract PackageExtractionMethod ExtractionMethod
        {
            get;
        }

        /// <summary>
        /// The NuGet package identifier.
        /// </summary>
        public string Id => Identity.Id;

        /// <summary>
        /// The identity of the NuGet package.
        /// </summary>
        public PackageIdentity Identity
        {
            get;
        }

        /// <summary>
        /// Gets whether the package has been extracted.
        /// </summary>
        public bool HasBeenExtracted
        {
            get;
            private set;
        }

        public LicenseMetadata? LicenseData
        {
            get;
        }

        public string? LicenseUrl
        {
            get;
        }

        /// <summary>
        /// Gets the version to use for the generated MSI's ProductVersion property.
        /// </summary>
        public abstract Version MsiVersion
        {
            get;
        }

        public string PackagePath
        {
            get;
        }

        public string PackageFileName
        {
            get;
        }

        public string ShortName
        {
            get;
        }

        /// <summary>
        /// A string containing the major, minor and patch version of the package.
        /// </summary>
        public string ProductVersion => $"{PackageVersion.Major}.{PackageVersion.Minor}.{PackageVersion.Patch}";

        public string Title
        {
            get;
        }

        public string ProjectUrl
        {
            get;
        }

        /// <summary>
        /// The version of the NuGet package.
        /// </summary>
        public NuGetVersion PackageVersion => Identity.Version;

        public ITaskItem[]? ShortNames
        {
            get;
        }

        /// <summary>
        /// The SWIX identifier for the package in VS.
        /// </summary>
        public string SwixPackageId
        {
            get;
            protected set;
        }

        /// <summary>
        /// The SWIX identifier for a package group that references this SWIX package.
        /// </summary>
        public string SwixPackageGroupId
        {
            get;
            protected set;
        }

        /// <summary>
        /// Gets an instance of a <see cref="TaskLoggingHelper"/> class containing task logging methods.
        /// </summary>
        protected TaskLoggingHelper? Log
        {
            get;
        }

        /// <summary>
        /// A <see cref="System.Version"/> containing the major, minor, and patch version of the underlying NuGet package.
        /// </summary>
        public Version Version => Identity.Version.Version;

        /// <summary>
        /// The destination directory where the package will be extracted.
        /// </summary>
        public string DestinationDirectory
        {
            get;
        }

        /// <summary>
        /// Creates a new instance of a <see cref="WorkloadPackageBase"/> class.
        /// </summary>
        /// <param name="packagePath">The path of the NuGet package.</param>
        /// <param name="destinationBaseDirectory">The root directory where packages will be extracted.</param>
        /// <param name="shortNames">A set of items used to shorten the names and identifiers of setup packages.</param>
        /// <param name="log">A <see cref="TaskLoggingHelper"/> class containing task logging methods.</param>
        public WorkloadPackageBase(string packagePath, string destinationBaseDirectory, ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null)
        {
            // Very important: If the underlying stream isn't closed, it will cause
            // sharing violations when the package content is being extracted later.
            using FileStream fs = new(packagePath, FileMode.Open);
            using PackageArchiveReader reader = new(fs);
            NuspecReader nuspec = reader.NuspecReader;

            Authors = nuspec.GetAuthors();
            Copyright = nuspec.GetCopyright();
            Description = nuspec.GetDescription();
            Identity = nuspec.GetIdentity();
            LicenseData = nuspec.GetLicenseMetadata();
            LicenseUrl = nuspec.GetLicenseUrl();
            ProjectUrl = nuspec.GetProjectUrl();
            Title = nuspec.GetTitle();

            PackagePath = packagePath;

            // Directory structures that are too deep can still cause failures
            // when harvesting packages. Especially when running tests under Arcade. Stripping
            // off the package identity can work around this. Below is an example of such a failure:
            // 
            // heat.exe : error HEAT5059 : The file 'D:\git\forks\dotnet\src\arcade\artifacts\bin\Microsoft.DotNet.Build.Tasks.Workloads.Tests\Debug\net11.0\TEST_OUTPUT\uq4xhvn3\pkg\Microsoft.NET.Runtime.Emscripten.2.0.23.Python.win-x64.6.0.4\tools\lib\site-packages\pythonwin\pywin\framework\editor\color\coloreditor.py' cannot be found.
            DestinationDirectory = Path.Combine(destinationBaseDirectory, Path.GetRandomFileName());
            ShortNames = shortNames;

            PackageFileName = Path.GetFileNameWithoutExtension(packagePath);
            ShortName = PackageFileName.Replace(shortNames);
            SwixPackageId = $"{Id.Replace(shortNames)}.{Identity.Version}";
            SwixPackageGroupId = $"{DefaultValues.PackageGroupPrefix}.{SwixPackageId}";
            Log = log;
        }

        /// <summary>
        /// Extracts the contents of the package.
        /// </summary>
        public void Extract()
        {
            Extract(Enumerable.Empty<string>());
        }

        /// <summary>
        /// Extract the contents of the package and optionally delete files that match
        /// the set of exclusions.
        /// </summary>
        /// <param name="exclusionPatterns">A set of regular expression patterns used to determine if a
        /// file should be excluded. Excluded files will be deleted after the package has been extracted.</param>
        public virtual void Extract(IEnumerable<string> exclusionPatterns)
        {
            if (HasBeenExtracted)
            {
                return;
            }

            Utils.DeleteDirectory(DestinationDirectory);
            Directory.CreateDirectory(DestinationDirectory);

            if (ExtractionMethod == PackageExtractionMethod.Copy)
            {
                File.Copy(PackagePath, Path.Combine(DestinationDirectory, Path.GetFileName(PackagePath)), overwrite: true);
                HasBeenExtracted = true;
            }
            else if (ExtractionMethod == PackageExtractionMethod.Unzip)
            {
                ZipFile.ExtractToDirectory(PackagePath, DestinationDirectory);

                // Remove unnecessary files and directories that we never want to ship. These are always present in a NuGet package.
                Utils.DeleteDirectory(Path.Combine(DestinationDirectory, "_rels"));
                Utils.DeleteDirectory(Path.Combine(DestinationDirectory, "package"));

                Utils.DeleteFile(Path.Combine(DestinationDirectory, ".signature.p7s"));
                Utils.DeleteFile(Path.Combine(DestinationDirectory, "[Content_Types].xml"));
                Utils.DeleteFile(Path.Combine(DestinationDirectory, $"{Id}.nuspec"));

                if (exclusionPatterns.Any())
                {
                    foreach (string file in Directory.EnumerateFiles(DestinationDirectory, "*.*", SearchOption.AllDirectories))
                    {
                        if (exclusionPatterns.Any(pattern => Regex.IsMatch(file, pattern)))
                        {
                            Log?.LogMessage(MessageImportance.Low, string.Format(Strings.WorkloadPackageDeleteExclusion, file));
                            File.Delete(file);
                        }
                    }
                }

                HasBeenExtracted = true;
            }
        }

        /// <summary>
        /// Converts a string containing an SDK version to a semantic version that normalizes the patch level and 
        /// optionally includes the first two prerelease labels. For example, if the specified version is 6.0.105, then
        /// 6.0.100 would be returned. If the version is 6.0.301-preview.2.1234, the result would be 6.0.300-preview.1.
        /// </summary>
        /// <param name="sdkVersion">A string containing an SDK version.</param>
        /// <returns>An SDK feature band version.</returns>
        internal static ReleaseVersion GetSdkFeatureBandVersion(string sdkVersion)
        {
            ReleaseVersion version = new(sdkVersion);

            // Ignore CI and dev builds.
            if (string.IsNullOrEmpty(version.Prerelease) || version.Prerelease.Split('.').Any(s => string.Equals("ci", s) || string.Equals("dev", s)))
            {
                return new ReleaseVersion(version.Major, version.Minor, version.SdkFeatureBand);
            }

            string[] preleaseParts = version.Prerelease.Split('.');

            // Only the first two prerelease identifiers are used to support side-by-side previews.
            string prerelease = (preleaseParts.Length > 1) ?
                $"{preleaseParts[0]}.{preleaseParts[1]}" :
                preleaseParts[0];

            return new ReleaseVersion(version.Major, version.Minor, version.SdkFeatureBand, prerelease);
        }

        /// <summary>
        /// Extracts the SDK version from the package ID.
        /// </summary>
        /// <param name="packageId">The package ID from which to extract the SDK version.</param>
        /// <param name="separator">A string used to determine where the SDK version should start.</param>
        /// <returns>SDK version part of the package ID.</returns>
        /// <exception cref="FormatException" />
        internal static string GetSdkVersion(string packageId, string separator) =>
            !string.IsNullOrWhiteSpace(packageId) && packageId.IndexOf(separator) > -1 ?
                packageId.Substring(packageId.IndexOf(separator) + separator.Length) :
                throw new FormatException(string.Format(Strings.CannotExtractSdkVersionFromPackageId, packageId));

        /// <summary>
        /// Gets the MSI ProductVersion to use for the given packagage. The task item metadata is used first, before falling
        /// back to using the version parameter on the task. If neither exist an exception is thrown.
        /// </summary>
        /// <param name="package">The package item to convert into an MSI.</param>
        /// <param name="msiVersion">The default MSI version 1</param>
        /// <param name="taskName"></param>
        /// <param name="taskParameterName"></param>
        /// <param name="taskItemName"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        internal static Version GetMsiVersion(ITaskItem package, Version msiVersion, string taskName,
            string taskParameterName, string taskItemName)
        {
            if (!string.IsNullOrWhiteSpace(package.GetMetadata(Metadata.MsiVersion)))
            {
                // We prefer version metadata information on the package item.
                return new(package.GetMetadata(Metadata.MsiVersion));
            }
            else if (msiVersion != null)
            {
                // Fall back to the version provided by the task parameter.
                return msiVersion;
            }

            // While we could use the major.minor.patch part of the package, it won't work for upgradable MSIs (manifests) and
            // unlike packs, we want users to be explicit about the MSI versionsand
            // the user to be aware of this and explicitly tell us the value.
            throw new Exception(string.Format(Strings.NoInstallerVersion, taskName,
                taskParameterName, taskItemName, Metadata.MsiVersion));
        }
    }
}

#nullable disable