using System.Diagnostics;
using Medallion.Threading;

namespace Dpz.Core.Web.Library;

/// <summary>
/// 应用启动时自动将 wwwroot 目录下所有文件上传到对象存储
/// </summary>
internal sealed class AssetUploadHostedService(
    AssetService assetService,
    IFusionCache fusionCache,
    IDistributedLockProvider distributedLockProvider,
    ILogger<AssetUploadHostedService> logger
) : IHostedService
{
    private readonly string _instanceId = Guid.NewGuid().ToString();
    private const string LockKey = "Dpz.Core.AssetUpload.Startup";
    private const string LastSuccessCacheKey = "Dpz.Core.AssetUpload.LastSuccessUtc";
    private const int SkipMinutes = 30;
    private static readonly TimeSpan LockWaitTimeout = TimeSpan.FromSeconds(5);
    private static readonly TimeSpan LastSuccessCacheTtl = TimeSpan.FromDays(7);

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        await using var lockHandle = await TryAcquireStartupLockAsync(cancellationToken);
        if (lockHandle == null)
        {
            logger.LogInformation(
                "实例 {InstanceId} 未获取到资产上传锁，跳过本次上传",
                _instanceId
            );
            return;
        }

        var lastSuccess = await fusionCache.TryGetAsync<DateTimeOffset>(
            LastSuccessCacheKey,
            token: cancellationToken
        );
        if (lastSuccess.HasValue)
        {
            var elapsed = DateTimeOffset.UtcNow - lastSuccess.Value;
            if (elapsed < TimeSpan.FromMinutes(SkipMinutes))
            {
                logger.LogInformation(
                    "实例 {InstanceId} 跳过资产上传：距上次成功仅 {ElapsedMinutes:F1} 分钟，阈值 {SkipMinutes} 分钟",
                    _instanceId,
                    elapsed.TotalMinutes,
                    SkipMinutes
                );
                return;
            }
        }

        logger.LogInformation("实例 {InstanceId} 开始上传 wwwroot 资产到对象存储", _instanceId);
        var stopwatch = Stopwatch.StartNew();

        try
        {
            await assetService.UploadAssentAsync(cancellationToken);

            stopwatch.Stop();

            await fusionCache.SetAsync(
                LastSuccessCacheKey,
                DateTimeOffset.UtcNow,
                LastSuccessCacheTtl,
                token: cancellationToken
            );

            logger.LogInformation(
                "实例 {InstanceId} 资产上传完成，耗时 {ElapsedMs}ms",
                _instanceId,
                stopwatch.ElapsedMilliseconds
            );
        }
        catch (Exception ex)
        {
            stopwatch.Stop();
            logger.LogError(
                ex,
                "实例 {InstanceId} 资产上传失败，耗时 {ElapsedMs}ms",
                _instanceId,
                stopwatch.ElapsedMilliseconds
            );
        }
    }

    private async Task<IDistributedSynchronizationHandle?> TryAcquireStartupLockAsync(
        CancellationToken cancellationToken
    )
    {
        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        cts.CancelAfter(LockWaitTimeout);

        try
        {
            return await distributedLockProvider.AcquireLockAsync(
                LockKey,
                timeout: null,
                cancellationToken: cts.Token
            );
        }
        catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
        {
            return null;
        }
    }

    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
}