//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using OpenTap.Cli;
using System.Threading;
using Tap.Shared;

namespace OpenTap.Package
{
    /// <summary>
    /// CLI sub command `tap sdk create` that can create a *.TapPackage from a definition in a package.xml file.
    /// </summary>
    [Display("create", Group: "package", Description: "Create a package based on an XML description file.")]
    public class PackageCreateAction : PackageAction
    {
      
        private static readonly char[] IllegalPackageNameChars = {'"', '<', '>', '|', '\0', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005', '\u0006', '\a', '\b', 
            '\t', '\n', '\v', '\f', '\r', '\u000e', '\u000f', '\u0010', '\u0011', '\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017', '\u0018', 
            '\u0019', '\u001a', '\u001b', '\u001c', '\u001d', '\u001e', '\u001f', ':', '*', '?', '\\'};

        
        /// <summary>
        /// The default file extension for OpenTAP packages.
        /// </summary>
        public static string DefaultEnding = "TapPackage";
        /// <summary>
        /// The default file name for the created OpenTAP package. 
        /// Not used anymore, a default file name is now generated from the package name and version.
        /// </summary>
        public static string DefaultFileName = "Package";

        /// <summary>
        /// Represents an unnamed command line argument which specifies the package.xml file that defines the package that should be generated.
        /// </summary>
        [UnnamedCommandLineArgument("Package Xml File", Required = true, Description = "The path to the package xml file to create a package from.")]
        public string PackageXmlFile { get; set; }

        
        /// <summary>
        /// Represents the --project-directory command line argument, which specifies the directory containing the git repository used to get values for version/branch macros.
        /// </summary>
        [CommandLineArgument("project-directory", Description = "The directory containing the git repository.\nUsed to get values for version/branch macros.")]
        public string ProjectDir { get; set; }

        /// <summary>
        /// Represents the --install command line argument. When true, this action will also install the created package.
        /// </summary>
        [CommandLineArgument("install", Description = "Install the created package. It will not overwrite the files \nalready in the target installation (e.g., debug binaries).")]
        public bool Install { get; set; } = false;

        /// <summary>
        /// Obsolete, use Install property instead.
        /// </summary>
        [CommandLineArgument("fake-install", Description = "Install the created package. It will not overwrite files \nalready in the target installation (e.g. debug binaries).")]
        [Browsable(false)]
        public bool FakeInstall { get; set; } = false;

        /// <summary>
        /// Represents the --out command line argument which specifies the path to the output file.
        /// </summary>
        [CommandLineArgument("out", Description = "Path to the output file.", ShortName = "o")]
        public string[] OutputPaths { get; set; }

        /// <summary>
        /// Constructs new action with default values for arguments.
        /// </summary>
        public PackageCreateAction()
        {
            ProjectDir = Directory.GetCurrentDirectory();
        }

        /// <summary>
        /// Executes this action.
        /// </summary>
        public override int Execute(CancellationToken cancellationToken)
        {
            if (PackageXmlFile == null)
                throw new Exception("No packages definition file specified.");

            return Process(OutputPaths, cancellationToken);
        }

