settings_panel.cc

Go to the documentation of this file.

#include "app/editor/shell/windows/settings_panel.h"
 
#include "app/gui/automation/widget_id_registry.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <cstring>
#include <filesystem>
#include <set>
#include <vector>
 
#include "absl/strings/ascii.h"
#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "app/editor/layout/layout_designer/dock_tree.h"
#include "app/editor/layout/layout_designer/dock_tree_json.h"
#include "app/editor/layout/layout_manager.h"
#include "app/editor/registry/content_registry.h"
#include "app/editor/system/commands/shortcut_manager.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "app/gui/animation/animator.h"
#include "app/gui/app/feature_flags_menu.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/style.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/core/ui_config.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/font_picker.h"
#include "app/gui/widgets/property_inspector.h"
#include "app/gui/widgets/themed_widgets.h"
#include "app/platform/font_loader.h"
#include "cli/service/ai/provider_ids.h"
#include "core/patch/asm_patch.h"
#include "core/patch/patch_manager.h"
#include "imgui/imgui.h"
#include "imgui/misc/cpp/imgui_stdlib.h"
#include "nlohmann/json.hpp"
#include "rom/rom.h"
#include "util/file_util.h"
#include "util/log.h"
#include "util/platform_paths.h"
#include "util/rom_hash.h"
#include "zelda3/sprite/sprite.h"
 
namespace yaze {
namespace editor {
 
void SettingsPanel::SetDependencies(const EditorDependencies& deps) {
  Editor::SetDependencies(deps);
  SetRom(deps.rom);
  SetUserSettings(deps.user_settings);
  SetWindowManager(deps.window_manager);
  SetShortcutManager(deps.shortcut_manager);
  SetProject(deps.project);
  SetStatusBar(deps.status_bar);
}
 
namespace {
 
std::string FormatHexList(const std::vector<uint16_t>& values) {
  std::string result;
  result.reserve(values.size() * 6);
  for (size_t i = 0; i < values.size(); ++i) {
    const uint16_t value = values[i];
    std::string token = value <= 0xFF ? absl::StrFormat("0x%02X", value)
                                      : absl::StrFormat("0x%04X", value);
    if (!result.empty()) {
      result.append(", ");
    }
    result.append(token);
  }
  return result;
}
 
std::vector<uint16_t> DefaultTrackTiles() {
  std::vector<uint16_t> values;
  for (uint16_t tile = 0xB0; tile <= 0xBE; ++tile) {
    values.push_back(tile);
  }
  return values;
}
 
std::vector<uint16_t> DefaultStopTiles() {
  return {0xB7, 0xB8, 0xB9, 0xBA};
}
 
std::vector<uint16_t> DefaultSwitchTiles() {
  return {0xD0, 0xD1, 0xD2, 0xD3};
}
 
std::vector<uint16_t> DefaultTrackObjectIds() {
  return {0x31};
}
 
std::vector<uint16_t> DefaultMinecartSpriteIds() {
  return {0xA3};
}
 
bool IsLocalEndpoint(const std::string& base_url) {
  if (base_url.empty()) {
    return false;
  }
  std::string lower = absl::AsciiStrToLower(base_url);
  return absl::StrContains(lower, "localhost") ||
         absl::StrContains(lower, "127.0.0.1") ||
         absl::StrContains(lower, "::1") ||
         absl::StrContains(lower, "0.0.0.0") ||
         absl::StrContains(lower, "192.168.") || absl::StartsWith(lower, "10.");
}
 
bool IsTailscaleEndpoint(const std::string& base_url) {
  if (base_url.empty()) {
    return false;
  }
  std::string lower = absl::AsciiStrToLower(base_url);
  return absl::StrContains(lower, ".ts.net") ||
         absl::StrContains(lower, "100.64.");
}
 
std::string BuildHostTagString(const UserSettings::Preferences::AiHost& host) {
  std::vector<std::string> tags;
  if (IsLocalEndpoint(host.base_url)) {
    tags.push_back("local");
  }
  if (IsTailscaleEndpoint(host.base_url)) {
    tags.push_back("tailscale");
  }
  if (absl::StartsWith(absl::AsciiStrToLower(host.base_url), "https://")) {
    tags.push_back("https");
  } else if (absl::StartsWith(absl::AsciiStrToLower(host.base_url),
                              "http://") &&
             !IsLocalEndpoint(host.base_url) &&
             !IsTailscaleEndpoint(host.base_url)) {
    tags.push_back("http");
  }
  if (host.supports_vision) {
    tags.push_back("vision");
  }
  if (host.supports_tools) {
    tags.push_back("tools");
  }
  if (host.supports_streaming) {
    tags.push_back("stream");
  }
  if (tags.empty()) {
    return "";
  }
  std::string result = "[";
  for (size_t i = 0; i < tags.size(); ++i) {
    result += tags[i];
    if (i + 1 < tags.size()) {
      result += ", ";
    }
  }
  result += "]";
  return result;
}
 
// Expands a leading '~' or '~/' to the user's home directory so paths entered
// by the user (or copied from other platforms) resolve on Linux/Windows.
std::string ExpandLeadingTilde(const std::string& path) {
  if (path.empty() || path.front() != '~') {
    return path;
  }
  const auto home_dir = util::PlatformPaths::GetHomeDirectory();
  if (home_dir.empty() || home_dir == ".") {
    return path;
  }
  if (path.size() == 1) {
    return home_dir.string();
  }
  if (path[1] == '/' || path[1] == '\\') {
    return (home_dir / path.substr(2)).string();
  }
  return (home_dir / path.substr(1)).string();
}
 
bool AddUniquePath(std::vector<std::string>* paths, const std::string& path) {
  if (!paths || path.empty()) {
    return false;
  }
  const std::string expanded = ExpandLeadingTilde(path);
  auto it = std::find(paths->begin(), paths->end(), expanded);
  if (it != paths->end()) {
    return false;
  }
  paths->push_back(expanded);
  return true;
}
 
constexpr std::array<SettingsPanel::CategoryDescriptor, 10>
    kSettingsCategories = {{
        {"appearance", "Appearance", ICON_MD_PALETTE,
         SettingsPanel::Scope::kApplication,
         "theme font scale density motion colors"},
        {"behavior", "Editor Behavior", ICON_MD_TUNE,
         SettingsPanel::Scope::kApplication,
         "autosave backup tips editor defaults"},
        {"performance", "Performance", ICON_MD_SPEED,
         SettingsPanel::Scope::kApplication,
         "vsync fps cache undo performance"},
        {"files", "Files & Sync", ICON_MD_STORAGE,
         SettingsPanel::Scope::kApplication,
         "folders roots filesystem icloud sync"},
        {"ai", "AI Agent", ICON_MD_SMART_TOY,
         SettingsPanel::Scope::kApplication,
         "agent provider model host ollama gemini openai"},
        {"shortcuts", "Keyboard Shortcuts", ICON_MD_KEYBOARD,
         SettingsPanel::Scope::kApplication, "keys bindings commands panels"},
        {"layout", "Workspace Layout", ICON_MD_DASHBOARD_CUSTOMIZE,
         SettingsPanel::Scope::kWorkspace,
         "layout dock windows named workspace"},
        {"project", "Project Configuration", ICON_MD_FOLDER,
         SettingsPanel::Scope::kProject,
         "project rom identity paths build manifest"},
        {"features", "Feature Flags", ICON_MD_FLAG,
         SettingsPanel::Scope::kProject,
         "experimental system overworld dungeon resources save flags"},
        {"patches", "ASM Patches", ICON_MD_EXTENSION,
         SettingsPanel::Scope::kProject, "asar asm patches parameters"},
    }};
 
const char* ScopeLabel(SettingsPanel::Scope scope) {
  switch (scope) {
    case SettingsPanel::Scope::kApplication:
      return "Application";
    case SettingsPanel::Scope::kWorkspace:
      return "Workspace";
    case SettingsPanel::Scope::kProject:
      return "Project";
  }
  return "Application";
}
 
}  // namespace
 
std::vector<SettingsPanel::CategoryDescriptor> SettingsPanel::FilterCategories(
    Scope scope, const std::string& query) {
  const std::string needle = absl::AsciiStrToLower(query);
  std::vector<CategoryDescriptor> result;
  for (const CategoryDescriptor& category : kSettingsCategories) {
    if (category.scope != scope) {
      continue;
    }
    if (!needle.empty()) {
      const std::string haystack = absl::AsciiStrToLower(absl::StrFormat(
          "%s %s %s", category.id, category.label, category.keywords));
      if (haystack.find(needle) == std::string::npos) {
        continue;
      }
    }
    result.push_back(category);
  }
  return result;
}
 
SettingsPanel::DungeonOverlaySummary SettingsPanel::BuildDungeonOverlaySummary(
    const project::DungeonOverlaySettings& overlay) {
  const auto summarize = [](const std::vector<uint16_t>& configured,
                            const std::vector<uint16_t>& standard) {
    const bool uses_standard_values =
        configured.empty() || configured == standard;
    return std::pair<std::string, bool>(
        FormatHexList(configured.empty() ? standard : configured),
        uses_standard_values);
  };
 
  return {summarize(overlay.track_tiles, DefaultTrackTiles()),
          summarize(overlay.track_stop_tiles, DefaultStopTiles()),
          summarize(overlay.track_switch_tiles, DefaultSwitchTiles()),
          summarize(overlay.track_object_ids, DefaultTrackObjectIds()),
          summarize(overlay.minecart_sprite_ids, DefaultMinecartSpriteIds())};
}
 
absl::Status SettingsPanel::RequestOpenMinecartTracks() {
  if (!open_minecart_tracks_callback_) {
    project_status_message_ = "Minecart Tracks navigation is unavailable.";
    return absl::FailedPreconditionError(project_status_message_);
  }
 
  const absl::Status status = open_minecart_tracks_callback_();
  if (!status.ok()) {
    project_status_message_ = std::string(status.message());
    return status;
  }
 
  project_status_message_.clear();
  return absl::OkStatus();
}
 
void SettingsPanel::Draw() {
  if (project_provider_) {
    project_ = project_provider_();
  }
  if (!user_settings_) {
    ImGui::TextDisabled(tr("Settings not available"));
    return;
  }
 
  DrawScopeTabs();
  ImGui::SetNextItemWidth(-1.0f);
  ImGui::InputTextWithHint("##SettingsSearch",
                           ICON_MD_SEARCH " Search settings",
                           settings_search_.data(), settings_search_.size());
  gui::WidgetIdRegistry::Instance().RegisterWidget("Settings/input:Search",
                                                   "input", ImGui::GetItemID());
 
  const auto categories =
      FilterCategories(active_scope_, settings_search_.data());
  EnsureActiveCategory(categories);
  if (categories.empty()) {
    ImGui::Spacing();
    ImGui::TextDisabled(tr("No %s settings match \"%s\"."),
                        ScopeLabel(active_scope_), settings_search_.data());
    return;
  }
 
  ImGui::Spacing();
  const bool wide_layout =
      ImGui::GetContentRegionAvail().x >= gui::ScaledSize(520.0f, 0.0f).x;
  if (wide_layout && ImGui::BeginTable("##SettingsLayout", 2,
                                       ImGuiTableFlags_Resizable |
                                           ImGuiTableFlags_BordersInnerV |
                                           ImGuiTableFlags_SizingStretchProp)) {
    ImGui::TableSetupColumn("Categories", ImGuiTableColumnFlags_WidthFixed,
                            std::clamp(ImGui::GetContentRegionAvail().x * 0.30f,
                                       gui::ScaledSize(150.0f, 0.0f).x,
                                       gui::ScaledSize(220.0f, 0.0f).x));
    ImGui::TableSetupColumn("Settings", ImGuiTableColumnFlags_WidthStretch);
    ImGui::TableNextRow();
    ImGui::TableNextColumn();
    DrawCategoryNavigation(categories, false);
    ImGui::TableNextColumn();
    DrawCategoryContent(active_category_);
    ImGui::EndTable();
    return;
  }
 
  DrawCategoryNavigation(categories, true);
  DrawCategoryContent(active_category_);
}
 
void SettingsPanel::DrawScopeTabs() {
  if (!ImGui::BeginTabBar("##SettingsScopes")) {
    return;
  }
  for (const Scope scope :
       {Scope::kApplication, Scope::kWorkspace, Scope::kProject}) {
    const bool selected = active_scope_ == scope;
    const bool tab_open = ImGui::BeginTabItem(ScopeLabel(scope));
    gui::WidgetIdRegistry::Instance().RegisterWidget(
        std::string("Settings/tab:") + ScopeLabel(scope), "tab",
        ImGui::GetItemID());
    if (tab_open) {
      if (!selected) {
        active_scope_ = scope;
        active_category_.clear();
        settings_search_.fill('\0');
      }
      ImGui::EndTabItem();
    }
  }
  ImGui::EndTabBar();
}
 
void SettingsPanel::EnsureActiveCategory(
    const std::vector<CategoryDescriptor>& categories) {
  if (categories.empty()) {
    active_category_.clear();
    return;
  }
  const auto active = std::find_if(categories.begin(), categories.end(),
                                   [this](const CategoryDescriptor& category) {
                                     return active_category_ == category.id;
                                   });
  if (active == categories.end()) {
    active_category_ = categories.front().id;
  }
}
 
void SettingsPanel::DrawCategoryNavigation(
    const std::vector<CategoryDescriptor>& categories, bool compact) {
  if (compact) {
    const CategoryDescriptor* active = nullptr;
    for (const CategoryDescriptor& category : categories) {
      if (active_category_ == category.id) {
        active = &category;
        break;
      }
    }
    const std::string preview =
        active ? absl::StrFormat("%s %s", active->icon, active->label)
               : std::string("Select category");
    ImGui::SetNextItemWidth(-1.0f);
    if (ImGui::BeginCombo("##SettingsCategory", preview.c_str())) {
      for (const CategoryDescriptor& category : categories) {
        const bool selected = active_category_ == category.id;
        const std::string label =
            absl::StrFormat("%s %s", category.icon, category.label);
        if (ImGui::Selectable(label.c_str(), selected)) {
          active_category_ = category.id;
        }
        if (selected) {
          ImGui::SetItemDefaultFocus();
        }
      }
      ImGui::EndCombo();
    }
    return;
  }
 
  const bool nav_open =
      ImGui::BeginChild("##SettingsCategories", ImVec2(0.0f, 0.0f), false);
  if (nav_open) {
    for (const CategoryDescriptor& category : categories) {
      const bool selected = active_category_ == category.id;
      const std::string label =
          absl::StrFormat("%s %s", category.icon, category.label);
      if (ImGui::Selectable(label.c_str(), selected)) {
        active_category_ = category.id;
      }
    }
  }
  ImGui::EndChild();
}
 
void SettingsPanel::DrawCategoryContent(const std::string& category_id) {
  const auto descriptor =
      std::find_if(kSettingsCategories.begin(), kSettingsCategories.end(),
                   [&category_id](const CategoryDescriptor& category) {
                     return category_id == category.id;
                   });
  if (descriptor == kSettingsCategories.end()) {
    return;
  }
 
  const std::string heading =
      absl::StrFormat("%s %s", descriptor->icon, descriptor->label);
  ImGui::SeparatorText(heading.c_str());
  if (category_id == "appearance") {
    DrawAppearanceSettings();
  } else if (category_id == "behavior") {
    DrawEditorBehavior();
  } else if (category_id == "performance") {
    DrawPerformanceSettings();
  } else if (category_id == "files") {
    DrawFilesystemSettings();
  } else if (category_id == "ai") {
    DrawAIAgentSettings();
  } else if (category_id == "shortcuts") {
    DrawKeyboardShortcuts();
  } else if (category_id == "layout") {
    DrawWorkspaceSettings();
  } else if (category_id == "project") {
    DrawProjectSettings();
  } else if (category_id == "features") {
    DrawGeneralSettings();
  } else if (category_id == "patches") {
    DrawPatchSettings();
  }
}
 
void SettingsPanel::DrawGeneralSettings() {
  // Refactored from table to vertical list for sidebar
  static gui::FlagsMenu flags;
 
  ImGui::TextDisabled(tr("Feature Flags configuration"));
  ImGui::Spacing();
 
  bool experiments_enabled = user_settings_->prefs().show_experimental_editors;
  if (ImGui::Checkbox(tr("Acknowledge Experimental Editors"),
                      &experiments_enabled)) {
    user_settings_->prefs().show_experimental_editors = experiments_enabled;
    user_settings_->Save();
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Acknowledges Screen, Music, and Agent editor maturity. Turning "
           "this off keeps the editors visible but warns and may force a "
           "backup. Feature-specific write guards remain authoritative."));
  }
  if (!experiments_enabled) {
    ImGui::TextDisabled(
        "%s",
        tr("Experimental editors remain available with warnings and defensive "
           "save safeguards."));
  }
  ImGui::Separator();
 
