XCEngine/editor/app/Platform/Win32/Windowing/EditorWindow.h

#pragma once

#ifndef NOMINMAX
#define NOMINMAX
#endif

#include "Platform/Win32/Windowing/EditorWindowSession.h"
#include "Windowing/Host/EditorWindowHostInterfaces.h"

#include <windows.h>

#include <cstdint>
#include <filesystem>
#include <memory>
#include <string>
#include <string_view>
#include <vector>

namespace XCEngine::UI {

class UIDrawData;
class UIDrawList;

struct UIPoint;
struct UIRect;
struct UIInputEvent;
struct UIInputModifiers;

enum class UIPointerButton : std::uint8_t;
enum class UIInputEventType : std::uint8_t;

} // namespace XCEngine::UI

namespace XCEngine::UI::Editor {

struct UIEditorDockHostTabDropTarget;
class UIEditorWorkspaceController;

struct UIEditorDockHostInteractionState;
struct UIEditorShellInteractionFrame;
struct UIEditorShellInteractionState;
struct UIEditorShellInteractionResult;

namespace Widgets {
struct UIEditorDockHostDropPreviewState;
}

} // namespace XCEngine::UI::Editor

namespace XCEngine::UI::Editor::App {

class EditorContext;
class EditorWindowContentController;
class EditorWindowChromeController;
class EditorWindowDockHostBinding;
class EditorWindowFrameDriver;
class EditorWindowFrameOrchestrator;
class EditorWindowHostRuntime;
class EditorWindowInputController;
class EditorWindowLifecycleCoordinator;
class EditorWindowMessageDispatcher;
class EditorWindowRuntimeController;
class EditorWindowWorkspaceCoordinator;
class EditorWindowSession;
struct EditorWorkspaceWindowProjection;

class EditorWindow final : public EditorHostWindow {
public:
    EditorWindow(
        std::string windowId,
        std::wstring title,
        EditorWindowCategory category,
        EditorWindowChromePolicy chromePolicy,
        bool primary,
        std::unique_ptr<EditorWindowContentController> contentController);
    ~EditorWindow();

    EditorWindow(const EditorWindow&) = delete;
    EditorWindow& operator=(const EditorWindow&) = delete;
    EditorWindow(EditorWindow&&) = delete;
    EditorWindow& operator=(EditorWindow&&) = delete;

    std::string_view GetWindowId() const override;
    HWND GetHwnd() const;
    bool HasHwnd() const;
    EditorWindowCategory GetCategory() const;
    const EditorWindowChromePolicy& GetChromePolicy() const;
    EditorWindowLifecycleState GetLifecycleState() const override;
    bool IsPrimary() const override;
    bool IsWorkspaceWindow() const override;
    bool IsUtilityWindow() const override;
    bool IsClosing() const override;
    bool IsDestroyed() const override;
    bool HasLiveHostWindow() const override;
    const std::wstring& GetTitle() const override;
    std::string_view GetCachedTitleText() const;
    const UIEditorWorkspaceController* TryGetWorkspaceController() const override;
    const EditorWorkspaceWindowProjection* TryGetWorkspaceProjection() const override;
    const UIEditorWorkspaceController& GetWorkspaceController() const;
    EditorWindowDockHostBinding* TryGetDockHostBinding() override;
    const EditorWindowDockHostBinding* TryGetDockHostBinding() const override;
    ::XCEngine::UI::UIPoint ConvertScreenPixelsToClientDips(
        const EditorWindowScreenPoint& screenPoint) const override;

private:
    friend class EditorWindowChromeController;
    friend class EditorWindowFrameDriver;
    friend class EditorWindowHostRuntime;
    friend class EditorWindowMessageDispatcher;
    friend class EditorWindowLifecycleCoordinator;
    friend class EditorWindowWorkspaceCoordinator;

    bool IsRenderReady() const override;
    bool TryResolveDockTabDragHotspot(
        std::string_view nodeId,
        std::string_view panelId,
        const EditorWindowScreenPoint& screenPoint,
        EditorWindowScreenPoint& outHotspot) const override;
    bool TryResolveDockTabDropTarget(
        const EditorWindowScreenPoint& screenPoint,
        UIEditorDockHostTabDropTarget& outTarget) const override;
    void InvalidateHostWindow() const override;

