// 1. Creamos la aplicación web
var builder = WebApplication.CreateBuilder(args);

// 2. Agregamos servicios (como ingredientes de una receta)
builder.Services.AddEndpointsApiExplorer();  // Para documentación
builder.Services.AddSwaggerGen();             // Para probar nuestra API

var app = builder.Build();

// 3. Configuramos Swagger (interfaz para probar)
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

// 4. Lista en memoria para guardar tareas (por ahora)
var tareas = new List<Tarea>();

// 5. ENDPOINTS - Las URLs de nuestro servicio

// GET: Obtener todas las tareas
app.MapGet("/api/tareas", () =>
{
    return Results.Ok(tareas);
})
.WithName("ObtenerTareas")
.WithOpenApi();

// GET: Obtener una tarea por ID
app.MapGet("/api/tareas/{id}", (int id) =>
{
    var tarea = tareas.FirstOrDefault(t => t.Id == id);
    return tarea is null 
        ? Results.NotFound($"Tarea {id} no encontrada") 
        : Results.Ok(tarea);
})
.WithName("ObtenerTareaPorId")
.WithOpenApi();

// POST: Crear nueva tarea
app.MapPost("/api/tareas", (Tarea nuevaTarea) =>
{
    nuevaTarea.Id = tareas.Count + 1;
    nuevaTarea.FechaCreacion = DateTime.Now;
    tareas.Add(nuevaTarea);
    
    return Results.Created($"/api/tareas/{nuevaTarea.Id}", nuevaTarea);
})
.WithName("CrearTarea")
.WithOpenApi();

// PUT: Actualizar tarea
app.MapPut("/api/tareas/{id}", (int id, Tarea tareaActualizada) =>
{
    var tarea = tareas.FirstOrDefault(t => t.Id == id);
    if (tarea is null)
        return Results.NotFound();
    
    tarea.Titulo = tareaActualizada.Titulo;
    tarea.Completada = tareaActualizada.Completada;
    
    return Results.Ok(tarea);
})
.WithName("ActualizarTarea")
.WithOpenApi();

// DELETE: Eliminar tarea
app.MapDelete("/api/tareas/{id}", (int id) =>
{
    var tarea = tareas.FirstOrDefault(t => t.Id == id);
    if (tarea is null)
        return Results.NotFound();
    
    tareas.Remove(tarea);
    return Results.Ok($"Tarea {id} eliminada");
})
.WithName("EliminarTarea")
.WithOpenApi();

app.Run();

// 6. Nuestra clase modelo (¿qué es una tarea?)
public class Tarea
{
    public int Id { get; set; }
    public string Titulo { get; set; } = "";
    public bool Completada { get; set; }
    public DateTime FechaCreacion { get; set; }
}

// Servicio A llama a Servicio B
public class ProductoService
{
    private readonly HttpClient _httpClient;
    
    public async Task<decimal> ObtenerPrecioConDescuento(int productoId, int usuarioId)
    {
        // 1. Obtener información del producto (local)
        var producto = await _dbContext.Productos.FindAsync(productoId);
        
        // 2. Llamar al servicio de usuarios para obtener descuento
        var response = await _httpClient.GetAsync(
            $"http://usuario-service/api/usuarios/{usuarioId}/descuento"
        );
        
        var descuento = await response.Content.ReadFromJsonAsync<decimal>();
        
        // 3. Calcular precio final
        return producto.Precio * (1 - descuento);
    }
}

// Flujo de creación de pedido con SAGA
public class CrearPedidoSaga
{
    // Paso 1: Reservar inventario
    public async Task<bool> ReservarInventario(Pedido pedido)
    {
        try
        {
            await _inventarioService.ReservarProductos(pedido.Productos);
            return true;
        }
        catch
        {
            return false; // Si falla, se detiene aquí
        }
    }
    
    // Paso 2: Procesar pago
    public async Task<bool> ProcesarPago(Pedido pedido)
    {
        try
        {
            await _pagoService.Cobrar(pedido.Total, pedido.ClienteId);
            return true;
        }
        catch
        {
            // Si falla, compensamos: liberamos el inventario
            await _inventarioService.LiberarProductos(pedido.Productos);
            return false;
        }
    }
    
    // Paso 3: Crear pedido
    public async Task<bool> CrearPedido(Pedido pedido)
    {
        try
        {
            await _pedidoService.Crear(pedido);
            return true;
        }
        catch
        {
            // Si falla, compensamos todo
            await _pagoService.Reembolsar(pedido.Total, pedido.ClienteId);
            await _inventarioService.LiberarProductos(pedido.Productos);
            return false;
        }
    }
}

// 1. Instalar paquete: dotnet add package Polly

// 2. Configurar políticas de resiliencia
var retryPolicy = Policy
    .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
    .WaitAndRetryAsync(
        3,  // Reintentar 3 veces
        retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), // 2, 4, 8 segundos
        onRetry: (outcome, timespan, retryCount, context) =>
        {
            Console.WriteLine($"Reintento {retryCount} después de {timespan} segundos");
        });

