editor_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_EDITOR_MANAGER_H
#define YAZE_APP_EDITOR_EDITOR_MANAGER_H
 
#define IMGUI_DEFINE_MATH_OPERATORS
 
#include <atomic>
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/strings/string_view.h"
#include "app/editor/agent/agent_ui_controller.h"
#include "app/editor/code/project_file_editor.h"
#include "app/editor/core/content_registry.h"
#include "app/editor/core/editor_context.h"
#include "app/editor/core/event_bus.h"
#include "app/editor/editor.h"
#include "app/editor/layout/layout_coordinator.h"
#include "app/editor/layout/layout_manager.h"
#include "app/editor/layout/window_delegate.h"
#include "app/editor/menu/activity_bar.h"
#include "app/editor/menu/menu_builder.h"
#include "app/editor/menu/menu_orchestrator.h"
#include "app/editor/menu/right_drawer_manager.h"
#include "app/editor/menu/status_bar.h"
#include "app/editor/session_types.h"
#include "app/editor/shell/coordinator/ui_coordinator.h"
#include "app/editor/shell/coordinator/welcome_screen.h"
#include "app/editor/shell/coordinator/workspace_manager.h"
#include "app/editor/shell/feedback/popup_manager.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/shell/windows/dashboard_panel.h"
#include "app/editor/shell/windows/project_management_panel.h"
#include "app/editor/shell/windows/selection_properties_panel.h"
#include "app/editor/system/editor_activator.h"
#include "app/editor/system/editor_manager_interfaces.h"
#include "app/editor/system/editor_registry.h"
#include "app/editor/system/panel_host.h"
#include "app/editor/system/project_workflow_status.h"
#include "app/editor/system/proposal_drawer.h"
#include "app/editor/system/session/background_command_task.h"
#include "app/editor/system/session/project_manager.h"
#include "app/editor/system/session/rom_file_manager.h"
#include "app/editor/system/session/rom_lifecycle_manager.h"
#include "app/editor/system/session/session_coordinator.h"
#include "app/editor/system/session/user_settings.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "app/editor/ui/rom_load_options_dialog.h"
#include "app/emu/emulator.h"
#include "app/startup_flags.h"
#include "core/project.h"
#include "core/version_manager.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
#include "util/log.h"
#include "yaze_config.h"
#include "zelda3/overworld/overworld.h"
 
// Forward declarations for gRPC-dependent types
namespace yaze {
class CanvasAutomationServiceImpl;
}
 
namespace yaze::editor {
class AgentEditor;
namespace workflow {
class HackWorkflowBackend;
}  // namespace workflow
}  // namespace yaze::editor
 
namespace yaze {
 
// Forward declaration for AppConfig
struct AppConfig;
 
namespace editor {
 
std::optional<EditorType> ParseEditorTypeFromString(absl::string_view name);
 
class EditorManager : public ISessionConfigurator, public IEditorSwitcher {
 public:
  struct UiSyncState {
    uint64_t frame_id = 0;
    int pending_editor_actions = 0;
    int pending_layout_actions = 0;
    bool layout_rebuild_pending = false;
  };
 
  enum class PotItemSaveDecision {
    kSaveWithPotItems,
    kSaveWithoutPotItems,
    kCancel
  };
 
  // Constructor and destructor must be defined in .cc file for std::unique_ptr
  // with forward-declared types
  EditorManager();
  ~EditorManager();
 
  void Initialize(gfx::IRenderer* renderer, const std::string& filename = "");
 
  // Processes startup flags to open a specific editor and panels.
  void OpenEditorAndPanelsFromFlags(const std::string& editor_name,
                                    const std::string& panels_str);
 
  // Apply startup actions based on AppConfig
  void ProcessStartupActions(const AppConfig& config);
  void ApplyStartupVisibility(const AppConfig& config);
  void SetStartupLoadHints(const AppConfig& config);
 
  void SetAssetLoadMode(AssetLoadMode mode);
  AssetLoadMode asset_load_mode() const { return asset_load_mode_; }
 
