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

using AcDream.App.UI;
using AcDream.App.UI.Layout;

namespace AcDream.App.Tests.UI.Layout;

/// <summary>
/// Pure unit tests for <see cref="LayoutImporter.BuildFromInfos"/> — no dats, no GL.
/// Verifies the tree-builder: widget dispatch, Type-12 skipping, and meter child consumption.
/// </summary>
public class LayoutImporterTests
{
    private static (uint, int, int) NoTex(uint _) => (0, 0, 0);

    // ── Test 1: Health meter element → UiMeter with correct rect ─────────────

    /// <summary>
    /// A Type-7 (meter) child element with X=5,Y=5,W=150,H=16 must produce a UiMeter
    /// that is findable by its id, positioned at Left=5, Width=150.
    /// The resolve lambda is a 1-arg Func&lt;uint,(uint,int,int)&gt;.
    /// </summary>
    [Fact]
    public void BuildFromInfos_HealthMeter_IsUiMeterAtRect()
    {
        var root   = new ElementInfo { Id = 0x100005F9, Type = 3, Width = 160, Height = 58 };
        var health = new ElementInfo { Id = 0x100000E6, Type = 7, X = 5, Y = 5, Width = 150, Height = 16 };

        var tree = LayoutImporter.BuildFromInfos(root, new[] { health }, NoTex, null);

        var found = tree.FindElement(0x100000E6);
        Assert.IsType<UiMeter>(found);
        Assert.Equal(5f,   found!.Left);
        Assert.Equal(150f, found.Width);
    }

    // ── Test 2: Type-12 child builds a UiText; Type-3 sibling is also present ──

    /// <summary>
    /// A root with two children: one Type-12 UIElement_Text and one Type-3 container.
    /// The Type-12 must appear as a <see cref="UiText"/> in the tree (transparent,
    /// draws nothing until a controller binds its <c>LinesProvider</c>);
    /// the Type-3 must also be present.
    /// </summary>
    [Fact]
    public void BuildFromInfos_Type12Child_IsSkipped_Type3Present()
    {
        var root      = new ElementInfo { Id = 0x10000001, Type = 3, Width = 160, Height = 58 };
        var prototype = new ElementInfo { Id = 0x20000001, Type = 12, Width = 0, Height = 0 };
        var container = new ElementInfo { Id = 0x20000002, Type = 3,  Width = 100, Height = 20 };

        var tree = LayoutImporter.BuildFromInfos(root, new[] { prototype, container }, NoTex, null);

        // Type-12 is now a UiText (transparent, no lines) — present in the tree.
        Assert.IsType<UiText>(tree.FindElement(0x20000001));
        // Type-3 must also be present.
        Assert.NotNull(tree.FindElement(0x20000002));
    }

    // ── Test 3: Meter consumes its children — child ids not in byId ──────────

    /// <summary>
    /// A meter (Type 7) whose children are the 3-slice back/front containers.
    /// The meter itself must be findable; its direct children must NOT appear as
    /// separate nodes in the tree (meters own their children, not the generic tree).
    /// </summary>
    [Fact]
    public void BuildFromInfos_MeterWithChildren_MeterPresent_ChildrenNotInTree()
    {
        const uint MeterId      = 0x100000E6u;
        const uint BackLayerId  = 0x100000E7u;
        const uint FrontLayerId = 0x00000002u;

        // Build a minimal meter with back + front containers, each with 3 slice children.
        var backContainer  = BuildSliceContainer(BackLayerId,  ReadOrder: 0,
            l: 0x0600747Eu, t: 0x0600747Fu, r: 0x06007480u);
        var frontContainer = BuildSliceContainer(FrontLayerId, ReadOrder: 1,
            l: 0x06007481u, t: 0x06007482u, r: 0x06007483u);

        var meter = new ElementInfo { Id = MeterId, Type = 7, Width = 150, Height = 16 };
        meter.Children.Add(backContainer);
        meter.Children.Add(frontContainer);

        var root = new ElementInfo { Id = 0x100005F9, Type = 3, Width = 160, Height = 58 };

        var tree = LayoutImporter.BuildFromInfos(root, new[] { meter }, NoTex, null);

        // The meter widget is present.
        Assert.IsType<UiMeter>(tree.FindElement(MeterId));
        // The meter's dat-children are NOT separate UiElement nodes.
        Assert.Null(tree.FindElement(BackLayerId));
        Assert.Null(tree.FindElement(FrontLayerId));
        // The UiMeter itself has no Ui children (meters consume their children internally).
        var uiMeter = (UiMeter)tree.FindElement(MeterId)!;
        Assert.Empty(uiMeter.Children);
    }

