using adas_core.Application.Services.Caching;

namespace adas_core.Test.Services;

/// <summary>
/// Test fixture that validates the behavior of the NoCacheService, ensuring its operations function correctly in a non-caching context.
/// </summary>
/// <!-- aidoc:v1 sig=d79267a -->
[TestFixture]
public class NoCacheServiceTest
{
    private NoCacheService _noCacheService = null!;

    /// <summary>
    /// Initializes a fresh <see cref="NoCacheService"/> instance and assigns it to <c>_noCacheService</c>
    /// to provide a clean, dependency-free test fixture prior to executing each test.
    /// </summary>
    /// <!-- aidoc:v1 sig=d8eb19f body=f419747 -->
    [SetUp]
        public void SetUp()
        {
            _noCacheService = new NoCacheService();
        }

    #region TC-27

    /// <summary>
    /// Verifies that the no-cache implementation of <see cref="GetOrSetObjectAsync"/> always invokes the supplied factory delegate
    /// and never returns a previously cached value, even when called repeatedly with the same key.
    /// </summary>
    /// <!-- aidoc:v1 sig=0ade665 body=93b4d4c -->
    [Test]
    public async Task GetOrSetObjectAsync_AlwaysCallsFactory_NeverUsesCache()
    {
        // Arrange
        var callCount = 0;
        var expectedResult = new { Name = "TestPatient", Id = "123" };

        Func<Task<object>> factory = () =>
        {
            callCount++;
            return Task.FromResult<object>(expectedResult);
        };

        var key = "patients:abc123";
        var ttl = TimeSpan.FromMinutes(5);

        // Act
        var result1 = await _noCacheService.GetOrSetObjectAsync(key, factory, ttl);
        var result2 = await _noCacheService.GetOrSetObjectAsync(key, factory, ttl);

        // Assert
        Assert.That(callCount, Is.EqualTo(2), "La factory debería llamarse siempre (no hay caché)");
        Assert.That(result1, Is.EqualTo(expectedResult));
        Assert.That(result2, Is.EqualTo(expectedResult));
    }

    /// <summary>
    /// Verifies that <c>GetOrSetValueAsync</c> invokes the supplied factory delegate once for every unique key passed in, ensuring that the no-cache implementation does not deduplicate or short-circuit calls based on key uniqueness.
    /// </summary>
    /// <!-- aidoc:v1 sig=7b6a45d body=15c5c5c -->
    [Test]
    public async Task GetOrSetObjectAsync_CallsFactory_ForEachUniqueKey()
    {
        // Arrange
        var callCount = 0;

        Func<Task<string>> factory = () =>
        {
            callCount++;
            return Task.FromResult($"result-{callCount}");
        };

        // Act
        await _noCacheService.GetOrSetValueAsync("key1", factory);
        await _noCacheService.GetOrSetValueAsync("key2", factory);
        await _noCacheService.GetOrSetValueAsync("key3", factory);

        // Assert
        Assert.That(callCount, Is.EqualTo(3),
            "La factory debería haber sido invocada 3 veces, una por cada clave única");
    }

    #endregion

    #region TC-28

    /// <summary>
    /// Verifies that the no-cache service implementation never persists data to any backend when <c>GetOrSetObjectAsync</c> is invoked, and confirms that a subsequent <c>DeleteObjectAsync</c> on the same key does not throw.
    /// </summary>
    /// <!-- aidoc:v1 sig=9b41a17 body=279c122 -->
    [Test]
        public async Task GetOrSetObjectAsync_DoesNotStoreData_InAnyBackend()
        {
            var key = "patients:abc123";
            var expectedResult = new { Name = "TestPatient" };
    
            Func<Task<object>> factory = () => Task.FromResult<object>(expectedResult);
    
            await _noCacheService.GetOrSetObjectAsync(key, factory);
    
            var retrieved = await _noCacheService.GetObjectAsync<object>(key);
            Assert.That(retrieved, Is.Null);
    
    
            Func<Task> act = async () => await _noCacheService.DeleteObjectAsync(key);
            Assert.That(act, Throws.Nothing);
    
        }


    #endregion

    #region TC-29

    /// <summary>
    /// Verifies that the no-cache service's <c>DeleteByPatternAsync</c> returns 0 and does not throw when invoked with arbitrary patterns, confirming the no-op delete behavior for any key pattern.
    /// </summary>
    /// <!-- aidoc:v1 sig=d8ac365 body=97d47fa -->
    [Test]
        public async Task DeleteByPatternAsync_ReturnsZero_DoesNotThrow()
        {
            // Act
            var result = await _noCacheService.DeleteByPatternAsync("patients:*");
            var result2 = await _noCacheService.DeleteByPatternAsync("any:pattern:*");
    
            // Assert
            Assert.That(result, Is.EqualTo(0));
            Assert.That(result2, Is.EqualTo(0));
        }

    #endregion

    #region TC-30

    /// <summary>
    /// Verifies that calling CleanCache on the no-cache service is a safe no-op that does not throw,
    /// and that subsequent calls to GetValue consistently return <c>null</c> for any key.
    /// </summary>
    /// <!-- aidoc:v1 sig=732eb50 body=c99cdf2 -->
    [Test]
        public void CleanCache_IsNoOp_DoesNotThrow()
        {
    
            Action act = () => _noCacheService.CleanCache();
            Assert.That(act, Throws.Nothing);
    
            var result = _noCacheService.GetValue("any-key");
            Assert.That(result, Is.Null);
        }


    /// <summary>
    /// Verifies that calling <c>SetValue</c> on the no-cache service is a no-op and does not throw any exception.
    /// </summary>
    /// <!-- aidoc:v1 sig=93ab163 body=4352e8e -->
    [Test]
        public void SetValue_IsNoOp_DoesNotThrow()
        {
    
            Action act = () => _noCacheService.SetValue("key", "value");
            Assert.That(act, Throws.Nothing);
    
        }


    /// <summary>
    /// Verifies that the no-cache service's GetValue method returns null for any key,
    /// confirming that the no-op implementation does not return or simulate cached values.
    /// </summary>
    /// <!-- aidoc:v1 sig=11d9010 body=0d07264 -->
    [Test]
        public void GetValue_IsNoOp_ReturnsNull()
        {
            var result = _noCacheService.GetValue("any-key");
    
            Assert.That(result, Is.Null);
        }

    #endregion
}