ui_coordinator.cc

Go to the documentation of this file.

#include "app/editor/shell/coordinator/ui_coordinator.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <filesystem>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "absl/strings/match.h"
#include "absl/strings/str_format.h"
 
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif
#include "app/application.h"
#include "app/editor/core/content_registry.h"
#include "app/editor/editor.h"
#include "app/editor/editor_manager.h"
#include "app/editor/layout/layout_presets.h"
#include "app/editor/layout/window_delegate.h"
#include "app/editor/menu/right_drawer_manager.h"
#include "app/editor/shell/coordinator/welcome_screen.h"
#include "app/editor/shell/feedback/popup_manager.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/system/command_palette_providers.h"
#include "app/editor/system/commands/command_palette_goto.h"
#include "app/editor/system/editor_registry.h"
#include "app/editor/system/session/project_manager.h"
#include "app/editor/system/session/rom_file_manager.h"
#include "app/editor/system/session/session_coordinator.h"
#include "app/gui/core/background_renderer.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/layout_helpers.h"
#include "app/gui/core/style.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/themed_widgets.h"
#include "core/project.h"
#include "imgui/imgui.h"
#include "util/file_util.h"
#include "util/platform_paths.h"
 
namespace yaze {
namespace editor {
 
UICoordinator::UICoordinator(
    EditorManager* editor_manager, RomFileManager& rom_manager,
    ProjectManager& project_manager, EditorRegistry& editor_registry,
    WorkspaceWindowManager& window_manager,
    SessionCoordinator& session_coordinator, WindowDelegate& window_delegate,
    ToastManager& toast_manager, PopupManager& popup_manager,
    ShortcutManager& shortcut_manager)
    : editor_manager_(editor_manager),
      rom_manager_(rom_manager),
      project_manager_(project_manager),
      editor_registry_(editor_registry),
      window_manager_(window_manager),
      session_coordinator_(session_coordinator),
      window_delegate_(window_delegate),
      toast_manager_(toast_manager),
      popup_manager_(popup_manager),
      shortcut_manager_(shortcut_manager) {
  // Initialize welcome screen with proper callbacks
  welcome_screen_ = std::make_unique<WelcomeScreen>();
 
  // Bind persistent prefs so animation tweaks survive restart.
  if (editor_manager_) {
    welcome_screen_->SetUserSettings(&editor_manager_->user_settings());
  }
 
  // Wire welcome screen callbacks to EditorManager
  welcome_screen_->SetOpenRomCallback([this]() {
#ifdef __EMSCRIPTEN__
    // In web builds, trigger the file input element directly
    // The file input handler in app.js will handle the file selection
    // and call LoadRomFromWeb, which will update the ROM
    EM_ASM({
      var romInput = document.getElementById('rom-input');
      if (romInput) {
        romInput.click();
      }
    });
    // Don't hide welcome screen yet - it will be hidden when ROM loads
    // (DrawWelcomeScreen auto-transitions to Dashboard on ROM load)
#else
    if (editor_manager_) {
      auto status = editor_manager_->LoadRom();
      if (!status.ok()) {
        toast_manager_.Show(
            absl::StrFormat("Failed to load ROM: %s", status.message()),
            ToastType::kError);
      }
#if !(defined(__APPLE__) && TARGET_OS_IOS == 1)
      else {
        // Transition to Dashboard on successful ROM load
        SetStartupSurface(StartupSurface::kDashboard);
      }
#endif
    }
#endif
  });
 
  welcome_screen_->SetNewProjectCallback(
      [this]() { new_project_dialog_.Open("Vanilla ROM Hack"); });
 
  new_project_dialog_.SetCreateCallback(
      [this](const std::string& template_name, const std::string& rom_path,
             const std::string& project_name) -> absl::Status {
        if (!editor_manager_) {
          return absl::FailedPreconditionError(
              "Editor manager is not available");
        }
        auto status = editor_manager_->CreateNewProjectFromRom(
            template_name, rom_path, project_name);
        if (!status.ok()) {
          toast_manager_.Show(
              absl::StrFormat("Failed to create project: %s", status.message()),
              ToastType::kError);
          return status;
        }
        toast_manager_.Show(absl::StrFormat("Created project \"%s\" from %s",
                                            project_name, template_name),
                            ToastType::kSuccess);
        SetStartupSurface(StartupSurface::kDashboard);
        return absl::OkStatus();
      });
 
  welcome_screen_->SetOpenProjectCallback([this](const std::string& filepath) {
    if (editor_manager_) {
      auto status = editor_manager_->OpenRomOrProject(filepath);
      if (!status.ok()) {
        toast_manager_.Show(
            absl::StrFormat("Failed to open project: %s", status.message()),
            ToastType::kError);
      } else {
        // Transition to Dashboard on successful project open
        SetStartupSurface(StartupSurface::kDashboard);
      }
    }
  });
 
  welcome_screen_->SetOpenProjectManagementCallback([this]() {
    if (editor_manager_) {
      editor_manager_->ShowProjectManagement();
      SetStartupSurface(StartupSurface::kDashboard);
    }
  });
 
  welcome_screen_->SetComingFromZScreamCallback([this]() {
    popup_manager_.Show(PopupID::kComingFromZScream);
    if (editor_manager_) {
      editor_manager_->feature_hint_manager()->Dismiss(
          FeatureHintId::kZScreamWelcome);
    }
  });
 
  welcome_screen_->SetOpenPrototypeResearchCallback([this]() {
    if (!editor_manager_) {
      return;
    }
    editor_manager_->SwitchToEditor(EditorType::kGraphics, true);
    window_manager_.OpenWindow("graphics.prototype_viewer");
    SetWelcomeScreenVisible(false);
    SetWelcomeScreenManuallyClosed(true);
  });
 
  welcome_screen_->SetOpenAssemblyEditorNoRomCallback([this]() {
    if (!editor_manager_) {
      return;
    }
    editor_manager_->SwitchToEditor(EditorType::kAssembly, true);
    window_manager_.OpenWindow("assembly.code_editor");
    SetWelcomeScreenVisible(false);
    SetWelcomeScreenManuallyClosed(true);
  });
}
 
void UICoordinator::SetWelcomeScreenBehavior(StartupVisibility mode) {
  welcome_behavior_override_ = mode;
  if (mode == StartupVisibility::kHide) {
    welcome_screen_manually_closed_ = true;
    // If hiding welcome, transition to appropriate state
    if (current_startup_surface_ == StartupSurface::kWelcome) {
      SetStartupSurface(StartupSurface::kDashboard);
    }
  } else if (mode == StartupVisibility::kShow) {
    welcome_screen_manually_closed_ = false;
    SetStartupSurface(StartupSurface::kWelcome);
  }
}
 
void UICoordinator::SetDashboardBehavior(StartupVisibility mode) {
  if (dashboard_behavior_override_ == mode) {
    return;
  }
  dashboard_behavior_override_ = mode;
  if (mode == StartupVisibility::kShow) {
    // Only transition to dashboard if we're not in welcome
    if (current_startup_surface_ != StartupSurface::kWelcome) {
      SetStartupSurface(StartupSurface::kDashboard);
    }
  } else if (mode == StartupVisibility::kHide) {
    // If hiding dashboard, transition to editor state
    if (current_startup_surface_ == StartupSurface::kDashboard) {
      SetStartupSurface(StartupSurface::kEditor);
    }
  }
}
 
void UICoordinator::DrawBackground() {
  if (!ImGui::GetCurrentContext()) {
    return;
  }
 
  const ImGuiViewport* viewport = ImGui::GetMainViewport();
  if (!viewport) {
    return;
  }
 
  ImDrawList* bg_draw_list =
      ImGui::GetBackgroundDrawList(const_cast<ImGuiViewport*>(viewport));
 
  auto& theme_manager = gui::ThemeManager::Get();
  auto current_theme = theme_manager.GetCurrentTheme();
  auto& bg_renderer = gui::BackgroundRenderer::Get();
 
  // Draw grid covering the entire main viewport
  ImVec2 grid_pos = viewport->WorkPos;
  ImVec2 grid_size = viewport->WorkSize;
  bg_renderer.RenderDockingBackground(bg_draw_list, grid_pos, grid_size,
                                      current_theme.primary);
}
 
void UICoordinator::DrawAllUI() {
  // Note: Theme styling is applied by ThemeManager, not here
  // This is called from EditorManager::Update() - don't call menu bar stuff
  // here
 
  // Draw UI windows and dialogs
  // Session dialogs are drawn by SessionCoordinator separately to avoid
  // duplication
  DrawCommandPalette();          // Ctrl+Shift+P (+ Window Finder seeds window:)
  DrawPanelFinder();             // Legacy modal (kept for direct flag use)
  DrawShortcutsBrowser();        // Help > Keyboard Shortcuts
  DrawGlobalSearch();            // Ctrl+Shift+K
  DrawWorkspacePresetDialogs();  // Save/Load workspace dialogs
  DrawLayoutPresets();           // Layout preset dialogs
  DrawWelcomeScreen();           // Welcome screen
  DrawProjectHelp();             // Project help
  DrawWindowManagementUI();      // Window management
 
#ifdef YAZE_BUILD_AGENT_UI
  if (show_ai_agent_) {
    if (editor_manager_) {
      editor_manager_->ShowAIAgent();
    }
    show_ai_agent_ = false;
  }
 
  if (show_chat_history_) {
    if (editor_manager_) {
      editor_manager_->ShowChatHistory();
    }
    show_chat_history_ = false;
  }
 
  if (show_proposal_drawer_) {
    if (editor_manager_) {
      if (auto* right_panel = editor_manager_->right_drawer_manager()) {
        right_panel->OpenDrawer(RightDrawerManager::DrawerType::kProposals);
      }
    }
    show_proposal_drawer_ = false;
  }
#endif
 
  // Draw popups and toasts
  DrawAllPopups();
  toast_manager_.Draw();
}
 
bool UICoordinator::IsCompactLayout() const {
  const ImGuiViewport* viewport = ImGui::GetMainViewport();
  if (!viewport) {
    return false;
  }
  const float width = viewport->WorkSize.x;
#if defined(__APPLE__) && TARGET_OS_IOS == 1
  // Use hysteresis to avoid layout thrash while iPad windows are being
  // interactively resized around the compact breakpoint.
  static bool compact_mode = false;
  constexpr float kEnterCompactWidth = 900.0f;
  constexpr float kExitCompactWidth = 940.0f;
  compact_mode =
      compact_mode ? (width < kExitCompactWidth) : (width < kEnterCompactWidth);
  return compact_mode;
#else
  return width < 900.0f;
#endif
}
 
// =============================================================================
// Menu Bar Helpers
// =============================================================================
 
bool UICoordinator::DrawMenuBarIconButton(const char* icon, const char* tooltip,
                                          bool is_active) {
  // Consistent button styling: transparent background, themed text
  gui::StyleColorGuard btn_guard(
      {{ImGuiCol_Button, ImVec4(0, 0, 0, 0)},
       {ImGuiCol_ButtonHovered, gui::GetSurfaceContainerHighVec4()},
       {ImGuiCol_ButtonActive, gui::GetSurfaceContainerHighestVec4()},
       {ImGuiCol_Text,
        is_active ? gui::GetPrimaryVec4() : gui::GetTextSecondaryVec4()}});
 
  bool clicked = ImGui::SmallButton(icon);
 
  if (tooltip && ImGui::IsItemHovered()) {
    ImGui::SetTooltip("%s", tooltip);
  }
 
  return clicked;
}
 
float UICoordinator::GetMenuBarIconButtonWidth() {
  // SmallButton width = text width + frame padding * 2
  const float frame_padding = ImGui::GetStyle().FramePadding.x;
  // Use a standard icon width (Material Design icons are uniform)
  const float icon_width = ImGui::CalcTextSize(ICON_MD_SETTINGS).x;
  return icon_width + frame_padding * 2.0f;
}
 
void UICoordinator::DrawMenuBarExtras() {
  // Right-aligned status cluster: dirty indicator, session, bell, sidebar.
  // The sidebar toggle uses screen coordinates so it stays fixed when the
  // dockspace resizes due to sidebar open/close.
  //
  // Layout: [●][📄▾][🔔] [sidebar][⬆]
  //         ^^^ shifts with dockspace ^^^  ^^^ fixed screen position ^^^
 
  auto* current_rom = editor_manager_->GetCurrentRom();
 
  const float item_spacing = 6.0f;
  const float padding = 8.0f;
 
  auto CalcSmallButtonWidth = [](const char* label) -> float {
    // SmallButton width = text width + frame padding * 2
    const float frame_padding = ImGui::GetStyle().FramePadding.x;
    const float text_w = ImGui::CalcTextSize(label).x;
    return text_w + frame_padding * 2.0f;
  };
 
  // Get TRUE viewport dimensions (not affected by dockspace resize)
  const ImGuiViewport* viewport = ImGui::GetMainViewport();
  const float true_viewport_right = viewport->WorkPos.x + viewport->WorkSize.x;
 
  const bool has_panel_toggles =
      editor_manager_->right_drawer_manager() != nullptr;
  float panel_buttons_width = 0.0f;
  if (has_panel_toggles) {
    panel_buttons_width = RightDrawerManager::GetSidebarToggleWidth();
  }
 
  // Reserve only the real button footprint so compact icon toggles do not
  // leave a dead gap before the right edge cluster.
  float panel_region_width = panel_buttons_width;
#ifdef __EMSCRIPTEN__
  // WASM hide menu bar toggle (drawn inline after panel buttons).
  panel_region_width +=
      CalcSmallButtonWidth(ICON_MD_EXPAND_LESS) + item_spacing;
#endif
 
  // Calculate screen X position for panel toggles (fixed at viewport right edge)
  float panel_screen_x = true_viewport_right - panel_region_width;
  if (editor_manager_->right_drawer_manager() &&
      editor_manager_->right_drawer_manager()->IsDrawerExpanded()) {
    panel_screen_x -= editor_manager_->right_drawer_manager()->GetDrawerWidth();
  }
 
  // Available space for status cluster (dirty, session, bell) ends where the
  // right-sidebar toggle begins.
  const float window_width = ImGui::GetWindowWidth();
  const float window_screen_x = ImGui::GetWindowPos().x;
  const float menu_items_end = ImGui::GetCursorPosX() + 16.0f;
 
  // Convert panel screen X to window-local coordinates for space calculation
  float panel_local_x = panel_screen_x - window_screen_x;
  float region_end =
      std::min(window_width - padding, panel_local_x - item_spacing);
 
  // Progressive show/hide when space is tight
  bool has_dirty_rom =
      current_rom && current_rom->is_loaded() && current_rom->dirty();
  bool has_multiple_sessions = session_coordinator_.HasMultipleSessions();
 
  float dirty_width =
      ImGui::CalcTextSize(ICON_MD_FIBER_MANUAL_RECORD).x + item_spacing;
  const float session_width = CalcSmallButtonWidth(ICON_MD_LAYERS);
 
  const float available_width = region_end - menu_items_end - padding;
 
  // Minimum required width: just the bell (always visible)
  float required_width = CalcSmallButtonWidth(ICON_MD_NOTIFICATIONS);
 
  // Priority (highest to lowest): Bell > Dirty > Session
 
  // Try to fit session button (medium priority)
  bool show_session =
      has_multiple_sessions &&
      (required_width + session_width + item_spacing) <= available_width;
  if (show_session) {
    required_width += session_width + item_spacing;
  }
 
  // Try to fit dirty indicator (high priority - only hide if extremely tight)
  bool show_dirty =
      has_dirty_rom && (required_width + dirty_width) <= available_width;
  if (show_dirty) {
    required_width += dirty_width;
  }
 
  // Calculate start position (right-align within available space)
  float start_pos = std::max(menu_items_end, region_end - required_width);
 
  // =========================================================================
  // DRAW STATUS CLUSTER (shifts with dockspace)
  // =========================================================================
  ImGui::SameLine(start_pos);
  gui::StyleVarGuard item_spacing_guard(ImGuiStyleVar_ItemSpacing,
                                        ImVec2(item_spacing, 0.0f));
 
  // 1. Dirty badge - warning color dot
  if (show_dirty) {
    const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
    gui::ColoredText(ICON_MD_FIBER_MANUAL_RECORD,
                     gui::ConvertColorToImVec4(theme.warning));
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Unsaved changes: %s"),
                        current_rom->short_name().c_str());
    }
    ImGui::SameLine();
  }
 