    // ── Test 4: Prototype-skip in BuildFromInfos ─────────────────────────────

    /// <summary>
    /// When one top-level element is referenced as a BaseElement by a sibling
    /// (mirroring the toolbar slot prototype pattern), and the prototype element
    /// has no own state media, the importer must NOT produce a widget for the
    /// prototype id (FindElement returns null), but MUST produce the derived element.
    ///
    /// NOTE: This test exercises <see cref="LayoutImporter.BuildFromInfos"/> (the pure
    /// layer), where prototype detection is done by inspecting the pre-resolved
    /// ElementInfo tree rather than the raw dat ElementDesc. The pure layer skips
    /// an element if its Id is in a sibling's (or child's) <c>Children</c> chain
    /// as a BaseElement — but actually the pure layer has no BaseElement knowledge
    /// at this stage (that's resolved before Build). The prototype-skip in the real
    /// world occurs in <c>ImportInfos</c> (the dat shell), BEFORE calling Build.
    ///
    /// This test verifies the INVARIANT that holds AFTER ImportInfos filters prototypes:
    /// a pure template element that was skipped is absent from FindElement, while the
    /// derived element (which inherited from it) IS present.
    ///
    /// We model this by simply NOT adding the prototype to the ElementInfo tree passed
    /// to BuildFromInfos — as if ImportInfos already filtered it out.
    /// </summary>
    [Fact]
    public void BuildFromInfos_PrototypeSkipped_DerivedPresent_PrototypeAbsent()
    {
        // Simulate what ImportInfos does AFTER filtering: the prototype 0xBBB00001 is
        // absent (already skipped by ImportInfos), the derived element 0xCCC00001 is
        // present with its own media inherited from the prototype.
        var root    = new ElementInfo { Id = 0x10000001, Type = 3, Width = 200, Height = 100 };
        // The derived element has its own size + media (prototype was merged into it already).
        var derived = new ElementInfo
        {
            Id = 0xCCC00001u,
            Type = 0x10000031u, // UIElement_ItemList (toolbar slot type)
            X = 10, Y = 10, Width = 32, Height = 32,
        };
        derived.StateMedia[""] = (0x06001234u, 1);

        // Only the derived element appears in the tree (prototype was filtered by ImportInfos).
        var tree = LayoutImporter.BuildFromInfos(root, new[] { derived }, NoTex, null);

        // The derived element is present in the built tree.
        Assert.NotNull(tree.FindElement(0xCCC00001u));
        // The prototype id is NOT in the tree (was never added).
        Assert.Null(tree.FindElement(0xBBB00001u));
    }

    // ── Helpers ───────────────────────────────────────────────────────────────

    private static ElementInfo BuildSliceContainer(uint id, uint ReadOrder, uint l, uint t, uint r)
    {
        var c = new ElementInfo { Id = id, Type = 3, ReadOrder = ReadOrder };
        c.Children.Add(new ElementInfo { X = 0,   StateMedia = { [""] = (l, 1) } });
        c.Children.Add(new ElementInfo { X = 10,  StateMedia = { [""] = (t, 1) } });
        c.Children.Add(new ElementInfo { X = 140, StateMedia = { [""] = (r, 1) } });
        return c;
    }
}