  if (ImGui::TreeNode(ICON_MD_FLAG " System Flags")) {
    flags.DrawSystemFlags();
    ImGui::TreePop();
  }
 
  if (ImGui::TreeNode(ICON_MD_MAP " Overworld Flags")) {
    flags.DrawOverworldFlags();
    ImGui::TreePop();
  }
 
  if (ImGui::TreeNode(ICON_MD_EXTENSION " ZSCustomOverworld Enable Flags")) {
    flags.DrawZSCustomOverworldFlags(rom_);
    ImGui::TreePop();
  }
 
  if (ImGui::TreeNode(ICON_MD_CASTLE " Dungeon Flags")) {
    flags.DrawDungeonFlags();
    ImGui::TreePop();
  }
 
  if (ImGui::TreeNode(ICON_MD_FOLDER_SPECIAL " Resource Flags")) {
    flags.DrawResourceFlags();
    ImGui::TreePop();
  }
}
 
void SettingsPanel::DrawProjectSettings() {
  if (!project_) {
    ImGui::TextDisabled(tr("No active project."));
    return;
  }
 
  ImGui::Text(tr("%s Project Info"), ICON_MD_INFO);
  ImGui::Separator();
 
  ImGui::Text(tr("Name: %s"), project_->name.c_str());
  ImGui::Text(tr("Path: %s"), project_->filepath.c_str());
 
  ImGui::Spacing();
  ImGui::Text(tr("%s ROM Identity"), ICON_MD_VIDEOGAME_ASSET);
  ImGui::Separator();
 
  const char* roles[] = {"base", "dev", "patched", "release"};
  int role_index = static_cast<int>(project_->rom_metadata.role);
  if (ImGui::Combo(tr("Role"), &role_index, roles, IM_ARRAYSIZE(roles))) {
    project_->rom_metadata.role = static_cast<project::RomRole>(role_index);
    project_->Save();
  }
 
  const char* policies[] = {"allow", "warn", "block", "read_only"};
  int policy_index = static_cast<int>(project_->rom_metadata.write_policy);
  if (ImGui::Combo(tr("Write Policy"), &policy_index, policies,
                   IM_ARRAYSIZE(policies))) {
    project_->rom_metadata.write_policy =
        static_cast<project::RomWritePolicy>(policy_index);
    project_->Save();
  }
 
  std::string expected_hash = project_->rom_metadata.expected_hash;
  if (ImGui::InputText(tr("Expected Hash"), &expected_hash)) {
    project_->rom_metadata.expected_hash = expected_hash;
    project_->Save();
  }
 
  if (rom_ && rom_->is_loaded()) {
    // Use the identity checked by save policy, not a separately cached hash of
    // the editor's mutable ROM buffer (which may already contain edits).
    const auto current_hash =
        rom_hash_provider_ ? rom_hash_provider_()
                           : util::ComputeRomHash(rom_->data(), rom_->size());
    ImGui::Text(tr("Current ROM Hash: %s"),
                current_hash.empty() ? "(unknown)" : current_hash.c_str());
    const bool use_hash = ImGui::Button(tr("Use Current ROM Hash"));
    gui::WidgetIdRegistry::Instance().RegisterWidget(
        "Settings/button:Use Current ROM Hash", "button", ImGui::GetItemID());
    if (use_hash && !current_hash.empty()) {
      project_->rom_metadata.expected_hash = current_hash;
      project_->Save();
    }
  } else {
    ImGui::TextDisabled(tr("Current ROM Hash: (no ROM loaded)"));
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Paths"), ICON_MD_FOLDER_OPEN);
  ImGui::Separator();
 
  // Output Folder
  std::string output_folder = project_->output_folder;
  if (ImGui::InputText(tr("Output Folder"), &output_folder)) {
    project_->output_folder = output_folder;
    project_->Save();
  }
 
  // Git Repository
  std::string git_repo = project_->git_repository;
  if (ImGui::InputText(tr("Git Repository"), &git_repo)) {
    project_->git_repository = git_repo;
    project_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Build"), ICON_MD_BUILD);
  ImGui::Separator();
 
  // Build Target
  std::string build_target = project_->build_target;
  if (ImGui::InputText(tr("Build Target (ROM)"), &build_target)) {
    project_->build_target = build_target;
    project_->Save();
  }
 
  // Symbols File
  std::string symbols_file = project_->symbols_filename;
  if (ImGui::InputText(tr("Symbols File"), &symbols_file)) {
    project_->symbols_filename = symbols_file;
    project_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s ASM / Hack Manifest"), ICON_MD_CODE);
  ImGui::Separator();
  ImGui::TextWrapped(tr(
      "Optional: load a hack manifest JSON (generated by an ASM project) to "
      "annotate room tags, show feature flags, and surface which ROM regions "
      "are owned by ASM vs safe to edit in yaze."));
 
  std::string manifest_file = project_->hack_manifest_file;
  if (ImGui::InputText(tr("Hack Manifest File"), &manifest_file)) {
    project_->hack_manifest_file = manifest_file;
    project_->ReloadHackManifest();
    project_->Save();
  }
 
  const bool manifest_loaded = project_->hack_manifest.loaded();
  ImGui::SameLine();
  ImGui::TextDisabled(manifest_loaded ? "(loaded)" : "(not loaded)");
  if (ImGui::Button(tr("Reload Manifest"))) {
    project_->ReloadHackManifest();
  }
 
  if (manifest_loaded) {
    ImGui::Spacing();
    ImGui::Text(tr("Hack: %s"), project_->hack_manifest.hack_name().c_str());
    ImGui::Text(tr("Manifest Version: %d"),
                project_->hack_manifest.manifest_version());
    ImGui::Text(tr("Hooks Tracked: %d"), project_->hack_manifest.total_hooks());
 
    const auto& pipeline = project_->hack_manifest.build_pipeline();
    if (!pipeline.dev_rom.empty()) {
      ImGui::Text(tr("Dev ROM: %s"), pipeline.dev_rom.c_str());
    }
    if (!pipeline.patched_rom.empty()) {
      ImGui::Text(tr("Patched ROM: %s"), pipeline.patched_rom.c_str());
    }
    if (!pipeline.build_script.empty()) {
      ImGui::Text(tr("Build Script: %s"), pipeline.build_script.c_str());
    }
 
    const auto& msg_layout = project_->hack_manifest.message_layout();
    if (msg_layout.first_expanded_id != 0 || msg_layout.last_expanded_id != 0) {
      ImGui::Text(tr("Expanded Messages: 0x%03X-0x%03X (%d)"),
                  msg_layout.first_expanded_id, msg_layout.last_expanded_id,
                  msg_layout.expanded_count);
    }
 
    if (ImGui::TreeNode(ICON_MD_FLAG " Hack Feature Flags")) {
      for (const auto& flag : project_->hack_manifest.feature_flags()) {
        ImGui::BulletText("%s = %d (%s)", flag.name.c_str(), flag.value,
                          flag.enabled ? "enabled" : "disabled");
        if (!flag.source.empty()) {
          ImGui::SameLine();
          ImGui::TextDisabled("%s", flag.source.c_str());
        }
      }
      ImGui::TreePop();
    }
 
    if (ImGui::TreeNode(ICON_MD_LABEL " Room Tags (Dispatch)")) {
      for (const auto& tag : project_->hack_manifest.room_tags()) {
        ImGui::BulletText(tr("0x%02X: %s"), tag.tag_id, tag.name.c_str());
        if (!tag.enabled && !tag.feature_flag.empty()) {
          ImGui::SameLine();
          ImGui::TextDisabled(tr("(disabled by %s)"), tag.feature_flag.c_str());
        }
        if (!tag.purpose.empty() && ImGui::IsItemHovered()) {
          ImGui::SetTooltip("%s", tag.purpose.c_str());
        }
      }
      ImGui::TreePop();
    }
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Backup Settings"), ICON_MD_BACKUP);
  ImGui::Separator();
 
  std::string backup_folder = project_->rom_backup_folder;
  if (ImGui::InputText(tr("Backup Folder"), &backup_folder)) {
    project_->rom_backup_folder = backup_folder;
    project_->Save();
  }
 
  bool backup_on_save = project_->workspace_settings.backup_on_save;
  if (gui::DrawProperty("Backup Before Save", &backup_on_save)) {
    project_->workspace_settings.backup_on_save = backup_on_save;
    // While a project is open the live preference is its overlay, and project
    // saves copy the live value back. Keep both in step.
    if (user_settings_ && user_settings_->HasWorkspaceOverrides()) {
      user_settings_->prefs().backup_before_save = backup_on_save;
    }
    project_->Save();
  }
 
  int retention = project_->workspace_settings.backup_retention_count;
  if (gui::DrawProperty("Retention Count", &retention,
                        {.min = 0, .max = 10000})) {
    project_->workspace_settings.backup_retention_count = retention;
    project_->Save();
  }
 
  bool keep_daily = project_->workspace_settings.backup_keep_daily;
  if (gui::DrawProperty("Keep Daily Snapshots", &keep_daily)) {
    project_->workspace_settings.backup_keep_daily = keep_daily;
    project_->Save();
  }
 
  int keep_days = project_->workspace_settings.backup_keep_daily_days;
  if (gui::DrawProperty("Keep Daily Days", &keep_days,
                        {.min = 1, .max = 3650})) {
    project_->workspace_settings.backup_keep_daily_days = keep_days;
    project_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Dungeon Overlay"), ICON_MD_TRAIN);
  ImGui::Separator();
  ImGui::TextWrapped(
      tr("Read-only here. Edit collision and object IDs in Minecart Tracks > "
         "Advanced."));
 
  constexpr std::array<const char*, 5> kLabels = {
      "Track Tiles", "Stop Tiles", "Switch Tiles", "Track Object IDs",
      "Minecart Sprite IDs"};
  const DungeonOverlaySummary summary =
      BuildDungeonOverlaySummary(project_->dungeon_overlay);
  if (ImGui::BeginTable("DungeonOverlaySummary", 2,
                        ImGuiTableFlags_SizingStretchProp)) {
    ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, 132.0f);
    ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
    for (size_t i = 0; i < summary.size(); ++i) {
      ImGui::TableNextRow();
      ImGui::TableSetColumnIndex(0);
      ImGui::TextDisabled("%s", tr(kLabels[i]));
      ImGui::TableSetColumnIndex(1);
      ImGui::TextWrapped("%s", summary[i].first.c_str());
      ImGui::TextDisabled("%s", summary[i].second
                                    ? tr("Standard values")
                                    : tr("Custom project values"));
    }
    ImGui::EndTable();
  }
 
  ImGui::Spacing();
  const bool custom_objects_enabled =
      core::FeatureFlags::get().kEnableCustomObjects;
  const bool can_open = custom_objects_enabled &&
                        static_cast<bool>(open_minecart_tracks_callback_);
  ImGui::BeginDisabled(!can_open);
  if (ImGui::Button(ICON_MD_TRAIN " Open Minecart Tracks")) {
    (void)RequestOpenMinecartTracks();
  }
  ImGui::EndDisabled();
 
  if (!custom_objects_enabled) {
    ImGui::TextDisabled(
        tr("Enable Custom Dungeon Objects in General Settings first."));
  } else if (!open_minecart_tracks_callback_) {
    ImGui::TextDisabled(tr("Minecart Tracks navigation is unavailable."));
  }
 
  if (!project_status_message_.empty()) {
    ImGui::TextColored(gui::GetErrorColor(), "%s",
                       project_status_message_.c_str());
  }
}
 
void SettingsPanel::DrawFilesystemSettings() {
  if (!user_settings_) {
    return;
  }
 
  auto& prefs = user_settings_->prefs();
  auto& roots = prefs.project_root_paths;
  static int selected_root_index = -1;
  static std::string new_root_path;
 
  ImGui::Text(tr("%s Project Roots"), ICON_MD_FOLDER_OPEN);
  ImGui::Separator();
 
  if (roots.empty()) {
    ImGui::TextDisabled(tr("No project roots configured."));
  }
 
  const float roots_height = std::clamp(
      ImGui::GetContentRegionAvail().y * 0.28f, gui::ScaledSize(0.0f, 100.0f).y,
      gui::ScaledSize(0.0f, 220.0f).y);
  if (ImGui::BeginChild("ProjectRootsList", ImVec2(0, roots_height), true)) {
    for (size_t i = 0; i < roots.size(); ++i) {
      const bool is_default = roots[i] == prefs.default_project_root;
      std::string label =
          util::PlatformPaths::NormalizePathForDisplay(roots[i]);
      if (is_default) {
        label += " (default)";
      }
      if (ImGui::Selectable(label.c_str(),
                            selected_root_index == static_cast<int>(i))) {
        selected_root_index = static_cast<int>(i);
      }
    }
  }
  ImGui::EndChild();
 
  const bool has_selection =
      selected_root_index >= 0 &&
      selected_root_index < static_cast<int>(roots.size());
  if (has_selection) {
    if (ImGui::Button(tr("Set Default"))) {
      prefs.default_project_root = roots[selected_root_index];
      user_settings_->Save();
    }
    ImGui::SameLine();
    if (ImGui::Button(ICON_MD_DELETE " Remove")) {
      const std::string removed = roots[selected_root_index];
      roots.erase(roots.begin() + selected_root_index);
      if (prefs.default_project_root == removed) {
        prefs.default_project_root = roots.empty() ? "" : roots.front();
      }
      selected_root_index = roots.empty()
                                ? -1
                                : std::min(selected_root_index,
                                           static_cast<int>(roots.size() - 1));
      user_settings_->Save();
    }
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Add Root"), ICON_MD_ADD);
  ImGui::Separator();
 
  ImGui::InputTextWithHint("##project_root_add", "Add folder path...",
                           &new_root_path);
  if (ImGui::Button(ICON_MD_ADD " Add Path")) {
    const std::string trimmed =
        std::string(absl::StripAsciiWhitespace(new_root_path));
    if (!trimmed.empty()) {
      if (AddUniquePath(&roots, trimmed) &&
          prefs.default_project_root.empty()) {
        prefs.default_project_root = trimmed;
      }
      user_settings_->Save();
    }
  }
  ImGui::SameLine();
  if (ImGui::Button(ICON_MD_FOLDER_OPEN " Browse")) {
    const std::string folder = util::FileDialogWrapper::ShowOpenFolderDialog();
    if (!folder.empty()) {
      if (AddUniquePath(&roots, folder) && prefs.default_project_root.empty()) {
        prefs.default_project_root = folder;
      }
      user_settings_->Save();
    }
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Quick Add"), ICON_MD_BOLT);
  ImGui::Separator();
 
  if (ImGui::Button(ICON_MD_HOME " Add Documents")) {
    auto docs_dir = util::PlatformPaths::GetUserDocumentsDirectory();
    if (docs_dir.ok()) {
      if (AddUniquePath(&roots, docs_dir->string()) &&
          prefs.default_project_root.empty()) {
        prefs.default_project_root = docs_dir->string();
      }
      user_settings_->Save();
    }
  }
  ImGui::SameLine();
  if (ImGui::Button(ICON_MD_CLOUD " Add iCloud Projects")) {
    auto icloud_dir =
        util::PlatformPaths::GetUserDocumentsSubdirectory("iCloud");
    if (icloud_dir.ok()) {
      if (AddUniquePath(&roots, icloud_dir->string())) {
        prefs.default_project_root = icloud_dir->string();
      }
      user_settings_->Save();
    }
  }
  ImGui::TextDisabled(
      tr("iCloud projects live in Documents/Yaze/iCloud on this Mac."));
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Sync Options"), ICON_MD_SYNC);
  ImGui::Separator();
 
  bool use_icloud_sync = prefs.use_icloud_sync;
  if (ImGui::Checkbox(tr("Use iCloud sync (Documents)"), &use_icloud_sync)) {
    prefs.use_icloud_sync = use_icloud_sync;
    if (use_icloud_sync) {
      auto icloud_dir =
          util::PlatformPaths::GetUserDocumentsSubdirectory("iCloud");
      if (icloud_dir.ok()) {
        AddUniquePath(&roots, icloud_dir->string());
        prefs.default_project_root = icloud_dir->string();
      }
    }
    user_settings_->Save();
  }
 
  bool use_files_app = prefs.use_files_app;
  if (ImGui::Checkbox(tr("Prefer Files app on iOS"), &use_files_app)) {
    prefs.use_files_app = use_files_app;
    user_settings_->Save();
  }
}
 
void SettingsPanel::ApplyDisplayDensity(gui::DensityPreset preset) {
  auto& theme_manager = gui::ThemeManager::Get();
  auto theme = theme_manager.GetCurrentTheme();
  theme.ApplyDensityPreset(preset);
  // ReapplyTheme, not ApplyTheme: this re-applies the theme the user is
  // already on, so Classic YAZE has to route back through ColorsYaze().
  theme_manager.ReapplyTheme(theme);
}
 
void SettingsPanel::DrawAppearanceSettings() {
  auto& theme_manager = gui::ThemeManager::Get();
 
  ImGui::Text(tr("%s Theme"), ICON_MD_PALETTE);
  ImGui::Separator();
 
  const std::string current = theme_manager.GetCurrentThemeName();
  const auto& current_theme = theme_manager.GetCurrentTheme();
 
  ImGui::SetNextItemWidth(-1.0f);
  if (ImGui::BeginCombo("##AppearanceTheme", current.c_str())) {
    for (const auto& theme_name : theme_manager.GetAvailableThemes()) {
      const bool is_current = theme_name == current;
      if (ImGui::Selectable(theme_name.c_str(), is_current)) {
        if (theme_manager.IsPreviewActive()) {
          theme_manager.EndPreview();
        }
        theme_manager.ApplyTheme(theme_name);
      }
      if (is_current) {
        ImGui::SetItemDefaultFocus();
      }
    }
    ImGui::EndCombo();
  }
 
  const ImGuiColorEditFlags swatch_flags = ImGuiColorEditFlags_NoTooltip |
                                           ImGuiColorEditFlags_NoDragDrop |
                                           ImGuiColorEditFlags_NoPicker;
  const float swatch_size = std::max(12.0f, ImGui::GetFrameHeight() * 0.62f);
  ImGui::TextDisabled("%s", tr("Palette"));
  ImGui::SameLine(0.0f, 6.0f);
  ImGui::PushID("CurrentThemeSwatches");
  ImGui::ColorButton("Primary",
                     gui::ConvertColorToImVec4(current_theme.primary),
                     swatch_flags, ImVec2(swatch_size, swatch_size));
  ImGui::SameLine(0.0f, 3.0f);
  ImGui::ColorButton("Surface",
                     gui::ConvertColorToImVec4(current_theme.surface),
                     swatch_flags, ImVec2(swatch_size, swatch_size));
  ImGui::SameLine(0.0f, 3.0f);
  ImGui::ColorButton("Accent", gui::ConvertColorToImVec4(current_theme.accent),
                     swatch_flags, ImVec2(swatch_size, swatch_size));
  ImGui::PopID();
  if (!current_theme.description.empty()) {
    ImGui::PushTextWrapPos(0.0f);
    ImGui::TextDisabled("%s", current_theme.description.c_str());
    ImGui::PopTextWrapPos();
  }
 
  if (ImGui::SmallButton(ICON_MD_REFRESH " Reload themes")) {
    theme_manager.RefreshAvailableThemes();
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Re-scan theme folders for new or changed themes"));
  }
 
  ImGui::Spacing();
  ImGui::SeparatorText(tr("Density"));
 
  {
    auto preset = theme_manager.GetCurrentTheme().density_preset;
    int density = static_cast<int>(preset);
    const char* density_labels[] = {tr("Compact"), tr("Normal"),
                                    tr("Comfortable")};
    ImGui::SetNextItemWidth(-1.0f);
    if (ImGui::Combo("##DisplayDensity", &density, density_labels,
                     IM_ARRAYSIZE(density_labels))) {
      ApplyDisplayDensity(static_cast<gui::DensityPreset>(density));
    }
    ImGui::TextDisabled(
        "%s", density == 0   ? tr("Tighter controls and more visible content")
              : density == 2 ? tr("Larger controls with more breathing room")
                             : tr("Balanced spacing for everyday editing"));
  }
 
  ImGui::Spacing();
  ImGui::SeparatorText(tr("Motion"));
 
  auto& prefs = user_settings_->prefs();
  bool reduced_motion = prefs.reduced_motion;
  if (ImGui::Checkbox(tr("Reduced Motion"), &reduced_motion)) {
    prefs.reduced_motion = reduced_motion;
    gui::GetAnimator().SetMotionPreferences(
        prefs.reduced_motion,
        gui::Animator::ClampMotionProfile(prefs.switch_motion_profile));
    user_settings_->Save();
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Disable panel/editor transition animations for a calmer editing "
           "experience."));
  }
 
  int switch_profile = std::clamp(prefs.switch_motion_profile, 0, 2);
  const char* switch_profile_labels[] = {"Snappy", "Standard", "Relaxed"};
  if (ImGui::Combo(tr("Switch Motion Profile"), &switch_profile,
                   switch_profile_labels,
                   IM_ARRAYSIZE(switch_profile_labels))) {
    prefs.switch_motion_profile = switch_profile;
    gui::GetAnimator().SetMotionPreferences(
        prefs.reduced_motion,
        gui::Animator::ClampMotionProfile(prefs.switch_motion_profile));
    user_settings_->Save();
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Controls editor/workspace switch timing and easing for panel fades "
           "and sidebar slides."));
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Font"), ICON_MD_TEXT_FIELDS);
  ImGui::Separator();
 
  if (user_settings_) {
    int font_index = user_settings_->prefs().font_family_index;
    if (gui::FontPicker("##font_family", &font_index)) {
      user_settings_->prefs().font_family_index = font_index;
      ::yaze::SetActiveFontIndex(font_index);
      user_settings_->Save();
    }
 
    ImGui::Text(tr("Global Font Scale"));
    float scale = user_settings_->prefs().font_global_scale;
    if (ImGui::SliderFloat("##global_font_scale", &scale, 0.5f, 2.0f, "%.2f")) {
      user_settings_->prefs().font_global_scale = scale;
      ImGui::GetIO().FontGlobalScale = scale;
      user_settings_->Save();
    }
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Status Bar"), ICON_MD_HORIZONTAL_RULE);
  ImGui::Separator();
 
  bool show_status_bar = user_settings_->prefs().show_status_bar;
  if (ImGui::Checkbox(tr("Show Status Bar"), &show_status_bar)) {
    user_settings_->prefs().show_status_bar = show_status_bar;
    user_settings_->Save();
    // Immediately apply to status bar if status_bar_ is available
    if (status_bar_) {
      status_bar_->SetEnabled(show_status_bar);
    }
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Display ROM, session, cursor, and zoom info at bottom of window"));
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Editor Behavior"), ICON_MD_TUNE);
  ImGui::Separator();
 
  bool keep_emu_bg =
      user_settings_->prefs().emulator_keep_running_in_background;
  if (ImGui::Checkbox(tr("Keep Emulator Running in Background"),
                      &keep_emu_bg)) {
    user_settings_->prefs().emulator_keep_running_in_background = keep_emu_bg;
    user_settings_->Save();
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr(
        "When off (default), hiding emulator panels pauses the SNES tick and "
        "audio. Music playback still drives its own frames."));
  }
}
 
void SettingsPanel::DrawWorkspaceSettings() {
  if (!user_settings_) {
    ImGui::TextDisabled(tr("UserSettings unavailable."));
    return;
  }
 
  auto& prefs = user_settings_->prefs();
 
  ImGui::Text(tr("%s Named Layouts"), ICON_MD_DASHBOARD);
  ImGui::Separator();
 
  if (prefs.named_layouts.empty()) {
    ImGui::TextDisabled(
        tr("No saved layouts yet. Open the Layout Designer to capture one."));
  } else {
    // Sort the keys so the combo order is stable across frames
    // (named_layouts is unordered_map).
    std::vector<std::string> names;
    names.reserve(prefs.named_layouts.size());
    for (const auto& entry : prefs.named_layouts) {
      names.push_back(entry.first);
    }
    std::sort(names.begin(), names.end());
 
    const std::string& active = prefs.last_applied_layout_name;
    const char* preview =
        active.empty() ? "(select a layout…)" : active.c_str();
 
    if (ImGui::BeginCombo(tr("Active Layout"), preview)) {
      for (const auto& name : names) {
        const bool is_selected = (name == active);
        if (ImGui::Selectable(name.c_str(), is_selected)) {
          // Mirrors the LayoutManager startup-reapply path in shape:
          // lookup → parse → validate → ApplyDockTree. Inlined rather
          // than shared because the call sites have different error
          // surfacing — this one writes to a transient status string;
          // startup writes to the log and a one-shot consumed flag.
          ApplyNamedLayoutToDockspace(name);
        }
        if (is_selected) {
          ImGui::SetItemDefaultFocus();
        }
      }
      ImGui::EndCombo();
    }
 
    ImGui::SameLine();
    ImGui::BeginDisabled(active.empty() ||
                         prefs.named_layouts.count(active) == 0);
    if (ImGui::SmallButton(tr("Re-apply"))) {
      ApplyNamedLayoutToDockspace(active);
    }
    ImGui::EndDisabled();
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Re-apply the active layout (useful after closing or rearranging "
             "panels manually)."));
    }
  }
 
  ImGui::Spacing();
  if (ImGui::Button(ICON_MD_DASHBOARD_CUSTOMIZE " Open Layout Designer")) {
    if (window_manager_ == nullptr) {
      workspace_status_message_ = "Designer unavailable: no window manager.";
      workspace_status_is_error_ = true;
    } else if (!window_manager_->IsWindowOpen("layout.designer") &&
               !window_manager_->OpenWindow("layout.designer")) {
      // OpenWindow returns false when the panel id isn't registered in
      // the active session. Surface that — silently doing nothing on
      // a missing registration would hide a real bug (panel renamed,
      // force-load archive misconfigured, etc.).
      workspace_status_message_ =
          "Open failed: \"layout.designer\" panel is not registered.";
      workspace_status_is_error_ = true;
    } else {
      window_manager_->SetWindowPinned("layout.designer", true);
      workspace_status_message_.clear();
      workspace_status_is_error_ = false;
    }
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Open the Layout Designer panel to author or capture a workspace "
           "layout."));
  }
 
  if (!workspace_status_message_.empty()) {
    ImGui::Spacing();
    if (workspace_status_is_error_) {
      ImGui::TextColored(gui::GetErrorColor(), "%s",
                         workspace_status_message_.c_str());
    } else {
      ImGui::TextDisabled("%s", workspace_status_message_.c_str());
    }
  }
}
 
