session_coordinator.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SYSTEM_SESSION_COORDINATOR_H_
#define YAZE_APP_EDITOR_SYSTEM_SESSION_COORDINATOR_H_
 
#include <deque>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/core/event_bus.h"
#include "app/editor/session_types.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
 
// Forward declarations
namespace yaze {
class Rom;
namespace editor {
class ISessionConfigurator;
class EditorRegistry;
class EditorSet;
class WorkspaceWindowManager;
}  // namespace editor
}  // namespace yaze
 
namespace yaze {
namespace editor {
 
// Forward declarations
class EditorSet;
class ToastManager;
 
class SessionCoordinator {
 public:
  explicit SessionCoordinator(WorkspaceWindowManager* window_manager,
                              ToastManager* toast_manager,
                              UserSettings* user_settings);
  ~SessionCoordinator();
 
  void SetEditorManager(ISessionConfigurator* manager) {
    editor_manager_ = manager;
  }
  void SetBeforeSessionTransition(std::function<absl::Status()> callback) {
    before_session_transition_ = std::move(callback);
  }
  void SetEditorRegistry(EditorRegistry* registry) {
    editor_registry_ = registry;
  }
 
  void SetEventBus(EventBus* bus) { event_bus_ = bus; }
 
  // Session lifecycle management
  void CreateNewSession();
  void DuplicateCurrentSession();
  void RequestCloseCurrentSession();
  void CloseCurrentSession();
  void CloseSession(size_t index);
  // Closes `index` even when it is the only session, leaving the app with no
  // ROM session (the welcome surface takes over). Used by File > Close ROM.
  // Unsaved-work confirmation is the caller's responsibility.
  void CloseSessionAllowingEmpty(size_t index);
  void RemoveSession(size_t index);
  void SwitchToSession(size_t index);
  void UpdateSessions();
 
  // Session activation and queries
  void ActivateSession(size_t index);
  size_t GetActiveSessionIndex() const;
  size_t GetActiveSessionId() const;
  size_t GetSessionId(size_t index) const;
  void* GetActiveSession() const;
  RomSession* GetActiveRomSession() const;
  Rom* GetCurrentRom() const;
  zelda3::GameData* GetCurrentGameData() const;
  EditorSet* GetCurrentEditorSet() const;
  void* GetSession(size_t index) const;
  bool HasMultipleSessions() const;
  size_t GetActiveSessionCount() const;
  absl::Status CheckBackingFileAvailable(
      const std::string& filepath,
      std::optional<size_t> excluded_session_id = std::nullopt) const;
  static bool PathsReferToSameBackingFile(const std::string& lhs,
                                          const std::string& rhs);
  bool HasDuplicateSession(const std::string& filepath) const;
 
  // Session UI components
  void DrawSessionSwitcher();
  void DrawSessionManager();
  void DrawSessionRenameDialog();
  void DrawSessionTabs();
  void DrawSessionIndicator();
 
  // Session information
  std::string GetSessionDisplayName(size_t index) const;
  std::string GetActiveSessionDisplayName() const;
  void RenameSession(size_t index, const std::string& new_name);
  std::string GenerateUniqueEditorTitle(const std::string& editor_name,
                                        size_t session_index) const;
 
  // Session state management
  void SetActiveSessionIndex(size_t index);
  void UpdateSessionCount();
 
  // Panel coordination across sessions
  void ShowAllPanelsInActiveSession();
  void HideAllPanelsInActiveSession();
  void ShowPanelsInCategory(const std::string& category);
  void HidePanelsInCategory(const std::string& category);
 
  // Session validation
  bool IsValidSessionIndex(size_t index) const;
  bool IsSessionActive(size_t index) const;
  bool IsSessionLoaded(size_t index) const;
 
  // Session statistics
  size_t GetTotalSessionCount() const;
  size_t GetLoadedSessionCount() const;
  size_t GetEmptySessionCount() const;
 