  absl::Status Update();
  void DrawMainMenuBar();
 
  // Host visibility/focus lifecycle hook (e.g., OS space switching).
  void HandleHostVisibilityChanged(bool visible);
 
  auto emulator() -> emu::Emulator& { return emulator_; }
  auto quit() const { return quit_; }
  auto version() const { return version_; }
 
  MenuBuilder& menu_builder() { return menu_builder_; }
  WorkspaceManager* workspace_manager() { return &workspace_manager_; }
  RightDrawerManager* right_drawer_manager() {
    return right_drawer_manager_.get();
  }
  const RightDrawerManager* right_drawer_manager() const {
    return right_drawer_manager_.get();
  }
  StatusBar* status_bar() { return &status_bar_; }
  ToastManager* toast_manager() { return &toast_manager_; }
  PopupManager* popup_manager() { return popup_manager_.get(); }
  WorkspaceWindowManager* GetWindowManager() { return &window_manager_; }
  WorkspaceWindowManager& window_manager() { return window_manager_; }
  const WorkspaceWindowManager& window_manager() const {
    return window_manager_;
  }
  SessionCoordinator* session_coordinator() {
    return session_coordinator_.get();
  }
  const SessionCoordinator* session_coordinator() const {
    return session_coordinator_.get();
  }
  [[deprecated("Use window_host() instead.")]] PanelHost* panel_host() {
    return window_host_.get();
  }
  [[deprecated("Use window_host() instead.")]] const PanelHost* panel_host()
      const {
    return window_host_.get();
  }
  WindowHost* window_host() { return window_host_.get(); }
  const WindowHost* window_host() const { return window_host_.get(); }
 
  // Layout offset calculation for dockspace adjustment
  // Delegates to LayoutCoordinator for cleaner separation of concerns
  float GetLeftLayoutOffset() const {
    return layout_coordinator_.GetLeftLayoutOffset();
  }
  float GetRightLayoutOffset() const {
    return layout_coordinator_.GetRightLayoutOffset();
  }
  float GetBottomLayoutOffset() const {
    return layout_coordinator_.GetBottomLayoutOffset();
  }
 
  absl::Status SetCurrentRom(Rom* rom);
  Rom* GetCurrentRom() const override {
    return session_coordinator_ ? session_coordinator_->GetCurrentRom()
                                : nullptr;
  }
  auto GetCurrentGameData() const -> zelda3::GameData* {
    return session_coordinator_ ? session_coordinator_->GetCurrentGameData()
                                : nullptr;
  }
  auto GetCurrentEditorSet() const -> EditorSet* {
    return session_coordinator_ ? session_coordinator_->GetCurrentEditorSet()
                                : nullptr;
  }
  auto GetCurrentEditor() const -> Editor* override { return current_editor_; }
  std::string GetCurrentRomHash() const {
    return rom_lifecycle_.current_rom_hash();
  }
  project::RomRole GetProjectRomRole() const {
    return current_project_.rom_metadata.role;
  }
  project::RomWritePolicy GetProjectRomWritePolicy() const {
    return current_project_.rom_metadata.write_policy;
  }
  std::string GetProjectExpectedRomHash() const {
    return current_project_.rom_metadata.expected_hash;
  }
  bool IsRomHashMismatch() const { return rom_lifecycle_.IsRomHashMismatch(); }
  std::vector<editor::RomFileManager::BackupEntry> GetRomBackups() const;
  bool IsRomBackupRestorePending() const;
  absl::Status RestoreRomBackup(const std::string& backup_path);
  absl::Status DiscardPendingRomBackupRestore();
  absl::Status PruneRomBackups();
  void ConfirmRomWrite();
  void CancelRomWriteConfirm();
  bool IsRomWriteConfirmPending() const {
    return rom_lifecycle_.IsRomWriteConfirmPending();
  }
 
