using Dpz.Core.Entity.Base.Indexes;
using Medallion.Threading;
using Microsoft.Extensions.Hosting;

namespace Dpz.Core.Service;

/// <summary>
/// 应用启动时自动扫描所有 IIndexedEntity 实现并创建 MongoDB 索引
/// </summary>
internal sealed class MongoIndexInitializerService(
    IConfiguration configuration,
    IMongoIndexInitializer mongoIndexInitializer,
    IFusionCache fusionCache,
    IDistributedLockProvider distributedLockProvider,
    ILogger<MongoIndexInitializerService> logger
) : IHostedService
{
    private readonly string _instanceId = Guid.NewGuid().ToString();
    private const string LockKey = "Dpz.Core.MongoIndexInitializer.Startup";
    private const string LastSuccessCacheKey = "Dpz.Core.MongoIndexInitializer.LastSuccessUtc";
    private const int DefaultSkipHours = 6;
    private static readonly TimeSpan LockWaitTimeout = TimeSpan.FromSeconds(3);
    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 connectionString = configuration.GetConnectionString("mongodb");
        if (string.IsNullOrEmpty(connectionString))
        {
            logger.LogWarning("未配置 mongodb 连接字符串，跳过索引初始化");
            return;
        }

        Assembly entityAssembly;

        try
        {
            entityAssembly = Assembly.Load("Dpz.Core.Public.Entity");
        }
        catch (Exception e)
        {
            logger.LogError(e, "未找到 Dpz.Core.Public.Entity 程序集，忽略初始化索引");
            return;
        }

        logger.LogInformation("实例 {InstanceId} 获取到索引初始化锁，开始初始化", _instanceId);

        var lastSuccess = await fusionCache.TryGetAsync<DateTimeOffset>(
            LastSuccessCacheKey,
            token: cancellationToken
        );
        if (lastSuccess.HasValue)
        {
            var elapsed = DateTimeOffset.UtcNow - lastSuccess.Value;
            var threshold = TimeSpan.FromHours(DefaultSkipHours);
            if (elapsed < threshold)
            {
                logger.LogInformation(
                    "实例 {InstanceId} 跳过索引初始化：距离上次成功仅 {ElapsedMinutes:F1} 分钟，阈值 {SkipHours} 小时",
                    _instanceId,
                    elapsed.TotalMinutes,
                    DefaultSkipHours
                );
                return;
            }
        }

        var stopwatch = Stopwatch.StartNew();

        var indexedTypes = entityAssembly
            .GetExportedTypes()
            .Where(t =>
                t is { IsClass: true, IsAbstract: false }
                && t.GetInterfaces()
                    .Any(i =>
                        i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IIndexedEntity<>)
                    )
            )
            .ToList();

        if (indexedTypes.Count == 0)
        {
            logger.LogInformation("未找到实现 IIndexedEntity 的实体类型");
            return;
        }

        var failedCount = 0;
        foreach (var entityType in indexedTypes)
        {
            try
            {
                await mongoIndexInitializer.SynchronizeForTypeAsync(
                    entityType,
                    connectionString,
                    cancellationToken
                );
            }
            catch (Exception ex)
            {
                failedCount++;
                logger.LogError(ex, "初始化 {EntityType} 的索引时出错", entityType.Name);
            }
        }

        stopwatch.Stop();

        if (failedCount == 0)
        {
            await fusionCache.SetAsync(
                LastSuccessCacheKey,
                DateTimeOffset.UtcNow,
                LastSuccessCacheTtl,
                token: cancellationToken
            );
        }

        logger.LogInformation(
            "MongoDB 索引初始化完成，共处理 {Count} 个实体类型，失败 {FailedCount}，耗时 {ElapsedMs}ms",
            indexedTypes.Count,
            failedCount,
            stopwatch.ElapsedMilliseconds
        );
    }

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

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

    public Task StopAsync(CancellationToken cancellationToken)
    {
        return mongoIndexInitializer.ResetAsync(cancellationToken);
    }
}