user_settings.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SYSTEM_USER_SETTINGS_H_
#define YAZE_APP_EDITOR_SYSTEM_USER_SETTINGS_H_
 
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "absl/status/status.h"
 
namespace yaze {
namespace editor {
 
class UserSettings {
 public:
  struct Preferences {
    struct AiHost {
      std::string id;
      std::string label;
      std::string base_url;
      std::string api_type;  // openai, ollama, gemini, lmstudio, grpc
      bool supports_vision = false;
      bool supports_tools = true;
      bool supports_streaming = true;
      bool allow_insecure = false;
      std::string api_key;  // Optional plaintext key (desktop/non-keychain)
      std::string
          credential_id;  // Keychain reference (never store secrets here)
    };
 
    struct AiModelProfile {
      std::string name;
      std::string model;
      float temperature = 0.25f;
      float top_p = 0.95f;
      int max_output_tokens = 2048;
      bool supports_vision = false;
      bool supports_tools = true;
    };
 
    // General
    float font_global_scale = 1.0f;
    bool backup_rom = false;
    bool save_new_auto = true;
    bool autosave_enabled = true;
    float autosave_interval = 300.0f;
    int recent_files_limit = 10;
    std::string last_rom_path;
    std::string last_project_path;
    bool show_welcome_on_startup = true;
    // Test mode: launch without the welcome screen or editor picker and start
    // the local test server (gRPC builds), so an agent that can only
    // double-click the app gets a quiet, scriptable start. Next launch.
    bool test_mode = false;
    bool restore_last_session = true;
    bool prefer_hmagic_sprite_names = true;
 
    // One-shot feature tips (FeatureHintManager). Dismissed ids persist so
    // ZScream/HM migrant tips do not re-fire after the user has seen them.
    bool feature_hints_enabled = true;
    std::unordered_set<std::string> dismissed_feature_hints;
 
    // Welcome screen animation preferences. Match the defaults hard-coded in
    // WelcomeScreen so first-run behavior is unchanged.
    float welcome_triforce_alpha = 1.0f;
    float welcome_triforce_speed = 0.3f;
    float welcome_triforce_size = 1.0f;
    bool welcome_particles_enabled = true;
    bool welcome_mouse_repel_enabled = true;
 
    // Accessibility / interaction
    bool reduced_motion = false;
    int switch_motion_profile = 1;  // 0=Snappy, 1=Standard, 2=Relaxed
 
    // Theme (last applied theme persists across restart; empty = default)
    std::string last_theme_name;
 
    // UI language (locale code, e.g. "en"/"fr"; matches assets/i18n/<code>.json)
    std::string language_locale = "en";
 
    // Font (index into ImGui::GetIO().Fonts->Fonts, typically 0..4)
    int font_family_index = 0;
 
    // Editor Behavior
    bool backup_before_save = true;
    // 0=None, 1=Overworld, 2=Dungeon, 3=Graphics, 4=Messages (append only)
    int default_editor = 0;
 
    // Performance
    bool vsync = true;
    int target_fps = 60;
    int cache_size_mb = 512;
    int undo_history_size = 50;
 
    // AI Agent
    int ai_provider =
        0;  // Legacy default provider (0=Ollama, 1=Gemini, 2=Mock)
    std::string ai_model;
    std::string ollama_url = "http://localhost:11434";
    std::string gemini_api_key;
    std::string openai_api_key;
    std::string anthropic_api_key;
    float ai_temperature = 0.7f;
    int ai_max_tokens = 2048;
    bool ai_proactive = true;
    bool ai_auto_learn = true;
    bool ai_multimodal = true;
    std::vector<AiHost> ai_hosts;
    std::string active_ai_host_id;
    std::vector<AiModelProfile> ai_profiles;
    std::string active_ai_profile;
    std::string remote_build_host_id;
    std::vector<std::string> ai_model_paths;
 
    // CLI Logging
    int log_level = 1;  // 0=Debug, 1=Info, 2=Warning, 3=Error, 4=Fatal
    bool log_to_file = false;
    std::string log_file_path;
    bool log_ai_requests = true;
    bool log_rom_operations = true;
    bool log_gui_automation = true;
    bool log_proposals = true;
 
    // Filesystem (iOS + remote workflows)
    std::vector<std::string> project_root_paths;
    std::string default_project_root;
    bool use_files_app = true;
    bool use_icloud_sync = true;
 
    // Shortcut Overrides
    // Maps panel_id -> shortcut string (e.g., "dungeon.room_selector" -> "Ctrl+Shift+R")
    std::unordered_map<std::string, std::string> panel_shortcuts;
    // Maps global action id -> shortcut string (e.g., "Open", "Save")
    std::unordered_map<std::string, std::string> global_shortcuts;
    // Maps editor-scoped action id -> shortcut string (keyed by editor namespace)
    std::unordered_map<std::string, std::string> editor_shortcuts;
 
    // Sidebar State
    bool sidebar_visible = true;  // Controls Activity Bar visibility
    bool sidebar_panel_expanded =
        false;  // WindowSidebar; ActivityBar-only default
    float sidebar_panel_width = 0.0f;  // 0 = responsive default
    float panel_browser_category_width = 260.0f;
    int panel_layout_defaults_revision = 0;
    std::string sidebar_active_category;  // Last active category
 
    // Sidebar customization (Phase 4): user-controlled category order,
    // hidden set (filtered out of the rail), and pinned set (pinned-first).
    std::vector<std::string> sidebar_order;
    std::unordered_set<std::string> sidebar_hidden;
    std::unordered_set<std::string> sidebar_pinned;
    std::unordered_set<std::string> sidebar_context_collapsed;
 