  // Write conflict warning (ASM-owned address protection)
  const std::vector<core::WriteConflict>& pending_write_conflicts() const {
    return rom_lifecycle_.pending_write_conflicts();
  }
  void BypassWriteConflictOnce() { rom_lifecycle_.BypassWriteConflictOnce(); }
  void ClearPendingWriteConflicts();
  void SetCurrentEditor(Editor* editor) override {
    current_editor_ = editor;
    // Update ContentRegistry context for panel access
    ContentRegistry::Context::SetCurrentEditor(editor);
    // Update help panel's editor context for context-aware help
    if (right_drawer_manager_ && editor) {
      right_drawer_manager_->SetActiveEditor(editor->type());
    }
  }
  size_t GetCurrentSessionId() const {
    return session_coordinator_ ? session_coordinator_->GetActiveSessionId()
                                : 0;
  }
  UICoordinator* ui_coordinator() { return ui_coordinator_.get(); }
  yaze::zelda3::Overworld* overworld() const;
 
  // Session management helpers (compact, zero-based UI ordering)
  size_t GetCurrentSessionIndex() const;
 
  // Get current session's feature flags (falls back to global if no session)
  core::FeatureFlags::Flags* GetCurrentFeatureFlags() {
    size_t current_index = GetCurrentSessionIndex();
    if (session_coordinator_ &&
        current_index < session_coordinator_->GetTotalSessionCount()) {
      auto* session = static_cast<RomSession*>(
          session_coordinator_->GetSession(current_index));
      if (session) {
        return &session->feature_flags;
      }
    }
    return &core::FeatureFlags::get();  // Fallback to global
  }
 
  void SetFontGlobalScale(float scale) {
    user_settings_.prefs().font_global_scale = scale;
    ImGui::GetIO().FontGlobalScale = scale;
    auto status = user_settings_.Save();
    if (!status.ok()) {
      LOG_WARN("EditorManager", "Failed to save user settings: %s",
               status.ToString().c_str());
    }
  }
 
  UserSettings& user_settings() { return user_settings_; }
  const UserSettings& user_settings() const { return user_settings_; }
 
  // Workspace management (delegates to WorkspaceManager)
  void RefreshWorkspacePresets() { workspace_manager_.RefreshPresets(); }
  void SaveWorkspacePreset(const std::string& name) {
    workspace_manager_.SaveWorkspacePreset(name);
  }
  void LoadWorkspacePreset(const std::string& name) {
    workspace_manager_.LoadWorkspacePreset(name);
  }
 
  // Jump-to functionality for cross-editor navigation
  void SwitchToEditor(EditorType editor_type, bool force_visible = false,
                      bool from_dialog = false) override;
  void DismissEditorSelection() override;
 
  // Panel-based editor registry
  static bool IsPanelBasedEditor(EditorType type);
  bool IsSidebarVisible() const {
    return ui_coordinator_ ? ui_coordinator_->IsPanelSidebarVisible() : false;
  }
  void SetSidebarVisible(bool visible) {
    if (ui_coordinator_) {
      ui_coordinator_->SetPanelSidebarVisible(visible);
    }
  }
 
  // Lazy asset loading helpers
  absl::Status EnsureEditorAssetsLoaded(EditorType type);
  absl::Status EnsureGameDataLoaded();
 
  // Session management
  void CreateNewSession();
  void DuplicateCurrentSession();
  void CloseCurrentSession();
  void RemoveSession(size_t index);
  void SwitchToSession(size_t index);
  void RequestSwitchToSession(size_t index) override { SwitchToSession(index); }
  void RequestCloseSession(size_t index) override { RemoveSession(index); }
  size_t GetActiveSessionCount() const;
 
  // Workspace layout management
  // Window management - inline delegation (reduces EditorManager bloat)
  void SaveWorkspaceLayout() { workspace_manager_.SaveWorkspaceLayout(); }
  void LoadWorkspaceLayout() { workspace_manager_.LoadWorkspaceLayout(); }
  void ResetWorkspaceLayout();
  void ShowAllWindows() {
    if (ui_coordinator_)
      ui_coordinator_->ShowAllWindows();
  }
  void HideAllWindows() {
    if (ui_coordinator_)
      ui_coordinator_->HideAllWindows();
  }
 
