XCEngine/new_editor/app/Application.cpp

#include "Application.h"

#include <XCEngine/Input/InputTypes.h>

#include <algorithm>
#include <chrono>
#include <filesystem>
#include <sstream>
#include <string>
#include <system_error>
#include <unordered_set>
#include <vector>

#ifndef XCUIEDITOR_REPO_ROOT
#define XCUIEDITOR_REPO_ROOT "."
#endif

namespace XCEngine::UI::Editor {

namespace {

using ::XCEngine::UI::UIColor;
using ::XCEngine::UI::UIDrawData;
using ::XCEngine::UI::UIDrawList;
using ::XCEngine::UI::UIInputEvent;
using ::XCEngine::UI::UIInputEventType;
using ::XCEngine::UI::UIPoint;
using ::XCEngine::UI::UIPointerButton;
using ::XCEngine::UI::UIRect;
using ::XCEngine::UI::Runtime::UIScreenFrameInput;
using ::XCEngine::Input::KeyCode;

constexpr const wchar_t* kWindowClassName = L"XCUIEditorShellHost";
constexpr const wchar_t* kWindowTitle = L"XCUI Editor";
constexpr auto kReloadPollInterval = std::chrono::milliseconds(150);

constexpr UIColor kOverlayBgColor(0.10f, 0.10f, 0.10f, 0.95f);
constexpr UIColor kOverlayBorderColor(0.25f, 0.25f, 0.25f, 1.0f);
constexpr UIColor kOverlayTextPrimary(0.93f, 0.93f, 0.93f, 1.0f);
constexpr UIColor kOverlayTextMuted(0.70f, 0.70f, 0.70f, 1.0f);
constexpr UIColor kOverlaySuccess(0.82f, 0.82f, 0.82f, 1.0f);
constexpr UIColor kOverlayFallback(0.56f, 0.56f, 0.56f, 1.0f);

Application* GetApplicationFromWindow(HWND hwnd) {
    return reinterpret_cast<Application*>(GetWindowLongPtrW(hwnd, GWLP_USERDATA));
}

std::string TruncateText(const std::string& text, std::size_t maxLength) {
    if (text.size() <= maxLength) {
        return text;
    }

    if (maxLength <= 3u) {
        return text.substr(0, maxLength);
    }

    return text.substr(0, maxLength - 3u) + "...";
}

std::string ExtractStateKeyTail(const std::string& stateKey) {
    if (stateKey.empty()) {
        return "-";
    }

    const std::size_t separator = stateKey.find_last_of('/');
    if (separator == std::string::npos || separator + 1u >= stateKey.size()) {
        return stateKey;
    }

    return stateKey.substr(separator + 1u);
}

std::string FormatFloat(float value) {
    std::ostringstream stream;
    stream.setf(std::ios::fixed, std::ios::floatfield);
    stream.precision(1);
    stream << value;
    return stream.str();
}

std::string FormatPoint(const UIPoint& point) {
    return "(" + FormatFloat(point.x) + ", " + FormatFloat(point.y) + ")";
}

void AppendErrorMessage(std::string& target, const std::string& message) {
    if (message.empty()) {
        return;
    }

    if (!target.empty()) {
        target += " | ";
    }
    target += message;
}

std::int32_t MapVirtualKeyToUIKeyCode(WPARAM wParam) {
    switch (wParam) {
    case 'A': return static_cast<std::int32_t>(KeyCode::A);
    case 'B': return static_cast<std::int32_t>(KeyCode::B);
    case 'C': return static_cast<std::int32_t>(KeyCode::C);
    case 'D': return static_cast<std::int32_t>(KeyCode::D);
    case 'E': return static_cast<std::int32_t>(KeyCode::E);
    case 'F': return static_cast<std::int32_t>(KeyCode::F);
    case 'G': return static_cast<std::int32_t>(KeyCode::G);
    case 'H': return static_cast<std::int32_t>(KeyCode::H);
    case 'I': return static_cast<std::int32_t>(KeyCode::I);
    case 'J': return static_cast<std::int32_t>(KeyCode::J);
    case 'K': return static_cast<std::int32_t>(KeyCode::K);
    case 'L': return static_cast<std::int32_t>(KeyCode::L);
    case 'M': return static_cast<std::int32_t>(KeyCode::M);
    case 'N': return static_cast<std::int32_t>(KeyCode::N);
    case 'O': return static_cast<std::int32_t>(KeyCode::O);
    case 'P': return static_cast<std::int32_t>(KeyCode::P);
    case 'Q': return static_cast<std::int32_t>(KeyCode::Q);
    case 'R': return static_cast<std::int32_t>(KeyCode::R);
    case 'S': return static_cast<std::int32_t>(KeyCode::S);
    case 'T': return static_cast<std::int32_t>(KeyCode::T);
    case 'U': return static_cast<std::int32_t>(KeyCode::U);
    case 'V': return static_cast<std::int32_t>(KeyCode::V);
    case 'W': return static_cast<std::int32_t>(KeyCode::W);
    case 'X': return static_cast<std::int32_t>(KeyCode::X);
    case 'Y': return static_cast<std::int32_t>(KeyCode::Y);
    case 'Z': return static_cast<std::int32_t>(KeyCode::Z);
    case '0': return static_cast<std::int32_t>(KeyCode::Zero);
    case '1': return static_cast<std::int32_t>(KeyCode::One);
    case '2': return static_cast<std::int32_t>(KeyCode::Two);
    case '3': return static_cast<std::int32_t>(KeyCode::Three);
    case '4': return static_cast<std::int32_t>(KeyCode::Four);
    case '5': return static_cast<std::int32_t>(KeyCode::Five);
    case '6': return static_cast<std::int32_t>(KeyCode::Six);
    case '7': return static_cast<std::int32_t>(KeyCode::Seven);
    case '8': return static_cast<std::int32_t>(KeyCode::Eight);
    case '9': return static_cast<std::int32_t>(KeyCode::Nine);
    case VK_SPACE: return static_cast<std::int32_t>(KeyCode::Space);
    case VK_TAB: return static_cast<std::int32_t>(KeyCode::Tab);
    case VK_RETURN: return static_cast<std::int32_t>(KeyCode::Enter);
    case VK_ESCAPE: return static_cast<std::int32_t>(KeyCode::Escape);
    case VK_SHIFT: return static_cast<std::int32_t>(KeyCode::LeftShift);
    case VK_CONTROL: return static_cast<std::int32_t>(KeyCode::LeftCtrl);
    case VK_MENU: return static_cast<std::int32_t>(KeyCode::LeftAlt);
    case VK_UP: return static_cast<std::int32_t>(KeyCode::Up);
    case VK_DOWN: return static_cast<std::int32_t>(KeyCode::Down);
    case VK_LEFT: return static_cast<std::int32_t>(KeyCode::Left);
    case VK_RIGHT: return static_cast<std::int32_t>(KeyCode::Right);
    case VK_HOME: return static_cast<std::int32_t>(KeyCode::Home);
    case VK_END: return static_cast<std::int32_t>(KeyCode::End);
    case VK_PRIOR: return static_cast<std::int32_t>(KeyCode::PageUp);
    case VK_NEXT: return static_cast<std::int32_t>(KeyCode::PageDown);
    case VK_DELETE: return static_cast<std::int32_t>(KeyCode::Delete);
    case VK_BACK: return static_cast<std::int32_t>(KeyCode::Backspace);
    case VK_F1: return static_cast<std::int32_t>(KeyCode::F1);
    case VK_F2: return static_cast<std::int32_t>(KeyCode::F2);
    case VK_F3: return static_cast<std::int32_t>(KeyCode::F3);
    case VK_F4: return static_cast<std::int32_t>(KeyCode::F4);
    case VK_F5: return static_cast<std::int32_t>(KeyCode::F5);
    case VK_F6: return static_cast<std::int32_t>(KeyCode::F6);
    case VK_F7: return static_cast<std::int32_t>(KeyCode::F7);
    case VK_F8: return static_cast<std::int32_t>(KeyCode::F8);
    case VK_F9: return static_cast<std::int32_t>(KeyCode::F9);
    case VK_F10: return static_cast<std::int32_t>(KeyCode::F10);
    case VK_F11: return static_cast<std::int32_t>(KeyCode::F11);
    case VK_F12: return static_cast<std::int32_t>(KeyCode::F12);
    default: return static_cast<std::int32_t>(KeyCode::None);
    }
}

bool IsRepeatKeyMessage(LPARAM lParam) {
    return (static_cast<unsigned long>(lParam) & (1ul << 30)) != 0ul;
}

} // namespace

Application::Application()
    : m_screenPlayer(m_documentHost) {
}

int Application::Run(HINSTANCE hInstance, int nCmdShow) {
    if (!Initialize(hInstance, nCmdShow)) {
        Shutdown();
        return 1;
    }

    MSG message = {};
    while (message.message != WM_QUIT) {
        if (PeekMessageW(&message, nullptr, 0U, 0U, PM_REMOVE)) {
            TranslateMessage(&message);
            DispatchMessageW(&message);
            continue;
        }

        RenderFrame();
        Sleep(8);
    }

    Shutdown();
    return static_cast<int>(message.wParam);
}

bool Application::Initialize(HINSTANCE hInstance, int nCmdShow) {
    m_hInstance = hInstance;
    m_shellAssetDefinition = BuildDefaultEditorShellAsset(ResolveRepoRootPath());

    WNDCLASSEXW windowClass = {};
    windowClass.cbSize = sizeof(windowClass);
    windowClass.style = CS_HREDRAW | CS_VREDRAW;
    windowClass.lpfnWndProc = &Application::WndProc;
    windowClass.hInstance = hInstance;
    windowClass.hCursor = LoadCursorW(nullptr, IDC_ARROW);
    windowClass.lpszClassName = kWindowClassName;

    m_windowClassAtom = RegisterClassExW(&windowClass);
    if (m_windowClassAtom == 0) {
        return false;
    }

    m_hwnd = CreateWindowExW(
        0,
        kWindowClassName,
        kWindowTitle,
        WS_OVERLAPPEDWINDOW | WS_VISIBLE,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        1440,
        900,
        nullptr,
        nullptr,
        hInstance,
        this);
    if (m_hwnd == nullptr) {
        return false;
    }

    ShowWindow(m_hwnd, nCmdShow);
    UpdateWindow(m_hwnd);

    if (!m_renderer.Initialize(m_hwnd)) {
        return false;
    }

    m_startTime = std::chrono::steady_clock::now();
    m_lastFrameTime = m_startTime;
    m_autoScreenshot.Initialize(m_shellAssetDefinition.captureRootPath);
    LoadStructuredScreen("startup");
    return true;
}

void Application::Shutdown() {
    m_autoScreenshot.Shutdown();
    m_screenPlayer.Unload();
    m_trackedFiles.clear();
    m_screenAsset = {};
    m_useStructuredScreen = false;
    m_runtimeStatus.clear();
    m_runtimeError.clear();
    m_frameIndex = 0;

    m_renderer.Shutdown();

    if (m_hwnd != nullptr && IsWindow(m_hwnd)) {
        DestroyWindow(m_hwnd);
    }
    m_hwnd = nullptr;

    if (m_windowClassAtom != 0 && m_hInstance != nullptr) {
        UnregisterClassW(kWindowClassName, m_hInstance);
        m_windowClassAtom = 0;
    }
}

void Application::RenderFrame() {
    if (m_hwnd == nullptr) {
        return;
    }

    RECT clientRect = {};
    GetClientRect(m_hwnd, &clientRect);
    const float width = static_cast<float>((std::max)(clientRect.right - clientRect.left, 1L));
    const float height = static_cast<float>((std::max)(clientRect.bottom - clientRect.top, 1L));

    const auto now = std::chrono::steady_clock::now();
    double deltaTimeSeconds = std::chrono::duration<double>(now - m_lastFrameTime).count();
    if (deltaTimeSeconds <= 0.0) {
        deltaTimeSeconds = 1.0 / 60.0;
    }
    m_lastFrameTime = now;

    RefreshStructuredScreen();
    std::vector<UIInputEvent> frameEvents = std::move(m_pendingInputEvents);
    m_pendingInputEvents.clear();

    UIDrawData drawData = {};
    if (m_useStructuredScreen && m_screenPlayer.IsLoaded()) {
        UIScreenFrameInput input = {};
        input.viewportRect = UIRect(0.0f, 0.0f, width, height);
        input.events = std::move(frameEvents);
        input.deltaTimeSeconds = deltaTimeSeconds;
        input.frameIndex = ++m_frameIndex;
        input.focused = GetForegroundWindow() == m_hwnd;

        const auto& frame = m_screenPlayer.Update(input);
        for (const auto& drawList : frame.drawData.GetDrawLists()) {
            drawData.AddDrawList(drawList);
        }

        m_runtimeStatus = "XCUI Editor Shell";
        m_runtimeError = frame.errorMessage;
    } else {
        m_runtimeStatus = "Editor Shell | Load Error";
        if (m_runtimeError.empty() && !m_screenPlayer.IsLoaded()) {
            m_runtimeError = m_screenPlayer.GetLastError();
        }
    }

    AppendRuntimeOverlay(drawData, width, height);

    const bool framePresented = m_renderer.Render(drawData);
    m_autoScreenshot.CaptureIfRequested(
        m_renderer,
        drawData,
        static_cast<unsigned int>(width),
        static_cast<unsigned int>(height),
        framePresented);
}

void Application::OnResize(UINT width, UINT height) {
    if (width == 0 || height == 0) {
        return;
    }

    m_renderer.Resize(width, height);
}

void Application::QueuePointerEvent(UIInputEventType type, UIPointerButton button, WPARAM wParam, LPARAM lParam) {
    UIInputEvent event = {};
    event.type = type;
    event.pointerButton = button;
    event.position = UIPoint(
        static_cast<float>(GET_X_LPARAM(lParam)),
        static_cast<float>(GET_Y_LPARAM(lParam)));
    event.modifiers = m_inputModifierTracker.BuildPointerModifiers(static_cast<std::size_t>(wParam));
    m_pendingInputEvents.push_back(event);
}

void Application::QueuePointerLeaveEvent() {
    UIInputEvent event = {};
    event.type = UIInputEventType::PointerLeave;
    if (m_hwnd != nullptr) {
        POINT clientPoint = {};
        GetCursorPos(&clientPoint);
        ScreenToClient(m_hwnd, &clientPoint);
        event.position = UIPoint(static_cast<float>(clientPoint.x), static_cast<float>(clientPoint.y));
    }
    m_pendingInputEvents.push_back(event);
}

void Application::QueuePointerWheelEvent(short wheelDelta, WPARAM wParam, LPARAM lParam) {
    if (m_hwnd == nullptr) {
        return;
    }

    POINT screenPoint = {
        GET_X_LPARAM(lParam),
        GET_Y_LPARAM(lParam)
    };
    ScreenToClient(m_hwnd, &screenPoint);

    UIInputEvent event = {};
    event.type = UIInputEventType::PointerWheel;
    event.position = UIPoint(static_cast<float>(screenPoint.x), static_cast<float>(screenPoint.y));
    event.wheelDelta = static_cast<float>(wheelDelta);
    event.modifiers = m_inputModifierTracker.BuildPointerModifiers(static_cast<std::size_t>(wParam));
    m_pendingInputEvents.push_back(event);
}

void Application::QueueKeyEvent(UIInputEventType type, WPARAM wParam, LPARAM lParam) {
    UIInputEvent event = {};
    event.type = type;
    event.keyCode = MapVirtualKeyToUIKeyCode(wParam);
    event.modifiers = m_inputModifierTracker.ApplyKeyMessage(type, wParam, lParam);
    event.repeat = IsRepeatKeyMessage(lParam);
    m_pendingInputEvents.push_back(event);
}

void Application::QueueCharacterEvent(WPARAM wParam, LPARAM) {
    UIInputEvent event = {};
    event.type = UIInputEventType::Character;
    event.character = static_cast<std::uint32_t>(wParam);
    event.modifiers = m_inputModifierTracker.GetCurrentModifiers();
    m_pendingInputEvents.push_back(event);
}

void Application::QueueWindowFocusEvent(UIInputEventType type) {
    UIInputEvent event = {};
    event.type = type;
    m_pendingInputEvents.push_back(event);
}

bool Application::LoadStructuredScreen(const char* triggerReason) {
    (void)triggerReason;
    m_screenAsset = {};
    m_screenAsset.screenId = m_shellAssetDefinition.screenId;
    m_screenAsset.documentPath = m_shellAssetDefinition.documentPath.string();
    m_screenAsset.themePath = m_shellAssetDefinition.themePath.string();

    const bool loaded = m_screenPlayer.Load(m_screenAsset);
    const EditorShellAssetValidationResult shellAssetValidation =
        ValidateEditorShellAsset(m_shellAssetDefinition);
    m_useStructuredScreen = loaded;
    m_runtimeStatus = loaded ? "XCUI Editor Shell" : "Editor Shell | Load Error";
    m_runtimeError.clear();
    if (!loaded) {
        AppendErrorMessage(m_runtimeError, m_screenPlayer.GetLastError());
    }
    if (!shellAssetValidation.IsValid()) {
        AppendErrorMessage(
            m_runtimeError,
            "Editor shell asset invalid: " + shellAssetValidation.message);
    }
    RebuildTrackedFileStates();
    return loaded;
}

void Application::RefreshStructuredScreen() {
    const auto now = std::chrono::steady_clock::now();
    if (m_lastReloadPollTime.time_since_epoch().count() != 0 &&
        now - m_lastReloadPollTime < kReloadPollInterval) {
        return;
    }

    m_lastReloadPollTime = now;
    if (DetectTrackedFileChange()) {
        LoadStructuredScreen("reload");
    }
}

void Application::RebuildTrackedFileStates() {
    namespace fs = std::filesystem;

    m_trackedFiles.clear();
    std::unordered_set<std::string> seenPaths = {};
    std::error_code errorCode = {};

    auto appendTrackedPath = [&](const std::string& rawPath) {
        if (rawPath.empty()) {
            return;
        }

        const fs::path normalizedPath = fs::path(rawPath).lexically_normal();
        const std::string key = normalizedPath.string();
        if (!seenPaths.insert(key).second) {
            return;
        }

        TrackedFileState state = {};
        state.path = normalizedPath;
        state.exists = fs::exists(normalizedPath, errorCode);
        errorCode.clear();
        if (state.exists) {
            state.writeTime = fs::last_write_time(normalizedPath, errorCode);
            errorCode.clear();
        }
        m_trackedFiles.push_back(std::move(state));
    };

    appendTrackedPath(m_screenAsset.documentPath);
    appendTrackedPath(m_screenAsset.themePath);

    if (const auto* document = m_screenPlayer.GetDocument(); document != nullptr) {
        for (const std::string& dependency : document->dependencies) {
            appendTrackedPath(dependency);
        }
    }
}

bool Application::DetectTrackedFileChange() const {
    namespace fs = std::filesystem;

    std::error_code errorCode = {};
    for (const TrackedFileState& trackedFile : m_trackedFiles) {
        const bool existsNow = fs::exists(trackedFile.path, errorCode);
        errorCode.clear();
        if (existsNow != trackedFile.exists) {
            return true;
        }

        if (!existsNow) {
            continue;
        }

        const auto writeTimeNow = fs::last_write_time(trackedFile.path, errorCode);
        errorCode.clear();
        if (writeTimeNow != trackedFile.writeTime) {
            return true;
        }
    }

    return false;
}

void Application::AppendRuntimeOverlay(UIDrawData& drawData, float width, float height) const {
    const bool authoredMode = m_useStructuredScreen && m_screenPlayer.IsLoaded();
    const float panelWidth = authoredMode ? 430.0f : 380.0f;
    std::vector<std::string> detailLines = {};
    detailLines.push_back(
        authoredMode
            ? "Hot reload watches editor shell resources."
            : "Authored editor shell failed to load.");
    detailLines.push_back("Document: editor_shell.xcui");

    if (authoredMode) {
        const auto& inputDebug = m_documentHost.GetInputDebugSnapshot();
        detailLines.push_back(
            "Hover | Focus: " +
            ExtractStateKeyTail(inputDebug.hoveredStateKey) +
            " | " +
            ExtractStateKeyTail(inputDebug.focusedStateKey));
        detailLines.push_back(
            "Active | Capture: " +
            ExtractStateKeyTail(inputDebug.activeStateKey) +
            " | " +
            ExtractStateKeyTail(inputDebug.captureStateKey));
        if (!inputDebug.lastEventType.empty()) {
            const std::string eventPosition = inputDebug.lastEventType == "KeyDown" ||
                    inputDebug.lastEventType == "KeyUp" ||
                    inputDebug.lastEventType == "Character" ||
                    inputDebug.lastEventType == "FocusGained" ||
                    inputDebug.lastEventType == "FocusLost"
                ? std::string()
                : " at " + FormatPoint(inputDebug.pointerPosition);
            detailLines.push_back(
                "Last input: " +
                inputDebug.lastEventType +
                eventPosition);
            detailLines.push_back(
                "Route: " +
                inputDebug.lastTargetKind +
                " -> " +
                ExtractStateKeyTail(inputDebug.lastTargetStateKey));
            detailLines.push_back(
                "Last event result: " +
                (inputDebug.lastResult.empty() ? std::string("n/a") : inputDebug.lastResult));
        }
    }

    if (m_autoScreenshot.HasPendingCapture()) {
        detailLines.push_back("Shot pending...");
    } else if (!m_autoScreenshot.GetLastCaptureSummary().empty()) {
        detailLines.push_back(TruncateText(m_autoScreenshot.GetLastCaptureSummary(), 78u));
    } else {
        detailLines.push_back("Screenshots: F12 -> new_editor/captures/");
    }

    if (!m_runtimeError.empty()) {
        detailLines.push_back(TruncateText(m_runtimeError, 78u));
    } else if (!m_autoScreenshot.GetLastCaptureError().empty()) {
        detailLines.push_back(TruncateText(m_autoScreenshot.GetLastCaptureError(), 78u));
    } else if (!authoredMode) {
        detailLines.push_back("No fallback sandbox is rendered in this host.");
    }

    const float panelHeight = 38.0f + static_cast<float>(detailLines.size()) * 18.0f;
    const UIRect panelRect(width - panelWidth - 16.0f, height - panelHeight - 42.0f, panelWidth, panelHeight);

    UIDrawList& overlay = drawData.EmplaceDrawList("XCUI Editor Runtime Overlay");
    overlay.AddFilledRect(panelRect, kOverlayBgColor, 10.0f);
    overlay.AddRectOutline(panelRect, kOverlayBorderColor, 1.0f, 10.0f);
    overlay.AddFilledRect(
        UIRect(panelRect.x + 12.0f, panelRect.y + 14.0f, 8.0f, 8.0f),
        authoredMode ? kOverlaySuccess : kOverlayFallback,
        4.0f);
    overlay.AddText(
        UIPoint(panelRect.x + 28.0f, panelRect.y + 10.0f),
        m_runtimeStatus.empty() ? "XCUI Editor Shell" : m_runtimeStatus,
        kOverlayTextPrimary,
        14.0f);

    float detailY = panelRect.y + 30.0f;
    for (std::size_t index = 0; index < detailLines.size(); ++index) {
        const bool lastLine = index + 1u == detailLines.size();
        overlay.AddText(
            UIPoint(panelRect.x + 28.0f, detailY),
            detailLines[index],
            lastLine && (!m_runtimeError.empty() || !m_autoScreenshot.GetLastCaptureError().empty())
                ? kOverlayFallback
                : kOverlayTextMuted,
            12.0f);
        detailY += 18.0f;
    }
}

std::filesystem::path Application::ResolveRepoRootPath() {
    std::string root = XCUIEDITOR_REPO_ROOT;
    if (root.size() >= 2u && root.front() == '"' && root.back() == '"') {
        root = root.substr(1u, root.size() - 2u);
    }
    return std::filesystem::path(root).lexically_normal();
}

LRESULT CALLBACK Application::WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
    if (message == WM_NCCREATE) {
        const auto* createStruct = reinterpret_cast<CREATESTRUCTW*>(lParam);
        auto* application = reinterpret_cast<Application*>(createStruct->lpCreateParams);
        SetWindowLongPtrW(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(application));
        return TRUE;
    }