    // Status Bar
    bool show_status_bar =
        false;  // Show status bar at bottom (disabled by default)
 
    // Emulator: keep ticking/audio when emulator panels are hidden.
    // Default off — switching editors pauses the SNES.
    bool emulator_keep_running_in_background = false;
 
    // Legacy persisted name. This acknowledges experimental warnings and lets
    // supported writers use their normal posture; it never hides an editor or
    // bypasses a feature-specific write guard.
    bool show_experimental_editors = false;
 
    // Dungeon workbench layout: which side of the workbench window the
    // inspector pane occupies. "left" (default) places object/entrance tools
    // above the room matrix on the right; "right" mirrors that arrangement.
    // Read by dungeon_workbench_content at draw time. Persisted as a string so
    // a future "top" / "bottom" / "floating" extension does not require a
    // migration of existing settings files.
    std::string dungeon_inspector_side = "left";
 
    // Panel Visibility State (per editor type)
    // Maps editor_type_name -> (panel_id -> visible)
    // e.g., "Overworld" -> {"overworld.tile16_selector" -> true, ...}
    std::unordered_map<std::string, std::unordered_map<std::string, bool>>
        panel_visibility_state;
 
    // Pinned panels (persists across sessions)
    // Maps panel_id -> pinned
    std::unordered_map<std::string, bool> pinned_panels;
    std::unordered_map<std::string, float> right_panel_widths;
 
    // Named layouts (user-saved workspace configurations)
    // Maps layout_name -> (panel_id -> visible)
    std::unordered_map<std::string, std::unordered_map<std::string, bool>>
        saved_layouts;
 
    // Named DockTree layouts authored in the Layout Designer.
    // Maps layout_name -> JSON-serialized DockTree (schema v1).
    // Kept as opaque strings so UserSettings does not have to understand
    // DockTree internals; the designer parses/re-serializes via
    // layout_designer::DockTreeFromJson / DockTreeToJson.
    std::unordered_map<std::string, std::string> named_layouts;
 
    // Name of the last DockTree layout applied to the live dockspace.
    // Empty string => nothing to auto-apply on startup. Mirrors the
    // `last_theme_name` persistence pattern.
    std::string last_applied_layout_name;
 
    // Remembered ROM load options. Maps a RomLoadOptionsDialog::RomChoiceKey
    // path -> that dialog's opaque encoding. A key that decodes and matches
    // the ROM's ZSCustomOverworld byte skips the load options dialog.
    std::unordered_map<std::string, std::string> rom_load_choices;
  };
 
  UserSettings();
 
  absl::Status Load();
  absl::Status Save();
 
  // Applies one-time layout-default migrations when target_revision is newer
  // than persisted settings. Returns true when preferences changed; callers
  // must not assume every revision requires rebuilding the whole workspace.
  bool ApplyPanelLayoutDefaultsRevision(int target_revision);
 
  static constexpr int kLatestPanelLayoutDefaultsRevision = 30;
  // Revisions through 21, and 27, changed whole-workspace arrangements.
  // Revision 27 rebuilds once so the overworld map keeps its height: Tile16
  // and area graphics share the right column, and nothing starts on the bottom.
  // Revisions 22-26 and 28-30 are targeted preference migrations.
  static constexpr int kLastWorkspaceResetPanelLayoutDefaultsRevision = 27;
 
  Preferences& prefs() { return prefs_; }
  const Preferences& prefs() const { return prefs_; }
 
  // Project workspace values for font scale, autosave, and backup-on-save.
  // While an overlay is active these values are live in prefs(), but Save()
  // keeps writing the user's own values, so opening a project never rewrites
  // the global defaults. Edits made during an overlay belong to the project;
  // ClearWorkspaceOverrides() restores the user's values.
  struct WorkspaceOverrides {
    float font_global_scale = 1.0f;
    bool autosave_enabled = true;
    float autosave_interval = 300.0f;
    bool backup_before_save = true;
  };
  void ApplyWorkspaceOverrides(const WorkspaceOverrides& overrides);
  void ClearWorkspaceOverrides();
  bool HasWorkspaceOverrides() const { return workspace_baseline_.has_value(); }
 
  // Dungeon workbench inspector placement. Returns the persisted value
  // verbatim ("right" / "left"), defaulting to "right" if the value is empty
  // or unrecognized so callers can switch on it without a null check.
  std::string GetDungeonInspectorSide() const;
  // Sets the inspector placement. Accepts "right" or "left"; any other value
  // is normalized to "right". Caller must invoke Save() to persist.
  void SetDungeonInspectorSide(std::string side);
 
  // Testing hook: redirect JSON plus legacy INI Load/Save to caller-owned
  // paths. Production code should never call this; it only exists so unit
  // tests can exercise settings migration without touching the user's files.
  void SetSettingsFilePathForTesting(std::string path) {
    settings_file_path_ = std::move(path);
    legacy_settings_file_path_ = settings_file_path_ + ".legacy.ini";
  }
  const std::string& settings_file_path() const { return settings_file_path_; }
  const std::string& legacy_settings_file_path() const {
    return legacy_settings_file_path_;
  }
 
 private:
  Preferences prefs_;
  // The user's own values for the WorkspaceOverrides fields while a project
  // overlay is active; empty when prefs() holds only the user's values.
  std::optional<WorkspaceOverrides> workspace_baseline_;
  std::string settings_file_path_;
  std::string legacy_settings_file_path_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_SYSTEM_USER_SETTINGS_H_