GestionIntegralWeb/Backend/GestionIntegral.Api/Program.cs

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;
using GestionIntegral.Api.Data;
using GestionIntegral.Api.Services.Contables;
using GestionIntegral.Api.Services.Distribucion;
using GestionIntegral.Api.Data.Repositories.Contables;
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Data.Repositories.Impresion;
using GestionIntegral.Api.Services.Impresion;
using GestionIntegral.Api.Services.Usuarios;
using GestionIntegral.Api.Data.Repositories.Usuarios;
using Microsoft.OpenApi.Models;

var builder = WebApplication.CreateBuilder(args);

// --- Registros de Servicios ---
builder.Services.AddSingleton<DbConnectionFactory>();
builder.Services.AddScoped<PasswordHasherService>();
builder.Services.AddScoped<IAuthRepository, AuthRepository>();
builder.Services.AddScoped<IAuthService, AuthService>();
builder.Services.AddScoped<ITipoPagoRepository, TipoPagoRepository>();
builder.Services.AddScoped<ITipoPagoService, TipoPagoService>();
builder.Services.AddScoped<IZonaRepository, ZonaRepository>();
builder.Services.AddScoped<IZonaService, ZonaService>();
builder.Services.AddScoped<IEmpresaRepository, EmpresaRepository>();
builder.Services.AddScoped<IEmpresaService, EmpresaService>();
builder.Services.AddScoped<ISaldoRepository, SaldoRepository>();
builder.Services.AddScoped<IPlantaRepository, PlantaRepository>();
builder.Services.AddScoped<IPlantaService, PlantaService>();
builder.Services.AddScoped<ITipoBobinaRepository, TipoBobinaRepository>();
builder.Services.AddScoped<ITipoBobinaService, TipoBobinaService>();
builder.Services.AddScoped<IEstadoBobinaRepository, EstadoBobinaRepository>();
builder.Services.AddScoped<IEstadoBobinaService, EstadoBobinaService>();
builder.Services.AddScoped<IOtroDestinoRepository, OtroDestinoRepository>();
builder.Services.AddScoped<IOtroDestinoService, OtroDestinoService>();
builder.Services.AddScoped<IPerfilRepository, PerfilRepository>();
builder.Services.AddScoped<IPerfilService, PerfilService>();
builder.Services.AddScoped<IPermisoRepository, PermisoRepository>();
builder.Services.AddScoped<IPermisoService, PermisoService>();
builder.Services.AddScoped<IUsuarioRepository, UsuarioRepository>();
builder.Services.AddScoped<IUsuarioService, UsuarioService>();
builder.Services.AddScoped<ICanillaRepository, CanillaRepository>();
builder.Services.AddScoped<ICanillaService, CanillaService>();
builder.Services.AddScoped<IDistribuidorRepository, DistribuidorRepository>();
builder.Services.AddScoped<IDistribuidorService, DistribuidorService>();
builder.Services.AddScoped<IPublicacionRepository, PublicacionRepository>();
builder.Services.AddScoped<IPublicacionService, PublicacionService>();
builder.Services.AddScoped<IRecargoZonaRepository, RecargoZonaRepository>();
builder.Services.AddScoped<IRecargoZonaService, RecargoZonaService>();
builder.Services.AddScoped<IPorcPagoRepository, PorcPagoRepository>();
builder.Services.AddScoped<IPorcPagoService, PorcPagoService>();
builder.Services.AddScoped<IPorcMonCanillaRepository, PorcMonCanillaRepository>();
builder.Services.AddScoped<IPorcMonCanillaService, PorcMonCanillaService>();
builder.Services.AddScoped<IPubliSeccionRepository, PubliSeccionRepository>();
builder.Services.AddScoped<IPubliSeccionService, PubliSeccionService>();
builder.Services.AddScoped<IPrecioRepository, PrecioRepository>();
builder.Services.AddScoped<IPrecioService, PrecioService>();
builder.Services.AddScoped<IStockBobinaRepository, StockBobinaRepository>();
builder.Services.AddScoped<IStockBobinaService, StockBobinaService>();
builder.Services.AddScoped<IRegTiradaRepository, RegTiradaRepository>();
builder.Services.AddScoped<IRegPublicacionSeccionRepository, RegPublicacionSeccionRepository>();
builder.Services.AddScoped<ITiradaService, TiradaService>();
builder.Services.AddScoped<ISalidaOtroDestinoRepository, SalidaOtroDestinoRepository>();
builder.Services.AddScoped<ISalidaOtroDestinoService, SalidaOtroDestinoService>();
builder.Services.AddScoped<IEntradaSalidaDistRepository, EntradaSalidaDistRepository>();
builder.Services.AddScoped<IEntradaSalidaDistService, EntradaSalidaDistService>();