  // Layout presets (inline delegation)
  void LoadDeveloperLayout() { window_delegate_.LoadDeveloperLayout(); }
  void LoadDesignerLayout() { window_delegate_.LoadDesignerLayout(); }
  void LoadModderLayout() { window_delegate_.LoadModderLayout(); }
 
  // Panel layout presets (command palette accessible)
  void ApplyLayoutPreset(const std::string& preset_name);
  bool ApplyLayoutProfile(const std::string& profile_id);
  void CaptureTemporaryLayoutSnapshot();
  void RestoreTemporaryLayoutSnapshot(bool clear_after_restore = false);
  void ClearTemporaryLayoutSnapshot();
 
  // Named, session-scoped layout snapshots (in-memory, multi-slot).
  bool SaveLayoutSnapshotAs(const std::string& name);
  bool RestoreLayoutSnapshot(const std::string& name,
                             bool remove_after_restore = false);
  bool DeleteLayoutSnapshot(const std::string& name);
  std::vector<std::string> ListLayoutSnapshots() const;
 
  void ResetCurrentEditorLayout();
 
  // Helper methods
  std::string GenerateUniqueEditorTitle(EditorType type,
                                        size_t session_index) const;
  bool HasDuplicateSession(const std::string& filepath);
  void RenameSession(size_t index, const std::string& new_name);
  void Quit();
 
  bool HasPendingUnsavedSessionAction() const;
  std::string GetPendingUnsavedSessionActionPrompt() const;
  std::string GetPendingUnsavedSessionActionSaveLabel() const;
  std::string GetPendingUnsavedSessionActionContinueLabel() const;
  void ConfirmPendingUnsavedSessionActionSaveAndContinue();
  void ConfirmPendingUnsavedSessionActionDiscardAndContinue();
  void CancelPendingUnsavedSessionAction();
 
  // Deferred action queue - actions executed safely on next frame
  // Use this to avoid modifying ImGui state during menu/popup rendering
  void QueueDeferredAction(std::function<void()> action) {
    deferred_actions_.push_back(std::move(action));
    pending_editor_deferred_actions_.fetch_add(1, std::memory_order_relaxed);
  }
 
  UiSyncState GetUiSyncStateSnapshot() const;
 
  // Public for SessionCoordinator to configure new sessions
  void ConfigureSession(RomSession* session) override;
 
#ifdef YAZE_WITH_GRPC
  void SetCanvasAutomationService(CanvasAutomationServiceImpl* service) {
    canvas_automation_service_ = service;
  }
#endif
 
  // UI visibility controls (public for MenuOrchestrator)
  // UI visibility controls - inline for performance (single-line wrappers
  // delegating to UICoordinator)
  void ShowImGuiDemo() {
    if (ui_coordinator_)
      ui_coordinator_->SetImGuiDemoVisible(true);
  }
  void ShowImGuiMetrics() {
    if (ui_coordinator_)
      ui_coordinator_->SetImGuiMetricsVisible(true);
  }
 
#ifdef YAZE_ENABLE_TESTING
  void ShowTestDashboard() { show_test_dashboard_ = true; }
#endif
 
#ifdef YAZE_BUILD_AGENT_UI
  void ShowAIAgent();
  void ShowChatHistory();
  AgentEditor* GetAgentEditor() { return agent_ui_.GetAgentEditor(); }
  AgentUiController* GetAgentUiController() { return &agent_ui_; }
#else
  AgentEditor* GetAgentEditor() { return nullptr; }
  AgentUiController* GetAgentUiController() { return nullptr; }
#endif
#ifdef YAZE_BUILD_AGENT_UI
  void ShowProposalDrawer() { proposal_drawer_.Show(); }
#endif
 
