#include "XCUIBackend/XCUIShellChromeState.h"

namespace XCEngine {
namespace Editor {
namespace XCUIBackend {

namespace {

constexpr std::size_t ToIndex(XCUIShellPanelId panelId) {
    return static_cast<std::size_t>(panelId);
}

} // namespace

XCUIShellChromeState::XCUIShellChromeState() {
    m_panels[ToIndex(XCUIShellPanelId::XCUIDemo)] = {
        XCUIShellPanelId::XCUIDemo,
        "XCUI Demo",
        "XCUI Demo",
        "new_editor.panels.xcui_demo",
        true,
        true,
        XCUIShellHostedPreviewMode::NativeOffscreen
    };
    m_panels[ToIndex(XCUIShellPanelId::XCUILayoutLab)] = {
        XCUIShellPanelId::XCUILayoutLab,
        "XCUI Layout Lab",
        "XCUI Layout Lab",
        "new_editor.panels.xcui_layout_lab",
        true,
        true,
        XCUIShellHostedPreviewMode::LegacyImGui
    };
}

const XCUIShellViewToggleState& XCUIShellChromeState::GetViewToggles() const {
    return m_viewToggles;
}

const std::array<XCUIShellPanelChromeState, static_cast<std::size_t>(XCUIShellPanelId::Count)>&
XCUIShellChromeState::GetPanels() const {
    return m_panels;
}

const XCUIShellPanelChromeState* XCUIShellChromeState::TryGetPanelState(XCUIShellPanelId panelId) const {
    const std::size_t index = ToIndex(panelId);
    if (index >= m_panels.size()) {
        return nullptr;
    }

    return &m_panels[index];
}

XCUIShellPanelChromeState* XCUIShellChromeState::TryGetPanelStateMutable(XCUIShellPanelId panelId) {
    const std::size_t index = ToIndex(panelId);
    if (index >= m_panels.size()) {
        return nullptr;
    }

    return &m_panels[index];
}

bool XCUIShellChromeState::IsPanelVisible(XCUIShellPanelId panelId) const {
    const XCUIShellPanelChromeState* panelState = TryGetPanelState(panelId);
    return panelState != nullptr && panelState->visible;
}

bool XCUIShellChromeState::SetPanelVisible(XCUIShellPanelId panelId, bool visible) {
    XCUIShellPanelChromeState* panelState = TryGetPanelStateMutable(panelId);
    if (panelState == nullptr || panelState->visible == visible) {
        return false;
    }

    panelState->visible = visible;
    return true;
}

bool XCUIShellChromeState::TogglePanelVisible(XCUIShellPanelId panelId) {
    XCUIShellPanelChromeState* panelState = TryGetPanelStateMutable(panelId);
    if (panelState == nullptr) {
        return false;
    }

    panelState->visible = !panelState->visible;
    return true;
}

bool XCUIShellChromeState::IsHostedPreviewEnabled(XCUIShellPanelId panelId) const {
    const XCUIShellPanelChromeState* panelState = TryGetPanelState(panelId);
    return panelState != nullptr && panelState->hostedPreviewEnabled;
}

bool XCUIShellChromeState::SetHostedPreviewEnabled(XCUIShellPanelId panelId, bool enabled) {
    XCUIShellPanelChromeState* panelState = TryGetPanelStateMutable(panelId);
    if (panelState == nullptr || panelState->hostedPreviewEnabled == enabled) {
        return false;
    }

    panelState->hostedPreviewEnabled = enabled;
    return true;
}

XCUIShellHostedPreviewMode XCUIShellChromeState::GetHostedPreviewMode(XCUIShellPanelId panelId) const {
    const XCUIShellPanelChromeState* panelState = TryGetPanelState(panelId);
    return panelState != nullptr
        ? panelState->previewMode
        : XCUIShellHostedPreviewMode::LegacyImGui;
}

XCUIShellHostedPreviewState XCUIShellChromeState::GetHostedPreviewState(XCUIShellPanelId panelId) const {
    const XCUIShellPanelChromeState* panelState = TryGetPanelState(panelId);
    if (panelState == nullptr || !panelState->hostedPreviewEnabled) {
        return XCUIShellHostedPreviewState::Disabled;
    }

    return panelState->previewMode == XCUIShellHostedPreviewMode::NativeOffscreen
        ? XCUIShellHostedPreviewState::NativeOffscreen
        : XCUIShellHostedPreviewState::LegacyImGui;
}

bool XCUIShellChromeState::IsNativeHostedPreviewActive(XCUIShellPanelId panelId) const {
    return GetHostedPreviewState(panelId) == XCUIShellHostedPreviewState::NativeOffscreen;
}

bool XCUIShellChromeState::IsLegacyHostedPreviewActive(XCUIShellPanelId panelId) const {
    return GetHostedPreviewState(panelId) == XCUIShellHostedPreviewState::LegacyImGui;
}

bool XCUIShellChromeState::SetHostedPreviewMode(
    XCUIShellPanelId panelId,
    XCUIShellHostedPreviewMode mode) {
    XCUIShellPanelChromeState* panelState = TryGetPanelStateMutable(panelId);
    if (panelState == nullptr || panelState->previewMode == mode) {
        return false;
    }

    panelState->previewMode = mode;
    return true;
}

bool XCUIShellChromeState::ToggleHostedPreviewMode(XCUIShellPanelId panelId) {
    XCUIShellPanelChromeState* panelState = TryGetPanelStateMutable(panelId);
    if (panelState == nullptr) {
        return false;
    }

    panelState->previewMode =
        panelState->previewMode == XCUIShellHostedPreviewMode::NativeOffscreen
        ? XCUIShellHostedPreviewMode::LegacyImGui
        : XCUIShellHostedPreviewMode::NativeOffscreen;
    return true;
}

bool XCUIShellChromeState::GetViewToggle(XCUIShellViewToggleId toggleId) const {
    switch (toggleId) {
    case XCUIShellViewToggleId::ImGuiDemoWindow:
        return m_viewToggles.imguiDemoWindowVisible;
    case XCUIShellViewToggleId::NativeBackdrop:
        return m_viewToggles.nativeBackdropVisible;
    case XCUIShellViewToggleId::PulseAccent:
        return m_viewToggles.pulseAccentEnabled;
    case XCUIShellViewToggleId::NativeXCUIOverlay:
        return m_viewToggles.nativeXCUIOverlayVisible;
    case XCUIShellViewToggleId::HostedPreviewHud:
        return m_viewToggles.hostedPreviewHudVisible;
    case XCUIShellViewToggleId::Count:
    default:
        return false;
    }
}

bool XCUIShellChromeState::SetViewToggle(XCUIShellViewToggleId toggleId, bool enabled) {
    bool* target = nullptr;
    switch (toggleId) {
    case XCUIShellViewToggleId::ImGuiDemoWindow:
        target = &m_viewToggles.imguiDemoWindowVisible;
        break;
    case XCUIShellViewToggleId::NativeBackdrop:
        target = &m_viewToggles.nativeBackdropVisible;
        break;
    case XCUIShellViewToggleId::PulseAccent:
        target = &m_viewToggles.pulseAccentEnabled;
        break;
    case XCUIShellViewToggleId::NativeXCUIOverlay:
        target = &m_viewToggles.nativeXCUIOverlayVisible;
        break;
    case XCUIShellViewToggleId::HostedPreviewHud:
        target = &m_viewToggles.hostedPreviewHudVisible;
        break;
    case XCUIShellViewToggleId::Count:
    default:
        return false;
    }

    if (*target == enabled) {
        return false;
    }

    *target = enabled;
    return true;
}

bool XCUIShellChromeState::ToggleViewToggle(XCUIShellViewToggleId toggleId) {
    return SetViewToggle(toggleId, !GetViewToggle(toggleId));
}

bool XCUIShellChromeState::HasCommand(std::string_view commandId) const {
    return commandId == GetPanelVisibilityCommandId(XCUIShellPanelId::XCUIDemo) ||
        commandId == GetPanelVisibilityCommandId(XCUIShellPanelId::XCUILayoutLab) ||
        commandId == GetViewToggleCommandId(XCUIShellViewToggleId::ImGuiDemoWindow) ||
        commandId == GetViewToggleCommandId(XCUIShellViewToggleId::NativeBackdrop) ||
        commandId == GetViewToggleCommandId(XCUIShellViewToggleId::PulseAccent) ||
        commandId == GetViewToggleCommandId(XCUIShellViewToggleId::NativeXCUIOverlay) ||
        commandId == GetViewToggleCommandId(XCUIShellViewToggleId::HostedPreviewHud) ||
        commandId == GetPanelPreviewModeCommandId(XCUIShellPanelId::XCUIDemo) ||
        commandId == GetPanelPreviewModeCommandId(XCUIShellPanelId::XCUILayoutLab);
}

bool XCUIShellChromeState::InvokeCommand(std::string_view commandId) {
    if (commandId == XCUIShellChromeCommandIds::ToggleXCUIDemoPanel) {
        return TogglePanelVisible(XCUIShellPanelId::XCUIDemo);
    }
    if (commandId == XCUIShellChromeCommandIds::ToggleXCUILayoutLabPanel) {
        return TogglePanelVisible(XCUIShellPanelId::XCUILayoutLab);
    }
    if (commandId == XCUIShellChromeCommandIds::ToggleImGuiDemoWindow) {
        return ToggleViewToggle(XCUIShellViewToggleId::ImGuiDemoWindow);
    }
    if (commandId == XCUIShellChromeCommandIds::ToggleNativeBackdrop) {
        return ToggleViewToggle(XCUIShellViewToggleId::NativeBackdrop);
    }
    if (commandId == XCUIShellChromeCommandIds::TogglePulseAccent) {
        return ToggleViewToggle(XCUIShellViewToggleId::PulseAccent);
    }
    if (commandId == XCUIShellChromeCommandIds::ToggleNativeXCUIOverlay) {
        return ToggleViewToggle(XCUIShellViewToggleId::NativeXCUIOverlay);
    }
    if (commandId == XCUIShellChromeCommandIds::ToggleHostedPreviewHud) {
        return ToggleViewToggle(XCUIShellViewToggleId::HostedPreviewHud);
    }
    if (commandId == XCUIShellChromeCommandIds::ToggleNativeDemoPanelPreview) {
        return ToggleHostedPreviewMode(XCUIShellPanelId::XCUIDemo);
    }
    if (commandId == XCUIShellChromeCommandIds::ToggleNativeLayoutLabPreview) {
        return ToggleHostedPreviewMode(XCUIShellPanelId::XCUILayoutLab);
    }

    return false;
}

std::string_view XCUIShellChromeState::GetPanelVisibilityCommandId(XCUIShellPanelId panelId) {
    switch (panelId) {
    case XCUIShellPanelId::XCUIDemo:
        return XCUIShellChromeCommandIds::ToggleXCUIDemoPanel;
    case XCUIShellPanelId::XCUILayoutLab:
        return XCUIShellChromeCommandIds::ToggleXCUILayoutLabPanel;
    case XCUIShellPanelId::Count:
    default:
        return {};
    }
}

std::string_view XCUIShellChromeState::GetPanelPreviewModeCommandId(XCUIShellPanelId panelId) {
    switch (panelId) {
    case XCUIShellPanelId::XCUIDemo:
        return XCUIShellChromeCommandIds::ToggleNativeDemoPanelPreview;
    case XCUIShellPanelId::XCUILayoutLab:
        return XCUIShellChromeCommandIds::ToggleNativeLayoutLabPreview;
    case XCUIShellPanelId::Count:
    default:
        return {};
    }
}

std::string_view XCUIShellChromeState::GetViewToggleCommandId(XCUIShellViewToggleId toggleId) {
    switch (toggleId) {
    case XCUIShellViewToggleId::ImGuiDemoWindow:
        return XCUIShellChromeCommandIds::ToggleImGuiDemoWindow;
    case XCUIShellViewToggleId::NativeBackdrop:
        return XCUIShellChromeCommandIds::ToggleNativeBackdrop;
    case XCUIShellViewToggleId::PulseAccent:
        return XCUIShellChromeCommandIds::TogglePulseAccent;
    case XCUIShellViewToggleId::NativeXCUIOverlay:
        return XCUIShellChromeCommandIds::ToggleNativeXCUIOverlay;
    case XCUIShellViewToggleId::HostedPreviewHud:
        return XCUIShellChromeCommandIds::ToggleHostedPreviewHud;
    case XCUIShellViewToggleId::Count:
    default:
        return {};
    }
}

} // namespace XCUIBackend
} // namespace Editor
} // namespace XCEngine