#pragma once

#include "BorderlessWindowFrame.h"

#include <windows.h>

namespace XCEngine::UI::Editor::Host {

struct BorderlessWindowResizeState {
    bool active = false;
    BorderlessWindowResizeEdge edge = BorderlessWindowResizeEdge::None;
    POINT initialScreenPoint = {};
    RECT initialWindowRect = {};
    BorderlessWindowResizeEdge hoveredEdge = BorderlessWindowResizeEdge::None;
};

struct PredictedClientPixelSize {
    bool active = false;
    UINT width = 0u;
    UINT height = 0u;
};

struct BorderlessWindowPlacementState {
    bool maximized = false;
    bool hasRestoreRect = false;
    RECT restoreRect = {};
};

struct BorderlessWindowDragRestoreState {
    bool armed = false;
    POINT initialScreenPoint = {};
};

class HostRuntimeState {
public:
    void Reset() {
        m_windowDpi = 96u;
        m_inInteractiveResize = false;
        m_borderlessResizeState = {};
        m_predictedClientPixelSize = {};
        m_borderlessWindowPlacementState = {};
        m_borderlessWindowDragRestoreState = {};
    }

    void SetWindowDpi(UINT dpi) {
        m_windowDpi = dpi == 0u ? 96u : dpi;
    }

    UINT GetWindowDpi() const {
        return m_windowDpi;
    }

    float GetDpiScale(float baseDpiScale) const {
        return baseDpiScale > 0.0f
            ? static_cast<float>(m_windowDpi) / baseDpiScale
            : 1.0f;
    }

    void BeginInteractiveResize() {
        m_inInteractiveResize = true;
    }

    void EndInteractiveResize() {
        m_inInteractiveResize = false;
    }

    bool IsInteractiveResize() const {
        return m_inInteractiveResize;
    }

    void BeginBorderlessResize(
        BorderlessWindowResizeEdge edge,
        const POINT& initialScreenPoint,
        const RECT& initialWindowRect) {
        m_borderlessResizeState.active = edge != BorderlessWindowResizeEdge::None;
        m_borderlessResizeState.edge = edge;
        m_borderlessResizeState.initialScreenPoint = initialScreenPoint;
        m_borderlessResizeState.initialWindowRect = initialWindowRect;
        m_borderlessResizeState.hoveredEdge = edge;
        m_inInteractiveResize = m_borderlessResizeState.active;
    }

    void EndBorderlessResize() {
        m_borderlessResizeState.active = false;
        m_borderlessResizeState.edge = BorderlessWindowResizeEdge::None;
        m_inInteractiveResize = false;
        m_predictedClientPixelSize = {};
    }

    bool IsBorderlessResizeActive() const {
        return m_borderlessResizeState.active;
    }

    BorderlessWindowResizeEdge GetBorderlessResizeEdge() const {
        return m_borderlessResizeState.edge;
    }

    const POINT& GetBorderlessResizeInitialScreenPoint() const {
        return m_borderlessResizeState.initialScreenPoint;
    }

    const RECT& GetBorderlessResizeInitialWindowRect() const {
        return m_borderlessResizeState.initialWindowRect;
    }

    void SetHoveredBorderlessResizeEdge(BorderlessWindowResizeEdge edge) {
        m_borderlessResizeState.hoveredEdge = edge;
    }

    BorderlessWindowResizeEdge GetHoveredBorderlessResizeEdge() const {
        return m_borderlessResizeState.hoveredEdge;
    }

    void SetPredictedClientPixelSize(UINT width, UINT height) {
        if (width == 0u || height == 0u) {
            m_predictedClientPixelSize = {};
            return;
        }

        m_predictedClientPixelSize.active = true;
        m_predictedClientPixelSize.width = width;
        m_predictedClientPixelSize.height = height;
    }

    void ClearPredictedClientPixelSize() {
        m_predictedClientPixelSize = {};
    }

    bool TryGetPredictedClientPixelSize(UINT& outWidth, UINT& outHeight) const {
        outWidth = 0u;
        outHeight = 0u;
        if (!m_predictedClientPixelSize.active ||
            m_predictedClientPixelSize.width == 0u ||
            m_predictedClientPixelSize.height == 0u) {
            return false;
        }

        outWidth = m_predictedClientPixelSize.width;
        outHeight = m_predictedClientPixelSize.height;
        return true;
    }

    void SetBorderlessWindowMaximized(bool maximized) {
        m_borderlessWindowPlacementState.maximized = maximized;
    }

    bool IsBorderlessWindowMaximized() const {
        return m_borderlessWindowPlacementState.maximized;
    }

    void SetBorderlessWindowRestoreRect(const RECT& rect) {
        m_borderlessWindowPlacementState.restoreRect = rect;
        m_borderlessWindowPlacementState.hasRestoreRect = true;
    }

    bool TryGetBorderlessWindowRestoreRect(RECT& outRect) const {
        outRect = {};
        if (!m_borderlessWindowPlacementState.hasRestoreRect) {
            return false;
        }

        outRect = m_borderlessWindowPlacementState.restoreRect;
        return true;
    }

    void BeginBorderlessWindowDragRestore(const POINT& initialScreenPoint) {
        m_borderlessWindowDragRestoreState.armed = true;
        m_borderlessWindowDragRestoreState.initialScreenPoint = initialScreenPoint;
    }

    void EndBorderlessWindowDragRestore() {
        m_borderlessWindowDragRestoreState = {};
    }

    bool IsBorderlessWindowDragRestoreArmed() const {
        return m_borderlessWindowDragRestoreState.armed;
    }

    const POINT& GetBorderlessWindowDragRestoreInitialScreenPoint() const {
        return m_borderlessWindowDragRestoreState.initialScreenPoint;
    }

private:
    UINT m_windowDpi = 96u;
    bool m_inInteractiveResize = false;
    BorderlessWindowResizeState m_borderlessResizeState = {};
    PredictedClientPixelSize m_predictedClientPixelSize = {};
    BorderlessWindowPlacementState m_borderlessWindowPlacementState = {};
    BorderlessWindowDragRestoreState m_borderlessWindowDragRestoreState = {};
};

} // namespace XCEngine::UI::Editor::Host