using FluentAssertions;
using Marathon.Application.Abstractions;
using Marathon.Application.UseCases;
using Marathon.Domain.Backtesting;
using Microsoft.Extensions.Logging.Abstractions;
using NSubstitute;

namespace Marathon.Application.Tests.UseCases;

public sealed class SaveStrategyUseCaseTests
{
    private readonly ISavedStrategyRepository _repo = Substitute.For<ISavedStrategyRepository>();

    private SaveStrategyUseCase CreateSut() =>
        new(_repo, NullLogger<SaveStrategyUseCase>.Instance);

    [Fact]
    public async Task Creates_New_When_NameUnused()
    {
        _repo.GetByNameAsync("Fresh", Arg.Any<CancellationToken>()).Returns((SavedStrategy?)null);

        var result = await CreateSut().ExecuteAsync("Fresh", BacktestStrategy.Default, CancellationToken.None);

        result.Name.Should().Be("Fresh");
        await _repo.Received(1).AddAsync(
            Arg.Is<SavedStrategy>(s => s.Name == "Fresh"), Arg.Any<CancellationToken>());
        await _repo.DidNotReceive().UpdateAsync(Arg.Any<SavedStrategy>(), Arg.Any<CancellationToken>());
        await _repo.Received(1).SaveChangesAsync(Arg.Any<CancellationToken>());
    }

    [Fact]
    public async Task Overwrites_Existing_KeepingIdentityAndCreatedAt()
    {
        var existing = SavedStrategy.Create("Reused", BacktestStrategy.Default);
        _repo.GetByNameAsync("Reused", Arg.Any<CancellationToken>()).Returns(existing);

        var newStrategy = new BacktestStrategy(1000m, 0.7m, StakeRule.Flat, 50m, 0.02m, 0.25m);
        var result = await CreateSut().ExecuteAsync("Reused", newStrategy, CancellationToken.None);

        result.Id.Should().Be(existing.Id);
        result.CreatedAt.Should().Be(existing.CreatedAt);
        result.Strategy.MinScore.Should().Be(0.7m);
        await _repo.Received(1).UpdateAsync(
            Arg.Is<SavedStrategy>(s => s.Id == existing.Id && s.Strategy.MinScore == 0.7m),
            Arg.Any<CancellationToken>());
        await _repo.DidNotReceive().AddAsync(Arg.Any<SavedStrategy>(), Arg.Any<CancellationToken>());
    }

    [Fact]
    public async Task UpsertLookup_UsesTrimmedName()
    {
        _repo.GetByNameAsync("Padded", Arg.Any<CancellationToken>()).Returns((SavedStrategy?)null);

        await CreateSut().ExecuteAsync("  Padded  ", BacktestStrategy.Default, CancellationToken.None);

        await _repo.Received(1).GetByNameAsync("Padded", Arg.Any<CancellationToken>());
    }

    [Theory]
    [InlineData("")]
    [InlineData("   ")]
    public async Task Throws_When_NameBlank(string blank)
    {
        var act = async () => await CreateSut().ExecuteAsync(blank, BacktestStrategy.Default, CancellationToken.None);

        await act.Should().ThrowAsync<ArgumentException>();
        await _repo.DidNotReceive().AddAsync(Arg.Any<SavedStrategy>(), Arg.Any<CancellationToken>());
    }
}