using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Omika.Core.Interfaces.Mobile;
using Omika.Data;
using Omika.Data.Configuration;
using Omika.Data.Connection;
using Omika.Data.Repositories.Technical;

namespace Omika.Tests.Connection;

public class ServiceCollectionExtensionsTests
{
    [Fact]
    public void AddOmikaData_RegistersWebServiceConnectionAsScoped()
    {
        var services = new ServiceCollection();

        services.AddOmikaData();

        var descriptor = services.Single(d => d.ServiceType == typeof(IWebServiceHfSqlConnection));
        Assert.Equal(ServiceLifetime.Scoped, descriptor.Lifetime);
    }

    [Fact]
    public void AddOmikaDataServiceConnection_RegistersServiceConnectionAsScoped()
    {
        var services = new ServiceCollection();

        services.AddOmikaDataServiceConnection();

        var descriptor = services.Single(d => d.ServiceType == typeof(IServiceHfSqlConnection));
        Assert.Equal(ServiceLifetime.Scoped, descriptor.Lifetime);
    }

    [Fact]
    public void AddOmikaData_RegistersSyncTransferRepositoryAsScoped()
    {
        var services = new ServiceCollection();

        services.AddOmikaData();

        var descriptor = services.Single(d => d.ServiceType == typeof(ISyncTransferRepository));
        Assert.Equal(ServiceLifetime.Scoped, descriptor.Lifetime);
        Assert.Equal(typeof(SyncTransferRepository), descriptor.ImplementationType);
    }

    [Fact]
    public void AddOmikaDataSyncConnection_DoesNotRegisterSyncTransferRepository()
    {
        // L'ancienne connexion Sync unique ne doit plus brancher le repository :
        // le repository est désormais multi-connexion (Service + WebService).
        var services = new ServiceCollection();

        services.AddOmikaDataSyncConnection();

        Assert.DoesNotContain(services, d => d.ServiceType == typeof(ISyncTransferRepository));
    }

    [Fact]
    public async Task AddOmikaData_ResolvesSyncTransferRepository_WithBothConnections()
    {
        // Vérifie que le DI résout ISyncTransferRepository avec les deux connexions
        // explicites (Service pour TOSRV, WebService pour MobReception/MobLog).
        var services = new ServiceCollection();
        services.AddLogging();
        // IConfiguration est requis par les Configure<IConfiguration> des options
        // (HfsqlOptions, ServiceConnectionOptions, etc.) lors de la résolution.
        // La section ServiceConnection doit être valide pour que le validateur
        // (ServiceConnectionOptionsValidator) accepte la résolution de la connexion
        // Service. Le mot de passe reste volontairement absent (optionnel).
        var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
            .AddInMemoryCollection(new Dictionary<string, string?>
            {
                // Connexion Service (base TOSRV) : mot de passe volontairement absent
                // (optionnel : null/vide/renseigné sont tous valides).
                [$"{ServiceConnectionOptions.SectionName}:Server"] = "localhost",
                [$"{ServiceConnectionOptions.SectionName}:Port"] = "49000",
                [$"{ServiceConnectionOptions.SectionName}:DatabaseName"] = "BATIK.01_BLS",
                [$"{ServiceConnectionOptions.SectionName}:Login"] = "service",
                // Connexion WebService/Business (base MobReception/MobLog) : la
                // résolution de IHfsqlConnection exige des options Hfsql valides.
                [$"{HfsqlOptions.SectionName}:Server"] = "localhost",
                [$"{HfsqlOptions.SectionName}:Port"] = "49000",
                [$"{HfsqlOptions.SectionName}:DatabaseName"] = "BATIK_TEST",
                [$"{HfsqlOptions.SectionName}:Login"] = "service"
            })
            .Build();
        services.AddSingleton<Microsoft.Extensions.Configuration.IConfiguration>(configuration);
        services.AddOmikaData();
        services.AddOmikaDataServiceConnection();

        using var provider = services.BuildServiceProvider();
        await using var scope = provider.CreateAsyncScope();

        var repo = scope.ServiceProvider.GetRequiredService<ISyncTransferRepository>();
        Assert.IsType<SyncTransferRepository>(repo);

        // Les deux connexions explicites sont résolvables dans le même scope.
        var service = scope.ServiceProvider.GetRequiredService<IServiceHfSqlConnection>();
        var web = scope.ServiceProvider.GetRequiredService<IWebServiceHfSqlConnection>();
        Assert.NotNull(service);
        Assert.NotNull(web);
    }

    [Fact]
    public void AddOmikaData_RegistersHfsqlConnectionAsScoped()
    {
        var services = new ServiceCollection();

        services.AddOmikaData();

        var descriptor = services.Single(d => d.ServiceType == typeof(IHfsqlConnection));
        Assert.Equal(ServiceLifetime.Scoped, descriptor.Lifetime);
    }

    [Fact]
    public void AddOmikaData_RegistersConnectionFactoryAsSingleton()
    {
        var services = new ServiceCollection();

        services.AddOmikaData();

        var descriptor = services.Single(d => d.ServiceType == typeof(IHfsqlConnectionFactory));
        Assert.Equal(ServiceLifetime.Singleton, descriptor.Lifetime);
        Assert.Equal(typeof(OdbcConnectionFactory), descriptor.ImplementationType);
    }

    [Fact]
    public void AddOmikaData_RegistersOptionsValidator()
    {
        var services = new ServiceCollection();

        services.AddOmikaData();

        var descriptor = services.Single(d => d.ServiceType == typeof(IValidateOptions<HfsqlOptions>));
        Assert.Equal(typeof(HfsqlOptionsValidator), descriptor.ImplementationType);
    }

    [Fact]
    public void AddOmikaData_RegistersHfsqlOptions()
    {
        var services = new ServiceCollection();

        services.AddOmikaData();

        var descriptor = services.Single(d => d.ServiceType == typeof(IConfigureOptions<HfsqlOptions>));
        Assert.NotNull(descriptor);
    }
}