void SettingsPanel::ApplyNamedLayoutToDockspace(const std::string& name) {
  workspace_status_message_.clear();
  workspace_status_is_error_ = false;
  if (user_settings_ == nullptr) {
    workspace_status_message_ = "Apply failed: UserSettings unavailable.";
    workspace_status_is_error_ = true;
    return;
  }
  auto& prefs = user_settings_->prefs();
  const auto it = prefs.named_layouts.find(name);
  if (it == prefs.named_layouts.end()) {
    workspace_status_message_ =
        absl::StrCat("Apply failed: \"", name, "\" not found.");
    workspace_status_is_error_ = true;
    return;
  }
 
  nlohmann::json parsed;
  try {
    parsed = nlohmann::json::parse(it->second);
  } catch (const nlohmann::json::parse_error& e) {
    workspace_status_message_ =
        absl::StrCat("Apply failed: invalid JSON (", e.what(), ").");
    workspace_status_is_error_ = true;
    return;
  }
 
  auto tree_or = layout_designer::DockTreeFromJson(parsed);
  if (!tree_or.ok()) {
    workspace_status_message_ =
        absl::StrCat("Apply failed: ", tree_or.status().message());
    workspace_status_is_error_ = true;
    return;
  }
 
  std::string validation_error;
  if (!tree_or->Validate(&validation_error)) {
    workspace_status_message_ =
        absl::StrCat("Apply failed: invalid layout (", validation_error, ").");
    workspace_status_is_error_ = true;
    return;
  }
 
  LayoutManager* manager = ContentRegistry::Context::layout_manager();
  if (manager == nullptr) {
    workspace_status_message_ = "Apply failed: LayoutManager unavailable.";
    workspace_status_is_error_ = true;
    return;
  }
  const ImGuiID dockspace_id = manager->GetMainDockspaceId();
  if (dockspace_id == 0) {
    workspace_status_message_ = "Apply failed: main dockspace not yet created.";
    workspace_status_is_error_ = true;
    return;
  }
 
  const absl::Status apply_status =
      manager->ApplyDockTree(*tree_or, dockspace_id);
  if (!apply_status.ok()) {
    workspace_status_message_ =
        absl::StrCat("Apply failed: ", apply_status.message());
    workspace_status_is_error_ = true;
    return;
  }
 
  prefs.last_applied_layout_name = name;
  (void)user_settings_->Save();
  workspace_status_message_ = absl::StrCat("Applied \"", name, "\".");
  workspace_status_is_error_ = false;
}
 