  // ROM and Project operations (public for MenuOrchestrator)
  absl::Status LoadRom();
  absl::Status SaveRom();
  absl::Status SaveRomAs(const std::string& filename);
  absl::Status ResumePendingRomSave();
  absl::Status OpenRomOrProject(const std::string& filename);
  absl::Status CreateNewProject(
      const std::string& template_name = "Basic ROM Hack");
  absl::Status CreateNewProjectFromRom(
      const std::string& template_name, const std::string& rom_path,
      const std::string& project_name,
      const std::string& project_path = std::string());
  absl::Status FinalizeNewProject(
      const std::string& project_name,
      const std::string& project_path = std::string());
  absl::Status OpenProject();
  absl::Status SaveProject();
  absl::Status SaveProjectAs();
  absl::Status SaveProjectAs(const std::string& filepath);
  absl::Status AutosaveActiveSession();
  absl::Status BuildCurrentProject();
  void QueueBuildCurrentProject();
  void CancelQueuedProjectBuild();
  absl::Status RunCurrentProject();
 
  bool HasPendingPotItemSaveConfirmation() const {
    return rom_lifecycle_.HasPendingPotItemSaveConfirmation();
  }
  int pending_pot_item_unloaded_rooms() const {
    return rom_lifecycle_.pending_pot_item_unloaded_rooms();
  }
  int pending_pot_item_total_rooms() const {
    return rom_lifecycle_.pending_pot_item_total_rooms();
  }
  void ResolvePotItemSaveConfirmation(PotItemSaveDecision decision);
  absl::Status ImportProject(const std::string& project_path);
  absl::Status RepairCurrentProject();
 
  // Project management
  absl::Status LoadProjectWithRom();
  absl::Status SwapProjectRom(const std::string& rom_path);
  absl::Status ReloadProjectRom();
  project::YazeProject* GetCurrentProject() { return &current_project_; }
  const project::YazeProject* GetCurrentProject() const {
    return &current_project_;
  }
  // True only for the session whose project is currently restored into
  // current_project_. SessionCoordinator also performs transient switches
  // while drawing inactive sessions, so its active session is not sufficient
  // for routing project mutations or saves.
  bool IsCurrentProjectContextOwnedBySession(size_t session_id) const {
    return active_project_context_session_id_.has_value() &&
           *active_project_context_session_id_ == session_id;
  }
  void MarkCurrentProjectDirty();
  bool IsCurrentProjectDirty() const;
  core::VersionManager* GetVersionManager() { return version_manager_; }
 
  // Show project management panel in right sidebar
  void ShowProjectManagement();
 
  // Show project file editor
  void ShowProjectFileEditor();
  ProjectFileEditor* project_file_editor() { return &project_file_editor_; }
  ProjectManagementPanel* project_management_panel() {
    return project_management_panel_.get();
  }
 
 private:
  absl::Status DrawRomSelector() = delete;  // Moved to UICoordinator
  // DrawContextSensitivePanelControl removed - card control moved to sidebar
 
  // Optional loading_handle for WASM progress tracking (0 = create new)
  absl::Status LoadAssets(uint64_t loading_handle = 0);
  absl::Status LoadAssetsForMode(uint64_t loading_handle = 0);
  absl::Status LoadAssetsLazy(uint64_t loading_handle = 0);
  absl::Status InitializeEditorForType(EditorType type, EditorSet* editor_set,
                                       Rom* rom);
  void ResetAssetState(RomSession* session);
  void MarkEditorInitialized(RomSession* session, EditorType type);
  void MarkEditorLoaded(RomSession* session, EditorType type);
  Editor* GetEditorByType(EditorType type, EditorSet* editor_set) const;
  Editor* ResolveEditorForCategory(const std::string& category);
  void SyncEditorContextForCategory(const std::string& category);
  bool EditorRequiresGameData(EditorType type) const;
  bool EditorInitRequiresGameData(EditorType type) const;
  std::vector<EditorType> CollectEditorsToPreload(EditorSet* editor_set) const;
 
  // Testing system
  void InitializeTestSuites();
  void ApplyStartupVisibilityOverrides();
  void ApplyLayoutDefaultsMigrationIfNeeded();
  // Returns a preferred startup category, skipping "Emulator" to prevent
  // the emulator panel from auto-opening on project load.
  std::string GetPreferredStartupCategory(
      const std::string& saved_category,
      const std::vector<std::string>& available_categories) const;
 