  // Session operations with error handling
  absl::Status LoadRomIntoSession(const std::string& filename,
                                  size_t session_index = SIZE_MAX);
  absl::Status SaveActiveSession(const std::string& filename = "");
  absl::Status SaveSessionAs(size_t session_index, const std::string& filename);
  absl::StatusOr<RomSession*> CreateSessionFromRom(Rom&& rom,
                                                   const std::string& filepath);
  // Remove a just-created session after a failed open transaction. Unlike the
  // user-facing close flow, this may return the coordinator to zero sessions.
  absl::Status DiscardProvisionalSession(size_t session_id);
 
  // Session cleanup
  void CleanupClosedSessions();
  void ClearAllSessions();
 
  // Session navigation
  void FocusNextSession();
  void FocusPreviousSession();
  void FocusFirstSession();
  void FocusLastSession();
 
  // Session UI state
  void ShowSessionSwitcher() { show_session_switcher_ = true; }
  void HideSessionSwitcher() { show_session_switcher_ = false; }
  void ToggleSessionSwitcher() {
    show_session_switcher_ = !show_session_switcher_;
  }
  bool IsSessionSwitcherVisible() const { return show_session_switcher_; }
 
  void ShowSessionManager() { show_session_manager_ = true; }
  void HideSessionManager() { show_session_manager_ = false; }
  void ToggleSessionManager() {
    show_session_manager_ = !show_session_manager_;
  }
  bool IsSessionManagerVisible() const { return show_session_manager_; }
 
  // Helper methods
  void UpdateActiveSession();
  void ValidateSessionIndex(size_t index) const;
  std::string GenerateUniqueSessionName(const std::string& base_name) const;
  void ShowSessionLimitWarning();
  void ShowSessionOperationResult(const std::string& operation, bool success);
 
  // UI helper methods
  void DrawSessionTab(size_t index, bool is_active);
  void DrawSessionContextMenu(size_t index);
  void DrawSessionBadge(size_t index);
  ImVec4 GetSessionColor(size_t index) const;
  std::string GetSessionIcon(size_t index) const;
 
  // Session validation helpers
  bool IsSessionEmpty(size_t index) const;
  bool IsSessionClosed(size_t index) const;
  bool IsSessionModified(size_t index) const;
 
 private:
  void ActivateCreatedSession(size_t index);
  void SwitchToSessionInternal(size_t index, bool transient);
  absl::Status PrepareActiveSessionTransition();
  void ApplySessionActivation(size_t index, bool transient);
  void CloseSessionInternal(size_t index, bool allow_closing_last);
  void NotifySessionSwitched(size_t old_index, size_t new_index,
                             RomSession* session, bool transient);
  void NotifySessionCreated(size_t index, RomSession* session);
  void NotifySessionClosed(size_t index);
  void NotifySessionRomLoaded(size_t index, RomSession* session);
 
  // Core dependencies
  ISessionConfigurator* editor_manager_ = nullptr;
  EditorRegistry* editor_registry_ = nullptr;
  EventBus* event_bus_ = nullptr;  // For publishing session lifecycle events
  std::vector<std::unique_ptr<RomSession>> sessions_;
  WorkspaceWindowManager* window_manager_;
  ToastManager* toast_manager_;
  UserSettings* user_settings_;
 
  // Session state
  size_t active_session_index_ = 0;
  size_t session_count_ = 0;
  size_t next_session_id_ = 0;
 
  // UI state
  bool show_session_switcher_ = false;
  bool show_session_manager_ = false;
  bool show_session_rename_dialog_ = false;
  size_t session_to_rename_ = 0;
  char session_rename_buffer_[256] = {};
 
  // Session limits
  static constexpr size_t kMaxSessions = 8;
  static constexpr size_t kMinSessions = 1;
  std::function<absl::Status()> before_session_transition_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_SYSTEM_SESSION_COORDINATOR_H_