// 3. Circuit Breaker: después de 3 fallas, espera 30 segundos
var circuitBreakerPolicy = Policy
    .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
    .CircuitBreakerAsync(
        3,  // Después de 3 fallas consecutivas
        TimeSpan.FromSeconds(30), // Espera 30 segundos antes de intentar de nuevo
        onBreak: (result, timespan) =>
        {
            Console.WriteLine($"Circuito abierto por {timespan}");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuito cerrado, funcionando normal");
        });

// 4. Combinar políticas
var resilientPolicy = Policy.WrapAsync(retryPolicy, circuitBreakerPolicy);

// 5. Usar en tu código
public async Task<Producto> ObtenerProducto(int id)
{
    return await resilientPolicy.ExecuteAsync(async () =>
    {
        var response = await _httpClient.GetAsync($"/api/productos/{id}");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<Producto>();
    });
}

# 1. Imagen base - Como elegir el sistema operativo
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

# 2. Compilar la aplicación
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MiServicio.csproj", "."]
RUN dotnet restore "MiServicio.csproj"
COPY . .
RUN dotnet build "MiServicio.csproj" -c Release -o /app/build

# 3. Publicar la aplicación
FROM build AS publish
RUN dotnet publish "MiServicio.csproj" -c Release -o /app/publish

# 4. Imagen final - Solo lo necesario para ejecutar
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MiServicio.dll"]

version: '3.8'

services:
  # Servicio de API
  api:
    build: ./ServicioAPI
    ports:
      - "8080:80"
    environment:
      - ConnectionStrings__DefaultConnection=Server=db;Database=MiDB;
    depends_on:
      - db
  
  # Base de datos
  db:
    image: postgres:15
    environment:
      - POSTGRES_PASSWORD=MiPassword123
      - POSTGRES_DB=MiDB
    volumes:
      - db-data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

volumes:
  db-data:

using Xunit;

public class CalculadoraTests
{
    [Fact]
    public void Sumar_DosNumeros_RetornaResultadoCorrecto()
    {
        // Arrange (Preparar)
        var calculadora = new Calculadora();
        
        // Act (Actuar)
        var resultado = calculadora.Sumar(5, 3);
        
        // Assert (Verificar)
        Assert.Equal(8, resultado);
    }
    
    [Theory]
    [InlineData(1, 1, 2)]
    [InlineData(-1, 1, 0)]
    [InlineData(0, 0, 0)]
    public void Sumar_VariosEscenarios_RetornaResultadoCorrecto(int a, int b, int esperado)
    {
        var calculadora = new Calculadora();
        var resultado = calculadora.Sumar(a, b);
        Assert.Equal(esperado, resultado);
    }
}

public class ProductosApiTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;
    
    public ProductosApiTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory;
    }
    
    [Fact]
    public async Task ObtenerProductos_RetornaListaDeProductos()
    {
        // Arrange
        var client = _factory.CreateClient();
        
        // Act
        var response = await client.GetAsync("/api/productos");
        
        // Assert
        response.EnsureSuccessStatusCode();
        var productos = await response.Content.ReadFromJsonAsync<List<Producto>>();
        Assert.NotNull(productos);
        Assert.NotEmpty(productos);
    }
}

// 1. Instalar: dotnet add package Serilog.AspNetCore

// 2. Configurar en Program.cs
using Serilog;

// Configurar Serilog
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Information()
    .WriteTo.Console()  // Logs en consola
    .WriteTo.File("logs/miapp-.txt", rollingInterval: RollingInterval.Day)  // Logs en archivo
    .CreateLogger();

var builder = WebApplication.CreateBuilder(args);
builder.Host.UseSerilog();  // Usar Serilog

// 3. Usar en tu código
app.MapPost("/api/pedidos", (Pedido pedido, ILogger<Program> logger) =>
{
    logger.LogInformation("Creando pedido para cliente {ClienteId}", pedido.ClienteId);
    
    try
    {
        // Procesar pedido
        var resultado = ProcesarPedido(pedido);
        
        logger.LogInformation("Pedido {PedidoId} creado exitosamente", resultado.Id);
        return Results.Ok(resultado);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Error creando pedido para cliente {ClienteId}", pedido.ClienteId);
        return Results.Problem("Error procesando pedido");
    }
});

// Facade que decide si usar monolito o microservicio
public interface IUserService
{
    Task<User> GetUserAsync(int id);
}

public class UserServiceFacade : IUserService
{
    private readonly IConfiguration _config;
    private readonly HttpClient _httpClient;
    private readonly MonolithUserRepository _monolithRepo;
    
    public async Task<User> GetUserAsync(int id)
    {
        // Feature flag para migración gradual
        var useMicroservice = _config.GetValue<bool>("Features:UseUserMicroservice");
        
        if (useMicroservice)
        {
            // Llamar al nuevo microservicio
            var response = await _httpClient.GetAsync($"/api/users/{id}");
            return await response.Content.ReadFromJsonAsync<User>();
        }
        else
        {
            // Usar el código del monolito
            return await _monolithRepo.GetUserAsync(id);
        }
    }
}