XCEngine/tests/Core/UI/test_ui_runtime.cpp

#include <gtest/gtest.h>

#include <XCEngine/UI/Runtime/UIScreenDocumentHost.h>
#include <XCEngine/UI/Runtime/UIScreenPlayer.h>
#include <XCEngine/UI/Runtime/UISceneRuntimeContext.h>
#include <XCEngine/UI/Runtime/UIScreenStackController.h>
#include <XCEngine/UI/Runtime/UISystem.h>

#include <chrono>
#include <filesystem>
#include <fstream>
#include <limits>
#include <string>
#include <vector>

namespace {

using XCEngine::UI::Runtime::UIScreenAsset;
using XCEngine::UI::Runtime::UIScreenFrameInput;
using XCEngine::UI::Runtime::UIScreenPlayer;
using XCEngine::UI::Runtime::UISceneRuntimeContext;
using XCEngine::UI::Runtime::UIDocumentScreenHost;
using XCEngine::UI::Runtime::UIScreenStackController;
using XCEngine::UI::Runtime::UISystem;

namespace fs = std::filesystem;

class TempFileScope {
public:
    TempFileScope(std::string stem, std::string extension, std::string contents) {
        const auto uniqueId = std::to_string(
            std::chrono::steady_clock::now().time_since_epoch().count());
        m_path = fs::temp_directory_path() / (std::move(stem) + "_" + uniqueId + std::move(extension));
        std::ofstream output(m_path, std::ios::binary | std::ios::trunc);
        output << contents;
    }

    ~TempFileScope() {
        std::error_code ec;
        fs::remove(m_path, ec);
    }

    const fs::path& Path() const {
        return m_path;
    }

private:
    fs::path m_path = {};
};

std::string BuildViewMarkup(const char* heroTitle, const char* overlayText = nullptr) {
    std::string markup =
        "<View name=\"Runtime Screen\">\n"
        "  <Column id=\"root\" padding=\"18\" gap=\"10\">\n"
        "    <Card id=\"hero\" title=\"" + std::string(heroTitle) + "\" subtitle=\"Shared XCUI runtime layer\" />\n"
        "    <Text id=\"status\" text=\"Ready for play\" />\n"
        "    <Row id=\"actions\" gap=\"12\">\n"
        "      <Button id=\"start\" text=\"Start\" />\n"
        "      <Button id=\"options\" text=\"Options\" />\n"
        "    </Row>\n";
    if (overlayText != nullptr) {
        markup += "    <Card id=\"overlay\" title=\"" + std::string(overlayText) + "\" tone=\"accent\" />\n";
    }
    markup +=
        "  </Column>\n"
        "</View>\n";
    return markup;
}

UIScreenAsset BuildScreenAsset(const fs::path& viewPath, const char* screenId) {
    UIScreenAsset screen = {};
    screen.screenId = screenId;
    screen.documentPath = viewPath.string();
    return screen;
}

bool DrawDataContainsText(
    const XCEngine::UI::UIDrawData& drawData,
    const std::string& text) {
    for (const XCEngine::UI::UIDrawList& drawList : drawData.GetDrawLists()) {
        for (const XCEngine::UI::UIDrawCommand& command : drawList.GetCommands()) {
            if (command.type == XCEngine::UI::UIDrawCommandType::Text &&
                command.text == text) {
                return true;
            }
        }
    }

    return false;
}

std::vector<XCEngine::UI::UIRect> CollectFilledRects(
    const XCEngine::UI::UIDrawData& drawData) {
    std::vector<XCEngine::UI::UIRect> rects = {};
    for (const XCEngine::UI::UIDrawList& drawList : drawData.GetDrawLists()) {
        for (const XCEngine::UI::UIDrawCommand& command : drawList.GetCommands()) {
            if (command.type == XCEngine::UI::UIDrawCommandType::FilledRect) {
                rects.push_back(command.rect);
            }
        }
    }

    return rects;
}

const XCEngine::UI::UIDrawCommand* FindTextCommand(
    const XCEngine::UI::UIDrawData& drawData,
    const std::string& text) {
    for (const XCEngine::UI::UIDrawList& drawList : drawData.GetDrawLists()) {
        for (const XCEngine::UI::UIDrawCommand& command : drawList.GetCommands()) {
            if (command.type == XCEngine::UI::UIDrawCommandType::Text &&
                command.text == text) {
                return &command;
            }
        }
    }

    return nullptr;
}

bool RectContainsPoint(
    const XCEngine::UI::UIRect& rect,
    const XCEngine::UI::UIPoint& point) {
    return point.x >= rect.x &&
        point.x <= rect.x + rect.width &&
        point.y >= rect.y &&
        point.y <= rect.y + rect.height;
}

bool TryFindSmallestFilledRectContainingPoint(
    const XCEngine::UI::UIDrawData& drawData,
    const XCEngine::UI::UIPoint& point,
    XCEngine::UI::UIRect& outRect) {
    bool found = false;
    float bestArea = (std::numeric_limits<float>::max)();

    for (const XCEngine::UI::UIDrawList& drawList : drawData.GetDrawLists()) {
        for (const XCEngine::UI::UIDrawCommand& command : drawList.GetCommands()) {
            if (command.type != XCEngine::UI::UIDrawCommandType::FilledRect ||
                !RectContainsPoint(command.rect, point)) {
                continue;
            }

            const float area = command.rect.width * command.rect.height;
            if (!found || area < bestArea) {
                outRect = command.rect;
                bestArea = area;
                found = true;
            }
        }
    }

    return found;
}

bool TryFindFilledRectForText(
    const XCEngine::UI::UIDrawData& drawData,
    const std::string& text,
    XCEngine::UI::UIRect& outRect) {
    const auto* textCommand = FindTextCommand(drawData, text);
    return textCommand != nullptr &&
        TryFindSmallestFilledRectContainingPoint(drawData, textCommand->position, outRect);
}

XCEngine::UI::UIPoint GetRectCenter(const XCEngine::UI::UIRect& rect) {
    return XCEngine::UI::UIPoint(
        rect.x + rect.width * 0.5f,
        rect.y + rect.height * 0.5f);
}

std::size_t CountCommandsOfType(
    const XCEngine::UI::UIDrawData& drawData,
    XCEngine::UI::UIDrawCommandType type) {
    std::size_t count = 0u;
    for (const XCEngine::UI::UIDrawList& drawList : drawData.GetDrawLists()) {
        for (const XCEngine::UI::UIDrawCommand& command : drawList.GetCommands()) {
            if (command.type == type) {
                ++count;
            }
        }
    }

    return count;
}

UIScreenFrameInput BuildInputState(std::uint64_t frameIndex = 1u) {
    UIScreenFrameInput input = {};
    input.viewportRect = XCEngine::UI::UIRect(0.0f, 0.0f, 800.0f, 480.0f);
    input.frameIndex = frameIndex;
    input.focused = true;
    return input;
}

const XCEngine::UI::Runtime::UISystemPresentedLayer* FindPresentedLayerById(
    const XCEngine::UI::Runtime::UISystemFrameResult& frame,
    XCEngine::UI::Runtime::UIScreenLayerId layerId) {
    for (const XCEngine::UI::Runtime::UISystemPresentedLayer& layer : frame.layers) {
        if (layer.layerId == layerId) {
            return &layer;
        }
    }

    return nullptr;
}

class RecordingDocumentHost final : public XCEngine::UI::Runtime::IUIScreenDocumentHost {
public:
    struct BuildCall {
        std::string displayName = {};
        UIScreenFrameInput input = {};
    };

