Suite de Tests NutriTrack API

using FluentAssertions;
using NSubstitute;
using NutriTrack.Domain.Plans;
using NutriTrack.Application.Services;

namespace NutriTrack.UnitTests.Services;

public sealed class PlanServiceTests
{
    // ── Dependencias mockeadas ────────────────────────────────────
    private readonly INutritionPlanRepository _repo
        = Substitute.For<INutritionPlanRepository>();
    private readonly ILogger<PlanService> _logger
        = Substitute.For<ILogger<PlanService>>();
    private readonly PlanService _sut;

    public PlanServiceTests()
        => _sut = new PlanService(_repo, _logger);

    // ── CreatePlanAsync ───────────────────────────────────────────
    [Fact]
    public async Task CreatePlanAsync_ReturnsCreatedPlan_WhenRequestIsValid()
    {
        // Arrange
        var request = new CreatePlanRequest
        {
            PatientId  = "pat-001",
            DietitianId = "diet-007",
            Calories   = 1800,
            Macros     = new(180, 60, 200) // g: carbs, fat, protein
        };

        // Act
        var result = await _sut.CreatePlanAsync(request, CancellationToken.None);

        // Assert
        result.Should().NotBeNull();
        result.PatientId.Should().Be("pat-001");
        result.Status.Should().Be(PlanStatus.Active);
    }

    [Fact]
    public async Task CreatePlanAsync_PersistsPlan_WhenRequestIsValid()
    {
        var request = PlanRequestFaker.Valid();

        await _sut.CreatePlanAsync(request, CancellationToken.None);

        // Verifica que el repositorio fue llamado exactamente 1 vez
        await _repo.Received(1).AddAsync(
            Arg.Is<NutritionPlan>(p => p.PatientId == request.PatientId),
            Arg.Any<CancellationToken>());
    }

    [Fact]
    public async Task CreatePlanAsync_ThrowsDomainException_WhenCaloriesAreZero()
    {
        var request = PlanRequestFaker.Valid() with { Calories = 0 };

        var act = () => _sut.CreatePlanAsync(request, CancellationToken.None);

        await act.Should().ThrowAsync<DomainException>()
            .WithMessage("*calories*must be greater than zero*");
    }

    // ── ArchivePlanAsync ──────────────────────────────────────────
    [Fact]
    public async Task ArchivePlanAsync_SetsStatusArchived_WhenPlanExists()
    {
        var planId = Guid.NewGuid();
        var plan   = new NutritionPlanBuilder().WithId(planId).Build();
        _repo.FindByIdAsync(planId, Arg.Any<CancellationToken>())
             .Returns(plan);

        await _sut.ArchivePlanAsync(planId, CancellationToken.None);

        plan.Status.Should().Be(PlanStatus.Archived);
    }

    [Fact]
    public async Task ArchivePlanAsync_ThrowsNotFoundException_WhenPlanDoesNotExist()
    {
        _repo.FindByIdAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>())
             .Returns((NutritionPlan?)null);

        var act = () => _sut.ArchivePlanAsync(Guid.NewGuid(), CancellationToken.None);

        await act.Should().ThrowAsync<NotFoundException>();
    }
}

namespace NutriTrack.UnitTests.Validators;

public sealed class MacroValidatorTests
{
    // InlineData: casos simples directo en el atributo
    [Theory]
    [InlineData(180, 60, 150, true)]   // balance correcto
    [InlineData(0,   60, 150, false)]  // carbohidratos = 0
    [InlineData(180, -5, 150, false)]  // grasa negativa
    [InlineData(500, 500, 500, false)]  // ratio imposible
    public void IsValidMacroBalance_ReturnsExpected(
        int carbs, int fat, int protein, bool expected)
    {
        MacroValidator.IsValid(carbs, fat, protein)
            .Should().Be(expected);
    }

    // MemberData: casos complejos con objetos
    [Theory]
    [MemberData(nameof(InvalidPlanCases))]
    public async Task CreatePlanAsync_RejectsInvalidMacros(
        CreatePlanRequest req, string expectedError)
    {
        var sut = PlanServiceFactory.Create();

        var act = () => sut.CreatePlanAsync(req, CancellationToken.None);

        await act.Should().ThrowAsync<DomainException>()
            .WithMessage($"*{expectedError}*");
    }

    public static TheoryData<CreatePlanRequest, string> InvalidPlanCases => new()
    {
        { new() { PatientId = "",     Calories = 1800 }, "PatientId" },
        { new() { PatientId = "p1", Calories = 0    }, "calories" },
        { new() { PatientId = "p1", Calories = 9999 }, "exceeds maximum" },
    };
}

namespace NutriTrack.IntegrationTests.Api;

