using System.Globalization;
using System.Security.Cryptography;
using System.Text;

namespace Dpz.Core.Service.ObjectStorage.Services.Impl;

internal sealed class CosRequestSigner(S3ObjectStorageOptions options) : ICosRequestSigner
{
    private static readonly TimeSpan DefaultExpiration = TimeSpan.FromMinutes(5);

    public HttpRequestMessage CreateRequest(
        HttpMethod method,
        string pathToFile,
        IReadOnlyCollection<CosQueryParameter> queryParameters,
        string? bucket = null,
        TimeSpan? expires = null
    )
    {
        ArgumentNullException.ThrowIfNull(method);
        ArgumentNullException.ThrowIfNull(queryParameters);

        var effectiveBucket = string.IsNullOrWhiteSpace(bucket) ? options.Bucket : bucket;
        if (string.IsNullOrWhiteSpace(effectiveBucket))
        {
            throw new ArgumentException("COS bucket is required", nameof(bucket));
        }

        var key = S3ObjectKeyHelper.NormalizeKey(pathToFile);
        var host = BuildCosHost(effectiveBucket);
        var encodedKey = EncodePath(key);
        var query = BuildQueryString(queryParameters);
        var requestUri = new Uri(
            string.IsNullOrEmpty(query)
                ? $"https://{host}/{encodedKey}"
                : $"https://{host}/{encodedKey}?{query}"
        );

        var request = new HttpRequestMessage(method, requestUri);
        request.Headers.Host = host;
        request.Headers.TryAddWithoutValidation(
            "Authorization",
            BuildAuthorization(method, encodedKey, host, queryParameters, expires)
        );
        return request;
    }

    private string BuildCosHost(string bucket)
    {
        return $"{bucket}.cos.{options.Region}.myqcloud.com";
    }

    private string BuildAuthorization(
        HttpMethod method,
        string encodedKey,
        string host,
        IReadOnlyCollection<CosQueryParameter> queryParameters,
        TimeSpan? expires
    )
    {
        var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        var end = now + (long)(expires ?? DefaultExpiration).TotalSeconds;
        var signTime = $"{now};{end}";
        var keyTime = signTime;
        const string signAlgorithm = "sha1";
        const string headerList = "host";
        var urlParamList = BuildParameterList(queryParameters);
        var canonicalHeaders = $"host={Encode(host)}";
        var canonicalQuery = BuildCanonicalQueryString(queryParameters);
        var httpString =
            $"{method.Method.ToLowerInvariant()}\n/{encodedKey}\n{canonicalQuery}\n{canonicalHeaders}\n";
        var stringToSign =
            $"{signAlgorithm}\n{signTime}\n{Sha1Hex(Encoding.UTF8.GetBytes(httpString))}\n";
        var signKey = HmacSha1Hex(options.SecretKey!, keyTime);
        var signature = HmacSha1Hex(signKey, stringToSign);

        return string.Join(
            "&",
            [
                $"q-sign-algorithm={signAlgorithm}",
                $"q-ak={Encode(options.SecretId!)}",
                $"q-sign-time={signTime}",
                $"q-key-time={keyTime}",
                $"q-header-list={headerList}",
                $"q-url-param-list={urlParamList}",
                $"q-signature={signature}",
            ]
        );
    }

    private static string BuildQueryString(IReadOnlyCollection<CosQueryParameter> parameters)
    {
        return string.Join(
            "&",
            parameters.Select(x =>
                x.Value == null ? Encode(x.Name) : $"{Encode(x.Name)}={Encode(x.Value)}"
            )
        );
    }

    private static string BuildCanonicalQueryString(
        IReadOnlyCollection<CosQueryParameter> parameters
    )
    {
        return string.Join(
            "&",
            parameters
                .Select(x => new
                {
                    Name = x.Name.ToLowerInvariant(),
                    Value = x.Value ?? string.Empty,
                })
                .OrderBy(x => x.Name, StringComparer.Ordinal)
                .Select(x => $"{Encode(x.Name)}={Encode(x.Value)}")
        );
    }

    private static string BuildParameterList(IReadOnlyCollection<CosQueryParameter> parameters)
    {
        return string.Join(
            ";",
            parameters.Select(x => x.Name.ToLowerInvariant()).Order(StringComparer.Ordinal)
        );
    }

    private static string EncodePath(string key)
    {
        return string.Join("/", key.Split('/').Select(Encode));
    }

    private static string Encode(string value)
    {
        var bytes = Encoding.UTF8.GetBytes(value);
        var builder = new StringBuilder();
        foreach (var item in bytes)
        {
            var valueChar = (char)item;
            if (
                valueChar is >= 'A' and <= 'Z'
                || valueChar is >= 'a' and <= 'z'
                || valueChar is >= '0' and <= '9'
                || valueChar is '-' or '_' or '.' or '~'
            )
            {
                builder.Append(valueChar);
            }
            else
            {
                builder.Append('%');
                builder.Append(item.ToString("X2", CultureInfo.InvariantCulture));
            }
        }

        return builder.ToString();
    }

    private static string Sha1Hex(byte[] bytes)
    {
        return Convert.ToHexString(SHA1.HashData(bytes)).ToLowerInvariant();
    }

    private static string HmacSha1Hex(string key, string message)
    {
        using var hmac = new HMACSHA1(Encoding.UTF8.GetBytes(key));
        return Convert
            .ToHexString(hmac.ComputeHash(Encoding.UTF8.GetBytes(message)))
            .ToLowerInvariant();
    }
}