using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using Strata.SqlTools.Breakdowns.SqlServer;
using Strata.SqlTools.EFCore.Abstractions;
using Strata.SqlTools.EFCore.Services;

namespace Strata.SqlTools.EFCore.Tests;

[TestFixture]
public class QueryBreakdownRepositoryTests
{
    private DbContext _dbContext = null!;
    private IQueryBreakdownMapper _mapper = null!;
    private IQueryBreakdownRepository _repository = null!;

    [SetUp]
    public void Setup()
    {
        var options = new DbContextOptionsBuilder()
            .UseInMemoryDatabase(Guid.NewGuid().ToString())
            .Options;

        _dbContext = new TestDbContext(options);
        _dbContext.Database.EnsureCreated();

        _mapper = new QueryBreakdownMapper();
        _repository = new QueryBreakdownRepository(_dbContext, _mapper);
    }

    [TearDown]
    public void TearDown()
    {
        _dbContext.Dispose();
    }

    [Test]
    public async Task AddAsync_WithValidQuery_ReturnsValidId()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");

        // Act
        int id = await _repository.AddAsync(queryBreakdown);

        // Assert
        Assert.That(id, Is.GreaterThan(0));
    }

    [Test]
    public async Task GetByIdAsync_WithExistingId_ReturnsQueryBreakdown()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
        int id = await _repository.AddAsync(queryBreakdown);

        // Act
        var retrieved = await _repository.GetByIdAsync(id);

        // Assert
        Assert.That(retrieved, Is.Not.Null);
        Assert.That(retrieved?.SelectClause?.Clause, Is.EqualTo("ID, Name"));
        Assert.That(retrieved?.FromClause?.Clause, Is.EqualTo("Users"));
    }

    [Test]
    public async Task GetByIdAsync_WithNonExistentId_ReturnsNull()
    {
        // Act
        var retrieved = await _repository.GetByIdAsync(999);

        // Assert
        Assert.That(retrieved, Is.Null);
    }

    [Test]
    public async Task GetAllAsync_WithMultipleQueries_ReturnsAllQueries()
    {
        // Arrange
        var query1 = new QueryBreakdown("ID", "Users");
        var query2 = new QueryBreakdown("OrderID, Total", "Orders");

        await _repository.AddAsync(query1);
        await _repository.AddAsync(query2);

        // Act
        var allQueries = await _repository.GetAllAsync();

        // Assert
        Assert.That(allQueries, Has.Count.EqualTo(2));
    }

    [Test]
    public async Task UpdateAsync_WithExistingQuery_UpdatesData()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
        int id = await _repository.AddAsync(queryBreakdown);

        var updatedQuery = new QueryBreakdown("ID, Name, Email", "Users");

        // Act
        await _repository.UpdateAsync(id, updatedQuery);
        var retrieved = await _repository.GetByIdAsync(id);

        // Assert
        Assert.That(retrieved?.SelectClause?.Clause, Is.EqualTo("ID, Name, Email"));
    }

    [Test]
    public async Task DeleteAsync_WithExistingId_DeletesQuery()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
        int id = await _repository.AddAsync(queryBreakdown);

        // Act
        bool deleted = await _repository.DeleteAsync(id);
        var retrieved = await _repository.GetByIdAsync(id);

        // Assert
        Assert.That(deleted, Is.True);
        Assert.That(retrieved, Is.Null);
    }

    [Test]
    public async Task DeleteAsync_WithNonExistentId_ReturnsFalse()
    {
        // Act
        bool deleted = await _repository.DeleteAsync(999);

        // Assert
        Assert.That(deleted, Is.False);
    }

    [Test]
    public async Task GetCountAsync_WithMultipleQueries_ReturnsCorrectCount()
    {
        // Arrange
        await _repository.AddAsync(new QueryBreakdown("ID", "Users"));
        await _repository.AddAsync(new QueryBreakdown("OrderID", "Orders"));
        await _repository.AddAsync(new QueryBreakdown("ProductID", "Products"));

        // Act
        int count = await _repository.GetCountAsync();

        // Assert
        Assert.That(count, Is.EqualTo(3));
    }

    [Test]
    public async Task AddAsync_WithParameters_PersistsParameters()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
        queryBreakdown.AddParameter("UserId", 123);

        // Act
        int id = await _repository.AddAsync(queryBreakdown);
        var retrieved = await _repository.GetByIdAsync(id);

        // Assert
        Assert.That(retrieved?.Parameters, Does.ContainKey("@UserId"));
    }
}