using System.Buffers;
using System.Collections.Specialized;
using System.Web;
using Dpz.Core.Public.Entity.VideoEntity;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Primitives;

namespace Dpz.Core.Service.Mediator.Features.Storage.Commands;

/// <summary>
/// 处理又拍云回调通知
/// </summary>
public class UpyunNotificationEventHandle(
    ILogger<UpyunNotificationEventHandle> logger,
    IConfiguration configuration,
    IRepository<Notification> repository
) : IRequestHandler<UpyunNotificationRequest, ResponseResult>
{
    /// <summary>
    /// 验签并处理又拍云回调通知，保存转码元数据并清理源文件。
    /// </summary>
    public async ValueTask<ResponseResult> Handle(
        UpyunNotificationRequest request,
        CancellationToken cancellationToken
    )
    {
        if (!await CheckSignature(request.Request, request.UpyunOperator))
        {
            return ResponseResult.Fail("签名验证失败", 401);
        }

        var body = await ReadBodyAsync(request.Request);

        logger.LogInformation(
            "receive upyun notification: {Body},authorization:{Authorization},content-type:{ContentType}",
            body,
            request.Request.Headers.Authorization,
            request.Request.Headers.ContentType
        );
        var parameters = HttpUtility.ParseQueryString(body);
        var bucketName = parameters.Get("bucket_name");
        if (string.IsNullOrEmpty(bucketName) || bucketName != request.UpyunOperator.Bucket)
        {
            return ResponseResult.Fail("非法存储桶", 401);
        }

        var statusCode = parameters.Get("status_code");
        if (string.IsNullOrEmpty(statusCode) || statusCode != "200")
        {
            return ResponseResult.Fail("回调状态异常", 400);
        }
        var sourceUrl = parameters.Get("media_uris[0]");
        if (!string.IsNullOrEmpty(sourceUrl))
        {
            await request.DeleteAsync(sourceUrl, cancellationToken);
        }

        var meta = GetVideoMetaInformation(parameters);
        if (meta != null)
        {
            await repository.InsertAsync(meta, cancellationToken);
        }

        return new ResponseResult
        {
            Success = true,
            Code = 204,
            Message = "NoContent",
        };
    }

    private async Task<bool> CheckSignature(HttpRequest request, UpyunOperator upyunOperator)
    {
        var authorization = request.Headers.Authorization;
        var requestDate = request.Headers.Date;
        var contentMd5 = request.Headers.ContentMD5;
        if (
            StringValues.IsNullOrEmpty(authorization)
            || StringValues.IsNullOrEmpty(requestDate)
            || StringValues.IsNullOrEmpty(contentMd5)
        )
        {
            return false;
        }

        var notifyUrl = configuration["NotifyUrl"] ?? throw new InvalidConfigurationException();
        var uri = new Uri(notifyUrl);

        var signatureBody = $"POST&{uri.OriginalString}&{requestDate}&{contentMd5}";
        var signatureKeyBytes = Encoding.UTF8.GetBytes(
            upyunOperator.Password ?? throw new InvalidConfigurationException()
        );

        using var hmac = new HMACSHA1(signatureKeyBytes);
        var signatureBodyBytes = Encoding.UTF8.GetBytes(signatureBody);
        await using var stream = ApplicationTools.MemoryStreamManager.GetStream(signatureBodyBytes);
        var signatureBytes = await hmac.ComputeHashAsync(stream);
        var signature = Convert.ToBase64String(signatureBytes);

        return authorization == $"UPYUN {upyunOperator.Operator}:{signature}";
    }

    private static async Task<string> ReadBodyAsync(HttpRequest request)
    {
        var body = new StringBuilder();
        var reader = request.BodyReader;
        while (true)
        {
            var readResult = await reader.ReadAsync();
            var buffer = readResult.Buffer;
            if (readResult.IsCompleted && buffer.Length > 0)
            {
                AppendString(body, in buffer);
            }

            reader.AdvanceTo(buffer.Start, buffer.End);

            if (readResult.IsCompleted)
            {
                break;
            }
        }

        return body.ToString();
    }

    private static void AppendString(
        StringBuilder result,
        in ReadOnlySequence<byte> readOnlySequence
    )
    {
        var span = readOnlySequence.IsSingleSegment
            ? readOnlySequence.First.Span
            : readOnlySequence.ToArray().AsSpan();
        result.Append(Encoding.UTF8.GetString(span));
    }

    private readonly JsonSerializerOptions _options = new() { PropertyNameCaseInsensitive = true };

    private Notification? GetVideoMetaInformation(NameValueCollection parameters)
    {
        var info = parameters.Get("info");
        Notification? notification = null;
        if (string.IsNullOrEmpty(info))
        {
            return notification;
        }

        var bytes = DpzAppBuilderExtensions.Base64StringToBytes(info);
        if (bytes.Length <= 0)
        {
            return notification;
        }

        var json = Encoding.UTF8.GetString(bytes);

        try
        {
            notification = JsonSerializer.Deserialize<Notification>(json, _options);
        }
        catch (Exception e)
        {
            logger.LogError(e, "parse notification info failed: {Json}", json);
            return notification;
        }

        logger.LogInformation("notification: {@Notification}", notification);
        return notification;
    }
}