// --- Configuración de Autenticación JWT ---
var jwtSettings = builder.Configuration.GetSection("Jwt");
var jwtKey = jwtSettings["Key"] ?? throw new ArgumentNullException("Jwt:Key", "JWT Key not configured in appsettings");
var keyBytes = Encoding.ASCII.GetBytes(jwtKey);

builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.RequireHttpsMetadata = builder.Environment.IsProduction();
    options.SaveToken = true;
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuerSigningKey = true,
        IssuerSigningKey = new SymmetricSecurityKey(keyBytes),
        ValidateIssuer = true,
        ValidIssuer = jwtSettings["Issuer"],
        ValidateAudience = true,
        ValidAudience = jwtSettings["Audience"],
        ValidateLifetime = true,
        ClockSkew = TimeSpan.Zero
    };
});

// --- Configuración de Autorización ---
builder.Services.AddAuthorization();

// --- Configuración de CORS --- //
var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";
builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy  =>
                      {
                          policy.WithOrigins("http://localhost:5173") // URL Frontend React
                                .AllowAnyHeader()
                                .AllowAnyMethod();
                          // Para pruebas más permisivas (NO USAR EN PRODUCCIÓN):
                          // policy.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod();
                      });
});
// --- Fin CORS ---

// --- Servicios del Contenedor ---
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();

// --- Configuración Avanzada de Swagger/OpenAPI ---
builder.Services.AddSwaggerGen(options =>
{
    // Definición general del documento Swagger
    options.SwaggerDoc("v1", new OpenApiInfo
    {
        Version = "v1",
        Title = "GestionIntegral API",
        Description = "API para el sistema de Gestión Integral (Migración VB.NET)",
        // Puedes añadir TermsOfService, Contact, License si lo deseas
    });

    // (Opcional) Incluir comentarios XML si los usas en tus controladores/DTOs
    // var xmlFilename = $"{System.Reflection.Assembly.GetExecutingAssembly().GetName().Name}.xml";
    // options.IncludeXmlComments(System.IO.Path.Combine(AppContext.BaseDirectory, xmlFilename));

    // Definición de Seguridad para JWT en Swagger UI
    // Esto añade el botón "Authorize" en la UI de Swagger para poder pegar el token Bearer
    options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        In = ParameterLocation.Header,
        Description = "Por favor, introduce 'Bearer' seguido de un espacio y luego tu token JWT.",
        Name = "Authorization",
        Type = SecuritySchemeType.ApiKey, // Usar ApiKey para el formato Bearer simple
        Scheme = "Bearer" // Esquema a usar
    });

    options.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference
                {
                    Type = ReferenceType.SecurityScheme,
                    Id = "Bearer" // Debe coincidir con el Id definido en AddSecurityDefinition
                },
                Scheme = "oauth2", // Aunque el scheme sea ApiKey, a veces se usa oauth2 aquí para la UI
                Name = "Bearer",
                In = ParameterLocation.Header,
            },
            new List<string>() // Lista de scopes (vacía si no usas scopes OAuth2 complejos)
        }
    });
});
// --- Fin Configuración Swagger ---

var app = builder.Build();

// --- Configuración del Pipeline HTTP ---
if (app.Environment.IsDevelopment())
{
    app.UseSwagger(); // Habilita el middleware para servir el JSON de Swagger
    app.UseSwaggerUI(options => // Habilita el middleware para servir la UI de Swagger
    {
        options.SwaggerEndpoint("/swagger/v1/swagger.json", "GestionIntegral API v1");
        // options.RoutePrefix = string.Empty; // Para servir la UI de Swagger en la raíz (ej: http://localhost:5183/)
                                             // Comenta esto si prefieres /swagger (ej: http://localhost:5183/swagger/)
    });
}

// ¡¡¡NO USAR UseHttpsRedirection si tu API corre en HTTP!!!
// Comenta o elimina la siguiente línea si SÓLO usas http://localhost:5183
// app.UseHttpsRedirection();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthentication(); // Debe ir ANTES de UseAuthorization
app.UseAuthorization();

app.MapControllers();

app.Run();