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

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Arcade.Common
{
    public class Helpers : IHelpers
    {
        private static readonly char[] s_slashes = [ '/', '\\' ];

        public string RemoveTrailingSlash(string directoryPath)
        {
            return directoryPath.TrimEnd(s_slashes);
        }

        public string ComputeSha256Hash(string normalizedPath)
        {
            using (var hasher = SHA256.Create())
            {
                var dirHash = Convert.ToBase64String(hasher.ComputeHash(Encoding.UTF8.GetBytes(normalizedPath)));
                dirHash = dirHash.TrimEnd('='); // base64 url encode it.
                dirHash = dirHash.Replace('+', '-');
                dirHash = dirHash.Replace('/', '_');
                return dirHash;
            }
        }

        public T MutexExec<T>(Func<T> function, string mutexName)
        {
            using var mutex = new Mutex(false, mutexName);
            bool hasMutex = false;

            try
            {
                try
                {
                    mutex.WaitOne();
                }
                catch (AbandonedMutexException)
                {
                }

                hasMutex = true;
                return function();
            }
            finally
            {
                if (hasMutex)
                {
                    mutex.ReleaseMutex();
                }
            }
        }

        public T MutexExec<T>(Func<Task<T>> function, string mutexName) =>
            MutexExec(() => function().GetAwaiter().GetResult(), mutexName); // Can't await because of mutex

        // This overload is here so that async Actions don't get routed to MutexExec<T>(Func<T> function, string path)
        public void MutexExec(Func<Task> function, string mutexName) =>
            MutexExec(() => { function().GetAwaiter().GetResult(); return true; }, mutexName);

        public T DirectoryMutexExec<T>(Func<T> function, string path) =>
            MutexExec(function, $"Global\\{ComputeSha256Hash(path)}");

        public T DirectoryMutexExec<T>(Func<Task<T>> function, string path) =>
            DirectoryMutexExec(() => function().GetAwaiter().GetResult(), path); // Can't await because of mutex

        // This overload is here so that async Actions don't get routed to DirectoryMutexExec<T>(Func<T> function, string path)
        public void DirectoryMutexExec(Func<Task> function, string path) => 
            DirectoryMutexExec(() => { function().GetAwaiter().GetResult(); return true; }, path);
    }

    public static class KeyValuePairExtensions
    {
        public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value) { key = pair.Key; value = pair.Value; }
    }
}