theme_manager.cc

Go to the documentation of this file.

#include "theme_manager.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <cctype>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <set>
#include <sstream>
 
#include "absl/strings/str_format.h"
#include "absl/strings/str_split.h"
#include "app/gui/core/agent_theme.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/style.h"  // For ColorsYaze function
#include "imgui/imgui.h"
#include "nlohmann/json.hpp"
#include "util/file_util.h"
#include "util/log.h"
#include "util/platform_paths.h"
 
namespace yaze {
namespace gui {
 
// Helper function to create Color from RGB values
Color RGB(float r, float g, float b, float a = 1.0f) {
  return {r / 255.0f, g / 255.0f, b / 255.0f, a};
}
 
Color RGBA(int r, int g, int b, int a = 255) {
  return {r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f};
}
 
// Scales the spacing metrics already present in ImGui's style by `factor`.
// Used only after ColorsYaze(), whose values are Classic YAZE's identity and
// must be scaled in place rather than recomputed from the shared base.
void ScaleCurrentStyleSpacing(float factor) {
  if (factor == 1.0f) {
    return;
  }
  ImGuiStyle* style = &ImGui::GetStyle();
  style->WindowPadding.x *= factor;
  style->WindowPadding.y *= factor;
  style->FramePadding.x *= factor;
  style->FramePadding.y *= factor;
  style->CellPadding.x *= factor;
  style->CellPadding.y *= factor;
  style->ItemSpacing.x *= factor;
  style->ItemSpacing.y *= factor;
  style->ItemInnerSpacing.x *= factor;
  style->ItemInnerSpacing.y *= factor;
  style->IndentSpacing *= factor;
  style->ScrollbarSize *= factor;
  style->GrabMinSize *= factor;
}
 
Theme BuildClassicYazeTheme() {
  Theme classic_theme;
  classic_theme.name = "Classic YAZE";
  classic_theme.description =
      "Original YAZE theme (direct ColorsYaze() function)";
  classic_theme.author = "YAZE Team";
 
  classic_theme.primary = RGBA(92, 115, 92);
  classic_theme.secondary = RGBA(71, 92, 71);
  classic_theme.accent = RGBA(89, 119, 89);
  classic_theme.background = RGBA(8, 8, 8);
 
  classic_theme.text_primary = RGBA(230, 230, 230);
  classic_theme.text_disabled = RGBA(153, 153, 153);
  classic_theme.window_bg = RGBA(8, 8, 8, 217);
  classic_theme.child_bg = RGBA(0, 0, 0, 0);
  classic_theme.popup_bg = RGBA(28, 28, 36, 235);
 
  classic_theme.button = RGBA(71, 92, 71);
  classic_theme.button_hovered = RGBA(125, 146, 125);
  classic_theme.button_active = RGBA(92, 115, 92);
  classic_theme.header = RGBA(46, 66, 46);
  classic_theme.header_hovered = RGBA(92, 115, 92);
  classic_theme.header_active = RGBA(71, 92, 71);
  classic_theme.menu_bar_bg = RGBA(46, 66, 46);
  classic_theme.tab = RGBA(46, 66, 46);
  classic_theme.tab_hovered = RGBA(71, 92, 71);
  classic_theme.tab_active = RGBA(89, 119, 89);
  classic_theme.tab_unfocused = RGBA(37, 52, 37);
  classic_theme.tab_unfocused_active = RGBA(62, 83, 62);
  classic_theme.title_bg = RGBA(71, 92, 71);
  classic_theme.title_bg_active = RGBA(46, 66, 46);
  classic_theme.title_bg_collapsed = RGBA(71, 92, 71);
 
  classic_theme.surface = classic_theme.background;
  classic_theme.error = RGBA(220, 50, 50);
  classic_theme.warning = RGBA(255, 200, 50);
  classic_theme.success = classic_theme.primary;
  classic_theme.info = RGBA(70, 170, 255);
  classic_theme.text_secondary = RGBA(200, 200, 200);
  classic_theme.modal_bg = classic_theme.popup_bg;
 
  classic_theme.border = RGBA(92, 115, 92);
  classic_theme.border_shadow = RGBA(0, 0, 0, 0);
  classic_theme.separator = RGBA(128, 128, 128, 153);
  classic_theme.separator_hovered = RGBA(153, 153, 178);
  classic_theme.separator_active = RGBA(178, 178, 230);
 
  classic_theme.scrollbar_bg = RGBA(92, 115, 92, 153);
  classic_theme.scrollbar_grab = RGBA(92, 115, 92, 76);
  classic_theme.scrollbar_grab_hovered = RGBA(92, 115, 92, 102);
  classic_theme.scrollbar_grab_active = RGBA(92, 115, 92, 153);
 
  classic_theme.frame_bg = RGBA(46, 66, 46, 140);
  classic_theme.frame_bg_hovered = RGBA(71, 92, 71, 170);
  classic_theme.frame_bg_active = RGBA(92, 115, 92, 200);
  classic_theme.resize_grip = RGBA(92, 115, 92, 80);
  classic_theme.resize_grip_hovered = RGBA(125, 146, 125, 180);
  classic_theme.resize_grip_active = RGBA(125, 146, 125, 255);
  classic_theme.check_mark = RGBA(125, 255, 125, 255);
  classic_theme.slider_grab = RGBA(92, 115, 92, 255);
  classic_theme.slider_grab_active = RGBA(125, 146, 125, 255);
  classic_theme.input_text_cursor = RGBA(255, 255, 255, 255);
  classic_theme.nav_cursor = RGBA(125, 146, 125, 255);
  classic_theme.nav_windowing_highlight = RGBA(92, 115, 92, 200);
  classic_theme.nav_windowing_dim_bg = RGBA(0, 0, 0, 150);
  classic_theme.modal_window_dim_bg = RGBA(0, 0, 0, 128);
  classic_theme.text_selected_bg = RGBA(92, 115, 92, 128);
  classic_theme.drag_drop_target = RGBA(125, 146, 125, 200);
  classic_theme.table_header_bg = RGBA(46, 66, 46);
  classic_theme.table_border_strong = RGBA(71, 92, 71);
  classic_theme.table_border_light = RGBA(66, 66, 71);
  classic_theme.table_row_bg = RGBA(0, 0, 0, 0);
  classic_theme.table_row_bg_alt = RGBA(255, 255, 255, 18);
  classic_theme.text_link = classic_theme.accent;
  classic_theme.plot_lines = RGBA(255, 255, 255);
  classic_theme.plot_lines_hovered = RGBA(230, 178, 0);
  classic_theme.plot_histogram = RGBA(230, 178, 0);
  classic_theme.plot_histogram_hovered = RGBA(255, 153, 0);
  classic_theme.docking_preview = RGBA(92, 115, 92, 180);
  classic_theme.docking_empty_bg = RGBA(46, 66, 46, 255);
  classic_theme.tree_lines = classic_theme.separator;
  classic_theme.tab_dimmed = RGBA(37, 52, 37);
  classic_theme.tab_dimmed_selected = RGBA(62, 83, 62);
  classic_theme.tab_dimmed_selected_overline = classic_theme.accent;
  classic_theme.tab_selected_overline = classic_theme.accent;
 
  classic_theme.text_highlight = RGBA(255, 255, 150);
  classic_theme.link_hover = RGBA(140, 220, 255);
  classic_theme.code_background = RGBA(40, 60, 40);
  classic_theme.success_light = RGBA(140, 195, 140);
  classic_theme.warning_light = RGBA(255, 220, 100);
  classic_theme.error_light = RGBA(255, 150, 150);
  classic_theme.info_light = RGBA(150, 200, 255);
 
  classic_theme.active_selection = classic_theme.accent;
  classic_theme.hover_highlight = RGBA(92, 115, 92, 100);
  classic_theme.focus_border = classic_theme.primary;
  classic_theme.disabled_overlay = RGBA(50, 50, 50, 128);
  classic_theme.editor_background = RGBA(30, 45, 30);
  classic_theme.editor_grid = RGBA(80, 100, 80, 100);
  classic_theme.editor_cursor = RGBA(255, 255, 255);
  classic_theme.editor_selection = RGBA(110, 145, 110, 100);
 
  classic_theme.window_rounding = 0.0f;
  classic_theme.frame_rounding = 5.0f;
  classic_theme.scrollbar_rounding = 5.0f;
  classic_theme.grab_rounding = 5.0f;
  classic_theme.tab_rounding = 0.0f;
  classic_theme.enable_glow_effects = false;
 
  return classic_theme;
}
 
// Theme Implementation
void Theme::ApplyToImGui() const {
  ImGuiStyle* style = &ImGui::GetStyle();
  ImVec4* colors = style->Colors;
 
  // Apply colors
  colors[ImGuiCol_Text] = ConvertColorToImVec4(text_primary);
  colors[ImGuiCol_TextDisabled] = ConvertColorToImVec4(text_disabled);
  colors[ImGuiCol_WindowBg] = ConvertColorToImVec4(window_bg);
  colors[ImGuiCol_ChildBg] = ConvertColorToImVec4(child_bg);
  colors[ImGuiCol_PopupBg] = ConvertColorToImVec4(popup_bg);
  colors[ImGuiCol_Border] = ConvertColorToImVec4(border);
  colors[ImGuiCol_BorderShadow] = ConvertColorToImVec4(border_shadow);
  colors[ImGuiCol_FrameBg] = ConvertColorToImVec4(frame_bg);
  colors[ImGuiCol_FrameBgHovered] = ConvertColorToImVec4(frame_bg_hovered);
  colors[ImGuiCol_FrameBgActive] = ConvertColorToImVec4(frame_bg_active);
  colors[ImGuiCol_TitleBg] = ConvertColorToImVec4(title_bg);
  colors[ImGuiCol_TitleBgActive] = ConvertColorToImVec4(title_bg_active);
  colors[ImGuiCol_TitleBgCollapsed] = ConvertColorToImVec4(title_bg_collapsed);
  colors[ImGuiCol_MenuBarBg] = ConvertColorToImVec4(menu_bar_bg);
  colors[ImGuiCol_ScrollbarBg] = ConvertColorToImVec4(scrollbar_bg);
  colors[ImGuiCol_ScrollbarGrab] = ConvertColorToImVec4(scrollbar_grab);
  colors[ImGuiCol_ScrollbarGrabHovered] =
      ConvertColorToImVec4(scrollbar_grab_hovered);
  colors[ImGuiCol_ScrollbarGrabActive] =
      ConvertColorToImVec4(scrollbar_grab_active);
  colors[ImGuiCol_Button] = ConvertColorToImVec4(button);
  colors[ImGuiCol_ButtonHovered] = ConvertColorToImVec4(button_hovered);
  colors[ImGuiCol_ButtonActive] = ConvertColorToImVec4(button_active);
  colors[ImGuiCol_Header] = ConvertColorToImVec4(header);
  colors[ImGuiCol_HeaderHovered] = ConvertColorToImVec4(header_hovered);
  colors[ImGuiCol_HeaderActive] = ConvertColorToImVec4(header_active);
  colors[ImGuiCol_Separator] = ConvertColorToImVec4(separator);
  colors[ImGuiCol_SeparatorHovered] = ConvertColorToImVec4(separator_hovered);
  colors[ImGuiCol_SeparatorActive] = ConvertColorToImVec4(separator_active);
  colors[ImGuiCol_ResizeGrip] = ConvertColorToImVec4(resize_grip);
  colors[ImGuiCol_ResizeGripHovered] =
      ConvertColorToImVec4(resize_grip_hovered);
  colors[ImGuiCol_ResizeGripActive] = ConvertColorToImVec4(resize_grip_active);
  colors[ImGuiCol_Tab] = ConvertColorToImVec4(tab);
  colors[ImGuiCol_TabHovered] = ConvertColorToImVec4(tab_hovered);
  colors[ImGuiCol_TabSelected] = ConvertColorToImVec4(tab_active);
  colors[ImGuiCol_TabUnfocused] = ConvertColorToImVec4(tab_unfocused);
  colors[ImGuiCol_TabUnfocusedActive] =
      ConvertColorToImVec4(tab_unfocused_active);
  colors[ImGuiCol_DockingPreview] = ConvertColorToImVec4(docking_preview);
  colors[ImGuiCol_DockingEmptyBg] = ConvertColorToImVec4(docking_empty_bg);
 
  // Complete ImGui color support
  colors[ImGuiCol_CheckMark] = ConvertColorToImVec4(check_mark);
  colors[ImGuiCol_SliderGrab] = ConvertColorToImVec4(slider_grab);
  colors[ImGuiCol_SliderGrabActive] = ConvertColorToImVec4(slider_grab_active);
  colors[ImGuiCol_InputTextCursor] = ConvertColorToImVec4(input_text_cursor);
  colors[ImGuiCol_NavCursor] = ConvertColorToImVec4(nav_cursor);
  colors[ImGuiCol_NavWindowingHighlight] =
      ConvertColorToImVec4(nav_windowing_highlight);
  colors[ImGuiCol_NavWindowingDimBg] =
      ConvertColorToImVec4(nav_windowing_dim_bg);
  colors[ImGuiCol_ModalWindowDimBg] = ConvertColorToImVec4(modal_window_dim_bg);
  colors[ImGuiCol_TextSelectedBg] = ConvertColorToImVec4(text_selected_bg);
  colors[ImGuiCol_DragDropTarget] = ConvertColorToImVec4(drag_drop_target);
  colors[ImGuiCol_TableHeaderBg] = ConvertColorToImVec4(table_header_bg);
  colors[ImGuiCol_TableBorderStrong] =
      ConvertColorToImVec4(table_border_strong);
  colors[ImGuiCol_TableBorderLight] = ConvertColorToImVec4(table_border_light);
  colors[ImGuiCol_TableRowBg] = ConvertColorToImVec4(table_row_bg);
  colors[ImGuiCol_TableRowBgAlt] = ConvertColorToImVec4(table_row_bg_alt);
  colors[ImGuiCol_TextLink] = ConvertColorToImVec4(text_link);
  colors[ImGuiCol_PlotLines] = ConvertColorToImVec4(plot_lines);
  colors[ImGuiCol_PlotLinesHovered] = ConvertColorToImVec4(plot_lines_hovered);
  colors[ImGuiCol_PlotHistogram] = ConvertColorToImVec4(plot_histogram);
  colors[ImGuiCol_PlotHistogramHovered] =
      ConvertColorToImVec4(plot_histogram_hovered);
  colors[ImGuiCol_TreeLines] = ConvertColorToImVec4(tree_lines);
 
  // Additional ImGui colors for complete coverage
  colors[ImGuiCol_TabDimmed] = ConvertColorToImVec4(tab_dimmed);
  colors[ImGuiCol_TabDimmedSelected] =
      ConvertColorToImVec4(tab_dimmed_selected);
  colors[ImGuiCol_TabDimmedSelectedOverline] =
      ConvertColorToImVec4(tab_dimmed_selected_overline);
  colors[ImGuiCol_TabSelectedOverline] =
      ConvertColorToImVec4(tab_selected_overline);
 
  // Apply style parameters
  style->WindowRounding = window_rounding;
  style->ChildRounding =
      window_rounding * 0.5f;  // Consistent with window rounding
  style->FrameRounding = frame_rounding;
  style->PopupRounding = frame_rounding;
  style->ScrollbarRounding = scrollbar_rounding;
  style->GrabRounding = grab_rounding;
  style->TabRounding = tab_rounding;
  style->WindowBorderSize = window_border_size;
  style->ChildBorderSize = frame_border_size;
  style->PopupBorderSize = window_border_size;
  style->FrameBorderSize = frame_border_size;
  style->TabBorderSize = frame_border_size;
 
  ApplyDensitySizingToImGui();
}
 
void Theme::ApplyDensitySizingToImGui() const {
  ImGuiStyle* style = &ImGui::GetStyle();
  float base_spacing = 8.0f * compact_factor;
  style->WindowPadding = ImVec2(base_spacing, base_spacing);
  style->FramePadding = ImVec2(base_spacing * 0.5f, base_spacing * 0.375f);
  style->CellPadding = ImVec2(base_spacing * 0.5f, base_spacing * 0.25f);
  style->ItemSpacing = ImVec2(base_spacing, base_spacing * 0.5f);
  style->ItemInnerSpacing = ImVec2(base_spacing * 0.5f, base_spacing * 0.5f);
  style->IndentSpacing = base_spacing * 2.5f;
  style->ScrollbarSize = 14.0f * compact_factor;
  style->GrabMinSize = 12.0f * compact_factor;
}
 
void Theme::ApplyDensityPreset(DensityPreset preset) {
  density_preset = preset;
 
  switch (preset) {
    case DensityPreset::kCompact:
      compact_factor = 0.75f;
      widget_height_multiplier = 0.85f;
      spacing_multiplier = 0.7f;
      toolbar_height_multiplier = 0.65f;
      panel_padding_multiplier = 0.75f;
      button_padding_multiplier = 0.8f;
      table_row_height_multiplier = 0.85f;
      canvas_toolbar_multiplier = 0.6f;
      break;
 
    case DensityPreset::kNormal:
      compact_factor = 1.0f;
      widget_height_multiplier = 1.0f;
      spacing_multiplier = 1.0f;
      toolbar_height_multiplier = 0.8f;
      panel_padding_multiplier = 1.0f;
      button_padding_multiplier = 1.0f;
      table_row_height_multiplier = 1.0f;
      canvas_toolbar_multiplier = 0.75f;
      break;
 
    case DensityPreset::kComfortable:
      compact_factor = 1.25f;
      widget_height_multiplier = 1.2f;
      spacing_multiplier = 1.3f;
      toolbar_height_multiplier = 1.0f;
      panel_padding_multiplier = 1.25f;
      button_padding_multiplier = 1.2f;
      table_row_height_multiplier = 1.2f;
      canvas_toolbar_multiplier = 0.9f;
      break;
  }
}
 
// ThemeManager Implementation
ThemeManager& ThemeManager::Get() {
  static ThemeManager instance;
  return instance;
}
 
void ThemeManager::InitializeBuiltInThemes() {
  // This runs inside the ThemeManager singleton constructor. Anything that
  // calls ThemeManager::Get() from here (transitively) hits __cxa_guard_acquire
  // recursively and aborts. The flag lets ApplyClassicYazeTheme skip the
  // AgentUI palette refresh until the constructor finishes.
  initializing_built_ins_ = true;
 
  // Always create fallback theme first
  CreateFallbackYazeClassic();
 
  // Create the Classic YAZE theme during initialization
  ApplyClassicYazeTheme();
 
  // Load all available theme files dynamically
  auto status = LoadAllAvailableThemes();
  if (!status.ok()) {
    LOG_ERROR("Theme Manager", "Failed to load some theme files");
  }
 
  initializing_built_ins_ = false;
 
  // Ensure we have a valid current theme (Classic is already set above)
  // Only fallback to file themes if Classic creation failed
  if (current_theme_name_ != "Classic YAZE") {
    if (themes_.find("YAZE Tre") != themes_.end()) {
      current_theme_ = themes_["YAZE Tre"];
      current_theme_name_ = "YAZE Tre";
    }
  }
}
 
void ThemeManager::CreateFallbackYazeClassic() {
  // Fallback theme that matches the original ColorsYaze() function colors but
  // in theme format
  Theme theme;
  theme.name = "YAZE Tre";
  theme.description = "YAZE theme resource edition";
  theme.author = "YAZE Team";
 
  // Use the exact original ColorsYaze colors
  theme.primary = RGBA(92, 115, 92);   // allttpLightGreen
  theme.secondary = RGBA(71, 92, 71);  // alttpMidGreen
  theme.accent = RGBA(89, 119, 89);    // TabActive
  theme.background =
      RGBA(8, 8, 8);  // Very dark gray for better grid visibility
 
  theme.text_primary = RGBA(230, 230, 230);   // 0.90f, 0.90f, 0.90f
  theme.text_disabled = RGBA(153, 153, 153);  // 0.60f, 0.60f, 0.60f
  theme.window_bg = RGBA(8, 8, 8, 217);       // Very dark gray with same alpha
  theme.child_bg = RGBA(0, 0, 0, 0);          // Transparent
  theme.popup_bg = RGBA(28, 28, 36, 235);     // 0.11f, 0.11f, 0.14f, 0.92f
 
  theme.button = RGBA(71, 92, 71);             // alttpMidGreen
  theme.button_hovered = RGBA(125, 146, 125);  // allttpLightestGreen
  theme.button_active = RGBA(92, 115, 92);     // allttpLightGreen
 
  theme.header = RGBA(46, 66, 46);           // alttpDarkGreen
  theme.header_hovered = RGBA(92, 115, 92);  // allttpLightGreen
  theme.header_active = RGBA(71, 92, 71);    // alttpMidGreen
 
  theme.menu_bar_bg = RGBA(46, 66, 46);    // alttpDarkGreen
  theme.tab = RGBA(46, 66, 46);            // alttpDarkGreen
  theme.tab_hovered = RGBA(71, 92, 71);    // alttpMidGreen
  theme.tab_active = RGBA(89, 119, 89);    // TabActive
  theme.tab_unfocused = RGBA(37, 52, 37);  // Darker version of tab
  theme.tab_unfocused_active =
      RGBA(62, 83, 62);  // Darker version of tab_active
 
  // Complete all remaining ImGui colors from original ColorsYaze() function
  theme.title_bg = RGBA(71, 92, 71);            // alttpMidGreen
  theme.title_bg_active = RGBA(46, 66, 46);     // alttpDarkGreen
  theme.title_bg_collapsed = RGBA(71, 92, 71);  // alttpMidGreen
 
  // Initialize missing fields that were added to the struct
  theme.surface = theme.background;
  theme.error = RGBA(220, 50, 50);
  theme.warning = RGBA(255, 200, 50);
  theme.success = theme.primary;
  theme.info = RGBA(70, 170, 255);
  theme.text_secondary = RGBA(200, 200, 200);
  theme.modal_bg = theme.popup_bg;
 
  // Borders and separators
  theme.border = RGBA(92, 115, 92);               // allttpLightGreen
  theme.border_shadow = RGBA(0, 0, 0, 0);         // Transparent
  theme.separator = RGBA(128, 128, 128, 153);     // 0.50f, 0.50f, 0.50f, 0.60f
  theme.separator_hovered = RGBA(153, 153, 178);  // 0.60f, 0.60f, 0.70f
  theme.separator_active = RGBA(178, 178, 230);   // 0.70f, 0.70f, 0.90f
 
  // Scrollbars
  theme.scrollbar_bg = RGBA(92, 115, 92, 153);   // 0.36f, 0.45f, 0.36f, 0.60f
  theme.scrollbar_grab = RGBA(92, 115, 92, 76);  // 0.36f, 0.45f, 0.36f, 0.30f
  theme.scrollbar_grab_hovered =
      RGBA(92, 115, 92, 102);  // 0.36f, 0.45f, 0.36f, 0.40f
  theme.scrollbar_grab_active =
      RGBA(92, 115, 92, 153);  // 0.36f, 0.45f, 0.36f, 0.60f
 
  // Resize grips (from original - light blue highlights)
  theme.resize_grip = RGBA(255, 255, 255, 26);  // 1.00f, 1.00f, 1.00f, 0.10f
  theme.resize_grip_hovered =
      RGBA(199, 209, 255, 153);  // 0.78f, 0.82f, 1.00f, 0.60f
  theme.resize_grip_active =
      RGBA(199, 209, 255, 230);  // 0.78f, 0.82f, 1.00f, 0.90f
 
  // ENHANCED: Complete ImGui colors with theme-aware smart defaults
  // Use theme colors instead of hardcoded values for consistency
  theme.check_mark =
      RGBA(125, 255, 125, 255);  // Bright green checkmark (highly visible!)
  theme.slider_grab = RGBA(92, 115, 92, 255);  // Theme green (solid)
  theme.slider_grab_active =
      RGBA(125, 146, 125, 255);  // Lighter green when active
  theme.input_text_cursor =
      RGBA(255, 255, 255, 255);                 // White cursor (always visible)
  theme.nav_cursor = RGBA(125, 146, 125, 255);  // Light green for navigation
  theme.nav_windowing_highlight =
      RGBA(89, 119, 89, 200);  // Accent with high visibility
  theme.nav_windowing_dim_bg =
      RGBA(0, 0, 0, 150);  // Darker overlay for better contrast
  theme.modal_window_dim_bg = RGBA(0, 0, 0, 128);  // 50% alpha for modals
  theme.text_selected_bg = RGBA(
      92, 115, 92, 128);  // Theme green with 50% alpha (visible selection!)
  theme.drag_drop_target =
      RGBA(125, 146, 125, 200);  // Bright green for drop zones
 
  // Table colors (from original)
  theme.table_header_bg = RGBA(46, 66, 46);      // alttpDarkGreen
  theme.table_border_strong = RGBA(71, 92, 71);  // alttpMidGreen
  theme.table_border_light = RGBA(66, 66, 71);   // 0.26f, 0.26f, 0.28f
  theme.table_row_bg = RGBA(0, 0, 0, 0);         // Transparent
  theme.table_row_bg_alt =
      RGBA(255, 255, 255, 18);  // 1.00f, 1.00f, 1.00f, 0.07f
 
  // Links and plots - use accent colors intelligently
  theme.text_link = theme.accent;                    // Accent for links
  theme.plot_lines = RGBA(255, 255, 255);            // White for plots
  theme.plot_lines_hovered = RGBA(230, 178, 0);      // 0.90f, 0.70f, 0.00f
  theme.plot_histogram = RGBA(230, 178, 0);          // Same as above
  theme.plot_histogram_hovered = RGBA(255, 153, 0);  // 1.00f, 0.60f, 0.00f
 
  // Docking colors
  theme.docking_preview =
      RGBA(92, 115, 92, 180);  // Light green with transparency
  theme.docking_empty_bg = RGBA(46, 66, 46, 255);  // Dark green
 
  // Editor-specific colors
  theme.editor_background = RGBA(30, 45, 30);  // Dark green background
  theme.editor_grid = RGBA(80, 100, 80, 100);  // Subtle grid lines
  theme.editor_cursor = RGBA(255, 255, 255);   // White cursor
  theme.editor_selection =
      RGBA(110, 145, 110, 100);  // Semi-transparent selection
 
  // Unified selection and interaction colors
  theme.selection_primary = RGBA(255, 230, 51, 204);    // Yellow
  theme.selection_secondary = RGBA(51, 230, 255, 204);  // Cyan
  theme.selection_hover = RGBA(255, 255, 255, 100);    // Semi-transparent white
  theme.selection_pulsing = RGBA(255, 255, 255, 204);  // White pulse
  theme.selection_handle = RGBA(255, 255, 255, 255);   // White handle
  theme.drag_preview = RGBA(128, 128, 255, 102);       // Blueish
  theme.drag_preview_outline = RGBA(153, 153, 255, 204);
 
  // Common entity colors
  theme.entrance_color = RGBA(51, 255, 51, 200);     // Green
  theme.hole_color = RGBA(255, 51, 255, 200);        // Magenta
  theme.exit_color = RGBA(255, 51, 51, 200);         // Red
  theme.item_color = RGBA(255, 214, 0, 200);         // Gold
  theme.sprite_color = RGBA(51, 153, 255, 200);      // Blue
  theme.transport_color = RGBA(153, 102, 255, 200);  // Purple
  theme.music_zone_color = RGBA(255, 153, 51, 200);  // Orange
 
  // Dungeon editor colors
  theme.dungeon.selection_primary = RGBA(255, 230, 51, 153);    // Yellow
  theme.dungeon.selection_secondary = RGBA(51, 230, 255, 153);  // Cyan
  theme.dungeon.selection_pulsing = RGBA(255, 255, 255, 204);   // White pulse
  theme.dungeon.selection_handle = RGBA(255, 255, 255, 255);    // White handle
  theme.dungeon.drag_preview = RGBA(128, 128, 255, 102);        // Blueish
  theme.dungeon.drag_preview_outline = RGBA(153, 153, 255, 204);
  theme.dungeon.object_wall = RGBA(153, 153, 153, 255);
  theme.dungeon.object_floor = RGBA(102, 102, 102, 255);
  theme.dungeon.object_chest = RGBA(255, 214, 0, 255);  // Gold
  theme.dungeon.object_door = RGBA(140, 69, 18, 255);
  theme.dungeon.object_pot = RGBA(204, 102, 51, 255);
  theme.dungeon.object_stairs = RGBA(230, 230, 77, 255);
  theme.dungeon.object_decoration = RGBA(153, 204, 153, 255);
  theme.dungeon.object_default = RGBA(204, 204, 204, 255);
  theme.dungeon.grid_cell_highlight = RGBA(77, 204, 77, 77);
  theme.dungeon.grid_cell_selected = RGBA(51, 179, 51, 128);
  theme.dungeon.grid_cell_border = RGBA(102, 102, 102, 128);
  theme.dungeon.grid_text = RGBA(255, 255, 255, 204);
  theme.dungeon.room_border = RGBA(128, 128, 128, 255);
  theme.dungeon.room_border_dark = RGBA(51, 51, 51, 255);
  theme.dungeon.sprite_layer0 = RGBA(77, 204, 77, 255);  // Green
  theme.dungeon.sprite_layer1 = RGBA(77, 77, 204, 255);  // Blue
  theme.dungeon.sprite_layer2 = RGBA(77, 77, 204, 255);
  theme.dungeon.outline_layer0 = RGBA(255, 51, 51, 255);  // Red
  theme.dungeon.outline_layer1 = RGBA(51, 255, 51, 255);  // Green
  theme.dungeon.outline_layer2 = RGBA(51, 51, 255, 255);  // Blue
 
  // Chat/agent colors
  theme.agent.user_message = RGBA(102, 179, 255, 255);
  theme.agent.agent_message = RGBA(102, 230, 102, 255);
  theme.agent.system_message = RGBA(179, 179, 179, 255);
  theme.agent.text_secondary = theme.text_secondary;
  theme.agent.json_text = RGBA(230, 179, 102, 255);
  theme.agent.command_text = RGBA(230, 102, 102, 255);
  theme.agent.code_background = RGBA(26, 26, 31, 255);
 
  theme.agent.panel_bg = theme.child_bg;
  theme.agent.panel_bg_darker = RGBA(0, 0, 0, 50);
  theme.agent.panel_border = RGBA(92, 115, 92, 115);
  theme.agent.accent = theme.accent;
 
  theme.agent.status_active = theme.success;
  theme.agent.status_inactive = theme.text_disabled;
  theme.agent.status_success = theme.success;
  theme.agent.status_warning = theme.warning;
  theme.agent.status_error = theme.error;
 
  theme.agent.provider_ollama = RGBA(230, 230, 230, 255);
  theme.agent.provider_gemini = RGBA(77, 153, 230, 255);
  theme.agent.provider_mock = RGBA(128, 128, 128, 255);
  theme.agent.provider_openai =
      RGBA(51, 204, 153, 255);  // Teal/green for OpenAI
 
  theme.agent.collaboration_active = theme.success;
  theme.agent.collaboration_inactive = theme.text_disabled;
 
  theme.agent.proposal_panel_bg = RGBA(38, 38, 46, 255);
  theme.agent.proposal_accent = RGBA(102, 153, 230, 255);
  theme.agent.button_copy = RGBA(77, 77, 89, 255);
  theme.agent.button_copy_hover = RGBA(102, 102, 115, 255);
  theme.agent.gradient_top = theme.primary;
  theme.agent.gradient_bottom = theme.secondary;
 
  // Apply original style settings
  theme.window_rounding = 0.0f;
  theme.frame_rounding = 5.0f;
  theme.scrollbar_rounding = 5.0f;
  theme.tab_rounding = 0.0f;
  theme.enable_glow_effects = false;
 
  // Hydrate semantic/interaction defaults so the fallback matches the
  // file-backed theme when LoadThemeFromFile can't reach assets/themes/
  // (e.g. test binaries whose working directory doesn't contain the bundle).
  ApplySmartDefaults(theme);
 
  themes_["YAZE Tre"] = theme;
  current_theme_ = theme;
  current_theme_name_ = "YAZE Tre";
}
 
absl::Status ThemeManager::LoadTheme(const std::string& theme_name) {
  auto it = themes_.find(theme_name);
  if (it == themes_.end()) {
    return absl::NotFoundError(
        absl::StrFormat("Theme '%s' not found", theme_name));
  }
 
  current_theme_ = it->second;
  current_theme_name_ = theme_name;
  current_theme_.ApplyToImGui();
  // Keep AgentUI-derived palettes in lockstep with active theme selection.
  editor::AgentUI::RefreshTheme();
  // Cancel any in-progress color transition so the requested theme applies
  // immediately and doesn't get overridden by UpdateTransition().
  transitioning_ = false;
  transition_progress_ = 0.0f;
  NotifyThemeChanged();
 
  return absl::OkStatus();
}
 
void ThemeManager::NotifyThemeChanged() {
  // Suppress during preview so hover-over-theme-names doesn't churn persistence
  // to disk. EndPreview() fires once the original theme is restored.
  if (preview_active_) {
    return;
  }
  if (on_theme_changed_) {
    on_theme_changed_(current_theme_name_);
  }
}
 
absl::Status ThemeManager::LoadThemeFromFile(const std::string& filepath) {
  // Try multiple possible paths where theme files might be located
  std::vector<std::string> possible_paths = {filepath};  // Absolute path
  // Prefer the robust asset search (exe-dir, ~/.yaze, /usr/share, repo-relative)
  // so installed/double-click launches resolve bundled themes too.
  if (auto found = util::PlatformPaths::FindAsset("themes/" + filepath);
      found.ok()) {
    possible_paths.push_back(found->string());
  }
  possible_paths.push_back("assets/themes/" + filepath);  // Relative build dir
  possible_paths.push_back("../assets/themes/" + filepath);  // Relative bin dir
  possible_paths.push_back(util::GetResourcePath(
      "assets/themes/" + filepath));  // Platform-specific resource path
 
  std::ifstream file;
  std::string successful_path;
 
  for (const auto& path : possible_paths) {
    file.open(path);
    if (file.is_open()) {
      successful_path = path;
      break;
    } else {
      file.clear();  // Clear any error flags before trying next path
    }
  }
 
  if (!file.is_open()) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Cannot open theme file: %s (tried %zu paths)",
                        filepath, possible_paths.size()));
  }
 
  std::string content((std::istreambuf_iterator<char>(file)),
                      std::istreambuf_iterator<char>());
  file.close();
 
  if (content.empty()) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Theme file is empty: %s", successful_path));
  }
 
  Theme theme;
  std::set<std::string> declared_keys;
  auto parse_status = ParseThemeFile(content, theme, &declared_keys);
  if (!parse_status.ok()) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Failed to parse theme file %s: %s", successful_path,
                        parse_status.message()));
  }
 
  if (theme.name.empty()) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Theme file missing name: %s", successful_path));
  }
 
  // Fill in any missing properties with smart defaults, leaving alone every
  // field the file named — including ones it deliberately set to black.
  ApplySmartDefaults(theme, declared_keys);
 
  themes_[theme.name] = theme;
  // Remember where the theme came from. Display-name-derived paths won't round-
  // trip for presets like "Majora's Moon" (filename: majoras_moon.theme) or
  // "Tokyo Night" (tokyo_night.theme); GetCurrentThemeFilePath consults this
  // map first so "Save Over Current" works without guessing.
  theme_file_paths_[theme.name] = successful_path;
  return absl::OkStatus();
}
 
