using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using StellaOps.Cryptography;
using StellaOps.Cryptography.PluginLoader;

namespace StellaOps.Cryptography.DependencyInjection;

/// <summary>
/// DI extension methods for configuration-driven crypto plugin loading.
/// </summary>
public static class CryptoPluginServiceCollectionExtensions
{
    /// <summary>
    /// Registers crypto providers using configuration-driven plugin loading.
    /// Replaces hardcoded provider registrations with dynamic plugin loader.
    /// </summary>
    /// <param name="services">Service collection.</param>
    /// <param name="configuration">Application configuration.</param>
    /// <param name="configurePlugins">Optional plugin configuration action.</param>
    /// <returns>The service collection.</returns>
    public static IServiceCollection AddStellaOpsCryptoWithPlugins(
        this IServiceCollection services,
        IConfiguration configuration,
        Action<CryptoPluginConfiguration>? configurePlugins = null)
    {
        ArgumentNullException.ThrowIfNull(services);
        ArgumentNullException.ThrowIfNull(configuration);

        // Bind plugin configuration from appsettings
        services.Configure<CryptoPluginConfiguration>(options =>
        {
            configuration.GetSection("StellaOps:Crypto:Plugins").Bind(options);
            configurePlugins?.Invoke(options);
        });

        // Register compliance options (reuse existing code)
        services.TryAddSingleton<IOptionsMonitor<CryptoComplianceOptions>>(sp =>
        {
            var config = sp.GetService<IConfiguration>();
            var options = new CryptoComplianceOptions();
            config?.GetSection(CryptoComplianceOptions.SectionKey).Bind(options);
            options.ApplyEnvironmentOverrides();
            return new StaticComplianceOptionsMonitor(options);
        });

        services.TryAddSingleton<ICryptoComplianceService, CryptoComplianceService>();
        services.TryAddSingleton<ICryptoHash, DefaultCryptoHash>();
        services.TryAddSingleton<ICryptoHmac, DefaultCryptoHmac>();

        // Register plugin loader and load providers dynamically
        services.TryAddSingleton<CryptoPluginLoader>(sp =>
        {
            var pluginConfig = sp.GetRequiredService<IOptions<CryptoPluginConfiguration>>().Value;
            var logger = sp.GetService<ILogger<CryptoPluginLoader>>();
            return new CryptoPluginLoader(pluginConfig, logger);
        });

        // Load all configured crypto providers
        services.TryAddSingleton(sp =>
        {
            var loader = sp.GetRequiredService<CryptoPluginLoader>();
            return loader.LoadProviders();
        });

        // Register each loaded provider as ICryptoProvider
        services.TryAddSingleton<IEnumerable<ICryptoProvider>>(sp =>
        {
            return sp.GetRequiredService<IReadOnlyList<ICryptoProvider>>();
        });

        // Register crypto provider registry with loaded providers
        services.TryAddSingleton<ICryptoProviderRegistry>(sp =>
        {
            var providers = sp.GetRequiredService<IReadOnlyList<ICryptoProvider>>();
            var options = sp.GetService<IOptionsMonitor<CryptoProviderRegistryOptions>>();
            IEnumerable<string>? preferred = options?.CurrentValue?.ResolvePreferredProviders();
            return new CryptoProviderRegistry(providers, preferred);
        });

        return services;
    }

    /// <summary>
    /// Registers crypto providers with plugin loading and compliance profile configuration.
    /// </summary>
    /// <param name="services">Service collection.</param>
    /// <param name="configuration">Application configuration.</param>
    /// <param name="configurePlugins">Optional plugin configuration.</param>
    /// <param name="configureCompliance">Optional compliance configuration.</param>
    /// <returns>The service collection.</returns>
    public static IServiceCollection AddStellaOpsCryptoWithPluginsAndCompliance(
        this IServiceCollection services,
        IConfiguration configuration,
        Action<CryptoPluginConfiguration>? configurePlugins = null,
        Action<CryptoComplianceOptions>? configureCompliance = null)
    {
        ArgumentNullException.ThrowIfNull(services);
        ArgumentNullException.ThrowIfNull(configuration);

        // Bind compliance options from configuration
        services.Configure<CryptoComplianceOptions>(options =>
        {
            configuration.GetSection(CryptoComplianceOptions.SectionKey).Bind(options);
            configureCompliance?.Invoke(options);
            options.ApplyEnvironmentOverrides();
        });

        // Register base crypto services with plugin loading
        services.AddStellaOpsCryptoWithPlugins(configuration, configurePlugins);

        return services;
    }

    /// <summary>
    /// Helper class for static options monitoring.
    /// </summary>
    private sealed class StaticComplianceOptionsMonitor : IOptionsMonitor<CryptoComplianceOptions>
    {
        private readonly CryptoComplianceOptions _options;

        public StaticComplianceOptionsMonitor(CryptoComplianceOptions options)
            => _options = options;

        public CryptoComplianceOptions CurrentValue => _options;

        public CryptoComplianceOptions Get(string? name) => _options;

        public IDisposable OnChange(Action<CryptoComplianceOptions, string> listener)
            => NullDisposable.Instance;

        private sealed class NullDisposable : IDisposable
        {
            public static readonly NullDisposable Instance = new();
            public void Dispose() { }
        }
    }
}