using Microsoft.Extensions.Logging;
using MongoDB.Bson.Serialization;
using MongoDB.Driver.Linq;

namespace Dpz.Core.ServiceTest;

[TestFixture]
public class UnitOfWorkTest : Basic
{
    private class UnitOfWorkTestEntity : BaseEntity
    {
        public string Value { get; set; } = "";
    }

    private class UnitOfWorkTestEntity2 : BaseEntity
    {
        public string Value { get; set; } = "";
    }

    [Test]
    public async Task TransactionTestAsync()
    {
        using var uow = GetService<IUnitOfWork>();
        var repository1 = uow.GetRepository<UnitOfWorkTestEntity>();
        var repository2 = uow.GetRepository<UnitOfWorkTestEntity2>();
        var logger = GetService<ILogger<UnitOfWorkTest>>();

        uow.Begin();
        await repository1.DeleteAsync(x => true);
        await repository2.DeleteAsync(x => true);

        var entity1 = new UnitOfWorkTestEntity { Value = Guid.NewGuid().ToString("N") };
        await repository1.InsertAsync(entity1);
        var entity2 = new UnitOfWorkTestEntity2 { Value = Guid.NewGuid().ToString("N") };
        await repository2.InsertAsync(entity2);

        logger.LogInformation("entity1 value:{Entity1}", entity1.Value);
        logger.LogInformation("entity2 value:{Entity2}", entity2.Value);

        await uow.CommitAsync();

        using var uow2 = GetService<IUnitOfWork>();
        var repository3 = uow2.GetRepository<UnitOfWorkTestEntity>();
        var repository4 = uow2.GetRepository<UnitOfWorkTestEntity2>();
        var guid1 = Guid.NewGuid().ToString("N");
        var guid2 = Guid.NewGuid().ToString("N");
        try
        {
            var list1 = await repository3.SearchFor(x => true).ToListAsync();
            Assert.That(list1, Is.Not.Null);
            Assert.That(list1, Is.Not.Empty);

            var list2 = await repository4.SearchFor(x => true).ToListAsync();
            Assert.That(list2, Is.Not.Null);
            Assert.That(list2, Is.Not.Empty);

            uow2.Begin();
            var entity3 = new UnitOfWorkTestEntity { Value = guid1 };
            var entity4 = new UnitOfWorkTestEntity2 { Value = guid2 };

            await repository3.InsertAsync(entity3);
            await repository4.InsertAsync(entity4);

            var r1 = await repository3.SearchFor(x => x.Value == guid1).FirstOrDefaultAsync();
            Assert.That(r1, Is.Not.Null);

            var r2 = await repository4.SearchFor(x => x.Value == guid2).FirstOrDefaultAsync();
            Assert.That(r2, Is.Not.Null);

            logger.LogInformation("fail entity3 value:{Entity3}", entity3.Value);
            logger.LogInformation("fail entity4 value:{Entity4}", entity4.Value);

            throw new Exception();
        }
        catch (Exception)
        {
            await uow2.RollbackAsync();
        }

        var repo1 = new Repository<UnitOfWorkTestEntity>(ConnectionString);
        var repo2 = new Repository<UnitOfWorkTestEntity2>(ConnectionString);

        var result1 = await repo1.SearchFor(x => x.Value == guid1).FirstOrDefaultAsync();
        Assert.That(result1, Is.Null);
        var result2 = await repo2.SearchFor(x => x.Value == guid2).FirstOrDefaultAsync();
        Assert.That(result2, Is.Null);
    }

    public void Test()
    {
        var serializerRegistry = BsonSerializer.SerializerRegistry;
        var documentSerializer = serializerRegistry.GetSerializer<SteamGame>();
        var update = Builders<SteamGame>.Update.Set(x => x.PlayTime, 100u);

        var updateArgs = new RenderArgs<SteamGame>(documentSerializer, serializerRegistry);

        Console.WriteLine(update.Render(updateArgs));
        update = update.Set(x => x.LastUpdateTime, DateTime.Now);

        Console.WriteLine(update.Render(updateArgs));
    }
}