using AcDream.App.UI;
using AcDream.Core.Chat;
using AcDream.UI.Abstractions.Panels.SpewBox;

namespace AcDream.App.Tests.UI;

/// <summary>
/// CH2 REJECT-review rework, BLOCKER 1
/// (<c>docs/research/2026-08-09-ch2-review-findings.md</c>): these tests
/// drive the controller's frame hook (<c>UiRoot.Tick</c>, the global-message-3
/// broadcast) rather than calling <c>UiText.LinesProvider</c> directly. The
/// original tests invoked the provider straight through, bypassing the
/// <c>Visible</c> gate that <c>UiText.OnDraw</c> checks before ever polling
/// it — that is exactly why the original bug (start-invisible → provider
/// never called by drawing → no line ever visible, pending queue never
/// drains) was invisible to the original test suite.
/// </summary>
public sealed class SpewBoxControllerTests
{
    [Fact]
    public void Controller_IsClickThroughOverlayAndDisposesFromRetainedRoot()
    {
        var root = new UiRoot
        {
            Width = 1280f,
            Height = 720f,
        };
        var state = new SpewBoxState();

        using (var controller = new SpewBoxController(root, new SpewBoxVM(state)))
        {
            UiText text = Assert.IsType<UiText>(root.Children.OfType<UiText>().Single());
            Assert.False(text.Visible);
            Assert.True(text.ClickThrough);
            Assert.Equal(int.MaxValue, text.ZOrder);

            state.Enqueue("You can't jump while in the air");

            // Drive the frame hook, NOT the provider — this is the tick
            // that drains the pending queue in production, wired through
            // UiRoot.Tick's IUiGlobalTimeListener broadcast.
            root.Tick(dt: 0d, nowMs: 1000L);

            UiText.Line line = Assert.Single(text.LinesProvider!());
            Assert.Equal("You can't jump while in the air", line.Text);
            Assert.True(text.Visible);
        }

        Assert.Empty(root.Children);
    }

    [Fact]
    public void Controller_NoContent_LeavesTextHiddenWithEmptyLines()
    {
        var root = new UiRoot { Width = 1280f, Height = 720f };
        using var controller = new SpewBoxController(root, new SpewBoxVM(new SpewBoxState()));

        root.Tick(dt: 0d, nowMs: 1000L);

        UiText text = Assert.IsType<UiText>(root.Children.OfType<UiText>().Single());
        Assert.Empty(text.LinesProvider!());
        Assert.False(text.Visible);
    }

    [Fact]
    public void Controller_BecomesVisible_WithoutAnyDrawHavingHappenedFirst()
    {
        // BLOCKER 1 acceptance (a): the original bug was start-invisible →
        // LinesProvider only reachable through UiElement.DrawSelfAndChildren
        // (which returns early on !Visible) → provider never called → never
        // visible. This test never calls anything draw-shaped — no OnDraw,
        // no DrawSelfAndChildren, no UiRenderContext — only the tick.
        var root = new UiRoot { Width = 1280f, Height = 720f };
        var state = new SpewBoxState();
        using var controller = new SpewBoxController(root, new SpewBoxVM(state));

        UiText text = Assert.IsType<UiText>(root.Children.OfType<UiText>().Single());
        Assert.False(text.Visible);

        state.Enqueue("Out of Range!");
        root.Tick(dt: 0d, nowMs: 500L);

        Assert.True(text.Visible);
        Assert.Equal("Out of Range!", Assert.Single(text.LinesProvider!()).Text);
    }