  // Session event handlers (EventBus subscribers)
  void HandleSessionSwitched(size_t new_index, RomSession* session,
                             bool transient = false);
  void HandleSessionCreated(size_t index, RomSession* session);
  void HandleSessionClosed(size_t index);
  // Initialization helpers (extracted from constructor for readability)
  void SubscribeToEvents();
  void InitializeSubsystems();
  void RegisterEditors();
  void RegisterEmulatorPanels();
  void InitializeServices();
  void SetupComponentCallbacks();
  void SetupDialogCallbacks();
  void SetupWelcomeScreenCallbacks();
  void SetupSidebarCallbacks();
  void InitializeShortcutSystem();
  void ProcessInput();
  void UpdateEditorState();
  void PollProjectWorkflowTasks();
  void DrawInterface();
  void DrawSecondaryWindows();
  void UpdateSystemUIs();
  void RunEmulator();
  void RefreshHackWorkflowBackend();
 
  void HandleSessionRomLoaded(size_t index, Rom* rom);
  void RefreshResourceLabelProvider();
 
  // UI action event handler (EventBus subscriber for UIActionRequestEvent)
  void HandleUIActionRequest(UIActionRequestEvent::Action action);
 
  bool quit_ = false;
 
  // Note: All show_* flags are being moved to UICoordinator
  // Access via ui_coordinator_->IsXxxVisible() or SetXxxVisible()
 
  // Workspace dialog flags (managed by EditorManager, not UI)
  bool show_workspace_layout = false;
  size_t session_to_rename_ = 0;
  char session_rename_buffer_[256] = {};
 
  // Note: Most UI visibility flags have been moved to UICoordinator
  // Access via ui_coordinator_->IsXxxVisible() or SetXxxVisible()
 
  // Agent proposal drawer
  ProposalDrawer proposal_drawer_;
  bool show_proposal_drawer_ = false;
 
  // Agent UI (chat + editor), no-op when agent UI is disabled
  AgentUiController agent_ui_;
 
  // Project file editor
  ProjectFileEditor project_file_editor_;
 
  // Note: Editor selection dialog and welcome screen are now managed by
  // UICoordinator Kept here for backward compatibility during transition
  std::unique_ptr<DashboardPanel> dashboard_panel_;
  WelcomeScreen welcome_screen_;
  RomLoadOptionsDialog rom_load_options_dialog_;
  bool show_rom_load_options_ = false;
  StartupVisibility welcome_mode_override_ = StartupVisibility::kAuto;
  StartupVisibility dashboard_mode_override_ = StartupVisibility::kAuto;
  StartupVisibility sidebar_mode_override_ = StartupVisibility::kAuto;
  AssetLoadMode asset_load_mode_ = AssetLoadMode::kFull;
  std::string startup_editor_hint_;
  std::vector<std::string> startup_panel_hints_;
 
  // Properties panel for selection editing
  SelectionPropertiesPanel selection_properties_panel_;
 
  // Project management panel for version control and ROM management
  std::unique_ptr<ProjectManagementPanel> project_management_panel_;
 
  std::string version_ = "";
  absl::Status status_;
  emu::Emulator emulator_;
 
 public:
 private:
  Editor* current_editor_ = nullptr;
  // Tracks which session is currently active so delegators (menus, popups,
  // shortcuts) stay in sync without relying on per-editor context.
 
  gfx::IRenderer* renderer_ = nullptr;
 