    XCEngine::UI::Runtime::UIScreenLoadResult LoadScreen(const UIScreenAsset& asset) override {
        XCEngine::UI::Runtime::UIScreenLoadResult result = {};
        result.succeeded = asset.IsValid();
        result.document.sourcePath = asset.documentPath;
        result.document.displayName = asset.screenId.empty() ? asset.documentPath : asset.screenId;
        return result;
    }

    XCEngine::UI::Runtime::UIScreenFrameResult BuildFrame(
        const XCEngine::UI::Runtime::UIScreenDocument& document,
        const UIScreenFrameInput& input) override {
        m_buildCalls.push_back(BuildCall{ document.displayName, input });

        XCEngine::UI::Runtime::UIScreenFrameResult result = {};
        result.stats.documentLoaded = true;
        result.stats.inputEventCount = input.events.size();
        result.stats.presentedFrameIndex = input.frameIndex;
        XCEngine::UI::UIDrawList& drawList = result.drawData.EmplaceDrawList(document.displayName);
        drawList.AddText(
            XCEngine::UI::UIPoint(input.viewportRect.x, input.viewportRect.y),
            document.displayName);
        result.stats.drawListCount = result.drawData.GetDrawListCount();
        result.stats.commandCount = result.drawData.GetTotalCommandCount();
        return result;
    }

    const BuildCall* FindBuildCall(const std::string& displayName) const {
        for (const BuildCall& call : m_buildCalls) {
            if (call.displayName == displayName) {
                return &call;
            }
        }

        return nullptr;
    }

    std::size_t GetBuildCallCount() const {
        return m_buildCalls.size();
    }

private:
    std::vector<BuildCall> m_buildCalls = {};
};

} // namespace

TEST(UIRuntimeTest, ScreenPlayerBuildsDrawDataFromDocumentTree) {
    TempFileScope viewFile("xcui_runtime_screen", ".xcui", BuildViewMarkup("Runtime HUD"));
    UIDocumentScreenHost host = {};
    UIScreenPlayer player(host);

    ASSERT_TRUE(player.Load(BuildScreenAsset(viewFile.Path(), "runtime.main_menu")));

    const auto& frame = player.Update(BuildInputState());
    EXPECT_TRUE(frame.stats.documentLoaded);
    EXPECT_EQ(frame.stats.nodeCount, 7u);
    EXPECT_EQ(frame.stats.drawListCount, frame.drawData.GetDrawListCount());
    EXPECT_EQ(frame.stats.commandCount, frame.drawData.GetTotalCommandCount());
    EXPECT_GE(frame.stats.textCommandCount, 5u);
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Runtime HUD"));
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Ready for play"));
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Start"));
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Options"));
    EXPECT_EQ(player.GetPresentedFrameCount(), 1u);
}

TEST(UIRuntimeTest, DocumentHostStretchesColumnChildrenAcrossCrossAxis) {
    TempFileScope viewFile(
        "xcui_runtime_stretch_column",
        ".xcui",
        "<View name=\"Stretch Column\">\n"
        "  <Column padding=\"18\" gap=\"10\">\n"
        "    <Button text=\"Wide Button\" />\n"
        "  </Column>\n"
        "</View>\n");
    UIDocumentScreenHost host = {};
    UIScreenPlayer player(host);

    ASSERT_TRUE(player.Load(BuildScreenAsset(viewFile.Path(), "runtime.stretch.column")));

    UIScreenFrameInput input = BuildInputState();
    input.viewportRect = XCEngine::UI::UIRect(0.0f, 0.0f, 400.0f, 220.0f);
    const auto& frame = player.Update(input);
    const auto* buttonText = FindTextCommand(frame.drawData, "Wide Button");
    ASSERT_NE(buttonText, nullptr);

    XCEngine::UI::UIRect buttonRect = {};
    ASSERT_TRUE(TryFindSmallestFilledRectContainingPoint(frame.drawData, buttonText->position, buttonRect));
    EXPECT_FLOAT_EQ(buttonRect.x, 34.0f);
    EXPECT_FLOAT_EQ(buttonRect.width, 332.0f);
}