  // 2. Session button - layers icon
  if (show_session) {
    DrawSessionButton();
    ImGui::SameLine();
  }
 
  // 3. Notification bell (pass visibility flags for enhanced tooltip)
  DrawNotificationBell(show_dirty, has_dirty_rom, show_session,
                       has_multiple_sessions);
 
  // =========================================================================
  // DRAW RIGHT-SIDEBAR TOGGLE (fixed screen position)
  // =========================================================================
  if (has_panel_toggles) {
    float menu_bar_y = ImGui::GetCursorScreenPos().y;
    ImGui::SetCursorScreenPos(ImVec2(panel_screen_x, menu_bar_y));
    editor_manager_->right_drawer_manager()->DrawSidebarToggleButton();
  }
 
#ifdef __EMSCRIPTEN__
  // WASM toggle button - also at fixed position
  ImGui::SameLine();
  if (DrawMenuBarIconButton(ICON_MD_EXPAND_LESS,
                            "Hide menu bar (Alt to restore)")) {
    show_menu_bar_ = false;
  }
#endif
}
 
void UICoordinator::DrawMenuBarRestoreButton() {
  // Only draw when menu bar is hidden (primarily for WASM builds)
  if (show_menu_bar_) {
    return;
  }
 
  // Small floating button in top-left corner to restore menu bar
  ImGuiWindowFlags flags =
      ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize |
      ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoSavedSettings;
 
  ImGui::SetNextWindowPos(ImVec2(8, 8));
  ImGui::SetNextWindowBgAlpha(0.7f);
 
  if (ImGui::Begin("##MenuBarRestore", nullptr, flags)) {
    gui::StyleColorGuard btn_guard(
        {{ImGuiCol_Button, gui::GetSurfaceContainerVec4()},
         {ImGuiCol_ButtonHovered, gui::GetSurfaceContainerHighVec4()},
         {ImGuiCol_ButtonActive, gui::GetSurfaceContainerHighestVec4()},
         {ImGuiCol_Text, gui::GetPrimaryVec4()}});
 
    if (ImGui::Button(ICON_MD_FULLSCREEN_EXIT, ImVec2(32, 32))) {
      show_menu_bar_ = true;
    }
 
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Show menu bar (Alt)"));
    }
  }
  ImGui::End();
 
  // Also check for Alt key to restore menu bar
  if (ImGui::IsKeyPressed(ImGuiKey_LeftAlt) ||
      ImGui::IsKeyPressed(ImGuiKey_RightAlt)) {
    show_menu_bar_ = true;
  }
}
 