  project::YazeProject current_project_;
  struct PendingProjectRomSelection {
    std::string previous_path;
    std::string candidate_path;
  };
  std::optional<PendingProjectRomSelection> pending_project_rom_selection_;
  uint64_t project_rom_selection_generation_ = 0;
  bool pending_project_open_transition_ = false;
  std::optional<size_t> pending_project_open_previous_session_id_;
  // current_project_ is a stable-address working copy owned by the active
  // user-facing session. Stable IDs survive UI-index compaction.
  std::optional<size_t> active_project_context_session_id_;
  // The global FeatureFlags singleton is also rebound during transient frame
  // iteration, so track which session currently owns its value separately.
  std::optional<size_t> runtime_feature_flags_session_id_;
  // Non-owning view of the active session's VersionManager. Each RomSession
  // owns its manager so EditorSet dependency pointers remain valid while that
  // session is inactive.
  core::VersionManager* version_manager_ = nullptr;
  SharedClipboard shared_clipboard_;
  std::unique_ptr<PopupManager> popup_manager_;
  ToastManager toast_manager_;
  MenuBuilder menu_builder_;
  ShortcutManager shortcut_manager_;
  UserSettings user_settings_;
 
  // New delegated components (dependency injection architecture)
  WorkspaceWindowManager
      window_manager_;  // Window management with session awareness
  std::unique_ptr<WindowHost> window_host_;
  EditorRegistry editor_registry_;
  std::unique_ptr<MenuOrchestrator> menu_orchestrator_;
  ProjectManager project_manager_;
  RomFileManager rom_file_manager_;
  std::unique_ptr<UICoordinator> ui_coordinator_;
  WindowDelegate window_delegate_;
  EditorActivator editor_activator_;
  std::unique_ptr<SessionCoordinator> session_coordinator_;
  std::unique_ptr<LayoutManager>
      layout_manager_;                    // DockBuilder layout management
  LayoutCoordinator layout_coordinator_;  // Facade for layout operations
  std::unique_ptr<RightDrawerManager>
      right_drawer_manager_;  // Right-side drawer system
  StatusBar status_bar_;      // Bottom status bar
  std::unique_ptr<ActivityBar> activity_bar_;
  WorkspaceManager workspace_manager_{&toast_manager_};
 
  emu::input::InputConfig BuildInputConfigFromSettings() const;
  void PersistInputConfig(const emu::input::InputConfig& config);
  void UpdateCurrentRomHash();
  void ApplyDefaultBackupPolicy();
  void CaptureRuntimeFeatureFlags();
  void CaptureActiveProjectEditingState();
  void CaptureActiveProjectContext();
  absl::Status PrepareActiveProjectEditorDraftsForSave();
  void DetachActiveProjectContext();
  void BindProjectContextToSession(RomSession* session,
                                   const project::YazeProject& project);
  bool RestoreProjectContextForSession(RomSession* session);
  void RestoreProjectEditingStateForSession(RomSession* session);
  absl::Status SaveActiveProjectEditingWork();
  absl::Status PrepareRawProjectFileSave(const std::string& filepath,
                                         const std::string& contents);
  absl::Status CommitRawProjectFileSave(const std::string& filepath,
                                        const std::string& contents);
  absl::Status ReplaceActiveSessionRom(Rom&& rom, const std::string& filepath);
  bool ProjectFileDraftTargetsCurrentProject() const;
  void RebaseCleanProjectFileDraft(const std::string& filepath);
  void RestoreProjectContextAfterFailedOpen(
      std::optional<size_t> previous_session_id);
  absl::Status DiscardProvisionalSessionCreatedSince(
      size_t previous_session_count);
  void ApplyCurrentProjectRuntimeContext();
  absl::StatusOr<const project::YazeProject*>
  PrepareActiveProjectContextForSave();
  ProjectWorkflowStatus MakeBuildStatus(const std::string& summary,
                                        const std::string& detail,
                                        ProjectWorkflowState state,
                                        const std::string& output_tail = "",
                                        bool can_cancel = false) const;
  ProjectWorkflowStatus MakeRunStatus(const std::string& summary,
                                      const std::string& detail,
                                      ProjectWorkflowState state) const;
  absl::StatusOr<std::string> RunProjectBuildCommand();
  absl::StatusOr<std::string> ResolveProjectBuildCommand() const;
  absl::StatusOr<std::string> ResolveProjectRunTarget() const;
  absl::Status CheckRomWritePolicy(
      const std::optional<std::string>& target_filename = std::nullopt);
  absl::Status CheckOracleRomSafetyPreSave(Rom* rom);
  absl::Status SaveRomInternal(
      const std::optional<std::string>& save_as_filename);
  bool HasPendingRomSaveConfirmation() const;
  bool PendingRomSaveMatchesActiveSession() const;
  void FinishPendingRomSaveAttempt(const absl::Status& status);
  void CancelPendingRomSave(bool hide_popups = false);
  absl::Status StartPendingRomSave(
      const std::optional<std::string>& save_as_filename);
  absl::Status LoadRomInternal();
  absl::Status OpenRomOrProjectInternal(const std::string& filename);
  absl::Status OpenProjectInternal();
  absl::Status ValidateProjectRomSelection(const std::string& rom_path);
 
