acdream/tests/AcDream.App.Tests/UI/Layout/OP2ReworkBlastRadiusConformanceTests.cs

using System.IO;
using System.Text.Json;
using AcDream.App.UI;
using AcDream.App.UI.Layout;

namespace AcDream.App.Tests.UI.Layout;

/// <summary>
/// Built-widget behavior pins for the pre-existing, already-shipped Type-8/Type-5
/// elements the OP2 double-REJECT findings named
/// (`docs/research/2026-08-11-op2-review-blast.md` §1.1/§1.2,
/// `docs/research/2026-08-11-op2-review-mechanism.md` §2.1/§2.2). These fixtures are
/// NOT Options-panel data — they are the character sheet, spellbook, vendor, and
/// combat panels' own committed fixtures — and every assertion here is a regression
/// guard for the OP2 rework's dormancy model: a Type-8/Type-5 element that reaches
/// <see cref="DatWidgetFactory"/> without a controller opting it into the new
/// mechanism must render and hit-test EXACTLY like the pre-OP2
/// <see cref="UiDatElement"/> fallback.
///
/// <para>
/// Before this rework, these five Type-8 elements and every pre-existing Type-5
/// element silently re-classed to a bare-<see cref="UiElement"/>-derived
/// <c>UiTabControl</c>/<c>UiTemplateListBox</c> in production while every fixture-
/// driven test still exercised the OLD stale-fixture shape (empty TabTable/
/// TemplateList) — a structural false negative the blast-radius review named as the
/// root enabler. These tests build through the REAL (regenerated) fixtures, so a
/// future regression that reintroduces eager wiring, media loss, or a ClickThrough
/// flip WILL fail here.
/// </para>
/// </summary>
public class OP2ReworkBlastRadiusConformanceTests
{
    // ── Type 8 — vendor's media-bearing, tab-table-less backdrop ────────────

    /// <summary>
    /// Vendor `0x1000008D` (800x20) authors a DirectState fill and NO tab table —
    /// `RetailUiRuntime.cs` documents it by name as the vendor panel's own backdrop
    /// fill. Blast-review MUST-FIX 1(a): the OP2-as-landed unconditional-but-bare
    /// mapping stopped this drawing entirely.
    /// </summary>
    [Fact]
    public void Vendor_BackdropElement_DrawsItsAuthoredMedia_AndStaysClickThrough()
    {
        var layout = FixtureLoader.LoadVendor();
        var backdrop = Assert.IsType<UiTabPanel>(layout.FindElement(0x1000008Du));

        Assert.Empty(backdrop.Tabs); // no authored 0x2E on this element
        Assert.False(backdrop.BehaviorActive); // nobody activates it — dormant
        Assert.True(backdrop.ClickThrough); // UiDatElement's generic-decoration default
        (uint file, int _) = backdrop.ActiveMedia();
        Assert.NotEqual(0u, file); // the authored fill still draws
    }

    /// <summary>
    /// Vendor `0x100000B8` (the ACTUAL tab host, distinct from the `0x1000008D`
    /// backdrop above) authors a 3-entry tab table that `VendorUiController`
    /// already switches end-to-end. Same claim as the character/spellbook roots
    /// below: dormant on import, controller owns activation.
    /// </summary>
    [Fact]
    public void Vendor_TabHost_StaysDormant_ControllerOwnsSwitching()
    {
        var layout = FixtureLoader.LoadVendor();
        var host = Assert.IsType<UiTabPanel>(layout.FindElement(0x100000B8u));

        Assert.Equal(3, host.Tabs.Count); // the authored table IS present…
        Assert.False(host.BehaviorActive); // …but nobody has activated it
        Assert.Equal(0u, host.ActivePageElementId);
        Assert.True(host.ClickThrough);
    }

