using AcDream.Core.Chat;

namespace AcDream.Core.Tests.Chat;

/// <summary>
/// Campaign CH slice CH2: unit tests for <see cref="SpewBoxState"/>, the
/// pure-state port of retail's <c>gmSpewBoxUI</c> pending/visible queue
/// split (research doc §3.1/§7.2).
/// </summary>
public sealed class SpewBoxStateTests
{
    [Fact]
    public void Enqueue_DoesNotBecomeVisibleUntilTick()
    {
        // Retail decouples enqueue (RecvNotice_DisplayFinalStringInfo) from
        // display (Update, driven by UI tick global message 3) by one frame.
        var state = new SpewBoxState();
        state.Enqueue("You can't jump while in the air");

        Assert.Equal(0, state.Count);
        Assert.Empty(state.Snapshot());
    }

    [Fact]
    public void Tick_DrainsPendingIntoVisible()
    {
        var state = new SpewBoxState();
        state.Enqueue("You can't jump while in the air");

        state.Tick(nowSeconds: 0d);

        Assert.Equal(1, state.Count);
        SpewBoxEntry entry = Assert.Single(state.Snapshot());
        Assert.Equal("You can't jump while in the air", entry.Text);
    }

    [Fact]
    public void Tick_InsertsNewestAtIndexZero()
    {
        // Retail: InsertItem(item, 0) — with MaxConcurrentItems raised past
        // the code default of 1, newer entries must lead the visible list.
        var state = new SpewBoxState();
        state.Enqueue("first");
        state.Tick(0d);
        state.Enqueue("second");
        state.Tick(0d);

        // MaxConcurrentItems == 1 (retail code default) means "first" was
        // already evicted by the overflow rule — assert directly on the
        // ordering guarantee instead by forcing a raised cap via reflection
        // is out of scope; the dedupe/overflow tests below cover that
        // interaction precisely. Here we only need the single surviving
        // entry to be "second" (the newest), proving insert-at-front beat
        // whatever eviction order a stack (insert-at-back) would produce.
        SpewBoxEntry entry = Assert.Single(state.Snapshot());
        Assert.Equal("second", entry.Text);
    }

    [Fact]
    public void Tick_IdenticalRepeat_RefreshesInPlace_DoesNotStack()
    {
        // Retail (0x004D5EF6-0x004D5F91): if the current item 0 has
        // byte-identical text, that older item is deleted first — a
        // repeated message refreshes instead of stacking a duplicate.
        var state = new SpewBoxState();
        state.Enqueue("You are too encumbered to carry that!");
        state.Tick(0d);
        state.Enqueue("You are too encumbered to carry that!");
        state.Tick(1d);

        Assert.Equal(1, state.Count);
        SpewBoxEntry entry = Assert.Single(state.Snapshot());
        Assert.Equal("You are too encumbered to carry that!", entry.Text);
        // The refreshed entry carries the LATER expiry (re-inserted at t=1).
        Assert.Equal(1d + SpewBoxState.DefaultLifetime.TotalSeconds, entry.ExpiresAtSeconds);
    }

    [Fact]
    public void Tick_DifferentText_DoesNotDedupe()
    {
        var state = new SpewBoxState();
        state.Enqueue("first message");
        state.Tick(0d);
        state.Enqueue("second message");
        state.Tick(0d);

        // With MaxConcurrentItems == 1, "second message" evicts "first
        // message" via overflow, not dedupe — either way only one survives,
        // and it must be the newest.
        SpewBoxEntry entry = Assert.Single(state.Snapshot());
        Assert.Equal("second message", entry.Text);
    }

    [Fact]
    public void Tick_Overflow_DropsOldest_RespectingMaxConcurrentItems()
    {
        var state = new SpewBoxState();
        Assert.Equal(1, SpewBoxState.MaxConcurrentItems);

        state.Enqueue("oldest");
        state.Tick(0d);
        state.Enqueue("newer");
        state.Tick(0d);

        Assert.Equal(SpewBoxState.MaxConcurrentItems, state.Count);
        SpewBoxEntry entry = Assert.Single(state.Snapshot());
        Assert.Equal("newer", entry.Text);
    }

    [Fact]
    public void Tick_PrunesExpiredEntries()
    {
        var state = new SpewBoxState();
        state.Enqueue("fading message");
        state.Tick(nowSeconds: 0d);
        Assert.Equal(1, state.Count);

        double justPastExpiry = SpewBoxState.DefaultLifetime.TotalSeconds + 0.001;
        state.Tick(justPastExpiry);

        Assert.Equal(0, state.Count);
        Assert.Empty(state.Snapshot());
    }

    [Fact]
    public void Tick_NoPendingNoExpired_RevisionUnchanged()
    {
        var state = new SpewBoxState();
        state.Enqueue("stays visible a while");
        state.Tick(0d);
        long revisionAfterFirstTick = state.Revision;

        // Well within the lifetime window, nothing pending — a second Tick
        // should be a pure no-op.
        state.Tick(0.5d);

        Assert.Equal(revisionAfterFirstTick, state.Revision);
    }

    [Fact]
    public void Reset_ClearsPendingAndVisible()
    {
        var state = new SpewBoxState();
        state.Enqueue("pending, never ticked");
        state.Enqueue("about to be visible");
        state.Tick(0d);
        Assert.True(state.Count > 0);

        state.Reset();

        Assert.Equal(0, state.Count);
        Assert.Empty(state.Snapshot());

        // A Reset while text was still pending (never ticked) must also
        // discard the pending queue — ticking afterward shows nothing.
        state.Tick(1d);
        Assert.Equal(0, state.Count);
    }

    [Fact]
    public void Revision_AdvancesOnTickThatChangesVisibleSet()
    {
        var state = new SpewBoxState();
        long initial = state.Revision;

        state.Enqueue("a line");
        state.Tick(0d);

        Assert.True(state.Revision > initial);
    }
}