  struct PendingUnsavedSessionAction {
    enum class Type {
      kOpenRomDialog,
      kOpenRomOrProjectPath,
      kOpenProjectDialog,
      kSwitchSession,
      kCloseSession,
      kQuit,
    };
 
    Type type = Type::kOpenRomDialog;
    size_t source_session_id = SIZE_MAX;
    size_t target_session_id = SIZE_MAX;
    std::string path;
  };
 
  std::optional<size_t> ResolveSessionIndexById(size_t session_id) const;
  bool MaybeGuardPendingSessionAction(PendingUnsavedSessionAction action);
  void ExecutePendingUnsavedSessionAction(
      const PendingUnsavedSessionAction& action);
  bool SessionHasPendingUnsavedWork(size_t session_index) const;
  bool SessionHasPendingRomWork(size_t session_index) const;
  bool HasAnySessionPendingUnsavedWork() const;
  bool HasPendingDungeonChangesForSession(size_t session_index) const;
  int PendingDungeonRoomCountForSession(size_t session_index) const;
  size_t PendingPaletteColorCountForSession(size_t session_index) const;
  int ModifiedSessionCount() const;
  std::string DescribePendingUnsavedWork(size_t session_index) const;
  std::string DescribeAllPendingUnsavedWork() const;
 
  float autosave_timer_ = 0.0f;
  bool settings_dirty_ = false;
  float settings_dirty_timestamp_ = 0.0f;
  bool pending_layout_defaults_reset_ = false;
  std::optional<PendingUnsavedSessionAction> pending_unsaved_session_action_;
 
  // ROM lifecycle state (hash, write policy, confirmation dialogs, backups)
  // Mutable because some const accessors delegate to it.
  mutable RomLifecycleManager rom_lifecycle_;
  struct PendingRomSave {
    std::optional<std::string> save_as_filename;
    size_t session_index = SIZE_MAX;
    Rom* rom = nullptr;
  };
  std::optional<PendingRomSave> pending_rom_save_;
 
  // Deferred action queue - executed at the start of each frame
  std::vector<std::function<void()>> deferred_actions_;
  std::atomic<int> pending_editor_deferred_actions_{0};
  std::atomic<uint64_t> ui_sync_frame_id_{0};
  std::unique_ptr<BackgroundCommandTask> active_project_build_;
  bool active_project_build_reported_ = false;
 
  // Core Event Bus and Context
  EventBus event_bus_;
  std::unique_ptr<GlobalEditorContext> editor_context_;
  std::unique_ptr<workflow::HackWorkflowBackend> hack_workflow_backend_;
 
#ifdef YAZE_WITH_GRPC
  CanvasAutomationServiceImpl* canvas_automation_service_ = nullptr;
#endif
 
  // RAII helper for clean session context switching
  class SessionScope {
   public:
    SessionScope(EditorManager* manager, size_t session_index);
    ~SessionScope();
 
   private:
    EditorManager* manager_;
    Rom* prev_rom_;
    EditorSet* prev_editor_set_;
    size_t prev_session_index_;
  };
 
  void ConfigureEditorDependencies(EditorSet* editor_set, Rom* rom,
                                   size_t session_id);
  void SyncLayoutScopeFromCurrentProject();
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_EDITOR_MANAGER_H