    [Fact]
    public void Controller_PendingQueueDrains_WithoutAnyDrawPass()
    {
        // BLOCKER 1 acceptance (b): SpewBoxState.Tick is the only caller
        // that drains _pending (SpewBoxState.cs's Queue<string>). Before the
        // fix, that call only happened inside LinesProvider, which drawing
        // gated behind Visible — so the pending queue was an unbounded
        // per-session leak. Enqueue, tick the frame hook, and assert the
        // underlying state actually drained (Count reflects the visible
        // set, not the still-pending queue) — never touching drawing.
        var root = new UiRoot { Width = 1280f, Height = 720f };
        var state = new SpewBoxState();
        using var controller = new SpewBoxController(root, new SpewBoxVM(state));

        state.Enqueue("first");
        Assert.Equal(0, state.Count); // still pending, not yet drained

        root.Tick(dt: 0d, nowMs: 100L);

        Assert.Equal(1, state.Count); // drained into the visible list
        Assert.Equal("first", state.Snapshot()[0].Text);
    }

    [Fact]
    public void Controller_QueueStaysBounded_AcrossManyTicksWithoutADrawPass()
    {
        // BLOCKER 1 acceptance (c): repeated enqueue+tick cycles must never
        // let the visible set grow past SpewBoxState.MaxConcurrentItems.
        // CH2 re-review nit 4 (docs/plans/2026-08-09-chat-parity-campaign.md):
        // corrected — MaxConcurrentItems is the shipped LayoutDesc's
        // AUTHORED value, 4, not retail's code-default of 1 (the fallback
        // gmSpewBoxUI::PostInit uses only when the property is absent; see
        // SpewBoxState.MaxConcurrentItems). This is what "unbounded
        // per-session leak" would have looked like if the drain never ran
        // at all.
        var root = new UiRoot { Width = 1280f, Height = 720f };
        var state = new SpewBoxState();
        using var controller = new SpewBoxController(root, new SpewBoxVM(state));

        for (int i = 0; i < 50; i++)
        {
            state.Enqueue($"line {i}");
            root.Tick(dt: 0d, nowMs: 1000L + i);
            Assert.True(state.Count <= SpewBoxState.MaxConcurrentItems);
        }

        UiText text = Assert.IsType<UiText>(root.Children.OfType<UiText>().Single());
        Assert.True(text.LinesProvider!().Count <= SpewBoxState.MaxConcurrentItems);
        // Newest-at-top, matching retail's InsertItem(item, 0).
        Assert.Equal("line 49", text.LinesProvider!()[0].Text);
    }

    [Fact]
    public void Controller_RenderedOrder_NewerMessageIsTheTopmostLine()
    {
        // CH2 re-review nit 3 (docs/plans/2026-08-09-chat-parity-campaign.md):
        // pins the RENDERED order, not UiText.LinesProvider's documented
        // contract (oldest-first) — SpewBoxController deliberately inverts
        // that (see Tick's ordering comment) because the box is now
        // top-aligned and retail shows the newest interface-text line on
        // top. Drives root.Tick, not the provider, matching every other
        // test in this file.
        var root = new UiRoot { Width = 1280f, Height = 720f };
        var state = new SpewBoxState();
        using var controller = new SpewBoxController(root, new SpewBoxVM(state));

        state.Enqueue("older message");
        root.Tick(dt: 0d, nowMs: 1000L);

        state.Enqueue("newer message");
        root.Tick(dt: 0d, nowMs: 1001L);

        UiText text = Assert.IsType<UiText>(root.Children.OfType<UiText>().Single());
        IReadOnlyList<UiText.Line> rendered = text.LinesProvider!();
        Assert.Equal(2, rendered.Count);
        Assert.Equal("newer message", rendered[0].Text);
        Assert.Equal("older message", rendered[1].Text);
    }

    [Fact]
    public void Dispose_RemovesBothTheTextAndTheGlobalTimeSinkFromTheRoot()
    {
        var root = new UiRoot { Width = 1280f, Height = 720f };
        var controller = new SpewBoxController(root, new SpewBoxVM(new SpewBoxState()));

        Assert.Equal(2, root.Children.Count); // UiText + the tick sink

        controller.Dispose();

        Assert.Empty(root.Children);
    }
}