std::vector<std::string> ThemeManager::GetAvailableThemes() const {
  std::vector<std::string> theme_names = {"Classic YAZE"};
  for (const auto& [name, theme] : themes_) {
    if (name != "Classic YAZE") {
      theme_names.push_back(name);
    }
  }
  return theme_names;
}
 
const Theme* ThemeManager::GetTheme(const std::string& name) const {
  if (name == "Classic YAZE") {
    static const Theme classic_theme = BuildClassicYazeTheme();
    return &classic_theme;
  }
  auto it = themes_.find(name);
  return (it != themes_.end()) ? &it->second : nullptr;
}
 
void ThemeManager::ApplyTheme(const std::string& theme_name) {
  // Classic YAZE is intentionally kept out of themes_ (see ApplyClassicYazeTheme
  // for the off-by-one note). Route by name so callers — including the restore
  // path in EditorManager::Initialize — don't silently fall back to YAZE Tre.
  if (theme_name == "Classic YAZE") {
    ApplyClassicYazeTheme();
    return;
  }
 
  auto status = LoadTheme(theme_name);
  if (!status.ok()) {
    // Missing or stale saved themes should land on the stable built-in
    // default, not the experimental file-backed theme.
    ApplyClassicYazeTheme();
  }
}
 
void ThemeManager::ReapplyTheme(const Theme& theme) {
  if (theme.name == "Classic YAZE") {
    ApplyClassicYazeTheme(theme.density_preset);
    return;
  }
  ApplyTheme(theme);
}
 
void ThemeManager::ApplyTheme(const Theme& theme) {
  // Capture current ImGui colors as transition start
  const bool should_transition =
      current_theme_.enable_animations && !preview_active_;
 
  if (should_transition) {
    ImVec4* colors = ImGui::GetStyle().Colors;
    for (int idx = 0; idx < ImGuiCol_COUNT; ++idx) {
      transition_from_[idx] = colors[idx];
    }
  }
 
  current_theme_ = theme;
  current_theme_name_ = theme.name;  // CRITICAL: Update the name tracking
  current_theme_.ApplyToImGui();
 
  if (should_transition) {
    // Capture the target colors after applying
    ImVec4* colors = ImGui::GetStyle().Colors;
    for (int idx = 0; idx < ImGuiCol_COUNT; ++idx) {
      transition_to_[idx] = colors[idx];
    }
    // Restore the starting colors — UpdateTransition() will lerp toward target
    for (int idx = 0; idx < ImGuiCol_COUNT; ++idx) {
      colors[idx] = transition_from_[idx];
    }
    transitioning_ = true;
    transition_progress_ = 0.0f;
  } else {
    // Ensure non-transition theme changes are not overridden by a previous
    // transition in progress (e.g. selecting a theme while a density transition
    // is running, or starting a live preview).
    transitioning_ = false;
    transition_progress_ = 0.0f;
  }
 
  // Keep AgentUI theme cache in sync with the new theme colors.
  editor::AgentUI::RefreshTheme();
  NotifyThemeChanged();
}
 
void ThemeManager::UpdateTransition() {
  if (!transitioning_) {
    return;
  }
 
  const float delta_time = ImGui::GetIO().DeltaTime;
  constexpr float kTransitionSpeed = 4.0f;  // ~250ms to complete
 
  transition_progress_ += delta_time * kTransitionSpeed;
  if (transition_progress_ >= 1.0f) {
    transition_progress_ = 1.0f;
    transitioning_ = false;
  }
 
  // Smooth ease-out curve: t' = 1 - (1 - t)^2
  const float eased =
      1.0f - (1.0f - transition_progress_) * (1.0f - transition_progress_);
 
  ImVec4* colors = ImGui::GetStyle().Colors;
  for (int idx = 0; idx < ImGuiCol_COUNT; ++idx) {
    colors[idx].x = transition_from_[idx].x +
                    (transition_to_[idx].x - transition_from_[idx].x) * eased;
    colors[idx].y = transition_from_[idx].y +
                    (transition_to_[idx].y - transition_from_[idx].y) * eased;
    colors[idx].z = transition_from_[idx].z +
                    (transition_to_[idx].z - transition_from_[idx].z) * eased;
    colors[idx].w = transition_from_[idx].w +
                    (transition_to_[idx].w - transition_from_[idx].w) * eased;
  }
}
 
Color ThemeManager::GetWelcomeScreenBackground() const {
  // Create a darker version of the window background for welcome screen
  Color bg = current_theme_.window_bg;
  return {bg.red * 0.8f, bg.green * 0.8f, bg.blue * 0.8f, bg.alpha};
}
 
Color ThemeManager::GetWelcomeScreenBorder() const {
  return current_theme_.accent;
}
 
Color ThemeManager::GetWelcomeScreenAccent() const {
  return current_theme_.primary;
}
 
