Elecciones-2025/Elecciones-Web/src/Elecciones.Worker/Program.cs

using Elecciones.Database;
using Elecciones.Infrastructure.Services;
using Elecciones.Worker;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Net;
using Serilog;
using System.Net.Http;
using System.Net.Security;
using System.Security.Authentication;
using Polly;
using Polly.Extensions.Http;
using System.Threading.RateLimiting;

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateBootstrapLogger();

Log.Information("Iniciando Elecciones.Worker Host...");

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddSerilog(config => 
    config
        .ReadFrom.Configuration(builder.Configuration)
        .Enrich.FromLogContext()
        .WriteTo.Console()
        .WriteTo.File("logs/worker-.log", rollingInterval: RollingInterval.Day));

// --- Configuración de Servicios ---
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<EleccionesDbContext>(options =>
    options.UseSqlServer(connectionString));

builder.Services.AddHttpClient("ElectoralApiClient", client =>
{
    var baseUrl = builder.Configuration["ElectoralApi:BaseUrl"];
    if (!string.IsNullOrEmpty(baseUrl))
    {
        client.BaseAddress = new Uri(baseUrl);
    }

    // --- TIMEOUT MÁS LARGO ---
    // Aumentamos el tiempo de espera a 90 segundos.
    // Esto le dará a las peticiones lentas de la API tiempo suficiente para responder.
    client.Timeout = TimeSpan.FromSeconds(90);

    client.DefaultRequestHeaders.Clear();
    client.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36");
    client.DefaultRequestHeaders.Add("Accept", "*/*");
    client.DefaultRequestHeaders.Add("Accept-Encoding", "gzip, deflate, br");
    client.DefaultRequestHeaders.Add("Connection", "keep-alive");

})
.ConfigurePrimaryHttpMessageHandler(() =>
{
    var handler = new SocketsHttpHandler
    {
        // Habilita la descompresión automática de respuestas GZIP y Deflate.
        // Esto soluciona el error de JsonException ('0x1F').
        AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,

        SslOptions = new SslClientAuthenticationOptions
        {
            EnabledSslProtocols = SslProtocols.Tls13,
        }
    };

    if (!OperatingSystem.IsWindows())
    {
        handler.SslOptions.CipherSuitesPolicy = new CipherSuitesPolicy(new[]
        {
            TlsCipherSuite.TLS_AES_128_GCM_SHA256,
            TlsCipherSuite.TLS_AES_256_GCM_SHA384,
            TlsCipherSuite.TLS_CHACHA20_POLY1305_SHA256
        });
    }

    return handler;
})

.AddPolicyHandler(GetRetryPolicy());

// --- LIMITADOR DE VELOCIDAD BASADO EN TOKEN BUCKET ---
/*builder.Services.AddSingleton<RateLimiter>(sp => 
    new TokenBucketRateLimiter(new TokenBucketRateLimiterOptions
    {
        // El tamaño máximo del cubo (la ráfaga máxima que permitimos).
        TokenLimit = 50, 
        
        // Con qué frecuencia se añaden nuevas fichas al cubo.
        ReplenishmentPeriod = TimeSpan.FromSeconds(1), 
        
        // Cuántas fichas se añaden en cada período.
        TokensPerPeriod = 20, 
        
        // Cuántas peticiones pueden estar en cola esperando una ficha.
        QueueLimit = 1000, 
        
        // Cómo se comporta cuando la cola está llena.
        QueueProcessingOrder = QueueProcessingOrder.OldestFirst
    }));
*/
builder.Services.AddScoped<IElectoralApiService, ElectoralApiService>(); 

// Registramos el servicio de token como un Singleton para que sea compartido.
builder.Services.AddSingleton<SharedTokenService>();

// Registramos ambos workers. El framework se encargará de iniciarlos y detenerlos.
builder.Services.AddHostedService<CriticalDataWorker>();
builder.Services.AddHostedService<LowPriorityDataWorker>();
//builder.Services.AddHostedService<Worker>();

var host = builder.Build();

try
{
    host.Run();
}
catch (Exception ex)
{
    Log.Fatal(ex, "El Host de Elecciones.Worker terminó inesperadamente");
}
finally
{
    Log.CloseAndFlush();
}

static IAsyncPolicy<HttpResponseMessage> GetRetryPolicy()
{
    return HttpPolicyExtensions
        // Manejar peticiones que fallaron por errores de red O que devolvieron un error de servidor (como 504)
        .HandleTransientHttpError()
        // O que devolvieron un código 504 Gateway Timeout específicamente
        .OrResult(msg => msg.StatusCode == System.Net.HttpStatusCode.GatewayTimeout)
        // Esperar y reintentar. La espera se duplica en cada reintento.
        .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
            onRetry: (outcome, timespan, retryAttempt, context) =>
            {
                // Opcional: Loguear cada reintento. Necesitarías pasar ILogger aquí.
                // Log.Warning("Retrying due to {StatusCode}. Waited {seconds}s. Attempt {retryAttempt}/3", outcome.Result.StatusCode, timespan.TotalSeconds, retryAttempt);
            });
}