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 <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/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"); });
 
  // Template-driven creation now opens the guided dialog instead of chaining
  // straight into CreateNewProject -> LoadRom. The dialog calls back into
  // EditorManager once the user has a ROM path and project name picked.
  welcome_screen_->SetNewProjectWithTemplateCallback(
      [this](const std::string& template_name) {
        new_project_dialog_.Open(template_name);
      });
 
  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_->SetOpenAgentCallback([this]() {
    if (editor_manager_) {
#ifdef YAZE_BUILD_AGENT_UI
      editor_manager_->ShowAIAgent();
#endif
      // Exit welcome so the agent panels can be interacted with
      SetStartupSurface(StartupSurface::kEditor);
    }
  });
 
  welcome_screen_->SetOpenProjectDialogCallback([this]() {
    if (editor_manager_) {
      auto status = editor_manager_->OpenProject();
      if (!status.ok()) {
        toast_manager_.Show(
            absl::StrFormat("Failed to open project: %s", status.message()),
            ToastType::kError);
      } else {
        SetStartupSurface(StartupSurface::kDashboard);
      }
    }
  });
 
  welcome_screen_->SetOpenProjectManagementCallback([this]() {
    if (editor_manager_) {
      editor_manager_->ShowProjectManagement();
      SetStartupSurface(StartupSurface::kDashboard);
    }
  });
 
  welcome_screen_->SetOpenProjectFileEditorCallback([this]() {
    if (!editor_manager_) {
      return;
    }
    const auto* project = editor_manager_->GetCurrentProject();
    if (!project || project->filepath.empty()) {
      toast_manager_.Show("No project file to edit", ToastType::kInfo);
      return;
    }
    editor_manager_->ShowProjectFileEditor();
    SetStartupSurface(StartupSurface::kDashboard);
  });
 
  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
  DrawPanelFinder();             // Ctrl+P
  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: Version, dirty indicator, session, bell, panel toggles
  // Panel toggles are positioned using SCREEN coordinates (from viewport) so they
  // stay fixed even when the dockspace resizes due to panel open/close.
  //
  // Layout: [v0.x.x][●][📄▾][🔔] [panels][⬆]
  //         ^^^ shifts with dockspace ^^^  ^^^ fixed screen position ^^^
 
  auto* current_rom = editor_manager_->GetCurrentRom();
  const std::string full_version =
      absl::StrFormat("v%s", editor_manager_->version().c_str());
 
  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;
 
  // Calculate panel toggle region width
  // Keep this in sync with RightDrawerManager::DrawDrawerToggleButtons().
  const bool has_panel_toggles =
      editor_manager_->right_drawer_manager() != nullptr;
  float panel_buttons_width = 0.0f;
  if (has_panel_toggles) {
    const char* kIcons[] = {
        ICON_MD_FOLDER_SPECIAL,  // Project
        ICON_MD_SMART_TOY,       // Agent
        ICON_MD_HELP_OUTLINE,    // Help
        ICON_MD_SETTINGS,        // Settings
        ICON_MD_LIST_ALT,        // Properties
    };
    constexpr size_t kIconCount = sizeof(kIcons) / sizeof(kIcons[0]);
 
    for (size_t i = 0; i < kIconCount; ++i) {
      panel_buttons_width += CalcSmallButtonWidth(kIcons[i]);
      if (i + 1 < kIconCount) {
        panel_buttons_width += item_spacing;
      }
    }
  }
 
  // 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();
  }
 
  // Calculate available space for status cluster (version, dirty, session, bell)
  // This ends where the panel toggle region 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);
 
  // Calculate what elements to show - progressive hiding 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 version_width = ImGui::CalcTextSize(full_version.c_str()).x;
  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);
 
  // Progressive show/hide based on available space
  // Priority (highest to lowest): Bell > Dirty > Session > Version
 
  // Try to fit version (lowest priority - hide first when tight)
  bool show_version =
      (required_width + version_width + item_spacing) <= available_width;
  if (show_version) {
    required_width += version_width + item_spacing;
  }
 
  // 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. Version - subdued gray text
  if (show_version) {
    gui::ColoredText(full_version.c_str(), gui::GetTextDisabledVec4());
    ImGui::SameLine();
  }
 
  // 2. 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();
  }
 
  // 3. Session button - layers icon
  if (show_session) {
    DrawSessionButton();
    ImGui::SameLine();
  }
 
  // 4. Notification bell (pass visibility flags for enhanced tooltip)
  DrawNotificationBell(show_dirty, has_dirty_rom, show_session,
                       has_multiple_sessions);
 
  // =========================================================================
  // DRAW PANEL TOGGLES (fixed screen position, unaffected by dockspace resize)
  // =========================================================================
  if (has_panel_toggles) {
    // Get current Y position within menu bar
    float menu_bar_y = ImGui::GetCursorScreenPos().y;
 
    // Position at fixed screen coordinates
    ImGui::SetCursorScreenPos(ImVec2(panel_screen_x, menu_bar_y));
 
    // Draw panel toggle buttons
    editor_manager_->right_drawer_manager()->DrawDrawerToggleButtons();
  }
 