    /// <summary>
    /// Blast review SHOULD-FIX 3 / NOTE 2 (2026-08-11 fix round): AD-73's
    /// dormancy contract is that a Type-8 host with an authored tab table
    /// performs NO switching until a controller calls
    /// <see cref="UiTabPanel.ActivateTabBehavior"/> — but nothing had pinned
    /// <see cref="UiTabPanel.ActivePageChanged"/> ITSELF against a dormant
    /// host (as opposed to <c>BehaviorActive</c>/<c>ActivePageElementId</c>,
    /// which the test above already covers). <c>SwitchTo</c> is public and
    /// its own doc invites a future direct call, so this guards the CURRENT
    /// dormant-by-default contract, not <c>SwitchTo</c> itself.
    /// </summary>
    [Fact]
    public void Vendor_TabHost_DormantHost_NeverRaisesActivePageChanged()
    {
        var layout = FixtureLoader.LoadVendor();
        var host = Assert.IsType<UiTabPanel>(layout.FindElement(0x100000B8u));
        int raised = 0;
        host.ActivePageChanged += (_, _) => raised++;

        Assert.False(host.BehaviorActive);

        // R3 (OP3 re-review, 2026-08-11): a subscribe-then-assert-zero pin
        // passes even with dormancy fully broken. The REAL dormancy
        // mechanism is that ActivateTabBehavior (via RetailTabBinding.
        // SetClick) was never called, so the authored tab BUTTONS carry no
        // click handler — clicking a dormant host's tab can invoke nothing.
        // SwitchTo itself deliberately has no dormancy guard (a controller
        // may drive it directly), so the button wiring IS the contract.
        foreach (UiTabTableEntry tab in host.Tabs)
        {
            var button = layout.FindElement(tab.ButtonElementId);
            Assert.NotNull(button);
            Assert.False(button!.HandlesClick,
                $"dormant tab button 0x{tab.ButtonElementId:X8} has a click "
                + "handler — import-time activation regressed (AD-73)");
        }
        Assert.Equal(0, raised);
    }

    // ── Type 8 — panel roots with their own controller-owned switching ──────

    /// <summary>
    /// Character sheet root `0x10000227` authors a 3-entry tab table but
    /// `CharacterStatController` already owns tab switching for this panel
    /// end-to-end. Blast-review MUST-FIX 1(b)/(c): the OP2-as-landed mapping made
    /// this element claim every unclaimed click in its bounds
    /// (<c>ClickThrough</c> false→ silently) and stop propagating
    /// <see cref="IUiDatStateful"/> state into its children.
    /// </summary>
    [Fact]
    public void CharacterRoot_StaysClickThrough_AndPropagatesState_WithoutActivation()
    {
        var layout = FixtureLoader.LoadCharacter();
        var root = Assert.IsType<UiTabPanel>(layout.Root);
        Assert.Equal(0x10000227u, root.DatElementId);

        Assert.NotEmpty(root.Tabs); // the authored table IS present…
        Assert.False(root.BehaviorActive); // …but nobody has activated it
        Assert.Equal(0u, root.ActivePageElementId);
        Assert.True(root.ClickThrough);
        Assert.IsAssignableFrom<IUiDatStateful>(root);
    }

    /// <summary>Spellbook root `0x100002A8` — same shape/claim as the character
    /// sheet, owned end-to-end by <c>SpellbookWindowController</c>.</summary>
    [Fact]
    public void SpellbookRoot_StaysClickThrough_AndPropagatesState_WithoutActivation()
    {
        var layout = FixtureLoader.LoadSpellbook();
        var root = Assert.IsType<UiTabPanel>(layout.Root);
        Assert.Equal(0x100002A8u, root.DatElementId);

        Assert.NotEmpty(root.Tabs);
        Assert.False(root.BehaviorActive);
        Assert.Equal(0u, root.ActivePageElementId);
        Assert.True(root.ClickThrough);
        Assert.IsAssignableFrom<IUiDatStateful>(root);
    }

    // ── Type 8 — combat, which has NO controller re-binder at all ───────────