        private int Process(string[] OutputPaths, CancellationToken cancellationToken)
        {
            try
            {
                PackageDef pkg = null;
                if (!File.Exists(PackageXmlFile))
                {
                    log.Error("Cannot locate XML file '{0}'", PackageXmlFile);
                    return (int)ExitCodes.ArgumentError;
                }
                if (!Directory.Exists(ProjectDir))
                {
                    log.Error("Project directory '{0}' does not exist.", ProjectDir);
                    return (int)ExitCodes.ArgumentError;
                }
                try
                {
                    var fullpath = Path.GetFullPath(PackageXmlFile);
                    pkg = PackageDefExt.FromInputXml(fullpath, ProjectDir);
                    if (pkg.Version == null)
                    {
                        log.Error(
                            $"The specified version '{pkg.RawVersion}' is not a valid semantic version. See https://semver.org");
                        return (int)PackageExitCodes.InvalidPackageDefinition;
                    }

                    // Check if package name has invalid characters or is not a valid path
                    var illegalCharacter = pkg.Name.IndexOfAny(IllegalPackageNameChars);
                    if (illegalCharacter >= 0)
                    {
                        log.Error("Package name cannot contain invalid file path characters: '{0}'.", pkg.Name[illegalCharacter]);
                        return (int)PackageExitCodes.InvalidPackageName;
                    }

                    foreach (var ch in pkg.Name.Distinct())
                    {
                            switch (ch)
                            {
                                case '/':
                                    log.Warning($"Use of the character '/' in a package name is discouraged. " +
                                                $"This will never be supported by the package repository, " +
                                                $"and might lead to problems in the future.");
                                    break;
                                default:
                                    break;
                            }
                    }

                    // Check for invalid package metadata
                    const string validMetadataPattern = "^[_a-zA-Z][_a-zA-Z0-9]*";
                    var validMetadataRegex = new Regex(validMetadataPattern);
                    foreach (var metaDataKey in pkg.MetaData.Keys)
                    {
                        var match = validMetadataRegex.Match(metaDataKey);
                        if (match.Success == false || match.Length != metaDataKey.Length)
                        {
                            if (metaDataKey.Length > 0)
                                log.Error($"Found invalid character '{metaDataKey[match.Length]}' in package metadata key '{metaDataKey}' at position {match.Length + 1}.");
                            else
                                log.Error($"Metadata key cannot be empty.");
                            return (int)PackageExitCodes.InvalidPackageDefinition;
                        }
                    }
                }
                catch (AggregateException aex)
                {
                    foreach (var inner in aex.InnerExceptions)
                    {
                        if (inner is FileNotFoundException ex)
                        {
                            log.Error("File not found: '{0}'", ex.FileName);
                        }
                        else
                        {
                            log.Error(inner.ToString());
                        }
                    }
                    log.Error("Caught errors while loading package definition.");
                    return (int)PackageExitCodes.InvalidPackageDefinition;
                }

                var tmpFile = PathUtils.GetTempFileName(".opentap_package_tmp.zip"); ;

                // If user omitted the Version XML attribute or put Version="", lets inform.
                if(string.IsNullOrEmpty(pkg.RawVersion))
                    log.Warning($"Package version is {pkg.Version} due to blank or missing 'Version' XML attribute in 'Package' element");

                using (var str = new FileStream(tmpFile, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite | FileShare.Delete, 4096, FileOptions.DeleteOnClose))
                {
                    pkg.CreatePackage(str);
                    if (OutputPaths == null || OutputPaths.Length == 0)
                        OutputPaths = new string[1] {""};

                    foreach (var outputPath in OutputPaths)
                    {
                        var path = outputPath;

                        if (String.IsNullOrEmpty(path) || path.EndsWith(Path.DirectorySeparatorChar.ToString()) || path.EndsWith(Path.AltDirectorySeparatorChar.ToString()))
                        {
                            // Package names support path separators now -- avoid writing the newly created package into a nested folder and
                            // replace the path separators with dots instead
                            var name = pkg.Name.Replace(Path.DirectorySeparatorChar, '.').Replace(Path.AltDirectorySeparatorChar, '.');
                            path = Path.Combine(path, GetRealFilePathFromName(name, pkg.Version.ToString(), DefaultEnding));
                        }

                        Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path)));
                        ProgramHelper.FileCopy(tmpFile, path);
                        log.Info("OpenTAP plugin package '{0}' containing '{1}' successfully created.", path, pkg.Name);
                    }
                }

                if (FakeInstall)
                {
                    log.Warning("--fake-install argument is obsolete, use --install instead");
                    Install = FakeInstall;
                }
                if (Install)
                {
                    var path = PackageDef.GetDefaultPackageMetadataPath(pkg, Directory.GetCurrentDirectory());
                    Directory.CreateDirectory(Path.GetDirectoryName(path));
                    using (FileStream fs = new FileStream(path, FileMode.Create))
                    {
                        pkg.SaveTo(fs);
                    }
                    log.Info($"Installed '{pkg.Name}' ({Path.GetFullPath(path)})");
                }
            }
            catch (ArgumentException ex)
            {
                log.Error("Caught exception: {0}", ex.Message);
                return (int)PackageExitCodes.PackageCreateError;
            }
            catch (InvalidDataException ex)
            {
                log.Error("Caught invalid data exception: {0}", ex.Message);

                return (int)PackageExitCodes.InvalidPackageDefinition;
            }
            return (int)ExitCodes.Success;
        }

        /// <summary>
        /// Obsolete. Do not use.
        /// </summary>
        [Obsolete("Will be removed in OpenTAP 10.")]
        public static string GetRealFilePath(string path, string version, string extension)
        {
            return GetRealFilePathFromName(Path.GetFileNameWithoutExtension(path), version, extension);
        }

        internal static string GetRealFilePathFromName(string name, string version, string extension)
        {            
            string toInsert;
            if (String.IsNullOrEmpty(version))
            {
                toInsert = "."; //just separate with '.'   
            }
            else
            {
                toInsert = "." + version + "."; // insert version between ext and path
            }

            return name + toInsert + extension;
        }
    }
}