#include "XCUIBackend/XCUIShellChromeState.h"

#include <gtest/gtest.h>

namespace {

using XCEngine::Editor::XCUIBackend::XCUIShellChromeCommandIds;
using XCEngine::Editor::XCUIBackend::XCUIShellCommandDescriptor;
using XCEngine::Editor::XCUIBackend::XCUIShellChromeState;
using XCEngine::Editor::XCUIBackend::XCUIShellHostedPreviewMode;
using XCEngine::Editor::XCUIBackend::XCUIShellHostedPreviewState;
using XCEngine::Editor::XCUIBackend::XCUIShellMenuItemKind;
using XCEngine::Editor::XCUIBackend::XCUIShellPanelId;
using XCEngine::Editor::XCUIBackend::XCUIShellViewToggleId;

TEST(XCUIShellChromeStateTest, DefaultsMatchCurrentShellChromeConfiguration) {
    XCUIShellChromeState state = {};

    const auto& viewToggles = state.GetViewToggles();
    EXPECT_FALSE(viewToggles.legacyHostDemoWindowVisible);
    EXPECT_TRUE(viewToggles.nativeBackdropVisible);
    EXPECT_TRUE(viewToggles.pulseAccentEnabled);
    EXPECT_TRUE(viewToggles.nativeXCUIOverlayVisible);
    EXPECT_TRUE(viewToggles.hostedPreviewHudVisible);

    const auto* demoPanel = state.TryGetPanelState(XCUIShellPanelId::XCUIDemo);
    ASSERT_NE(demoPanel, nullptr);
    EXPECT_EQ(demoPanel->panelTitle, "XCUI Demo");
    EXPECT_EQ(demoPanel->previewDebugName, "XCUI Demo");
    EXPECT_EQ(demoPanel->previewDebugSource, "new_editor.panels.xcui_demo");
    EXPECT_TRUE(demoPanel->visible);
    EXPECT_TRUE(demoPanel->hostedPreviewEnabled);
    EXPECT_EQ(demoPanel->previewMode, XCUIShellHostedPreviewMode::NativeOffscreen);
    EXPECT_EQ(
        state.GetHostedPreviewState(XCUIShellPanelId::XCUIDemo),
        XCUIShellHostedPreviewState::NativeOffscreen);
    EXPECT_TRUE(state.IsNativeHostedPreviewActive(XCUIShellPanelId::XCUIDemo));
    EXPECT_FALSE(state.IsHostedPresenterPreviewActive(XCUIShellPanelId::XCUIDemo));

    const auto* layoutLabPanel = state.TryGetPanelState(XCUIShellPanelId::XCUILayoutLab);
    ASSERT_NE(layoutLabPanel, nullptr);
    EXPECT_EQ(layoutLabPanel->panelTitle, "XCUI Layout Lab");
    EXPECT_EQ(layoutLabPanel->previewDebugName, "XCUI Layout Lab");
    EXPECT_EQ(layoutLabPanel->previewDebugSource, "new_editor.panels.xcui_layout_lab");
    EXPECT_TRUE(layoutLabPanel->visible);
    EXPECT_TRUE(layoutLabPanel->hostedPreviewEnabled);
    EXPECT_EQ(layoutLabPanel->previewMode, XCUIShellHostedPreviewMode::HostedPresenter);
    EXPECT_EQ(
        state.GetHostedPreviewState(XCUIShellPanelId::XCUILayoutLab),
        XCUIShellHostedPreviewState::HostedPresenter);
    EXPECT_FALSE(state.IsNativeHostedPreviewActive(XCUIShellPanelId::XCUILayoutLab));
    EXPECT_TRUE(state.IsHostedPresenterPreviewActive(XCUIShellPanelId::XCUILayoutLab));
}

TEST(XCUIShellChromeStateTest, PanelVisibilityAndPreviewModeMutatorsTrackStateChanges) {
    XCUIShellChromeState state = {};

    EXPECT_TRUE(state.SetPanelVisible(XCUIShellPanelId::XCUIDemo, false));
    EXPECT_FALSE(state.IsPanelVisible(XCUIShellPanelId::XCUIDemo));
    EXPECT_FALSE(state.SetPanelVisible(XCUIShellPanelId::XCUIDemo, false));
    EXPECT_TRUE(state.TogglePanelVisible(XCUIShellPanelId::XCUIDemo));
    EXPECT_TRUE(state.IsPanelVisible(XCUIShellPanelId::XCUIDemo));

    EXPECT_TRUE(state.SetHostedPreviewEnabled(XCUIShellPanelId::XCUILayoutLab, false));
    EXPECT_FALSE(state.IsHostedPreviewEnabled(XCUIShellPanelId::XCUILayoutLab));
    EXPECT_FALSE(state.SetHostedPreviewEnabled(XCUIShellPanelId::XCUILayoutLab, false));
    EXPECT_EQ(
        state.GetHostedPreviewMode(XCUIShellPanelId::XCUILayoutLab),
        XCUIShellHostedPreviewMode::HostedPresenter);

    EXPECT_TRUE(state.ToggleHostedPreviewMode(XCUIShellPanelId::XCUILayoutLab));
    EXPECT_EQ(
        state.GetHostedPreviewMode(XCUIShellPanelId::XCUILayoutLab),
        XCUIShellHostedPreviewMode::NativeOffscreen);
    EXPECT_TRUE(state.SetHostedPreviewMode(
        XCUIShellPanelId::XCUILayoutLab,
        XCUIShellHostedPreviewMode::HostedPresenter));
    EXPECT_EQ(
        state.GetHostedPreviewMode(XCUIShellPanelId::XCUILayoutLab),
        XCUIShellHostedPreviewMode::HostedPresenter);
    EXPECT_FALSE(state.SetHostedPreviewMode(
        XCUIShellPanelId::XCUILayoutLab,
        XCUIShellHostedPreviewMode::HostedPresenter));
}

TEST(XCUIShellChromeStateTest, HostedPreviewStateSeparatesEnablementFromRequestedMode) {
    XCUIShellChromeState state = {};

    EXPECT_EQ(
        state.GetHostedPreviewState(XCUIShellPanelId::XCUIDemo),
        XCUIShellHostedPreviewState::NativeOffscreen);

    EXPECT_TRUE(state.SetHostedPreviewEnabled(XCUIShellPanelId::XCUIDemo, false));
    EXPECT_EQ(
        state.GetHostedPreviewState(XCUIShellPanelId::XCUIDemo),
        XCUIShellHostedPreviewState::Disabled);
    EXPECT_FALSE(state.IsNativeHostedPreviewActive(XCUIShellPanelId::XCUIDemo));
    EXPECT_FALSE(state.IsHostedPresenterPreviewActive(XCUIShellPanelId::XCUIDemo));

    EXPECT_TRUE(state.SetHostedPreviewMode(
        XCUIShellPanelId::XCUIDemo,
        XCUIShellHostedPreviewMode::HostedPresenter));
    EXPECT_EQ(
        state.GetHostedPreviewMode(XCUIShellPanelId::XCUIDemo),
        XCUIShellHostedPreviewMode::HostedPresenter);
    EXPECT_EQ(
        state.GetHostedPreviewState(XCUIShellPanelId::XCUIDemo),
        XCUIShellHostedPreviewState::Disabled);

    EXPECT_TRUE(state.SetHostedPreviewEnabled(XCUIShellPanelId::XCUIDemo, true));
    EXPECT_EQ(
        state.GetHostedPreviewState(XCUIShellPanelId::XCUIDemo),
        XCUIShellHostedPreviewState::HostedPresenter);
    EXPECT_FALSE(state.IsNativeHostedPreviewActive(XCUIShellPanelId::XCUIDemo));
    EXPECT_TRUE(state.IsHostedPresenterPreviewActive(XCUIShellPanelId::XCUIDemo));
}

TEST(XCUIShellChromeStateTest, ViewToggleMutatorsOnlyFlipRequestedFlags) {
    XCUIShellChromeState state = {};

    EXPECT_TRUE(state.SetViewToggle(XCUIShellViewToggleId::LegacyHostDemoWindow, true));
    EXPECT_TRUE(state.GetViewToggle(XCUIShellViewToggleId::LegacyHostDemoWindow));
    EXPECT_FALSE(state.SetViewToggle(XCUIShellViewToggleId::LegacyHostDemoWindow, true));

    EXPECT_TRUE(state.ToggleViewToggle(XCUIShellViewToggleId::HostedPreviewHud));
    EXPECT_FALSE(state.GetViewToggle(XCUIShellViewToggleId::HostedPreviewHud));
    EXPECT_TRUE(state.GetViewToggle(XCUIShellViewToggleId::NativeBackdrop));
    EXPECT_TRUE(state.GetViewToggle(XCUIShellViewToggleId::PulseAccent));
    EXPECT_TRUE(state.GetViewToggle(XCUIShellViewToggleId::NativeXCUIOverlay));
}

TEST(XCUIShellChromeStateTest, CommandInterfaceTogglesShellViewAndPreviewStates) {
    XCUIShellChromeState state = {};

    EXPECT_TRUE(state.HasCommand(XCUIShellChromeCommandIds::ToggleXCUIDemoPanel));
    EXPECT_TRUE(state.HasCommand(XCUIShellChromeCommandIds::ToggleHostedPreviewHud));
    EXPECT_TRUE(state.HasCommand(XCUIShellChromeCommandIds::ToggleNativeLayoutLabPreview));
    EXPECT_FALSE(state.HasCommand("new_editor.view.unknown"));

    EXPECT_TRUE(state.InvokeCommand(XCUIShellChromeCommandIds::ToggleXCUIDemoPanel));
    EXPECT_FALSE(state.IsPanelVisible(XCUIShellPanelId::XCUIDemo));

    EXPECT_TRUE(state.InvokeCommand(XCUIShellChromeCommandIds::ToggleHostedPreviewHud));
    EXPECT_FALSE(state.GetViewToggle(XCUIShellViewToggleId::HostedPreviewHud));

    EXPECT_TRUE(state.InvokeCommand(XCUIShellChromeCommandIds::ToggleNativeLayoutLabPreview));
    EXPECT_EQ(
        state.GetHostedPreviewMode(XCUIShellPanelId::XCUILayoutLab),
        XCUIShellHostedPreviewMode::NativeOffscreen);
    EXPECT_TRUE(state.InvokeCommand(XCUIShellChromeCommandIds::ToggleNativeLayoutLabPreview));
    EXPECT_EQ(
        state.GetHostedPreviewMode(XCUIShellPanelId::XCUILayoutLab),
        XCUIShellHostedPreviewMode::HostedPresenter);

    EXPECT_FALSE(state.InvokeCommand("new_editor.view.unknown"));
}

TEST(XCUIShellChromeStateTest, CommandDescriptorsMatchCurrentShellMenuLabelsShortcutsAndCheckedState) {
    XCUIShellChromeState state = {};
    XCUIShellCommandDescriptor descriptor = {};

    ASSERT_TRUE(state.TryGetCommandDescriptor(XCUIShellChromeCommandIds::ToggleXCUIDemoPanel, descriptor));
    EXPECT_EQ(descriptor.label, "XCUI Demo");
    EXPECT_EQ(descriptor.shortcut, "Ctrl+1");
    EXPECT_EQ(descriptor.commandId, XCUIShellChromeCommandIds::ToggleXCUIDemoPanel);
    EXPECT_TRUE(descriptor.checkable);
    EXPECT_TRUE(descriptor.checked);
    EXPECT_TRUE(descriptor.enabled);

    ASSERT_TRUE(state.TryGetCommandDescriptor(XCUIShellChromeCommandIds::ToggleHostedPreviewHud, descriptor));
    EXPECT_EQ(descriptor.label, "Hosted Preview HUD");
    EXPECT_EQ(descriptor.shortcut, "Ctrl+Shift+H");
    EXPECT_TRUE(descriptor.checked);

    ASSERT_TRUE(state.TryGetCommandDescriptor(XCUIShellChromeCommandIds::ToggleNativeLayoutLabPreview, descriptor));
    EXPECT_EQ(descriptor.label, "Native Layout Lab Preview");
    EXPECT_EQ(descriptor.shortcut, "Ctrl+Alt+2");
    EXPECT_FALSE(descriptor.checked);

    EXPECT_FALSE(state.TryGetCommandDescriptor("new_editor.view.unknown", descriptor));
    EXPECT_TRUE(descriptor.label.empty());
    EXPECT_TRUE(descriptor.shortcut.empty());
    EXPECT_TRUE(descriptor.commandId.empty());
    EXPECT_FALSE(descriptor.checked);
    EXPECT_FALSE(descriptor.enabled);
}

TEST(XCUIShellChromeStateTest, ViewMenuDescriptorMatchesCurrentApplicationOrderingAndSeparators) {
    XCUIShellChromeState state = {};

    const auto menu = state.BuildViewMenuDescriptor();
    ASSERT_EQ(menu.label, "View");
    ASSERT_EQ(menu.items.size(), 10u);

    ASSERT_EQ(menu.items[0].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[0].command.label, "XCUI Demo");
    EXPECT_EQ(menu.items[0].command.shortcut, "Ctrl+1");
    EXPECT_EQ(menu.items[0].command.commandId, XCUIShellChromeCommandIds::ToggleXCUIDemoPanel);
    EXPECT_TRUE(menu.items[0].command.checked);

    ASSERT_EQ(menu.items[1].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[1].command.label, "XCUI Layout Lab");
    EXPECT_EQ(menu.items[1].command.shortcut, "Ctrl+2");
    EXPECT_EQ(menu.items[1].command.commandId, XCUIShellChromeCommandIds::ToggleXCUILayoutLabPanel);

    ASSERT_EQ(menu.items[2].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[2].command.label, "Legacy Host Demo");
    EXPECT_EQ(menu.items[2].command.shortcut, "Ctrl+3");
    EXPECT_EQ(menu.items[2].command.commandId, XCUIShellChromeCommandIds::ToggleLegacyHostDemoWindow);

    EXPECT_EQ(menu.items[3].kind, XCUIShellMenuItemKind::Separator);

    ASSERT_EQ(menu.items[4].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[4].command.label, "Native Backdrop");
    EXPECT_EQ(menu.items[4].command.shortcut, "Ctrl+Shift+B");
    EXPECT_EQ(menu.items[4].command.commandId, XCUIShellChromeCommandIds::ToggleNativeBackdrop);

    ASSERT_EQ(menu.items[5].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[5].command.label, "Pulse Accent");
    EXPECT_EQ(menu.items[5].command.shortcut, "Ctrl+Shift+P");
    EXPECT_EQ(menu.items[5].command.commandId, XCUIShellChromeCommandIds::TogglePulseAccent);

    ASSERT_EQ(menu.items[6].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[6].command.label, "Native XCUI Overlay");
    EXPECT_EQ(menu.items[6].command.shortcut, "Ctrl+Shift+O");
    EXPECT_EQ(menu.items[6].command.commandId, XCUIShellChromeCommandIds::ToggleNativeXCUIOverlay);

    ASSERT_EQ(menu.items[7].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[7].command.label, "Hosted Preview HUD");
    EXPECT_EQ(menu.items[7].command.shortcut, "Ctrl+Shift+H");
    EXPECT_EQ(menu.items[7].command.commandId, XCUIShellChromeCommandIds::ToggleHostedPreviewHud);

    ASSERT_EQ(menu.items[8].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[8].command.label, "Native Demo Panel Preview");
    EXPECT_EQ(menu.items[8].command.shortcut, "Ctrl+Alt+1");
    EXPECT_EQ(menu.items[8].command.commandId, XCUIShellChromeCommandIds::ToggleNativeDemoPanelPreview);

    ASSERT_EQ(menu.items[9].kind, XCUIShellMenuItemKind::Command);
    EXPECT_EQ(menu.items[9].command.label, "Native Layout Lab Preview");
    EXPECT_EQ(menu.items[9].command.shortcut, "Ctrl+Alt+2");
    EXPECT_EQ(menu.items[9].command.commandId, XCUIShellChromeCommandIds::ToggleNativeLayoutLabPreview);
}

TEST(XCUIShellChromeStateTest, ViewMenuDescriptorCheckedStateTracksShellStateChanges) {
    XCUIShellChromeState state = {};

    EXPECT_TRUE(state.SetPanelVisible(XCUIShellPanelId::XCUIDemo, false));
    EXPECT_TRUE(state.SetViewToggle(XCUIShellViewToggleId::HostedPreviewHud, false));
    EXPECT_TRUE(state.SetHostedPreviewMode(
        XCUIShellPanelId::XCUILayoutLab,
        XCUIShellHostedPreviewMode::NativeOffscreen));
    EXPECT_TRUE(state.SetHostedPreviewEnabled(XCUIShellPanelId::XCUIDemo, false));

    const auto menu = state.BuildViewMenuDescriptor();

    EXPECT_FALSE(menu.items[0].command.checked);
    EXPECT_FALSE(menu.items[7].command.checked);
    EXPECT_FALSE(menu.items[8].command.checked);
    EXPECT_TRUE(menu.items[9].command.checked);
}

TEST(XCUIShellChromeStateTest, PanelCommandIdHelpersMatchCurrentShellCommands) {
    EXPECT_EQ(
        XCUIShellChromeState::GetPanelVisibilityCommandId(XCUIShellPanelId::XCUIDemo),
        XCUIShellChromeCommandIds::ToggleXCUIDemoPanel);
    EXPECT_EQ(
        XCUIShellChromeState::GetPanelVisibilityCommandId(XCUIShellPanelId::XCUILayoutLab),
        XCUIShellChromeCommandIds::ToggleXCUILayoutLabPanel);
    EXPECT_EQ(
        XCUIShellChromeState::GetPanelPreviewModeCommandId(XCUIShellPanelId::XCUIDemo),
        XCUIShellChromeCommandIds::ToggleNativeDemoPanelPreview);
    EXPECT_EQ(
        XCUIShellChromeState::GetPanelPreviewModeCommandId(XCUIShellPanelId::XCUILayoutLab),
        XCUIShellChromeCommandIds::ToggleNativeLayoutLabPreview);
}

TEST(XCUIShellChromeStateTest, ViewToggleCommandIdHelpersMatchCurrentShellCommands) {
    EXPECT_EQ(
        XCUIShellChromeState::GetViewToggleCommandId(XCUIShellViewToggleId::LegacyHostDemoWindow),
        XCUIShellChromeCommandIds::ToggleLegacyHostDemoWindow);
    EXPECT_EQ(
        XCUIShellChromeState::GetViewToggleCommandId(XCUIShellViewToggleId::NativeBackdrop),
        XCUIShellChromeCommandIds::ToggleNativeBackdrop);
    EXPECT_EQ(
        XCUIShellChromeState::GetViewToggleCommandId(XCUIShellViewToggleId::PulseAccent),
        XCUIShellChromeCommandIds::TogglePulseAccent);
    EXPECT_EQ(
        XCUIShellChromeState::GetViewToggleCommandId(XCUIShellViewToggleId::NativeXCUIOverlay),
        XCUIShellChromeCommandIds::ToggleNativeXCUIOverlay);
    EXPECT_EQ(
        XCUIShellChromeState::GetViewToggleCommandId(XCUIShellViewToggleId::HostedPreviewHud),
        XCUIShellChromeCommandIds::ToggleHostedPreviewHud);
}

TEST(XCUIShellChromeStateTest, InvalidPanelAndToggleIdsFailGracefully) {
    XCUIShellChromeState state = {};

    const XCUIShellPanelId invalidPanelId = static_cast<XCUIShellPanelId>(255);
    const XCUIShellViewToggleId invalidToggleId = static_cast<XCUIShellViewToggleId>(255);

    EXPECT_EQ(state.TryGetPanelState(invalidPanelId), nullptr);
    EXPECT_FALSE(state.IsPanelVisible(invalidPanelId));
    EXPECT_FALSE(state.SetPanelVisible(invalidPanelId, true));
    EXPECT_FALSE(state.TogglePanelVisible(invalidPanelId));
    EXPECT_FALSE(state.IsHostedPreviewEnabled(invalidPanelId));
    EXPECT_FALSE(state.SetHostedPreviewEnabled(invalidPanelId, false));
    EXPECT_EQ(
        state.GetHostedPreviewMode(invalidPanelId),
        XCUIShellHostedPreviewMode::HostedPresenter);
    EXPECT_EQ(
        state.GetHostedPreviewState(invalidPanelId),
        XCUIShellHostedPreviewState::Disabled);
    EXPECT_FALSE(state.IsNativeHostedPreviewActive(invalidPanelId));
    EXPECT_FALSE(state.IsHostedPresenterPreviewActive(invalidPanelId));
    EXPECT_FALSE(state.SetHostedPreviewMode(invalidPanelId, XCUIShellHostedPreviewMode::NativeOffscreen));
    EXPECT_FALSE(state.ToggleHostedPreviewMode(invalidPanelId));

    EXPECT_FALSE(state.GetViewToggle(invalidToggleId));
    EXPECT_FALSE(state.SetViewToggle(invalidToggleId, true));
    EXPECT_FALSE(state.ToggleViewToggle(invalidToggleId));

    EXPECT_TRUE(XCUIShellChromeState::GetPanelVisibilityCommandId(invalidPanelId).empty());
    EXPECT_TRUE(XCUIShellChromeState::GetPanelPreviewModeCommandId(invalidPanelId).empty());
    EXPECT_TRUE(XCUIShellChromeState::GetViewToggleCommandId(invalidToggleId).empty());
}

} // namespace