void ThemeManager::ShowThemeSelector(bool* p_open) {
  if (!p_open || !*p_open)
    return;
 
  if (ImGui::Begin(
          absl::StrFormat("%s Theme Selector", ICON_MD_PALETTE).c_str(),
          p_open)) {
    // Add subtle particle effects to theme selector
    static float theme_animation_time = 0.0f;
    theme_animation_time += ImGui::GetIO().DeltaTime;
 
    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    ImVec2 window_pos = ImGui::GetWindowPos();
    ImVec2 window_size = ImGui::GetWindowSize();
 
    // Subtle corner particles for theme selector
    for (int i = 0; i < 4; ++i) {
      float corner_offset = i * 1.57f;  // 90 degrees apart
      float x = window_pos.x + window_size.x * 0.5f +
                cosf(theme_animation_time * 0.8f + corner_offset) *
                    (window_size.x * 0.4f);
      float y = window_pos.y + window_size.y * 0.5f +
                sinf(theme_animation_time * 0.8f + corner_offset) *
                    (window_size.y * 0.4f);
 
      float alpha =
          0.1f + 0.1f * sinf(theme_animation_time * 1.2f + corner_offset);
      auto current_theme = GetCurrentTheme();
      ImU32 particle_color = ImGui::ColorConvertFloat4ToU32(
          ImVec4(current_theme.accent.red, current_theme.accent.green,
                 current_theme.accent.blue, alpha));
 
      draw_list->AddCircleFilled(ImVec2(x, y), 3.0f, particle_color);
    }
 
    ImGui::Text(tr("%s Available Themes"), ICON_MD_COLOR_LENS);
    ImGui::Separator();
 
    // Add Classic YAZE button first (direct ColorsYaze() application)
    bool is_classic_active = (current_theme_name_ == "Classic YAZE");
    if (is_classic_active) {
      ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.36f, 0.45f, 0.36f,
                                                    1.0f));  // allttpLightGreen
    }
 
    if (ImGui::Button(
            absl::StrFormat("%s YAZE Classic (Original)",
                            is_classic_active ? ICON_MD_CHECK : ICON_MD_STAR)
                .c_str(),
            ImVec2(-1, 50))) {
      ApplyClassicYazeTheme();
    }
 
    if (is_classic_active) {
      ImGui::PopStyleColor();
    }
 
    if (ImGui::IsItemHovered()) {
      ImGui::BeginTooltip();
      ImGui::Text(tr("Original YAZE theme using ColorsYaze() function"));
      ImGui::Text(
          tr("This is the authentic classic look - direct function call"));
      ImGui::EndTooltip();
    }
 
    ImGui::Separator();
 
    // Sort themes alphabetically for consistent ordering (by name only)
    std::vector<std::string> sorted_theme_names;
    for (const auto& [name, theme] : themes_) {
      sorted_theme_names.push_back(name);
    }
    std::sort(sorted_theme_names.begin(), sorted_theme_names.end());
 
    // Track if any theme item is hovered for live preview
    bool any_theme_hovered = false;
    static std::string hovered_theme_name;
 
    for (const auto& name : sorted_theme_names) {
      const auto& theme = themes_.at(name);
      bool is_current = (name == current_theme_name_) ||
                        (IsPreviewActive() && name == hovered_theme_name);
 
      if (is_current) {
        ImGui::PushStyleColor(ImGuiCol_Button,
                              ConvertColorToImVec4(theme.accent));
      }
 
      if (ImGui::Button(
              absl::StrFormat("%s %s",
                              is_current ? ICON_MD_CHECK : ICON_MD_CIRCLE,
                              name.c_str())
                  .c_str(),
              ImVec2(-1, 40))) {
        // End preview before applying (to restore original first)
        if (IsPreviewActive()) {
          EndPreview();
        }
        ApplyTheme(name);
      }
 
      // Check hover state for live preview
      bool button_hovered = ImGui::IsItemHovered();
 
      if (is_current) {
        ImGui::PopStyleColor();
      }
 
      // Show theme preview colors
      ImGui::SameLine();
      ImGui::ColorButton(absl::StrFormat("##primary_%s", name.c_str()).c_str(),
                         ConvertColorToImVec4(theme.primary),
                         ImGuiColorEditFlags_NoTooltip, ImVec2(20, 20));
      bool color1_hovered = ImGui::IsItemHovered();
      ImGui::SameLine();
      ImGui::ColorButton(
          absl::StrFormat("##secondary_%s", name.c_str()).c_str(),
          ConvertColorToImVec4(theme.secondary), ImGuiColorEditFlags_NoTooltip,
          ImVec2(20, 20));
      bool color2_hovered = ImGui::IsItemHovered();
      ImGui::SameLine();
      ImGui::ColorButton(absl::StrFormat("##accent_%s", name.c_str()).c_str(),
                         ConvertColorToImVec4(theme.accent),
                         ImGuiColorEditFlags_NoTooltip, ImVec2(20, 20));
      bool color3_hovered = ImGui::IsItemHovered();
 
      // If hovering any part of this theme row, show tooltip and trigger preview
      bool row_hovered =
          button_hovered || color1_hovered || color2_hovered || color3_hovered;
 
      if (row_hovered) {
        any_theme_hovered = true;
        hovered_theme_name = name;
 
        // Start preview if not already previewing this theme
        if (!IsPreviewActive() || current_theme_name_ != name) {
          StartPreview(name);
        }
 
        ImGui::BeginTooltip();
        ImGui::Text("%s %s", ICON_MD_PREVIEW, "Live Preview Active");
        ImGui::Separator();
        ImGui::Text("%s", theme.description.c_str());
        ImGui::Text(tr("Author: %s"), theme.author.c_str());
        ImGui::EndTooltip();
      }
    }
 
    // End preview if no theme is hovered
    if (!any_theme_hovered && IsPreviewActive()) {
      EndPreview();
      hovered_theme_name.clear();
    }
 
    ImGui::Separator();
    if (ImGui::Button(
            absl::StrFormat("%s Refresh Themes", ICON_MD_REFRESH).c_str())) {
      auto status = RefreshAvailableThemes();
      if (!status.ok()) {
        LOG_ERROR("Theme Manager", "Failed to refresh themes");
      }
    }
 
    ImGui::SameLine();
    if (ImGui::Button(
            absl::StrFormat("%s Load Custom Theme", ICON_MD_FOLDER_OPEN)
                .c_str())) {
      auto file_path = util::FileDialogWrapper::ShowOpenFileDialog();
      if (!file_path.empty()) {
        auto status = LoadThemeFromFile(file_path);
        if (!status.ok()) {
          // Show error toast (would need access to toast manager)
        }
      }
    }
 
    ImGui::SameLine();
    static bool show_simple_editor = false;
    if (ImGui::Button(
            absl::StrFormat("%s Theme Editor", ICON_MD_EDIT).c_str())) {
      show_simple_editor = true;
    }
 
    if (ImGui::IsItemHovered()) {
      ImGui::BeginTooltip();
      ImGui::Text(tr("Edit and save custom themes"));
      ImGui::Text(tr("Includes 'Save to File' functionality"));
      ImGui::EndTooltip();
    }
 
    if (show_simple_editor) {
      ShowSimpleThemeEditor(&show_simple_editor);
    }
  }
  ImGui::End();
}
 
absl::Status ThemeManager::ParseThemeFile(
    const std::string& content, Theme& theme,
    std::set<std::string>* declared_keys) {
  std::istringstream stream(content);
  std::string line;
  std::string current_section;
 
  while (std::getline(stream, line)) {
    // Skip empty lines and comments
    if (line.empty() || line[0] == '#') {
      continue;
    }
 
    // Check for section headers [section_name]
    if (line[0] == '[' && line.back() == ']') {
      current_section = line.substr(1, line.length() - 2);
      continue;
    }
 
    size_t eq_pos = line.find('=');
    if (eq_pos == std::string::npos) {
      continue;
    }
 
    std::string key = line.substr(0, eq_pos);
    std::string value = line.substr(eq_pos + 1);
 
    // Trim whitespace and comments
    key.erase(0, key.find_first_not_of(" \t"));
    key.erase(key.find_last_not_of(" \t") + 1);
    value.erase(0, value.find_first_not_of(" \t"));
 
    // Remove inline comments
    size_t comment_pos = value.find('#');
    if (comment_pos != std::string::npos) {
      value = value.substr(0, comment_pos);
    }
    value.erase(value.find_last_not_of(" \t") + 1);
 
    // Record what the file actually named, before any section dispatch. Keys
    // are unique across sections here, so one set is enough.
    if (declared_keys != nullptr) {
      declared_keys->insert(key);
    }
 
    // Parse based on section
    if (current_section == "colors") {
      Color color = ParseColorFromString(value);
 
      if (key == "primary")
        theme.primary = color;
      else if (key == "secondary")
        theme.secondary = color;
      else if (key == "accent")
        theme.accent = color;
      else if (key == "background")
        theme.background = color;
      else if (key == "surface")
        theme.surface = color;
      else if (key == "error")
        theme.error = color;
      else if (key == "warning")
        theme.warning = color;
      else if (key == "success")
        theme.success = color;
      else if (key == "info")
        theme.info = color;
      else if (key == "text_primary")
        theme.text_primary = color;
      else if (key == "text_secondary")
        theme.text_secondary = color;
      else if (key == "text_disabled")
        theme.text_disabled = color;
      else if (key == "window_bg")
        theme.window_bg = color;
      else if (key == "child_bg")
        theme.child_bg = color;
      else if (key == "popup_bg")
        theme.popup_bg = color;
      else if (key == "button")
        theme.button = color;
      else if (key == "button_hovered")
        theme.button_hovered = color;
      else if (key == "button_active")
        theme.button_active = color;
      else if (key == "frame_bg")
        theme.frame_bg = color;
      else if (key == "frame_bg_hovered")
        theme.frame_bg_hovered = color;
      else if (key == "frame_bg_active")
        theme.frame_bg_active = color;
      else if (key == "header")
        theme.header = color;
      else if (key == "header_hovered")
        theme.header_hovered = color;
      else if (key == "header_active")
        theme.header_active = color;
      else if (key == "tab")
        theme.tab = color;
      else if (key == "tab_hovered")
        theme.tab_hovered = color;
      else if (key == "tab_active")
        theme.tab_active = color;
      else if (key == "menu_bar_bg")
        theme.menu_bar_bg = color;
      else if (key == "title_bg")
        theme.title_bg = color;
      else if (key == "title_bg_active")
        theme.title_bg_active = color;
      else if (key == "title_bg_collapsed")
        theme.title_bg_collapsed = color;
      else if (key == "separator")
        theme.separator = color;
      else if (key == "separator_hovered")
        theme.separator_hovered = color;
      else if (key == "separator_active")
        theme.separator_active = color;
      else if (key == "scrollbar_bg")
        theme.scrollbar_bg = color;
      else if (key == "scrollbar_grab")
        theme.scrollbar_grab = color;
      else if (key == "scrollbar_grab_hovered")
        theme.scrollbar_grab_hovered = color;
      else if (key == "scrollbar_grab_active")
        theme.scrollbar_grab_active = color;
      else if (key == "border")
        theme.border = color;
      else if (key == "border_shadow")
        theme.border_shadow = color;
      else if (key == "resize_grip")
        theme.resize_grip = color;
      else if (key == "resize_grip_hovered")
        theme.resize_grip_hovered = color;
      else if (key == "resize_grip_active")
        theme.resize_grip_active = color;
      else if (key == "check_mark")
        theme.check_mark = color;
      else if (key == "slider_grab")
        theme.slider_grab = color;
      else if (key == "slider_grab_active")
        theme.slider_grab_active = color;
      else if (key == "input_text_cursor")
        theme.input_text_cursor = color;
      else if (key == "nav_cursor")
        theme.nav_cursor = color;
      else if (key == "nav_windowing_highlight")
        theme.nav_windowing_highlight = color;
      else if (key == "nav_windowing_dim_bg")
        theme.nav_windowing_dim_bg = color;
      else if (key == "modal_window_dim_bg")
        theme.modal_window_dim_bg = color;
      else if (key == "text_selected_bg")
        theme.text_selected_bg = color;
      else if (key == "drag_drop_target")
        theme.drag_drop_target = color;
      else if (key == "table_header_bg")
        theme.table_header_bg = color;
      else if (key == "table_border_strong")
        theme.table_border_strong = color;
      else if (key == "table_border_light")
        theme.table_border_light = color;
      else if (key == "table_row_bg")
        theme.table_row_bg = color;
      else if (key == "table_row_bg_alt")
        theme.table_row_bg_alt = color;
      else if (key == "text_link")
        theme.text_link = color;
      else if (key == "plot_lines")
        theme.plot_lines = color;
      else if (key == "plot_lines_hovered")
        theme.plot_lines_hovered = color;
      else if (key == "plot_histogram")
        theme.plot_histogram = color;
      else if (key == "plot_histogram_hovered")
        theme.plot_histogram_hovered = color;
      else if (key == "tree_lines")
        theme.tree_lines = color;
      else if (key == "tab_dimmed")
        theme.tab_dimmed = color;
      else if (key == "tab_dimmed_selected")
        theme.tab_dimmed_selected = color;
      else if (key == "tab_dimmed_selected_overline")
        theme.tab_dimmed_selected_overline = color;
      else if (key == "tab_selected_overline")
        theme.tab_selected_overline = color;
      else if (key == "text_highlight")
        theme.text_highlight = color;
      else if (key == "link_hover")
        theme.link_hover = color;
      else if (key == "code_background")
        theme.code_background = color;
      else if (key == "success_light")
        theme.success_light = color;
      else if (key == "warning_light")
        theme.warning_light = color;
      else if (key == "error_light")
        theme.error_light = color;
      else if (key == "info_light")
        theme.info_light = color;
      else if (key == "active_selection")
        theme.active_selection = color;
      else if (key == "hover_highlight")
        theme.hover_highlight = color;
      else if (key == "focus_border")
        theme.focus_border = color;
      else if (key == "disabled_overlay")
        theme.disabled_overlay = color;
      else if (key == "editor_background")
        theme.editor_background = color;
      else if (key == "editor_grid")
        theme.editor_grid = color;
      else if (key == "editor_cursor")
        theme.editor_cursor = color;
      else if (key == "editor_selection")
        theme.editor_selection = color;
      else if (key == "docking_preview")
        theme.docking_preview = color;
      else if (key == "docking_empty_bg")
        theme.docking_empty_bg = color;
    } else if (current_section == "style") {
      // A malformed number must not throw: themes load from the ThemeManager
      // singleton's constructor, where an exception ends the process. Keep the
      // field's current value instead.
      auto parse_float = [](const std::string& text, float fallback) -> float {
        try {
          return std::stof(text);
        } catch (const std::exception&) {
          return fallback;
        }
      };
      if (key == "window_rounding")
        theme.window_rounding = parse_float(value, theme.window_rounding);
      else if (key == "frame_rounding")
        theme.frame_rounding = parse_float(value, theme.frame_rounding);
      else if (key == "scrollbar_rounding")
        theme.scrollbar_rounding = parse_float(value, theme.scrollbar_rounding);
      else if (key == "grab_rounding")
        theme.grab_rounding = parse_float(value, theme.grab_rounding);
      else if (key == "tab_rounding")
        theme.tab_rounding = parse_float(value, theme.tab_rounding);
      else if (key == "window_border_size")
        theme.window_border_size = parse_float(value, theme.window_border_size);
      else if (key == "frame_border_size")
        theme.frame_border_size = parse_float(value, theme.frame_border_size);
      else if (key == "enable_animations")
        theme.enable_animations = (value == "true");
      else if (key == "enable_glow_effects")
        theme.enable_glow_effects = (value == "true");
      else if (key == "animation_speed")
        theme.animation_speed = parse_float(value, theme.animation_speed);
    } else if (current_section == "" || current_section == "metadata") {
      // Top-level metadata
      if (key == "name")
        theme.name = value;
      else if (key == "description")
        theme.description = value;
      else if (key == "author")
        theme.author = value;
    }
  }
 
  return absl::OkStatus();
}
 
