using audit_logs.Models;
using audit_logs.Utils;

namespace audit_test.Repository;

using audit_logs.Repositories;
using audit.Model;
using audit_logs.Services;

public class AuditServiceIntegrationTests
{
    private AuditService _service;
   // private AuditRecordRepository _repository;

    [Order(1)]
    [SetUp]
    public void Setup()
    {
        IntegrationDb.Database.DropCollectionAsync("AuditRecords");
        //_repository = new AuditRecordRepository(IntegrationDb.Database);
        _service = new AuditService(IntegrationDb.Database);
    }

    [Test]
    public async Task RecordAuditAsync_CreatesAndRetrievesAuditRecord()
    {
        // Arrange
        var changes = new List<AuditRecord.Change>
        {
            new AuditRecord.Change
                { Field = "Username", OldValue = "oldUser", NewValue = "newUser", ValueType = "String" }
        };
        AuditRecord auditLogData = new();
        auditLogData.EntityType = "User";
        auditLogData.RecordId = "1";
        auditLogData.UserId = "123";
        auditLogData.ActionType = "Update";
        auditLogData.ActionTime = DateTime.UtcNow;
        auditLogData.Reason = "Testing change detection";
        auditLogData.UserIpAddress = "127.0.0.1";
        auditLogData.Changes = changes;

        // Act
        await _service.RecordAuditAsync(auditLogData);


        // Retrieve all records to validate insertion
        var allRecords = await _service.AuditLogRepository.GetAllAuditRecordsAsync();

        // Assert
        Assert.AreEqual(1, allRecords.Count, "There should be exactly three audit record in the database.");
        var storedRecord = allRecords[0];
        Assert.AreEqual(auditLogData.EntityType, storedRecord.EntityType);
        Assert.AreEqual(auditLogData.RecordId, storedRecord.RecordId);
        Assert.AreEqual(auditLogData.UserId, storedRecord.UserId);
        Assert.AreEqual(auditLogData.ActionType, storedRecord.ActionType);
        Assert.AreEqual(auditLogData.Reason, storedRecord.Reason);
        //  Assert.That(storedRecord.Changes, Is.EquivalentTo(changes).Using(new ChangeComparer()), "Changes should match the input changes.");
    }

    [Test]
    public async Task GetAllAuditRecords_ReturnsAllRecords()
    {
        // Prepare multiple records
        var records = new List<AuditRecord>
        {
            new AuditRecord
            {
                EntityType = "User", RecordId = "1", UserId = "123", ActionType = "Create",
                ActionTime = DateTime.UtcNow, Reason = "Test Reason 1"
            },
            new AuditRecord
            {
                EntityType = "Admin", RecordId = "2", UserId = "456", ActionType = "Delete",
                ActionTime = DateTime.UtcNow, Reason = "Test Reason 2"
            }
        };

        foreach (var rec in records)
        {
            await  _service.AuditLogRepository.InsertOneAsync(rec);
        }

        // Test retrieval method
        var allRecords = await  _service.AuditLogRepository.GetAllAuditRecordsAsync();

        // Assert
        Assert.AreEqual(2, allRecords.Count, "All records should be retrieved.");
        Assert.IsTrue(allRecords.Exists(r => r.RecordId == "1" && r.EntityType == "User"));
        Assert.IsTrue(allRecords.Exists(r => r.RecordId == "2" && r.EntityType == "Admin"));
    }