TEST(UIRuntimeTest, DocumentHostDoesNotLetExplicitHeightCrushCardContent) {
    TempFileScope viewFile(
        "xcui_runtime_card_height_floor",
        ".xcui",
        "<View name=\"Card Height Floor\">\n"
        "  <Column padding=\"18\" gap=\"10\">\n"
        "    <Card title=\"Hero\" subtitle=\"Subtitle\" height=\"32\">\n"
        "      <Row gap=\"10\">\n"
        "        <Button text=\"Action\" />\n"
        "      </Row>\n"
        "    </Card>\n"
        "  </Column>\n"
        "</View>\n");
    UIDocumentScreenHost host = {};
    UIScreenPlayer player(host);

    ASSERT_TRUE(player.Load(BuildScreenAsset(viewFile.Path(), "runtime.card.height.floor")));

    UIScreenFrameInput input = BuildInputState();
    input.viewportRect = XCEngine::UI::UIRect(0.0f, 0.0f, 500.0f, 300.0f);
    const auto& frame = player.Update(input);
    const auto* heroTitle = FindTextCommand(frame.drawData, "Hero");
    const auto* actionText = FindTextCommand(frame.drawData, "Action");
    ASSERT_NE(heroTitle, nullptr);
    ASSERT_NE(actionText, nullptr);

    XCEngine::UI::UIRect cardRect = {};
    XCEngine::UI::UIRect buttonRect = {};
    ASSERT_TRUE(TryFindSmallestFilledRectContainingPoint(frame.drawData, heroTitle->position, cardRect));
    ASSERT_TRUE(TryFindSmallestFilledRectContainingPoint(frame.drawData, actionText->position, buttonRect));

    EXPECT_GT(cardRect.height, 32.0f);
    EXPECT_GE(buttonRect.y, cardRect.y + 50.0f);
    EXPECT_LE(buttonRect.y + buttonRect.height, cardRect.y + cardRect.height - 8.0f);
}

TEST(UIRuntimeTest, DocumentHostScrollViewClipsOverflowingChildrenAndRespondsToWheelInput) {
    TempFileScope viewFile(
        "xcui_runtime_scroll_view",
        ".xcui",
        "<View name=\"Scroll View Test\">\n"
        "  <Column padding=\"18\" gap=\"10\">\n"
        "    <Card title=\"Console\" subtitle=\"Scroll smoke\" height=\"200\">\n"
        "      <ScrollView id=\"log-scroll\" height=\"fill\">\n"
        "        <Column gap=\"8\">\n"
        "          <Text text=\"Line 01\" />\n"
        "          <Text text=\"Line 02\" />\n"
        "          <Text text=\"Line 03\" />\n"
        "          <Text text=\"Line 04\" />\n"
        "          <Text text=\"Line 05\" />\n"
        "          <Text text=\"Line 06\" />\n"
        "          <Text text=\"Line 07\" />\n"
        "          <Text text=\"Line 08\" />\n"
        "          <Text text=\"Line 09\" />\n"
        "          <Text text=\"Line 10\" />\n"
        "          <Text text=\"Line 11\" />\n"
        "          <Text text=\"Line 12\" />\n"
        "        </Column>\n"
        "      </ScrollView>\n"
        "    </Card>\n"
        "  </Column>\n"
        "</View>\n");
    UIDocumentScreenHost host = {};
    UIScreenPlayer player(host);

    ASSERT_TRUE(player.Load(BuildScreenAsset(viewFile.Path(), "runtime.scroll.view")));

    UIScreenFrameInput firstInput = BuildInputState(1u);
    firstInput.viewportRect = XCEngine::UI::UIRect(0.0f, 0.0f, 480.0f, 320.0f);
    const auto& firstFrame = player.Update(firstInput);
    const auto* line01Before = FindTextCommand(firstFrame.drawData, "Line 01");
    ASSERT_NE(line01Before, nullptr);
    const float line01BeforeY = line01Before->position.y;
    EXPECT_GT(CountCommandsOfType(firstFrame.drawData, XCEngine::UI::UIDrawCommandType::PushClipRect), 0u);
    EXPECT_GT(CountCommandsOfType(firstFrame.drawData, XCEngine::UI::UIDrawCommandType::PopClipRect), 0u);

    UIScreenFrameInput secondInput = BuildInputState(2u);
    secondInput.viewportRect = firstInput.viewportRect;
    XCEngine::UI::UIInputEvent wheelEvent = {};
    wheelEvent.type = XCEngine::UI::UIInputEventType::PointerWheel;
    wheelEvent.position = XCEngine::UI::UIPoint(90.0f, 130.0f);
    wheelEvent.wheelDelta = -120.0f;
    secondInput.events.push_back(wheelEvent);
    const auto& secondFrame = player.Update(secondInput);
    const auto* line01After = FindTextCommand(secondFrame.drawData, "Line 01");
    ASSERT_NE(line01After, nullptr);
    const float line01AfterY = line01After->position.y;
    EXPECT_LT(line01AfterY, line01BeforeY);

    UIScreenFrameInput thirdInput = BuildInputState(3u);
    thirdInput.viewportRect = firstInput.viewportRect;
    const auto& thirdFrame = player.Update(thirdInput);
    const auto* line01Persisted = FindTextCommand(thirdFrame.drawData, "Line 01");
    ASSERT_NE(line01Persisted, nullptr);
    EXPECT_FLOAT_EQ(line01Persisted->position.y, line01AfterY);
}

