using Coravel;
using Coravel.Queuing.Interfaces;
using Foxnouns.Backend.Database;
using Foxnouns.Backend.Jobs;
using Foxnouns.Backend.Middleware;
using Foxnouns.Backend.Services;
using Microsoft.EntityFrameworkCore;
using Minio;
using NodaTime;
using Prometheus;
using Serilog;
using Serilog.Events;
using IClock = NodaTime.IClock;

namespace Foxnouns.Backend.Extensions;

public static class WebApplicationExtensions
{
    /// <summary>
    /// Adds Serilog to this service collection. This method also initializes Serilog, so it should be called as early as possible, before any log calls.
    /// </summary>
    public static WebApplicationBuilder AddSerilog(this WebApplicationBuilder builder)
    {
        var config = builder.Configuration.Get<Config>() ?? new();

        var logCfg = new LoggerConfiguration()
            .Enrich.FromLogContext()
            .MinimumLevel.Is(config.Logging.LogEventLevel)
            // ASP.NET's built in request logs are extremely verbose, so we use Serilog's instead.
            // Serilog doesn't disable the built-in logs, so we do it here.
            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
            .MinimumLevel.Override("Microsoft.EntityFrameworkCore.Database.Command",
                config.Logging.LogQueries ? LogEventLevel.Information : LogEventLevel.Fatal)
            .MinimumLevel.Override("Microsoft.AspNetCore.Hosting", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.AspNetCore.Mvc", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.AspNetCore.Routing", LogEventLevel.Warning)
            .WriteTo.Console();

        if (config.Logging.SeqLogUrl != null)
        {
            logCfg.WriteTo.Seq(config.Logging.SeqLogUrl, restrictedToMinimumLevel: LogEventLevel.Verbose);
        }

        // AddSerilog doesn't seem to add an ILogger to the service collection, so add that manually.
        builder.Services.AddSerilog().AddSingleton(Log.Logger = logCfg.CreateLogger());

        return builder;
    }

    public static Config AddConfiguration(this WebApplicationBuilder builder)
    {
        builder.Configuration.Sources.Clear();
        builder.Configuration.AddConfiguration();

        var config = builder.Configuration.Get<Config>() ?? new();
        builder.Services.AddSingleton(config);
        return config;
    }

    public static IConfigurationBuilder AddConfiguration(this IConfigurationBuilder builder)
    {
        var file = Environment.GetEnvironmentVariable("FOXNOUNS_CONFIG_FILE") ?? "config.ini";

        return builder
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appSettings.json", true)
            .AddIniFile(file, optional: false, reloadOnChange: true)
            .AddEnvironmentVariables();
    }

    /// <summary>
    /// Adds required services to the WebApplicationBuilder.
    /// This should only add services that are not ASP.NET-related (i.e. no middleware).
    /// </summary>
    public static IServiceCollection AddServices(this WebApplicationBuilder builder, Config config)
    {
        builder.Host.ConfigureServices((ctx, services) =>
        {
            services
                .AddQueue()
                .AddSmtpMailer(ctx.Configuration)
                .AddDbContext<DatabaseContext>()
                .AddMetricServer(o => o.Port = config.Logging.MetricsPort)
                .AddMinio(c =>
                    c.WithEndpoint(config.Storage.Endpoint)
                        .WithCredentials(config.Storage.AccessKey, config.Storage.SecretKey)
                        .Build())
                .AddSingleton<MetricsCollectionService>()
                .AddSingleton<IClock>(SystemClock.Instance)
                .AddSnowflakeGenerator()
                .AddSingleton<MailService>()
                .AddScoped<UserRendererService>()
                .AddScoped<MemberRendererService>()
                .AddScoped<AuthService>()
                .AddScoped<KeyCacheService>()
                .AddScoped<RemoteAuthService>()
                .AddScoped<ObjectStorageService>()
                // Background services
                .AddHostedService<PeriodicTasksService>()
                // Transient jobs
                .AddTransient<MemberAvatarUpdateInvocable>()
                .AddTransient<UserAvatarUpdateInvocable>()
                .AddTransient<CreateFlagInvocable>();

            if (!config.Logging.EnableMetrics)
                services.AddHostedService<BackgroundMetricsCollectionService>();
        });

        return builder.Services;
    }

    public static IServiceCollection AddCustomMiddleware(this IServiceCollection services) => services
        .AddScoped<ErrorHandlerMiddleware>()
        .AddScoped<AuthenticationMiddleware>()
        .AddScoped<AuthorizationMiddleware>();

    public static IApplicationBuilder UseCustomMiddleware(this IApplicationBuilder app) => app
        .UseMiddleware<ErrorHandlerMiddleware>()
        .UseMiddleware<AuthenticationMiddleware>()
        .UseMiddleware<AuthorizationMiddleware>();

    public static async Task Initialize(this WebApplication app, string[] args)
    {
        // Read version information from .version in the repository root
        await BuildInfo.ReadBuildInfo();

        app.Services.ConfigureQueue().LogQueuedTaskProgress(app.Services.GetRequiredService<ILogger<IQueue>>());

        await using var scope = app.Services.CreateAsyncScope();
        var logger = scope.ServiceProvider.GetRequiredService<ILogger>().ForContext<WebApplication>();
        var db = scope.ServiceProvider.GetRequiredService<DatabaseContext>();

        logger.Information("Starting Foxnouns.NET {Version} ({Hash})", BuildInfo.Version, BuildInfo.Hash);

        var pendingMigrations = (await db.Database.GetPendingMigrationsAsync()).ToList();
        if (args.Contains("--migrate") || args.Contains("--migrate-and-start"))
        {
            if (pendingMigrations.Count == 0)
            {
                logger.Information("Migrations requested but no migrations are required");
            }
            else
            {
                logger.Information("Migrating database to the latest version");
                await db.Database.MigrateAsync();
                logger.Information("Successfully migrated database");
            }

            if (!args.Contains("--migrate-and-start")) Environment.Exit(0);
        }
        else if (pendingMigrations.Count > 0)
        {
            logger.Fatal(
                "There are {Count} pending migrations, run server with --migrate or --migrate-and-start to run migrations.",
                pendingMigrations.Count);
            Environment.Exit(1);
        }

        logger.Information("Initializing frontend OAuth application");
        _ = await db.GetFrontendApplicationAsync();
    }
}