    [Test]
    public async Task DetectChangesAsync_DetectsAndRecordsChanges()
    {
        // Arrange
        
        // Variables de auditoría
        AuditLogData auditLogData = new();
        auditLogData.OriginalJson = "{ \"Username\": \"oldUser\", \"Email\": \"old@example.com\", \"address\": 15 }";
        auditLogData.ModifiedJson =
            "{ \"Username\": \"newUser\", \"Email\": \"old@example.com\", \"PhoneNumber\": \"123456789\" }";
        auditLogData.EntityType = "User";
        auditLogData.RecordId = "1";
        auditLogData.UserId = "123";
        auditLogData.ActionType = "Update";
        auditLogData.ActionTime = DateTime.UtcNow;
        auditLogData.Reason = "Testing change detection";
        auditLogData.UserIpAddress = "127.0.0.1";

        // Act - Llamar a DetectChangesAsync para que identifique cambios
        await _service.CreateAuditLogAsync(auditLogData);

        // Act - Registrar la auditoría usando los cambios detectados
       // List<AuditRecord.Change> changes = new JsonComparer().GetDifferences(originalJson, modifiedJson);
        //await _service.RecordAuditAsync(entityType, recordId, userId, actionType, reason,actionTime, changes, );

        // Retrieve all records to validate insertion
        var allRecords = await  _service.AuditLogRepository.GetAllAuditRecordsAsync();

        // Assert
        Assert.AreEqual(1, allRecords.Count, "Debe haber exactamente un registro de auditoría en la base de datos.");
        var storedRecord = allRecords[0];
        Assert.AreEqual(auditLogData.EntityType, storedRecord.EntityType);
        Assert.AreEqual(auditLogData.RecordId, storedRecord.RecordId);
        Assert.AreEqual(auditLogData.UserId, storedRecord.UserId);
        Assert.AreEqual(auditLogData.ActionType, storedRecord.ActionType);
        Assert.AreEqual(auditLogData.Reason, storedRecord.Reason);

        // Verificar que los cambios detectados sean correctos
        Assert.That(storedRecord.Changes.Count, Is.EqualTo(3), "Debería detectar tres cambios.");


        var changeUsername = storedRecord.Changes.Find(c => c.Field == "Username");
        Assert.NotNull(changeUsername, "Debe existir un cambio en el campo 'Username'.");
        Assert.AreEqual("oldUser", changeUsername.OldValue.AsString);
        Assert.AreEqual("newUser", changeUsername.NewValue.AsString);
        Assert.AreEqual("string", changeUsername.ValueType);

        var changePhoneNumber = storedRecord.Changes.Find(c => c.Field == "PhoneNumber");
        Assert.NotNull(changePhoneNumber, "Debe existir un cambio en el campo 'PhoneNumber'.");
        Assert.IsTrue(changePhoneNumber.OldValue.IsBsonNull, "El valor anterior de 'PhoneNumber' debe ser nulo.");
        Assert.AreEqual("123456789", changePhoneNumber.NewValue.AsString);
        Assert.AreEqual("string", changePhoneNumber.ValueType);
    }
    [Test]
public async Task GetAuditLogsAsync_ReturnsPaginatedRecords()
{
    // Arrange - Insert multiple audit records to test pagination
    var records = new List<AuditRecord>();
    for (int i = 1; i <= 20; i++)
    {
        records.Add(new AuditRecord
        {
            EntityType = "TestEntity",
            RecordId = i.ToString(),
            UserId = "User" + i,
            ActionType = "Create",
            ActionTime = DateTime.UtcNow,
            Reason = "Test Reason " + i,
            Changes = new List<AuditRecord.Change>
            {
                new AuditRecord.Change
                {
                    Field = "Field" + i,
                    OldValue = "OldValue" + i,
                    NewValue = "NewValue" + i,
                    ValueType = "String"
                }
            }
        });
    }

    foreach (var record in records)
    {
        await _service.AuditLogRepository.InsertOneAsync(record);
    }

    // Act - Retrieve the first page with a page size of 5
    int pageNumber = 1;
    int pageSize = 5;
    var paginatedResult = await _service.GetAuditLogsAsync(pageNumber, pageSize);

    // Assert - Check that the pagination returns the correct number of records and page information
    Assert.AreEqual(pageSize, paginatedResult.Records.Count(), "The number of records should match the page size.");
    Assert.AreEqual(20, paginatedResult.TotalRecords, "The total number of records should match the inserted records.");
    Assert.AreEqual(4, paginatedResult.TotalPages, "The total pages should be calculated correctly.");
    Assert.AreEqual(pageNumber, paginatedResult.CurrentPage, "The current page should be correct.");

    // Further assertions to check that the records and changes are the expected ones
    var firstRecord = paginatedResult.Records.First();
    Assert.AreEqual("TestEntity", firstRecord.EntityType);
    Assert.AreEqual("1", firstRecord.RecordId);
    Assert.AreEqual("User1", firstRecord.UserId);
    Assert.AreEqual("Create", firstRecord.ActionType);

    // Verify the changes for the first record
    Assert.IsNotNull(firstRecord.Changes);
    Assert.AreEqual(1, firstRecord.Changes.Count, "There should be exactly one change in the first record.");
    var firstChange = firstRecord.Changes.First();
    Assert.AreEqual("Field1", firstChange.Field);
    Assert.AreEqual("OldValue1", firstChange.OldValue.AsString);
    Assert.AreEqual("NewValue1", firstChange.NewValue.AsString);
    Assert.AreEqual("String", firstChange.ValueType);
}

}