void UICoordinator::DrawNotificationBell(bool show_dirty, bool has_dirty_rom,
                                         bool show_session,
                                         bool has_multiple_sessions) {
  size_t unread = toast_manager_.GetUnreadCount();
  auto* current_rom = editor_manager_->GetCurrentRom();
  auto* right_panel = editor_manager_->right_drawer_manager();
 
  bool is_active =
      right_panel && right_panel->IsDrawerActive(
                         RightDrawerManager::DrawerType::kNotifications);
 
  if (DrawMenuBarIconButton(ICON_MD_NOTIFICATIONS, nullptr,
                            unread > 0 || is_active)) {
    if (right_panel) {
      right_panel->ToggleDrawer(RightDrawerManager::DrawerType::kNotifications);
      toast_manager_.MarkAllRead();
    }
  }
 
  // Enhanced tooltip showing notifications + hidden status items
  if (ImGui::IsItemHovered()) {
    ImGui::BeginTooltip();
 
    // Notifications
    if (unread > 0) {
      gui::ColoredTextF(gui::GetPrimaryVec4(), "%s %zu new notification%s",
                        ICON_MD_NOTIFICATIONS, unread, unread == 1 ? "" : "s");
    } else {
      gui::ColoredText(ICON_MD_NOTIFICATIONS " No new notifications",
                       gui::GetTextSecondaryVec4());
    }
 
    ImGui::TextDisabled(tr("Click to open Notifications panel"));
 
    // Show hidden status items if any
    if (!show_dirty && has_dirty_rom) {
      ImGui::Separator();
      gui::ColoredTextF(gui::ConvertColorToImVec4(
                            gui::ThemeManager::Get().GetCurrentTheme().warning),
                        ICON_MD_FIBER_MANUAL_RECORD " Unsaved changes: %s",
                        current_rom->short_name().c_str());
    }
 
    if (!show_session && has_multiple_sessions) {
      if (!show_dirty && has_dirty_rom) {
        // Already had a separator
      } else {
        ImGui::Separator();
      }
      gui::ColoredTextF(gui::GetTextSecondaryVec4(),
                        ICON_MD_LAYERS " %zu sessions active",
                        session_coordinator_.GetActiveSessionCount());
    }
 
    ImGui::EndTooltip();
  }
}
 
void UICoordinator::DrawSessionButton() {
  auto* current_rom = editor_manager_->GetCurrentRom();
 
  // Store button position for popup anchoring
  ImVec2 button_min = ImGui::GetCursorScreenPos();
 
  std::string tooltip =
      current_rom && current_rom->is_loaded()
          ? absl::StrFormat("%s\n%zu sessions open (Ctrl+Tab)",
                            current_rom->short_name().c_str(),
                            session_coordinator_.GetActiveSessionCount())
          : absl::StrFormat("No ROM loaded\n%zu sessions open (Ctrl+Tab)",
                            session_coordinator_.GetActiveSessionCount());
 
  if (DrawMenuBarIconButton(ICON_MD_LAYERS, tooltip.c_str(), false)) {
    ImGui::OpenPopup("##SessionSwitcherPopup");
  }
 
  ImVec2 button_max = ImGui::GetItemRectMax();
 
  // Anchor popup to right edge - position so right edge aligns with button
  const float popup_width = 250.0f;
  const float screen_width = ImGui::GetIO().DisplaySize.x;
  const float popup_x =
      std::min(button_min.x, screen_width - popup_width - 10.0f);
 
  ImGui::SetNextWindowPos(ImVec2(popup_x, button_max.y + 2.0f),
                          ImGuiCond_Appearing);
 
  // Session switcher popup
  if (ImGui::BeginPopup("##SessionSwitcherPopup")) {
    ImGui::Text(ICON_MD_LAYERS " Sessions");
    ImGui::Separator();
 
    for (size_t i = 0; i < session_coordinator_.GetTotalSessionCount(); ++i) {
      if (session_coordinator_.IsSessionClosed(i))
        continue;
 
      auto* session =
          static_cast<RomSession*>(session_coordinator_.GetSession(i));
      if (!session)
        continue;
 
      Rom* rom = &session->rom;
      ImGui::PushID(static_cast<int>(i));
 
      bool is_current = (rom == current_rom);
      std::optional<gui::StyleColorGuard> current_guard;
      if (is_current) {
        current_guard.emplace(ImGuiCol_Text, gui::GetPrimaryVec4());
      }
 
      std::string label =
          rom->is_loaded()
              ? absl::StrFormat("%s %s", ICON_MD_DESCRIPTION,
                                rom->short_name().c_str())
              : absl::StrFormat("%s Session %zu", ICON_MD_DESCRIPTION, i + 1);
 
      if (ImGui::Selectable(label.c_str(), is_current)) {
        editor_manager_->SwitchToSession(i);
      }
 
      ImGui::PopID();
    }
 
    ImGui::EndPopup();
  }
}
 
// ============================================================================
// Session UI Delegation
// ============================================================================
// All session-related UI is now managed by SessionCoordinator to eliminate
// duplication. UICoordinator methods delegate to SessionCoordinator.
 
void UICoordinator::ShowSessionSwitcher() {
  session_coordinator_.ShowSessionSwitcher();
}
 
bool UICoordinator::IsSessionSwitcherVisible() const {
  return session_coordinator_.IsSessionSwitcherVisible();
}
 
void UICoordinator::SetSessionSwitcherVisible(bool visible) {
  if (visible) {
    session_coordinator_.ShowSessionSwitcher();
  } else {
    session_coordinator_.HideSessionSwitcher();
  }
}
 
void UICoordinator::ShowCommandPalette(const char* initial_query) {
  const size_t session_id = session_coordinator_.GetActiveSessionId();
  if (command_palette_initialized_) {
    RefreshCommandPalette(session_id);
  } else {
    InitializeCommandPalette(session_id);
  }
  if (initial_query != nullptr) {
    std::snprintf(command_palette_query_, sizeof(command_palette_query_), "%s",
                  initial_query);
    command_palette_selected_idx_ = 0;
  }
  show_command_palette_ = true;
}
 
void UICoordinator::ShowPanelFinder() {
  // Consolidate window discovery into the command palette (`window:` prefix).
  ShowCommandPalette("window: ");
}
 
void UICoordinator::SetCommandPaletteVisible(bool visible) {
  if (visible) {
    ShowCommandPalette();
    return;
  }
  show_command_palette_ = false;
}
 
// Emulator visibility delegates to WorkspaceWindowManager (single source of truth)
bool UICoordinator::IsEmulatorVisible() const {
  size_t session_id = session_coordinator_.GetActiveSessionId();
  auto emulator_windows =
      window_manager_.GetWindowsInCategory(session_id, "Emulator");
  for (const auto& window : emulator_windows) {
    if (window.visibility_flag && *window.visibility_flag) {
      return true;
    }
  }
  return false;
}
 
void UICoordinator::SetEmulatorVisible(bool visible) {
  size_t session_id = session_coordinator_.GetActiveSessionId();
  if (visible) {
    auto default_windows =
        LayoutPresets::GetDefaultWindows(EditorType::kEmulator);
    for (const auto& window_id : default_windows) {
      window_manager_.OpenWindow(session_id, window_id);
    }
  } else {
    window_manager_.HideAllWindowsInCategory(session_id, "Emulator");
  }
}
 
// Assembly editor visibility: same delegation pattern as the emulator. The
// `show_asm_editor_` boolean was a parallel source of truth that could drift
// when the user closed a single Assembly panel via its window close button;
// reading through the category means the user's last interaction always wins.
bool UICoordinator::IsAsmEditorVisible() const {
  size_t session_id = session_coordinator_.GetActiveSessionId();
  auto windows = window_manager_.GetWindowsInCategory(session_id, "Assembly");
  for (const auto& window : windows) {
    if (window.visibility_flag && *window.visibility_flag) {
      return true;
    }
  }
  return false;
}
 
void UICoordinator::SetAsmEditorVisible(bool visible) {
  size_t session_id = session_coordinator_.GetActiveSessionId();
  if (visible) {
    auto default_windows =
        LayoutPresets::GetDefaultWindows(EditorType::kAssembly);
    for (const auto& window_id : default_windows) {
      window_manager_.OpenWindow(session_id, window_id);
    }
  } else {
    window_manager_.HideAllWindowsInCategory(session_id, "Assembly");
  }
}
 
// ============================================================================
// Layout and Window Management UI
// ============================================================================
 
void UICoordinator::DrawLayoutPresets() {
  // TODO: [EditorManagerRefactor] Implement full layout preset UI with
  // save/load For now, this is accessed via Window menu items that call
  // workspace_manager directly
}
 