void ThemeManager::ApplySmartDefaults(
    Theme& theme, const std::set<std::string>& declared_keys) {
  // A key absent from a .theme file leaves its field default-constructed, and
  // Color declares `alpha = 1.0f`, so an omitted field reads as opaque black
  // rather than transparent black. Detecting "unset" by value alone therefore
  // cannot distinguish an omitted field from one the author deliberately set
  // to black — and the parser accepts black for text, backgrounds and borders,
  // where it is an entirely reasonable choice on a light or OLED theme.
  //
  // So the value test only applies to fields the file did NOT declare. Callers
  // that build a Theme in code (Classic YAZE, GenerateThemeFromAccent) pass no
  // declared keys, which is correct: nothing was declared, so every field with
  // a default-looking value is genuinely unset.
  auto declared = [&declared_keys](const char* key) {
    return key != nullptr && declared_keys.count(key) != 0;
  };
  auto looks_default = [](const Color& color) {
    return color.red == 0.0f && color.green == 0.0f && color.blue == 0.0f &&
           (color.alpha == 0.0f || color.alpha == 1.0f);
  };
  auto is_unset = [&](const Color& color, const char* key = nullptr) {
    return !declared(key) && looks_default(color);
  };
  // Legacy theme files often omit newer semantic fields, which then remain at
  // default-constructed opaque black. Treat that as "missing" for
  // semantic/interaction colors to avoid black overlays and handles.
  auto needs_semantic_default = [&](const Color& color,
                                    const char* key = nullptr) {
    return is_unset(color, key);
  };
 
  // Seed the five source colors FIRST. Around twenty fields below derive from
  // accent/error/warning/success/info, but nothing guaranteed those were set:
  // a theme file that omits `info` handed black to text_link, plot_histogram,
  // text_highlight, info_light and selection_secondary. Every shipped preset
  // declares all five, which is why this never surfaced — a minimal or
  // hand-written theme is not so lucky.
  //
  // The status colors are fixed rather than accent-derived on purpose: red
  // means error and green means success regardless of the theme's hue, which
  // ThemeGeneratorTest.StatusColorsAreStableAcrossAccents pins. Values match
  // GenerateThemeFromAccent so both paths agree.
  if (is_unset(theme.accent, "accent")) {
    theme.accent = is_unset(theme.primary, "primary")
                       ? Color{0.35f, 0.70f, 0.95f, 1.0f}
                       : theme.primary;
  }
  if (is_unset(theme.error, "error")) {
    theme.error = Color{0.90f, 0.30f, 0.30f, 1.0f};
  }
  if (is_unset(theme.warning, "warning")) {
    theme.warning = Color{0.95f, 0.75f, 0.25f, 1.0f};
  }
  if (is_unset(theme.success, "success")) {
    theme.success = Color{0.30f, 0.85f, 0.45f, 1.0f};
  }
  if (is_unset(theme.info, "info")) {
    theme.info = Color{0.35f, 0.70f, 0.95f, 1.0f};
  }
 
  // Helper to create a color with modified alpha
  auto with_alpha = [](const Color& color, float alpha) {
    return Color{color.red, color.green, color.blue, alpha};
  };
 
  // Helper to lighten a color
  auto lighten = [](const Color& color, float amount) {
    return Color{std::min(1.0f, color.red + amount),
                 std::min(1.0f, color.green + amount),
                 std::min(1.0f, color.blue + amount), color.alpha};
  };
 
  // Helper to darken a color
  auto darken = [](const Color& color, float amount) {
    return Color{std::max(0.0f, color.red - amount),
                 std::max(0.0f, color.green - amount),
                 std::max(0.0f, color.blue - amount), color.alpha};
  };
  auto darken_with_floor = [](const Color& color, float amount,
                              float floor = 0.03f) {
    return Color{std::max(floor, color.red - amount),
                 std::max(floor, color.green - amount),
                 std::max(floor, color.blue - amount), color.alpha};
  };
  auto is_effectively_transparent = [](const Color& color) {
    return color.alpha <= 0.01f;
  };
 
  // Borders and separators
  if (is_unset(theme.border, "border")) {
    theme.border = theme.primary;
  }
  if (is_unset(theme.border_shadow, "border_shadow")) {
    theme.border_shadow = RGBA(0, 0, 0, 0);
  }
  if (is_unset(theme.separator, "separator")) {
    theme.separator = with_alpha(theme.secondary, 0.6f);
  }
  if (is_unset(theme.separator_hovered, "separator_hovered")) {
    theme.separator_hovered = with_alpha(theme.primary, 0.8f);
  }
  if (is_unset(theme.separator_active, "separator_active")) {
    theme.separator_active = theme.accent;
  }
 
  // Scrollbars
  if (is_unset(theme.scrollbar_bg, "scrollbar_bg")) {
    theme.scrollbar_bg = with_alpha(theme.surface, 0.6f);
  }
  if (is_unset(theme.scrollbar_grab, "scrollbar_grab")) {
    theme.scrollbar_grab = with_alpha(theme.secondary, 0.5f);
  }
  if (is_unset(theme.scrollbar_grab_hovered, "scrollbar_grab_hovered")) {
    theme.scrollbar_grab_hovered = with_alpha(theme.secondary, 0.7f);
  }
  if (is_unset(theme.scrollbar_grab_active, "scrollbar_grab_active")) {
    theme.scrollbar_grab_active = with_alpha(theme.secondary, 0.9f);
  }
 
  // Resize grips
  if (is_unset(theme.resize_grip, "resize_grip")) {
    theme.resize_grip = RGBA(255, 255, 255, 26);
  }
  if (is_unset(theme.resize_grip_hovered, "resize_grip_hovered")) {
    theme.resize_grip_hovered = with_alpha(theme.accent, 0.6f);
  }
  if (is_unset(theme.resize_grip_active, "resize_grip_active")) {
    theme.resize_grip_active = with_alpha(theme.accent, 0.9f);
  }
 
  // Controls
  if (is_unset(theme.check_mark, "check_mark")) {
    theme.check_mark = lighten(theme.accent, 0.2f);
  }
  if (is_unset(theme.slider_grab, "slider_grab")) {
    theme.slider_grab = theme.primary;
  }
  if (is_unset(theme.slider_grab_active, "slider_grab_active")) {
    theme.slider_grab_active = theme.accent;
  }
 
  // Tables
  if (is_unset(theme.table_header_bg, "table_header_bg")) {
    theme.table_header_bg = theme.header;
  }
  if (is_unset(theme.table_border_strong, "table_border_strong")) {
    theme.table_border_strong = theme.secondary;
  }
  if (is_unset(theme.table_border_light, "table_border_light")) {
    theme.table_border_light = with_alpha(theme.surface, 0.5f);
  }
  if (is_unset(theme.table_row_bg, "table_row_bg")) {
    theme.table_row_bg = RGBA(0, 0, 0, 0);
  }
  if (is_unset(theme.table_row_bg_alt, "table_row_bg_alt")) {
    theme.table_row_bg_alt = RGBA(255, 255, 255, 20);
  }
 
  // Links
  if (is_unset(theme.text_link, "text_link")) {
    theme.text_link = theme.info;
  }
 
  // Plots. No .theme file ships these, so without a fallback every preset
  // draws ImGui plots and histograms in opaque black.
  if (is_unset(theme.plot_lines, "plot_lines")) {
    theme.plot_lines = theme.accent;
  }
  if (is_unset(theme.plot_lines_hovered, "plot_lines_hovered")) {
    theme.plot_lines_hovered = lighten(theme.accent, 0.15f);
  }
  if (is_unset(theme.plot_histogram, "plot_histogram")) {
    theme.plot_histogram = theme.info;
  }
  if (is_unset(theme.plot_histogram_hovered, "plot_histogram_hovered")) {
    theme.plot_histogram_hovered = lighten(theme.info, 0.15f);
  }
 
  // Navigation and special elements
  if (is_unset(theme.input_text_cursor, "input_text_cursor")) {
    theme.input_text_cursor = theme.text_primary;
  }
  if (is_unset(theme.nav_cursor, "nav_cursor")) {
    theme.nav_cursor = theme.accent;
  }
  if (is_unset(theme.nav_windowing_highlight, "nav_windowing_highlight")) {
    theme.nav_windowing_highlight = with_alpha(theme.accent, 0.8f);
  }
  if (is_unset(theme.nav_windowing_dim_bg, "nav_windowing_dim_bg")) {
    theme.nav_windowing_dim_bg = RGBA(0, 0, 0, 128);
  }
  if (is_unset(theme.modal_window_dim_bg, "modal_window_dim_bg")) {
    theme.modal_window_dim_bg = RGBA(0, 0, 0, 100);
  }
  if (is_unset(theme.text_selected_bg, "text_selected_bg")) {
    theme.text_selected_bg = with_alpha(theme.primary, 0.4f);
  }
  if (is_unset(theme.drag_drop_target, "drag_drop_target")) {
    theme.drag_drop_target = with_alpha(theme.accent, 0.8f);
  }
 
  // Docking
  if (is_unset(theme.docking_preview, "docking_preview")) {
    theme.docking_preview = with_alpha(theme.primary, 0.7f);
  }
  if (is_unset(theme.docking_empty_bg, "docking_empty_bg")) {
    theme.docking_empty_bg = theme.header;
  }
 
  // Tree
  if (is_unset(theme.tree_lines, "tree_lines")) {
    theme.tree_lines = with_alpha(theme.separator, 0.6f);
  }
 
  // Tab variations
  if (is_unset(theme.tab_dimmed, "tab_dimmed")) {
    theme.tab_dimmed = darken(theme.tab, 0.1f);
  }
  if (is_unset(theme.tab_dimmed_selected, "tab_dimmed_selected")) {
    theme.tab_dimmed_selected = darken(theme.tab_active, 0.1f);
  }
  if (is_unset(theme.tab_dimmed_selected_overline,
               "tab_dimmed_selected_overline")) {
    theme.tab_dimmed_selected_overline = theme.accent;
  }
  if (is_unset(theme.tab_selected_overline, "tab_selected_overline")) {
    theme.tab_selected_overline = theme.accent;
  }
 
  // Surface variants (if missing)
  if (is_unset(theme.surface, "surface")) {
    theme.surface = theme.background;
  }
  if (is_unset(theme.modal_bg)) {
    theme.modal_bg = theme.popup_bg;
  }
 
  // Enhanced semantic colors
  if (needs_semantic_default(theme.text_highlight, "text_highlight")) {
    theme.text_highlight = with_alpha(theme.info, 0.25f);
  }
  if (needs_semantic_default(theme.link_hover, "link_hover")) {
    theme.link_hover = lighten(theme.text_link, 0.12f);
  }
  if (needs_semantic_default(theme.code_background, "code_background")) {
    theme.code_background = darken_with_floor(theme.surface, 0.08f);
  }
  if (needs_semantic_default(theme.success_light, "success_light")) {
    theme.success_light = lighten(theme.success, 0.15f);
  }
  if (needs_semantic_default(theme.warning_light, "warning_light")) {
    theme.warning_light = lighten(theme.warning, 0.12f);
  }
  if (needs_semantic_default(theme.error_light, "error_light")) {
    theme.error_light = lighten(theme.error, 0.18f);
  }
  if (needs_semantic_default(theme.info_light, "info_light")) {
    theme.info_light = lighten(theme.info, 0.12f);
  }
 
  // Selection sources first: the UI state colors below derive from them.
  if (needs_semantic_default(theme.selection_primary)) {
    theme.selection_primary = theme.warning;
  }
  if (needs_semantic_default(theme.selection_secondary)) {
    theme.selection_secondary = theme.info;
  }
 
  // UI state colors
  if (needs_semantic_default(theme.active_selection, "active_selection")) {
    theme.active_selection = with_alpha(theme.selection_primary, 0.35f);
  }
  if (needs_semantic_default(theme.hover_highlight, "hover_highlight")) {
    theme.hover_highlight = with_alpha(theme.selection_secondary, 0.2f);
  }
  if (needs_semantic_default(theme.focus_border, "focus_border")) {
    theme.focus_border = theme.primary;
  }
  if (needs_semantic_default(theme.disabled_overlay, "disabled_overlay")) {
    theme.disabled_overlay = with_alpha(theme.background, 0.5f);
  }
 
  // Editor-specific defaults
  if (needs_semantic_default(theme.editor_background, "editor_background")) {
    theme.editor_background = theme.background;
  }
  if (needs_semantic_default(theme.editor_grid, "editor_grid")) {
    theme.editor_grid = with_alpha(theme.text_secondary, 0.2f);
  }
  if (needs_semantic_default(theme.editor_cursor, "editor_cursor")) {
    theme.editor_cursor = theme.text_primary;
  }
  if (needs_semantic_default(theme.editor_selection, "editor_selection")) {
    theme.editor_selection = with_alpha(theme.primary, 0.3f);
  }
 
  // Interaction defaults
  if (needs_semantic_default(theme.selection_hover)) {
    theme.selection_hover = with_alpha(theme.text_primary, 0.2f);
  }
  if (needs_semantic_default(theme.selection_pulsing)) {
    theme.selection_pulsing = with_alpha(theme.text_primary, 0.8f);
  }
  if (needs_semantic_default(theme.selection_handle)) {
    theme.selection_handle = theme.text_primary;
  }
  if (needs_semantic_default(theme.drag_preview)) {
    theme.drag_preview = with_alpha(theme.secondary, 0.4f);
  }
  if (needs_semantic_default(theme.drag_preview_outline)) {
    theme.drag_preview_outline = with_alpha(theme.secondary, 0.8f);
  }
 
  // Entity defaults
  if (needs_semantic_default(theme.entrance_color)) {
    theme.entrance_color = theme.success;
  }
  if (needs_semantic_default(theme.hole_color)) {
    theme.hole_color = theme.secondary;
  }
  if (needs_semantic_default(theme.exit_color)) {
    theme.exit_color = theme.error;
  }
  if (needs_semantic_default(theme.item_color)) {
    theme.item_color = theme.warning;
  }
  if (needs_semantic_default(theme.sprite_color)) {
    theme.sprite_color = theme.info;
  }
  if (needs_semantic_default(theme.transport_color)) {
    theme.transport_color = lighten(theme.secondary, 0.2f);
  }
  if (needs_semantic_default(theme.music_zone_color)) {
    theme.music_zone_color = darken(theme.warning, 0.1f);
  }
 
  // Dungeon semantic defaults
  if (needs_semantic_default(theme.dungeon.selection_primary)) {
    theme.dungeon.selection_primary = theme.selection_primary;
  }
  if (needs_semantic_default(theme.dungeon.selection_secondary)) {
    theme.dungeon.selection_secondary = theme.selection_secondary;
  }
  if (needs_semantic_default(theme.dungeon.selection_pulsing)) {
    theme.dungeon.selection_pulsing = theme.selection_pulsing;
  }
  if (needs_semantic_default(theme.dungeon.selection_handle)) {
    theme.dungeon.selection_handle = theme.selection_handle;
  }
  if (needs_semantic_default(theme.dungeon.drag_preview)) {
    theme.dungeon.drag_preview = theme.drag_preview;
  }
  if (needs_semantic_default(theme.dungeon.drag_preview_outline)) {
    theme.dungeon.drag_preview_outline = theme.drag_preview_outline;
  }
  if (needs_semantic_default(theme.dungeon.object_wall)) {
    theme.dungeon.object_wall = with_alpha(theme.text_secondary, 1.0f);
  }
  if (needs_semantic_default(theme.dungeon.object_floor)) {
    theme.dungeon.object_floor =
        darken(with_alpha(theme.text_secondary, 1.0f), 0.2f);
  }
  if (needs_semantic_default(theme.dungeon.object_chest)) {
    theme.dungeon.object_chest = theme.warning;
  }
  if (needs_semantic_default(theme.dungeon.object_door)) {
    theme.dungeon.object_door = darken(theme.warning, 0.45f);
  }
  if (needs_semantic_default(theme.dungeon.object_pot)) {
    theme.dungeon.object_pot = darken(theme.warning, 0.25f);
  }
  if (needs_semantic_default(theme.dungeon.object_stairs)) {
    theme.dungeon.object_stairs = lighten(theme.warning, 0.1f);
  }
  if (needs_semantic_default(theme.dungeon.object_decoration)) {
    theme.dungeon.object_decoration = theme.success;
  }
  if (needs_semantic_default(theme.dungeon.object_default)) {
    theme.dungeon.object_default = theme.text_secondary;
  }
  if (needs_semantic_default(theme.dungeon.grid_cell_highlight)) {
    theme.dungeon.grid_cell_highlight = with_alpha(theme.success, 0.3f);
  }
  if (needs_semantic_default(theme.dungeon.grid_cell_selected)) {
    theme.dungeon.grid_cell_selected = with_alpha(theme.success, 0.5f);
  }
  if (needs_semantic_default(theme.dungeon.grid_cell_border)) {
    theme.dungeon.grid_cell_border = with_alpha(theme.border, 0.5f);
  }
  if (needs_semantic_default(theme.dungeon.grid_text)) {
    theme.dungeon.grid_text = with_alpha(theme.text_primary, 0.8f);
  }
  if (needs_semantic_default(theme.dungeon.room_border)) {
    theme.dungeon.room_border = with_alpha(theme.text_secondary, 1.0f);
  }
  if (needs_semantic_default(theme.dungeon.room_border_dark)) {
    theme.dungeon.room_border_dark =
        darken(with_alpha(theme.text_secondary, 1.0f), 0.3f);
  }
  if (needs_semantic_default(theme.dungeon.sprite_layer0)) {
    theme.dungeon.sprite_layer0 = theme.success;
  }
  if (needs_semantic_default(theme.dungeon.sprite_layer1)) {
    theme.dungeon.sprite_layer1 = theme.info;
  }
  if (needs_semantic_default(theme.dungeon.sprite_layer2)) {
    theme.dungeon.sprite_layer2 = theme.info;
  }
  if (needs_semantic_default(theme.dungeon.outline_layer0)) {
    theme.dungeon.outline_layer0 = theme.error;
  }
  if (needs_semantic_default(theme.dungeon.outline_layer1)) {
    theme.dungeon.outline_layer1 = theme.success;
  }
  if (needs_semantic_default(theme.dungeon.outline_layer2)) {
    theme.dungeon.outline_layer2 = theme.info;
  }
 
  // Agent semantic defaults
  if (needs_semantic_default(theme.agent.user_message)) {
    theme.agent.user_message = theme.info;
  }
  if (needs_semantic_default(theme.agent.agent_message)) {
    theme.agent.agent_message = theme.success;
  }
  if (needs_semantic_default(theme.agent.system_message)) {
    theme.agent.system_message = theme.text_secondary;
  }
  if (needs_semantic_default(theme.agent.text_secondary)) {
    theme.agent.text_secondary = theme.text_secondary;
  }
  if (needs_semantic_default(theme.agent.json_text)) {
    theme.agent.json_text = theme.warning;
  }
  if (needs_semantic_default(theme.agent.command_text)) {
    theme.agent.command_text = theme.error;
  }
  if (needs_semantic_default(theme.agent.code_background)) {
    theme.agent.code_background = darken_with_floor(theme.surface, 0.1f);
  }
  if (needs_semantic_default(theme.agent.panel_bg)) {
    theme.agent.panel_bg = is_effectively_transparent(theme.child_bg)
                               ? with_alpha(theme.surface, 0.95f)
                               : theme.child_bg;
  }
  if (needs_semantic_default(theme.agent.panel_bg_darker)) {
    theme.agent.panel_bg_darker = darken_with_floor(
        with_alpha(theme.agent.panel_bg, theme.agent.panel_bg.alpha), 0.06f,
        0.02f);
  }
  if (needs_semantic_default(theme.agent.panel_border)) {
    // Editor panels use this compatibility palette too. Keep panel separation
    // visible without repeating the theme accent around every nested child.
    theme.agent.panel_border =
        with_alpha(theme.border, std::min(theme.border.alpha, 0.45f));
  }
  if (needs_semantic_default(theme.agent.accent)) {
    theme.agent.accent = theme.accent;
  }
  if (needs_semantic_default(theme.agent.status_active)) {
    theme.agent.status_active = theme.success;
  }
  if (needs_semantic_default(theme.agent.status_inactive)) {
    theme.agent.status_inactive = theme.text_disabled;
  }
  if (needs_semantic_default(theme.agent.status_success)) {
    theme.agent.status_success = theme.success;
  }
  if (needs_semantic_default(theme.agent.status_warning)) {
    theme.agent.status_warning = theme.warning;
  }
  if (needs_semantic_default(theme.agent.status_error)) {
    theme.agent.status_error = theme.error;
  }
  if (needs_semantic_default(theme.agent.provider_ollama)) {
    theme.agent.provider_ollama = theme.text_primary;
  }
  if (needs_semantic_default(theme.agent.provider_gemini)) {
    theme.agent.provider_gemini = theme.info;
  }
  if (needs_semantic_default(theme.agent.provider_mock)) {
    theme.agent.provider_mock = theme.text_disabled;
  }
  if (needs_semantic_default(theme.agent.provider_openai)) {
    theme.agent.provider_openai = theme.success;
  }
  if (needs_semantic_default(theme.agent.collaboration_active)) {
    theme.agent.collaboration_active = theme.success;
  }
  if (needs_semantic_default(theme.agent.collaboration_inactive)) {
    theme.agent.collaboration_inactive = theme.text_disabled;
  }
  if (needs_semantic_default(theme.agent.proposal_panel_bg)) {
    theme.agent.proposal_panel_bg = with_alpha(theme.surface, 1.0f);
  }
  if (needs_semantic_default(theme.agent.proposal_accent)) {
    theme.agent.proposal_accent = theme.info;
  }
  if (needs_semantic_default(theme.agent.button_copy)) {
    theme.agent.button_copy = with_alpha(theme.secondary, 1.0f);
  }
  if (needs_semantic_default(theme.agent.button_copy_hover)) {
    theme.agent.button_copy_hover = lighten(theme.secondary, 0.1f);
  }
  if (needs_semantic_default(theme.agent.gradient_top)) {
    theme.agent.gradient_top = theme.primary;
  }
  if (needs_semantic_default(theme.agent.gradient_bottom)) {
    theme.agent.gradient_bottom = theme.secondary;
  }
}
 
