using DigitalData.Core.Tests.Mock;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Reflection;
using DigitalData.Core.Abstraction.Application.Repository;
using DigitalData.Core.Infrastructure;

namespace DigitalData.Core.Tests.Infrastructure;

public class DbRepositoryTests
{
    private IHost _host;

    private IRepository Repo;

    [SetUp]
    public void Setup()
    {
        var builder = Host.CreateApplicationBuilder();

        builder.Services.AddDbContext<MockDbContext>(opt => opt.UseInMemoryDatabase("MockDB"));

        builder.Services.AddDbRepository(opt =>
        {
            opt.RegisterFromAssembly<MockDbContext>(typeof(User).Assembly);
        });

        builder.Services.AddAutoMapper(Assembly.GetExecutingAssembly());

        _host = builder.Build();

        Repo = _host.Services.GetRequiredService<IRepository>();
    }

    [TearDown]
    public void TearDown()
    {
        if (_host is IDisposable disposableHost)
            disposableHost.Dispose();
    }

    [TestCase(true, TestName = "WhenGivenMultipleUsers")]
    [TestCase(false, TestName = "WhenGivenSingleUser")]
    public void CreateAsync_ShouldNotThrow(bool multiple)
    {
        // Arrange
        var faker = Fake.CreateUserFaker();

        // Act & Assert
        if (multiple)
            Assert.DoesNotThrowAsync(async () => await Repo.CreateAsync(faker.Generate(Random.Shared.Next(1, 10))));
        else
            Assert.DoesNotThrowAsync(async () => await Repo.CreateAsync(faker.Generate()));
    }

    [TestCase(true, TestName = "WhenDtoUsed")]
    [TestCase(false, TestName = "WhenEntityUsed")]
    public async Task ReadAsync_ShouldReturnCreated(bool useDto)
    {
        // Act
        var createdUser = useDto
            ? await Repo.CreateAsync<User, UserCreateDto>(Fake.UserCreateDto)
            : await Repo.CreateAsync(Fake.User);

        var readUser = await Repo.Where<User>(u => u.Id == createdUser.Id).FirstOrDefaultAsync();

        // Assert
        Assert.Multiple(() =>
        {
            Assert.That(readUser, Is.Not.Null);
            Assert.That(readUser, Is.EqualTo(createdUser));
        });
    }

    [Test]
    public async Task ReadAsync_ShouldReturnUpdated()
    {
        // Arrange
        var createdUser = await Repo.CreateAsync<User, UserCreateDto>(Fake.UserCreateDto);
        var userUpdateDto = new UserUpdateDto() { Age = 10, Email = "Bar", FirstName = "Foo" };

        // Act
        await Repo.UpdateAsync<User, UserUpdateDto>(userUpdateDto, u => u.Id == createdUser!.Id);
        var upToDateUser = await Repo.Where<User>(u => u.Id == createdUser!.Id).FirstOrDefaultAsync();

        // Assert
        Assert.Multiple(() =>
        {
            Assert.That(upToDateUser, Is.Not.Null);
            Assert.That(upToDateUser?.FirstName, Is.EqualTo(userUpdateDto.FirstName));
            Assert.That(upToDateUser?.Email, Is.EqualTo(userUpdateDto.Email));
            Assert.That(upToDateUser?.Age, Is.EqualTo(userUpdateDto.Age));
        });
    }

    [Test]
    public async Task ReadAsync_ShouldNotReturnDeleted()
    {
        // Arrange
        var createdUser = await Repo.CreateAsync<User, UserCreateDto>(Fake.UserCreateDto);
        var readUser = await Repo.Where<User>(u => u.Id == createdUser.Id).FirstOrDefaultAsync();

        // Act
        await Repo.DeleteAsync<User>(u => u.Id == createdUser.Id);
        var deletedUser = await Repo.Where<User>(u => u.Id == createdUser.Id).FirstOrDefaultAsync();
        
        // Assert
        Assert.Multiple(() =>
        {
            Assert.That(readUser, Is.Not.Null);
            Assert.That(deletedUser, Is.Null);
        });
    }
}