void UICoordinator::DrawWelcomeScreen() {
  // ============================================================================
  // CENTRALIZED WELCOME SCREEN LOGIC (using StartupSurface state)
  // ============================================================================
  // Uses ShouldShowWelcome() as single source of truth
  // Auto-transitions to Dashboard on ROM load
  // Activity Bar hidden when welcome is visible
  // ============================================================================
 
  if (!editor_manager_) {
    LOG_ERROR("UICoordinator",
              "EditorManager is null - cannot check ROM state");
    return;
  }
 
  if (!welcome_screen_) {
    LOG_ERROR("UICoordinator", "WelcomeScreen object is null - cannot render");
    return;
  }
 
  // Check ROM state and update startup surface accordingly
  auto* current_rom = editor_manager_->GetCurrentRom();
  bool rom_is_loaded = current_rom && current_rom->is_loaded();
 
  // Auto-transition: ROM loaded -> Dashboard or Editor
  if (rom_is_loaded && current_startup_surface_ == StartupSurface::kWelcome) {
    if (welcome_screen_manually_closed_) {
      SetStartupSurface(StartupSurface::kEditor);
    } else {
      SetStartupSurface(StartupSurface::kDashboard);
    }
  }
 
  // Auto-transition: ROM unloaded -> Welcome (reset to welcome state)
  if (!rom_is_loaded && current_startup_surface_ != StartupSurface::kWelcome &&
      !welcome_screen_manually_closed_) {
    SetStartupSurface(StartupSurface::kWelcome);
  }
 
  // Use centralized visibility check
  if (!ShouldShowWelcome()) {
    // Project creation can start from the menu or command palette while the
    // welcome surface is hidden.
    new_project_dialog_.Draw();
    return;
  }
 
  // Provide context state for first-run guidance.
  welcome_screen_->SetContextState(rom_is_loaded);
 
  // Update recent projects before showing (cheap no-op when the
  // RecentFilesManager generation counter hasn't changed).
  welcome_screen_->RefreshRecentProjects();
 
  // Pass layout offsets so welcome screen centers within dockspace region
  // Note: Activity Bar is hidden when welcome is shown, so left_offset = 0
  float left_offset =
      ShouldShowActivityBar() ? editor_manager_->GetLeftLayoutOffset() : 0.0f;
  float right_offset = editor_manager_->GetRightLayoutOffset();
  welcome_screen_->SetLayoutOffsets(left_offset, right_offset);
 
  // Show the welcome screen window
  bool is_open = true;
  welcome_screen_->Show(&is_open);
 
  // Draw after the welcome window so the modal layers above it.
  new_project_dialog_.Draw();
 
  // If user closed it via X button, respect that and transition to appropriate state
  if (!is_open) {
    welcome_screen_manually_closed_ = true;
    // Transition to Dashboard if ROM loaded, stay in Editor state otherwise
    if (rom_is_loaded) {
      SetStartupSurface(StartupSurface::kDashboard);
    }
  }
}
 
void UICoordinator::DrawProjectHelp() {
  // TODO: [EditorManagerRefactor] Implement project help dialog
  // Show context-sensitive help based on current editor and ROM state
}
 
void UICoordinator::DrawWorkspacePresetDialogs() {
  if (show_save_workspace_preset_) {
    ImGui::Begin("Save Workspace Preset", &show_save_workspace_preset_,
                 ImGuiWindowFlags_AlwaysAutoResize);
    static char preset_name[128] = "";
    ImGui::InputText(tr("Name"), preset_name, IM_ARRAYSIZE(preset_name));
    if (ImGui::Button(tr("Save"), gui::kDefaultModalSize)) {
      if (strlen(preset_name) > 0) {
        editor_manager_->SaveWorkspacePreset(preset_name);
        toast_manager_.Show("Preset saved", editor::ToastType::kSuccess);
        show_save_workspace_preset_ = false;
        preset_name[0] = '\0';
      }
    }
    ImGui::SameLine();
    if (ImGui::Button(tr("Cancel"), gui::kDefaultModalSize)) {
      show_save_workspace_preset_ = false;
      preset_name[0] = '\0';
    }
    ImGui::End();
  }
 
  if (show_load_workspace_preset_) {
    ImGui::Begin("Load Workspace Preset", &show_load_workspace_preset_,
                 ImGuiWindowFlags_AlwaysAutoResize);
 
    // Lazy load workspace presets when UI is accessed
    editor_manager_->RefreshWorkspacePresets();
 
    if (auto* workspace_manager = editor_manager_->workspace_manager()) {
      for (const auto& name : workspace_manager->workspace_presets()) {
        if (ImGui::Selectable(name.c_str())) {
          editor_manager_->LoadWorkspacePreset(name);
          toast_manager_.Show("Preset loaded", editor::ToastType::kSuccess);
          show_load_workspace_preset_ = false;
        }
      }
      if (workspace_manager->workspace_presets().empty())
        ImGui::Text(tr("No presets found"));
    }
    ImGui::End();
  }
}
 
void UICoordinator::DrawWindowManagementUI() {
  // TODO: [EditorManagerRefactor] Implement window management dialog
  // Provide UI for toggling window visibility, managing docking, etc.
}
 
void UICoordinator::DrawAllPopups() {
  // Draw all registered popups
  popup_manager_.DrawPopups();
}
 
void UICoordinator::ShowPopup(const std::string& popup_name) {
  popup_manager_.Show(popup_name.c_str());
}
 
void UICoordinator::HidePopup(const std::string& popup_name) {
  popup_manager_.Hide(popup_name.c_str());
}
 
void UICoordinator::ShowDisplaySettings() {
  // Display Settings is now a popup managed by PopupManager
  // Delegate directly to PopupManager instead of UICoordinator
  popup_manager_.Show(PopupID::kDisplaySettings);
}
 
// ============================================================================
// Sidebar visibility delegates to WorkspaceWindowManager
// ============================================================================
 
void UICoordinator::TogglePanelSidebar() {
  window_manager_.ToggleSidebarVisibility();
}
 
bool UICoordinator::IsPanelSidebarVisible() const {
  return window_manager_.IsSidebarVisible();
}
 
void UICoordinator::SetPanelSidebarVisible(bool visible) {
  window_manager_.SetSidebarVisible(visible);
}
 
void UICoordinator::ShowAllWindows() {
  window_delegate_.ShowAllWindows();
}
 
void UICoordinator::HideAllWindows() {
  window_delegate_.HideAllWindows();
}
 
// Material Design component helpers
void UICoordinator::DrawMaterialButton(const std::string& text,
                                       const std::string& icon,
                                       const ImVec4& color,
                                       std::function<void()> callback,
                                       bool enabled) {
  std::optional<gui::StyleColorGuard> disabled_guard;
  if (!enabled) {
    disabled_guard.emplace(std::initializer_list<gui::StyleColorGuard::Entry>{
        {ImGuiCol_Button, gui::GetSurfaceContainerHighestVec4()},
        {ImGuiCol_Text, gui::GetOnSurfaceVariantVec4()}});
  }
 
  std::string button_text =
      absl::StrFormat("%s %s", icon.c_str(), text.c_str());
  if (ImGui::Button(button_text.c_str())) {
    if (enabled && callback) {
      callback();
    }
  }
}
 
// Layout and positioning helpers
void UICoordinator::CenterWindow(const std::string& window_name) {
  ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(),
                          ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
}
 
void UICoordinator::PositionWindow(const std::string& window_name, float x,
                                   float y) {
  ImGui::SetNextWindowPos(ImVec2(x, y), ImGuiCond_Appearing);
}
 
void UICoordinator::SetWindowSize(const std::string& window_name, float width,
                                  float height) {
  ImGui::SetNextWindowSize(ImVec2(width, height), ImGuiCond_FirstUseEver);
}
 
void UICoordinator::SaveCommandPaletteHistory() {
  auto config_dir = util::PlatformPaths::GetConfigDirectory();
  if (config_dir.ok()) {
    std::filesystem::path history_file = *config_dir / "command_history.json";
    command_palette_.SaveHistory(history_file.string());
  }
}
 
void UICoordinator::ExecutePaletteCommand(const std::string& name,
                                          std::function<void()> callback) {
  if (!callback)
    return;
  // Close first: the callback may reopen the palette (e.g. Window Finder
  // seeds "window: ") or refresh providers, which must not be undone here.
  show_command_palette_ = false;
  callback();
  if (command_palette_.RecordUsage(name)) {
    SaveCommandPaletteHistory();
  }
}
 