TEST(UIRuntimeTest, DocumentHostTracksHoverFocusAndPointerCaptureAcrossFrames) {
    TempFileScope viewFile(
        "xcui_runtime_input_states",
        ".xcui",
        "<View name=\"Input State Test\">\n"
        "  <Column padding=\"18\" gap=\"10\">\n"
        "    <Button id=\"input-hover\" text=\"Hover / Focus\" />\n"
        "    <Button id=\"input-capture\" text=\"Pointer Capture\" capturePointer=\"true\" />\n"
        "    <Button id=\"input-route\" text=\"Route Target\" />\n"
        "  </Column>\n"
        "</View>\n");
    UIDocumentScreenHost host = {};
    UIScreenPlayer player(host);

    ASSERT_TRUE(player.Load(BuildScreenAsset(viewFile.Path(), "runtime.input.states")));

    UIScreenFrameInput firstInput = BuildInputState(1u);
    firstInput.viewportRect = XCEngine::UI::UIRect(0.0f, 0.0f, 520.0f, 260.0f);
    const auto& firstFrame = player.Update(firstInput);
    const auto* hoverButtonText = FindTextCommand(firstFrame.drawData, "Hover / Focus");
    const auto* captureButtonText = FindTextCommand(firstFrame.drawData, "Pointer Capture");
    const auto* routeButtonText = FindTextCommand(firstFrame.drawData, "Route Target");
    ASSERT_NE(hoverButtonText, nullptr);
    ASSERT_NE(captureButtonText, nullptr);
    ASSERT_NE(routeButtonText, nullptr);

    XCEngine::UI::UIRect hoverButtonRect = {};
    XCEngine::UI::UIRect captureButtonRect = {};
    XCEngine::UI::UIRect routeButtonRect = {};
    ASSERT_TRUE(TryFindFilledRectForText(firstFrame.drawData, "Hover / Focus", hoverButtonRect));
    ASSERT_TRUE(TryFindFilledRectForText(firstFrame.drawData, "Pointer Capture", captureButtonRect));
    ASSERT_TRUE(TryFindFilledRectForText(firstFrame.drawData, "Route Target", routeButtonRect));

    const XCEngine::UI::UIPoint hoverButtonPoint = GetRectCenter(hoverButtonRect);
    const XCEngine::UI::UIPoint captureButtonPoint = GetRectCenter(captureButtonRect);
    const XCEngine::UI::UIPoint routeButtonPoint = GetRectCenter(routeButtonRect);

    SCOPED_TRACE(
        std::string("hoverPos=") + std::to_string(hoverButtonText->position.x) + "," + std::to_string(hoverButtonText->position.y) +
        " hoverRect=" + std::to_string(hoverButtonRect.x) + "," + std::to_string(hoverButtonRect.y) + "," +
        std::to_string(hoverButtonRect.width) + "," + std::to_string(hoverButtonRect.height) +
        " capturePos=" + std::to_string(captureButtonText->position.x) + "," + std::to_string(captureButtonText->position.y) +
        " captureRect=" + std::to_string(captureButtonRect.x) + "," + std::to_string(captureButtonRect.y) + "," +
        std::to_string(captureButtonRect.width) + "," + std::to_string(captureButtonRect.height) +
        " routePos=" + std::to_string(routeButtonText->position.x) + "," + std::to_string(routeButtonText->position.y) +
        " routeRect=" + std::to_string(routeButtonRect.x) + "," + std::to_string(routeButtonRect.y) + "," +
        std::to_string(routeButtonRect.width) + "," + std::to_string(routeButtonRect.height));

    UIScreenFrameInput hoverInput = BuildInputState(2u);
    hoverInput.viewportRect = firstInput.viewportRect;
    XCEngine::UI::UIInputEvent hoverEvent = {};
    hoverEvent.type = XCEngine::UI::UIInputEventType::PointerMove;
    hoverEvent.position = hoverButtonPoint;
    hoverInput.events.push_back(hoverEvent);
    player.Update(hoverInput);
    const auto& afterHover = host.GetInputDebugSnapshot();
    EXPECT_NE(afterHover.hoveredStateKey.find("/input-hover"), std::string::npos);
    EXPECT_TRUE(afterHover.focusedStateKey.empty());

    UIScreenFrameInput captureDownInput = BuildInputState(3u);
    captureDownInput.viewportRect = firstInput.viewportRect;
    XCEngine::UI::UIInputEvent captureDownEvent = {};
    captureDownEvent.type = XCEngine::UI::UIInputEventType::PointerButtonDown;
    captureDownEvent.pointerButton = XCEngine::UI::UIPointerButton::Left;
    captureDownEvent.position = captureButtonPoint;
    captureDownInput.events.push_back(captureDownEvent);
    player.Update(captureDownInput);
    const auto& afterCaptureDown = host.GetInputDebugSnapshot();
    SCOPED_TRACE(
        std::string("afterCaptureDown hovered=") + afterCaptureDown.hoveredStateKey +
        " focused=" + afterCaptureDown.focusedStateKey +
        " active=" + afterCaptureDown.activeStateKey +
        " capture=" + afterCaptureDown.captureStateKey +
        " lastKind=" + afterCaptureDown.lastTargetKind +
        " lastTarget=" + afterCaptureDown.lastTargetStateKey +
        " result=" + afterCaptureDown.lastResult);
    EXPECT_NE(afterCaptureDown.focusedStateKey.find("/input-capture"), std::string::npos);
    EXPECT_NE(afterCaptureDown.activeStateKey.find("/input-capture"), std::string::npos);
    EXPECT_NE(afterCaptureDown.captureStateKey.find("/input-capture"), std::string::npos);

    UIScreenFrameInput dragInput = BuildInputState(4u);
    dragInput.viewportRect = firstInput.viewportRect;
    XCEngine::UI::UIInputEvent dragEvent = {};
    dragEvent.type = XCEngine::UI::UIInputEventType::PointerMove;
    dragEvent.position = routeButtonPoint;
    dragInput.events.push_back(dragEvent);
    player.Update(dragInput);
    const auto& afterDrag = host.GetInputDebugSnapshot();
    SCOPED_TRACE(
        std::string("afterDrag hovered=") + afterDrag.hoveredStateKey +
        " focused=" + afterDrag.focusedStateKey +
        " active=" + afterDrag.activeStateKey +
        " capture=" + afterDrag.captureStateKey +
        " lastKind=" + afterDrag.lastTargetKind +
        " lastTarget=" + afterDrag.lastTargetStateKey +
        " result=" + afterDrag.lastResult);
    EXPECT_NE(afterDrag.hoveredStateKey.find("/input-route"), std::string::npos);
    EXPECT_NE(afterDrag.captureStateKey.find("/input-capture"), std::string::npos);
    EXPECT_EQ(afterDrag.lastTargetKind, "Captured");
    EXPECT_NE(afterDrag.lastTargetStateKey.find("/input-capture"), std::string::npos);

    UIScreenFrameInput releaseInput = BuildInputState(5u);
    releaseInput.viewportRect = firstInput.viewportRect;
    XCEngine::UI::UIInputEvent releaseEvent = {};
    releaseEvent.type = XCEngine::UI::UIInputEventType::PointerButtonUp;
    releaseEvent.pointerButton = XCEngine::UI::UIPointerButton::Left;
    releaseEvent.position = routeButtonPoint;
    releaseInput.events.push_back(releaseEvent);
    player.Update(releaseInput);
    const auto& afterRelease = host.GetInputDebugSnapshot();
    EXPECT_TRUE(afterRelease.activeStateKey.empty());
    EXPECT_TRUE(afterRelease.captureStateKey.empty());
    EXPECT_NE(afterRelease.focusedStateKey.find("/input-capture"), std::string::npos);
    EXPECT_NE(afterRelease.hoveredStateKey.find("/input-route"), std::string::npos);
}

