using Omika.Core.Observability.External;

namespace Omika.Tests.Observability.External;

/// <summary>
/// Compteurs du pont externe (Phase 5) : valeurs initiales à 0, incréments exacts,
/// thread-safe (Interlocked), jamais-throw. Compteurs purement mémoire — jamais
/// réinjectés dans IOmikaTelemetry (anti-boucle).
/// </summary>
public class ExternalObservabilityCountersTests
{
    [Fact]
    public void AllCounters_StartAtZero()
    {
        var counters = new ExternalObservabilityCounters();

        Assert.Equal(0, counters.Accepted);
        Assert.Equal(0, counters.Exported);
        Assert.Equal(0, counters.DroppedDisabled);
        Assert.Equal(0, counters.DroppedCircuitOpen);
        Assert.Equal(0, counters.DroppedSecurity);
        Assert.Equal(0, counters.DroppedInvalid);
        Assert.Equal(0, counters.DroppedInternal);
        Assert.Equal(0, counters.Failure);
        Assert.Equal(0, counters.CircuitOpened);
        Assert.Equal(0, counters.Forwarded);
        Assert.Equal(0, counters.ForwardFailure);
    }

    [Fact]
    public void Increments_AreExact()
    {
        var counters = new ExternalObservabilityCounters();

        counters.IncrementAccepted();
        counters.IncrementExported(7);
        counters.IncrementDroppedDisabled();
        counters.IncrementDroppedCircuitOpen();
        counters.IncrementDroppedSecurity();
        counters.IncrementDroppedInvalid();
        counters.IncrementDroppedInternal();
        counters.IncrementFailure();
        counters.IncrementCircuitOpened();
        counters.IncrementForwarded(3);
        counters.IncrementForwardFailure();

        Assert.Equal(1, counters.Accepted);
        Assert.Equal(7, counters.Exported);
        Assert.Equal(1, counters.DroppedDisabled);
        Assert.Equal(1, counters.DroppedCircuitOpen);
        Assert.Equal(1, counters.DroppedSecurity);
        Assert.Equal(1, counters.DroppedInvalid);
        Assert.Equal(1, counters.DroppedInternal);
        Assert.Equal(1, counters.Failure);
        Assert.Equal(1, counters.CircuitOpened);
        Assert.Equal(3, counters.Forwarded);
        Assert.Equal(1, counters.ForwardFailure);
    }

    [Fact]
    public void IncrementExported_AccumulatesByCount()
    {
        var counters = new ExternalObservabilityCounters();

        counters.IncrementExported(5);
        counters.IncrementExported(11);

        Assert.Equal(16, counters.Exported);
    }

    [Fact]
    public void ConcurrentIncrements_ProduceExactTotal()
    {
        const int threads = 8;
        const int perThread = 1000;
        var counters = new ExternalObservabilityCounters();

        Parallel.For(0, threads, _ =>
        {
            for (int i = 0; i < perThread; i++)
            {
                counters.IncrementAccepted();
            }
        });

        Assert.Equal(threads * perThread, counters.Accepted);
    }
}