Theme ThemeManager::GenerateThemeFromAccent(const Color& accent,
                                            bool dark_mode) {
  Theme theme;
  theme.name = "Custom Accent Theme";
  theme.description = "Generated from accent color";
  theme.author = "YAZE Theme Generator";
 
  // Get HSL of accent for derivation
  Color::HSL accent_hsl = accent.ToHSL();
 
  // Generate primary as a slightly darker/less saturated version of accent
  theme.primary = accent;
  theme.accent = accent;
 
  // Generate secondary with complementary hue shift (30 degrees)
  theme.secondary = accent.ShiftHue(30.0f).Desaturate(0.1f);
 
  if (dark_mode) {
    // Dark theme: very dark backgrounds, light text
    theme.background = Color::FromHSL(accent_hsl.h, 0.15f, 0.08f);
    theme.surface = Color::FromHSL(accent_hsl.h, 0.12f, 0.12f);
    theme.window_bg = theme.background.WithAlpha(0.95f);
    theme.child_bg = Color::FromHSL(accent_hsl.h, 0.10f, 0.10f).WithAlpha(0.8f);
    theme.popup_bg =
        Color::FromHSL(accent_hsl.h, 0.12f, 0.14f).WithAlpha(0.98f);
    theme.modal_bg = theme.popup_bg;
 
    // Light text on dark backgrounds
    theme.text_primary = Color{0.95f, 0.95f, 0.95f, 1.0f};
    theme.text_secondary = Color{0.75f, 0.75f, 0.78f, 1.0f};
    theme.text_disabled = Color{0.45f, 0.45f, 0.48f, 1.0f};
 
    // Buttons derived from accent
    theme.button = accent.Darker(0.15f).Desaturate(0.1f);
    theme.button_hovered = accent;
    theme.button_active = accent.Lighter(0.1f);
 
    // Frame backgrounds (inputs, etc.)
    theme.frame_bg = Color::FromHSL(accent_hsl.h, 0.08f, 0.15f);
    theme.frame_bg_hovered = Color::FromHSL(accent_hsl.h, 0.12f, 0.20f);
    theme.frame_bg_active = Color::FromHSL(accent_hsl.h, 0.15f, 0.25f);
 
    // Headers
    theme.header = Color::FromHSL(accent_hsl.h, 0.20f, 0.18f);
    theme.header_hovered = accent.Darker(0.2f);
    theme.header_active = accent.Darker(0.1f);
 
    // Tabs
    theme.tab = Color::FromHSL(accent_hsl.h, 0.12f, 0.12f);
    theme.tab_hovered = accent.Darker(0.25f);
    theme.tab_active = accent.Darker(0.15f);
 
    // Title bars
    theme.title_bg = Color::FromHSL(accent_hsl.h, 0.15f, 0.10f);
    theme.title_bg_active = Color::FromHSL(accent_hsl.h, 0.20f, 0.14f);
    theme.title_bg_collapsed = theme.title_bg;
 
    // Menu bar
    theme.menu_bar_bg = Color::FromHSL(accent_hsl.h, 0.10f, 0.12f);
 
  } else {
    // Light theme: light backgrounds, dark text
    theme.background = Color::FromHSL(accent_hsl.h, 0.05f, 0.96f);
    theme.surface = Color::FromHSL(accent_hsl.h, 0.08f, 0.94f);
    theme.window_bg = theme.background.WithAlpha(0.98f);
    theme.child_bg = Color::FromHSL(accent_hsl.h, 0.05f, 0.92f).WithAlpha(0.8f);
    theme.popup_bg = Color{1.0f, 1.0f, 1.0f, 0.98f};
    theme.modal_bg = theme.popup_bg;
 
    // Dark text on light backgrounds
    theme.text_primary = Color{0.12f, 0.12f, 0.15f, 1.0f};
    theme.text_secondary = Color{0.35f, 0.35f, 0.40f, 1.0f};
    theme.text_disabled = Color{0.60f, 0.60f, 0.65f, 1.0f};
 
    // Buttons derived from accent
    theme.button = accent.Lighter(0.1f);
    theme.button_hovered = accent;
    theme.button_active = accent.Darker(0.1f);
 
    // Frame backgrounds (inputs, etc.)
    theme.frame_bg = Color::FromHSL(accent_hsl.h, 0.05f, 0.90f);
    theme.frame_bg_hovered = Color::FromHSL(accent_hsl.h, 0.08f, 0.85f);
    theme.frame_bg_active = Color::FromHSL(accent_hsl.h, 0.12f, 0.80f);
 
    // Headers
    theme.header = Color::FromHSL(accent_hsl.h, 0.08f, 0.88f);
    theme.header_hovered = accent.Lighter(0.2f);
    theme.header_active = accent.Lighter(0.1f);
 
    // Tabs
    theme.tab = Color::FromHSL(accent_hsl.h, 0.05f, 0.90f);
    theme.tab_hovered = accent.Lighter(0.25f);
    theme.tab_active = accent.Lighter(0.15f);
 
    // Title bars
    theme.title_bg = Color::FromHSL(accent_hsl.h, 0.05f, 0.92f);
    theme.title_bg_active = Color::FromHSL(accent_hsl.h, 0.10f, 0.88f);
    theme.title_bg_collapsed = theme.title_bg;
 
    // Menu bar
    theme.menu_bar_bg = Color::FromHSL(accent_hsl.h, 0.05f, 0.94f);
  }
 
  // Status colors (independent of dark/light mode)
  theme.error = Color{0.90f, 0.30f, 0.30f, 1.0f};
  theme.warning = Color{0.95f, 0.75f, 0.25f, 1.0f};
  theme.success = Color{0.30f, 0.85f, 0.45f, 1.0f};
  theme.info = Color{0.35f, 0.70f, 0.95f, 1.0f};
 
  // Borders using accent hue
  theme.border = accent.WithAlpha(0.6f);
  theme.border_shadow = Color{0.0f, 0.0f, 0.0f, 0.0f};
  theme.separator = accent.Desaturate(0.3f).WithAlpha(0.4f);
  theme.separator_hovered = accent.WithAlpha(0.7f);
  theme.separator_active = accent;
 
  // Scrollbars
  theme.scrollbar_bg = dark_mode ? Color::FromHSL(accent_hsl.h, 0.08f, 0.12f)
                                 : Color::FromHSL(accent_hsl.h, 0.05f, 0.88f);
  theme.scrollbar_grab = accent.Darker(0.2f).WithAlpha(0.6f);
  theme.scrollbar_grab_hovered = accent.WithAlpha(0.8f);
  theme.scrollbar_grab_active = accent;
 
  // Resize grips
  theme.resize_grip = Color{1.0f, 1.0f, 1.0f, 0.1f};
  theme.resize_grip_hovered = accent.WithAlpha(0.6f);
  theme.resize_grip_active = accent;
 
  // Controls
  theme.check_mark = accent.Lighter(0.2f);
  theme.slider_grab = accent;
  theme.slider_grab_active = accent.Lighter(0.15f);
 
  // Tables
  theme.table_header_bg = theme.header;
  theme.table_border_strong = accent.Desaturate(0.2f);
  theme.table_border_light = accent.Desaturate(0.4f).WithAlpha(0.5f);
  theme.table_row_bg = Color{0.0f, 0.0f, 0.0f, 0.0f};
  theme.table_row_bg_alt = accent.WithAlpha(0.05f);
 
  // Links
  theme.text_link = accent.Lighter(0.1f);
 
  // Navigation
  theme.input_text_cursor = theme.text_primary;
  theme.nav_cursor = accent;
  theme.nav_windowing_highlight = accent.WithAlpha(0.7f);
  theme.nav_windowing_dim_bg = Color{0.0f, 0.0f, 0.0f, 0.5f};
  theme.modal_window_dim_bg = Color{0.0f, 0.0f, 0.0f, 0.4f};
  theme.text_selected_bg = accent.WithAlpha(0.35f);
  theme.drag_drop_target = accent.WithAlpha(0.8f);
 
  // Docking
  theme.docking_preview = accent.WithAlpha(0.7f);
  theme.docking_empty_bg = theme.menu_bar_bg;
 
  // Tree lines
  theme.tree_lines = accent.Desaturate(0.3f).WithAlpha(0.4f);
 
  // Tab variations
  theme.tab_unfocused = theme.tab.Darker(0.05f);
  theme.tab_unfocused_active = theme.tab_active.Darker(0.1f);
  theme.tab_dimmed = theme.tab.Darker(0.1f);
  theme.tab_dimmed_selected = theme.tab_active.Darker(0.05f);
  theme.tab_dimmed_selected_overline = accent;
  theme.tab_selected_overline = accent;
 
  // Style parameters
  theme.window_rounding = 8.0f;
  theme.frame_rounding = 6.0f;
  theme.scrollbar_rounding = 8.0f;
  theme.grab_rounding = 4.0f;
  theme.tab_rounding = 6.0f;
  theme.window_border_size = 1.0f;
  theme.frame_border_size = 0.0f;
 
  // Animation settings
  theme.enable_animations = true;
  theme.animation_speed = 1.0f;
  theme.enable_glow_effects = false;
 
  // Hydrate semantic/editor/dungeon/agent fields. Without this they reach
  // ConvertColorToImVec4 as default-constructed opaque black, unlike every
  // file-loaded theme, which gets these via LoadThemeFromFile.
  ApplySmartDefaults(theme);
 
  return theme;
}
 
void ThemeManager::ApplyAccentColor(const Color& accent, bool dark_mode) {
  Theme generated = GenerateThemeFromAccent(accent, dark_mode);
  ApplyTheme(generated);
  current_theme_ = generated;
  current_theme_name_ = "Custom Accent";
  // ApplyTheme(generated) already fired with generated.name; re-fire with the
  // user-visible "Custom Accent" label so persistence records the right value.
  NotifyThemeChanged();
}
 
Color ThemeManager::ParseColorFromString(const std::string& color_str) const {
  std::vector<std::string> components = absl::StrSplit(color_str, ',');
  if (components.size() != 4) {
    return RGBA(255, 255, 255, 255);  // White fallback
  }
 
  try {
    int r = std::stoi(components[0]);
    int g = std::stoi(components[1]);
    int b = std::stoi(components[2]);
    int a = std::stoi(components[3]);
    return RGBA(r, g, b, a);
  } catch (...) {
    return RGBA(255, 255, 255, 255);  // White fallback
  }
}
 
std::string ThemeManager::SerializeTheme(const Theme& theme) const {
  std::ostringstream ss;
 
  // Helper function to convert color to RGB string
  auto colorToString = [](const Color& c) -> std::string {
    int r = static_cast<int>(c.red * 255.0f);
    int g = static_cast<int>(c.green * 255.0f);
    int b = static_cast<int>(c.blue * 255.0f);
    int a = static_cast<int>(c.alpha * 255.0f);
    return std::to_string(r) + "," + std::to_string(g) + "," +
           std::to_string(b) + "," + std::to_string(a);
  };
 
  ss << "# yaze Theme File\n";
  ss << "# Generated by YAZE Theme Editor\n";
  ss << "name=" << theme.name << "\n";
  ss << "description=" << theme.description << "\n";
  ss << "author=" << theme.author << "\n";
  ss << "version=1.0\n";
  ss << "\n[colors]\n";
 
  // Primary colors
  ss << "# Primary colors\n";
  ss << "primary=" << colorToString(theme.primary) << "\n";
  ss << "secondary=" << colorToString(theme.secondary) << "\n";
  ss << "accent=" << colorToString(theme.accent) << "\n";
  ss << "background=" << colorToString(theme.background) << "\n";
  ss << "surface=" << colorToString(theme.surface) << "\n";
  ss << "\n";
 
  // Status colors
  ss << "# Status colors\n";
  ss << "error=" << colorToString(theme.error) << "\n";
  ss << "warning=" << colorToString(theme.warning) << "\n";
  ss << "success=" << colorToString(theme.success) << "\n";
  ss << "info=" << colorToString(theme.info) << "\n";
  ss << "\n";
 
  // Text colors
  ss << "# Text colors\n";
  ss << "text_primary=" << colorToString(theme.text_primary) << "\n";
  ss << "text_secondary=" << colorToString(theme.text_secondary) << "\n";
  ss << "text_disabled=" << colorToString(theme.text_disabled) << "\n";
  ss << "\n";
 
  // Window colors
  ss << "# Window colors\n";
  ss << "window_bg=" << colorToString(theme.window_bg) << "\n";
  ss << "child_bg=" << colorToString(theme.child_bg) << "\n";
  ss << "popup_bg=" << colorToString(theme.popup_bg) << "\n";
  ss << "\n";
 
  // Interactive elements
  ss << "# Interactive elements\n";
  ss << "button=" << colorToString(theme.button) << "\n";
  ss << "button_hovered=" << colorToString(theme.button_hovered) << "\n";
  ss << "button_active=" << colorToString(theme.button_active) << "\n";
  ss << "frame_bg=" << colorToString(theme.frame_bg) << "\n";
  ss << "frame_bg_hovered=" << colorToString(theme.frame_bg_hovered) << "\n";
  ss << "frame_bg_active=" << colorToString(theme.frame_bg_active) << "\n";
  ss << "\n";
 
  // Navigation
  ss << "# Navigation\n";
  ss << "header=" << colorToString(theme.header) << "\n";
  ss << "header_hovered=" << colorToString(theme.header_hovered) << "\n";
  ss << "header_active=" << colorToString(theme.header_active) << "\n";
  ss << "tab=" << colorToString(theme.tab) << "\n";
  ss << "tab_hovered=" << colorToString(theme.tab_hovered) << "\n";
  ss << "tab_active=" << colorToString(theme.tab_active) << "\n";
  ss << "menu_bar_bg=" << colorToString(theme.menu_bar_bg) << "\n";
  ss << "title_bg=" << colorToString(theme.title_bg) << "\n";
  ss << "title_bg_active=" << colorToString(theme.title_bg_active) << "\n";
  ss << "title_bg_collapsed=" << colorToString(theme.title_bg_collapsed)
     << "\n";
  ss << "\n";
 
  // Borders and separators
  ss << "# Borders and separators\n";
  ss << "border=" << colorToString(theme.border) << "\n";
  ss << "border_shadow=" << colorToString(theme.border_shadow) << "\n";
  ss << "separator=" << colorToString(theme.separator) << "\n";
  ss << "separator_hovered=" << colorToString(theme.separator_hovered) << "\n";
  ss << "separator_active=" << colorToString(theme.separator_active) << "\n";
  ss << "\n";
 
  // Scrollbars and controls
  ss << "# Scrollbars and controls\n";
  ss << "scrollbar_bg=" << colorToString(theme.scrollbar_bg) << "\n";
  ss << "scrollbar_grab=" << colorToString(theme.scrollbar_grab) << "\n";
  ss << "scrollbar_grab_hovered=" << colorToString(theme.scrollbar_grab_hovered)
     << "\n";
  ss << "scrollbar_grab_active=" << colorToString(theme.scrollbar_grab_active)
     << "\n";
  ss << "resize_grip=" << colorToString(theme.resize_grip) << "\n";
  ss << "resize_grip_hovered=" << colorToString(theme.resize_grip_hovered)
     << "\n";
  ss << "resize_grip_active=" << colorToString(theme.resize_grip_active)
     << "\n";
  ss << "check_mark=" << colorToString(theme.check_mark) << "\n";
  ss << "slider_grab=" << colorToString(theme.slider_grab) << "\n";
  ss << "slider_grab_active=" << colorToString(theme.slider_grab_active)
     << "\n";
  ss << "\n";
 
  // Navigation and special elements
  ss << "# Navigation and special elements\n";
  ss << "input_text_cursor=" << colorToString(theme.input_text_cursor) << "\n";
  ss << "nav_cursor=" << colorToString(theme.nav_cursor) << "\n";
  ss << "nav_windowing_highlight="
     << colorToString(theme.nav_windowing_highlight) << "\n";
  ss << "nav_windowing_dim_bg=" << colorToString(theme.nav_windowing_dim_bg)
     << "\n";
  ss << "modal_window_dim_bg=" << colorToString(theme.modal_window_dim_bg)
     << "\n";
  ss << "text_selected_bg=" << colorToString(theme.text_selected_bg) << "\n";
  ss << "drag_drop_target=" << colorToString(theme.drag_drop_target) << "\n";
  ss << "docking_preview=" << colorToString(theme.docking_preview) << "\n";
  ss << "docking_empty_bg=" << colorToString(theme.docking_empty_bg) << "\n";
  ss << "\n";
 
  // Table colors
  ss << "# Table colors\n";
  ss << "table_header_bg=" << colorToString(theme.table_header_bg) << "\n";
  ss << "table_border_strong=" << colorToString(theme.table_border_strong)
     << "\n";
  ss << "table_border_light=" << colorToString(theme.table_border_light)
     << "\n";
  ss << "table_row_bg=" << colorToString(theme.table_row_bg) << "\n";
  ss << "table_row_bg_alt=" << colorToString(theme.table_row_bg_alt) << "\n";
  ss << "\n";
 
  // Links and plots
  ss << "# Links and plots\n";
  ss << "text_link=" << colorToString(theme.text_link) << "\n";
  ss << "plot_lines=" << colorToString(theme.plot_lines) << "\n";
  ss << "plot_lines_hovered=" << colorToString(theme.plot_lines_hovered)
     << "\n";
  ss << "plot_histogram=" << colorToString(theme.plot_histogram) << "\n";
  ss << "plot_histogram_hovered=" << colorToString(theme.plot_histogram_hovered)
     << "\n";
  ss << "tree_lines=" << colorToString(theme.tree_lines) << "\n";
  ss << "\n";
 
  // Tab variations
  ss << "# Tab variations\n";
  ss << "tab_dimmed=" << colorToString(theme.tab_dimmed) << "\n";
  ss << "tab_dimmed_selected=" << colorToString(theme.tab_dimmed_selected)
     << "\n";
  ss << "tab_dimmed_selected_overline="
     << colorToString(theme.tab_dimmed_selected_overline) << "\n";
  ss << "tab_selected_overline=" << colorToString(theme.tab_selected_overline)
     << "\n";
  ss << "\n";
 
  // Enhanced semantic colors
  ss << "# Enhanced semantic colors\n";
  ss << "text_highlight=" << colorToString(theme.text_highlight) << "\n";
  ss << "link_hover=" << colorToString(theme.link_hover) << "\n";
  ss << "code_background=" << colorToString(theme.code_background) << "\n";
  ss << "success_light=" << colorToString(theme.success_light) << "\n";
  ss << "warning_light=" << colorToString(theme.warning_light) << "\n";
  ss << "error_light=" << colorToString(theme.error_light) << "\n";
  ss << "info_light=" << colorToString(theme.info_light) << "\n";
  ss << "\n";
 
  // UI state colors
  ss << "# UI state colors\n";
  ss << "active_selection=" << colorToString(theme.active_selection) << "\n";
  ss << "hover_highlight=" << colorToString(theme.hover_highlight) << "\n";
  ss << "focus_border=" << colorToString(theme.focus_border) << "\n";
  ss << "disabled_overlay=" << colorToString(theme.disabled_overlay) << "\n";
  ss << "\n";
 
  // Editor-specific colors
  ss << "# Editor-specific colors\n";
  ss << "editor_background=" << colorToString(theme.editor_background) << "\n";
  ss << "editor_grid=" << colorToString(theme.editor_grid) << "\n";
  ss << "editor_cursor=" << colorToString(theme.editor_cursor) << "\n";
  ss << "editor_selection=" << colorToString(theme.editor_selection) << "\n";
  ss << "\n";
 
  // Style settings
  ss << "[style]\n";
  ss << "window_rounding=" << theme.window_rounding << "\n";
  ss << "frame_rounding=" << theme.frame_rounding << "\n";
  ss << "scrollbar_rounding=" << theme.scrollbar_rounding << "\n";
  ss << "grab_rounding=" << theme.grab_rounding << "\n";
  ss << "tab_rounding=" << theme.tab_rounding << "\n";
  ss << "window_border_size=" << theme.window_border_size << "\n";
  ss << "frame_border_size=" << theme.frame_border_size << "\n";
  ss << "enable_animations=" << (theme.enable_animations ? "true" : "false")
     << "\n";
  ss << "animation_speed=" << theme.animation_speed << "\n";
  ss << "enable_glow_effects=" << (theme.enable_glow_effects ? "true" : "false")
     << "\n";
 
  return ss.str();
}
 
std::string ThemeManager::ExportCurrentThemeJson() const {
  nlohmann::json j;
  const auto& t = current_theme_;
 
  j["name"] = t.name;
  j["description"] = t.description;
  j["author"] = t.author;
 
  // Helper to convert Color to hex string (#RRGGBB or #RRGGBBAA)
  auto colorToHex = [](const Color& c) -> std::string {
    int r = static_cast<int>(c.red * 255.0f);
    int g = static_cast<int>(c.green * 255.0f);
    int b = static_cast<int>(c.blue * 255.0f);
    int a = static_cast<int>(c.alpha * 255.0f);
    if (a == 255) {
      return absl::StrFormat("#%02X%02X%02X", r, g, b);
    }
    return absl::StrFormat("#%02X%02X%02X%02X", r, g, b, a);
  };
 
  j["colors"] = {{"primary", colorToHex(t.primary)},
                 {"secondary", colorToHex(t.secondary)},
                 {"accent", colorToHex(t.accent)},
                 {"background", colorToHex(t.background)},
                 {"surface", colorToHex(t.surface)},
                 {"error", colorToHex(t.error)},
                 {"warning", colorToHex(t.warning)},
                 {"success", colorToHex(t.success)},
                 {"info", colorToHex(t.info)},
                 {"text_primary", colorToHex(t.text_primary)},
                 {"text_secondary", colorToHex(t.text_secondary)},
                 {"text_disabled", colorToHex(t.text_disabled)},
                 {"window_bg", colorToHex(t.window_bg)},
                 {"child_bg", colorToHex(t.child_bg)},
                 {"popup_bg", colorToHex(t.popup_bg)},
                 {"modal_bg", colorToHex(t.modal_bg)},
                 {"button", colorToHex(t.button)},
                 {"button_hovered", colorToHex(t.button_hovered)},
                 {"button_active", colorToHex(t.button_active)},
                 {"header", colorToHex(t.header)},
                 {"header_hovered", colorToHex(t.header_hovered)},
                 {"header_active", colorToHex(t.header_active)},
                 {"border", colorToHex(t.border)},
                 {"border_shadow", colorToHex(t.border_shadow)},
                 {"separator", colorToHex(t.separator)},
                 // Editor semantic colors
                 {"editor_background", colorToHex(t.editor_background)},
                 {"editor_grid", colorToHex(t.editor_grid)},
                 {"editor_cursor", colorToHex(t.editor_cursor)},
                 {"editor_selection", colorToHex(t.editor_selection)},
                 // Enhanced semantic colors
                 {"code_background", colorToHex(t.code_background)},
                 {"text_highlight", colorToHex(t.text_highlight)},
                 {"link_hover", colorToHex(t.link_hover)}};
 
  j["style"] = {{"window_rounding", t.window_rounding},
                {"frame_rounding", t.frame_rounding},
                {"compact_factor", t.compact_factor}};
 
  return j.dump();
}
 
absl::Status ThemeManager::SaveThemeToFile(const Theme& theme,
                                           const std::string& filepath) {
  std::string theme_content = SerializeTheme(theme);
 
  std::ofstream file(filepath);
  if (!file.is_open()) {
    return absl::InternalError(
        absl::StrFormat("Failed to open file for writing: %s", filepath));
  }
 
  file << theme_content;
  file.close();
 
  if (file.fail()) {
    return absl::InternalError(
        absl::StrFormat("Failed to write theme file: %s", filepath));
  }
 
  // Record the file association so GetCurrentThemeFilePath can find it by
  // display name without guessing a filename. Covers Save Over Current, Save
  // As, Save to File, and Export — previously only the load path recorded.
  if (!theme.name.empty()) {
    theme_file_paths_[theme.name] = filepath;
  }
 
  return absl::OkStatus();
}
 
