using System;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Diagnostics.HealthChecks;
using Microsoft.Extensions.Logging;
using StellaOps.Scheduler.Queue.Nats;
using StellaOps.Scheduler.Queue.Redis;

namespace StellaOps.Scheduler.Queue;

public static class SchedulerQueueServiceCollectionExtensions
{
    public static IServiceCollection AddSchedulerQueues(
        this IServiceCollection services,
        IConfiguration configuration,
        string sectionName = "scheduler:queue")
    {
        ArgumentNullException.ThrowIfNull(services);
        ArgumentNullException.ThrowIfNull(configuration);

        var options = new SchedulerQueueOptions();
        configuration.GetSection(sectionName).Bind(options);

        services.TryAddSingleton(TimeProvider.System);
        services.AddSingleton(options);

        services.AddSingleton<ISchedulerPlannerQueue>(sp =>
        {
            var loggerFactory = sp.GetRequiredService<ILoggerFactory>();
            var timeProvider = sp.GetService<TimeProvider>() ?? TimeProvider.System;

            return options.Kind switch
            {
                SchedulerQueueTransportKind.Redis => new RedisSchedulerPlannerQueue(
                    options,
                    options.Redis,
                    loggerFactory.CreateLogger<RedisSchedulerPlannerQueue>(),
                    timeProvider),
                SchedulerQueueTransportKind.Nats => new NatsSchedulerPlannerQueue(
                    options,
                    options.Nats,
                    loggerFactory.CreateLogger<NatsSchedulerPlannerQueue>(),
                    timeProvider),
                _ => throw new InvalidOperationException($"Unsupported scheduler queue transport '{options.Kind}'.")
            };
        });

        services.AddSingleton<ISchedulerRunnerQueue>(sp =>
        {
            var loggerFactory = sp.GetRequiredService<ILoggerFactory>();
            var timeProvider = sp.GetService<TimeProvider>() ?? TimeProvider.System;

            return options.Kind switch
            {
                SchedulerQueueTransportKind.Redis => new RedisSchedulerRunnerQueue(
                    options,
                    options.Redis,
                    loggerFactory.CreateLogger<RedisSchedulerRunnerQueue>(),
                    timeProvider),
                SchedulerQueueTransportKind.Nats => new NatsSchedulerRunnerQueue(
                    options,
                    options.Nats,
                    loggerFactory.CreateLogger<NatsSchedulerRunnerQueue>(),
                    timeProvider),
                _ => throw new InvalidOperationException($"Unsupported scheduler queue transport '{options.Kind}'.")
            };
        });

        services.AddSingleton<SchedulerQueueHealthCheck>();

        return services;
    }

    public static IHealthChecksBuilder AddSchedulerQueueHealthCheck(
        this IHealthChecksBuilder builder)
    {
        ArgumentNullException.ThrowIfNull(builder);

        builder.Services.TryAddSingleton<SchedulerQueueHealthCheck>();
        builder.AddCheck<SchedulerQueueHealthCheck>(
            name: "scheduler-queue",
            failureStatus: HealthStatus.Unhealthy,
            tags: new[] { "scheduler", "queue" });

        return builder;
    }
}