#include "Application.h"

#include "XCUIBackend/LegacyImGuiHostInterop.h"
#include "panels/XCUIDemoPanel.h"
#include "panels/XCUILayoutLabPanel.h"

#include <imgui.h>

#include <algorithm>
#include <chrono>

namespace XCEngine {
namespace NewEditor {

namespace {

constexpr float kLegacyHostClearColor[4] = { 0.08f, 0.09f, 0.11f, 1.0f };

std::uint64_t MakeLegacyHostFrameTimestampNanoseconds() {
    return static_cast<std::uint64_t>(
        std::chrono::duration_cast<std::chrono::nanoseconds>(
            std::chrono::steady_clock::now().time_since_epoch())
            .count());
}

const char* GetHostedPreviewPathLabel(bool nativeRequested, bool nativePresenterBound) {
    if (nativeRequested && nativePresenterBound) {
        return "native queued offscreen surface";
    }
    if (nativeRequested) {
        return "native requested, hosted presenter bound";
    }
    if (nativePresenterBound) {
        return "hosted presenter requested, native presenter still bound";
    }
    return "hosted presenter";
}

const char* GetHostedPreviewStateLabel(
    bool hostedPreviewEnabled,
    bool nativePresenterBound,
    bool presentedThisFrame,
    bool queuedToNativePassThisFrame,
    bool surfaceImageAvailable,
    bool surfaceAllocated,
    bool surfaceReady,
    bool descriptorAvailable) {
    if (!hostedPreviewEnabled) {
        return "disabled";
    }

    if (nativePresenterBound) {
        if (surfaceImageAvailable && surfaceReady) {
            return "live";
        }
        if (queuedToNativePassThisFrame || surfaceAllocated || descriptorAvailable) {
            return "warming";
        }
        return "awaiting submit";
    }

    if (presentedThisFrame) {
        return "live";
    }
    return "idle";
}

} // namespace

Application::Application() = default;
Application::~Application() = default;

std::unique_ptr<::XCEngine::Editor::XCUIBackend::IXCUIHostedPreviewPresenter>
Application::CreateHostedPreviewPresenter(bool nativePreview) {
    if (nativePreview) {
        return ::XCEngine::Editor::XCUIBackend::CreateQueuedNativeXCUIHostedPreviewPresenter(
            m_hostedPreviewQueue,
            m_hostedPreviewSurfaceRegistry);
    }

    return ::XCEngine::Editor::XCUIBackend::CreateLegacyImGuiHostedPreviewPresenter();
}

void Application::InitializePanelsForActiveWindowHost() {
    if (IsNativeWindowHostEnabled()) {
        InitializeNativeShell();
        return;
    }

    InitializeLegacyImGuiPanels();
    ConfigureHostedPreviewPresenters();
}

void Application::InitializeLegacyImGuiPanels() {
    m_demoPanel = std::make_unique<XCUIDemoPanel>(
        &m_xcuiInputSource,
        CreateHostedPreviewPresenter(IsNativeHostedPreviewEnabled(ShellPanelId::XCUIDemo)),
        ::XCEngine::Editor::XCUIBackend::CreateLegacyImGuiPanelCanvasHost());
    m_layoutLabPanel = std::make_unique<XCUILayoutLabPanel>(
        &m_xcuiInputSource,
        CreateHostedPreviewPresenter(IsNativeHostedPreviewEnabled(ShellPanelId::XCUILayoutLab)),
        ::XCEngine::Editor::XCUIBackend::CreateLegacyImGuiPanelCanvasHost());
}

void Application::ConfigureHostedPreviewPresenters() {
    const ShellPanelChromeState* demoState = TryGetShellPanelState(ShellPanelId::XCUIDemo);
    if (m_demoPanel != nullptr) {
        m_demoPanel->SetVisible(demoState != nullptr && demoState->visible);
        m_demoPanel->SetHostedPreviewEnabled(demoState == nullptr || demoState->hostedPreviewEnabled);
        m_demoPanel->SetHostedPreviewPresenter(CreateHostedPreviewPresenter(IsNativeHostedPreviewEnabled(ShellPanelId::XCUIDemo)));
    }

    const ShellPanelChromeState* layoutLabState = TryGetShellPanelState(ShellPanelId::XCUILayoutLab);
    if (m_layoutLabPanel != nullptr) {
        m_layoutLabPanel->SetVisible(layoutLabState != nullptr && layoutLabState->visible);
        m_layoutLabPanel->SetHostedPreviewEnabled(layoutLabState == nullptr || layoutLabState->hostedPreviewEnabled);
        m_layoutLabPanel->SetHostedPreviewPresenter(
            CreateHostedPreviewPresenter(IsNativeHostedPreviewEnabled(ShellPanelId::XCUILayoutLab)));
    }
}

void Application::ResetLegacyPanels() {
    m_demoPanel.reset();
    m_layoutLabPanel.reset();
}

void Application::SyncShellChromePanelStateFromPanels() {
    m_shellChromeState.SetPanelVisible(
        ShellPanelId::XCUIDemo,
        m_demoPanel != nullptr && m_demoPanel->IsVisible());
    m_shellChromeState.SetPanelVisible(
        ShellPanelId::XCUILayoutLab,
        m_layoutLabPanel != nullptr && m_layoutLabPanel->IsVisible());
}

void Application::ConfigureShellCommandRouter() {
    m_shellCommandRouter.Clear();

    ShellCommandBindings bindings = {};
    bindings.getXCUIDemoPanelVisible = [this]() {
        return m_shellChromeState.IsPanelVisible(ShellPanelId::XCUIDemo);
    };
    bindings.setXCUIDemoPanelVisible = [this](bool visible) {
        m_shellChromeState.SetPanelVisible(ShellPanelId::XCUIDemo, visible);
        if (m_demoPanel != nullptr) {
            m_demoPanel->SetVisible(visible);
        }
    };
    bindings.getXCUILayoutLabPanelVisible = [this]() {
        return m_shellChromeState.IsPanelVisible(ShellPanelId::XCUILayoutLab);
    };
    bindings.setXCUILayoutLabPanelVisible = [this](bool visible) {
        m_shellChromeState.SetPanelVisible(ShellPanelId::XCUILayoutLab, visible);
        if (m_layoutLabPanel != nullptr) {
            m_layoutLabPanel->SetVisible(visible);
        }
    };
    bindings.getImGuiDemoWindowVisible = [this]() {
        return IsShellViewToggleEnabled(ShellViewToggleId::ImGuiDemoWindow);
    };
    bindings.setImGuiDemoWindowVisible = [this](bool visible) {
        SetShellViewToggleEnabled(ShellViewToggleId::ImGuiDemoWindow, visible);
    };
    bindings.getNativeBackdropVisible = [this]() {
        return IsShellViewToggleEnabled(ShellViewToggleId::NativeBackdrop);
    };
    bindings.setNativeBackdropVisible = [this](bool visible) {
        SetShellViewToggleEnabled(ShellViewToggleId::NativeBackdrop, visible);
    };
    bindings.getPulseAccentEnabled = [this]() {
        return IsShellViewToggleEnabled(ShellViewToggleId::PulseAccent);
    };
    bindings.setPulseAccentEnabled = [this](bool enabled) {
        SetShellViewToggleEnabled(ShellViewToggleId::PulseAccent, enabled);
    };
    bindings.getNativeXCUIOverlayVisible = [this]() {
        return IsShellViewToggleEnabled(ShellViewToggleId::NativeXCUIOverlay);
    };
    bindings.setNativeXCUIOverlayVisible = [this](bool visible) {
        SetShellViewToggleEnabled(ShellViewToggleId::NativeXCUIOverlay, visible);
    };
    bindings.getHostedPreviewHudVisible = [this]() {
        return IsShellViewToggleEnabled(ShellViewToggleId::HostedPreviewHud);
    };
    bindings.setHostedPreviewHudVisible = [this](bool visible) {
        SetShellViewToggleEnabled(ShellViewToggleId::HostedPreviewHud, visible);
    };
    bindings.getNativeDemoPanelPreviewEnabled = [this]() {
        return IsNativeHostedPreviewEnabled(ShellPanelId::XCUIDemo);
    };
    bindings.setNativeDemoPanelPreviewEnabled = [this](bool enabled) {
        m_shellChromeState.SetHostedPreviewMode(
            ShellPanelId::XCUIDemo,
            enabled ? ShellHostedPreviewMode::NativeOffscreen : ShellHostedPreviewMode::HostedPresenter);
    };
    bindings.getNativeLayoutLabPreviewEnabled = [this]() {
        return IsNativeHostedPreviewEnabled(ShellPanelId::XCUILayoutLab);
    };
    bindings.setNativeLayoutLabPreviewEnabled = [this](bool enabled) {
        m_shellChromeState.SetHostedPreviewMode(
            ShellPanelId::XCUILayoutLab,
            enabled ? ShellHostedPreviewMode::NativeOffscreen : ShellHostedPreviewMode::HostedPresenter);
    };
    bindings.onHostedPreviewModeChanged = [this]() { ConfigureHostedPreviewPresenters(); };

    Application::RegisterShellViewCommands(m_shellCommandRouter, bindings);
}

::XCEngine::Editor::XCUIBackend::XCUIInputBridgeFrameDelta
Application::DispatchShellShortcuts(
    const ::XCEngine::Editor::XCUIBackend::XCUIInputBridgeFrameSnapshot& snapshot) {
    ::XCEngine::Editor::XCUIBackend::XCUIInputBridgeFrameSnapshot shellSnapshot = snapshot;
    if (!IsNativeWindowHostEnabled()) {
        ::XCEngine::Editor::XCUIBackend::ApplyLegacyImGuiHostInputCapture(shellSnapshot);
    }

    if (!m_shellInputBridge.HasBaseline()) {
        m_shellInputBridge.Prime(shellSnapshot);
    }
    const ::XCEngine::Editor::XCUIBackend::XCUIInputBridgeFrameDelta frameDelta =
        m_shellInputBridge.Translate(shellSnapshot);
    const ::XCEngine::Editor::XCUIBackend::XCUIEditorCommandInputSnapshot commandSnapshot =
        Application::BuildShellShortcutSnapshot(frameDelta);
    m_shellCommandRouter.InvokeMatchingShortcut({ &commandSnapshot });
    return frameDelta;
}

void Application::InitializeWindowCompositor() {
    m_windowCompositor = IsNativeWindowHostEnabled()
        ? ::XCEngine::Editor::XCUIBackend::CreateNativeWindowUICompositor()
        : ::XCEngine::Editor::XCUIBackend::CreateLegacyImGuiWindowUICompositor();
    if (m_windowCompositor != nullptr) {
        m_windowCompositor->Initialize(
            m_hwnd,
            m_windowRenderer,
            []() { (void)::XCEngine::Editor::XCUIBackend::ConfigureLegacyImGuiHostFonts(); });
    }
}

void Application::FrameLegacyImGuiHost() {
    Application::BeginHostedPreviewFrameLifecycle(
        m_hostedPreviewQueue,
        m_hostedPreviewSurfaceRegistry);
    SyncHostedPreviewSurfaces();
    if (m_windowCompositor == nullptr) {
        m_xcuiInputSource.ClearFrameTransients();
        return;
    }

    m_windowCompositor->RenderFrame(
        kLegacyHostClearColor,
        [this]() { RenderLegacyImGuiUiFrame(); },
        [this](
            const ::XCEngine::Rendering::RenderContext& renderContext,
            const ::XCEngine::Rendering::RenderSurface& surface) {
            RenderQueuedHostedPreviews(renderContext, surface);

            if (!IsShellViewToggleEnabled(ShellViewToggleId::NativeBackdrop) &&
                !IsShellViewToggleEnabled(ShellViewToggleId::NativeXCUIOverlay)) {
                return;
            }

            MainWindowNativeBackdropRenderer::FrameState frameState = {};
            frameState.elapsedSeconds = static_cast<float>(
                std::chrono::duration<double>(std::chrono::steady_clock::now() - m_startTime).count());
            frameState.pulseAccent = IsShellViewToggleEnabled(ShellViewToggleId::PulseAccent);
            frameState.drawBackdrop = IsShellViewToggleEnabled(ShellViewToggleId::NativeBackdrop);
            if (IsShellViewToggleEnabled(ShellViewToggleId::NativeXCUIOverlay)) {
                const float width = static_cast<float>(surface.GetWidth());
                const float height = static_cast<float>(surface.GetHeight());
                const float horizontalMargin = (std::min)(width * 0.14f, 128.0f);
                const float topMargin = (std::min)(height * 0.15f, 132.0f);
                const float bottomMargin = (std::min)(height * 0.12f, 96.0f);

                ::XCEngine::Editor::XCUIBackend::XCUILayoutLabInputState overlayInput = {};
                overlayInput.canvasRect = ::XCEngine::UI::UIRect(
                    horizontalMargin,
                    topMargin,
                    (std::max)(0.0f, width - horizontalMargin * 2.0f),
                    (std::max)(0.0f, height - topMargin - bottomMargin));
                overlayInput.pointerPosition = m_xcuiInputSource.GetPointerPosition();
                overlayInput.pointerInside =
                    overlayInput.pointerPosition.x >= overlayInput.canvasRect.x &&
                    overlayInput.pointerPosition.y >= overlayInput.canvasRect.y &&
                    overlayInput.pointerPosition.x <= overlayInput.canvasRect.x + overlayInput.canvasRect.width &&
                    overlayInput.pointerPosition.y <= overlayInput.canvasRect.y + overlayInput.canvasRect.height;
                const auto& overlayFrame = m_nativeOverlayRuntime.Update(overlayInput);
                frameState.overlayDrawData = &overlayFrame.drawData;
            }
            m_nativeBackdropRenderer.Render(renderContext, surface, frameState);
        });

    m_xcuiInputSource.ClearFrameTransients();
}

void Application::RenderLegacyImGuiUiFrame() {
    ::XCEngine::Editor::XCUIBackend::XCUIInputBridgeCaptureOptions options = {};
    options.timestampNanoseconds = MakeLegacyHostFrameTimestampNanoseconds();
    options.windowFocused = m_xcuiInputSource.IsWindowFocused();
    const auto shellSnapshot = m_xcuiInputSource.CaptureSnapshot(options);
    DispatchShellShortcuts(shellSnapshot);

    RenderShellChrome();
    if (m_demoPanel != nullptr) {
        m_demoPanel->RenderIfVisible();
    }
    if (m_layoutLabPanel != nullptr) {
        m_layoutLabPanel->RenderIfVisible();
    }

    bool showImGuiDemoWindow = IsShellViewToggleEnabled(ShellViewToggleId::ImGuiDemoWindow);
    if (::XCEngine::Editor::XCUIBackend::RenderLegacyImGuiDemoWindow(showImGuiDemoWindow)) {
        SetShellViewToggleEnabled(ShellViewToggleId::ImGuiDemoWindow, showImGuiDemoWindow);
    }

    SyncShellChromePanelStateFromPanels();
    SyncHostedPreviewSurfaces();
}

void Application::RenderShellChrome() {
    SyncShellChromePanelStateFromPanels();

    ImGuiViewport* viewport = ImGui::GetMainViewport();
    if (viewport == nullptr) {
        return;
    }

    ImGuiWindowFlags windowFlags =
        ImGuiWindowFlags_NoDocking |
        ImGuiWindowFlags_NoTitleBar |
        ImGuiWindowFlags_NoCollapse |
        ImGuiWindowFlags_NoResize |
        ImGuiWindowFlags_NoMove |
        ImGuiWindowFlags_NoBringToFrontOnFocus |
        ImGuiWindowFlags_NoNavFocus |
        ImGuiWindowFlags_MenuBar;

    ImGui::SetNextWindowPos(viewport->WorkPos);
    ImGui::SetNextWindowSize(viewport->WorkSize);
    ImGui::SetNextWindowViewport(viewport->ID);
    ImGui::SetNextWindowBgAlpha(0.0f);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
    const bool opened = ImGui::Begin("XCNewEditorShell", nullptr, windowFlags);
    ImGui::PopStyleVar(3);

    if (opened) {
        if (ImGui::BeginMenuBar()) {
            if (ImGui::BeginMenu("View")) {
                const auto drawCommandMenuItem =
                    [this](const char* label, const char* shortcut, bool selected, const char* commandId) {
                        const bool enabled = m_shellCommandRouter.IsCommandEnabled(commandId);
                        if (ImGui::MenuItem(label, shortcut, selected, enabled)) {
                            m_shellCommandRouter.InvokeCommand(commandId);
                        }
                    };

                drawCommandMenuItem(
                    "XCUI Demo",
                    "Ctrl+1",
                    TryGetShellPanelState(ShellPanelId::XCUIDemo) != nullptr &&
                        TryGetShellPanelState(ShellPanelId::XCUIDemo)->visible,
                    ShellCommandIds::ToggleXCUIDemoPanel);
                drawCommandMenuItem(
                    "XCUI Layout Lab",
                    "Ctrl+2",
                    TryGetShellPanelState(ShellPanelId::XCUILayoutLab) != nullptr &&
                        TryGetShellPanelState(ShellPanelId::XCUILayoutLab)->visible,
                    ShellCommandIds::ToggleXCUILayoutLabPanel);
                drawCommandMenuItem(
                    "ImGui Demo",
                    "Ctrl+3",
                    IsShellViewToggleEnabled(ShellViewToggleId::ImGuiDemoWindow),
                    ShellCommandIds::ToggleImGuiDemoWindow);
                ImGui::Separator();
                drawCommandMenuItem(
                    "Native Backdrop",
                    "Ctrl+Shift+B",
                    IsShellViewToggleEnabled(ShellViewToggleId::NativeBackdrop),
                    ShellCommandIds::ToggleNativeBackdrop);
                drawCommandMenuItem(
                    "Pulse Accent",
                    "Ctrl+Shift+P",
                    IsShellViewToggleEnabled(ShellViewToggleId::PulseAccent),
                    ShellCommandIds::TogglePulseAccent);
                drawCommandMenuItem(
                    "Native XCUI Overlay",
                    "Ctrl+Shift+O",
                    IsShellViewToggleEnabled(ShellViewToggleId::NativeXCUIOverlay),
                    ShellCommandIds::ToggleNativeXCUIOverlay);
                drawCommandMenuItem(
                    "Hosted Preview HUD",
                    "Ctrl+Shift+H",
                    IsShellViewToggleEnabled(ShellViewToggleId::HostedPreviewHud),
                    ShellCommandIds::ToggleHostedPreviewHud);
                drawCommandMenuItem(
                    "Native Demo Panel Preview",
                    "Ctrl+Alt+1",
                    IsNativeHostedPreviewEnabled(ShellPanelId::XCUIDemo),
                    ShellCommandIds::ToggleNativeDemoPanelPreview);
                drawCommandMenuItem(
                    "Native Layout Lab Preview",
                    "Ctrl+Alt+2",
                    IsNativeHostedPreviewEnabled(ShellPanelId::XCUILayoutLab),
                    ShellCommandIds::ToggleNativeLayoutLabPreview);
                ImGui::EndMenu();
            }

            ImGui::SeparatorText("XCUI Sandbox");
            const MainWindowNativeBackdropRenderer::OverlayStats& nativeOverlayStats =
                m_nativeBackdropRenderer.GetLastOverlayStats();
            const ::XCEngine::Editor::XCUIBackend::XCUILayoutLabFrameStats& overlayFrameStats =
                m_nativeOverlayRuntime.GetFrameResult().stats;
            const ::XCEngine::Editor::XCUIBackend::XCUIHostedPreviewDrainStats& hostedPreviewStats =
                m_hostedPreviewQueue.GetLastDrainStats();
            if (IsShellViewToggleEnabled(ShellViewToggleId::NativeXCUIOverlay)) {
                ImGui::TextDisabled(
                    "Native XCUI overlay: %s | runtime %zu cmds (%zu fill, %zu outline, %zu text, %zu image, clips %zu/%zu)",
                    overlayFrameStats.nativeOverlayReady ? "preflight OK" : "preflight issues",
                    overlayFrameStats.commandCount,
                    overlayFrameStats.filledRectCommandCount,
                    overlayFrameStats.rectOutlineCommandCount,
                    overlayFrameStats.textCommandCount,
                    overlayFrameStats.imageCommandCount,
                    overlayFrameStats.clipPushCommandCount,
                    overlayFrameStats.clipPopCommandCount);
                ImGui::TextDisabled(
                    "%s | supported %zu | unsupported %zu | prev native pass %zu cmds, %zu rendered, %zu skipped",
                    overlayFrameStats.nativeOverlayStatusMessage.empty()
                        ? "Overlay diagnostics unavailable"
                        : overlayFrameStats.nativeOverlayStatusMessage.c_str(),
                    overlayFrameStats.nativeSupportedCommandCount,
                    overlayFrameStats.nativeUnsupportedCommandCount,
                    nativeOverlayStats.commandCount,
                    nativeOverlayStats.renderedCommandCount,
                    nativeOverlayStats.skippedCommandCount);
            } else {
                ImGui::TextDisabled(
                    IsShellViewToggleEnabled(ShellViewToggleId::NativeBackdrop)
                        ? "Transition backend + runtime diagnostics + native backbuffer pass"
                        : "Transition backend + runtime diagnostics");
            }
            ImGui::TextDisabled(
                "Hosted preview queue: %zu frames | queued %zu cmds | rendered %zu cmds | skipped %zu cmds",
                hostedPreviewStats.queuedFrameCount,
                hostedPreviewStats.queuedCommandCount,
                hostedPreviewStats.renderedCommandCount,
                hostedPreviewStats.skippedCommandCount);
            std::size_t allocatedSurfaceCount = 0u;
            std::size_t readySurfaceCount = 0u;
            for (const HostedPreviewOffscreenSurface& previewSurface : m_hostedPreviewSurfaces) {
                if (previewSurface.colorTexture != nullptr || previewSurface.colorView != nullptr) {
                    ++allocatedSurfaceCount;
                }
                if (previewSurface.IsReady()) {
                    ++readySurfaceCount;
                }
            }
            ImGui::TextDisabled(
                "Hosted surfaces: %zu registry entries | %zu allocated | %zu ready",
                m_hostedPreviewSurfaceRegistry.GetDescriptors().size(),
                allocatedSurfaceCount,
                readySurfaceCount);
            if (m_demoPanel != nullptr) {
                ImGui::TextDisabled(
                    "XCUI Demo preview: %s",
                    IsNativeHostedPreviewEnabled(ShellPanelId::XCUIDemo)
                        ? "native offscreen preview surface"
                        : "hosted presenter");
            }
            if (m_layoutLabPanel != nullptr) {
                ImGui::TextDisabled(
                    "Layout Lab preview: %s",
                    IsNativeHostedPreviewEnabled(ShellPanelId::XCUILayoutLab)
                        ? "native offscreen preview surface"
                        : "hosted presenter");
            }
            ImGui::EndMenuBar();
        }

        ImGui::DockSpace(
            ImGui::GetID("XCNewEditorDockSpace"),
            ImVec2(0.0f, 0.0f),
            ImGuiDockNodeFlags_PassthruCentralNode);
    }

    ImGui::End();

    if (IsShellViewToggleEnabled(ShellViewToggleId::HostedPreviewHud)) {
        RenderHostedPreviewHud();
    }
}

void Application::RenderHostedPreviewHud() {
    ImGuiViewport* viewport = ImGui::GetMainViewport();
    if (viewport == nullptr) {
        return;
    }

    const ShellPanelChromeState* demoState = TryGetShellPanelState(ShellPanelId::XCUIDemo);
    const ShellPanelChromeState* layoutLabState = TryGetShellPanelState(ShellPanelId::XCUILayoutLab);
    const HostedPreviewPanelDiagnostics demoDiagnostics = BuildHostedPreviewPanelDiagnostics(
        demoState != nullptr ? demoState->previewDebugName.data() : "XCUI Demo",
        demoState != nullptr ? demoState->previewDebugSource.data() : "new_editor.panels.xcui_demo",
        demoState != nullptr && demoState->visible,
        demoState != nullptr && demoState->hostedPreviewEnabled,
        IsNativeHostedPreviewEnabled(ShellPanelId::XCUIDemo),
        m_demoPanel != nullptr && m_demoPanel->IsUsingNativeHostedPreview(),
        m_demoPanel != nullptr
            ? m_demoPanel->GetLastPreviewStats()
            : ::XCEngine::Editor::XCUIBackend::XCUIHostedPreviewStats{});
    const HostedPreviewPanelDiagnostics layoutLabDiagnostics = BuildHostedPreviewPanelDiagnostics(
        layoutLabState != nullptr ? layoutLabState->previewDebugName.data() : "XCUI Layout Lab",
        layoutLabState != nullptr ? layoutLabState->previewDebugSource.data() : "new_editor.panels.xcui_layout_lab",
        layoutLabState != nullptr && layoutLabState->visible,
        layoutLabState != nullptr && layoutLabState->hostedPreviewEnabled,
        IsNativeHostedPreviewEnabled(ShellPanelId::XCUILayoutLab),
        m_layoutLabPanel != nullptr && m_layoutLabPanel->IsUsingNativeHostedPreview(),
        m_layoutLabPanel != nullptr
            ? m_layoutLabPanel->GetLastPreviewStats()
            : ::XCEngine::Editor::XCUIBackend::XCUIHostedPreviewStats{});

    std::size_t allocatedSurfaceCount = 0u;
    std::size_t readySurfaceCount = 0u;
    for (const HostedPreviewOffscreenSurface& previewSurface : m_hostedPreviewSurfaces) {
        if (previewSurface.colorTexture != nullptr || previewSurface.colorView != nullptr) {
            ++allocatedSurfaceCount;
        }
        if (previewSurface.IsReady()) {
            ++readySurfaceCount;
        }
    }

    const ::XCEngine::Editor::XCUIBackend::XCUIHostedPreviewDrainStats& drainStats =
        m_hostedPreviewQueue.GetLastDrainStats();

    ImGuiWindowFlags windowFlags =
        ImGuiWindowFlags_NoDocking |
        ImGuiWindowFlags_NoSavedSettings |
        ImGuiWindowFlags_AlwaysAutoResize |
        ImGuiWindowFlags_NoFocusOnAppearing |
        ImGuiWindowFlags_NoNav;

    ImGui::SetNextWindowViewport(viewport->ID);
    ImGui::SetNextWindowPos(
        ImVec2(viewport->WorkPos.x + viewport->WorkSize.x - 18.0f, viewport->WorkPos.y + 42.0f),
        ImGuiCond_Always,
        ImVec2(1.0f, 0.0f));
    ImGui::SetNextWindowBgAlpha(0.9f);
    if (!ImGui::Begin("XCUI Hosted Preview HUD", nullptr, windowFlags)) {
        ImGui::End();
        return;
    }

    ImGui::TextUnformatted("XCUI Hosted Preview");
    ImGui::Text(
        "Registry %zu | surfaces %zu/%zu ready | last native drain %zu rendered, %zu skipped",
        m_hostedPreviewSurfaceRegistry.GetDescriptors().size(),
        readySurfaceCount,
        allocatedSurfaceCount,
        drainStats.renderedFrameCount,
        drainStats.skippedFrameCount);
    ImGui::Separator();

    const auto drawPanelRow = [](const HostedPreviewPanelDiagnostics& diagnostics) {
        const char* const pathLabel =
            GetHostedPreviewPathLabel(diagnostics.nativeRequested, diagnostics.nativePresenterBound);
        const char* const stateLabel = GetHostedPreviewStateLabel(
            diagnostics.hostedPreviewEnabled,
            diagnostics.nativePresenterBound,
            diagnostics.presentedThisFrame,
            diagnostics.queuedToNativePassThisFrame,
            diagnostics.surfaceImageAvailable,
            diagnostics.surfaceAllocated,
            diagnostics.surfaceReady,
            diagnostics.descriptorAvailable);

        ImGui::Text(
            "%s [%s] %s",
            diagnostics.debugName.c_str(),
            diagnostics.visible ? "visible" : "hidden",
            stateLabel);
        ImGui::TextDisabled("%s", pathLabel);
        ImGui::Text(
            "source %s | submit %zu lists / %zu cmds | flush %zu lists / %zu cmds",
            diagnostics.debugSource.empty() ? "n/a" : diagnostics.debugSource.c_str(),
            diagnostics.submittedDrawListCount,
            diagnostics.submittedCommandCount,
            diagnostics.flushedDrawListCount,
            diagnostics.flushedCommandCount);
        if (diagnostics.nativePresenterBound) {
            ImGui::Text(
                "surface %ux%u | logical %.0f x %.0f | descriptor %s | image %s | submit->native %s",
                diagnostics.surfaceWidth,
                diagnostics.surfaceHeight,
                diagnostics.logicalWidth,
                diagnostics.logicalHeight,
                diagnostics.descriptorAvailable ? "yes" : "no",
                diagnostics.surfaceImageAvailable ? "yes" : "no",
                diagnostics.queuedToNativePassThisFrame ? "yes" : "no");
        } else {
            ImGui::Text(
                "legacy present %s | cached native surface %s",
                diagnostics.presentedThisFrame ? "yes" : "no",
                (diagnostics.surfaceAllocated || diagnostics.surfaceImageAvailable) ? "retained" : "none");
        }
    };

    drawPanelRow(demoDiagnostics);
    ImGui::Separator();
    drawPanelRow(layoutLabDiagnostics);

    ImGui::End();
}

} // namespace NewEditor
} // namespace XCEngine