TEST(UIRuntimeTest, ScreenPlayerConsumeLastFrameReturnsDetachedPacketAndClearsBorrowedState) {
    TempFileScope viewFile("xcui_runtime_consume_player", ".xcui", BuildViewMarkup("Runtime Consume"));
    UIDocumentScreenHost host = {};
    UIScreenPlayer player(host);

    ASSERT_TRUE(player.Load(BuildScreenAsset(viewFile.Path(), "runtime.consume.player")));

    const auto& firstFrame = player.Update(BuildInputState(2u));
    ASSERT_TRUE(firstFrame.stats.documentLoaded);
    EXPECT_EQ(firstFrame.stats.presentedFrameIndex, 2u);
    EXPECT_TRUE(DrawDataContainsText(firstFrame.drawData, "Runtime Consume"));

    XCEngine::UI::Runtime::UIScreenFrameResult consumedFrame = player.ConsumeLastFrame();
    EXPECT_TRUE(consumedFrame.stats.documentLoaded);
    EXPECT_EQ(consumedFrame.stats.presentedFrameIndex, 2u);
    EXPECT_EQ(consumedFrame.stats.drawListCount, consumedFrame.drawData.GetDrawListCount());
    EXPECT_EQ(consumedFrame.stats.commandCount, consumedFrame.drawData.GetTotalCommandCount());
    EXPECT_TRUE(DrawDataContainsText(consumedFrame.drawData, "Runtime Consume"));
    EXPECT_EQ(player.GetPresentedFrameCount(), 1u);

    const auto& clearedFrame = player.GetLastFrame();
    EXPECT_FALSE(clearedFrame.stats.documentLoaded);
    EXPECT_EQ(clearedFrame.stats.presentedFrameIndex, 0u);
    EXPECT_EQ(clearedFrame.drawData.GetDrawListCount(), 0u);
    EXPECT_TRUE(clearedFrame.errorMessage.empty());

    const auto& secondFrame = player.Update(BuildInputState(3u));
    EXPECT_TRUE(secondFrame.stats.documentLoaded);
    EXPECT_EQ(secondFrame.stats.presentedFrameIndex, 3u);
    EXPECT_TRUE(DrawDataContainsText(secondFrame.drawData, "Runtime Consume"));
    EXPECT_EQ(player.GetPresentedFrameCount(), 2u);

    EXPECT_EQ(consumedFrame.stats.presentedFrameIndex, 2u);
    EXPECT_TRUE(DrawDataContainsText(consumedFrame.drawData, "Runtime Consume"));

    const XCEngine::UI::Runtime::UIScreenFrameResult emptyFrame = player.ConsumeLastFrame();
    EXPECT_TRUE(emptyFrame.stats.documentLoaded);
    EXPECT_EQ(emptyFrame.stats.presentedFrameIndex, 3u);
    EXPECT_TRUE(DrawDataContainsText(emptyFrame.drawData, "Runtime Consume"));

    const XCEngine::UI::Runtime::UIScreenFrameResult clearedAgain = player.ConsumeLastFrame();
    EXPECT_FALSE(clearedAgain.stats.documentLoaded);
    EXPECT_EQ(clearedAgain.stats.presentedFrameIndex, 0u);
    EXPECT_EQ(clearedAgain.drawData.GetDrawListCount(), 0u);
}

TEST(UIRuntimeTest, UISystemForwardsActiveScreenToPlayer) {
    TempFileScope baseView("xcui_runtime_base", ".xcui", BuildViewMarkup("Base Screen"));
    TempFileScope overlayView("xcui_runtime_overlay", ".xcui", BuildViewMarkup("Overlay Screen", "Modal Dialog"));

    UIDocumentScreenHost host = {};
    UISystem system(host);

    const auto baseLayer = system.PushScreen(
        BuildScreenAsset(baseView.Path(), "runtime.base"));
    ASSERT_NE(baseLayer, 0u);

    XCEngine::UI::Runtime::UIScreenLayerOptions overlayOptions = {};
    overlayOptions.debugName = "overlay";
    overlayOptions.blocksLayersBelow = true;
    const auto overlayLayer = system.PushScreen(
        BuildScreenAsset(overlayView.Path(), "runtime.overlay"),
        overlayOptions);
    ASSERT_NE(overlayLayer, 0u);

    const auto& frame = system.Update(BuildInputState(3u));
    EXPECT_EQ(frame.presentedLayerCount, 1u);
    EXPECT_EQ(frame.skippedLayerCount, 1u);
    EXPECT_EQ(frame.layers.size(), 1u);
    EXPECT_EQ(frame.layers.front().layerId, overlayLayer);
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Overlay Screen"));
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Modal Dialog"));
    EXPECT_FALSE(DrawDataContainsText(frame.drawData, "Base Screen"));
}

