using Dpz.Core.Backup;
using Dpz.Core.Service.Mediator.Features.Storage.Commands;
using Dpz.Core.WebApi.Models.Request;
using Microsoft.AspNetCore.RateLimiting;

namespace Dpz.Core.WebApi.Controllers;

/// <summary>
/// 系统设置
/// </summary>
[ApiController, Route("api/[controller]")]
public class SysController(
    IRestoreService restoreService,
    ILogger<SysController> logger,
    IMediator mediator,
    IConfiguration configuration
) : ControllerBase
{
    /// <summary>
    /// 还原最新数据
    /// </summary>
    /// <returns></returns>
    [HttpPost("restore"), Authorize(nameof(Permissions.System))]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> Restore([FromForm] RestoreRequest request)
    {
        try
        {
            var restoreFilePath = await SaveAsAsync(request.RestoreFile);
            await restoreService.RestoreAsync(
                request.ConnectionString,
                restoreFilePath,
                request.FilePassword
            );
        }
        catch (Exception e)
        {
            logger.LogError(e, "restore fail");
            return BadRequest();
        }

        return NoContent();
    }

    private static async Task<string> SaveAsAsync(IFormFile file)
    {
        if (file.Length <= 0)
        {
            throw new ArgumentException($"{nameof(file)} length must be greater than 0");
        }

        var restorePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "restore");
        if (!Directory.Exists(restorePath))
        {
            Directory.CreateDirectory(restorePath);
        }

        await using var stream = file.OpenReadStream();
        var restoreFilePath = Path.Combine(restorePath, $"{DateTime.Now:yyyyMMdd}.zip");
        await using var fileStream = new FileStream(
            restoreFilePath,
            FileMode.Create,
            FileAccess.Write,
            FileShare.Write,
            1 << 12
        );
        await stream.CopyToAsync(fileStream);
        await fileStream.FlushAsync();
        return restoreFilePath;
    }

    /// <summary>
    /// 接收腾讯云媒体处理回调
    /// </summary>
    [HttpPost("receive/tencent/media-process")]
    [AllowAnonymous]
    [EnableRateLimiting("callback")]
    [Consumes("application/json", "application/xml", "text/xml")]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
    public async Task<IActionResult> ReceiveTencentMediaProcessCallback(
        [FromQuery] string token = "",
        CancellationToken cancellationToken = default
    )
    {
        if (!IsCallbackTokenValid(token))
        {
            return Unauthorized("token invalid");
        }

        var result = await mediator.Send(
            new TencentMediaProcessCallbackRequest { Request = Request },
            cancellationToken
        );
        if (result.Success)
        {
            return Ok();
        }

        var statusCode = result.Code is >= 400 and <= 599
            ? result.Code
            : StatusCodes.Status400BadRequest;
        return StatusCode(statusCode, result);
    }

    /// <summary>
    /// 校验回调令牌
    /// </summary>
    private bool IsCallbackTokenValid(string token)
    {
        var configuredToken = configuration["TencentCallbackToken"];
        if (string.IsNullOrWhiteSpace(configuredToken) || string.IsNullOrWhiteSpace(token))
        {
            return false;
        }

        var configuredHash = SHA256.HashData(Encoding.UTF8.GetBytes(configuredToken));
        var providedHash = SHA256.HashData(Encoding.UTF8.GetBytes(token));
        return CryptographicOperations.FixedTimeEquals(configuredHash, providedHash);
    }
}