void ThemeManager::ApplyClassicYazeTheme(std::optional<DensityPreset> density) {
  // Apply the original ColorsYaze() function directly
  ColorsYaze();
  current_theme_name_ = "Classic YAZE";
  Theme classic_theme = BuildClassicYazeTheme();
  // Hydrate the same semantic/interaction/dungeon/agent defaults that file-
  // loaded themes get via LoadThemeFromFile → ApplySmartDefaults, so Classic
  // isn't missing fields (selection_primary, dungeon.object_door, agent.*).
  ApplySmartDefaults(classic_theme);
  // Carry the active Display Density across the switch. ColorsYaze() writes
  // Classic's OWN metrics (FramePadding 10x2, ItemSpacing 10x5, WindowPadding
  // 10x10), which are not the shared 8px base that Theme::ApplyToImGui uses.
  // Scale what ColorsYaze just wrote instead of calling the generic density
  // sizing, which would substitute that base and change Classic's look at
  // every density — including Normal, i.e. on every startup.
  classic_theme.ApplyDensityPreset(
      density.value_or(current_theme_.density_preset));
  ScaleCurrentStyleSpacing(classic_theme.compact_factor);
  current_theme_ = classic_theme;
 
  // Mirror the bookkeeping that LoadTheme and ApplyTheme(const Theme&) do:
  // refresh the AgentUI palette cache (stale until RefreshTheme is called) and
  // cancel any in-progress color transition so switches to Classic apply
  // immediately instead of getting lerped over by UpdateTransition(). Skip the
  // AgentUI refresh if we're still inside the singleton constructor — calling
  // Get() recursively aborts the process.
  if (!initializing_built_ins_) {
    editor::AgentUI::RefreshTheme();
  }
  transitioning_ = false;
  transition_progress_ = 0.0f;
  NotifyThemeChanged();
}
 
void ThemeManager::StartPreview(const std::string& theme_name) {
  // Don't start a new preview if already previewing
  if (preview_active_) {
    // If previewing a different theme, just switch to the new one
    ApplyTheme(theme_name);
    return;
  }
 
  // Store the original theme state before preview
  preview_original_theme_ = current_theme_;
  preview_original_name_ = current_theme_name_;
  preview_active_ = true;
 
  // Apply the preview theme
  ApplyTheme(theme_name);
}
 
void ThemeManager::EndPreview() {
  if (!preview_active_) {
    return;
  }
 
  // Restore the original theme
  current_theme_ = preview_original_theme_;
  current_theme_name_ = preview_original_name_;
 
  // Re-apply the original theme's colors to ImGui. preview_active_ is still
  // true here, so ApplyTheme's NotifyThemeChanged() is suppressed — we fire
  // once below, after clearing the preview flag, with the restored name.
  ReapplyTheme(current_theme_);
 
  preview_active_ = false;
  NotifyThemeChanged();
}
 
bool ThemeManager::IsPreviewActive() const {
  return preview_active_;
}
 