    /// <summary>
    /// Combat `0x100000A2` authors an 8-entry tab table and — unlike character/
    /// spellbook/vendor — has NO controller that re-binds it after import. Blast-
    /// review MUST-FIX 1(d): the OP2-as-landed <c>OnChildrenAttached</c> ran at
    /// import time regardless, so this element would have taken over its 8 stance
    /// pages outright with nothing to override it. Every child must remain exactly
    /// as imported: all Visible (retail's plain default), no page hidden, no click
    /// bound.
    /// </summary>
    [Fact]
    public void Combat_TabHost_PerformsNoImportTimeTakeover()
    {
        var layout = FixtureLoader.LoadCombat();
        var host = Assert.IsType<UiTabPanel>(layout.FindElement(0x100000A2u));

        Assert.Equal(8, host.Tabs.Count); // the authored table IS present…
        Assert.False(host.BehaviorActive); // …but nothing ever activates it
        Assert.Equal(0u, host.ActivePageElementId);
        Assert.Equal(16, host.Children.Count); // no children lost/consumed
        Assert.All(host.Children, child => Assert.True(child.Visible));
    }

    // ── Type 5 — a representative pre-existing ListBox with an authored template ──

    /// <summary>
    /// Effects list `0x10000123` (`EffectsUiController.ListId`) authors a 1-row
    /// template array. Blast-review MUST-FIX 2: the OP2-as-landed unconditional
    /// mapping lost the authored media, defaulted <c>ClickThrough=false</c>, and
    /// unconditionally injected a hit-testable viewport as child 0 — before
    /// <c>EffectsUiController.Bind</c> ever runs. This pins the dormant baseline
    /// directly; <c>EffectsUiControllerTests</c> pins the controller's own
    /// subsequent <see cref="UiElement.AddChild"/> behavior.
    /// </summary>
    [Fact]
    public void EffectsList_StaysDormant_ClickThrough_NoInjectedViewport()
    {
        var layout = FixtureLoader.LoadPositiveEffects();
        var host = Assert.IsType<UiTemplateListBox>(
            layout.FindElement(EffectsUiController.ListId));

        Assert.NotEmpty(host.Templates); // the authored 0x64 array IS present…
        Assert.Empty(host.Children); // …but no viewport was injected
        Assert.Equal(0, host.ContentHeight);
        Assert.True(host.ClickThrough);
    }

    /// <summary>
    /// AD-73 addendum (OP2 re-review closure, 2026-08-11):
    /// <see cref="UiTemplateListBox.ConsumesDatChildren"/> is <c>true</c> where the
    /// pre-rework generic fallback's was not. That delta drops nothing ONLY while no
    /// authored Type-5 element carries children — a premise the re-review verified by
    /// hand across all 32 fixtures. This test turns that manual sweep into a build
    /// gate: if a future DAT regeneration surfaces a Type-5 element WITH authored
    /// children, this fails loudly instead of the children silently vanishing.
    /// </summary>
    [Fact]
    public void EveryAuthoredType5Element_HasZeroChildren_AcrossAllFixtures()
    {
        string fixturesDir = Path.Combine(
            AppContext.BaseDirectory, "UI", "Layout", "fixtures");
        string[] fixtures = Directory.GetFiles(fixturesDir, "*.json");
        Assert.NotEmpty(fixtures);

        var opts = new JsonSerializerOptions { IncludeFields = true };
        int type5Seen = 0;
        foreach (string file in fixtures)
        {
            var root = JsonSerializer.Deserialize<ElementInfo>(
                File.ReadAllText(file), opts);
            Assert.NotNull(root);
            Walk(root!, file);
        }

        // The premise is only meaningful if the sweep actually saw Type-5
        // elements (16 across the current fixture set).
        Assert.True(type5Seen >= 10, $"sweep saw only {type5Seen} Type-5 elements");

        void Walk(ElementInfo node, string file)
        {
            if (node.Type == 5u)
            {
                type5Seen++;
                Assert.True(
                    node.Children.Count == 0,
                    $"{Path.GetFileName(file)}: Type-5 element 0x{node.Id:X8} authors "
                    + $"{node.Children.Count} children — UiTemplateListBox.ConsumesDatChildren "
                    + "would drop them; see AD-73's addendum.");
            }
            foreach (ElementInfo child in node.Children)
                Walk(child, file);
        }
    }
}