TEST(UIRuntimeTest, ScreenStackControllerAppliesHudAndMenuLayerPolicies) {
    TempFileScope hudView("xcui_runtime_hud", ".xcui", BuildViewMarkup("HUD Screen"));
    TempFileScope menuView("xcui_runtime_menu", ".xcui", BuildViewMarkup("Pause Menu", "Paused"));

    UIDocumentScreenHost host = {};
    UISystem system(host);
    UIScreenStackController stack(system);

    const auto hudLayer = stack.PushHud(BuildScreenAsset(hudView.Path(), "runtime.hud"), "hud");
    const auto menuLayer = stack.PushMenu(BuildScreenAsset(menuView.Path(), "runtime.menu"), "menu");
    ASSERT_NE(hudLayer, 0u);
    ASSERT_NE(menuLayer, 0u);

    ASSERT_EQ(stack.GetEntryCount(), 2u);
    ASSERT_NE(stack.GetTop(), nullptr);
    EXPECT_EQ(stack.GetTop()->layerId, menuLayer);

    const auto* hudOptions = system.FindLayerOptions(hudLayer);
    const auto* menuOptions = system.FindLayerOptions(menuLayer);
    ASSERT_NE(hudOptions, nullptr);
    ASSERT_NE(menuOptions, nullptr);
    EXPECT_FALSE(hudOptions->acceptsInput);
    EXPECT_FALSE(hudOptions->blocksLayersBelow);
    EXPECT_TRUE(menuOptions->acceptsInput);
    EXPECT_TRUE(menuOptions->blocksLayersBelow);

    const auto& frame = system.Update(BuildInputState(4u));
    EXPECT_EQ(frame.presentedLayerCount, 1u);
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Pause Menu"));
    EXPECT_FALSE(DrawDataContainsText(frame.drawData, "HUD Screen"));
}

TEST(UIRuntimeTest, ScreenStackControllerReplaceTopSwapsMenuContent) {
    TempFileScope pauseView("xcui_runtime_pause", ".xcui", BuildViewMarkup("Pause Menu"));
    TempFileScope settingsView("xcui_runtime_settings", ".xcui", BuildViewMarkup("Settings Menu"));

    UIDocumentScreenHost host = {};
    UISystem system(host);
    UIScreenStackController stack(system);

    const auto pauseLayer = stack.PushMenu(BuildScreenAsset(pauseView.Path(), "runtime.pause"), "pause");
    ASSERT_NE(pauseLayer, 0u);

    XCEngine::UI::Runtime::UIScreenLayerOptions replacementOptions = {};
    replacementOptions.debugName = "settings";
    replacementOptions.acceptsInput = true;
    replacementOptions.blocksLayersBelow = true;
    ASSERT_TRUE(stack.ReplaceTop(
        BuildScreenAsset(settingsView.Path(), "runtime.settings"),
        replacementOptions));

    ASSERT_EQ(stack.GetEntryCount(), 1u);
    ASSERT_NE(stack.GetTop(), nullptr);
    EXPECT_EQ(stack.GetTop()->asset.screenId, "runtime.settings");
    EXPECT_NE(stack.GetTop()->layerId, pauseLayer);

    const auto& frame = system.Update(BuildInputState(5u));
    EXPECT_EQ(frame.presentedLayerCount, 1u);
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Settings Menu"));
    EXPECT_FALSE(DrawDataContainsText(frame.drawData, "Pause Menu"));
}

TEST(UIRuntimeTest, ScreenStackControllerReplaceTopKeepsPreviousScreenWhenReplacementFails) {
    TempFileScope pauseView("xcui_runtime_pause", ".xcui", BuildViewMarkup("Pause Menu"));

    UIDocumentScreenHost host = {};
    UISystem system(host);
    UIScreenStackController stack(system);

    const auto pauseLayer = stack.PushMenu(BuildScreenAsset(pauseView.Path(), "runtime.pause"), "pause");
    ASSERT_NE(pauseLayer, 0u);

    XCEngine::UI::Runtime::UIScreenLayerOptions replacementOptions = {};
    replacementOptions.debugName = "broken";
    replacementOptions.acceptsInput = true;
    replacementOptions.blocksLayersBelow = true;

    UIScreenAsset invalidAsset = {};
    invalidAsset.screenId = "runtime.invalid";
    invalidAsset.documentPath = (fs::temp_directory_path() / "xcui_missing_runtime_screen.xcui").string();

    EXPECT_FALSE(stack.ReplaceTop(invalidAsset, replacementOptions));
    ASSERT_EQ(stack.GetEntryCount(), 1u);
    ASSERT_NE(stack.GetTop(), nullptr);
    EXPECT_EQ(stack.GetTop()->layerId, pauseLayer);
    EXPECT_EQ(stack.GetTop()->asset.screenId, "runtime.pause");
    EXPECT_EQ(system.GetLayerCount(), 1u);

    const auto& frame = system.Update(BuildInputState(6u));
    EXPECT_EQ(frame.presentedLayerCount, 1u);
    EXPECT_TRUE(DrawDataContainsText(frame.drawData, "Pause Menu"));
}

