//            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.IO;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using OpenTap.Cli;

namespace OpenTap.Package
{
    /// <summary>
    /// Base class for ICliActions that use a mutex to lock the Target directory for the duration of the command. 
    /// </summary>
    public abstract class LockingPackageAction : PackageAction
    {
        internal const string CommandLineArgumentRepositoryDescription =
            "Override the package repository.\n" +
            "The default is https://packages.opentap.io.\n" +
            "An authentication token can be optionally supplied by appending ';token=<token>' to the url.\n" +
            "Example: https://packages.opentap.io;token=1234";
        internal const string CommandLineArgumentNoCacheDescription =
            "A package cache is used by default.\n" +
            "This can be controlled from ./Settings/Package Manager.xml\n" +
            "or disabled using this option.";
        internal const string CommandLineArgumentVersionDescription =
            "Semantic version (semver) of the package.\n" +
            "The default is to select only non pre-release packages for the current OS and CPU architecture.\n" +
            "'x'     select all (non pre-release) versions >= x.0.0 and < (x+1).0.0,\n" +
            "'x.y'   select all (non pre-release) versions >= x.y.0 and < x.(y+1).0,\n" +
            "'^x.y'  select all (non pre-release) versions >= x.y.0 and < (x+1).0.0,\n" +
            "'x.y.z' only match the exact version.\n" +
            "Use 'any', 'beta', or 'rc' to match 'any', 'beta', or 'rc' pre-release versions and above.";
        internal const string CommandLineArgumentOsDescription =
            "Override the OS (Linux, Windows, MacOS) to target.\n" +
            "The default is the current OS.";
        internal const string CommandLineArgumentArchitectureDescription =
            "Override the CPU architecture (x86, x64, AnyCPU) to target.\n" +
            "The default is the current CPU architecture.";

        /// <summary>
        /// Unlockes the package action to allow multiple running at the same time.
        /// </summary>
        public bool Unlocked { get; set; }

        /// <summary>
        /// The location to apply the command to. The default is the location of OpenTap.PackageManager.exe
        /// </summary>
        [CommandLineArgument("target", Description = "Override the location where the command is applied.\nThe default is the OpenTAP installation directory.", ShortName = "t")]
        public string Target { get; set; }


        internal static string GetLocalInstallationDir()
        {
            return Installation.Current.Directory;
        }

        internal static string GuessHostOS()
        {
            return OperatingSystem.Current.Name;
        }

        /// <summary>
        /// Get the named mutex used to lock the specified OpenTAP installation directory while it is being changed.
        /// </summary>
        /// <param name="target">The OpenTAP installation directory</param>
        /// <returns></returns>
        public static Mutex GetMutex(string target)
        {
            if (target == null)
                throw new ArgumentNullException(nameof(target));

            var fullDir = Path.GetFullPath(target).Replace('\\', '/');
            var hasher = SHA256.Create();
            var hash = hasher.ComputeHash(Encoding.UTF8.GetBytes(fullDir));

            return new Mutex(false, "Keysight.Tap.Package InstallLock " + BitConverter.ToString(hash).Replace("-", ""));
        }
        
        /// <summary>
        /// Executes this the action. Derived types should override LockedExecute instead of this.
        /// </summary>
        /// <returns>Return 0 to indicate success. Otherwise return a custom errorcode that will be set as the exitcode from the CLI.</returns>
        public override int Execute(CancellationToken cancellationToken)
        {
            if (String.IsNullOrEmpty(Target))
                Target = GetLocalInstallationDir();
            else
                Target = Path.GetFullPath(Target.Trim());
            if (!Directory.Exists(Target))
            {
                if (File.Exists(Target))
                {
                    log.Error("Destination directory \"{0}\" is a file.", Target);
                    return (int)ExitCodes.ArgumentError;
                }
                FileSystemHelper.EnsureDirectoryOf(Target);
            }

            var lockfile = Path.Combine(Target, ".lock");
            FileSystemHelper.EnsureDirectoryOf(lockfile);
            using var fileLock = FileLock.Create(lockfile);
            bool useLocking = Unlocked == false;
            if (useLocking && !fileLock.WaitOne(0))
            {
                log.Info("Waiting for other package manager operation to complete.");
                try
                {
                    switch (WaitHandle.WaitAny(new WaitHandle[] { fileLock.WaitHandle, cancellationToken.WaitHandle }, TimeSpan.FromMinutes(2)))
                    {
                        case 0: // we got the mutex
                            break;
                        case 1: // user cancelled
                            throw new ExitCodeException(5, "User aborted while waiting for other package manager operation to complete.");
                        case WaitHandle.WaitTimeout:
                            throw new ExitCodeException(6, "Timeout after 2 minutes while waiting for other package manager operation to complete.");
                    }
                }
                catch (AbandonedMutexException)
                {
                    // Another package manager exited without releasing the mutex. We should be able to take it now.
                    if (!fileLock.WaitOne(0))
                        throw new ExitCodeException(7, "Unable to run while another package manager operation is running.");
                }
            }

            return LockedExecute(cancellationToken);
        }

        /// <summary>
        /// The code to be executed by the action while the Target directory is locked.
        /// </summary>
        /// <returns>Return 0 to indicate success. Otherwise return a custom errorcode that will be set as the exitcode from the CLI.</returns>
        protected abstract int LockedExecute(CancellationToken cancellationToken);

        
        /// <summary>
        /// Only here for compatibility. Use IsolatedPackageAction instead of calling this.
        /// </summary>
        [Obsolete("Inherit from IsolatedPackageAction instead.")]
        public static bool RunIsolated(string application = null, string target = null)
        {
            try
            {
                IsolatedPackageAction.RunIsolated(application, target);
                return true;
            }
            catch(InvalidOperationException)
            {
                return false;
            }
        }
    }

}