void UICoordinator::DrawCommandPalette() {
  if (!show_command_palette_)
    return;
 
  // Initialize command palette on first use
  if (!command_palette_initialized_) {
    InitializeCommandPalette(session_coordinator_.GetActiveSessionId());
  }
 
  using namespace ImGui;
  auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
 
  SetNextWindowPos(GetMainViewport()->GetCenter(), ImGuiCond_Appearing,
                   ImVec2(0.5f, 0.5f));
  SetNextWindowSize(ImVec2(800, 600), ImGuiCond_FirstUseEver);
 
  bool show_palette = true;
  bool close_requested = false;
  // Deferred so the callback runs after End() (it may open other windows).
  std::string pending_name;
  std::function<void()> pending_callback;
 
  if (Begin(absl::StrFormat("%s Command Palette", ICON_MD_SEARCH).c_str(),
            &show_palette, ImGuiWindowFlags_NoCollapse)) {
    const bool appearing = IsWindowAppearing();
    if (appearing) {
      command_palette_selected_idx_ = 0;
      command_palette_scroll_to_selected_ = true;
    }
 
    // Search input owns keyboard focus; list navigation is driven by the
    // keys below, not by ImGui nav focus.
    SetNextItemWidth(-100);
    if (appearing || command_palette_refocus_input_) {
      SetKeyboardFocusHere();
      command_palette_refocus_input_ = false;
    }
    bool input_changed = InputTextWithHint(
        "##cmd_query",
        absl::StrFormat("%s Search…  try room 4A  map 1B  msg #12  drawer:  "
                        "window:  layout:",
                        ICON_MD_SEARCH)
            .c_str(),
        command_palette_query_, IM_ARRAYSIZE(command_palette_query_),
        // CallbackHistory makes the input claim Up/Down so ImGui nav does not
        // steal focus; the no-op callback leaves the text alone and the keys
        // are read below for list navigation.
        ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_CallbackHistory,
        [](ImGuiInputTextCallbackData*) { return 0; });
 
    SameLine();
    if (Button(absl::StrFormat("%s Clear", ICON_MD_CLEAR).c_str())) {
      command_palette_query_[0] = '\0';
      input_changed = true;
    }
    if (input_changed) {
      command_palette_selected_idx_ = 0;
      command_palette_scroll_to_selected_ = true;
    }
 
    Separator();
 
    // One ranked list: an optional go-to row first, then scored commands.
    const std::string query(command_palette_query_);
    std::optional<CommandEntry> goto_row;
    if (auto go_to = ParseGotoQuery(query)) {
      goto_row =
          BuildGotoEntry(*go_to, session_coordinator_.GetActiveSessionId());
    }
    if (query != command_palette_cached_query_ ||
        command_palette_.generation() != command_palette_cached_generation_) {
      command_palette_cached_matches_ = command_palette_.Search(query);
      command_palette_cached_query_ = query;
      command_palette_cached_generation_ = command_palette_.generation();
    }
    const int goto_offset = goto_row ? 1 : 0;
    auto row_at = [&](int i) -> const CommandEntry& {
      if (goto_row && i == 0)
        return *goto_row;
      return command_palette_cached_matches_[i - goto_offset].entry;
    };
 
    // Keyboard navigation (mirrors the Window Finder).
    const int row_count =
        goto_offset + static_cast<int>(command_palette_cached_matches_.size());
    const bool palette_focused =
        IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows);
    if (palette_focused && row_count > 0) {
      constexpr int kPageStep = 10;
      int idx = command_palette_selected_idx_;
      if (IsKeyPressed(ImGuiKey_DownArrow))
        idx++;
      if (IsKeyPressed(ImGuiKey_UpArrow))
        idx--;
      if (IsKeyPressed(ImGuiKey_PageDown))
        idx += kPageStep;
      if (IsKeyPressed(ImGuiKey_PageUp))
        idx -= kPageStep;
      if (IsKeyPressed(ImGuiKey_Home, false))
        idx = 0;
      if (IsKeyPressed(ImGuiKey_End, false))
        idx = row_count - 1;
      idx = std::clamp(idx, 0, row_count - 1);
      if (idx != command_palette_selected_idx_) {
        command_palette_selected_idx_ = idx;
        command_palette_scroll_to_selected_ = true;
      }
    }
    command_palette_selected_idx_ =
        row_count > 0
            ? std::clamp(command_palette_selected_idx_, 0, row_count - 1)
            : 0;
    if (palette_focused && (IsKeyPressed(ImGuiKey_Enter, false) ||
                            IsKeyPressed(ImGuiKey_KeypadEnter, false))) {
      if (row_count > 0) {
        const CommandEntry& selected = row_at(command_palette_selected_idx_);
        if (selected.enabled && selected.callback) {
          pending_name = selected.name;
          pending_callback = selected.callback;
        } else {
          if (!selected.note.empty())
            toast_manager_.Show(selected.note, ToastType::kWarning);
          // Enter deactivated the input; keep typing possible.
          command_palette_refocus_input_ = true;
        }
      }
    }
    if (palette_focused && IsKeyPressed(ImGuiKey_Escape, false)) {
      close_requested = true;
    }
 
    // Display results with categories
    if (gui::BeginThemedTabBar("CommandCategories")) {
      if (BeginTabItem(
              absl::StrFormat("%s All Commands", ICON_MD_LIST).c_str())) {
        if (gui::LayoutHelpers::BeginTableWithTheming(
                "CommandPaletteTable", 3,
                ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg |
                    ImGuiTableFlags_SizingStretchProp,
                ImVec2(0, -30))) {
          TableSetupScrollFreeze(0, 1);
          TableSetupColumn("Command", ImGuiTableColumnFlags_WidthStretch,
                           0.55f);
          TableSetupColumn("Category", ImGuiTableColumnFlags_WidthStretch,
                           0.2f);
          TableSetupColumn("Shortcut", ImGuiTableColumnFlags_WidthStretch,
                           0.25f);
          TableHeadersRow();
 
          for (int i = 0; i < row_count; ++i) {
            const CommandEntry& cmd = row_at(i);
 
            TableNextRow();
            TableNextColumn();
 
            PushID(i);
            const bool is_selected = (i == command_palette_selected_idx_);
            const ImGuiSelectableFlags flags =
                ImGuiSelectableFlags_SpanAllColumns |
                (cmd.enabled ? ImGuiSelectableFlags_None
                             : ImGuiSelectableFlags_Disabled);
            if (Selectable(cmd.name.c_str(), is_selected, flags)) {
              command_palette_selected_idx_ = i;
              if (cmd.enabled && cmd.callback) {
                pending_name = cmd.name;
                pending_callback = cmd.callback;
              }
            }
            if (is_selected && command_palette_scroll_to_selected_) {
              SetScrollHereY();
              command_palette_scroll_to_selected_ = false;
            }
            if (!cmd.note.empty() || !cmd.description.empty()) {
              if (IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
                SetTooltip("%s", cmd.note.empty() ? cmd.description.c_str()
                                                  : cmd.note.c_str());
              }
            }
            PopID();
 
            TableNextColumn();
            gui::ColoredText(cmd.category.c_str(),
                             gui::ConvertColorToImVec4(theme.text_secondary));
 
            TableNextColumn();
            if (!cmd.enabled && !cmd.note.empty()) {
              gui::ColoredText(cmd.note.c_str(),
                               gui::ConvertColorToImVec4(theme.text_disabled));
            } else {
              gui::ColoredText(cmd.shortcut.c_str(),
                               gui::ConvertColorToImVec4(theme.text_secondary));
            }
          }
 
          gui::LayoutHelpers::EndTableWithTheming();
        }
        EndTabItem();
      }
 
      if (BeginTabItem(absl::StrFormat("%s Recent", ICON_MD_HISTORY).c_str())) {
        auto recent = command_palette_.GetRecentCommands(10);
        if (recent.empty()) {
          Text(tr("No recent commands yet."));
        } else {
          for (const auto& entry : recent) {
            if (Selectable(entry.name.c_str()) && entry.callback) {
              pending_name = entry.name;
              pending_callback = entry.callback;
            }
          }
        }
        EndTabItem();
      }
 
      if (BeginTabItem(absl::StrFormat("%s Frequent", ICON_MD_STAR).c_str())) {
        auto frequent = command_palette_.GetFrequentCommands(10);
        if (frequent.empty()) {
          Text(tr("No frequently used commands yet."));
        } else {
          for (const auto& entry : frequent) {
            if (Selectable(absl::StrFormat("%s (%d uses)", entry.name,
                                           entry.usage_count)
                               .c_str()) &&
                entry.callback) {
              pending_name = entry.name;
              pending_callback = entry.callback;
            }
          }
        }
        EndTabItem();
      }
 
      gui::EndThemedTabBar();
    }
 
    // Status bar with tips
    Separator();
    Text(tr("%s %d commands | Go to: room/map/msg <hex|#dec> | drawer: "
            "window: layout:"),
         ICON_MD_INFO, row_count);
    SameLine();
    gui::ColoredText("| ↑↓ PgUp/PgDn Home/End | Enter=Run | Esc=Close",
                     gui::ConvertColorToImVec4(theme.text_disabled));
  }
  End();
 
  if (!show_palette || close_requested) {
    show_command_palette_ = false;
  }
  if (pending_callback) {
    ExecutePaletteCommand(pending_name, std::move(pending_callback));
  }
}
 