#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();
 
  // Check if notifications panel is active
  bool is_active =
      right_panel && right_panel->IsDrawerActive(
                         RightDrawerManager::DrawerType::kNotifications);
 
  // Bell icon with accent color when there are unread notifications or panel is active
  ImVec4 bell_text_color = (unread > 0 || is_active)
                               ? gui::GetPrimaryVec4()
                               : gui::GetTextSecondaryVec4();
  gui::StyleColorGuard bell_guard(
      {{ImGuiCol_Text, bell_text_color},
       {ImGuiCol_Button, ImVec4(0, 0, 0, 0)},
       {ImGuiCol_ButtonHovered, gui::GetSurfaceContainerHighVec4()},
       {ImGuiCol_ButtonActive, gui::GetSurfaceContainerHighestVec4()}});
 
  // Bell button - opens notifications panel in right sidebar
  if (ImGui::SmallButton(ICON_MD_NOTIFICATIONS)) {
    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();
 
  // Consistent button styling with other menubar buttons
  gui::StyleColorGuard session_btn_guard(
      {{ImGuiCol_Button, ImVec4(0, 0, 0, 0)},
       {ImGuiCol_ButtonHovered, gui::GetSurfaceContainerHighVec4()},
       {ImGuiCol_ButtonActive, gui::GetSurfaceContainerHighestVec4()},
       {ImGuiCol_Text, gui::GetTextSecondaryVec4()}});
 
  // Store button position for popup anchoring
  ImVec2 button_min = ImGui::GetCursorScreenPos();
 
  if (ImGui::SmallButton(ICON_MD_LAYERS)) {
    ImGui::OpenPopup("##SessionSwitcherPopup");
  }
 
  ImVec2 button_max = ImGui::GetItemRectMax();
 
  if (ImGui::IsItemHovered()) {
    std::string tooltip = current_rom && current_rom->is_loaded()
                              ? current_rom->short_name()
                              : "No ROM loaded";
    ImGui::SetTooltip(tr("%s\n%zu sessions open (Ctrl+Tab)"), tooltip.c_str(),
                      session_coordinator_.GetActiveSessionCount());
  }
 
  // 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 size_t session_id = session_coordinator_.GetActiveSessionId();
  if (command_palette_initialized_) {
    RefreshCommandPalette(session_id);
  } else {
    InitializeCommandPalette(session_id);
  }
  show_command_palette_ = true;
}
 
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 gating actions
  welcome_screen_->SetContextState(rom_is_loaded,
                                   project_manager_.HasActiveProject());
 
  // 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::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;
  if (Begin(absl::StrFormat("%s Command Palette", ICON_MD_SEARCH).c_str(),
            &show_palette, ImGuiWindowFlags_NoCollapse)) {
    // Search input with focus management
    SetNextItemWidth(-100);
    if (IsWindowAppearing()) {
      SetKeyboardFocusHere();
      command_palette_selected_idx_ = 0;
    }
 
    bool input_changed = InputTextWithHint(
        "##cmd_query",
        absl::StrFormat("%s Search commands (fuzzy matching enabled)...",
                        ICON_MD_SEARCH)
            .c_str(),
        command_palette_query_, IM_ARRAYSIZE(command_palette_query_));
 
    SameLine();
    if (Button(absl::StrFormat("%s Clear", ICON_MD_CLEAR).c_str())) {
      command_palette_query_[0] = '\0';
      input_changed = true;
      command_palette_selected_idx_ = 0;
    }
 
    Separator();
 
    // Unified command list structure
    struct ScoredCommand {
      int score;
      std::string name;
      std::string category;
      std::string shortcut;
      std::function<void()> callback;
    };
    std::vector<ScoredCommand> scored_commands;
 
    std::string query_lower = command_palette_query_;
    std::transform(query_lower.begin(), query_lower.end(), query_lower.begin(),
                   ::tolower);
 
    auto score_text = [&query_lower](const std::string& text) -> int {
      std::string text_lower = text;
      std::transform(text_lower.begin(), text_lower.end(), text_lower.begin(),
                     ::tolower);
 
      if (query_lower.empty())
        return 1;
      if (text_lower.find(query_lower) == 0)
        return 1000;
      if (text_lower.find(query_lower) != std::string::npos)
        return 500;
 
      // Fuzzy match
      size_t text_idx = 0, query_idx = 0;
      int score = 0;
      while (text_idx < text_lower.length() &&
             query_idx < query_lower.length()) {
        if (text_lower[text_idx] == query_lower[query_idx]) {
          score += 10;
          query_idx++;
        }
        text_idx++;
      }
      return (query_idx == query_lower.length()) ? score : 0;
    };
 
    // Add shortcuts from ShortcutManager
    for (const auto& [name, shortcut] : shortcut_manager_.GetShortcuts()) {
      int score = score_text(name);
      if (score > 0) {
        std::string shortcut_text =
            shortcut.keys.empty()
                ? ""
                : absl::StrFormat("(%s)", PrintShortcut(shortcut.keys).c_str());
        scored_commands.push_back(
            {score, name, "Shortcuts", shortcut_text, shortcut.callback});
      }
    }
 
    // Add commands from CommandPalette
    for (const auto& entry : command_palette_.GetAllCommands()) {
      int score = score_text(entry.name);
      // Also search category and description
      score += score_text(entry.category) / 2;
      score += score_text(entry.description) / 4;
 
      if (score > 0) {
        scored_commands.push_back({score, entry.name, entry.category,
                                   entry.shortcut, entry.callback});
      }
    }
 
    // Sort by score descending
    std::sort(scored_commands.begin(), scored_commands.end(),
              [](const auto& a, const auto& b) { return a.score > b.score; });
 
    // 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", 4,
                ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg |
                    ImGuiTableFlags_SizingStretchProp,
                ImVec2(0, -30))) {
          TableSetupColumn("Command", ImGuiTableColumnFlags_WidthStretch,
                           0.45f);
          TableSetupColumn("Category", ImGuiTableColumnFlags_WidthStretch,
                           0.2f);
          TableSetupColumn("Shortcut", ImGuiTableColumnFlags_WidthStretch,
                           0.2f);
          TableSetupColumn("Score", ImGuiTableColumnFlags_WidthStretch, 0.15f);
          TableHeadersRow();
 
          for (size_t i = 0; i < scored_commands.size(); ++i) {
            const auto& cmd = scored_commands[i];
 
            TableNextRow();
            TableNextColumn();
 
            PushID(static_cast<int>(i));
            bool is_selected =
                (static_cast<int>(i) == command_palette_selected_idx_);
            if (Selectable(cmd.name.c_str(), is_selected,
                           ImGuiSelectableFlags_SpanAllColumns)) {
              command_palette_selected_idx_ = i;
              if (cmd.callback) {
                cmd.callback();
                show_command_palette_ = false;
                // Record usage for frecency
                command_palette_.RecordUsage(cmd.name);
              }
            }
            PopID();
 
            TableNextColumn();
            gui::ColoredText(cmd.category.c_str(),
                             gui::ConvertColorToImVec4(theme.text_secondary));
 
            TableNextColumn();
            gui::ColoredText(cmd.shortcut.c_str(),
                             gui::ConvertColorToImVec4(theme.text_secondary));
 
            TableNextColumn();
            gui::ColoredTextF(gui::ConvertColorToImVec4(theme.text_disabled),
                              "%d", cmd.score);
          }
 
          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())) {
              if (entry.callback) {
                entry.callback();
                show_command_palette_ = false;
                command_palette_.RecordUsage(entry.name);
              }
            }
          }
        }
        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())) {
              if (entry.callback) {
                entry.callback();
                show_command_palette_ = false;
                command_palette_.RecordUsage(entry.name);
              }
            }
          }
        }
        EndTabItem();
      }
 
      gui::EndThemedTabBar();
    }
 
    // Status bar with tips
    Separator();
    Text(tr("%s %zu commands | Score: fuzzy match"), ICON_MD_INFO,
         scored_commands.size());
    SameLine();
    gui::ColoredText("| ↑↓=Navigate | Enter=Execute | Esc=Close",
                     gui::ConvertColorToImVec4(theme.text_disabled));
  }
  End();
 
  // Update visibility state - save history when closing
  if (!show_palette) {
    show_command_palette_ = false;
    // Save command usage history on close
    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::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::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));
  }
 
  // 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
  command_palette_.AddCommand("Apply: Minimal Layout", CommandCategory::kLayout,
                              "Switch to essential cards only", "", [this]() {
                                if (editor_manager_) {
                                  editor_manager_->ApplyLayoutPreset("Minimal");
                                }
                              });
 
  command_palette_.AddCommand(
      "Apply: Logic Debugger Layout", CommandCategory::kLayout,
      "Switch to debug and development focused layout", "", [this]() {
        if (editor_manager_) {
          editor_manager_->ApplyLayoutPreset("Logic Debugger");
        }
      });
 
  command_palette_.AddCommand(
      "Apply: Overworld Artist Layout", CommandCategory::kLayout,
      "Switch to visual and overworld focused layout", "", [this]() {
        if (editor_manager_) {
          editor_manager_->ApplyLayoutPreset("Overworld Artist");
        }
      });
 
  command_palette_.AddCommand(
      "Apply: Dungeon Master Layout", CommandCategory::kLayout,
      "Switch to comprehensive dungeon editing layout", "", [this]() {
        if (editor_manager_) {
          editor_manager_->ApplyLayoutPreset("Dungeon Master");
        }
      });
 
  command_palette_.AddCommand(
      "Apply: Audio Engineer Layout", CommandCategory::kLayout,
      "Switch to music and sound editing layout", "", [this]() {
        if (editor_manager_) {
          editor_manager_->ApplyLayoutPreset("Audio Engineer");
        }
      });
 
  // 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 navigation helpers (room jump by id/label).
  command_palette_.RegisterProvider(
      std::make_unique<DungeonRoomCommandsProvider>(session_id));
 
  // 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)));
  }
 
  // Load command usage history
  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_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) {
  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 {
  // Respect CLI overrides
  if (dashboard_behavior_override_ == StartupVisibility::kHide) {
    return false;
  }
  if (dashboard_behavior_override_ == StartupVisibility::kShow) {
    return true;
  }
 
  // Default: show dashboard only when in dashboard state
  return current_startup_surface_ == StartupSurface::kDashboard;
}
 
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