void ThemeManager::ShowSimpleThemeEditor(bool* p_open) {
  if (!p_open || !*p_open)
    return;
 
  ImGui::SetNextWindowSize(ImVec2(800, 600), ImGuiCond_FirstUseEver);
 
  if (ImGui::Begin(absl::StrFormat("%s Theme Editor", ICON_MD_PALETTE).c_str(),
                   p_open, ImGuiWindowFlags_MenuBar)) {
    // Add gentle particle effects to theme editor background
    static float editor_animation_time = 0.0f;
    editor_animation_time += ImGui::GetIO().DeltaTime;
 
    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    ImVec2 window_pos = ImGui::GetWindowPos();
    ImVec2 window_size = ImGui::GetWindowSize();
 
    // Floating color orbs representing different color categories
    auto current_theme = GetCurrentTheme();
    std::vector<gui::Color> theme_colors = {
        current_theme.primary, current_theme.secondary, current_theme.accent,
        current_theme.success, current_theme.warning,   current_theme.error};
 
    for (size_t i = 0; i < theme_colors.size(); ++i) {
      float time_offset = i * 1.0f;
      float orbit_radius = 60.0f + i * 8.0f;
      float x = window_pos.x + window_size.x * 0.8f +
                cosf(editor_animation_time * 0.3f + time_offset) * orbit_radius;
      float y = window_pos.y + window_size.y * 0.3f +
                sinf(editor_animation_time * 0.3f + time_offset) * orbit_radius;
 
      float alpha =
          0.15f + 0.1f * sinf(editor_animation_time * 1.5f + time_offset);
      ImU32 orb_color = ImGui::ColorConvertFloat4ToU32(
          ImVec4(theme_colors[i].red, theme_colors[i].green,
                 theme_colors[i].blue, alpha));
 
      float radius =
          4.0f + sinf(editor_animation_time * 2.0f + time_offset) * 1.0f;
      draw_list->AddCircleFilled(ImVec2(x, y), radius, orb_color);
    }
 
    // Menu bar for theme operations
    if (ImGui::BeginMenuBar()) {
      if (ImGui::BeginMenu(tr("File"))) {
        if (ImGui::MenuItem(
                absl::StrFormat("%s New Theme", ICON_MD_ADD).c_str())) {
          // Reset to default theme
          ApplyClassicYazeTheme();
        }
        if (ImGui::MenuItem(
                absl::StrFormat("%s Load Theme", ICON_MD_FOLDER_OPEN)
                    .c_str())) {
          auto file_path = util::FileDialogWrapper::ShowOpenFileDialog();
          if (!file_path.empty()) {
            (void)LoadThemeFromFile(file_path);
          }
        }
        ImGui::Separator();
        if (ImGui::MenuItem(
                absl::StrFormat("%s Save Theme", ICON_MD_SAVE).c_str())) {
          // Save current theme to its existing file
          std::string current_file_path = GetCurrentThemeFilePath();
          if (!current_file_path.empty()) {
            auto status = SaveThemeToFile(current_theme_, current_file_path);
            if (!status.ok()) {
              LOG_ERROR("Theme Manager", "Failed to save theme");
            }
          } else {
            // No existing file, prompt for new location
            auto file_path = util::FileDialogWrapper::ShowSaveFileDialog(
                current_theme_.name, "theme");
            if (!file_path.empty()) {
              auto status = SaveThemeToFile(current_theme_, file_path);
              if (!status.ok()) {
                LOG_ERROR("Theme Manager", "Failed to save theme");
              }
            }
          }
        }
        if (ImGui::MenuItem(
                absl::StrFormat("%s Save As...", ICON_MD_SAVE_AS).c_str())) {
          // Save theme to new file
          auto file_path = util::FileDialogWrapper::ShowSaveFileDialog(
              current_theme_.name, "theme");
          if (!file_path.empty()) {
            auto status = SaveThemeToFile(current_theme_, file_path);
            if (!status.ok()) {
              LOG_ERROR("Theme Manager", "Failed to save theme");
            }
          }
        }
        ImGui::Separator();
        if (ImGui::MenuItem(
                absl::StrFormat("%s Export to User Themes", ICON_MD_FOLDER_OPEN)
                    .c_str())) {
          // Export current theme to ~/.yaze/themes/ for cross-platform sharing
          std::string user_themes_dir = GetUserThemesDirectory();
          std::string safe_name = current_theme_.name.empty()
                                      ? "custom_theme"
                                      : current_theme_.name;
          // Sanitize filename: replace invalid characters with underscores
          for (char& c : safe_name) {
            if (c == ' ' || c == '/' || c == '\\' || c == ':' || c == '*' ||
                c == '?' || c == '"' || c == '<' || c == '>' || c == '|') {
              c = '_';
            }
          }
          std::string file_path = user_themes_dir + safe_name + ".theme";
 
          auto status = SaveThemeToFile(current_theme_, file_path);
          if (status.ok()) {
            LOG_INFO("Theme Manager", "Exported theme to: %s",
                     file_path.c_str());
          } else {
            LOG_ERROR("Theme Manager", "Failed to export theme to user themes");
          }
        }
        ImGui::EndMenu();
      }
 
      if (ImGui::BeginMenu(tr("Presets"))) {
        if (ImGui::MenuItem(tr("YAZE Classic"))) {
          ApplyClassicYazeTheme();
        }
 
        auto available_themes = GetAvailableThemes();
        if (!available_themes.empty()) {
          ImGui::Separator();
          for (const auto& theme_name : available_themes) {
            if (theme_name == "Classic YAZE") {
              continue;
            }
            if (ImGui::MenuItem(theme_name.c_str())) {
              ApplyTheme(theme_name);
            }
          }
        }
        ImGui::EndMenu();
      }
 
      ImGui::EndMenuBar();
    }
 
    static Theme edit_theme = current_theme_;
    static char theme_name[128];
    static char theme_description[256];
    static char theme_author[128];
    static bool live_preview = true;
    static Theme original_theme;  // Store original theme for restoration
    static bool theme_backup_made = false;
 
    // Helper lambda for live preview application
    auto apply_live_preview = [&]() {
      if (live_preview) {
        if (!theme_backup_made) {
          original_theme = current_theme_;
          theme_backup_made = true;
        }
        // Apply the edit theme directly to ImGui without changing theme manager
        // state
        edit_theme.ApplyToImGui();
      }
    };
 
    // Live preview toggle
    ImGui::Checkbox(tr("Live Preview"), &live_preview);
    ImGui::SameLine();
    ImGui::Text(tr("| Changes apply immediately when enabled"));
 
    // If live preview was just disabled, restore original theme
    static bool prev_live_preview = live_preview;
    if (prev_live_preview && !live_preview && theme_backup_made) {
      ReapplyTheme(original_theme);
      theme_backup_made = false;
    }
    prev_live_preview = live_preview;
 
    ImGui::Separator();
 
    // Theme metadata in a table for better layout
    if (ImGui::BeginTable("ThemeMetadata", 2,
                          ImGuiTableFlags_SizingStretchProp)) {
      ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed,
                              100.0f);
      ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
 
      ImGui::TableNextRow();
      ImGui::TableNextColumn();
      ImGui::AlignTextToFramePadding();
      ImGui::Text(tr("Name:"));
      ImGui::TableNextColumn();
      if (ImGui::InputText("##theme_name", theme_name, sizeof(theme_name))) {
        edit_theme.name = std::string(theme_name);
      }
 
      ImGui::TableNextRow();
      ImGui::TableNextColumn();
      ImGui::AlignTextToFramePadding();
      ImGui::Text(tr("Description:"));
      ImGui::TableNextColumn();
      if (ImGui::InputText("##theme_description", theme_description,
                           sizeof(theme_description))) {
        edit_theme.description = std::string(theme_description);
      }
 
      ImGui::TableNextRow();
      ImGui::TableNextColumn();
      ImGui::AlignTextToFramePadding();
      ImGui::Text(tr("Author:"));
      ImGui::TableNextColumn();
      if (ImGui::InputText("##theme_author", theme_author,
                           sizeof(theme_author))) {
        edit_theme.author = std::string(theme_author);
      }
 
      ImGui::EndTable();
    }
 
    ImGui::Separator();
 
    // Enhanced theme editing with tabs for better organization
    if (ImGui::BeginTabBar("ThemeEditorTabs", ImGuiTabBarFlags_None)) {
      // Apply live preview on first frame if enabled
      static bool first_frame = true;
      if (first_frame && live_preview) {
        apply_live_preview();
        first_frame = false;
      }
 
      // Primary Colors Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Primary", ICON_MD_COLOR_LENS).c_str())) {
 
        // Accent Color Generator Section
        ImGui::PushStyleColor(ImGuiCol_ChildBg,
                              ImVec4(0.1f, 0.1f, 0.12f, 0.5f));
        ImGui::BeginChild("AccentGenerator", ImVec2(0, 120), true);
 
        ImGui::TextColored(ImVec4(0.7f, 0.8f, 1.0f, 1.0f),
                           tr("%s Generate Theme from Accent Color"),
                           ICON_MD_AUTO_FIX_HIGH);
        ImGui::Separator();
 
        static Color accent_picker_color = {0.4f, 0.6f, 0.9f, 1.0f};
        static bool dark_mode_generate = true;
 
        ImGui::Text(tr("Accent Color:"));
        ImGui::SameLine();
        ImVec4 accent_vec = ConvertColorToImVec4(accent_picker_color);
        if (ImGui::ColorEdit3("##AccentPicker", &accent_vec.x,
                              ImGuiColorEditFlags_NoInputs)) {
          accent_picker_color = {accent_vec.x, accent_vec.y, accent_vec.z,
                                 1.0f};
        }
 
        ImGui::SameLine();
        ImGui::Checkbox(tr("Dark Mode"), &dark_mode_generate);
 
        ImGui::SameLine();
        if (ImGui::Button(absl::StrFormat("%s Generate", ICON_MD_BOLT).c_str(),
                          ImVec2(120, 0))) {
          // Generate and apply theme from accent color
          Theme generated =
              GenerateThemeFromAccent(accent_picker_color, dark_mode_generate);
          edit_theme = generated;
          apply_live_preview();
        }
 
        // Show color harmony preview
        ImGui::Text(tr("Preview: "));
        ImGui::SameLine();
 
        // Show primary, secondary, background as color swatches
        Theme preview_theme =
            GenerateThemeFromAccent(accent_picker_color, dark_mode_generate);
        ImVec4 prev_primary = ConvertColorToImVec4(preview_theme.primary);
        ImVec4 prev_secondary = ConvertColorToImVec4(preview_theme.secondary);
        ImVec4 prev_bg = ConvertColorToImVec4(preview_theme.background);
        ImVec4 prev_surface = ConvertColorToImVec4(preview_theme.surface);
 
        ImGui::ColorButton("##prev_primary", prev_primary, 0, ImVec2(24, 24));
        ImGui::SameLine(0, 2);
        ImGui::ColorButton("##prev_secondary", prev_secondary, 0,
                           ImVec2(24, 24));
        ImGui::SameLine(0, 2);
        ImGui::ColorButton("##prev_bg", prev_bg, 0, ImVec2(24, 24));
        ImGui::SameLine(0, 2);
        ImGui::ColorButton("##prev_surface", prev_surface, 0, ImVec2(24, 24));
 
        ImGui::EndChild();
        ImGui::PopStyleColor();
 
        ImGui::Spacing();
 
        if (ImGui::BeginTable("PrimaryColorsTable", 3,
                              ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Color", ImGuiTableColumnFlags_WidthFixed,
                                  120.0f);
          ImGui::TableSetupColumn("Picker", ImGuiTableColumnFlags_WidthStretch,
                                  0.6f);
          ImGui::TableSetupColumn("Preview", ImGuiTableColumnFlags_WidthStretch,
                                  0.4f);
          ImGui::TableHeadersRow();
 
          // Primary color
          ImGui::TableNextRow();
          ImGui::TableNextColumn();
          ImGui::AlignTextToFramePadding();
          ImGui::Text(tr("Primary:"));
          ImGui::TableNextColumn();
          ImVec4 primary = ConvertColorToImVec4(edit_theme.primary);
          if (ImGui::ColorEdit3("##primary", &primary.x)) {
            edit_theme.primary = {primary.x, primary.y, primary.z, primary.w};
            apply_live_preview();
          }
          ImGui::TableNextColumn();
          ImGui::Button(tr("Primary Preview"), ImVec2(-1, 30));
 
          // Secondary color
          ImGui::TableNextRow();
          ImGui::TableNextColumn();
          ImGui::AlignTextToFramePadding();
          ImGui::Text(tr("Secondary:"));
          ImGui::TableNextColumn();
          ImVec4 secondary = ConvertColorToImVec4(edit_theme.secondary);
          if (ImGui::ColorEdit3("##secondary", &secondary.x)) {
            edit_theme.secondary = {secondary.x, secondary.y, secondary.z,
                                    secondary.w};
            apply_live_preview();
          }
          ImGui::TableNextColumn();
          ImGui::PushStyleColor(ImGuiCol_Button, secondary);
          ImGui::Button(tr("Secondary Preview"), ImVec2(-1, 30));
          ImGui::PopStyleColor();
 
          // Accent color
          ImGui::TableNextRow();
          ImGui::TableNextColumn();
          ImGui::AlignTextToFramePadding();
          ImGui::Text(tr("Accent:"));
          ImGui::TableNextColumn();
          ImVec4 accent = ConvertColorToImVec4(edit_theme.accent);
          if (ImGui::ColorEdit3("##accent", &accent.x)) {
            edit_theme.accent = {accent.x, accent.y, accent.z, accent.w};
            apply_live_preview();
          }
          ImGui::TableNextColumn();
          ImGui::PushStyleColor(ImGuiCol_Button, accent);
          ImGui::Button(tr("Accent Preview"), ImVec2(-1, 30));
          ImGui::PopStyleColor();
 
          // Background color
          ImGui::TableNextRow();
          ImGui::TableNextColumn();
          ImGui::AlignTextToFramePadding();
          ImGui::Text(tr("Background:"));
          ImGui::TableNextColumn();
          ImVec4 background = ConvertColorToImVec4(edit_theme.background);
          if (ImGui::ColorEdit4("##background", &background.x)) {
            edit_theme.background = {background.x, background.y, background.z,
                                     background.w};
            apply_live_preview();
          }
          ImGui::TableNextColumn();
          ImGui::Text(tr("Background preview shown in window"));
 
          ImGui::EndTable();
        }
        ImGui::EndTabItem();
      }
 
      // Text Colors Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Text", ICON_MD_TEXT_FIELDS).c_str())) {
        if (ImGui::BeginTable("TextColorsTable", 3,
                              ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Color", ImGuiTableColumnFlags_WidthFixed,
                                  120.0f);
          ImGui::TableSetupColumn("Picker", ImGuiTableColumnFlags_WidthStretch,
                                  0.6f);
          ImGui::TableSetupColumn("Preview", ImGuiTableColumnFlags_WidthStretch,
                                  0.4f);
          ImGui::TableHeadersRow();
 
          // Text colors with live preview
          auto text_colors = std::vector<std::pair<const char*, Color*>>{
              {"Primary Text", &edit_theme.text_primary},
              {"Secondary Text", &edit_theme.text_secondary},
              {"Disabled Text", &edit_theme.text_disabled},
              {"Link Text", &edit_theme.text_link},
              {"Text Highlight", &edit_theme.text_highlight},
              {"Link Hover", &edit_theme.link_hover},
              {"Text Selected BG", &edit_theme.text_selected_bg},
              {"Input Text Cursor", &edit_theme.input_text_cursor}};
 
          for (auto& [label, color_ptr] : text_colors) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text("%s:", label);
 
            ImGui::TableNextColumn();
            ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
            std::string id = absl::StrFormat("##%s", label);
            if (ImGui::ColorEdit3(id.c_str(), &color_vec.x)) {
              *color_ptr = {color_vec.x, color_vec.y, color_vec.z, color_vec.w};
              apply_live_preview();
            }
 
            ImGui::TableNextColumn();
            ImGui::PushStyleColor(ImGuiCol_Text, color_vec);
            ImGui::Text(tr("Sample %s"), label);
            ImGui::PopStyleColor();
          }
 
          ImGui::EndTable();
        }
        ImGui::EndTabItem();
      }
 
      // Interactive Elements Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Interactive", ICON_MD_TOUCH_APP).c_str())) {
        if (ImGui::BeginTable("InteractiveColorsTable", 3,
                              ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Element", ImGuiTableColumnFlags_WidthFixed,
                                  120.0f);
          ImGui::TableSetupColumn("Picker", ImGuiTableColumnFlags_WidthStretch,
                                  0.6f);
          ImGui::TableSetupColumn("Preview", ImGuiTableColumnFlags_WidthStretch,
                                  0.4f);
          ImGui::TableHeadersRow();
 
          // Interactive element colors
          auto interactive_colors =
              std::vector<std::tuple<const char*, Color*, ImGuiCol>>{
                  {"Button", &edit_theme.button, ImGuiCol_Button},
                  {"Button Hovered", &edit_theme.button_hovered,
                   ImGuiCol_ButtonHovered},
                  {"Button Active", &edit_theme.button_active,
                   ImGuiCol_ButtonActive},
                  {"Frame Background", &edit_theme.frame_bg, ImGuiCol_FrameBg},
                  {"Frame BG Hovered", &edit_theme.frame_bg_hovered,
                   ImGuiCol_FrameBgHovered},
                  {"Frame BG Active", &edit_theme.frame_bg_active,
                   ImGuiCol_FrameBgActive},
                  {"Check Mark", &edit_theme.check_mark, ImGuiCol_CheckMark},
                  {"Slider Grab", &edit_theme.slider_grab, ImGuiCol_SliderGrab},
                  {"Slider Grab Active", &edit_theme.slider_grab_active,
                   ImGuiCol_SliderGrabActive}};
 
          for (auto& [label, color_ptr, imgui_col] : interactive_colors) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text("%s:", label);
 
            ImGui::TableNextColumn();
            ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
            std::string id = absl::StrFormat("##%s", label);
            if (ImGui::ColorEdit3(id.c_str(), &color_vec.x)) {
              *color_ptr = {color_vec.x, color_vec.y, color_vec.z, color_vec.w};
              apply_live_preview();
            }
 
            ImGui::TableNextColumn();
            ImGui::PushStyleColor(imgui_col, color_vec);
            ImGui::Button(absl::StrFormat("Preview %s", label).c_str(),
                          ImVec2(-1, 30));
            ImGui::PopStyleColor();
          }
 
          ImGui::EndTable();
        }
        ImGui::EndTabItem();
      }
 
      // Style Parameters Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Style", ICON_MD_TUNE).c_str())) {
        ImGui::Text(tr("Rounding and Border Settings:"));
 
        if (ImGui::SliderFloat(tr("Window Rounding"),
                               &edit_theme.window_rounding, 0.0f, 20.0f)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
        if (ImGui::SliderFloat(tr("Frame Rounding"), &edit_theme.frame_rounding,
                               0.0f, 20.0f)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
        if (ImGui::SliderFloat(tr("Scrollbar Rounding"),
                               &edit_theme.scrollbar_rounding, 0.0f, 20.0f)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
        if (ImGui::SliderFloat(tr("Tab Rounding"), &edit_theme.tab_rounding,
                               0.0f, 20.0f)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
        if (ImGui::SliderFloat(tr("Grab Rounding"), &edit_theme.grab_rounding,
                               0.0f, 20.0f)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
 
        ImGui::Separator();
        ImGui::Text(tr("Border Sizes:"));
 
        if (ImGui::SliderFloat(tr("Window Border Size"),
                               &edit_theme.window_border_size, 0.0f, 3.0f)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
        if (ImGui::SliderFloat(tr("Frame Border Size"),
                               &edit_theme.frame_border_size, 0.0f, 3.0f)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
 
        ImGui::Separator();
        ImGui::Text(tr("Animation & Effects:"));
 
        if (ImGui::Checkbox(tr("Enable Animations"),
                            &edit_theme.enable_animations)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
        if (edit_theme.enable_animations) {
          if (ImGui::SliderFloat(tr("Animation Speed"),
                                 &edit_theme.animation_speed, 0.1f, 3.0f)) {
            apply_live_preview();
          }
        }
        if (ImGui::Checkbox(tr("Enable Glow Effects"),
                            &edit_theme.enable_glow_effects)) {
          if (live_preview)
            ApplyTheme(edit_theme);
        }
 
        ImGui::EndTabItem();
      }
 
      // Navigation & Windows Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Navigation", ICON_MD_NAVIGATION).c_str())) {
        if (ImGui::BeginTable("NavigationTable", 3,
                              ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Element", ImGuiTableColumnFlags_WidthFixed,
                                  120.0f);
          ImGui::TableSetupColumn("Picker", ImGuiTableColumnFlags_WidthStretch,
                                  0.6f);
          ImGui::TableSetupColumn("Preview", ImGuiTableColumnFlags_WidthStretch,
                                  0.4f);
          ImGui::TableHeadersRow();
 
          // Window colors
          auto window_colors =
              std::vector<std::tuple<const char*, Color*, const char*>>{
                  {"Window Background", &edit_theme.window_bg,
                   "Main window background"},
                  {"Child Background", &edit_theme.child_bg,
                   "Child window background"},
                  {"Popup Background", &edit_theme.popup_bg,
                   "Popup window background"},
                  {"Modal Background", &edit_theme.modal_bg,
                   "Modal window background"},
                  {"Menu Bar BG", &edit_theme.menu_bar_bg,
                   "Menu bar background"}};
 
          for (auto& [label, color_ptr, description] : window_colors) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text("%s:", label);
 
            ImGui::TableNextColumn();
            ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
            std::string id = absl::StrFormat("##window_%s", label);
            if (ImGui::ColorEdit4(id.c_str(), &color_vec.x)) {
              *color_ptr = {color_vec.x, color_vec.y, color_vec.z, color_vec.w};
              apply_live_preview();
            }
 
            ImGui::TableNextColumn();
            ImGui::TextWrapped("%s", description);
          }
 
          ImGui::EndTable();
        }
 
        ImGui::Separator();
 
        // Header and Tab colors
        if (ImGui::CollapsingHeader(tr("Headers & Tabs"),
                                    ImGuiTreeNodeFlags_DefaultOpen)) {
          if (ImGui::BeginTable("HeaderTabTable", 3,
                                ImGuiTableFlags_SizingStretchProp)) {
            ImGui::TableSetupColumn("Element", ImGuiTableColumnFlags_WidthFixed,
                                    120.0f);
            ImGui::TableSetupColumn("Picker",
                                    ImGuiTableColumnFlags_WidthStretch, 0.6f);
            ImGui::TableSetupColumn("Preview",
                                    ImGuiTableColumnFlags_WidthStretch, 0.4f);
            ImGui::TableHeadersRow();
 
            auto header_tab_colors =
                std::vector<std::pair<const char*, Color*>>{
                    {"Header", &edit_theme.header},
                    {"Header Hovered", &edit_theme.header_hovered},
                    {"Header Active", &edit_theme.header_active},
                    {"Tab", &edit_theme.tab},
                    {"Tab Hovered", &edit_theme.tab_hovered},
                    {"Tab Active", &edit_theme.tab_active},
                    {"Tab Unfocused", &edit_theme.tab_unfocused},
                    {"Tab Unfocused Active", &edit_theme.tab_unfocused_active},
                    {"Tab Dimmed", &edit_theme.tab_dimmed},
                    {"Tab Dimmed Selected", &edit_theme.tab_dimmed_selected},
                    {"Title Background", &edit_theme.title_bg},
                    {"Title BG Active", &edit_theme.title_bg_active},
                    {"Title BG Collapsed", &edit_theme.title_bg_collapsed}};
 
            for (auto& [label, color_ptr] : header_tab_colors) {
              ImGui::TableNextRow();
              ImGui::TableNextColumn();
              ImGui::AlignTextToFramePadding();
              ImGui::Text("%s:", label);
 
              ImGui::TableNextColumn();
              ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
              std::string id = absl::StrFormat("##header_%s", label);
              if (ImGui::ColorEdit3(id.c_str(), &color_vec.x)) {
                *color_ptr = {color_vec.x, color_vec.y, color_vec.z,
                              color_vec.w};
                apply_live_preview();
              }
 
              ImGui::TableNextColumn();
              ImGui::PushStyleColor(ImGuiCol_Button, color_vec);
              ImGui::Button(absl::StrFormat("Preview %s", label).c_str(),
                            ImVec2(-1, 25));
              ImGui::PopStyleColor();
            }
 
            ImGui::EndTable();
          }
        }
 
        // Navigation and Special Elements
        if (ImGui::CollapsingHeader(tr("Navigation & Special"))) {
          if (ImGui::BeginTable("NavSpecialTable", 3,
                                ImGuiTableFlags_SizingStretchProp)) {
            ImGui::TableSetupColumn("Element", ImGuiTableColumnFlags_WidthFixed,
                                    120.0f);
            ImGui::TableSetupColumn("Picker",
                                    ImGuiTableColumnFlags_WidthStretch, 0.6f);
            ImGui::TableSetupColumn("Description",
                                    ImGuiTableColumnFlags_WidthStretch, 0.4f);
            ImGui::TableHeadersRow();
 
            auto nav_special_colors =
                std::vector<std::tuple<const char*, Color*, const char*>>{
                    {"Nav Cursor", &edit_theme.nav_cursor,
                     "Navigation cursor color"},
                    {"Nav Win Highlight", &edit_theme.nav_windowing_highlight,
                     "Window selection highlight"},
                    {"Nav Win Dim BG", &edit_theme.nav_windowing_dim_bg,
                     "Background dimming for navigation"},
                    {"Modal Win Dim BG", &edit_theme.modal_window_dim_bg,
                     "Background dimming for modals"},
                    {"Drag Drop Target", &edit_theme.drag_drop_target,
                     "Drag and drop target highlight"},
                    {"Docking Preview", &edit_theme.docking_preview,
                     "Docking area preview"},
                    {"Docking Empty BG", &edit_theme.docking_empty_bg,
                     "Empty docking space background"}};
 
            for (auto& [label, color_ptr, description] : nav_special_colors) {
              ImGui::TableNextRow();
              ImGui::TableNextColumn();
              ImGui::AlignTextToFramePadding();
              ImGui::Text("%s:", label);
 
              ImGui::TableNextColumn();
              ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
              std::string id = absl::StrFormat("##nav_%s", label);
              if (ImGui::ColorEdit4(id.c_str(), &color_vec.x)) {
                *color_ptr = {color_vec.x, color_vec.y, color_vec.z,
                              color_vec.w};
                apply_live_preview();
              }
 
              ImGui::TableNextColumn();
              ImGui::TextWrapped("%s", description);
            }
 
            ImGui::EndTable();
          }
        }
 
        ImGui::EndTabItem();
      }
 
      // Tables & Data Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Tables", ICON_MD_TABLE_CHART).c_str())) {
        if (ImGui::BeginTable("TablesDataTable", 3,
                              ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Element", ImGuiTableColumnFlags_WidthFixed,
                                  120.0f);
          ImGui::TableSetupColumn("Picker", ImGuiTableColumnFlags_WidthStretch,
                                  0.6f);
          ImGui::TableSetupColumn("Description",
                                  ImGuiTableColumnFlags_WidthStretch, 0.4f);
          ImGui::TableHeadersRow();
 
          auto table_colors =
              std::vector<std::tuple<const char*, Color*, const char*>>{
                  {"Table Header BG", &edit_theme.table_header_bg,
                   "Table column headers"},
                  {"Table Border Strong", &edit_theme.table_border_strong,
                   "Outer table borders"},
                  {"Table Border Light", &edit_theme.table_border_light,
                   "Inner table borders"},
                  {"Table Row BG", &edit_theme.table_row_bg,
                   "Normal table rows"},
                  {"Table Row BG Alt", &edit_theme.table_row_bg_alt,
                   "Alternating table rows"},
                  {"Tree Lines", &edit_theme.tree_lines,
                   "Tree view connection lines"}};
 
          for (auto& [label, color_ptr, description] : table_colors) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text("%s:", label);
 
            ImGui::TableNextColumn();
            ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
            std::string id = absl::StrFormat("##table_%s", label);
            if (ImGui::ColorEdit4(id.c_str(), &color_vec.x)) {
              *color_ptr = {color_vec.x, color_vec.y, color_vec.z, color_vec.w};
              apply_live_preview();
            }
 
            ImGui::TableNextColumn();
            ImGui::TextWrapped("%s", description);
          }
 
          ImGui::EndTable();
        }
 
        ImGui::Separator();
 
        // Plots and Graphs
        if (ImGui::CollapsingHeader(tr("Plots & Graphs"))) {
          if (ImGui::BeginTable("PlotsTable", 3,
                                ImGuiTableFlags_SizingStretchProp)) {
            ImGui::TableSetupColumn("Element", ImGuiTableColumnFlags_WidthFixed,
                                    120.0f);
            ImGui::TableSetupColumn("Picker",
                                    ImGuiTableColumnFlags_WidthStretch, 0.6f);
            ImGui::TableSetupColumn("Description",
                                    ImGuiTableColumnFlags_WidthStretch, 0.4f);
            ImGui::TableHeadersRow();
 
            auto plot_colors =
                std::vector<std::tuple<const char*, Color*, const char*>>{
                    {"Plot Lines", &edit_theme.plot_lines, "Line plot color"},
                    {"Plot Lines Hovered", &edit_theme.plot_lines_hovered,
                     "Line plot hover color"},
                    {"Plot Histogram", &edit_theme.plot_histogram,
                     "Histogram fill color"},
                    {"Plot Histogram Hovered",
                     &edit_theme.plot_histogram_hovered,
                     "Histogram hover color"}};
 
            for (auto& [label, color_ptr, description] : plot_colors) {
              ImGui::TableNextRow();
              ImGui::TableNextColumn();
              ImGui::AlignTextToFramePadding();
              ImGui::Text("%s:", label);
 
              ImGui::TableNextColumn();
              ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
              std::string id = absl::StrFormat("##plot_%s", label);
              if (ImGui::ColorEdit3(id.c_str(), &color_vec.x)) {
                *color_ptr = {color_vec.x, color_vec.y, color_vec.z,
                              color_vec.w};
                apply_live_preview();
              }
 
              ImGui::TableNextColumn();
              ImGui::TextWrapped("%s", description);
            }
 
            ImGui::EndTable();
          }
        }
 
        ImGui::EndTabItem();
      }
 
      // Borders & Controls Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Borders", ICON_MD_BORDER_ALL).c_str())) {
        if (ImGui::BeginTable("BordersControlsTable", 3,
                              ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Element", ImGuiTableColumnFlags_WidthFixed,
                                  120.0f);
          ImGui::TableSetupColumn("Picker", ImGuiTableColumnFlags_WidthStretch,
                                  0.6f);
          ImGui::TableSetupColumn("Description",
                                  ImGuiTableColumnFlags_WidthStretch, 0.4f);
          ImGui::TableHeadersRow();
 
          auto border_control_colors =
              std::vector<std::tuple<const char*, Color*, const char*>>{
                  {"Border", &edit_theme.border, "General border color"},
                  {"Border Shadow", &edit_theme.border_shadow,
                   "Border shadow/depth"},
                  {"Separator", &edit_theme.separator,
                   "Horizontal/vertical separators"},
                  {"Separator Hovered", &edit_theme.separator_hovered,
                   "Separator hover state"},
                  {"Separator Active", &edit_theme.separator_active,
                   "Separator active/dragged state"},
                  {"Scrollbar BG", &edit_theme.scrollbar_bg,
                   "Scrollbar track background"},
                  {"Scrollbar Grab", &edit_theme.scrollbar_grab,
                   "Scrollbar handle"},
                  {"Scrollbar Grab Hovered", &edit_theme.scrollbar_grab_hovered,
                   "Scrollbar handle hover"},
                  {"Scrollbar Grab Active", &edit_theme.scrollbar_grab_active,
                   "Scrollbar handle active"},
                  {"Resize Grip", &edit_theme.resize_grip,
                   "Window resize grip"},
                  {"Resize Grip Hovered", &edit_theme.resize_grip_hovered,
                   "Resize grip hover"},
                  {"Resize Grip Active", &edit_theme.resize_grip_active,
                   "Resize grip active"}};
 
          for (auto& [label, color_ptr, description] : border_control_colors) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text("%s:", label);
 
            ImGui::TableNextColumn();
            ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
            std::string id = absl::StrFormat("##border_%s", label);
            if (ImGui::ColorEdit4(id.c_str(), &color_vec.x)) {
              *color_ptr = {color_vec.x, color_vec.y, color_vec.z, color_vec.w};
              apply_live_preview();
            }
 
            ImGui::TableNextColumn();
            ImGui::TextWrapped("%s", description);
          }
 
          ImGui::EndTable();
        }
 
        ImGui::EndTabItem();
      }
 
      // Enhanced Colors Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Enhanced", ICON_MD_AUTO_AWESOME).c_str())) {
        ImGui::Text(
            tr("Enhanced semantic colors and editor-specific customization"));
        ImGui::Separator();
 
        // Enhanced semantic colors section
        if (ImGui::CollapsingHeader(tr("Enhanced Semantic Colors"),
                                    ImGuiTreeNodeFlags_DefaultOpen)) {
          if (ImGui::BeginTable("EnhancedSemanticTable", 3,
                                ImGuiTableFlags_SizingStretchProp)) {
            ImGui::TableSetupColumn("Color", ImGuiTableColumnFlags_WidthFixed,
                                    120.0f);
            ImGui::TableSetupColumn("Picker",
                                    ImGuiTableColumnFlags_WidthStretch, 0.6f);
            ImGui::TableSetupColumn("Description",
                                    ImGuiTableColumnFlags_WidthStretch, 0.4f);
            ImGui::TableHeadersRow();
 
            auto enhanced_colors =
                std::vector<std::tuple<const char*, Color*, const char*>>{
                    {"Code Background", &edit_theme.code_background,
                     "Code blocks background"},
                    {"Success Light", &edit_theme.success_light,
                     "Light success variant"},
                    {"Warning Light", &edit_theme.warning_light,
                     "Light warning variant"},
                    {"Error Light", &edit_theme.error_light,
                     "Light error variant"},
                    {"Info Light", &edit_theme.info_light,
                     "Light info variant"}};
 
            for (auto& [label, color_ptr, description] : enhanced_colors) {
              ImGui::TableNextRow();
              ImGui::TableNextColumn();
              ImGui::AlignTextToFramePadding();
              ImGui::Text("%s:", label);
 
              ImGui::TableNextColumn();
              ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
              std::string id = absl::StrFormat("##enhanced_%s", label);
              if (ImGui::ColorEdit3(id.c_str(), &color_vec.x)) {
                *color_ptr = {color_vec.x, color_vec.y, color_vec.z,
                              color_vec.w};
                apply_live_preview();
              }
 
              ImGui::TableNextColumn();
              ImGui::TextWrapped("%s", description);
            }
 
            ImGui::EndTable();
          }
        }
 
        // UI State colors section
        if (ImGui::CollapsingHeader(tr("UI State Colors"))) {
          if (ImGui::BeginTable("UIStateTable", 3,
                                ImGuiTableFlags_SizingStretchProp)) {
            ImGui::TableSetupColumn("Color", ImGuiTableColumnFlags_WidthFixed,
                                    120.0f);
            ImGui::TableSetupColumn("Picker",
                                    ImGuiTableColumnFlags_WidthStretch, 0.6f);
            ImGui::TableSetupColumn("Description",
                                    ImGuiTableColumnFlags_WidthStretch, 0.4f);
            ImGui::TableHeadersRow();
 
            // UI state colors with alpha support where needed
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text(tr("Active Selection:"));
            ImGui::TableNextColumn();
            ImVec4 active_selection =
                ConvertColorToImVec4(edit_theme.active_selection);
            if (ImGui::ColorEdit4("##active_selection", &active_selection.x)) {
              edit_theme.active_selection = {
                  active_selection.x, active_selection.y, active_selection.z,
                  active_selection.w};
              apply_live_preview();
            }
            ImGui::TableNextColumn();
            ImGui::TextWrapped(tr("Active/selected UI elements"));
 
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text(tr("Hover Highlight:"));
            ImGui::TableNextColumn();
            ImVec4 hover_highlight =
                ConvertColorToImVec4(edit_theme.hover_highlight);
            if (ImGui::ColorEdit4("##hover_highlight", &hover_highlight.x)) {
              edit_theme.hover_highlight = {
                  hover_highlight.x, hover_highlight.y, hover_highlight.z,
                  hover_highlight.w};
              apply_live_preview();
            }
            ImGui::TableNextColumn();
            ImGui::TextWrapped(tr("General hover state highlighting"));
 
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text(tr("Focus Border:"));
            ImGui::TableNextColumn();
            ImVec4 focus_border = ConvertColorToImVec4(edit_theme.focus_border);
            if (ImGui::ColorEdit3("##focus_border", &focus_border.x)) {
              edit_theme.focus_border = {focus_border.x, focus_border.y,
                                         focus_border.z, focus_border.w};
              apply_live_preview();
            }
            ImGui::TableNextColumn();
            ImGui::TextWrapped(tr("Border for focused input elements"));
 
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::AlignTextToFramePadding();
            ImGui::Text(tr("Disabled Overlay:"));
            ImGui::TableNextColumn();
            ImVec4 disabled_overlay =
                ConvertColorToImVec4(edit_theme.disabled_overlay);
            if (ImGui::ColorEdit4("##disabled_overlay", &disabled_overlay.x)) {
              edit_theme.disabled_overlay = {
                  disabled_overlay.x, disabled_overlay.y, disabled_overlay.z,
                  disabled_overlay.w};
              apply_live_preview();
            }
            ImGui::TableNextColumn();
            ImGui::TextWrapped(
                tr("Semi-transparent overlay for disabled elements"));
 
            ImGui::EndTable();
          }
        }
 
        // Editor-specific colors section
        if (ImGui::CollapsingHeader(tr("Editor-Specific Colors"))) {
          if (ImGui::BeginTable("EditorColorsTable", 3,
                                ImGuiTableFlags_SizingStretchProp)) {
            ImGui::TableSetupColumn("Color", ImGuiTableColumnFlags_WidthFixed,
                                    120.0f);
            ImGui::TableSetupColumn("Picker",
                                    ImGuiTableColumnFlags_WidthStretch, 0.6f);
            ImGui::TableSetupColumn("Description",
                                    ImGuiTableColumnFlags_WidthStretch, 0.4f);
            ImGui::TableHeadersRow();
 
            auto editor_colors =
                std::vector<std::tuple<const char*, Color*, const char*, bool>>{
                    {"Editor Background", &edit_theme.editor_background,
                     "Main editor canvas background", false},
                    {"Editor Grid", &edit_theme.editor_grid,
                     "Grid lines in map/graphics editors", true},
                    {"Editor Cursor", &edit_theme.editor_cursor,
                     "Cursor color in editors", false},
                    {"Editor Selection", &edit_theme.editor_selection,
                     "Selection highlight in editors", true}};
 
            for (auto& [label, color_ptr, description, use_alpha] :
                 editor_colors) {
              ImGui::TableNextRow();
              ImGui::TableNextColumn();
              ImGui::AlignTextToFramePadding();
              ImGui::Text("%s:", label);
 
              ImGui::TableNextColumn();
              ImVec4 color_vec = ConvertColorToImVec4(*color_ptr);
              std::string id = absl::StrFormat("##editor_%s", label);
              if (use_alpha ? ImGui::ColorEdit4(id.c_str(), &color_vec.x)
                            : ImGui::ColorEdit3(id.c_str(), &color_vec.x)) {
                *color_ptr = {color_vec.x, color_vec.y, color_vec.z,
                              color_vec.w};
                apply_live_preview();
              }
 
              ImGui::TableNextColumn();
              ImGui::TextWrapped("%s", description);
            }
 
            ImGui::EndTable();
          }
        }
 
        ImGui::EndTabItem();
      }
 
      // Density & Layout Tab
      if (ImGui::BeginTabItem(
              absl::StrFormat("%s Density", ICON_MD_DENSITY_SMALL).c_str())) {
        ImGui::Text(tr("Control UI density, spacing, and typography scaling"));
        ImGui::Separator();
 
        // Density Preset Selector
        ImGui::TextColored(ImVec4(0.7f, 0.8f, 1.0f, 1.0f),
                           tr("%s Quick Presets"), ICON_MD_TUNE);
        ImGui::Spacing();
 
        // Get current preset
        int current_preset = static_cast<int>(edit_theme.density_preset);
 
        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(20, 12));
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(12, 0));
 
        // Compact button
        bool is_compact = (current_preset == 0);
        if (is_compact) {
          ImGui::PushStyleColor(
              ImGuiCol_Button,
              ImVec4(edit_theme.accent.red, edit_theme.accent.green,
                     edit_theme.accent.blue, 0.8f));
        }
        if (ImGui::Button(
                absl::StrFormat("%s Compact", ICON_MD_COMPRESS).c_str(),
                ImVec2(130, 50))) {
          edit_theme.ApplyDensityPreset(DensityPreset::kCompact);
          apply_live_preview();
        }
        if (is_compact) {
          ImGui::PopStyleColor();
        }
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip(
              tr("Dense UI with smaller widgets and tighter spacing\n"
                 "Best for: Information-dense workflows"));
        }
 
        ImGui::SameLine();
 
        // Normal button
        bool is_normal = (current_preset == 1);
        if (is_normal) {
          ImGui::PushStyleColor(
              ImGuiCol_Button,
              ImVec4(edit_theme.accent.red, edit_theme.accent.green,
                     edit_theme.accent.blue, 0.8f));
        }
        if (ImGui::Button(absl::StrFormat("%s Normal", ICON_MD_CHECK).c_str(),
                          ImVec2(130, 50))) {
          edit_theme.ApplyDensityPreset(DensityPreset::kNormal);
          apply_live_preview();
        }
        if (is_normal) {
          ImGui::PopStyleColor();
        }
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip(
              tr("Balanced spacing and widget sizes\n"
                 "Best for: General use"));
        }
 
        ImGui::SameLine();
 
        // Comfortable button
        bool is_comfortable = (current_preset == 2);
        if (is_comfortable) {
          ImGui::PushStyleColor(
              ImGuiCol_Button,
              ImVec4(edit_theme.accent.red, edit_theme.accent.green,
                     edit_theme.accent.blue, 0.8f));
        }
        if (ImGui::Button(
                absl::StrFormat("%s Comfortable", ICON_MD_EXPAND).c_str(),
                ImVec2(130, 50))) {
          edit_theme.ApplyDensityPreset(DensityPreset::kComfortable);
          apply_live_preview();
        }
        if (is_comfortable) {
          ImGui::PopStyleColor();
        }
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip(
              tr("Spacious layout with larger click targets\n"
                 "Best for: Touch screens, accessibility"));
        }
 
        ImGui::PopStyleVar(2);
 
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::Spacing();
 
        // Advanced Controls
        if (ImGui::CollapsingHeader(tr("Advanced Density Controls"))) {
          ImGui::Indent();
 
          ImGui::Text(tr("Fine-tune individual spacing multipliers:"));
          ImGui::Spacing();
 
          // Compact factor slider
          if (ImGui::SliderFloat(tr("Compact Factor"),
                                 &edit_theme.compact_factor, 0.5f, 1.5f,
                                 "%.2f")) {
            apply_live_preview();
          }
          if (ImGui::IsItemHovered()) {
            ImGui::SetTooltip(
                tr("Global density multiplier (0.5 = very compact, "
                   "1.5 = very spacious)"));
          }
 
          ImGui::Spacing();
 
          // Widget height
          if (ImGui::SliderFloat(tr("Widget Height"),
                                 &edit_theme.widget_height_multiplier, 0.6f,
                                 1.5f, "%.2f")) {
            apply_live_preview();
          }
 
          // Spacing
          if (ImGui::SliderFloat(tr("Item Spacing"),
                                 &edit_theme.spacing_multiplier, 0.5f, 1.5f,
                                 "%.2f")) {
            apply_live_preview();
          }
 
          // Toolbar height
          if (ImGui::SliderFloat(tr("Toolbar Height"),
                                 &edit_theme.toolbar_height_multiplier, 0.5f,
                                 1.2f, "%.2f")) {
            apply_live_preview();
          }
 
          // Panel padding
          if (ImGui::SliderFloat(tr("Panel Padding"),
                                 &edit_theme.panel_padding_multiplier, 0.5f,
                                 1.5f, "%.2f")) {
            apply_live_preview();
          }
 
          // Button padding
          if (ImGui::SliderFloat(tr("Button Padding"),
                                 &edit_theme.button_padding_multiplier, 0.5f,
                                 1.5f, "%.2f")) {
            apply_live_preview();
          }
 
          // Table row height
          if (ImGui::SliderFloat(tr("Table Row Height"),
                                 &edit_theme.table_row_height_multiplier, 0.7f,
                                 1.5f, "%.2f")) {
            apply_live_preview();
          }
 
          ImGui::Unindent();
        }
 
        // Style Rounding Controls
        if (ImGui::CollapsingHeader(tr("Corner Rounding"))) {
          ImGui::Indent();
 
          if (ImGui::SliderFloat(tr("Window Rounding"),
                                 &edit_theme.window_rounding, 0.0f, 20.0f,
                                 "%.1f")) {
            apply_live_preview();
          }
 
          if (ImGui::SliderFloat(tr("Frame Rounding"),
                                 &edit_theme.frame_rounding, 0.0f, 12.0f,
                                 "%.1f")) {
            apply_live_preview();
          }
 
          if (ImGui::SliderFloat(tr("Tab Rounding"), &edit_theme.tab_rounding,
                                 0.0f, 12.0f, "%.1f")) {
            apply_live_preview();
          }
 
          if (ImGui::SliderFloat(tr("Scrollbar Rounding"),
                                 &edit_theme.scrollbar_rounding, 0.0f, 12.0f,
                                 "%.1f")) {
            apply_live_preview();
          }
 
          if (ImGui::SliderFloat(tr("Grab Rounding"), &edit_theme.grab_rounding,
                                 0.0f, 12.0f, "%.1f")) {
            apply_live_preview();
          }
 
          ImGui::Unindent();
        }
 
        // Animation Settings
        if (ImGui::CollapsingHeader(tr("Animation Settings"))) {
          ImGui::Indent();
 
          if (ImGui::Checkbox(tr("Enable Animations"),
                              &edit_theme.enable_animations)) {
            apply_live_preview();
          }
 
          if (edit_theme.enable_animations) {
            if (ImGui::SliderFloat(tr("Animation Speed"),
                                   &edit_theme.animation_speed, 0.5f, 2.0f,
                                   "%.2f")) {
              apply_live_preview();
            }
          }
 
          if (ImGui::Checkbox(tr("Enable Glow Effects"),
                              &edit_theme.enable_glow_effects)) {
            apply_live_preview();
          }
 
          ImGui::Unindent();
        }
 
        ImGui::EndTabItem();
      }
 
      ImGui::EndTabBar();
    }
 
    ImGui::Separator();
 
    if (ImGui::Button(tr("Preview Theme"))) {
      ApplyTheme(edit_theme);
    }
 
    ImGui::SameLine();
    if (ImGui::Button(tr("Reset to Current"))) {
      edit_theme = current_theme_;
      // Safe string copy with bounds checking
      size_t name_len =
          std::min(current_theme_.name.length(), sizeof(theme_name) - 1);
      std::memcpy(theme_name, current_theme_.name.c_str(), name_len);
      theme_name[name_len] = '\0';
 
      size_t desc_len = std::min(current_theme_.description.length(),
                                 sizeof(theme_description) - 1);
      std::memcpy(theme_description, current_theme_.description.c_str(),
                  desc_len);
      theme_description[desc_len] = '\0';
 
      size_t author_len =
          std::min(current_theme_.author.length(), sizeof(theme_author) - 1);
      std::memcpy(theme_author, current_theme_.author.c_str(), author_len);
      theme_author[author_len] = '\0';
 
      // Reset backup state since we're back to current theme
      if (theme_backup_made) {
        theme_backup_made = false;
        // Restore-the-canonical-theme, so it must route through ReapplyTheme:
        // ApplyToImGui cannot reproduce ColorsYaze() for Classic YAZE. Copy
        // first — ReapplyTheme reassigns current_theme_.
        const Theme restored = current_theme_;
        ReapplyTheme(restored);
      }
    }
 
    ImGui::SameLine();
    if (ImGui::Button(tr("Save Theme"))) {
      edit_theme.name = std::string(theme_name);
      edit_theme.description = std::string(theme_description);
      edit_theme.author = std::string(theme_author);
 
      // Add to themes map and apply
      themes_[edit_theme.name] = edit_theme;
      ApplyTheme(edit_theme);
 
      // Reset backup state since theme is now applied
      theme_backup_made = false;
    }
 
    ImGui::SameLine();
 
    // Save Over Current button - overwrites the current theme file
    std::string current_file_path = GetCurrentThemeFilePath();
    bool can_save_over = !current_file_path.empty();
 
    if (!can_save_over) {
      ImGui::BeginDisabled();
    }
 
    if (ImGui::Button(tr("Save Over Current"))) {
      edit_theme.name = std::string(theme_name);
      edit_theme.description = std::string(theme_description);
      edit_theme.author = std::string(theme_author);
 
      auto status = SaveThemeToFile(edit_theme, current_file_path);
      if (status.ok()) {
        // Update themes map and apply
        themes_[edit_theme.name] = edit_theme;
        ApplyTheme(edit_theme);
        theme_backup_made =
            false;  // Reset backup state since theme is now applied
      } else {
        LOG_ERROR("Theme Manager", "Failed to save over current theme");
      }
    }
 
    if (!can_save_over) {
      ImGui::EndDisabled();
    }
 
    if (ImGui::IsItemHovered() && can_save_over) {
      ImGui::BeginTooltip();
      ImGui::Text(tr("Save over current theme file:"));
      ImGui::Text("%s", current_file_path.c_str());
      ImGui::EndTooltip();
    } else if (ImGui::IsItemHovered()) {
      ImGui::BeginTooltip();
      ImGui::Text(tr("No current theme file to overwrite"));
      ImGui::Text(tr("Use 'Save to File...' to create a new theme file"));
      ImGui::EndTooltip();
    }
 
    ImGui::SameLine();
    if (ImGui::Button(tr("Save to File..."))) {
      edit_theme.name = std::string(theme_name);
      edit_theme.description = std::string(theme_description);
      edit_theme.author = std::string(theme_author);
 
      // Use save file dialog with proper defaults
      std::string safe_name =
          edit_theme.name.empty() ? "custom_theme" : edit_theme.name;
      auto file_path =
          util::FileDialogWrapper::ShowSaveFileDialog(safe_name, "theme");
 
      if (!file_path.empty()) {
        // Ensure .theme extension
        if (file_path.find(".theme") == std::string::npos) {
          file_path += ".theme";
        }
 
        auto status = SaveThemeToFile(edit_theme, file_path);
        if (status.ok()) {
          // Also add to themes map for immediate use
          themes_[edit_theme.name] = edit_theme;
          ApplyTheme(edit_theme);
        } else {
          LOG_ERROR("Theme Manager", "Failed to save theme");
        }
      }
    }
 
    if (ImGui::IsItemHovered()) {
      ImGui::BeginTooltip();
      ImGui::Text(tr("Save theme to a .theme file"));
      ImGui::Text(tr("Saved themes can be shared and loaded later"));
      ImGui::EndTooltip();
    }
  }
  ImGui::End();
}
 