void UICoordinator::DrawPanelFinder() {
  if (!show_panel_finder_)
    return;
 
  using namespace ImGui;
  const size_t session_id = window_manager_.GetActiveSessionId();
 
  // B6: Responsive modal sizing with dim overlay
  const ImGuiViewport* viewport = GetMainViewport();
  ImDrawList* bg_list = GetBackgroundDrawList();
  bg_list->AddRectFilled(viewport->WorkPos,
                         ImVec2(viewport->WorkPos.x + viewport->WorkSize.x,
                                viewport->WorkPos.y + viewport->WorkSize.y),
                         IM_COL32(0, 0, 0, 100));
 
  SetNextWindowPos(viewport->GetCenter(), ImGuiCond_Appearing,
                   ImVec2(0.5f, 0.3f));
  if (IsCompactLayout()) {
    SetNextWindowSize(
        ImVec2(viewport->WorkSize.x * 0.95f, viewport->WorkSize.y * 0.70f),
        ImGuiCond_Appearing);
  } else {
    SetNextWindowSize(ImVec2(600, 420), ImGuiCond_Appearing);
  }
 
  const ImGuiWindowFlags finder_flags =
      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoMove |
      ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoDocking |
      ImGuiWindowFlags_NoSavedSettings;
 
  bool show = true;
  if (Begin(ICON_MD_DASHBOARD " Window Finder", &show, finder_flags)) {
    // Auto-focus search on open
    if (IsWindowAppearing()) {
      SetKeyboardFocusHere();
      panel_finder_selected_idx_ = 0;
    }
 
    SetNextItemWidth(-1);
    bool input_changed = InputTextWithHint(
        "##panel_finder_query", ICON_MD_SEARCH " Find window...",
        panel_finder_query_, IM_ARRAYSIZE(panel_finder_query_));
 
    if (input_changed) {
      panel_finder_selected_idx_ = 0;
    }
 
    Separator();
 
    // Build filtered + scored list
    struct WindowEntry {
      std::string card_id;
      std::string display_name;
      std::string icon;
      std::string category;
      bool visible;
      bool pinned;
      int score;
    };
    std::vector<WindowEntry> entries;
 
    std::string query(panel_finder_query_);
 
    // B2: Fuzzy scoring via CommandPalette::FuzzyScore
    for (const auto& card_id :
         window_manager_.GetWindowsInSession(session_id)) {
      const auto* desc =
          window_manager_.GetWindowDescriptor(session_id, card_id);
      if (!desc) {
        continue;
      }
      int score = 0;
      if (!query.empty()) {
        score = CommandPalette::FuzzyScore(desc->display_name, query) +
                CommandPalette::FuzzyScore(desc->category, query) / 2;
        if (score <= 0)
          continue;
      }
 
      bool vis = desc->visibility_flag ? *desc->visibility_flag : false;
      bool pin = window_manager_.IsWindowPinned(session_id, card_id);
      entries.push_back({card_id, desc->display_name, desc->icon,
                         desc->category, vis, pin, score});
    }
 
    // B3: MRU + fuzzy sort
    if (query.empty()) {
      // Empty query: pinned first, then MRU order (higher time = more recent)
      std::sort(
          entries.begin(), entries.end(),
          [this](const WindowEntry& lhs, const WindowEntry& rhs) {
            if (lhs.pinned != rhs.pinned)
              return lhs.pinned > rhs.pinned;
            uint64_t lhs_t = window_manager_.GetWindowMRUTime(lhs.card_id);
            uint64_t rhs_t = window_manager_.GetWindowMRUTime(rhs.card_id);
            if (lhs_t != rhs_t)
              return lhs_t > rhs_t;
            return lhs.display_name < rhs.display_name;
          });
    } else {
      // With query: sort by score descending, pinned tiebreaker
      std::sort(entries.begin(), entries.end(),
                [](const WindowEntry& lhs, const WindowEntry& rhs) {
                  if (lhs.score != rhs.score)
                    return lhs.score > rhs.score;
                  if (lhs.pinned != rhs.pinned)
                    return lhs.pinned > rhs.pinned;
                  return lhs.display_name < rhs.display_name;
                });
    }
 
    // Keyboard navigation
    if (IsKeyPressed(ImGuiKey_DownArrow) &&
        panel_finder_selected_idx_ < static_cast<int>(entries.size()) - 1) {
      panel_finder_selected_idx_++;
    }
    if (IsKeyPressed(ImGuiKey_UpArrow) && panel_finder_selected_idx_ > 0) {
      panel_finder_selected_idx_--;
    }
    bool enter_pressed = IsKeyPressed(ImGuiKey_Enter);
 
    // B5: Touch-aware item sizing
    const bool is_touch = gui::LayoutHelpers::IsTouchDevice();
    if (is_touch) {
      PushStyleVar(ImGuiStyleVar_ItemSpacing,
                   ImVec2(GetStyle().ItemSpacing.x, 10.0f));
    }
 
    // Draw panel list
    BeginChild("##PanelFinderList");
    for (int i = 0; i < static_cast<int>(entries.size()); ++i) {
      const auto& entry = entries[i];
      bool is_selected = (i == panel_finder_selected_idx_);
 
      // B4: Visibility indicator icon
      const char* vis_icon =
          entry.visible ? ICON_MD_VISIBILITY : ICON_MD_VISIBILITY_OFF;
 
      // Dim hidden panels
      std::optional<gui::StyleColorGuard> dim_guard;
      if (!entry.visible) {
        ImVec4 dimmed = GetStyleColorVec4(ImGuiCol_Text);
        dimmed.w *= 0.5f;
        dim_guard.emplace(ImGuiCol_Text, dimmed);
      }
 
      std::string label =
          absl::StrFormat("%s %s  %s", vis_icon, entry.icon.c_str(),
                          entry.display_name.c_str());
 
      // Touch: ensure selectable meets 44px minimum height
      float item_h =
          is_touch ? std::max(GetTextLineHeightWithSpacing(), 44.0f) : 0.0f;
 
      PushID(entry.card_id.c_str());
      if (Selectable(label.c_str(), is_selected, ImGuiSelectableFlags_None,
                     ImVec2(0, item_h))) {
        window_manager_.OpenWindow(session_id, entry.card_id);
        window_manager_.MarkWindowRecentlyUsed(entry.card_id);
        show_panel_finder_ = false;
      }
      // Show category badge on the same line
      SameLine(GetContentRegionAvail().x - 80);
      TextDisabled("%s", entry.category.c_str());
      if (entry.pinned) {
        SameLine();
        TextDisabled(ICON_MD_PUSH_PIN);
      }
      PopID();
 
      // Enter to activate selected
      if (is_selected && enter_pressed) {
        window_manager_.OpenWindow(session_id, entry.card_id);
        window_manager_.MarkWindowRecentlyUsed(entry.card_id);
        show_panel_finder_ = false;
      }
 
      // Scroll selected into view
      if (is_selected && (IsKeyPressed(ImGuiKey_DownArrow) ||
                          IsKeyPressed(ImGuiKey_UpArrow))) {
        SetScrollHereY();
      }
    }
    EndChild();
 
    if (is_touch) {
      PopStyleVar();
    }
  }
  End();
 
  // Escape or close button
  if (!show || ImGui::IsKeyPressed(ImGuiKey_Escape)) {
    show_panel_finder_ = false;
    panel_finder_query_[0] = '\0';
  }
}
 
void UICoordinator::DrawShortcutsBrowser() {
  if (!show_shortcuts_browser_) {
    return;
  }
 
  using namespace ImGui;
  const ImGuiViewport* viewport = GetMainViewport();
  SetNextWindowPos(viewport->GetCenter(), ImGuiCond_Appearing,
                   ImVec2(0.5f, 0.5f));
  if (IsCompactLayout()) {
    SetNextWindowSize(
        ImVec2(viewport->WorkSize.x * 0.95f, viewport->WorkSize.y * 0.80f),
        ImGuiCond_Appearing);
  } else {
    SetNextWindowSize(ImVec2(720, 520), ImGuiCond_Appearing);
  }
 
  bool show = true;
  if (Begin(absl::StrFormat("%s Keyboard Shortcuts", ICON_MD_KEYBOARD).c_str(),
            &show, ImGuiWindowFlags_NoCollapse)) {
    if (IsWindowAppearing()) {
      SetKeyboardFocusHere();
    }
 
    SetNextItemWidth(-180.0f);
    InputTextWithHint(
        "##shortcuts_query",
        ICON_MD_SEARCH " Filter by name, keys, or group (File, Drawers, …)",
        shortcuts_browser_query_, IM_ARRAYSIZE(shortcuts_browser_query_));
    SameLine();
    if (Button(ICON_MD_TUNE " Edit bindings")) {
      show_shortcuts_browser_ = false;
      if (editor_manager_) {
        editor_manager_->SwitchToEditor(EditorType::kSettings);
      }
    }
 
    Separator();
 
    std::string query = shortcuts_browser_query_;
    std::transform(query.begin(), query.end(), query.begin(), ::tolower);
 
    std::map<std::string, std::vector<const Shortcut*>> grouped;
    static const char* kGroupOrder[] = {"File",    "Edit",  "View",   "Drawers",
                                        "Windows", "Tools", "Layout", "Editor",
                                        "Help",    "Other"};
 
    for (const auto& [name, shortcut] : shortcut_manager_.GetShortcuts()) {
      const std::string group = InferShortcutGroup(name);
      const std::string keys = PrintShortcut(shortcut.keys);
      if (!query.empty()) {
        std::string hay =
            absl::AsciiStrToLower(absl::StrCat(name, " ", keys, " ", group));
        if (hay.find(query) == std::string::npos) {
          continue;
        }
      }
      grouped[group].push_back(&shortcut);
    }
 
    BeginChild("##ShortcutsBrowserList");
    for (const char* group_name : kGroupOrder) {
      auto it = grouped.find(group_name);
      if (it == grouped.end() || it->second.empty()) {
        continue;
      }
      if (!TreeNodeEx(group_name, ImGuiTreeNodeFlags_DefaultOpen)) {
        continue;
      }
      if (BeginTable(
              absl::StrFormat("##sc_%s", group_name).c_str(), 2,
              ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp)) {
        TableSetupColumn("Action", ImGuiTableColumnFlags_WidthStretch, 0.65f);
        TableSetupColumn("Keys", ImGuiTableColumnFlags_WidthStretch, 0.35f);
        for (const Shortcut* sc : it->second) {
          TableNextRow();
          TableNextColumn();
          if (Selectable(sc->name.c_str(), false,
                         ImGuiSelectableFlags_SpanAllColumns)) {
            if (sc->callback) {
              sc->callback();
              show_shortcuts_browser_ = false;
            }
          }
          TableNextColumn();
          const std::string keys = PrintShortcut(sc->keys);
          TextDisabled("%s", keys.empty() ? "—" : keys.c_str());
        }
        EndTable();
      }
      TreePop();
    }
    EndChild();
 
    Separator();
    TextDisabled(
        "%s Tip: Command Palette (Ctrl+Shift+P) also lists these actions. "
        "Try drawer: / window: / layout:",
        ICON_MD_INFO);
  }
  End();
 
  if (!show || IsKeyPressed(ImGuiKey_Escape)) {
    show_shortcuts_browser_ = false;
    shortcuts_browser_query_[0] = '\0';
  }
}
 