    void AttachHwnd(HWND hwnd);
    void MarkInitializing();
    void MarkRunning();
    void MarkDestroyed() override;
    void MarkClosing() override;
    void SetPrimary(bool primary) override;
    void SetTitle(std::wstring title) override;
    void ApplyHostWindowTitle() override;
    void RefreshWorkspaceProjection(EditorWorkspaceWindowProjection projection) override;

    bool Initialize(
        const std::filesystem::path& repoRoot,
        EditorContext& editorContext,
        const std::filesystem::path& captureRoot,
        bool autoCaptureOnStartup);
    void Shutdown() override;
    void ResetInteractionState() override;
    bool TryGetHostScreenRect(EditorWindowScreenRect& outRect) const override;
    void SetHostScreenPosition(const EditorWindowScreenPoint& screenPoint) override;
    void FocusHostWindow() override;
    void PostCloseToHost() override;
    void DestroyHostWindow() override;

    EditorWindowFrameTransferRequests RenderFrame(
        EditorContext& editorContext,
        bool globalTabDragActive);
    EditorWindowFrameTransferRequests OnPaintMessage(
        EditorContext& editorContext,
        bool globalTabDragActive);
    void QueueCompletedImmediateFrame(
        EditorWindowFrameTransferRequests transferRequests);
    bool HasQueuedCompletedImmediateFrame() const;
    EditorWindowFrameTransferRequests ConsumeQueuedCompletedImmediateFrameTransferRequests();
    void RequestSkipNextSteadyStateFrame();
    bool ConsumeSkipNextSteadyStateFrame();
    bool OnResize(UINT width, UINT height);
    void OnEnterSizeMove();
    bool OnExitSizeMove();
    void OnDpiChanged(UINT dpi, const RECT& suggestedRect);

    bool ApplyCurrentCursor() const;
    bool HasInteractiveCaptureState() const;
    bool OwnsPointerCapture(EditorWindowPointerCaptureOwner owner) const;
    void AcquirePointerCapture(EditorWindowPointerCaptureOwner owner) override;
    void ReleasePointerCapture(EditorWindowPointerCaptureOwner owner) override;
    void ForceReleasePointerCapture();
    void TryStartImmediateShellPointerCapture(LPARAM lParam);

    void QueuePointerEvent(
        ::XCEngine::UI::UIInputEventType type,
        ::XCEngine::UI::UIPointerButton button,
        WPARAM wParam,
        LPARAM lParam,
        bool doubleClick = false);
    void QueueSyntheticPointerStateSyncEvent(
        const ::XCEngine::UI::UIInputModifiers& modifiers);
    void QueuePointerLeaveEvent();
    void QueuePointerWheelEvent(short wheelDelta, WPARAM wParam, LPARAM lParam);
    void SyncShellCapturedPointerButtonsFromSystemState();

    bool ApplyWindowResize(UINT width, UINT height);
    bool QueryCurrentClientPixelSize(UINT& outWidth, UINT& outHeight) const;
    bool ResolveRenderClientPixelSize(UINT& outWidth, UINT& outHeight) const;
    ::XCEngine::UI::UIRect ResolveWorkspaceBounds(
        float clientWidthDips,
        float clientHeightDips) const;
    static POINT ToNativePoint(const EditorWindowScreenPoint& screenPoint);
    static EditorWindowScreenPoint FromNativePoint(const POINT& screenPoint);
    EditorWindowFrameTransferRequests RenderRuntimeFrame(
        EditorContext& editorContext,
        bool globalTabDragActive,
        const ::XCEngine::UI::UIRect& workspaceBounds,
        ::XCEngine::UI::UIDrawData& drawData);
    bool IsPointerInsideClientArea() const;
    LPCWSTR ResolveCurrentCursorResource() const;
    float GetDpiScale() const;
    float PixelsToDips(float pixels) const;
    ::XCEngine::UI::UIPoint ConvertClientPixelsToDips(LONG x, LONG y) const;
    void ApplyShellRuntimePointerCapture();
    static bool IsVerboseRuntimeTraceEnabled();

    std::unique_ptr<EditorWindowSession> m_session = {};
    std::unique_ptr<EditorWindowChromeController> m_chromeController = {};
    std::unique_ptr<EditorWindowFrameOrchestrator> m_frameOrchestrator = {};
    std::unique_ptr<EditorWindowInputController> m_inputController = {};
    std::unique_ptr<EditorWindowRuntimeController> m_runtime = {};
};

} // namespace XCEngine::UI::Editor::App