Program.cs

using System.Text;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Npgsql.EntityFrameworkCore.PostgreSQL;
using Scalar.AspNetCore;
using Serilog;
using WebApplication1.Data;
using WebApplication1.Domains;
using WebApplication1.Infrastructure.Background;
using WebApplication1.Infrastructure.Mapping;
using WebApplication1.Infrastructure.Middleware;
using WebApplication1.Services.Implementations;
using WebApplication1.Services.Interfaces;

var builder = WebApplication.CreateBuilder(args);

// Configure Serilog - Only log errors
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Error()
    .WriteTo.Console()
    .WriteTo.File("logs/log-.txt", rollingInterval: RollingInterval.Day)
    .CreateLogger();

builder.Host.UseSerilog();

// Add services to the container
builder.Services.AddControllers();

// Database configuration (switchable via appsettings.json "Database:Provider")
var dbProvider = builder.Configuration["Database:Provider"] ?? "Sqlite";

builder.Services.AddDbContext<AppDbContext>(options =>
{
    if (dbProvider == "Supabase")
    {
        AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
        options.UseNpgsql(
            builder.Configuration.GetConnectionString("SupabaseConnection"),
            npgsqlOptions => npgsqlOptions.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery)
        );
    }
    else
    {
        options.UseSqlite(
            builder.Configuration.GetConnectionString("DefaultConnection"),
            sqliteOptions => sqliteOptions.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery)
        );
    }
    options.EnableSensitiveDataLogging(builder.Environment.IsDevelopment());
});

// Built-in OpenAPI support
builder.Services.AddOpenApi();

// AutoMapper configuration
builder.Services.AddAutoMapper(typeof(MappingProfile));

// JWT Authentication
var jwtKey = builder.Configuration["Jwt:Key"];
var jwtIssuer = builder.Configuration["Jwt:Issuer"];
var jwtAudience = builder.Configuration["Jwt:Audience"];

builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    })
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = jwtIssuer,
            ValidAudience = jwtAudience,
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtKey!))
        };
    });

builder.Services.AddAuthorization();

// Dependency Injection
builder.Services.AddSingleton<IEncryptionService, EncryptionService>();
builder.Services.AddScoped<PasswordHasher<User>>();
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddScoped<IEmailService, EmailService>();
builder.Services.AddScoped<IMemoryService, MemoryService>();
builder.Services.AddScoped<ILetterService, LetterService>();
builder.Services.AddScoped<IQuestionService, QuestionService>();

// HttpClient for Gemini (90 second timeout for model inference)
builder.Services.AddHttpClient<IAIQuestionGenerator, GeminiQuestionGenerator>()
    .ConfigureHttpClient(client => client.Timeout = TimeSpan.FromSeconds(90));

// Question generation queue (singleton to persist across requests)
builder.Services.AddSingleton<IQuestionGenerationQueue, QuestionGenerationQueue>();

// Background service for question generation
builder.Services.AddHostedService<QuestionGenerationBackgroundService>();

var app = builder.Build();

// Apply migrations automatically in development (SQLite only - Supabase uses manual schema)
if (app.Environment.IsDevelopment() && dbProvider == "Sqlite")
{
    using (var scope = app.Services.CreateScope())
    {
        var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        dbContext.Database.Migrate();
    }
}

// Global exception middleware
app.UseMiddleware<GlobalExceptionMiddleware>();

// Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
    app.MapScalarApiReference(options =>
    {
        options.Title = "WebApplication1 API";
    });
}

app.UseHttpsRedirection();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Run();