void UICoordinator::InitializeCommandPalette(size_t session_id) {
  command_palette_.Clear();
  RefreshWorkflowActions();
 
  // Register panel commands
  command_palette_.RegisterProvider(
      std::make_unique<PanelCommandsProvider>(&window_manager_, session_id));
  command_palette_.RegisterProvider(
      std::make_unique<WorkflowCommandsProvider>(&window_manager_, session_id));
  if (editor_manager_) {
    command_palette_.RegisterProvider(std::make_unique<SidebarCommandsProvider>(
        &window_manager_, &editor_manager_->user_settings(), session_id));
 
    if (auto* drawers = editor_manager_->right_drawer_manager()) {
      command_palette_.RegisterProvider(
          std::make_unique<DrawerCommandsProvider>(
              [drawers](int drawer_type) {
                drawers->ToggleDrawer(
                    static_cast<RightDrawerManager::DrawerType>(drawer_type));
              },
              [drawers]() { drawers->CycleToNextDrawer(); },
              [drawers]() { drawers->CycleToPreviousDrawer(); }));
    }
  }
 
  // Register editor switch commands
  command_palette_.RegisterProvider(std::make_unique<EditorCommandsProvider>(
      [this](const std::string& category) {
        auto type = EditorRegistry::GetEditorTypeFromCategory(category);
        if (type != EditorType::kSettings && editor_manager_) {
          editor_manager_->SwitchToEditor(type);
        }
      }));
 
  // Register layout/profile commands (includes layout: prefixes)
  if (editor_manager_) {
    command_palette_.RegisterProvider(
        std::make_unique<LayoutCommandsProvider>([this](const std::string& id) {
          if (!editor_manager_) {
            return;
          }
          if (absl::StartsWith(id, "profile:")) {
            editor_manager_->ApplyLayoutProfile(id.substr(8));
          } else if (id == "session:capture") {
            editor_manager_->CaptureTemporaryLayoutSnapshot();
          } else if (id == "session:restore") {
            editor_manager_->RestoreTemporaryLayoutSnapshot();
          } else if (id == "session:clear") {
            editor_manager_->ClearTemporaryLayoutSnapshot();
          } else {
            editor_manager_->ApplyLayoutPreset(id);
          }
        }));
  }
 
  // Register recent files commands
  command_palette_.RegisterProvider(
      std::make_unique<RecentFilesCommandsProvider>(
          [this](const std::string& filepath) {
            if (editor_manager_) {
              auto status = editor_manager_->OpenRomOrProject(filepath);
              if (!status.ok()) {
                toast_manager_.Show(
                    absl::StrFormat("Failed to open: %s", status.message()),
                    ToastType::kError);
              }
            }
          }));
 
  // Dungeon / overworld navigation helpers (jump by id/label). Typed go-to
  // queries ("room 4A", "map #27", "msg 1C") are parsed in DrawCommandPalette.
  command_palette_.RegisterProvider(
      std::make_unique<DungeonRoomCommandsProvider>(session_id));
  command_palette_.RegisterProvider(
      std::make_unique<OverworldMapCommandsProvider>(session_id));
 
  // ShortcutManager commands with live keybindings. Registered through the
  // palette so search, dedupe and usage history treat them like any entry.
  command_palette_.RegisterProvider(
      std::make_unique<ShortcutCommandsProvider>(&shortcut_manager_));
 
  // Welcome-screen-scoped commands: per-entry pin/remove, undo, template
  // creation, and visibility toggles. Recent-entry iteration pulls from the
  // same model the welcome screen renders, so the palette and the cards stay
  // in sync without a separate refresh path. We rebuild these whenever
  // RefreshCommandPalette() is invoked after recents mutate.
  if (welcome_screen_) {
    WelcomeCommandsProvider::Callbacks welcome_callbacks;
    welcome_callbacks.model = &welcome_screen_->recent_projects();
    welcome_callbacks.template_names = {
        "Vanilla ROM Hack", "ZSCustomOverworld v3", "ZSCustomOverworld v2",
        "Randomizer Compatible"};
    welcome_callbacks.remove = [this](const std::string& path) {
      if (!welcome_screen_)
        return;
      welcome_screen_->recent_projects().RemoveRecent(path);
      welcome_screen_->RefreshRecentProjects(/*force=*/true);
      toast_manager_.Show(
          absl::StrFormat("Removed %s from recents",
                          std::filesystem::path(path).filename().string()),
          ToastType::kInfo);
    };
    welcome_callbacks.toggle_pin = [this](const std::string& path) {
      if (!welcome_screen_)
        return;
      auto& model = welcome_screen_->recent_projects();
      bool currently_pinned = false;
      for (const auto& entry : model.entries()) {
        if (entry.filepath == path) {
          currently_pinned = entry.pinned;
          break;
        }
      }
      model.SetPinned(path, !currently_pinned);
      welcome_screen_->RefreshRecentProjects(/*force=*/true);
    };
    welcome_callbacks.undo_remove = [this]() {
      if (!welcome_screen_)
        return;
      if (!welcome_screen_->recent_projects().UndoLastRemoval()) {
        toast_manager_.Show("Nothing to undo — the last removal has expired.",
                            ToastType::kWarning);
        return;
      }
      welcome_screen_->RefreshRecentProjects(/*force=*/true);
    };
    welcome_callbacks.clear_recents = [this]() {
      if (!welcome_screen_)
        return;
      welcome_screen_->recent_projects().ClearAll();
      welcome_screen_->RefreshRecentProjects(/*force=*/true);
    };
    welcome_callbacks.create_from_template =
        [this](const std::string& template_name) {
          new_project_dialog_.Open(template_name);
        };
    welcome_callbacks.dismiss_welcome = [this]() {
      welcome_screen_manually_closed_ = true;
      if (current_startup_surface_ == StartupSurface::kWelcome) {
        SetStartupSurface(StartupSurface::kDashboard);
      }
    };
    welcome_callbacks.show_welcome = [this]() {
      welcome_screen_manually_closed_ = false;
      SetStartupSurface(StartupSurface::kWelcome);
    };
    command_palette_.RegisterProvider(std::make_unique<WelcomeCommandsProvider>(
        std::move(welcome_callbacks)));
  }
 
  // Usage history lives in the palette across Clear()/refresh; read the
  // file once. Every execution saves it (ExecutePaletteCommand).
  if (!command_history_loaded_) {
    auto config_dir = util::PlatformPaths::GetConfigDirectory();
    if (config_dir.ok()) {
      std::filesystem::path history_file = *config_dir / "command_history.json";
      command_palette_.LoadHistory(history_file.string());
    }
    command_history_loaded_ = true;
  }
 
  command_palette_initialized_ = true;
}
 
void UICoordinator::RefreshWorkflowActions() {
  ContentRegistry::WorkflowActions::Clear();
 
  if (editor_manager_ && editor_manager_->GetCurrentProject() &&
      editor_manager_->GetCurrentProject()->project_opened()) {
    ContentRegistry::WorkflowActions::Register(
        {.id = "workflow.project.build",
         .group = "Build & Run",
         .label = "Build Project",
         .description = "Run the active project's configured build command",
         .shortcut = "",
         .priority = 5,
         .callback = [this]() {
           if (editor_manager_) {
             editor_manager_->QueueBuildCurrentProject();
           }
         }});
    ContentRegistry::WorkflowActions::Register(
        {.id = "workflow.project.run",
         .group = "Build & Run",
         .label = "Run Project Output",
         .description = "Open the active project's configured run target in a "
                        "test session",
         .shortcut = "",
         .priority = 10,
         .callback = [this]() {
           if (editor_manager_) {
             (void)editor_manager_->RunCurrentProject();
           }
         }});
  }
 
#ifdef YAZE_WITH_GRPC
  auto* emu_backend = Application::Instance().GetEmulatorBackend();
  if (emu_backend) {
    ContentRegistry::WorkflowActions::Register(
        {.id = "workflow.mesen.connect",
         .group = "Live Debugging",
         .label = "Connect Mesen2",
         .description =
             "Auto-discover and connect to the active Mesen2 backend",
         .shortcut = "",
         .priority = 10,
         .callback = [this]() {
           auto* backend = Application::Instance().GetEmulatorBackend();
           if (backend) {
             toast_manager_.Show("Mesen2 connection attempt queued",
                                 ToastType::kInfo);
           }
         }});
    ContentRegistry::WorkflowActions::Register(
        {.id = "workflow.mesen.step_over",
         .group = "Live Debugging",
         .label = "Mesen2 Step Over",
         .description = "Execute one instruction without entering subroutines",
         .shortcut = "F10",
         .priority = 20,
         .callback = [emu_backend]() { emu_backend->StepOver(); }});
    ContentRegistry::WorkflowActions::Register(
        {.id = "workflow.mesen.step_out",
         .group = "Live Debugging",
         .label = "Mesen2 Step Out",
         .description = "Run until return from the current subroutine",
         .shortcut = "Shift+F11",
         .priority = 30,
         .callback = [emu_backend]() { emu_backend->StepOut(); }});
    ContentRegistry::WorkflowActions::Register(
        {.id = "workflow.mesen.overlay_on",
         .group = "Live Debugging",
         .label = "Enable Collision Overlay",
         .description = "Show collision overlays in the active Mesen2 backend",
         .shortcut = "",
         .priority = 40,
         .callback = [emu_backend]() {
           emu_backend->SetCollisionOverlay(true);
         }});
    ContentRegistry::WorkflowActions::Register(
        {.id = "workflow.mesen.overlay_off",
         .group = "Live Debugging",
         .label = "Disable Collision Overlay",
         .description = "Hide collision overlays in the active Mesen2 backend",
         .shortcut = "",
         .priority = 50,
         .callback = [emu_backend]() {
           emu_backend->SetCollisionOverlay(false);
         }});
  }
#endif
}
 
void UICoordinator::RefreshCommandPalette(size_t session_id) {
  InitializeCommandPalette(session_id);
}
 
