using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;
using QYZH.InteractiveMagazine.Infrastructure.Cache;
using QYZH.InteractiveMagazine.Infrastructure.MessageQueue;
using QYZH.InteractiveMagazine.Infrastructure.Middleware;
using QYZH.InteractiveMagazine.Models.Settings;
using RabbitMQ.Client;
using StackExchange.Redis;
using System.Text;

namespace QYZH.InteractiveMagazine.Infrastructure.Extensions;

/// <summary>
/// 统一服务注册扩展
/// </summary>
public static class DependencyInjectionExtensions
{
    /// <summary>
    /// 注册基础设施服务
    /// </summary>
    /// <param name="services">服务集合</param>
    /// <param name="configuration">配置</param>
    public static void AddInfrastructureServices(this IServiceCollection services, IConfiguration configuration)
    {
        AddJwtAuthentication(services, configuration);
        AddRedisCache(services, configuration);
        AddRabbitMQ(services, configuration);

        services.AddTransient<GlobalExceptionMiddleware>();
        services.AddTransient<OperationLogMiddleware>();
    }

    /// <summary>
    /// 配置JWT认证
    /// </summary>
    /// <param name="services">服务集合</param>
    /// <param name="configuration">配置</param>
    private static void AddJwtAuthentication(IServiceCollection services, IConfiguration configuration)
    {
        var jwtSettings = configuration.GetSection("JwtSettings").Get<JwtSettings>()!;

        services.AddSingleton(jwtSettings);

        services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddJwtBearer(options =>
            {
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuer = true,
                    ValidIssuer = jwtSettings.Issuer,
                    ValidateAudience = true,
                    ValidAudience = jwtSettings.Audience,
                    ValidateIssuerSigningKey = true,
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSettings.SecretKey!)),
                    ValidateLifetime = true,
                    ClockSkew = TimeSpan.Zero
                };
            });
    }

    /// <summary>
    /// 注册Redis缓存
    /// </summary>
    /// <param name="services">服务集合</param>
    /// <param name="configuration">配置</param>
    private static void AddRedisCache(IServiceCollection services, IConfiguration configuration)
    {
        var redisSettings = configuration.GetSection("RedisSettings").Get<RedisSettings>()!;

        services.AddSingleton(redisSettings);

        services.AddSingleton<IConnectionMultiplexer>(sp =>
        {
            var multiplexer = ConnectionMultiplexer.Connect(redisSettings.ConnectionString!);
            RedisHelper.Connection = multiplexer;
            RedisHelper.SetKeyPrefix(redisSettings.InstanceName!);
            return multiplexer;
        });
    }

    /// <summary>
    /// 注册RabbitMQ
    /// </summary>
    /// <param name="services">服务集合</param>
    /// <param name="configuration">配置</param>
    private static void AddRabbitMQ(IServiceCollection services, IConfiguration configuration)
    {
        var rabbitMQSettings = configuration.GetSection("RabbitMQSettings").Get<RabbitMQSettings>()!;

        services.AddSingleton(rabbitMQSettings);

        services.AddSingleton<IConnection>(sp =>
        {
            var factory = new ConnectionFactory
            {
                HostName = rabbitMQSettings.HostName!,
                Port = rabbitMQSettings.Port,
                UserName = rabbitMQSettings.UserName!,
                Password = rabbitMQSettings.Password!,
                VirtualHost = rabbitMQSettings.VirtualHost!
            };

            return factory.CreateConnectionAsync().GetAwaiter().GetResult();
        });

        services.AddTransient<RabbitMQPublisher>();
    }
}