TEST(UIRuntimeTest, RoutesViewportAndFocusOnlyToTopInteractiveVisibleLayer) {
    RecordingDocumentHost host = {};
    UISystem system(host);

    XCEngine::UI::Runtime::UIScreenLayerOptions gameplayOptions = {};
    gameplayOptions.debugName = "gameplay";
    gameplayOptions.acceptsInput = true;
    gameplayOptions.blocksLayersBelow = false;

    XCEngine::UI::Runtime::UIScreenLayerOptions overlayOptions = {};
    overlayOptions.debugName = "overlay";
    overlayOptions.acceptsInput = true;
    overlayOptions.blocksLayersBelow = false;

    const auto gameplayLayerId = system.PushScreen(
        BuildScreenAsset(fs::path("gameplay_view.xcui"), "runtime.gameplay"),
        gameplayOptions);
    const auto overlayLayerId = system.PushScreen(
        BuildScreenAsset(fs::path("overlay_view.xcui"), "runtime.overlay"),
        overlayOptions);
    ASSERT_NE(gameplayLayerId, 0u);
    ASSERT_NE(overlayLayerId, 0u);

    UIScreenFrameInput input = BuildInputState(8u);
    input.viewportRect = XCEngine::UI::UIRect(15.0f, 25.0f, 1024.0f, 576.0f);
    XCEngine::UI::UIInputEvent textEvent = {};
    textEvent.type = XCEngine::UI::UIInputEventType::Character;
    textEvent.character = 'I';
    input.events.push_back(textEvent);

    const auto& frame = system.Update(input);
    ASSERT_EQ(frame.presentedLayerCount, 2u);
    ASSERT_EQ(frame.layers.size(), 2u);
    ASSERT_EQ(host.GetBuildCallCount(), 2u);

    const auto* gameplayCall = host.FindBuildCall("runtime.gameplay");
    const auto* overlayCall = host.FindBuildCall("runtime.overlay");
    ASSERT_NE(gameplayCall, nullptr);
    ASSERT_NE(overlayCall, nullptr);

    EXPECT_EQ(gameplayCall->input.viewportRect.x, input.viewportRect.x);
    EXPECT_EQ(gameplayCall->input.viewportRect.y, input.viewportRect.y);
    EXPECT_EQ(gameplayCall->input.viewportRect.width, input.viewportRect.width);
    EXPECT_EQ(gameplayCall->input.viewportRect.height, input.viewportRect.height);
    EXPECT_TRUE(gameplayCall->input.events.empty());
    EXPECT_FALSE(gameplayCall->input.focused);
    EXPECT_EQ(gameplayCall->input.frameIndex, input.frameIndex);

    EXPECT_EQ(overlayCall->input.viewportRect.x, input.viewportRect.x);
    EXPECT_EQ(overlayCall->input.viewportRect.y, input.viewportRect.y);
    EXPECT_EQ(overlayCall->input.viewportRect.width, input.viewportRect.width);
    EXPECT_EQ(overlayCall->input.viewportRect.height, input.viewportRect.height);
    EXPECT_EQ(overlayCall->input.events.size(), 1u);
    EXPECT_TRUE(overlayCall->input.focused);
    EXPECT_EQ(overlayCall->input.frameIndex, input.frameIndex);

    const auto* gameplayLayer = FindPresentedLayerById(frame, gameplayLayerId);
    const auto* overlayLayer = FindPresentedLayerById(frame, overlayLayerId);
    ASSERT_NE(gameplayLayer, nullptr);
    ASSERT_NE(overlayLayer, nullptr);
    EXPECT_EQ(gameplayLayer->stats.inputEventCount, 0u);
    EXPECT_EQ(overlayLayer->stats.inputEventCount, 1u);
}

TEST(UIRuntimeTest, HiddenTopLayerLeavesUnderlyingLayerFocusedAndInteractive) {
    RecordingDocumentHost host = {};
    UISystem system(host);

    XCEngine::UI::Runtime::UIScreenLayerOptions visibleOptions = {};
    visibleOptions.debugName = "visible";
    visibleOptions.acceptsInput = true;
    visibleOptions.blocksLayersBelow = false;

    XCEngine::UI::Runtime::UIScreenLayerOptions hiddenOptions = {};
    hiddenOptions.debugName = "hidden";
    hiddenOptions.visible = false;
    hiddenOptions.acceptsInput = true;
    hiddenOptions.blocksLayersBelow = false;

    const auto visibleLayerId = system.PushScreen(
        BuildScreenAsset(fs::path("visible_view.xcui"), "runtime.visible"),
        visibleOptions);
    const auto hiddenLayerId = system.PushScreen(
        BuildScreenAsset(fs::path("hidden_view.xcui"), "runtime.hidden"),
        hiddenOptions);
    ASSERT_NE(visibleLayerId, 0u);
    ASSERT_NE(hiddenLayerId, 0u);

    UIScreenFrameInput input = BuildInputState(9u);
    input.viewportRect = XCEngine::UI::UIRect(40.0f, 60.0f, 700.0f, 420.0f);
    XCEngine::UI::UIInputEvent keyEvent = {};
    keyEvent.type = XCEngine::UI::UIInputEventType::KeyDown;
    keyEvent.keyCode = 32;
    input.events.push_back(keyEvent);

    const auto& frame = system.Update(input);
    ASSERT_EQ(frame.presentedLayerCount, 1u);
    ASSERT_EQ(frame.skippedLayerCount, 1u);
    ASSERT_EQ(frame.layers.size(), 1u);
    ASSERT_EQ(host.GetBuildCallCount(), 1u);

    const auto* visibleCall = host.FindBuildCall("runtime.visible");
    ASSERT_NE(visibleCall, nullptr);
    EXPECT_EQ(visibleCall->input.viewportRect.x, input.viewportRect.x);
    EXPECT_EQ(visibleCall->input.viewportRect.y, input.viewportRect.y);
    EXPECT_EQ(visibleCall->input.viewportRect.width, input.viewportRect.width);
    EXPECT_EQ(visibleCall->input.viewportRect.height, input.viewportRect.height);
    EXPECT_EQ(visibleCall->input.events.size(), 1u);
    EXPECT_TRUE(visibleCall->input.focused);
    EXPECT_EQ(host.FindBuildCall("runtime.hidden"), nullptr);

    const auto* visibleLayer = FindPresentedLayerById(frame, visibleLayerId);
    ASSERT_NE(visibleLayer, nullptr);
    EXPECT_EQ(visibleLayer->stats.inputEventCount, 1u);
    EXPECT_EQ(FindPresentedLayerById(frame, hiddenLayerId), nullptr);
}