void UICoordinator::DrawGlobalSearch() {
  if (!show_global_search_)
    return;
 
  ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(),
                          ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
  ImGui::SetNextWindowSize(ImVec2(800, 600), ImGuiCond_FirstUseEver);
 
  bool show_search = true;
  if (ImGui::Begin(
          absl::StrFormat("%s Global Search", ICON_MD_MANAGE_SEARCH).c_str(),
          &show_search, ImGuiWindowFlags_NoCollapse)) {
    // Enhanced search input with focus management
    ImGui::SetNextItemWidth(-100);
    if (ImGui::IsWindowAppearing()) {
      ImGui::SetKeyboardFocusHere();
    }
 
    bool input_changed = ImGui::InputTextWithHint(
        "##global_query",
        absl::StrFormat("%s Search everything...", ICON_MD_SEARCH).c_str(),
        global_search_query_, IM_ARRAYSIZE(global_search_query_));
 
    ImGui::SameLine();
    if (ImGui::Button(absl::StrFormat("%s Clear", ICON_MD_CLEAR).c_str())) {
      global_search_query_[0] = '\0';
      input_changed = true;
    }
 
    ImGui::Separator();
 
    // Tabbed search results for better organization
    if (gui::BeginThemedTabBar("SearchResultTabs")) {
      // Recent Files Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Recent Files", ICON_MD_HISTORY).c_str())) {
        auto& manager = project::RecentFilesManager::GetInstance();
        auto recent_files = manager.GetRecentFiles();
 
        if (ImGui::BeginTable("RecentFilesTable", 3,
                              ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg |
                                  ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("File", ImGuiTableColumnFlags_WidthStretch,
                                  0.6f);
          ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_WidthFixed,
                                  80.0f);
          ImGui::TableSetupColumn("Action", ImGuiTableColumnFlags_WidthFixed,
                                  100.0f);
          ImGui::TableHeadersRow();
 
          for (const auto& file : recent_files) {
            if (global_search_query_[0] != '\0' &&
                file.find(global_search_query_) == std::string::npos)
              continue;
 
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::Text("%s", util::GetFileName(file).c_str());
 
            ImGui::TableNextColumn();
            std::string ext = util::GetFileExtension(file);
            if (ext == "sfc" || ext == "smc") {
              ImGui::TextColored(ImVec4(0.2f, 0.8f, 0.2f, 1.0f), tr("%s ROM"),
                                 ICON_MD_VIDEOGAME_ASSET);
            } else if (ext == "yaze") {
              ImGui::TextColored(ImVec4(0.2f, 0.6f, 0.8f, 1.0f),
                                 tr("%s Project"), ICON_MD_FOLDER);
            } else {
              ImGui::Text(tr("%s File"), ICON_MD_DESCRIPTION);
            }
 
            ImGui::TableNextColumn();
            ImGui::PushID(file.c_str());
            if (ImGui::Button(tr("Open"))) {
              auto status = editor_manager_->OpenRomOrProject(file);
              if (!status.ok()) {
                toast_manager_.Show(
                    absl::StrCat("Failed to open: ", status.message()),
                    ToastType::kError);
              }
              SetGlobalSearchVisible(false);
            }
            ImGui::PopID();
          }
 
          ImGui::EndTable();
        }
        ImGui::EndTabItem();
      }
 
      // Labels Tab (only if ROM is loaded)
      auto* current_rom = editor_manager_->GetCurrentRom();
      if (current_rom && current_rom->resource_label()) {
        if (ImGui::BeginTabItem(
                absl::StrFormat("%s Labels", ICON_MD_LABEL).c_str())) {
          auto& labels = current_rom->resource_label()->labels_;
 
          if (ImGui::BeginTable("LabelsTable", 3,
                                ImGuiTableFlags_ScrollY |
                                    ImGuiTableFlags_RowBg |
                                    ImGuiTableFlags_SizingStretchProp)) {
            ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_WidthFixed,
                                    100.0f);
            ImGui::TableSetupColumn("Label", ImGuiTableColumnFlags_WidthStretch,
                                    0.4f);
            ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch,
                                    0.6f);
            ImGui::TableHeadersRow();
 
            for (const auto& type_pair : labels) {
              for (const auto& kv : type_pair.second) {
                if (global_search_query_[0] != '\0' &&
                    kv.first.find(global_search_query_) == std::string::npos &&
                    kv.second.find(global_search_query_) == std::string::npos)
                  continue;
 
                ImGui::TableNextRow();
                ImGui::TableNextColumn();
                ImGui::Text("%s", type_pair.first.c_str());
 
                ImGui::TableNextColumn();
                if (ImGui::Selectable(kv.first.c_str(), false,
                                      ImGuiSelectableFlags_SpanAllColumns)) {
                  // Future: navigate to related editor/location
                }
 
                ImGui::TableNextColumn();
                ImGui::TextDisabled("%s", kv.second.c_str());
              }
            }
 
            ImGui::EndTable();
          }
          ImGui::EndTabItem();
        }
      }
 
      // Sessions Tab
      if (session_coordinator_.GetActiveSessionCount() > 1) {
        if (ImGui::BeginTabItem(
                absl::StrFormat("%s Sessions", ICON_MD_TAB).c_str())) {
          ImGui::Text(tr("Search and switch between active sessions:"));
 
          for (size_t i = 0; i < session_coordinator_.GetTotalSessionCount();
               ++i) {
            std::string session_info =
                session_coordinator_.GetSessionDisplayName(i);
            if (session_info == "[CLOSED SESSION]")
              continue;
 
            if (global_search_query_[0] != '\0' &&
                session_info.find(global_search_query_) == std::string::npos)
              continue;
 
            bool is_current =
                (i == session_coordinator_.GetActiveSessionIndex());
            std::optional<gui::StyleColorGuard> current_guard;
            if (is_current) {
              current_guard.emplace(ImGuiCol_Text,
                                    ImVec4(0.2f, 0.8f, 0.2f, 1.0f));
            }
 
            if (ImGui::Selectable(absl::StrFormat("%s %s %s", ICON_MD_TAB,
                                                  session_info.c_str(),
                                                  is_current ? "(Current)" : "")
                                      .c_str())) {
              if (!is_current) {
                editor_manager_->SwitchToSession(i);
                SetGlobalSearchVisible(false);
              }
            }
          }
          ImGui::EndTabItem();
        }
      }
 
      gui::EndThemedTabBar();
    }
 
    // Status bar
    ImGui::Separator();
    ImGui::Text(tr("%s Global search across all YAZE data"), ICON_MD_INFO);
  }
  ImGui::End();
 
  // Update visibility state
  if (!show_search) {
    SetGlobalSearchVisible(false);
  }
}
 
// ============================================================================
// Startup Surface Management (Single Source of Truth)
// ============================================================================
 
void UICoordinator::SetStartupSurface(StartupSurface surface) {
  // Automatic moves to the dashboard (after a ROM or project load, or when
  // the welcome screen closes) obey the same rule as
  // SetEditorSelectionVisible(true): no picker when it is suppressed or an
  // editor is already open. Ctrl+E uses ShowEditorSelection() instead.
  if (surface == StartupSurface::kDashboard && !ShouldShowDashboard()) {
    surface = StartupSurface::kEditor;
  }
  StartupSurface old_surface = current_startup_surface_;
  current_startup_surface_ = surface;
 
  // Log state transitions for debugging
  const char* surface_names[] = {"Welcome", "Dashboard", "Editor"};
  LOG_INFO("UICoordinator", "Startup surface: %s -> %s",
           surface_names[static_cast<int>(old_surface)],
           surface_names[static_cast<int>(surface)]);
 
  // Update dependent visibility flags
  switch (surface) {
    case StartupSurface::kWelcome:
      show_welcome_screen_ = true;
      show_editor_selection_ = false;  // Dashboard hidden
      // Activity Bar will be hidden (checked via ShouldShowActivityBar)
      break;
    case StartupSurface::kDashboard:
      show_welcome_screen_ = false;
      show_editor_selection_ = true;  // Dashboard shown
      break;
    case StartupSurface::kEditor:
      show_welcome_screen_ = false;
      show_editor_selection_ = false;  // Dashboard hidden
      break;
  }
}
 
bool UICoordinator::ShouldShowWelcome() const {
  // Respect CLI overrides
  if (welcome_behavior_override_ == StartupVisibility::kHide) {
    return false;
  }
  if (welcome_behavior_override_ == StartupVisibility::kShow) {
    return true;
  }
 
  // Default: show welcome only when in welcome state and not manually closed
  return current_startup_surface_ == StartupSurface::kWelcome &&
         !welcome_screen_manually_closed_;
}
 
bool UICoordinator::ShouldShowDashboard() const {
  // Consulted by SetEditorSelectionVisible, the choke point every automatic
  // entry into the dashboard passes through.
  //
  // This used to also require current_startup_surface_ == kDashboard, and
  // nothing called it at all — so --startup_dashboard=hide did nothing while
  // its sibling --startup_welcome worked, because ShouldShowWelcome() IS
  // consulted. The surface test is dropped on purpose: by the time a ROM
  // finishes loading the surface has already advanced past kDashboard, so
  // keying on it would suppress the very chooser the flag exists to govern.
  if (dashboard_behavior_override_ == StartupVisibility::kHide) {
    return false;
  }
  if (dashboard_behavior_override_ == StartupVisibility::kShow) {
    return true;
  }
  // Auto: the picker is for choosing a first editor. Do not cover one that
  // is already open (for example, File > Open while the Dungeon editor is up).
  return !(editor_manager_ && editor_manager_->HasOpenEditor());
}
 
bool UICoordinator::ShouldShowActivityBar() const {
  // Sidebar would consume the entire screen on compact (iPhone portrait)
  if (IsCompactLayout()) {
    return false;
  }
 
  // Activity Bar hidden on cold start (welcome screen)
  // Only show after ROM is loaded
  if (current_startup_surface_ == StartupSurface::kWelcome) {
    return false;
  }
 
  // Check if ROM is actually loaded
  if (editor_manager_) {
    auto* current_rom = editor_manager_->GetCurrentRom();
    if (!current_rom || !current_rom->is_loaded()) {
      return false;
    }
  }
 
  return true;
}
 
}  // namespace editor
}  // namespace yaze