using Dpz.Core.Entity.Base.MapperConfig;
using Dpz.Core.Infrastructure.Intercept;
using Dpz.Core.MessageQueue.Extensions;
using MailKit;
using Mapster;
using Medallion.Threading;
using Medallion.Threading.FileSystem;
using Medallion.Threading.Redis;
using Microsoft.Extensions.Caching.StackExchangeRedis;
using Microsoft.Extensions.DependencyInjection;
using StackExchange.Redis;
using ZiggyCreatures.Caching.Fusion.Backplane.StackExchangeRedis;
using ZiggyCreatures.Caching.Fusion.Serialization.SystemTextJson;

#pragma warning disable CS0162

namespace Dpz.Core.Service;

public static class ServiceExtensions
{
    public static void AddBusinessServices(
        this IServiceCollection services,
        IConfiguration configuration
    )
    {
        // 邮件日志
        services.AddTransient<IProtocolLogger, SerilogProtocolLogger>();
        services.AddTransient<IUnitOfWork, UnitOfWork>();
        services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
        // 索引初始化服务
        services.AddSingleton<IMongoIndexInitializer, MongoIndexInitializer>();
        // 索引初始化后台任务
        services.AddHostedService<MongoIndexInitializerService>();

#if DEBUG
        services.AddScoped<Func<IRepository<Music>>>(x =>
        {
            var config = x.GetService<IConfiguration>();
            var connectionString = config?.GetConnectionString("mongodb-test");
            return () => new Repository<Music>(connectionString);
        });
#endif
        services.AddSingleton<TypeAdapterConfig>(_ => GlobalConfigMapper.GetTypeAdapterConfig());
        services.AddSingleton<IMapper>(_ => GlobalConfigMapper.GetMapper());

        var redisConnectionStr = configuration.GetConnectionString("redis") ?? "";
        // 分布式锁
        services.AddSingleton<IDistributedLockProvider>(_ =>
        {
#if DEBUG
            var fileLockPath =
                configuration.GetValue("FileLockPath", @"D:\backup\dpz.core.lock")
                ?? throw new InvalidConfigurationException("FileLockPath Invalid Config");
            var lockFileDirectory = new DirectoryInfo(fileLockPath);
            return new FileDistributedSynchronizationProvider(lockFileDirectory);
#endif
            var connectionMultiplexer = ConnectionMultiplexer.Connect(redisConnectionStr);
            var database = connectionMultiplexer.GetDatabase();
            return new RedisDistributedSynchronizationProvider(database);
        });

        services.AddScoped<IBingWallpaper, BingWallpaper>();
        services.AddFusionCacheServices(redisConnectionStr);
        services.AddScoped<IInterceptRuleService, InterceptRuleService>();

        // 注册 RabbitMQ 消息队列基础服务（发布者）
        // 各应用层根据需要注册具体的消费者
        services.AddRabbitMQ(configuration).AddMessageOutbox();
        // 注册中介者，确保处理器可使用已注册的缓存/消息队列等组件。
        services.AddDpzMediator();
        services.AddSingleton<OwnerService>();
    }

    /// <summary>
    /// 添加 FusionCache 缓存服务配置
    /// </summary>
    /// <param name="services">服务集合</param>
    /// <param name="redisConnectionString">Redis 连接字符串</param>
    private static void AddFusionCacheServices(
        this IServiceCollection services,
        string redisConnectionString
    )
    {
        // 添加基础内存缓存服务
        services.AddMemoryCache();

        services
            .AddFusionCache()
            .WithOptions(options =>
            {
                // 分布式缓存熔断器持续时间：当Redis连接失败时，等待3秒后重试
                options.DistributedCacheCircuitBreakerDuration = TimeSpan.FromSeconds(3);

                /*
                 * 自定义日志级别配置
                 * 大幅减少 FusionCache 的日志噪音，特别是新版本的详细操作日志
                 */

                // 故障安全激活：重要事件，应该记录
                options.FailSafeActivationLogLevel = LogLevel.Warning;
                // 序列化错误：需要关注
                options.SerializationErrorsLogLevel = LogLevel.Warning;
                // 分布式缓存超时：只记录Warning级别
                options.DistributedCacheSyntheticTimeoutsLogLevel = LogLevel.Warning;
                // 分布式缓存错误：必须记录
                options.DistributedCacheErrorsLogLevel = LogLevel.Error;
                // 工厂方法超时：只记录Warning级别
                options.FactorySyntheticTimeoutsLogLevel = LogLevel.Warning;
                // 工厂方法错误：必须记录
                options.FactoryErrorsLogLevel = LogLevel.Error;
            })
            .WithDefaultEntryOptions(
                new FusionCacheEntryOptions
                {
                    // ===== 故障安全配置 =====
                    // 启用故障安全模式：当Redis不可用时，使用本地缓存中的旧数据
                    IsFailSafeEnabled = true,
                    // 故障安全最大持续时间：最多使用1天的旧数据
                    FailSafeMaxDuration = TimeSpan.FromDays(1),
                    // 故障安全节流持续时间：30秒内不重复尝试访问故障的分布式缓存
                    FailSafeThrottleDuration = TimeSpan.FromSeconds(30),

                    // ===== 工厂方法超时配置 =====
                    // 工厂方法软超时：500ms后开始使用故障安全数据（如果有）
                    FactorySoftTimeout = TimeSpan.FromMilliseconds(500),
                    // 工厂方法硬超时：2秒后强制中断工厂方法执行
                    FactoryHardTimeout = TimeSpan.FromMilliseconds(2000),

                    // ===== 分布式缓存配置 =====
                    // Redis 软超时：1秒后开始使用本地缓存（如果有）
                    DistributedCacheSoftTimeout = TimeSpan.FromSeconds(1),
                    // Redis 硬超时：2秒后放弃Redis操作，完全依赖本地缓存
                    DistributedCacheHardTimeout = TimeSpan.FromSeconds(2),
                    // 允许后台分布式缓存操作：写入Redis操作异步执行，不阻塞主请求
                    AllowBackgroundDistributedCacheOperations = true,

                    // ===== 抖动配置 =====
                    // 最大抖动时间：在缓存过期时间上随机添加0-2秒，防止缓存雪崩
                    JitterMaxDuration = TimeSpan.FromSeconds(2),
                }
            )
            // 使用 System.Text.Json 序列化器
            .WithSerializer(
                new FusionCacheSystemTextJsonSerializer(
                    new JsonSerializerOptions { IncludeFields = true }
                )
            )
            // 配置 Redis 作为分布式缓存（L2缓存）
            .WithDistributedCache(
                new RedisCache(new RedisCacheOptions { Configuration = redisConnectionString })
            )
            // 配置 Redis 背板：用于多服务器间的缓存失效通知
            .WithBackplane(
                new RedisBackplane(
                    new RedisBackplaneOptions { Configuration = redisConnectionString }
                )
            );
    }
}