public sealed class NutritionApiTests
    : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public NutritionApiTests(WebApplicationFactory<Program> factory)
    {
        _client = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // Reemplaza PostgreSQL real por InMemory en tests
                services.RemoveAll<DbContextOptions<NutriTrackDbContext>>();
                services.AddDbContext<NutriTrackDbContext>(o =>
                    o.UseInMemoryDatabase("NutriTrackTestDb"));
            });
        }).CreateClient();
    }

    [Fact]
    public async Task GetSummary_Returns404_WhenPatientDoesNotExist()
    {
        var response = await _client.GetAsync(
            $"/api/patients/{Guid.NewGuid()}/summary");

        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
    }

    [Fact]
    public async Task CreatePlan_Returns201_WithLocation_WhenRequestIsValid()
    {
        var request = new CreatePlanRequest
        {
            PatientId   = "pat-integration-01",
            DietitianId = "diet-007",
            Calories    = 2000,
            Macros      = new(200, 70, 160)
        };

        var response = await _client.PostAsJsonAsync("/api/plans", request);

        response.StatusCode.Should().Be(HttpStatusCode.Created);
        response.Headers.Location.Should().NotBeNull();
        response.Headers.Location!.ToString()
            .Should().StartWith("/api/plans/");
    }

    [Fact]
    public async Task GetPlan_Returns200_WithCorrectData_WhenPlanExists()
    {
        // 1. Crear plan
        var created  = await SeedPlanAsync();
        var location = created.Headers.Location!.ToString();

        // 2. Obtenerlo
        var response = await _client.GetAsync(location);
        var dto = await response.Content
            .ReadFromJsonAsync<NutritionPlanDto>();

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        dto!.Calories.Should().Be(2000);
        dto.Status.Should().Be("Active");
    }

    private async Task<HttpResponseMessage> SeedPlanAsync()
        => await _client.PostAsJsonAsync("/api/plans",
            PlanRequestFaker.Valid());
}

namespace NutriTrack.IntegrationTests.Repositories;

public sealed class FoodLogRepositoryTests : IAsyncLifetime
{
    // Levanta un contenedor postgres:16-alpine real en Docker
    private readonly PostgreSqlContainer _postgres
        = new PostgreSqlBuilder()
            .WithImage("postgres:16-alpine")
            .Build();

    private NutriTrackDbContext _db = null!;
    private SqlFoodLogRepository _repo = null!;

    public async Task InitializeAsync()
    {
        await _postgres.StartAsync();

        var options = new DbContextOptionsBuilder<NutriTrackDbContext>()
            .UseNpgsql(_postgres.GetConnectionString())
            .Options;

        _db   = new NutriTrackDbContext(options);
        _repo = new SqlFoodLogRepository(_db);

        await _db.Database.MigrateAsync(); // aplica migraciones reales
    }

    public async Task DisposeAsync()
    {
        await _db.DisposeAsync();
        await _postgres.DisposeAsync();
    }

    [Fact]
    public async Task LogFoodAsync_PersistsEntry_WhenDataIsValid()
    {
        var entry = new FoodEntry
        {
            PatientId = "pat-001", FoodName = "Avena",
            Grams = 80, Calories = 300, LoggedAt = DateTime.UtcNow
        };

        await _repo.LogFoodAsync(entry, CancellationToken.None);

        var found = await _repo.GetByPatientAsync("pat-001", CancellationToken.None);
        found.Should().ContainSingle(e => e.FoodName == "Avena");
    }

    [Fact]
    public async Task GetDailySummaryAsync_ReturnsAggregatedCalories()
    {
        await SeedFoodEntriesAsync("pat-002",
            ("Pollo", 200, 330), ("Arroz", 150, 210), ("Brócoli", 100, 35));

        var summary = await _repo.GetDailySummaryAsync(
            "pat-002", DateOnly.FromDateTime(DateTime.Today),
            CancellationToken.None);

        summary.TotalCalories.Should().Be(575);
        summary.EntryCount.Should().Be(3);
    }
}

namespace NutriTrack.TestHelpers.Builders;

/// Fluent builder — evita "magic values" dispersos por toda la suite.
public sealed class NutritionPlanBuilder
{
    private Guid   _id         = Guid.NewGuid();
    private string _patientId  = "pat-default";
    private int    _calories   = 2000;
    private Macros _macros     = new(200, 65, 160);
    private PlanStatus _status = PlanStatus.Active;

    public NutritionPlanBuilder WithId(Guid id)
        { _id = id; return this; }

    public NutritionPlanBuilder WithPatient(string patientId)
        { _patientId = patientId; return this; }

    public NutritionPlanBuilder WithCalories(int kcal)
        { _calories = kcal; return this; }

    public NutritionPlanBuilder Archived()
        { _status = PlanStatus.Archived; return this; }

    public NutritionPlan Build()
        => NutritionPlan.Reconstitute(_id, _patientId, _calories, _macros, _status);
}

/// Faker con datos realistas usando Bogus
public static class PlanRequestFaker
{
    private static readonly Faker<CreatePlanRequest> _faker
        = new Faker<CreatePlanRequest>()
            .RuleFor(r => r.PatientId,   f => $"pat-{f.Random.AlphaNumeric(6)}")
            .RuleFor(r => r.DietitianId, f => $"diet-{f.Random.AlphaNumeric(4)}")
            .RuleFor(r => r.Calories,    f => f.Random.Int(1200, 3500))
            .RuleFor(r => r.Macros,      f => new(
                f.Random.Int(100, 350),
                f.Random.Int(40, 100),
                f.Random.Int(80, 200)));

    public static CreatePlanRequest Valid() => _faker.Generate();
    public static IReadOnlyList<CreatePlanRequest> Many(int count) => _faker.Generate(count);
}