void SettingsPanel::DrawEditorBehavior() {
  if (!user_settings_)
    return;
 
  ImGui::Text(tr("%s Auto-Save"), ICON_MD_SAVE);
  ImGui::Separator();
  if (user_settings_->HasWorkspaceOverrides()) {
    ImGui::TextDisabled(
        "%s", tr("These apply to the open project and save with it."));
  }
 
  if (ImGui::Checkbox(tr("Enable Auto-Save"),
                      &user_settings_->prefs().autosave_enabled)) {
    user_settings_->Save();
  }
 
  if (user_settings_->prefs().autosave_enabled) {
    ImGui::Indent();
    int interval = static_cast<int>(user_settings_->prefs().autosave_interval);
    if (ImGui::SliderInt(tr("Interval (sec)"), &interval, 60, 600)) {
      user_settings_->prefs().autosave_interval = static_cast<float>(interval);
      user_settings_->Save();
    }
    ImGui::Unindent();
  }
 
  // Backups gate every ROM save, not only autosave.
  if (ImGui::Checkbox(tr("Backup Before Save"),
                      &user_settings_->prefs().backup_before_save)) {
    user_settings_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Recent Files"), ICON_MD_HISTORY);
  ImGui::Separator();
 
  if (ImGui::SliderInt(tr("Limit"), &user_settings_->prefs().recent_files_limit,
                       5, 50)) {
    user_settings_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Default Editor"), ICON_MD_EDIT);
  ImGui::Separator();
 
  // Index order is persisted as default_editor; append new editors only.
  const char* editors[] = {"None", "Overworld", "Dungeon", "Graphics",
                           "Messages"};
  if (ImGui::Combo("##DefaultEditor", &user_settings_->prefs().default_editor,
                   editors, IM_ARRAYSIZE(editors))) {
    user_settings_->Save();
  }
  ImGui::TextDisabled(
      "%s", tr("Opens after a ROM or project loads. None shows the picker."));
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Sprite Names"), ICON_MD_LABEL);
  ImGui::Separator();
  if (ImGui::Checkbox(tr("Use HMagic sprite names (expanded)"),
                      &user_settings_->prefs().prefer_hmagic_sprite_names)) {
    yaze::zelda3::SetPreferHmagicSpriteNames(
        user_settings_->prefs().prefer_hmagic_sprite_names);
    user_settings_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Testing"), ICON_MD_SCIENCE);
  ImGui::Separator();
  if (ImGui::Checkbox(tr("Test mode"), &user_settings_->prefs().test_mode)) {
    user_settings_->Save();
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("From the next launch: no welcome screen, no editor picker, and "
           "the local test server starts on port 50052 (builds with gRPC)."));
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Onboarding Tips"), ICON_MD_LIGHTBULB);
  ImGui::Separator();
  if (ImGui::Checkbox(tr("Show feature tips (ZScream migration, etc.)"),
                      &user_settings_->prefs().feature_hints_enabled)) {
    user_settings_->Save();
  }
  ImGui::TextDisabled(tr("%zu tip(s) already dismissed"),
                      user_settings_->prefs().dismissed_feature_hints.size());
  if (ImGui::Button(tr("Reset dismissed tips"))) {
    user_settings_->prefs().dismissed_feature_hints.clear();
    user_settings_->Save();
  }
}
 
void SettingsPanel::DrawPerformanceSettings() {
  if (!user_settings_)
    return;
 
  ImGui::Text(tr("%s Graphics"), ICON_MD_IMAGE);
  ImGui::Separator();
 
  if (ImGui::Checkbox(tr("V-Sync"), &user_settings_->prefs().vsync)) {
    user_settings_->Save();
  }
 
  if (ImGui::SliderInt(tr("Target FPS"), &user_settings_->prefs().target_fps,
                       30, 144)) {
    user_settings_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Memory"), ICON_MD_MEMORY);
  ImGui::Separator();
 
  if (ImGui::SliderInt(tr("Cache Size (MB)"),
                       &user_settings_->prefs().cache_size_mb, 128, 2048)) {
    user_settings_->Save();
  }
 
  if (ImGui::SliderInt(tr("Undo History"),
                       &user_settings_->prefs().undo_history_size, 10, 200)) {
    user_settings_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Separator();
  ImGui::Text(tr("Current FPS: %.1f"), ImGui::GetIO().Framerate);
  ImGui::Text(tr("Frame Time: %.3f ms"), 1000.0f / ImGui::GetIO().Framerate);
}
 
void SettingsPanel::DrawAIAgentSettings() {
  if (!user_settings_)
    return;
 
  auto& prefs = user_settings_->prefs();
  auto& hosts = prefs.ai_hosts;
  static int selected_host_index = -1;
 
  auto draw_key_row = [&](const char* label, std::string* key,
                          const char* env_var, const char* id) {
    ImGui::PushID(id);
    ImGui::Text("%s", label);
    const ImVec2 button_size = ImGui::CalcTextSize(ICON_MD_SYNC " Env");
    float env_button_width =
        button_size.x + ImGui::GetStyle().FramePadding.x * 2.0f;
    float input_width = ImGui::GetContentRegionAvail().x - env_button_width -
                        ImGui::GetStyle().ItemSpacing.x;
    bool stack = input_width < 160.0f;
    ImGui::SetNextItemWidth(stack ? -1.0f : input_width);
    if (ImGui::InputTextWithHint("##key", "API key...", key,
                                 ImGuiInputTextFlags_Password)) {
      user_settings_->Save();
    }
    if (!stack) {
      ImGui::SameLine();
    }
    if (ImGui::SmallButton(ICON_MD_SYNC " Env")) {
      const char* env_key = std::getenv(env_var);
      if (env_key) {
        *key = env_key;
        user_settings_->Save();
      }
    }
    ImGui::Spacing();
    ImGui::PopID();
  };
 
  ImGui::Text(tr("%s Provider Keys"), ICON_MD_VPN_KEY);
  ImGui::Separator();
  draw_key_row("OpenAI", &prefs.openai_api_key, "OPENAI_API_KEY", "openai_key");
  draw_key_row("Anthropic", &prefs.anthropic_api_key, "ANTHROPIC_API_KEY",
               "anthropic_key");
  draw_key_row("Google (Gemini)", &prefs.gemini_api_key, "GEMINI_API_KEY",
               "gemini_key");
  ImGui::Spacing();
 
  // Provider selection
  ImGui::Text(tr("%s Provider Defaults (legacy)"), ICON_MD_CLOUD);
  ImGui::Separator();
 
  const char* providers[] = {"Ollama (Local)", "Gemini (Cloud)",
                             "Mock (Testing)"};
  if (ImGui::Combo("##Provider", &prefs.ai_provider, providers,
                   IM_ARRAYSIZE(providers))) {
    user_settings_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Host Routing"), ICON_MD_STORAGE);
  ImGui::Separator();
 
  const char* active_preview = "None";
  const char* remote_preview = "None";
  for (const auto& host : hosts) {
    if (!prefs.active_ai_host_id.empty() &&
        host.id == prefs.active_ai_host_id) {
      active_preview = host.label.c_str();
    }
    if (!prefs.remote_build_host_id.empty() &&
        host.id == prefs.remote_build_host_id) {
      remote_preview = host.label.c_str();
    }
  }
 
  if (ImGui::BeginCombo(tr("Active Host"), active_preview)) {
    for (size_t i = 0; i < hosts.size(); ++i) {
      const bool is_selected = (!prefs.active_ai_host_id.empty() &&
                                hosts[i].id == prefs.active_ai_host_id);
      if (ImGui::Selectable(hosts[i].label.c_str(), is_selected)) {
        prefs.active_ai_host_id = hosts[i].id;
        if (prefs.remote_build_host_id.empty()) {
          prefs.remote_build_host_id = hosts[i].id;
        }
        user_settings_->Save();
      }
      if (is_selected) {
        ImGui::SetItemDefaultFocus();
      }
    }
    ImGui::EndCombo();
  }
 
  if (ImGui::BeginCombo(tr("Remote Build Host"), remote_preview)) {
    for (size_t i = 0; i < hosts.size(); ++i) {
      const bool is_selected = (!prefs.remote_build_host_id.empty() &&
                                hosts[i].id == prefs.remote_build_host_id);
      if (ImGui::Selectable(hosts[i].label.c_str(), is_selected)) {
        prefs.remote_build_host_id = hosts[i].id;
        user_settings_->Save();
      }
      if (is_selected) {
        ImGui::SetItemDefaultFocus();
      }
    }
    ImGui::EndCombo();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s AI Hosts"), ICON_MD_STORAGE);
  ImGui::Separator();
 
  if (selected_host_index >= static_cast<int>(hosts.size())) {
    selected_host_index = hosts.empty() ? -1 : 0;
  }
  if (selected_host_index < 0 && !hosts.empty()) {
    for (size_t i = 0; i < hosts.size(); ++i) {
      if (!prefs.active_ai_host_id.empty() &&
          hosts[i].id == prefs.active_ai_host_id) {
        selected_host_index = static_cast<int>(i);
        break;
      }
    }
    if (selected_host_index < 0) {
      selected_host_index = 0;
    }
  }
 
  const float hosts_height = std::clamp(
      ImGui::GetContentRegionAvail().y * 0.32f, gui::ScaledSize(0.0f, 120.0f).y,
      gui::ScaledSize(0.0f, 240.0f).y);
  ImGui::BeginChild("##ai_host_list", ImVec2(0, hosts_height), true);
  for (size_t i = 0; i < hosts.size(); ++i) {
    const bool is_selected = static_cast<int>(i) == selected_host_index;
    std::string label = hosts[i].label;
    if (hosts[i].id == prefs.active_ai_host_id) {
      label += " (active)";
    }
    if (hosts[i].id == prefs.remote_build_host_id) {
      label += " (build)";
    }
    if (ImGui::Selectable(label.c_str(), is_selected)) {
      selected_host_index = static_cast<int>(i);
    }
    std::string tags = BuildHostTagString(hosts[i]);
    if (!tags.empty()) {
      ImGui::SameLine();
      ImGui::TextDisabled("%s", tags.c_str());
    }
  }
  ImGui::EndChild();
 
  auto add_host = [&](UserSettings::Preferences::AiHost host) {
    if (host.id.empty()) {
      host.id = absl::StrFormat("host-%zu", hosts.size() + 1);
    }
    hosts.push_back(host);
    selected_host_index = static_cast<int>(hosts.size() - 1);
    if (prefs.active_ai_host_id.empty()) {
      prefs.active_ai_host_id = host.id;
    }
    if (prefs.remote_build_host_id.empty()) {
      prefs.remote_build_host_id = host.id;
    }
    user_settings_->Save();
  };
 
  if (ImGui::Button(ICON_MD_ADD " Add Host")) {
    UserSettings::Preferences::AiHost host;
    host.label = "New Host";
    host.base_url = "http://localhost:1234";
    host.api_type = "openai";
    add_host(host);
  }
  ImGui::SameLine();
  if (ImGui::Button(ICON_MD_DELETE " Remove") && selected_host_index >= 0 &&
      selected_host_index < static_cast<int>(hosts.size())) {
    const std::string removed_id = hosts[selected_host_index].id;
    hosts.erase(hosts.begin() + selected_host_index);
    if (prefs.active_ai_host_id == removed_id) {
      prefs.active_ai_host_id = hosts.empty() ? "" : hosts.front().id;
    }
    if (prefs.remote_build_host_id == removed_id) {
      prefs.remote_build_host_id = prefs.active_ai_host_id;
    }
    selected_host_index =
        hosts.empty()
            ? -1
            : std::min(selected_host_index, static_cast<int>(hosts.size() - 1));
    user_settings_->Save();
  }
 
  ImGui::SameLine();
  if (ImGui::Button(tr("Add LM Studio"))) {
    UserSettings::Preferences::AiHost host;
    host.label = "LM Studio (local)";
    host.base_url = "http://localhost:1234";
    host.api_type = cli::kProviderLmStudio;
    host.supports_tools = true;
    host.supports_streaming = true;
    add_host(host);
  }
  ImGui::SameLine();
  if (ImGui::Button(tr("Add AFS Bridge"))) {
    UserSettings::Preferences::AiHost host;
    host.label = "halext AFS Bridge";
    host.base_url = "https://halext.org";
    host.api_type = cli::kProviderOpenAi;
    host.supports_tools = true;
    host.supports_streaming = true;
    add_host(host);
  }
  ImGui::SameLine();
  if (ImGui::Button(tr("Add Ollama"))) {
    UserSettings::Preferences::AiHost host;
    host.label = "Ollama (local)";
    host.base_url = "http://localhost:11434";
    host.api_type = cli::kProviderOllama;
    host.supports_tools = true;
    host.supports_streaming = true;
    add_host(host);
  }
 
  static std::string tailscale_host;
  ImGui::InputTextWithHint("##tailscale_host", "host.ts.net:1234",
                           &tailscale_host);
  ImGui::SameLine();
  if (ImGui::Button(tr("Add Tailscale Host"))) {
    std::string trimmed =
        std::string(absl::StripAsciiWhitespace(tailscale_host));
    if (!trimmed.empty()) {
      UserSettings::Preferences::AiHost host;
      host.label = "Tailscale Host";
      if (absl::StrContains(trimmed, "://")) {
        host.base_url = trimmed;
      } else {
        host.base_url = "http://" + trimmed;
      }
      host.api_type = cli::kProviderOpenAi;
      host.supports_tools = true;
      host.supports_streaming = true;
      host.allow_insecure = true;
      add_host(host);
      tailscale_host.clear();
    }
  }
 
  if (selected_host_index >= 0 &&
      selected_host_index < static_cast<int>(hosts.size())) {
    auto& host = hosts[static_cast<size_t>(selected_host_index)];
    ImGui::Spacing();
    ImGui::Text(tr("Host Details"));
    ImGui::Separator();
    if (ImGui::InputText(tr("Label"), &host.label)) {
      user_settings_->Save();
    }
    if (ImGui::InputText(tr("Base URL"), &host.base_url)) {
      user_settings_->Save();
    }
 
    const char* api_types[] = {"openai",    "ollama",   "gemini",
                               "anthropic", "lmstudio", "grpc"};
    int api_index = 0;
    for (int i = 0; i < IM_ARRAYSIZE(api_types); ++i) {
      if (host.api_type == api_types[i]) {
        api_index = i;
        break;
      }
    }
    if (ImGui::Combo(tr("API Type"), &api_index, api_types,
                     IM_ARRAYSIZE(api_types))) {
      host.api_type = api_types[api_index];
      user_settings_->Save();
    }
 
    if (ImGui::InputText(tr("API Key"), &host.api_key,
                         ImGuiInputTextFlags_Password)) {
      user_settings_->Save();
    }
    if (ImGui::InputText(tr("Keychain ID"), &host.credential_id)) {
      user_settings_->Save();
    }
    ImGui::SameLine();
    if (ImGui::SmallButton(tr("Use Host ID"))) {
      host.credential_id = host.id;
      user_settings_->Save();
    }
    if (!host.credential_id.empty() && host.api_key.empty()) {
      ImGui::TextDisabled(tr("Keychain lookup enabled (leave API key empty)."));
    }
 
    if (ImGui::Checkbox(tr("Supports Vision"), &host.supports_vision)) {
      user_settings_->Save();
    }
    ImGui::SameLine();
    if (ImGui::Checkbox(tr("Supports Tools"), &host.supports_tools)) {
      user_settings_->Save();
    }
    ImGui::SameLine();
    if (ImGui::Checkbox(tr("Supports Streaming"), &host.supports_streaming)) {
      user_settings_->Save();
    }
    if (ImGui::Checkbox(tr("Allow Insecure HTTP"), &host.allow_insecure)) {
      user_settings_->Save();
    }
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Local Model Paths"), ICON_MD_FOLDER);
  ImGui::Separator();
 
  auto& model_paths = prefs.ai_model_paths;
  static int selected_model_path = -1;
  static std::string new_model_path;
 
  if (model_paths.empty()) {
    ImGui::TextDisabled(tr("No model paths configured."));
  }
 
  const float model_paths_height = std::clamp(
      ImGui::GetContentRegionAvail().y * 0.24f, gui::ScaledSize(0.0f, 96.0f).y,
      gui::ScaledSize(0.0f, 180.0f).y);
  if (ImGui::BeginChild("ModelPathsList", ImVec2(0, model_paths_height),
                        true)) {
    for (size_t i = 0; i < model_paths.size(); ++i) {
      std::string label =
          util::PlatformPaths::NormalizePathForDisplay(model_paths[i]);
      if (ImGui::Selectable(label.c_str(),
                            selected_model_path == static_cast<int>(i))) {
        selected_model_path = static_cast<int>(i);
      }
    }
  }
  ImGui::EndChild();
 
  const bool has_model_selection =
      selected_model_path >= 0 &&
      selected_model_path < static_cast<int>(model_paths.size());
  if (has_model_selection) {
    if (ImGui::Button(ICON_MD_DELETE " Remove")) {
      model_paths.erase(model_paths.begin() + selected_model_path);
      selected_model_path =
          model_paths.empty()
              ? -1
              : std::min(selected_model_path,
                         static_cast<int>(model_paths.size() - 1));
      user_settings_->Save();
    }
  }
 
  ImGui::Spacing();
  ImGui::InputTextWithHint("##model_path_add", "Add folder path...",
                           &new_model_path);
  if (ImGui::Button(ICON_MD_ADD " Add Path")) {
    const std::string trimmed =
        std::string(absl::StripAsciiWhitespace(new_model_path));
    if (!trimmed.empty() && AddUniquePath(&model_paths, trimmed)) {
      user_settings_->Save();
      new_model_path.clear();
    }
  }
  ImGui::SameLine();
  if (ImGui::Button(ICON_MD_FOLDER_OPEN " Browse")) {
    const std::string folder = util::FileDialogWrapper::ShowOpenFolderDialog();
    if (!folder.empty() && AddUniquePath(&model_paths, folder)) {
      user_settings_->Save();
    }
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Quick Add"), ICON_MD_BOLT);
  ImGui::Separator();
  const auto home_dir = util::PlatformPaths::GetHomeDirectory();
  if (ImGui::Button(ICON_MD_HOME " Add ~/models")) {
    if (!home_dir.empty() && home_dir != ".") {
      if (AddUniquePath(&model_paths, (home_dir / "models").string())) {
        user_settings_->Save();
      }
    }
  }
  ImGui::SameLine();
  if (ImGui::Button(tr("Add ~/.lmstudio/models"))) {
    if (!home_dir.empty() && home_dir != ".") {
      if (AddUniquePath(&model_paths,
                        (home_dir / ".lmstudio" / "models").string())) {
        user_settings_->Save();
      }
    }
  }
  ImGui::SameLine();
  if (ImGui::Button(tr("Add ~/.ollama/models"))) {
    if (!home_dir.empty() && home_dir != ".") {
      if (AddUniquePath(&model_paths,
                        (home_dir / ".ollama" / "models").string())) {
        user_settings_->Save();
      }
    }
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Parameters"), ICON_MD_TUNE);
  ImGui::Separator();
 
  if (ImGui::SliderFloat(tr("Temperature"),
                         &user_settings_->prefs().ai_temperature, 0.0f, 2.0f)) {
    user_settings_->Save();
  }
  ImGui::TextDisabled(tr("Higher = more creative"));
 
  if (ImGui::SliderInt(tr("Max Tokens"), &user_settings_->prefs().ai_max_tokens,
                       256, 8192)) {
    user_settings_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Behavior"), ICON_MD_PSYCHOLOGY);
  ImGui::Separator();
 
  if (ImGui::Checkbox(tr("Proactive Suggestions"),
                      &user_settings_->prefs().ai_proactive)) {
    user_settings_->Save();
  }
 
  if (ImGui::Checkbox(tr("Auto-Learn Preferences"),
                      &user_settings_->prefs().ai_auto_learn)) {
    user_settings_->Save();
  }
 
  if (ImGui::Checkbox(tr("Enable Vision"),
                      &user_settings_->prefs().ai_multimodal)) {
    user_settings_->Save();
  }
 
  ImGui::Spacing();
  ImGui::Text(tr("%s Logging"), ICON_MD_TERMINAL);
  ImGui::Separator();
 
  const char* log_levels[] = {"Debug", "Info", "Warning", "Error", "Fatal"};
  if (ImGui::Combo(tr("Log Level"), &user_settings_->prefs().log_level,
                   log_levels, IM_ARRAYSIZE(log_levels))) {
    // Apply log level logic here if needed
    user_settings_->Save();
  }
}
 
void SettingsPanel::DrawKeyboardShortcuts() {
  if (ImGui::TreeNodeEx(ICON_MD_KEYBOARD " Shortcuts",
                        ImGuiTreeNodeFlags_DefaultOpen)) {
    ImGui::InputTextWithHint("##shortcut_filter", "Filter shortcuts...",
                             &shortcut_filter_);
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Filter by action name or key combo"));
    }
    ImGui::Spacing();
 
    if (ImGui::TreeNode("Global Shortcuts")) {
      DrawGlobalShortcuts();
      ImGui::TreePop();
    }
    if (ImGui::TreeNode("Editor Shortcuts")) {
      DrawEditorShortcuts();
      ImGui::TreePop();
    }
    if (ImGui::TreeNode("Panel Shortcuts")) {
      DrawPanelShortcuts();
      ImGui::TreePop();
    }
    ImGui::TextDisabled(
        tr("Tip: Use Cmd/Opt labels on macOS or Ctrl/Alt on Windows/Linux. "
           "Function keys and symbols (/, -) are supported."));
    ImGui::TreePop();
  }
}
 
bool SettingsPanel::MatchesShortcutFilter(const std::string& text) const {
  if (shortcut_filter_.empty()) {
    return true;
  }
  std::string haystack = absl::AsciiStrToLower(text);
  std::string needle = absl::AsciiStrToLower(shortcut_filter_);
  return absl::StrContains(haystack, needle);
}
 
namespace {
 
// One editable binding row: text field (Enter applies), conflict warning, and
// a reset button when the binding differs from its registered default.
// `overrides` is the persisted map for this scope (global_shortcuts or
// editor_shortcuts): absent = default, "" = explicitly unbound.
void DrawShortcutBindingRow(
    const Shortcut& sc, std::string& value, ShortcutManager* shortcut_manager,
    UserSettings* user_settings,
    std::unordered_map<std::string, std::string>& overrides) {
  ImGui::PushID(sc.name.c_str());
  ImGui::Text("%s", sc.name.c_str());
  ImGui::SameLine();
  ImGui::SetNextItemWidth(std::clamp(ImGui::GetContentRegionAvail().x * 0.45f,
                                     gui::ScaledSize(160.0f, 0.0f).x,
                                     gui::ScaledSize(300.0f, 0.0f).x));
  if (ImGui::InputText("##binding", &value,
                       ImGuiInputTextFlags_EnterReturnsTrue |
                           ImGuiInputTextFlags_AutoSelectAll)) {
    auto parsed = ParseShortcut(value);
    if (!parsed.empty() || value.empty()) {
      // Empty string unbinds the shortcut (persisted as "").
      shortcut_manager->UpdateShortcutKeys(sc.name, parsed);
      overrides[sc.name] = value;
      value = PrintShortcut(parsed);
      user_settings->Save();
    }
  }
 
  const Shortcut* live = shortcut_manager->FindShortcut(sc.name);
  if (live) {
    const auto conflicts = shortcut_manager->FindConflicts(sc.name);
    if (!conflicts.empty()) {
      ImGui::SameLine();
      ImGui::TextColored(gui::GetWarningColor(), ICON_MD_WARNING);
      if (ImGui::IsItemHovered()) {
        std::string tip = "Also bound to:";
        for (const auto& other : conflicts) {
          tip += "\n  " + other;
        }
        ImGui::SetTooltip("%s", tip.c_str());
      }
    }
    if (live->keys != live->default_keys) {
      ImGui::SameLine();
      if (ImGui::SmallButton(tr("Reset"))) {
        shortcut_manager->ResetShortcutKeys(sc.name);
        overrides.erase(sc.name);
        value = PrintShortcut(live->default_keys);
        user_settings->Save();
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip("Default: %s",
                          live->default_keys.empty()
                              ? "(none)"
                              : PrintShortcut(live->default_keys).c_str());
      }
    }
  }
  ImGui::PopID();
}
 
}  // namespace
 
void SettingsPanel::DrawGlobalShortcuts() {
  if (!shortcut_manager_ || !user_settings_) {
    ImGui::TextDisabled(tr("Not available"));
    return;
  }
 
  auto shortcuts =
      shortcut_manager_->GetShortcutsByScope(Shortcut::Scope::kGlobal);
  if (shortcuts.empty()) {
    ImGui::TextDisabled(tr("No global shortcuts registered."));
    return;
  }
  std::sort(
      shortcuts.begin(), shortcuts.end(),
      [](const Shortcut& a, const Shortcut& b) { return a.name < b.name; });
 
  static std::unordered_map<std::string, std::string> editing;
 
  bool has_match = false;
  for (const auto& sc : shortcuts) {
    if (sc.keys.empty() && sc.default_keys.empty()) {
      continue;  // Command-palette-only entry; nothing to bind here.
    }
    std::string keys = PrintShortcut(sc.keys);
    if (!MatchesShortcutFilter(sc.name) && !MatchesShortcutFilter(keys)) {
      continue;
    }
    has_match = true;
    auto it = editing.find(sc.name);
    if (it == editing.end()) {
      it = editing.emplace(sc.name, keys).first;
    }
    DrawShortcutBindingRow(sc, it->second, shortcut_manager_, user_settings_,
                           user_settings_->prefs().global_shortcuts);
  }
  if (!has_match) {
    ImGui::TextDisabled(tr("No shortcuts match the current filter."));
  }
}
 
void SettingsPanel::DrawEditorShortcuts() {
  if (!shortcut_manager_ || !user_settings_) {
    ImGui::TextDisabled(tr("Not available"));
    return;
  }
 
  auto shortcuts =
      shortcut_manager_->GetShortcutsByScope(Shortcut::Scope::kEditor);
  std::map<std::string, std::vector<Shortcut>> grouped;
  static std::unordered_map<std::string, std::string> editing;
 
  for (const auto& sc : shortcuts) {
    if (sc.keys.empty() && sc.default_keys.empty()) {
      continue;  // Command-palette-only entry; nothing to bind here.
    }
    auto pos = sc.name.find(".");
    std::string group =
        pos != std::string::npos ? sc.name.substr(0, pos) : "general";
    grouped[group].push_back(sc);
  }
  bool has_match = false;
  for (auto& [group, list] : grouped) {
    std::sort(
        list.begin(), list.end(),
        [](const Shortcut& a, const Shortcut& b) { return a.name < b.name; });
    std::vector<Shortcut> filtered;
    filtered.reserve(list.size());
    for (const auto& sc : list) {
      std::string keys = PrintShortcut(sc.keys);
      if (MatchesShortcutFilter(sc.name) || MatchesShortcutFilter(keys)) {
        filtered.push_back(sc);
      }
    }
    if (filtered.empty()) {
      continue;
    }
    has_match = true;
    if (ImGui::TreeNode(group.c_str())) {
      for (const auto& sc : filtered) {
        auto it = editing.find(sc.name);
        if (it == editing.end()) {
          it = editing.emplace(sc.name, PrintShortcut(sc.keys)).first;
        }
        DrawShortcutBindingRow(sc, it->second, shortcut_manager_,
                               user_settings_,
                               user_settings_->prefs().editor_shortcuts);
      }
      ImGui::TreePop();
    }
  }
  if (!has_match) {
    ImGui::TextDisabled(tr("No shortcuts match the current filter."));
  }
}
 
void SettingsPanel::DrawPanelShortcuts() {
  if (!window_manager_ || !user_settings_) {
    ImGui::TextDisabled(tr("Registry not available"));
    return;
  }
 
  // Simplified shortcut editor for sidebar
  auto categories = window_manager_->GetAllCategories();
 
  bool has_match = false;
  for (const auto& category : categories) {
    auto cards = window_manager_->GetWindowsInCategory(0, category);
    std::vector<decltype(cards)::value_type> filtered_cards;
    filtered_cards.reserve(cards.size());
    for (const auto& card : cards) {
      if (MatchesShortcutFilter(card.display_name) ||
          MatchesShortcutFilter(card.card_id)) {
        filtered_cards.push_back(card);
      }
    }
    if (filtered_cards.empty()) {
      continue;
    }
    has_match = true;
    if (ImGui::TreeNode(category.c_str())) {
 
      for (const auto& card : filtered_cards) {
        ImGui::PushID(card.card_id.c_str());
 
        ImGui::Text("%s %s", card.icon.c_str(), card.display_name.c_str());
 
        std::string current_shortcut;
        auto it = user_settings_->prefs().panel_shortcuts.find(card.card_id);
        if (it != user_settings_->prefs().panel_shortcuts.end()) {
          current_shortcut = it->second;
        } else if (!card.shortcut_hint.empty()) {
          current_shortcut = card.shortcut_hint;
        } else {
          current_shortcut = "None";
        }
 
        // Display platform-aware label
        std::string display_shortcut = current_shortcut;
        auto parsed = ParseShortcut(current_shortcut);
        if (!parsed.empty()) {
          display_shortcut = PrintShortcut(parsed);
        }
 
        if (is_editing_shortcut_ && editing_card_id_ == card.card_id) {
          ImGui::SetNextItemWidth(
              std::clamp(ImGui::GetContentRegionAvail().x * 0.40f,
                         gui::ScaledSize(100.0f, 0.0f).x,
                         gui::ScaledSize(220.0f, 0.0f).x));
          ImGui::SetKeyboardFocusHere();
          if (ImGui::InputText("##Edit", shortcut_edit_buffer_,
                               sizeof(shortcut_edit_buffer_),
                               ImGuiInputTextFlags_EnterReturnsTrue)) {
            if (strlen(shortcut_edit_buffer_) > 0) {
              user_settings_->prefs().panel_shortcuts[card.card_id] =
                  shortcut_edit_buffer_;
            } else {
              user_settings_->prefs().panel_shortcuts.erase(card.card_id);
            }
            user_settings_->Save();
            is_editing_shortcut_ = false;
            editing_card_id_.clear();
          }
          ImGui::SameLine();
          if (ImGui::Button(ICON_MD_CLOSE)) {
            is_editing_shortcut_ = false;
            editing_card_id_.clear();
          }
        } else {
          if (ImGui::Button(display_shortcut.c_str(), ImVec2(120, 0))) {
            is_editing_shortcut_ = true;
            editing_card_id_ = card.card_id;
            strncpy(shortcut_edit_buffer_, current_shortcut.c_str(),
                    sizeof(shortcut_edit_buffer_) - 1);
          }
          if (ImGui::IsItemHovered()) {
            ImGui::SetTooltip(tr("Click to edit shortcut"));
          }
        }
 
        ImGui::PopID();
      }
 
      ImGui::TreePop();
    }
  }
  if (!has_match) {
    ImGui::TextDisabled(tr("No shortcuts match the current filter."));
  }
}
 
void SettingsPanel::DrawPatchSettings() {
  // Load patches on first access
  if (!patches_loaded_) {
    // Try to load from default patches location
    auto patches_dir_status = util::PlatformPaths::FindAsset("patches");
    if (patches_dir_status.ok()) {
      auto status = patch_manager_.LoadPatches(patches_dir_status->string());
      if (status.ok()) {
        patches_loaded_ = true;
        if (!patch_manager_.folders().empty()) {
          selected_folder_ = patch_manager_.folders()[0];
        }
      }
    }
  }
 
  ImGui::Text(tr("%s ZScream Patch System"), ICON_MD_EXTENSION);
  ImGui::Separator();
 
  if (!patches_loaded_) {
    ImGui::TextDisabled(tr("No patches loaded"));
    ImGui::TextDisabled(tr("Place .asm patches in assets/patches/"));
 
    if (ImGui::Button(tr("Browse for Patches Folder..."))) {
      // TODO: File browser for patches folder
    }
    return;
  }
 
  // Status line
  int enabled_count = patch_manager_.GetEnabledPatchCount();
  int total_count = static_cast<int>(patch_manager_.patches().size());
  ImGui::Text(tr("Loaded: %d patches (%d enabled)"), total_count,
              enabled_count);
 
  ImGui::Spacing();
 
  // Folder tabs
  if (gui::BeginThemedTabBar("##PatchFolders",
                             ImGuiTabBarFlags_FittingPolicyScroll)) {
    for (const auto& folder : patch_manager_.folders()) {
      if (ImGui::BeginTabItem(folder.c_str())) {
        selected_folder_ = folder;
        DrawPatchList(folder);
        ImGui::EndTabItem();
      }
    }
    gui::EndThemedTabBar();
  }
 
  ImGui::Spacing();
  ImGui::Separator();
 
  // Selected patch details
  if (selected_patch_) {
    DrawPatchDetails();
  } else {
    ImGui::TextDisabled(tr("Select a patch to view details"));
  }
 
  ImGui::Spacing();
  ImGui::Separator();
 
  // Action buttons
  if (ImGui::Button(ICON_MD_CHECK " Apply Patches to ROM")) {
    if (rom_ && rom_->is_loaded()) {
#ifdef YAZE_WITH_Z3DK
      if (project_) {
        core::Z3dkAssembleOptions options;
        const auto& z3dk = project_->z3dk_settings;
        options.include_paths = z3dk.include_paths;
        options.defines = z3dk.defines;
        options.std_includes_path = z3dk.std_includes_path;
        options.std_defines_path = z3dk.std_defines_path;
        options.mapper = z3dk.mapper;
        options.rom_size = z3dk.rom_size;
        options.capture_nocash_symbols = (z3dk.symbols_format == "nocash");
        options.warn_unused_symbols = z3dk.warn_unused_symbols;
        options.warn_branch_outside_bank = z3dk.warn_branch_outside_bank;
        options.warn_unknown_width = z3dk.warn_unknown_width;
        options.warn_org_collision = z3dk.warn_org_collision;
        options.warn_unauthorized_hook = z3dk.warn_unauthorized_hook;
        options.warn_stack_balance = z3dk.warn_stack_balance;
        options.warn_hook_return = z3dk.warn_hook_return;
        for (const auto& range : z3dk.prohibited_memory_ranges) {
          options.prohibited_memory_ranges.push_back(
              {.start = range.start, .end = range.end, .reason = range.reason});
        }
        if (!project_->code_folder.empty() &&
            std::find(options.include_paths.begin(),
                      options.include_paths.end(),
                      project_->code_folder) == options.include_paths.end()) {
          options.include_paths.push_back(project_->code_folder);
        }
        if (!z3dk.rom_path.empty()) {
          options.hooks_rom_path = z3dk.rom_path;
        }
        if (!rom_->filename().empty()) {
          options.hooks_rom_path = rom_->filename();
        }
        patch_manager_.SetZ3dkAssembleOptions(options);
      }
#endif
      auto status = patch_manager_.ApplyEnabledPatches(rom_);
      if (!status.ok()) {
        LOG_ERROR("Settings", "Failed to apply patches: %s", status.message());
      } else {
        LOG_INFO("Settings", "Applied %d patches successfully", enabled_count);
      }
    } else {
      LOG_WARN("Settings", "No ROM loaded");
    }
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Apply all enabled patches to the loaded ROM"));
  }
 
  ImGui::SameLine();
  if (ImGui::Button(ICON_MD_SAVE " Save All")) {
    auto status = patch_manager_.SaveAllPatches();
    if (!status.ok()) {
      LOG_ERROR("Settings", "Failed to save patches: %s", status.message());
    }
  }
 
  if (ImGui::Button(ICON_MD_REFRESH " Reload Patches")) {
    patches_loaded_ = false;
    selected_patch_ = nullptr;
  }
}
 
void SettingsPanel::DrawPatchList(const std::string& folder) {
  auto patches = patch_manager_.GetPatchesInFolder(folder);
 
  if (patches.empty()) {
    ImGui::TextDisabled(tr("No patches in this folder"));
    return;
  }
 
  // Use a child region for scrolling
  float available_height = std::min(200.0f, patches.size() * 25.0f + 10.0f);
  if (ImGui::BeginChild("##PatchList", ImVec2(0, available_height), true)) {
    for (auto* patch : patches) {
      ImGui::PushID(patch->filename().c_str());
 
      bool enabled = patch->enabled();
      if (ImGui::Checkbox("##Enabled", &enabled)) {
        patch->set_enabled(enabled);
      }
 
      ImGui::SameLine();
 
      // Highlight selected patch
      bool is_selected = (selected_patch_ == patch);
      if (ImGui::Selectable(patch->name().c_str(), is_selected)) {
        selected_patch_ = patch;
      }
 
      ImGui::PopID();
    }
  }
  ImGui::EndChild();
}
 
void SettingsPanel::DrawPatchDetails() {
  if (!selected_patch_)
    return;
 
  ImGui::Text("%s %s", ICON_MD_INFO, selected_patch_->name().c_str());
 
  if (!selected_patch_->author().empty()) {
    ImGui::TextDisabled(tr("by %s"), selected_patch_->author().c_str());
  }
 
  if (!selected_patch_->version().empty()) {
    ImGui::SameLine();
    ImGui::TextDisabled(tr("v%s"), selected_patch_->version().c_str());
  }
 
  // Description
  if (!selected_patch_->description().empty()) {
    ImGui::Spacing();
    ImGui::TextWrapped("%s", selected_patch_->description().c_str());
  }
 
  // Parameters
  auto& params = selected_patch_->mutable_parameters();
  if (!params.empty()) {
    ImGui::Spacing();
    ImGui::Text(tr("%s Parameters"), ICON_MD_TUNE);
    ImGui::Separator();
 
    for (auto& param : params) {
      DrawParameterWidget(&param);
    }
  }
}
 
void SettingsPanel::DrawParameterWidget(core::PatchParameter* param) {
  if (!param)
    return;
 
  ImGui::PushID(param->define_name.c_str());
 
  switch (param->type) {
    case core::PatchParameterType::kByte:
    case core::PatchParameterType::kWord:
    case core::PatchParameterType::kLong: {
      int value = param->value;
      const char* format = param->use_decimal ? "%d" : "$%X";
 
      ImGui::Text("%s", param->display_name.c_str());
      ImGui::SetNextItemWidth(std::clamp(
          ImGui::GetContentRegionAvail().x * 0.50f,
          gui::ScaledSize(120.0f, 0.0f).x, gui::ScaledSize(260.0f, 0.0f).x));
      if (ImGui::InputInt("##Value", &value, 1, 16)) {
        param->value = std::clamp(value, param->min_value, param->max_value);
      }
 
      // Show range hint
      if (param->min_value != 0 || param->max_value != 0xFF) {
        ImGui::SameLine();
        ImGui::TextDisabled("(%d-%d)", param->min_value, param->max_value);
      }
      break;
    }
 
    case core::PatchParameterType::kBool: {
      bool checked = (param->value == param->checked_value);
      if (ImGui::Checkbox(param->display_name.c_str(), &checked)) {
        param->value = checked ? param->checked_value : param->unchecked_value;
      }
      break;
    }
 
    case core::PatchParameterType::kChoice: {
      ImGui::Text("%s", param->display_name.c_str());
      for (size_t i = 0; i < param->choices.size(); ++i) {
        bool selected = (param->value == static_cast<int>(i));
        if (ImGui::RadioButton(param->choices[i].c_str(), selected)) {
          param->value = static_cast<int>(i);
        }
      }
      break;
    }
 
    case core::PatchParameterType::kBitfield: {
      ImGui::Text("%s", param->display_name.c_str());
      for (size_t i = 0; i < param->choices.size(); ++i) {
        if (param->choices[i].empty() || param->choices[i] == "_EMPTY") {
          continue;
        }
        bool bit_set = (param->value & (1 << i)) != 0;
        if (ImGui::Checkbox(param->choices[i].c_str(), &bit_set)) {
          if (bit_set) {
            param->value |= (1 << i);
          } else {
            param->value &= ~(1 << i);
          }
        }
      }
      break;
    }
 
    case core::PatchParameterType::kItem: {
      ImGui::Text("%s", param->display_name.c_str());
      // TODO: Implement item dropdown using game item names
      ImGui::SetNextItemWidth(-1.0f);
      if (ImGui::InputInt(tr("Item ID"), &param->value)) {
        param->value = std::clamp(param->value, 0, 255);
      }
      break;
    }
  }
 
  ImGui::PopID();
  ImGui::Spacing();
}
 
}  // namespace editor
}  // namespace yaze