std::vector<std::string> ThemeManager::GetThemeSearchPaths() const {
  std::vector<std::string> search_paths;
 
  // Priority 1: User themes directory (~/.yaze/themes/)
  // This is the primary location for user-installed and custom themes
  auto config_dir = util::PlatformPaths::GetConfigDirectory();
  if (config_dir.ok()) {
    auto user_themes = *config_dir / "themes";
    // Ensure the directory exists for user themes
    (void)util::PlatformPaths::EnsureDirectoryExists(user_themes);
    search_paths.push_back(user_themes.string() + "/");
  }
 
  // Priority 2: Application bundle/install themes. Keep this aligned with
  // every other runtime asset instead of maintaining platform-specific paths.
  if (auto themes = util::PlatformPaths::FindAsset("themes"); themes.ok()) {
    search_paths.push_back(themes->string() + "/");
  }
 
  // Priority 3: Legacy development paths (relative to working directory)
  search_paths.push_back("assets/themes/");
  search_paths.push_back("../assets/themes/");
#ifdef _WIN32
  search_paths.push_back("./assets/themes/");
  search_paths.push_back("./themes/");
#endif
 
  return search_paths;
}
 
std::string ThemeManager::GetThemesDirectory() const {
  auto search_paths = GetThemeSearchPaths();
 
  // Try each search path and return the first one that exists
  for (const auto& path : search_paths) {
    std::ifstream test_file(
        path + ".");  // Test if directory exists by trying to access it
    if (test_file.good()) {
      return path;
    }
 
    // Also try with platform-specific directory separators
    std::string normalized_path = path;
    if (!normalized_path.empty() && normalized_path.back() != '/' &&
        normalized_path.back() != '\\') {
      normalized_path += "/";
    }
 
    std::ifstream test_file2(normalized_path + ".");
    if (test_file2.good()) {
      return normalized_path;
    }
  }
 
  return search_paths.empty() ? "assets/themes/" : search_paths[0];
}
 
std::string ThemeManager::GetUserThemesDirectory() const {
  // Always return the user themes directory (~/.yaze/themes/)
  // This is the canonical location for user-created and exported themes
  auto config_dir = util::PlatformPaths::GetConfigDirectory();
  if (config_dir.ok()) {
    auto user_themes_path = *config_dir / "themes";
    // Ensure the directory exists
    (void)util::PlatformPaths::EnsureDirectoryExists(user_themes_path);
    return user_themes_path.string() + "/";
  }
 
  // Fallback to development path if config directory unavailable
  return "assets/themes/";
}
 
std::vector<std::string> ThemeManager::DiscoverAvailableThemeFiles() const {
  std::vector<std::string> theme_files;
  auto search_paths = GetThemeSearchPaths();
 
  for (const auto& search_path : search_paths) {
    try {
      std::filesystem::path dir_path(search_path);
 
      // Skip if directory doesn't exist
      std::error_code ec;
      if (!std::filesystem::exists(dir_path, ec) || ec) {
        continue;
      }
 
      if (!std::filesystem::is_directory(dir_path, ec) || ec) {
        continue;
      }
 
      // Iterate directory entries using std::filesystem (cross-platform)
      for (const auto& entry :
           std::filesystem::directory_iterator(dir_path, ec)) {
        if (ec) {
          LOG_WARN("Theme Manager", "Error iterating directory: %s",
                   ec.message().c_str());
          break;
        }
 
        if (!entry.is_regular_file(ec) || ec) {
          continue;
        }
 
        std::string filename = entry.path().filename().string();
        std::string extension = entry.path().extension().string();
 
        // Accept both .theme and .theme.json extensions
        if (extension == ".theme" ||
            (filename.length() > 11 &&
             filename.substr(filename.length() - 11) == ".theme.json")) {
          theme_files.push_back(entry.path().string());
        }
      }
    } catch (const std::exception& e) {
      LOG_WARN("Theme Manager", "Error scanning directory %s: %s",
               search_path.c_str(), e.what());
    }
  }
 
  // Remove duplicates while preserving order (user themes take priority)
  std::vector<std::string> unique_files;
  std::set<std::string> seen_basenames;
 
  for (const auto& file : theme_files) {
    std::string basename = util::GetFileName(file);
    // Normalize basename by removing both .theme and .theme.json extensions
    if (basename.length() > 11 &&
        basename.substr(basename.length() - 11) == ".theme.json") {
      basename = basename.substr(0, basename.length() - 11);
    } else if (basename.length() > 6 &&
               basename.substr(basename.length() - 6) == ".theme") {
      basename = basename.substr(0, basename.length() - 6);
    }
 
    if (seen_basenames.find(basename) == seen_basenames.end()) {
      unique_files.push_back(file);
      seen_basenames.insert(basename);
    }
  }
 
  LOG_INFO("Theme Manager", "Discovered %zu theme files", unique_files.size());
  return unique_files;
}
 
absl::Status ThemeManager::LoadAllAvailableThemes() {
  auto theme_files = DiscoverAvailableThemeFiles();
 
  int successful_loads = 0;
  int failed_loads = 0;
 
  for (const auto& theme_file : theme_files) {
    auto status = LoadThemeFromFile(theme_file);
    if (status.ok()) {
      successful_loads++;
    } else {
      failed_loads++;
    }
  }
 
  if (successful_loads == 0 && failed_loads > 0) {
    return absl::InternalError(absl::StrFormat(
        "Failed to load any themes (%d failures)", failed_loads));
  }
 
  return absl::OkStatus();
}
 
absl::Status ThemeManager::RefreshAvailableThemes() {
  return LoadAllAvailableThemes();
}
 
std::string ThemeManager::GetCurrentThemeFilePath() const {
  if (current_theme_name_ == "Classic YAZE") {
    return "";  // Classic theme doesn't have a file
  }
 
  // Prefer the exact load path recorded when the theme file was discovered.
  // Names like "Majora's Moon" don't normalize back to majoras_moon.theme; the
  // stored path lets "Save Over Current" succeed without guessing the filename.
  auto path_it = theme_file_paths_.find(current_theme_name_);
  if (path_it != theme_file_paths_.end()) {
    std::ifstream test_file(path_it->second);
    if (test_file.good()) {
      return path_it->second;
    }
    // Stored path no longer valid (e.g., file moved after install). Fall
    // through to the filename-synthesis heuristic below.
  }
 
  // Fallback: synthesize a filename from the display name. Works for legacy
  // presets whose filenames match the name after alnum normalization.
  auto search_paths = GetThemeSearchPaths();
  std::string theme_filename = current_theme_name_ + ".theme";
 
  // Convert theme name to safe filename (replace spaces and special chars).
  // The cast is load-bearing, not decoration: std::isalnum takes an int whose
  // value must be representable as unsigned char or EOF, and plain `char` is
  // signed on the platforms this builds for. Any byte above 0x7F — every
  // continuation byte of a UTF-8 theme name such as "Rosé Pine" — arrives
  // negative and the call is undefined behaviour.
  for (char& c : theme_filename) {
    const auto byte = static_cast<unsigned char>(c);
    if (!std::isalnum(byte) && c != '.' && c != '_') {
      c = '_';
    }
  }
 
  for (const auto& search_path : search_paths) {
    std::string full_path = search_path + theme_filename;
    std::ifstream test_file(full_path);
    if (test_file.good()) {
      return full_path;
    }
  }
 
  // If not found, return path in the first search directory (for new saves)
  return search_paths.empty() ? theme_filename
                              : search_paths[0] + theme_filename;
}
 
}  // namespace gui
}  // namespace yaze