    Application* application = GetApplicationFromWindow(hwnd);
    switch (message) {
    case WM_SIZE:
        if (application != nullptr && wParam != SIZE_MINIMIZED) {
            application->OnResize(static_cast<UINT>(LOWORD(lParam)), static_cast<UINT>(HIWORD(lParam)));
        }
        return 0;
    case WM_PAINT:
        if (application != nullptr) {
            PAINTSTRUCT paintStruct = {};
            BeginPaint(hwnd, &paintStruct);
            application->RenderFrame();
            EndPaint(hwnd, &paintStruct);
            return 0;
        }
        break;
    case WM_MOUSEMOVE:
        if (application != nullptr) {
            if (!application->m_trackingMouseLeave) {
                TRACKMOUSEEVENT trackMouseEvent = {};
                trackMouseEvent.cbSize = sizeof(trackMouseEvent);
                trackMouseEvent.dwFlags = TME_LEAVE;
                trackMouseEvent.hwndTrack = hwnd;
                if (TrackMouseEvent(&trackMouseEvent)) {
                    application->m_trackingMouseLeave = true;
                }
            }
            application->QueuePointerEvent(UIInputEventType::PointerMove, UIPointerButton::None, wParam, lParam);
            return 0;
        }
        break;
    case WM_MOUSELEAVE:
        if (application != nullptr) {
            application->m_trackingMouseLeave = false;
            application->QueuePointerLeaveEvent();
            return 0;
        }
        break;
    case WM_LBUTTONDOWN:
        if (application != nullptr) {
            SetFocus(hwnd);
            SetCapture(hwnd);
            application->QueuePointerEvent(UIInputEventType::PointerButtonDown, UIPointerButton::Left, wParam, lParam);
            return 0;
        }
        break;
    case WM_LBUTTONUP:
        if (application != nullptr) {
            if (GetCapture() == hwnd) {
                ReleaseCapture();
            }
            application->QueuePointerEvent(UIInputEventType::PointerButtonUp, UIPointerButton::Left, wParam, lParam);
            return 0;
        }
        break;
    case WM_MOUSEWHEEL:
        if (application != nullptr) {
            application->QueuePointerWheelEvent(GET_WHEEL_DELTA_WPARAM(wParam), wParam, lParam);
            return 0;
        }
        break;
    case WM_SETFOCUS:
        if (application != nullptr) {
            application->m_inputModifierTracker.SyncFromSystemState();
            application->QueueWindowFocusEvent(UIInputEventType::FocusGained);
            return 0;
        }
        break;
    case WM_KILLFOCUS:
        if (application != nullptr) {
            application->m_inputModifierTracker.Reset();
            application->QueueWindowFocusEvent(UIInputEventType::FocusLost);
            return 0;
        }
        break;
    case WM_KEYDOWN:
    case WM_SYSKEYDOWN:
        if (application != nullptr) {
            if (wParam == VK_F12) {
                application->m_autoScreenshot.RequestCapture("manual_f12");
            }
            application->QueueKeyEvent(UIInputEventType::KeyDown, wParam, lParam);
            return 0;
        }
        break;
    case WM_KEYUP:
    case WM_SYSKEYUP:
        if (application != nullptr) {
            application->QueueKeyEvent(UIInputEventType::KeyUp, wParam, lParam);
            return 0;
        }
        break;
    case WM_CHAR:
        if (application != nullptr) {
            application->QueueCharacterEvent(wParam, lParam);
            return 0;
        }
        break;
    case WM_ERASEBKGND:
        return 1;
    case WM_DESTROY:
        if (application != nullptr) {
            application->m_hwnd = nullptr;
        }
        PostQuitMessage(0);
        return 0;
    default:
        break;
    }

    return DefWindowProcW(hwnd, message, wParam, lParam);
}

int RunXCUIEditorApp(HINSTANCE hInstance, int nCmdShow) {
    Application application;
    return application.Run(hInstance, nCmdShow);
}

} // namespace XCEngine::UI::Editor