TEST(UIRuntimeTest, UISystemConsumeLastFrameReturnsDetachedPresentationPacket) {
    RecordingDocumentHost host = {};
    UISystem system(host);

    XCEngine::UI::Runtime::UIScreenLayerOptions options = {};
    options.debugName = "runtime";
    const auto layerId = system.PushScreen(
        BuildScreenAsset(fs::path("runtime_consume_view.xcui"), "runtime.consume"),
        options);
    ASSERT_NE(layerId, 0u);

    UIScreenFrameInput input = BuildInputState(12u);
    input.viewportRect = XCEngine::UI::UIRect(48.0f, 72.0f, 1280.0f, 720.0f);
    input.deltaTimeSeconds = 1.0 / 30.0;
    XCEngine::UI::UIInputEvent textEvent = {};
    textEvent.type = XCEngine::UI::UIInputEventType::Character;
    textEvent.character = 'R';
    input.events.push_back(textEvent);

    const auto& frame = system.Update(input);
    ASSERT_EQ(frame.presentedLayerCount, 1u);
    EXPECT_EQ(frame.viewportRect.x, input.viewportRect.x);
    EXPECT_EQ(frame.viewportRect.y, input.viewportRect.y);
    EXPECT_EQ(frame.viewportRect.width, input.viewportRect.width);
    EXPECT_EQ(frame.viewportRect.height, input.viewportRect.height);
    EXPECT_EQ(frame.submittedInputEventCount, 1u);
    EXPECT_DOUBLE_EQ(frame.deltaTimeSeconds, input.deltaTimeSeconds);
    EXPECT_TRUE(frame.focused);

    XCEngine::UI::Runtime::UISystemFrameResult consumedFrame = system.ConsumeLastFrame();
    EXPECT_EQ(consumedFrame.frameIndex, input.frameIndex);
    EXPECT_EQ(consumedFrame.presentedLayerCount, 1u);
    EXPECT_EQ(consumedFrame.layers.size(), 1u);
    EXPECT_EQ(consumedFrame.layers.front().layerId, layerId);
    EXPECT_EQ(consumedFrame.viewportRect.x, input.viewportRect.x);
    EXPECT_EQ(consumedFrame.viewportRect.y, input.viewportRect.y);
    EXPECT_EQ(consumedFrame.viewportRect.width, input.viewportRect.width);
    EXPECT_EQ(consumedFrame.viewportRect.height, input.viewportRect.height);
    EXPECT_EQ(consumedFrame.submittedInputEventCount, 1u);
    EXPECT_DOUBLE_EQ(consumedFrame.deltaTimeSeconds, input.deltaTimeSeconds);
    EXPECT_TRUE(consumedFrame.focused);
    EXPECT_TRUE(DrawDataContainsText(consumedFrame.drawData, "runtime.consume"));

    const auto& clearedFrame = system.GetLastFrame();
    EXPECT_EQ(clearedFrame.frameIndex, 0u);
    EXPECT_EQ(clearedFrame.presentedLayerCount, 0u);
    EXPECT_EQ(clearedFrame.submittedInputEventCount, 0u);
    EXPECT_TRUE(clearedFrame.layers.empty());
    EXPECT_EQ(clearedFrame.drawData.GetDrawListCount(), 0u);

    const XCEngine::UI::Runtime::UISystemFrameResult emptyFrame = system.ConsumeLastFrame();
    EXPECT_EQ(emptyFrame.frameIndex, 0u);
    EXPECT_TRUE(emptyFrame.layers.empty());
    EXPECT_EQ(emptyFrame.drawData.GetDrawListCount(), 0u);
}

TEST(UIRuntimeTest, SceneRuntimeContextConsumeLastFrameForwardsPresentationSnapshot) {
    TempFileScope viewFile("xcui_runtime_context", ".xcui", BuildViewMarkup("Runtime Context"));
    UISceneRuntimeContext runtimeContext = {};

    const auto layerId = runtimeContext.GetStackController().PushMenu(
        BuildScreenAsset(viewFile.Path(), "runtime.context"),
        "context");
    ASSERT_NE(layerId, 0u);

    const XCEngine::UI::UIRect viewportRect(24.0f, 32.0f, 960.0f, 540.0f);
    runtimeContext.SetViewportRect(viewportRect);
    runtimeContext.SetFocused(true);

    XCEngine::UI::UIInputEvent textEvent = {};
    textEvent.type = XCEngine::UI::UIInputEventType::Character;
    textEvent.character = 'C';
    runtimeContext.QueueInputEvent(textEvent);

    runtimeContext.Update(0.25);

    XCEngine::UI::Runtime::UISystemFrameResult consumedFrame = runtimeContext.ConsumeLastFrame();
    EXPECT_EQ(consumedFrame.frameIndex, 1u);
    EXPECT_EQ(consumedFrame.presentedLayerCount, 1u);
    EXPECT_EQ(consumedFrame.layers.size(), 1u);
    EXPECT_EQ(consumedFrame.layers.front().layerId, layerId);
    EXPECT_EQ(consumedFrame.viewportRect.x, viewportRect.x);
    EXPECT_EQ(consumedFrame.viewportRect.y, viewportRect.y);
    EXPECT_EQ(consumedFrame.viewportRect.width, viewportRect.width);
    EXPECT_EQ(consumedFrame.viewportRect.height, viewportRect.height);
    EXPECT_EQ(consumedFrame.submittedInputEventCount, 1u);
    EXPECT_DOUBLE_EQ(consumedFrame.deltaTimeSeconds, 0.25);
    EXPECT_TRUE(consumedFrame.focused);
    EXPECT_TRUE(DrawDataContainsText(consumedFrame.drawData, "Runtime Context"));

    const auto& clearedFrame = runtimeContext.GetLastFrame();
    EXPECT_EQ(clearedFrame.frameIndex, 0u);
    EXPECT_EQ(clearedFrame.presentedLayerCount, 0u);
    EXPECT_TRUE(clearedFrame.layers.empty());
    EXPECT_EQ(clearedFrame.drawData.GetDrawListCount(), 0u);

    runtimeContext.Update(0.5);
    const auto& secondFrame = runtimeContext.GetLastFrame();
    EXPECT_EQ(secondFrame.frameIndex, 2u);
    EXPECT_EQ(secondFrame.submittedInputEventCount, 0u);
    EXPECT_DOUBLE_EQ(secondFrame.deltaTimeSeconds, 0.5);
    EXPECT_TRUE(secondFrame.focused);
}