right_drawer_manager.cc

Go to the documentation of this file.

#include "app/editor/menu/right_drawer_manager.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <array>
#include <cctype>
#include <chrono>
#include <cmath>
#include <ctime>
#include <filesystem>
#include <optional>
#include <vector>
 
#include "absl/strings/str_format.h"
#include "absl/types/span.h"
#include "app/editor/agent/agent_chat.h"
#include "app/editor/core/content_registry.h"
#include "app/editor/hack/workflow/workflow_activity_widgets.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/shell/windows/project_management_panel.h"
#include "app/editor/shell/windows/selection_properties_panel.h"
#include "app/editor/shell/windows/settings_panel.h"
#include "app/editor/system/proposal_drawer.h"
#include "app/editor/system/shortcut_manager.h"
#include "app/gui/animation/animator.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/layout_helpers.h"
#include "app/gui/core/platform_keys.h"
#include "app/gui/core/style.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/core/ui_config.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/empty_state.h"
#include "app/gui/widgets/themed_widgets.h"
#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"
#include "util/json.h"
#include "util/log.h"
#include "util/platform_paths.h"
 
namespace yaze {
namespace editor {
 
namespace {
 
std::string ResolveAgentChatHistoryPath() {
  auto agent_dir = util::PlatformPaths::GetAppDataSubdirectory("agent");
  if (agent_dir.ok()) {
    return (*agent_dir / "agent_chat_history.json").string();
  }
  auto temp_dir = util::PlatformPaths::GetTempDirectory();
  if (temp_dir.ok()) {
    return (*temp_dir / "agent_chat_history.json").string();
  }
  return (std::filesystem::current_path() / "agent_chat_history.json").string();
}
 
std::string JsonValueToDisplayString(const Json& value) {
  if (value.is_string()) {
    return value.get<std::string>();
  }
  if (value.is_boolean()) {
    return value.get<bool>() ? "true" : "false";
  }
  if (value.is_number_integer()) {
    return std::to_string(value.get<long long>());
  }
  if (value.is_number_unsigned()) {
    return std::to_string(value.get<unsigned long long>());
  }
  if (value.is_number_float()) {
    return absl::StrFormat("%.3f", value.get<double>());
  }
  if (value.is_null()) {
    return "null";
  }
  return value.dump();
}
 
std::string SanitizeToolOutputIdFragment(const std::string& value) {
  std::string sanitized;
  sanitized.reserve(value.size());
  for (unsigned char ch : value) {
    if (std::isalnum(ch)) {
      sanitized.push_back(static_cast<char>(ch));
    } else {
      sanitized.push_back('_');
    }
  }
  return sanitized.empty() ? std::string("entry") : sanitized;
}
 
bool TryParseToolOutputJson(const std::string& text, Json* out) {
  if (!out || text.empty()) {
    return false;
  }
  try {
    *out = Json::parse(text);
    return out->is_object();
  } catch (...) {
    return false;
  }
}
 
std::optional<uint32_t> ParseToolOutputAddress(const Json& value) {
  if (value.is_number_unsigned()) {
    return static_cast<uint32_t>(value.get<uint64_t>());
  }
  if (value.is_number_integer()) {
    return static_cast<uint32_t>(value.get<int64_t>());
  }
  if (!value.is_string()) {
    return std::nullopt;
  }
 
  std::string token = value.get<std::string>();
  if (token.empty()) {
    return std::nullopt;
  }
  if (token[0] == '$') {
    token = token.substr(1);
  } else if (token.size() > 2 && token[0] == '0' &&
             (token[1] == 'x' || token[1] == 'X')) {
    token = token.substr(2);
  }
  try {
    return static_cast<uint32_t>(std::stoul(token, nullptr, 16));
  } catch (...) {
    return std::nullopt;
  }
}
 
std::optional<uint32_t> ExtractToolOutputAddress(const Json& object) {
  if (!object.is_object()) {
    return std::nullopt;
  }
  for (const char* key : {"address", "entry_address"}) {
    if (object.contains(key)) {
      auto parsed = ParseToolOutputAddress(object[key]);
      if (parsed.has_value()) {
        return parsed;
      }
    }
  }
  return std::nullopt;
}
 
std::string ExtractToolOutputReference(const Json& object) {
  if (!object.is_object()) {
    return {};
  }
  if (object.contains("source") && object["source"].is_string()) {
    return object["source"].get<std::string>();
  }
  if (object.contains("file") && object["file"].is_string()) {
    std::string reference = object["file"].get<std::string>();
    if (object.contains("line") && object["line"].is_number_integer()) {
      reference = absl::StrCat(reference, ":", object["line"].get<int>());
    }
    return reference;
  }
  return {};
}
 
std::string BuildToolOutputEntryTitle(const Json& object) {
  if (!object.is_object()) {
    return {};
  }
 
  const std::string address = object.contains("address")
                                  ? JsonValueToDisplayString(object["address"])
                                  : "";
  const std::string bank =
      object.contains("bank") ? JsonValueToDisplayString(object["bank"]) : "";
  const std::string name =
      object.contains("name") ? JsonValueToDisplayString(object["name"]) : "";
  const std::string source = ExtractToolOutputReference(object);
 
  if (!source.empty() && !address.empty()) {
    return absl::StrFormat("%s  (%s)", source.c_str(), address.c_str());
  }
  if (!name.empty() && !address.empty()) {
    return absl::StrFormat("%s  %s", name.c_str(), address.c_str());
  }
  if (!name.empty() && !bank.empty()) {
    return absl::StrFormat("%s  %s", name.c_str(), bank.c_str());
  }
  if (!source.empty()) {
    return source;
  }
  if (!address.empty()) {
    return address;
  }
  if (!bank.empty()) {
    return bank;
  }
  if (!name.empty()) {
    return name;
  }
  return {};
}
 
std::string BuildToolOutputActionLabel(const char* visible_label,
                                       const char* action_key,
                                       const Json& object) {
  const auto address = ExtractToolOutputAddress(object);
  if (address.has_value()) {
    return absl::StrFormat("%s##tool_output_%s_%06X", visible_label, action_key,
                           *address);
  }
 
  const std::string reference = ExtractToolOutputReference(object);
  if (!reference.empty()) {
    return absl::StrFormat("%s##tool_output_%s_%s", visible_label, action_key,
                           SanitizeToolOutputIdFragment(reference).c_str());
  }
 
  return absl::StrFormat("%s##tool_output_%s_entry", visible_label, action_key);
}
 
void DrawToolOutputEntryActions(
    const Json& object, const RightDrawerManager::ToolOutputActions& actions) {
  if (!object.is_object()) {
    return;
  }
 
  const std::string reference = ExtractToolOutputReference(object);
  const auto address = ExtractToolOutputAddress(object);
  bool drew_any = false;
 
  if (!reference.empty() && actions.on_open_reference) {
    const std::string label =
        BuildToolOutputActionLabel("Open", "open", object);
    if (ImGui::SmallButton(label.c_str())) {
      actions.on_open_reference(reference);
    }
    drew_any = true;
  }
  if (address.has_value() && actions.on_open_address) {
    if (drew_any) {
      ImGui::SameLine();
    }
    const std::string label =
        BuildToolOutputActionLabel("Addr", "addr", object);
    if (ImGui::SmallButton(label.c_str())) {
      actions.on_open_address(*address);
    }
    drew_any = true;
  }
  if (address.has_value() && actions.on_open_lookup) {
    if (drew_any) {
      ImGui::SameLine();
    }
    const std::string label =
        BuildToolOutputActionLabel("Lookup", "lookup", object);
    if (ImGui::SmallButton(label.c_str())) {
      actions.on_open_lookup(*address);
    }
  }
}
 
void DrawJsonObjectFields(const Json& object) {
  for (auto it = object.begin(); it != object.end(); ++it) {
    if (it.value().is_array() || it.value().is_object()) {
      continue;
    }
    ImGui::BulletText("%s: %s", it.key().c_str(),
                      JsonValueToDisplayString(it.value()).c_str());
  }
}
 
void DrawJsonObjectArraySection(
    const char* label, const Json& array,
    const RightDrawerManager::ToolOutputActions& actions) {
  if (!array.is_array() || array.empty()) {
    return;
  }
  if (!ImGui::CollapsingHeader(label, ImGuiTreeNodeFlags_DefaultOpen)) {
    return;
  }
  ImGui::PushID(label);
  for (size_t i = 0; i < array.size(); ++i) {
    const auto& entry = array[i];
    ImGui::PushID(static_cast<int>(i));
    if (entry.is_object()) {
      const std::string title = BuildToolOutputEntryTitle(entry);
      if (!title.empty()) {
        gui::ColoredText(title.c_str(), gui::GetOnSurfaceVec4());
      }
      DrawToolOutputEntryActions(entry, actions);
      if (!title.empty() || !entry.empty()) {
        ImGui::Spacing();
      }
      DrawJsonObjectFields(entry);
    } else {
      ImGui::BulletText("%s", JsonValueToDisplayString(entry).c_str());
    }
    if (i + 1 < array.size()) {
      ImGui::Separator();
    }
    ImGui::PopID();
  }
  ImGui::PopID();
}
 
std::string BuildSelectionContextSummary(const SelectionContext& selection) {
  if (selection.type == SelectionType::kNone) {
    return "";
  }
  std::string context =
      absl::StrFormat("Selection: %s", GetSelectionTypeName(selection.type));
  if (!selection.display_name.empty()) {
    context += absl::StrFormat("\nName: %s", selection.display_name);
  }
  if (selection.id >= 0) {
    context += absl::StrFormat("\nID: 0x%X", selection.id);
  }
  if (selection.secondary_id >= 0) {
    context += absl::StrFormat("\nSecondary: 0x%X", selection.secondary_id);
  }
  if (selection.read_only) {
    context += "\nRead Only: true";
  }
  return context;
}
 
void DrawWorkflowSummaryCard(
    const char* title, const char* fallback_icon,
    const ProjectWorkflowStatus& status,
    const std::function<void()>& cancel_callback = {}) {
  if (!status.visible) {
    return;
  }
 
  gui::ColoredTextF(workflow::WorkflowColor(status.state), "%s %s",
                    workflow::WorkflowIcon(status, fallback_icon), title);
  ImGui::TextWrapped("%s", status.summary.empty() ? status.label.c_str()
                                                  : status.summary.c_str());
  if (!status.detail.empty()) {
    ImGui::TextWrapped("%s", status.detail.c_str());
  }
  if (!status.output_tail.empty()) {
    ImGui::TextWrapped("%s", status.output_tail.c_str());
  }
  if (status.can_cancel && cancel_callback) {
    if (ImGui::SmallButton(ICON_MD_CANCEL " Cancel Build")) {
      cancel_callback();
    }
  }
}
 
void DrawWorkflowPreviewEntry(
    const ProjectWorkflowHistoryEntry& entry,
    const workflow::WorkflowActionCallbacks& callbacks) {
  gui::ColoredTextF(workflow::WorkflowColor(entry.status.state), "%s %s",
                    workflow::WorkflowIcon(
                        entry.status, entry.kind == "Run" ? ICON_MD_PLAY_ARROW
                                                          : ICON_MD_BUILD),
                    entry.kind.c_str());
  ImGui::SameLine();
  ImGui::TextDisabled("%s",
                      workflow::FormatHistoryTime(entry.timestamp).c_str());
  ImGui::TextWrapped("%s", entry.status.summary.empty()
                               ? entry.status.label.c_str()
                               : entry.status.summary.c_str());
  if (!entry.status.output_tail.empty()) {
    ImGui::TextWrapped("%s", entry.status.output_tail.c_str());
  }
  workflow::DrawHistoryActionRow(
      entry, callbacks, {.show_open_output = true, .show_copy_log = true});
}
 
}  // namespace
 
// Shared drawer catalog (persistent tabs, shortcuts, and command palette).
const std::array<DrawerCatalogEntry, 7> kDrawerCatalog = {{
    {RightDrawerManager::PanelType::kProject, "Project", ICON_MD_FOLDER_SPECIAL,
     "View: Toggle Project Panel"},
    {RightDrawerManager::PanelType::kProperties, "Properties", ICON_MD_LIST_ALT,
     "View: Toggle Properties Panel"},
    {RightDrawerManager::PanelType::kAgentChat, "AI Agent", ICON_MD_SMART_TOY,
     "View: Toggle AI Agent Panel"},
    {RightDrawerManager::PanelType::kProposals, "Proposals",
     ICON_MD_DESCRIPTION, "View: Toggle Proposals Panel"},
    {RightDrawerManager::PanelType::kNotifications, "Notifications",
     ICON_MD_NOTIFICATIONS, "View: Toggle Notifications Panel"},
    {RightDrawerManager::PanelType::kHelp, "Help", ICON_MD_HELP,
     "View: Toggle Help Panel"},
    {RightDrawerManager::PanelType::kSettings, "Settings", ICON_MD_SETTINGS,
     "View: Toggle Settings Panel"},
}};
 
namespace {
 
int FindRightPanelIndex(RightDrawerManager::PanelType type) {
  for (size_t i = 0; i < kDrawerCatalog.size(); ++i) {
    if (kDrawerCatalog[i].type == type) {
      return static_cast<int>(i);
    }
  }
  return -1;
}
 
RightDrawerManager::PanelType StepRightPanel(
    RightDrawerManager::PanelType current, int direction) {
  if (kDrawerCatalog.empty()) {
    return RightDrawerManager::PanelType::kNone;
  }
  int index = FindRightPanelIndex(current);
  if (index < 0) {
    index = 0;
  }
  const int size = static_cast<int>(kDrawerCatalog.size());
  const int next = (index + direction + size) % size;
  return kDrawerCatalog[static_cast<size_t>(next)].type;
}
 
}  // namespace
 
absl::Span<const DrawerCatalogEntry> GetDrawerCatalog() {
  return absl::MakeSpan(kDrawerCatalog);
}
 
const char* GetPanelShortcutAction(RightDrawerManager::PanelType type) {
  switch (type) {
    case RightDrawerManager::PanelType::kProject:
      return "View: Toggle Project Panel";
    case RightDrawerManager::PanelType::kAgentChat:
      return "View: Toggle AI Agent Panel";
    case RightDrawerManager::PanelType::kProposals:
      return "View: Toggle Proposals Panel";
    case RightDrawerManager::PanelType::kSettings:
      return "View: Toggle Settings Panel";
    case RightDrawerManager::PanelType::kHelp:
      return "View: Toggle Help Panel";
    case RightDrawerManager::PanelType::kNotifications:
      return "View: Toggle Notifications Panel";
    case RightDrawerManager::PanelType::kProperties:
      return "View: Toggle Properties Panel";
    case RightDrawerManager::PanelType::kNone:
    default:
      return "";
  }
}
 
const char* GetPanelTypeName(RightDrawerManager::PanelType type) {
  switch (type) {
    case RightDrawerManager::PanelType::kNone:
      return "None";
    case RightDrawerManager::PanelType::kAgentChat:
      return "AI Agent";
    case RightDrawerManager::PanelType::kProposals:
      return "Proposals";
    case RightDrawerManager::PanelType::kSettings:
      return "Settings";
    case RightDrawerManager::PanelType::kHelp:
      return "Help";
    case RightDrawerManager::PanelType::kNotifications:
      return "Notifications";
    case RightDrawerManager::PanelType::kProperties:
      return "Properties";
    case RightDrawerManager::PanelType::kProject:
      return "Project";
    case RightDrawerManager::PanelType::kToolOutput:
      return "Tool Output";
    default:
      return "Unknown";
  }
}
 
const char* GetPanelTypeIcon(RightDrawerManager::PanelType type) {
  switch (type) {
    case RightDrawerManager::PanelType::kNone:
      return "";
    case RightDrawerManager::PanelType::kAgentChat:
      return ICON_MD_SMART_TOY;
    case RightDrawerManager::PanelType::kProposals:
      return ICON_MD_DESCRIPTION;
    case RightDrawerManager::PanelType::kSettings:
      return ICON_MD_SETTINGS;
    case RightDrawerManager::PanelType::kHelp:
      return ICON_MD_HELP;
    case RightDrawerManager::PanelType::kNotifications:
      return ICON_MD_NOTIFICATIONS;
    case RightDrawerManager::PanelType::kProperties:
      return ICON_MD_LIST_ALT;
    case RightDrawerManager::PanelType::kProject:
      return ICON_MD_FOLDER_SPECIAL;
    case RightDrawerManager::PanelType::kToolOutput:
      return ICON_MD_ACCOUNT_TREE;
    default:
      return ICON_MD_HELP;
  }
}
 
std::string RightDrawerManager::PanelTypeKey(PanelType type) {
  switch (type) {
    case PanelType::kAgentChat:
      return "agent_chat";
    case PanelType::kProposals:
      return "proposals";
    case PanelType::kSettings:
      return "settings";
    case PanelType::kHelp:
      return "help";
    case PanelType::kNotifications:
      return "notifications";
    case PanelType::kProperties:
      return "properties";
    case PanelType::kProject:
      return "project";
    case PanelType::kToolOutput:
      return "tool_output";
    case PanelType::kNone:
    default:
      return "none";
  }
}
 
void RightDrawerManager::ToggleDrawer(PanelType type) {
  if (active_panel_ == type) {
    CloseDrawer();
  } else {
    // Opens the requested panel (also handles re-opening during close animation)
    OpenDrawer(type);
  }
}
 
void RightDrawerManager::ToggleLastDrawer() {
  if (active_panel_ != PanelType::kNone) {
    CloseDrawer();
    return;
  }
  OpenDrawer(last_active_panel_ == PanelType::kNone ? PanelType::kProject
                                                    : last_active_panel_);
}
 
void RightDrawerManager::SetToolOutput(std::string title, std::string query,
                                       std::string content,
                                       ToolOutputActions actions) {
  tool_output_title_ = std::move(title);
  tool_output_query_ = std::move(query);
  tool_output_content_ = std::move(content);
  tool_output_actions_ = std::move(actions);
}
 
bool RightDrawerManager::IsDrawerExpanded() const {
  return active_panel_ != PanelType::kNone || closing_;
}
 
void RightDrawerManager::OpenDrawer(PanelType type) {
  if (type == PanelType::kNone) {
    CloseDrawer();
    return;
  }
 
  // If we were closing, cancel the close animation
  closing_ = false;
  closing_panel_ = PanelType::kNone;
 
  active_panel_ = type;
  if (FindRightPanelIndex(type) >= 0) {
    last_active_panel_ = type;
  }
  animating_ = true;
  animation_target_ = 1.0f;
 
  // Check if animations are enabled
  if (!gui::GetAnimator().IsEnabled()) {
    panel_animation_ = 1.0f;
    animating_ = false;
  }
  // Otherwise keep current panel_animation_ for smooth transition
}
 
void RightDrawerManager::CloseDrawer() {
  if (!gui::GetAnimator().IsEnabled()) {
    // Instant close
    active_panel_ = PanelType::kNone;
    closing_ = false;
    closing_panel_ = PanelType::kNone;
    panel_animation_ = 0.0f;
    animating_ = false;
    return;
  }
 
  // Start close animation — keep the panel type so we can still draw it
  closing_ = true;
  closing_panel_ = active_panel_;
  active_panel_ = PanelType::kNone;
  animating_ = true;
  animation_target_ = 0.0f;
}
 
void RightDrawerManager::CycleDrawer(int direction) {
  if (direction == 0) {
    return;
  }
 
  const PanelType current_panel =
      (active_panel_ != PanelType::kNone) ? active_panel_ : closing_panel_;
  if (current_panel == PanelType::kNone) {
    return;
  }
 
  const int step = direction > 0 ? 1 : -1;
  OpenDrawer(StepRightPanel(current_panel, step));
}
 
void RightDrawerManager::OnHostVisibilityChanged(bool visible) {
  // Snap transition state to a stable endpoint. This avoids stale intermediate
  // frames being composited when the OS moves the app across spaces.
  (void)visible;
  closing_ = false;
  closing_panel_ = PanelType::kNone;
  animating_ = false;
 
  panel_animation_ = (active_panel_ == PanelType::kNone) ? 0.0f : 1.0f;
  animation_target_ = panel_animation_;
}
 
float RightDrawerManager::GetDrawerWidth() const {
  return GetExpandedDrawerWidth() * panel_animation_;
}
 
float RightDrawerManager::GetExpandedDrawerWidth() const {
  // Determine which panel to measure: active panel, or the one being closed
  PanelType effective_panel = active_panel_;
  if (effective_panel == PanelType::kNone && closing_) {
    effective_panel = closing_panel_;
  }
  if (effective_panel == PanelType::kNone) {
    return 0.0f;
  }
 
  ImGuiContext* context = ImGui::GetCurrentContext();
  if (!context) {
    return GetConfiguredPanelWidth(effective_panel);
  }
 
  const ImGuiViewport* viewport = ImGui::GetMainViewport();
  if (!viewport) {
    return GetConfiguredPanelWidth(effective_panel);
  }
 
  return GetClampedPanelWidth(effective_panel, viewport->WorkSize.x);
}
 
void RightDrawerManager::SetDrawerWidth(PanelType type, float width) {
  if (type == PanelType::kNone) {
    return;
  }
  float viewport_width = 0.0f;
  if (const ImGuiViewport* viewport = ImGui::GetMainViewport()) {
    viewport_width = viewport->WorkSize.x;
  }
  if (viewport_width <= 0.0f && ImGui::GetCurrentContext()) {
    viewport_width = ImGui::GetIO().DisplaySize.x;
  }
  const auto limits = GetSharedPanelSizeLimits();
  float clamped = std::max(limits.min_width, width);
  if (viewport_width > 0.0f) {
    const float ratio = viewport_width < 768.0f
                            ? std::max(0.88f, limits.max_width_ratio)
                            : limits.max_width_ratio;
    const float max_width = std::max(limits.min_width, viewport_width * ratio);
    clamped = std::clamp(clamped, limits.min_width, max_width);
  }
 
  if (std::abs(shared_width_ - clamped) < 0.5f) {
    return;
  }
  shared_width_ = clamped;
#if !defined(NDEBUG)
  LOG_INFO("RightDrawerManager",
           "SetDrawerWidth type=%d requested=%.1f clamped=%.1f",
           static_cast<int>(type), width, clamped);
#endif
  NotifyPanelWidthChanged(type, shared_width_);
}
 
void RightDrawerManager::ResetDrawerWidths() {
  float default_width =
      GetDefaultDrawerWidth(PanelType::kToolOutput, active_editor_type_);
  for (const DrawerCatalogEntry& entry : GetDrawerCatalog()) {
    default_width = std::max(
        default_width, GetDefaultDrawerWidth(entry.type, active_editor_type_));
  }
  SetDrawerWidth(PanelType::kProject, default_width);
}
 
float RightDrawerManager::GetDefaultDrawerWidth(PanelType type,
                                                EditorType editor) {
  switch (type) {
    case PanelType::kAgentChat:
      return std::max(gui::UIConfig::kPanelWidthAgentChat, 480.0f);
    case PanelType::kProposals:
      return std::max(gui::UIConfig::kPanelWidthProposals, 440.0f);
    case PanelType::kSettings:
      return std::max(gui::UIConfig::kPanelWidthSettings, 380.0f);
    case PanelType::kHelp:
      return std::max(gui::UIConfig::kPanelWidthHelp, 380.0f);
    case PanelType::kNotifications:
      return std::max(gui::UIConfig::kPanelWidthNotifications, 380.0f);
    case PanelType::kProperties:
      // Property panel can be wider in certain editors.
      if (editor == EditorType::kDungeon) {
        return 440.0f;
      }
      return std::max(gui::UIConfig::kPanelWidthProperties, 400.0f);
    case PanelType::kProject:
      return std::max(gui::UIConfig::kPanelWidthProject, 420.0f);
    case PanelType::kToolOutput:
      return 460.0f;
    default:
      return std::max(gui::UIConfig::kPanelWidthMedium, 380.0f);
  }
}
 
void RightDrawerManager::SetPanelSizeLimits(PanelType type,
                                            const PanelSizeLimits& limits) {
  if (type == PanelType::kNone) {
    return;
  }
  PanelSizeLimits normalized = limits;
  normalized.min_width =
      std::max(gui::UIConfig::kPanelMinWidthAbsolute, normalized.min_width);
  normalized.max_width_ratio =
      std::clamp(normalized.max_width_ratio, 0.25f, 0.95f);
  panel_size_limits_[PanelTypeKey(type)] = normalized;
}
 
RightDrawerManager::PanelSizeLimits RightDrawerManager::GetPanelSizeLimits(
    PanelType type) const {
  auto it = panel_size_limits_.find(PanelTypeKey(type));
  if (it != panel_size_limits_.end()) {
    return it->second;
  }
 
  PanelSizeLimits defaults;
  switch (type) {
    case PanelType::kAgentChat:
      defaults.min_width = gui::UIConfig::kPanelMinWidthAgentChat;
      defaults.max_width_ratio = 0.90f;
      break;
    case PanelType::kProposals:
      defaults.min_width = gui::UIConfig::kPanelMinWidthProposals;
      defaults.max_width_ratio = 0.86f;
      break;
    case PanelType::kSettings:
      defaults.min_width = gui::UIConfig::kPanelMinWidthSettings;
      defaults.max_width_ratio = 0.80f;
      break;
    case PanelType::kHelp:
      defaults.min_width = gui::UIConfig::kPanelMinWidthHelp;
      defaults.max_width_ratio = 0.80f;
      break;
    case PanelType::kNotifications:
      defaults.min_width = gui::UIConfig::kPanelMinWidthNotifications;
      defaults.max_width_ratio = 0.82f;
      break;
    case PanelType::kProperties:
      defaults.min_width = gui::UIConfig::kPanelMinWidthProperties;
      defaults.max_width_ratio = 0.90f;
      break;
    case PanelType::kProject:
      defaults.min_width = gui::UIConfig::kPanelMinWidthProject;
      defaults.max_width_ratio = 0.86f;
      break;
    case PanelType::kToolOutput:
      defaults.min_width = 360.0f;
      defaults.max_width_ratio = 0.88f;
      break;
    case PanelType::kNone:
    default:
      break;
  }
  return defaults;
}
 
RightDrawerManager::PanelSizeLimits
RightDrawerManager::GetSharedPanelSizeLimits() const {
  PanelSizeLimits shared{
      .min_width = gui::UIConfig::kPanelMinWidthAbsolute,
      .max_width_ratio = 0.95f,
  };
  const auto fold = [this, &shared](PanelType type) {
    const PanelSizeLimits limits = GetPanelSizeLimits(type);
    shared.min_width = std::max(shared.min_width, limits.min_width);
    shared.max_width_ratio =
        std::min(shared.max_width_ratio, limits.max_width_ratio);
  };
  for (const DrawerCatalogEntry& entry : GetDrawerCatalog()) {
    fold(entry.type);
  }
  fold(PanelType::kToolOutput);
  return shared;
}
 
float RightDrawerManager::GetConfiguredPanelWidth(PanelType type) const {
  return type == PanelType::kNone ? 0.0f : shared_width_;
}
 
float RightDrawerManager::GetClampedPanelWidth(PanelType type,
                                               float viewport_width) const {
  float width = GetConfiguredPanelWidth(type);
  if (width <= 0.0f) {
    return width;
  }
  const auto limits = GetSharedPanelSizeLimits();
  const float ratio = viewport_width < 768.0f
                          ? std::max(0.88f, limits.max_width_ratio)
                          : limits.max_width_ratio;
  const float max_width = std::max(limits.min_width, viewport_width * ratio);
  return std::clamp(width, limits.min_width, max_width);
}
 
void RightDrawerManager::NotifyPanelWidthChanged(PanelType type, float width) {
  if (on_panel_width_changed_) {
    on_panel_width_changed_(type, width);
  }
}
 
std::unordered_map<std::string, float>
RightDrawerManager::SerializeDrawerWidths() const {
  return {{"right_sidebar.shared", shared_width_}};
}
 
void RightDrawerManager::RestoreDrawerWidths(
    const std::unordered_map<std::string, float>& widths) {
#if !defined(NDEBUG)
  LOG_INFO("RightDrawerManager",
           "RestoreDrawerWidths: %zu entries from settings", widths.size());
#endif
  if (const auto shared = widths.find("right_sidebar.shared");
      shared != widths.end()) {
    SetDrawerWidth(PanelType::kProject, shared->second);
    return;
  }
 
  // One-way migration from #260's per-drawer map. Start at the widest
  // context-aware default, then retain any wider user value.
  float migrated =
      GetDefaultDrawerWidth(PanelType::kToolOutput, active_editor_type_);
  for (const DrawerCatalogEntry& entry : GetDrawerCatalog()) {
    migrated = std::max(migrated,
                        GetDefaultDrawerWidth(entry.type, active_editor_type_));
  }
  for (const DrawerCatalogEntry& entry : GetDrawerCatalog()) {
    if (const auto saved = widths.find(PanelTypeKey(entry.type));
        saved != widths.end()) {
      migrated = std::max(migrated, saved->second);
    }
  }
  if (const auto tool_output =
          widths.find(PanelTypeKey(PanelType::kToolOutput));
      tool_output != widths.end()) {
    migrated = std::max(migrated, tool_output->second);
  }
  SetDrawerWidth(PanelType::kProject, migrated);
}
 
void RightDrawerManager::Draw() {
  // Nothing to draw if no panel is active and no close animation running
  if (active_panel_ == PanelType::kNone && !closing_) {
    return;
  }
 
  // Handle Escape key to close panel
  if (active_panel_ != PanelType::kNone &&
      ImGui::IsKeyPressed(ImGuiKey_Escape)) {
    CloseDrawer();
    // Don't return — we need to start drawing the close animation this frame
    if (!closing_)
      return;
  }
 
  const bool animations_enabled = gui::GetAnimator().IsEnabled();
  if (!animations_enabled && animating_) {
    panel_animation_ = animation_target_;
    animating_ = false;
    if (closing_ && animation_target_ == 0.0f) {
      closing_ = false;
      closing_panel_ = PanelType::kNone;
      return;
    }
  }
 
  // Advance animation
  if (animating_ && animations_enabled) {
    // Clamp dt to avoid giant interpolation jumps after focus/space changes.
    float delta_time = std::clamp(ImGui::GetIO().DeltaTime, 0.0f, 1.0f / 20.0f);
    float speed = gui::UIConfig::kAnimationSpeed;
    switch (gui::GetAnimator().motion_profile()) {
      case gui::MotionProfile::kSnappy:
        speed *= 1.20f;
        break;
      case gui::MotionProfile::kRelaxed:
        speed *= 0.75f;
        break;
      case gui::MotionProfile::kStandard:
      default:
        break;
    }
    float diff = animation_target_ - panel_animation_;
    panel_animation_ += diff * std::min(1.0f, delta_time * speed);
 
    // Snap to target when close enough
    if (std::abs(animation_target_ - panel_animation_) <
        gui::UIConfig::kAnimationSnapThreshold) {
      panel_animation_ = animation_target_;
      animating_ = false;
 
      // Close animation finished — fully clean up
      if (closing_ && animation_target_ == 0.0f) {
        closing_ = false;
        closing_panel_ = PanelType::kNone;
        return;
      }
    }
  }
 
  // Determine which panel type to draw content for
  PanelType draw_panel = active_panel_;
  if (draw_panel == PanelType::kNone && closing_) {
    draw_panel = closing_panel_;
  }
 
  const ImGuiViewport* viewport = ImGui::GetMainViewport();
  const float viewport_width = viewport->WorkSize.x;
  const float top_inset = gui::LayoutHelpers::GetTopInset();
  const float bottom_safe = gui::LayoutHelpers::GetSafeAreaInsets().bottom;
  const float viewport_height =
      std::max(0.0f, viewport->WorkSize.y - top_inset - bottom_safe);
 
  // Keep full-width state explicit so drag-resize and animation remain stable.
  const float full_width =
      (draw_panel == PanelType::kNone)
          ? 0.0f
          : GetClampedPanelWidth(draw_panel, viewport_width);
  const float animated_width = full_width * panel_animation_;
 
  // Use SurfaceContainer for slightly elevated panel background
  ImVec4 panel_bg = gui::GetSurfaceContainerVec4();
  ImVec4 panel_border = gui::GetOutlineVec4();
 
  ImGuiWindowFlags panel_flags =
      ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove |
      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoDocking |
      ImGuiWindowFlags_NoNavFocus;
 
  // Position panel: slides from right edge. At animation=1.0, fully visible.
  // At animation=0.0, fully off-screen to the right.
  float panel_x = viewport->WorkPos.x + viewport_width - animated_width;
  ImGui::SetNextWindowPos(ImVec2(panel_x, viewport->WorkPos.y + top_inset));
  ImGui::SetNextWindowSize(ImVec2(full_width, viewport_height));
 
  gui::StyledWindow panel("##RightPanel",
                          {.bg = panel_bg,
                           .border = panel_border,
                           .padding = ImVec2(0.0f, 0.0f),
                           .border_size = 0.0f},
                          nullptr, panel_flags);
  if (panel) {
    const char* panel_title = GetPanelTypeName(draw_panel);
    const char* panel_icon = GetPanelTypeIcon(draw_panel);
    if (draw_panel == PanelType::kToolOutput && !tool_output_title_.empty()) {
      panel_title = tool_output_title_.c_str();
    }
    // Draw enhanced panel header and navigation strip
    DrawPanelHeader(draw_panel, panel_title, panel_icon);
    DrawDrawerNavStrip(draw_panel);
 
    // Content area with padding and minimum height so content never collapses
    gui::StyleVarGuard content_padding(
        ImGuiStyleVar_WindowPadding,
        ImVec2(gui::UIConfig::kPanelPaddingLarge,
               gui::UIConfig::kPanelPaddingMedium));
    const bool panel_content_open = gui::LayoutHelpers::BeginContentChild(
        "##PanelContent", ImVec2(0.0f, gui::UIConfig::kContentMinHeightList),
        ImGuiChildFlags_AlwaysUseWindowPadding);
    if (panel_content_open) {
      switch (draw_panel) {
        case PanelType::kAgentChat:
          DrawAgentChatPanel();
          break;
        case PanelType::kProposals:
          DrawProposalsPanel();
          break;
        case PanelType::kSettings:
          DrawSettingsPanel();
          break;
        case PanelType::kHelp:
          DrawHelpPanel();
          break;
        case PanelType::kNotifications:
          DrawNotificationsPanel();
          break;
        case PanelType::kProperties:
          DrawPropertiesPanel();
          break;
        case PanelType::kProject:
          DrawProjectPanel();
          break;
        case PanelType::kToolOutput:
          DrawToolOutputPanel();
          break;
        default:
          break;
      }
    }
    gui::LayoutHelpers::EndContentChild();
 
    // VSCode-style splitter: drag from the left edge to resize.
    if (!closing_ && active_panel_ != PanelType::kNone) {
      const float handle_width = gui::UIConfig::kSplitterWidth;
      const ImVec2 win_pos = ImGui::GetWindowPos();
      const float win_height = ImGui::GetWindowHeight();
      ImGui::SetCursorScreenPos(
          ImVec2(win_pos.x - handle_width * 0.5f, win_pos.y));
      ImGui::InvisibleButton("##RightPanelResizeHandle",
                             ImVec2(handle_width, win_height));
      const bool handle_hovered = ImGui::IsItemHovered();
      const bool handle_active = ImGui::IsItemActive();
      if (handle_hovered || handle_active) {
        ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
      }
      if (handle_hovered &&
          ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
        ResetDrawerWidths();
      }
      if (handle_active) {
        const float new_width = GetConfiguredPanelWidth(active_panel_) -
                                ImGui::GetIO().MouseDelta.x;
        SetDrawerWidth(active_panel_, new_width);
        ImGui::SetTooltip(tr("Width: %.0f px"),
                          GetConfiguredPanelWidth(active_panel_));
      }
 
      ImVec4 handle_color = gui::GetOutlineVec4();
      handle_color.w = handle_active ? 0.95f : (handle_hovered ? 0.72f : 0.35f);
      ImGui::GetWindowDrawList()->AddLine(
          ImVec2(win_pos.x, win_pos.y),
          ImVec2(win_pos.x, win_pos.y + win_height),
          ImGui::GetColorU32(handle_color), handle_active ? 2.0f : 1.0f);
    }
  }
}
 
void RightDrawerManager::DrawHeaderContextBadge(PanelType type,
                                                float available_width) {
  switch (type) {
    case PanelType::kAgentChat: {
#ifdef YAZE_BUILD_AGENT_UI
      if (agent_chat_ &&
          ImGui::CalcTextSize(ICON_MD_CIRCLE).x <= available_width) {
        gui::ColoredText(ICON_MD_CIRCLE, gui::GetSuccessVec4());
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip("%s", tr("Agent Ready"));
        }
      }
#endif
      break;
    }
    case PanelType::kNotifications: {
      if (toast_manager_) {
        const size_t unread = toast_manager_->GetUnreadCount();
        if (unread > 0) {
          const std::string badge = absl::StrFormat("%zu", unread);
          const ImVec2 badge_size = ImGui::CalcTextSize(badge.c_str());
          const float pad_x = 5.0f;
          const float badge_w = badge_size.x + pad_x * 2.0f;
          if (badge_w > available_width) {
            break;
          }
          const float badge_h = ImGui::GetTextLineHeight() + 2.0f;
          const ImVec2 p = ImGui::GetCursorScreenPos();
          ImDrawList* dl = ImGui::GetWindowDrawList();
          dl->AddRectFilled(p, ImVec2(p.x + badge_w, p.y + badge_h),
                            ImGui::GetColorU32(gui::GetPrimaryVec4()), 4.0f);
          dl->AddText(ImVec2(p.x + pad_x, p.y + 1.0f),
                      ImGui::GetColorU32(ImVec4(1.0f, 1.0f, 1.0f, 1.0f)),
                      badge.c_str());
          ImGui::Dummy(ImVec2(badge_w, badge_h));
          if (ImGui::IsItemHovered()) {
            ImGui::SetTooltip(tr("%zu unread notifications"), unread);
          }
        }
      }
      break;
    }
    case PanelType::kProperties: {
      if (properties_locked_ &&
          ImGui::CalcTextSize(ICON_MD_LOCK).x <= available_width) {
        gui::ColoredText(ICON_MD_LOCK, gui::GetWarningVec4());
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip("%s", tr("Selection Locked"));
        }
      }
      break;
    }
    case PanelType::kHelp: {
      const char* editor_name = nullptr;
      switch (active_editor_type_) {
        case EditorType::kOverworld:
          editor_name = "Overworld";
          break;
        case EditorType::kDungeon:
          editor_name = "Dungeon";
          break;
        case EditorType::kPalette:
          editor_name = "Palette";
          break;
        case EditorType::kGraphics:
          editor_name = "Graphics";
          break;
        case EditorType::kAssembly:
          editor_name = "Assembly";
          break;
        case EditorType::kMusic:
          editor_name = "Music";
          break;
        case EditorType::kMessage:
          editor_name = "Messages";
          break;
        default:
          break;
      }
      if (editor_name) {
        const ImVec4 tag_bg = gui::GetSurfaceContainerHighestVec4();
        const ImVec2 text_sz = ImGui::CalcTextSize(editor_name);
        const float pad = 5.0f;
        if (text_sz.x + pad * 2.0f > available_width) {
          break;
        }
        const ImVec2 p = ImGui::GetCursorScreenPos();
        ImDrawList* dl = ImGui::GetWindowDrawList();
        dl->AddRectFilled(
            p, ImVec2(p.x + text_sz.x + pad * 2.0f, p.y + text_sz.y + 2.0f),
            ImGui::GetColorU32(tag_bg), 4.0f);
        dl->AddText(ImVec2(p.x + pad, p.y + 1.0f),
                    ImGui::GetColorU32(gui::GetPrimaryVec4()), editor_name);
        ImGui::Dummy(ImVec2(text_sz.x + pad * 2.0f, text_sz.y + 2.0f));
      }
      break;
    }
    default:
      break;
  }
}
 
void RightDrawerManager::DrawHeaderActions(PanelType type [[maybe_unused]]) {
  // Panel-specific actions are handled inline within DrawPanelHeader.
}
 
void RightDrawerManager::DrawPanelHeader(PanelType type, const char* title,
                                         const char* icon) {
  const float header_height =
      gui::ScaledSize(0.0f, gui::UIConfig::kPanelHeaderHeight).y;
  const float padding =
      gui::ScaledSize(gui::UIConfig::kPanelPaddingLarge, 0.0f).x;
 
  // Keep the header on the drawer surface; the navigation divider supplies
  // separation without another outlined region around the title.
  ImVec2 header_min = ImGui::GetCursorScreenPos();
 
  ImDrawList* draw_list = ImGui::GetWindowDrawList();
  // Match the title's text color rather than introducing a separate accent.
  const float icon_chip_size = gui::ScaledSize(24.0f, 0.0f).x;
  const float chip_y = header_min.y + (header_height - icon_chip_size) * 0.5f;
  ImVec2 chip_min(header_min.x + padding, chip_y);
  const ImVec2 icon_sz = ImGui::CalcTextSize(icon);
  draw_list->AddText(ImVec2(chip_min.x + (icon_chip_size - icon_sz.x) * 0.5f,
                            chip_min.y + (icon_chip_size - icon_sz.y) * 0.5f),
                     ImGui::GetColorU32(gui::GetTextPrimaryVec4()), icon);
 
  // Reserve fixed chrome width so title truncation stays stable as badges /
  // panel actions appear. Layout (right → left): close, then panel actions.
  const ImVec2 chrome_btn_size = gui::ScaledSize(24.0f, 24.0f);
  const float chrome_gap = gui::ScaledSize(4.0f, 0.0f).x;
  int chrome_button_count = 1;  // close
  if (type == PanelType::kProperties) {
    chrome_button_count += 1;
  } else if (type == PanelType::kAgentChat) {
#ifdef YAZE_BUILD_AGENT_UI
    // Must match the draw path below (buttons only appear when agent_chat_).
    if (agent_chat_) {
      chrome_button_count += 2;
      if (proposal_drawer_) {
        chrome_button_count += 1;
      }
    }
#endif
  } else if (type == PanelType::kNotifications) {
    if (toast_manager_) {
      chrome_button_count += 2;
    }
  } else if (type == PanelType::kToolOutput) {
    if (!tool_output_content_.empty()) {
      chrome_button_count += 1;
    }
  } else if (type == PanelType::kHelp) {
    chrome_button_count += 1;
  }
  const float chrome_reserve =
      chrome_button_count * chrome_btn_size.x +
      std::max(0, chrome_button_count - 1) * chrome_gap + padding;
 
  // Title: truncate into the remaining space so drawer width no longer breathes
  // when chrome buttons appear/disappear.
  const float title_x = padding + icon_chip_size + 6.0f;
  const float title_y = ImGui::GetCursorPosY() +
                        (header_height - ImGui::GetTextLineHeight()) * 0.5f;
  ImGui::SetCursorPos(ImVec2(title_x, title_y));
  const float title_max_x =
      std::max(title_x, ImGui::GetWindowWidth() - chrome_reserve - 8.0f);
  const float title_avail = std::max(0.0f, title_max_x - title_x);
  ImVec2 title_size = ImGui::CalcTextSize(title);
  const ImVec2 text_min = ImGui::GetCursorScreenPos();
  const ImVec2 text_max =
      ImVec2(text_min.x + title_avail, text_min.y + ImGui::GetTextLineHeight());
  ImGui::RenderTextEllipsis(draw_list, text_min, text_max, text_max.x, title,
                            nullptr, &title_size);
  const float drawn_title_w = std::min(title_size.x, title_avail);
  ImGui::Dummy(ImVec2(drawn_title_w, ImGui::GetTextLineHeight()));
  if (title_size.x > title_avail && ImGui::IsItemHovered()) {
    ImGui::SetTooltip("%s", title);
  }
 
  // Dummy() advances to the next line and resets cursor X. Measure from the
  // title's right edge instead, then require the complete badge to fit.
  const float badge_x = title_x + drawn_title_w + 6.0f;
  if (badge_x < title_max_x) {
    ImGui::SameLine(0.0f, 6.0f);
    DrawHeaderContextBadge(type, title_max_x - badge_x);
  }
 
  // Right-aligned chrome buttons (right → left)
  const float btn_y = header_min.y + (header_height - chrome_btn_size.y) * 0.5f;
  float current_x = ImGui::GetWindowWidth() - chrome_btn_size.x - padding;
 
  // 1. Close Button
  ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
  if (gui::TransparentIconButton(
          ICON_MD_CANCEL, chrome_btn_size, "Close Drawer (Esc)", false,
          ImVec4(0, 0, 0, 0), "right_sidebar", "close_panel")) {
    CloseDrawer();
  }
 
  // Panel-specific quick actions
  if (type == PanelType::kProperties) {
    current_x -= (chrome_btn_size.x + chrome_gap);
    ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
    if (gui::TransparentIconButton(
            properties_locked_ ? ICON_MD_LOCK : ICON_MD_LOCK_OPEN,
            chrome_btn_size,
            properties_locked_ ? "Unlock Selection" : "Lock Selection",
            properties_locked_, ImVec4(0, 0, 0, 0), "right_sidebar",
            "lock_selection")) {
      properties_locked_ = !properties_locked_;
    }
  } else if (type == PanelType::kAgentChat) {
#ifdef YAZE_BUILD_AGENT_UI
    if (agent_chat_) {
      current_x -= (chrome_btn_size.x + chrome_gap);
      ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
      if (gui::TransparentIconButton(
              ICON_MD_DELETE_SWEEP, chrome_btn_size, "Clear Chat History",
              false, ImVec4(0, 0, 0, 0), "right_sidebar", "agent_clear_chat")) {
        agent_chat_->ClearHistory();
      }
      current_x -= (chrome_btn_size.x + chrome_gap);
      ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
      if (gui::TransparentIconButton(
              ICON_MD_SAVE_ALT, chrome_btn_size, "Save Chat History", false,
              ImVec4(0, 0, 0, 0), "right_sidebar", "agent_save_chat")) {
        agent_chat_->SaveHistory(ResolveAgentChatHistoryPath());
      }
      if (proposal_drawer_) {
        current_x -= (chrome_btn_size.x + chrome_gap);
        ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
        if (gui::TransparentIconButton(
                ICON_MD_DESCRIPTION, chrome_btn_size, "Open Proposals", false,
                ImVec4(0, 0, 0, 0), "right_sidebar", "agent_open_proposals")) {
          OpenDrawer(PanelType::kProposals);
        }
      }
    }
#endif
  } else if (type == PanelType::kNotifications) {
    if (toast_manager_) {
      current_x -= (chrome_btn_size.x + chrome_gap);
      ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
      if (gui::TransparentIconButton(
              ICON_MD_DELETE_SWEEP, chrome_btn_size, "Clear All Notifications",
              false, ImVec4(0, 0, 0, 0), "right_sidebar", "notif_clear_all")) {
        toast_manager_->ClearHistory();
      }
      current_x -= (chrome_btn_size.x + chrome_gap);
      ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
      if (gui::TransparentIconButton(ICON_MD_DONE_ALL, chrome_btn_size,
                                     "Mark All Read", false, ImVec4(0, 0, 0, 0),
                                     "right_sidebar", "notif_mark_read")) {
        toast_manager_->MarkAllRead();
      }
    }
  } else if (type == PanelType::kToolOutput) {
    if (!tool_output_content_.empty()) {
      current_x -= (chrome_btn_size.x + chrome_gap);
      ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
      if (gui::TransparentIconButton(ICON_MD_CONTENT_COPY, chrome_btn_size,
                                     "Copy Output", false, ImVec4(0, 0, 0, 0),
                                     "right_sidebar", "tool_copy_out")) {
        ImGui::SetClipboardText(tool_output_content_.c_str());
      }
    }
  } else if (type == PanelType::kHelp) {
    current_x -= (chrome_btn_size.x + chrome_gap);
    ImGui::SetCursorScreenPos(ImVec2(header_min.x + current_x, btn_y));
    if (gui::TransparentIconButton(
            ICON_MD_OPEN_IN_NEW, chrome_btn_size, "Open Online Documentation",
            false, ImVec4(0, 0, 0, 0), "right_sidebar", "help_open_docs")) {
      gui::OpenUrl("https://github.com/scawful/yaze/wiki");
    }
  }
 
  ImGui::SetCursorPosY(header_height);
}
 
void RightDrawerManager::DrawDrawerNavStrip(PanelType current_panel) {
  const float standard_height =
      std::max(24.0f, gui::LayoutHelpers::GetStandardWidgetHeight());
  const float padding =
      std::clamp(gui::LayoutHelpers::GetStandardSpacing(), 4.0f, 8.0f);
  const float gap = std::max(2.0f, padding * 0.5f);
  const float tab_h = standard_height;
  const float nav_height = tab_h + padding * 2.0f;
 
  const ImVec2 nav_min = ImGui::GetCursorScreenPos();
  const ImVec2 nav_max =
      ImVec2(nav_min.x + ImGui::GetWindowWidth(), nav_min.y + nav_height);
 
  ImDrawList* draw_list = ImGui::GetWindowDrawList();
  draw_list->AddRectFilled(nav_min, nav_max,
                           ImGui::GetColorU32(gui::GetSurfaceContainerVec4()));
  draw_list->AddLine(ImVec2(nav_min.x, nav_max.y), ImVec2(nav_max.x, nav_max.y),
                     ImGui::GetColorU32(gui::GetOutlineVec4()), 1.0f);
 
  const auto catalog = GetDrawerCatalog();
  const size_t count = catalog.size();
  if (count == 0) {
    ImGui::SetCursorPosY(ImGui::GetCursorPosY() + nav_height + 4.0f);
    return;
  }
 
  const float avail_w = ImGui::GetWindowWidth() - padding * 2.0f;
  const float tab_y = nav_min.y + (nav_height - tab_h) * 0.5f;
  std::vector<float> labeled_widths;
  labeled_widths.reserve(count);
  float labeled_total = gap * static_cast<float>(count - 1);
  for (const DrawerCatalogEntry& entry : catalog) {
    const std::string label = absl::StrFormat("%s %s", entry.icon, entry.name);
    const float width =
        std::max(tab_h, ImGui::CalcTextSize(label.c_str()).x + padding * 2.0f);
    labeled_widths.push_back(width);
    labeled_total += width;
  }
  const bool show_labels = labeled_total <= avail_w;
  const float extra_per_tab =
      show_labels ? std::max(0.0f, (avail_w - labeled_total) / count) : 0.0f;
  const float compact_tab_w =
      std::max(tab_h, std::floor((avail_w - (count - 1) * gap) / count));
  float tab_x = nav_min.x + padding;
 
  for (size_t i = 0; i < count; ++i) {
    const DrawerCatalogEntry& entry = catalog[i];
    const bool is_active = (current_panel == entry.type);
    const float tab_w =
        show_labels ? labeled_widths[i] + extra_per_tab : compact_tab_w;
 
    const ImVec2 tab_rect_min(tab_x, tab_y);
    const ImVec2 tab_rect_max(tab_x + tab_w, tab_y + tab_h);
 
    ImGui::SetCursorScreenPos(tab_rect_min);
    const std::string tab_id = absl::StrFormat("##drawer_nav_%zu_%s", i,
                                               entry.name ? entry.name : "x");
    if (ImGui::InvisibleButton(tab_id.c_str(), ImVec2(tab_w, tab_h))) {
      if (!is_active) {
        OpenDrawer(entry.type);
      }
    }
    const bool hovered = ImGui::IsItemHovered();
 
    if (hovered) {
      draw_list->AddRectFilled(
          tab_rect_min, tab_rect_max,
          ImGui::GetColorU32(gui::GetSurfaceContainerHighVec4()), 4.0f);
    }
    if (is_active) {
      draw_list->AddLine(ImVec2(tab_rect_min.x + 3.0f, tab_rect_max.y - 1.0f),
                         ImVec2(tab_rect_max.x - 3.0f, tab_rect_max.y - 1.0f),
                         ImGui::GetColorU32(gui::GetPrimaryVec4()), 2.0f);
    }
 
    const std::string tab_label =
        show_labels ? absl::StrFormat("%s %s", entry.icon, entry.name)
                    : std::string(entry.icon);
    const ImVec2 label_size = ImGui::CalcTextSize(tab_label.c_str());
    const ImVec2 label_pos(tab_rect_min.x + (tab_w - label_size.x) * 0.5f,
                           tab_rect_min.y + (tab_h - label_size.y) * 0.5f);
    const ImVec4 icon_col = (is_active || hovered)
                                ? gui::GetTextPrimaryVec4()
                                : gui::GetTextSecondaryVec4();
    draw_list->AddText(label_pos, ImGui::GetColorU32(icon_col),
                       tab_label.c_str());
 
    // Unread badge dot on Notifications tab
    if (entry.type == PanelType::kNotifications && toast_manager_ &&
        toast_manager_->GetUnreadCount() > 0) {
      draw_list->AddCircleFilled(
          ImVec2(tab_rect_max.x - 4.0f, tab_rect_min.y + 4.0f), 3.0f,
          ImGui::GetColorU32(gui::GetPrimaryVec4()));
    }
 
    if (hovered) {
      std::string tip = entry.name ? entry.name : "";
      if (entry.shortcut_action && entry.shortcut_action[0] != '\0') {
        const std::string sc = GetShortcutLabel(entry.shortcut_action, "");
        if (!sc.empty() && sc != "Unassigned") {
          tip = absl::StrFormat("%s (%s)", entry.name, sc.c_str());
        }
      }
      ImGui::SetTooltip("%s", tip.c_str());
    }
    tab_x += tab_w + gap;
  }
 
  // Advance cursor past the nav strip + small gap
  const float header_height =
      gui::ScaledSize(0.0f, gui::UIConfig::kPanelHeaderHeight).y;
  ImGui::SetCursorPosY(header_height + nav_height +
                       gui::ScaledSize(0.0f, 4.0f).y);
}
 
// =============================================================================
// Panel Styling Helpers
// =============================================================================
 
bool RightDrawerManager::BeginPanelSection(const char* label, const char* icon,
                                           bool default_open) {
  gui::StyleColorGuard section_colors({
      {ImGuiCol_Header, gui::GetSurfaceContainerHighVec4()},
      {ImGuiCol_HeaderHovered, gui::GetSurfaceContainerHighestVec4()},
      {ImGuiCol_HeaderActive, gui::GetSurfaceContainerHighestVec4()},
  });
  gui::StyleVarGuard section_vars({
      {ImGuiStyleVar_FramePadding, ImVec2(8.0f, 6.0f)},
      {ImGuiStyleVar_FrameRounding, 4.0f},
  });
 
  // Build header text with icon if provided
  std::string header_text;
  if (icon) {
    header_text = std::string(icon) + "  " + label;
  } else {
    header_text = label;
  }
 
  ImGuiTreeNodeFlags flags =
      ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_SpanAvailWidth |
      ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_FramePadding;
  if (default_open) {
    flags |= ImGuiTreeNodeFlags_DefaultOpen;
  }
 
  bool is_open = ImGui::TreeNodeEx(header_text.c_str(), flags);
 
  if (is_open) {
    ImGui::Spacing();
    ImGui::Indent(4.0f);
  }
 
  return is_open;
}
 
void RightDrawerManager::EndPanelSection() {
  ImGui::Unindent(4.0f);
  ImGui::TreePop();
  ImGui::Spacing();
}
 
void RightDrawerManager::DrawPanelDivider() {
  ImGui::Spacing();
  {
    gui::StyleColorGuard sep_color(ImGuiCol_Separator, gui::GetOutlineVec4());
    ImGui::Separator();
  }
  ImGui::Spacing();
}
 
void RightDrawerManager::DrawPanelLabel(const char* label) {
  gui::ColoredText(label, gui::GetTextSecondaryVec4());
}
 
void RightDrawerManager::DrawPanelValue(const char* label, const char* value) {
  gui::ColoredTextF(gui::GetTextSecondaryVec4(), "%s:", label);
  ImGui::SameLine();
  ImGui::TextUnformatted(value);
}
 
void RightDrawerManager::DrawPanelDescription(const char* text) {
  gui::StyleColorGuard desc_color(ImGuiCol_Text, gui::GetTextDisabledVec4());
  ImGui::PushTextWrapPos(ImGui::GetContentRegionAvail().x);
  ImGui::TextWrapped("%s", text);
  ImGui::PopTextWrapPos();
}
 
std::string RightDrawerManager::GetShortcutLabel(
    const std::string& action, const std::string& fallback) const {
  if (!shortcut_manager_) {
    return fallback;
  }
 
  const Shortcut* shortcut = shortcut_manager_->FindShortcut(action);
  if (!shortcut) {
    return fallback;
  }
  if (shortcut->keys.empty()) {
    return "Unassigned";
  }
 
  return PrintShortcut(shortcut->keys);
}
 
void RightDrawerManager::DrawShortcutRow(const std::string& action,
                                         const char* description,
                                         const std::string& fallback) {
  std::string label = GetShortcutLabel(action, fallback);
  DrawPanelValue(label.c_str(), description);
}
 
// =============================================================================
// Panel Content Drawing
// =============================================================================
 
void RightDrawerManager::DrawAgentChatPanel() {
#ifdef YAZE_BUILD_AGENT_UI
  if (!agent_chat_) {
    gui::ColoredText(ICON_MD_SMART_TOY " AI Agent Not Available",
                     gui::GetTextSecondaryVec4());
    ImGui::Spacing();
    DrawPanelDescription(
        "The AI Agent is not initialized. "
        "Open the AI Agent from View menu or use Ctrl+Shift+A.");
    return;
  }
 
  agent_chat_->set_active(true);
 
  // Actions (clear/save/proposals) have moved to the panel header.
  if (ImGui::BeginChild("AgentChatBody", ImVec2(0, 0), false)) {
    agent_chat_->Draw(0.0f);
  }
  ImGui::EndChild();
#else
  gui::ColoredText(ICON_MD_SMART_TOY " AI Agent Not Available",
                   gui::GetTextSecondaryVec4());
 
  ImGui::Spacing();
  DrawPanelDescription(
      "The AI Agent requires agent UI support. "
      "Build with YAZE_BUILD_AGENT_UI=ON to enable.");
#endif
}
 
bool RightDrawerManager::DrawAgentQuickActions() {
#ifdef YAZE_BUILD_AGENT_UI
  if (!agent_chat_) {
    return false;
  }
  const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
  const ImVec4 accent = gui::GetPrimaryVec4();
 
  std::string selection_context;
  if (properties_panel_ && properties_panel_->HasSelection()) {
    selection_context =
        BuildSelectionContextSummary(properties_panel_->GetSelection());
  }
 
  struct QuickAction {
    const char* label;
    std::string prompt;
  };
 
  std::vector<QuickAction> actions;
  if (!selection_context.empty()) {
    actions.push_back({"Explain selection",
                       "Explain this selection and how to edit it safely.\n\n" +
                           selection_context});
    actions.push_back(
        {"Suggest fixes",
         "Suggest improvements or checks for this selection.\n\n" +
             selection_context});
  }
 
  switch (active_editor_type_) {
    case EditorType::kOverworld:
      actions.push_back({"Summarize map",
                         "Summarize the current overworld map and its key "
                         "features. Use overworld tools if available."});
      actions.push_back({"List sprites/items",
                         "List notable sprites or items on the current "
                         "overworld map."});
      break;
    case EditorType::kDungeon:
      actions.push_back({"Audit room",
                         "Summarize the current dungeon room layout, doors, "
                         "and object density."});
      actions.push_back({"List sprites",
                         "List sprites in the current dungeon room and any "
                         "potential conflicts."});
      break;
    case EditorType::kGraphics:
      actions.push_back({"Review tiles",
                         "Review the current tileset usage and point out any "
                         "obvious issues."});
      actions.push_back({"Palette check",
                         "Check palette usage for contrast/readability "
                         "problems."});
      break;
    case EditorType::kPalette:
      actions.push_back({"Palette audit",
                         "Audit the active palette for hue/contrast balance "
                         "and note risks."});
      actions.push_back({"Theme ideas",
                         "Suggest a palette variation that fits the current "
                         "scene style."});
      break;
    case EditorType::kSprite:
      actions.push_back({"Sprite review",
                         "Review the selected sprite properties and suggest "
                         "tuning."});
      break;
    case EditorType::kMessage:
      actions.push_back({"Copy edit",
                         "Review the current message text for clarity and "
                         "style improvements."});
      break;
    case EditorType::kAssembly:
      actions.push_back({"ASM review",
                         "Review the current ASM changes for risks and style "
                         "issues."});
      break;
    case EditorType::kHex:
      actions.push_back({"Hex context",
                         "Explain what the current hex selection likely "
                         "represents."});
      break;
    case EditorType::kEmulator:
      actions.push_back({"Test suggestion",
                         "Propose a short emulator test to validate the "
                         "current feature."});
      break;
    case EditorType::kAgent:
      actions.push_back({"Agent config review",
                         "Review current agent configuration for practical "
                         "improvements."});
      break;
    default:
      actions.push_back({"Agent overview",
                         "Suggest the next best agent-assisted action for the "
                         "current editor context."});
      break;
  }
 
  if (actions.empty()) {
    return false;
  }
 
  ImGui::TextColored(accent, tr("%s Editor Actions"), ICON_MD_BOLT);
  gui::ColoredText("Send a context-aware prompt to the agent.",
                   gui::GetTextSecondaryVec4());
 
  int columns = ImGui::GetContentRegionAvail().x > 420.0f ? 2 : 1;
  if (ImGui::BeginTable("AgentQuickActionsTable", columns,
                        ImGuiTableFlags_SizingStretchSame)) {
    for (const auto& action : actions) {
      ImGui::TableNextColumn();
      if (ImGui::Button(action.label, ImVec2(-1, 0))) {
        agent_chat_->SendMessage(action.prompt);
      }
    }
    ImGui::EndTable();
  }
  return true;
#else
  return false;
#endif
}
 
void RightDrawerManager::DrawProposalsPanel() {
  if (proposal_drawer_) {
    // Set ROM and draw content inside the panel (not a separate window)
    if (rom_) {
      proposal_drawer_->SetRom(rom_);
    }
    proposal_drawer_->DrawContent();
  } else {
    gui::ColoredText(ICON_MD_DESCRIPTION " Proposals Not Available",
                     gui::GetTextSecondaryVec4());
 
    ImGui::Spacing();
    DrawPanelDescription(
        "The proposal system is not initialized. "
        "Proposals will appear here when the AI Agent creates them.");
  }
}
 
void RightDrawerManager::DrawSettingsPanel() {
  if (!settings_panel_ && settings_panel_provider_) {
    settings_panel_ = settings_panel_provider_();
  }
  if (settings_panel_) {
    // Draw settings inline (no card windows)
    settings_panel_->Draw();
  } else {
    gui::ColoredText(ICON_MD_SETTINGS " Settings Not Available",
                     gui::GetTextSecondaryVec4());
 
    ImGui::Spacing();
    DrawPanelDescription(
        "Settings will be available once initialized. "
        "This panel provides quick access to application settings.");
  }
}
 
void RightDrawerManager::DrawHelpPanel() {
  // Context-aware editor header
  DrawEditorContextHeader();
 
  // Keyboard Shortcuts section (default open)
  if (BeginPanelSection("Keyboard Shortcuts", ICON_MD_KEYBOARD, true)) {
    DrawGlobalShortcuts();
    DrawEditorSpecificShortcuts();
    EndPanelSection();
  }
 
  // Editor-specific help (default open)
  if (BeginPanelSection("Editor Guide", ICON_MD_HELP, true)) {
    DrawEditorSpecificHelp();
    EndPanelSection();
  }
 
  // Quick Actions (collapsed by default)
  if (BeginPanelSection("Quick Actions", ICON_MD_BOLT, false)) {
    DrawQuickActionButtons();
    EndPanelSection();
  }
 
  // About section (collapsed by default)
  if (BeginPanelSection("About", ICON_MD_INFO, false)) {
    DrawAboutSection();
    EndPanelSection();
  }
}
 
void RightDrawerManager::DrawEditorContextHeader() {
  const char* editor_name = "No Editor Selected";
  const char* editor_icon = ICON_MD_HELP;
 
  switch (active_editor_type_) {
    case EditorType::kOverworld:
      editor_name = "Overworld Editor";
      editor_icon = ICON_MD_LANDSCAPE;
      break;
    case EditorType::kDungeon:
      editor_name = "Dungeon Editor";
      editor_icon = ICON_MD_CASTLE;
      break;
    case EditorType::kGraphics:
      editor_name = "Graphics Editor";
      editor_icon = ICON_MD_IMAGE;
      break;
    case EditorType::kPalette:
      editor_name = "Palette Editor";
      editor_icon = ICON_MD_PALETTE;
      break;
    case EditorType::kMusic:
      editor_name = "Music Editor";
      editor_icon = ICON_MD_MUSIC_NOTE;
      break;
    case EditorType::kScreen:
      editor_name = "Screen Editor";
      editor_icon = ICON_MD_TV;
      break;
    case EditorType::kSprite:
      editor_name = "Sprite Editor";
      editor_icon = ICON_MD_SMART_TOY;
      break;
    case EditorType::kMessage:
      editor_name = "Message Editor";
      editor_icon = ICON_MD_CHAT;
      break;
    case EditorType::kEmulator:
      editor_name = "Emulator";
      editor_icon = ICON_MD_VIDEOGAME_ASSET;
      break;
    default:
      break;
  }
 
  // Draw context header with editor info
  gui::ColoredTextF(gui::GetPrimaryVec4(), "%s %s Help", editor_icon,
                    editor_name);
 
  DrawPanelDivider();
}
 
void RightDrawerManager::DrawGlobalShortcuts() {
  const char* ctrl = gui::GetCtrlDisplayName();
  DrawPanelLabel("Global");
  ImGui::Indent(8.0f);
  DrawShortcutRow("Open", "Open ROM", absl::StrFormat("%s+O", ctrl));
  DrawShortcutRow("Save", "Save ROM", absl::StrFormat("%s+S", ctrl));
  DrawShortcutRow("Save As", "Save ROM As",
                  absl::StrFormat("%s+Shift+S", ctrl));
  DrawShortcutRow("Undo", "Undo", absl::StrFormat("%s+Z", ctrl));
  DrawShortcutRow("Redo", "Redo", absl::StrFormat("%s+Shift+Z", ctrl));
  DrawShortcutRow("Command Palette", "Command Palette",
                  absl::StrFormat("%s+Shift+P", ctrl));
  DrawShortcutRow("Global Search", "Global Search",
                  absl::StrFormat("%s+Shift+K", ctrl));
  DrawShortcutRow("view.toggle_activity_bar", "Toggle Sidebar",
                  absl::StrFormat("%s+B", ctrl));
  DrawShortcutRow("Show About", "About / Help", "F1");
  DrawPanelValue("Esc", "Close Drawer");
  ImGui::Unindent(8.0f);
  ImGui::Spacing();
}
 
void RightDrawerManager::DrawEditorSpecificShortcuts() {
  const char* ctrl = gui::GetCtrlDisplayName();
  switch (active_editor_type_) {
    case EditorType::kOverworld:
      DrawPanelLabel("Overworld");
      ImGui::Indent(8.0f);
      DrawPanelValue("1 / 2 / 3", "Select / Paint / Entrances");
      DrawPanelValue("Alt+1 / Alt+2 / Alt+3", "Switch World (LW/DW/SP)");
      DrawPanelValue("Arrow Keys", "Navigate Maps");
      DrawPanelValue("E", "Entity Mode");
      DrawPanelValue("T", "Tile Mode");
      DrawShortcutRow("overworld.brush_toggle", "Toggle brush", "B");
      DrawShortcutRow("overworld.fill", "Fill tool", "F");
      DrawShortcutRow("overworld.next_tile", "Next tile", "]");
      DrawShortcutRow("overworld.prev_tile", "Previous tile", "[");
      DrawPanelValue("Right Click", "Pick Tile");
      ImGui::Unindent(8.0f);
      break;
 
    case EditorType::kDungeon:
      DrawPanelLabel("Dungeon");
      ImGui::Indent(8.0f);
      DrawShortcutRow("dungeon.object.select_tool", "Select tool", "S");
      DrawShortcutRow("dungeon.object.place_tool", "Place tool", "P");
      DrawShortcutRow("dungeon.object.delete_tool", "Delete tool", "D");
      DrawShortcutRow("dungeon.object.copy", "Copy selection",
                      absl::StrFormat("%s+C", ctrl));
      DrawShortcutRow("dungeon.object.paste", "Paste selection",
                      absl::StrFormat("%s+V", ctrl));
      DrawShortcutRow("dungeon.object.delete", "Delete selection", "Delete");
      DrawPanelValue("Arrow Keys", "Move Object");
      DrawPanelValue("G", "Toggle Grid");
      DrawPanelValue("L", "Cycle Layers");
      ImGui::Unindent(8.0f);
      break;
 
    case EditorType::kGraphics:
      DrawPanelLabel("Graphics");
      ImGui::Indent(8.0f);
      DrawShortcutRow("graphics.prev_sheet", "Previous sheet", "PageUp");
      DrawShortcutRow("graphics.next_sheet", "Next sheet", "PageDown");
      DrawShortcutRow("graphics.tool.pencil", "Pencil tool", "B");
      DrawShortcutRow("graphics.tool.fill", "Fill tool", "G");
      DrawShortcutRow("graphics.zoom_in", "Zoom in", "+");
      DrawShortcutRow("graphics.zoom_out", "Zoom out", "-");
      DrawShortcutRow("graphics.toggle_grid", "Toggle grid",
                      absl::StrFormat("%s+G", ctrl));
      ImGui::Unindent(8.0f);
      break;
 
    case EditorType::kPalette:
      DrawPanelLabel("Palette");
      ImGui::Indent(8.0f);
      DrawPanelValue("Click", "Select Color");
      DrawPanelValue("Double Click", "Edit Color");
      DrawPanelValue("Drag", "Copy Color");
      ImGui::Unindent(8.0f);
      break;
 
    case EditorType::kMusic:
      DrawPanelLabel("Music");
      ImGui::Indent(8.0f);
      DrawShortcutRow("music.play_pause", "Play/Pause", "Space");
      DrawShortcutRow("music.stop", "Stop", "Esc");
      DrawShortcutRow("music.speed_up", "Speed up", "+");
      DrawShortcutRow("music.speed_down", "Slow down", "-");
      DrawPanelValue("Left/Right", "Seek");
      ImGui::Unindent(8.0f);
      break;
 
    case EditorType::kMessage:
      DrawPanelLabel("Message");
      ImGui::Indent(8.0f);
      DrawPanelValue(absl::StrFormat("%s+Enter", ctrl).c_str(),
                     "Insert Line Break");
      DrawPanelValue("Up/Down", "Navigate Messages");
      ImGui::Unindent(8.0f);
      break;
 
    default:
      DrawPanelLabel("Editor Shortcuts");
      ImGui::Indent(8.0f);
      {
        gui::StyleColorGuard text_color(ImGuiCol_Text,
                                        gui::GetTextSecondaryVec4());
        ImGui::TextWrapped(tr("Select an editor to see specific shortcuts."));
      }
      ImGui::Unindent(8.0f);
      break;
  }
}
 
void RightDrawerManager::DrawEditorSpecificHelp() {
  switch (active_editor_type_) {
    case EditorType::kOverworld: {
      gui::StyleColorGuard text_color(ImGuiCol_Text,
                                      ImGui::GetStyleColorVec4(ImGuiCol_Text));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Paint tiles by selecting from Tile16 Selector"));
      ImGui::Bullet();
      ImGui::TextWrapped(
          tr("Switch between Light World, Dark World, and Special Areas"));
      ImGui::Bullet();
      ImGui::TextWrapped(
          tr("Use Entity Mode to place entrances, exits, items, and sprites"));
      ImGui::Bullet();
      ImGui::TextWrapped(
          tr("Right-click on the map to pick a tile for painting"));
    } break;
 
    case EditorType::kDungeon: {
      gui::StyleColorGuard text_color(ImGuiCol_Text,
                                      ImGui::GetStyleColorVec4(ImGuiCol_Text));
      ImGui::Bullet();
      ImGui::TextWrapped(
          tr("Select rooms from the Room Selector or Room Matrix"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Place objects using the Object Editor panel"));
      ImGui::Bullet();
      ImGui::TextWrapped(
          tr("Edit room headers for palette, GFX, and floor settings"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Multiple rooms can be opened in separate tabs"));
    } break;
 
    case EditorType::kGraphics: {
      gui::StyleColorGuard text_color(ImGuiCol_Text,
                                      ImGui::GetStyleColorVec4(ImGuiCol_Text));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Browse graphics sheets using the Sheet Browser"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Edit pixels directly with the Pixel Editor"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Choose palettes from Palette Controls"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("View 3D objects like rupees and crystals"));
    } break;
 
    case EditorType::kPalette: {
      gui::StyleColorGuard text_color(ImGuiCol_Text,
                                      ImGui::GetStyleColorVec4(ImGuiCol_Text));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Edit overworld, dungeon, and sprite palettes"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Use Quick Access for color harmony tools"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Changes update in real-time across all editors"));
    } break;
 
    case EditorType::kMusic: {
      gui::StyleColorGuard text_color(ImGuiCol_Text,
                                      ImGui::GetStyleColorVec4(ImGuiCol_Text));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Browse songs in the Song Browser"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Use the tracker for playback control"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Edit instruments and BRR samples"));
    } break;
 
    case EditorType::kMessage: {
      gui::StyleColorGuard text_color(ImGuiCol_Text,
                                      ImGui::GetStyleColorVec4(ImGuiCol_Text));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Edit all in-game dialog messages"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Preview text rendering with the font atlas"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Manage the compression dictionary"));
    } break;
 
    default:
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Open a ROM file via File > Open ROM"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Select an editor from the sidebar"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Use panels to access tools and settings"));
      ImGui::Bullet();
      ImGui::TextWrapped(tr("Save your work via File > Save ROM"));
      break;
  }
}
 
void RightDrawerManager::DrawQuickActionButtons() {
  const float button_width = ImGui::GetContentRegionAvail().x;
 
  gui::StyleVarGuard button_vars({
      {ImGuiStyleVar_FramePadding, ImVec2(10.0f, 7.0f)},
      {ImGuiStyleVar_FrameRounding, 6.0f},
      {ImGuiStyleVar_FrameBorderSize, 1.0f},
  });
 
  auto draw_link_button = [&](const char* icon, const char* label,
                              const char* url) {
    gui::StyleColorGuard btn_colors({
        {ImGuiCol_Button, gui::GetSurfaceContainerHighVec4()},
        {ImGuiCol_ButtonHovered, gui::GetSurfaceContainerHighestVec4()},
        {ImGuiCol_Border, gui::GetOutlineVec4()},
    });
    const std::string text =
        absl::StrFormat("%s  %s  " ICON_MD_OPEN_IN_NEW, icon, label);
    if (ImGui::Button(text.c_str(), ImVec2(button_width, 0))) {
      gui::OpenUrl(url);
    }
  };
 
  draw_link_button(ICON_MD_DESCRIPTION, "Open Documentation",
                   "https://github.com/scawful/yaze/wiki");
  ImGui::Spacing();
  draw_link_button(ICON_MD_BUG_REPORT, "Report Issue",
                   "https://github.com/scawful/yaze/issues/new");
  ImGui::Spacing();
  draw_link_button(ICON_MD_FORUM, "Join Discord",
                   "https://discord.gg/zU5qDm8MZg");
}
 
void RightDrawerManager::DrawAboutSection() {
  gui::ColoredText("YAZE - Yet Another Zelda3 Editor", gui::GetPrimaryVec4());
 
  ImGui::Spacing();
  DrawPanelDescription(
      "A comprehensive editor for The Legend of Zelda: "
      "A Link to the Past ROM files.");
 
  DrawPanelDivider();
 
  DrawPanelLabel("Credits");
  ImGui::Spacing();
  ImGui::Text(tr("Written by: scawful"));
  ImGui::Text(tr("Special Thanks: Zarby89, JaredBrian"));
 
  DrawPanelDivider();
 
  DrawPanelLabel("Links");
  ImGui::Spacing();
  gui::ColoredText(ICON_MD_LINK " github.com/scawful/yaze",
                   gui::GetTextSecondaryVec4());
}
 
void RightDrawerManager::DrawNotificationsPanel() {
  if (!toast_manager_) {
    gui::ColoredText(ICON_MD_NOTIFICATIONS_OFF " Notifications Unavailable",
                     gui::GetTextSecondaryVec4());
    return;
  }
 
  // Header actions
  float avail = ImGui::GetContentRegionAvail().x;
 
  // Mark all read / Clear all buttons
  {
    gui::StyleColorGuard btn_colors({
        {ImGuiCol_Button, gui::GetSurfaceContainerHighVec4()},
        {ImGuiCol_ButtonHovered, gui::GetSurfaceContainerHighestVec4()},
    });
 
    if (ImGui::Button(ICON_MD_DONE_ALL " Mark All Read",
                      ImVec2(avail * 0.5f - 4.0f, 0))) {
      toast_manager_->MarkAllRead();
    }
    ImGui::SameLine();
    if (ImGui::Button(ICON_MD_DELETE_SWEEP " Clear All",
                      ImVec2(avail * 0.5f - 4.0f, 0))) {
      toast_manager_->ClearHistory();
    }
  }
 
  DrawPanelDivider();
 
  const auto build_status = ContentRegistry::Context::build_workflow_status();
  const auto run_status = ContentRegistry::Context::run_workflow_status();
  const auto workflow_history = ContentRegistry::Context::workflow_history();
  workflow::WorkflowActionCallbacks workflow_callbacks;
  workflow_callbacks.start_build =
      ContentRegistry::Context::start_build_workflow_callback();
  workflow_callbacks.run_project =
      ContentRegistry::Context::run_project_workflow_callback();
  workflow_callbacks.show_output =
      ContentRegistry::Context::show_workflow_output_callback();
  const auto cancel_build =
      ContentRegistry::Context::cancel_build_workflow_callback();
 
  if (build_status.visible || run_status.visible || !workflow_history.empty()) {
    DrawPanelLabel("Workflow Activity");
    if (build_status.visible) {
      DrawWorkflowSummaryCard("Build", ICON_MD_BUILD, build_status,
                              cancel_build);
      ImGui::Spacing();
    }
    if (run_status.visible) {
      DrawWorkflowSummaryCard("Run", ICON_MD_PLAY_ARROW, run_status);
      ImGui::Spacing();
    }
    if (!workflow_history.empty()) {
      DrawPanelLabel("Recent Workflow History");
      const auto preview_entries =
          workflow::SelectWorkflowPreviewEntries(workflow_history, 3);
      for (size_t i = 0; i < preview_entries.size(); ++i) {
        ImGui::PushID(static_cast<int>(i));
        DrawWorkflowPreviewEntry(preview_entries[i], workflow_callbacks);
        ImGui::PopID();
        if (i + 1 < preview_entries.size()) {
          ImGui::Separator();
        }
      }
      if (workflow_history.size() > preview_entries.size()) {
        ImGui::Spacing();
        ImGui::TextDisabled(
            tr("+%zu more entries available in Workflow Output"),
            workflow_history.size() - preview_entries.size());
        if (workflow_callbacks.show_output) {
          if (ImGui::SmallButton(ICON_MD_OPEN_IN_NEW
                                 " View Full History##workflow_view_full")) {
            workflow_callbacks.show_output();
          }
        }
      }
    }
    DrawPanelDivider();
  }
 
  // Notification history
  const auto& history = toast_manager_->GetHistory();
 
  if (history.empty()) {
    ImGui::Spacing();
    gui::ColoredText(ICON_MD_INBOX " No notifications",
                     gui::GetTextSecondaryVec4());
    ImGui::Spacing();
    DrawPanelDescription(
        "Notifications will appear here when actions complete.");
    return;
  }
 
  // Stats
  size_t unread_count = toast_manager_->GetUnreadCount();
  if (unread_count > 0) {
    gui::ColoredTextF(gui::GetPrimaryVec4(), "%zu unread", unread_count);
  } else {
    gui::ColoredText("All caught up", gui::GetTextSecondaryVec4());
  }
 
  ImGui::Spacing();
 
  // Scrollable notification list (minimum height so list never collapses)
  const bool notification_list_open = gui::LayoutHelpers::BeginContentChild(
      "##NotificationList", ImVec2(0.0f, gui::UIConfig::kContentMinHeightList),
      ImGuiChildFlags_None, ImGuiWindowFlags_AlwaysVerticalScrollbar);
  if (notification_list_open) {
    const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
    auto now = std::chrono::system_clock::now();
 
    // Group by time (Today, Yesterday, Older)
    bool shown_today = false;
    bool shown_yesterday = false;
    bool shown_older = false;
 
    for (const auto& entry : history) {
      auto diff =
          std::chrono::duration_cast<std::chrono::hours>(now - entry.timestamp)
              .count();
 
      // Time grouping headers
      if (diff < 24 && !shown_today) {
        DrawPanelLabel("Today");
        shown_today = true;
      } else if (diff >= 24 && diff < 48 && !shown_yesterday) {
        ImGui::Spacing();
        DrawPanelLabel("Yesterday");
        shown_yesterday = true;
      } else if (diff >= 48 && !shown_older) {
        ImGui::Spacing();
        DrawPanelLabel("Older");
        shown_older = true;
      }
 
      // Notification item
      ImGui::PushID(&entry);
 
      // Icon and color based on type
      const char* icon;
      ImVec4 color;
      switch (entry.type) {
        case ToastType::kSuccess:
          icon = ICON_MD_CHECK_CIRCLE;
          color = gui::ConvertColorToImVec4(theme.success);
          break;
        case ToastType::kWarning:
          icon = ICON_MD_WARNING;
          color = gui::ConvertColorToImVec4(theme.warning);
          break;
        case ToastType::kError:
          icon = ICON_MD_ERROR;
          color = gui::ConvertColorToImVec4(theme.error);
          break;
        default:
          icon = ICON_MD_INFO;
          color = gui::ConvertColorToImVec4(theme.info);
          break;
      }
 
      // Unread indicator
      if (!entry.read) {
        gui::ColoredText(ICON_MD_FIBER_MANUAL_RECORD, gui::GetPrimaryVec4());
        ImGui::SameLine();
      }
 
      // Icon
      gui::ColoredTextF(color, "%s", icon);
      ImGui::SameLine();
 
      // Message
      ImGui::TextWrapped("%s", entry.message.c_str());
 
      // Timestamp
      auto diff_sec = std::chrono::duration_cast<std::chrono::seconds>(
                          now - entry.timestamp)
                          .count();
      std::string time_str;
      if (diff_sec < 60) {
        time_str = "just now";
      } else if (diff_sec < 3600) {
        time_str = absl::StrFormat("%dm ago", diff_sec / 60);
      } else if (diff_sec < 86400) {
        time_str = absl::StrFormat("%dh ago", diff_sec / 3600);
      } else {
        time_str = absl::StrFormat("%dd ago", diff_sec / 86400);
      }
 
      gui::ColoredTextF(gui::GetTextDisabledVec4(), "  %s", time_str.c_str());
 
      ImGui::PopID();
      ImGui::Spacing();
    }
  }
  gui::LayoutHelpers::EndContentChild();
}
 
void RightDrawerManager::DrawPropertiesPanel() {
  if (properties_panel_) {
    properties_panel_->Draw();
  } else {
    gui::DrawEmptyState(gui::EmptyNoSelection(/*compact=*/true));
  }
}
 
void RightDrawerManager::DrawProjectPanel() {
  if (project_panel_) {
    project_panel_->Draw();
  } else {
    gui::DrawEmptyState(gui::EmptyNoProject(/*compact=*/true));
  }
}
 
void RightDrawerManager::DrawToolOutputPanel() {
  if (!tool_output_query_.empty()) {
    gui::ColoredText(ICON_MD_TERMINAL " Query", gui::GetPrimaryVec4());
    ImGui::SameLine();
    if (ImGui::SmallButton(ICON_MD_CONTENT_COPY " Copy")) {
      ImGui::SetClipboardText(tool_output_query_.c_str());
    }
    ImGui::TextWrapped("%s", tool_output_query_.c_str());
    DrawPanelDivider();
  }
 
  if (tool_output_content_.empty()) {
    gui::EmptyStateOptions opts;
    opts.icon = ICON_MD_TERMINAL;
    opts.title = "No tool output";
    opts.detail =
        "Run a project-graph query from the editor to inspect its output here.";
    opts.compact = true;
    gui::DrawEmptyState(opts);
    return;
  }
 
  Json parsed;
  const bool has_json = TryParseToolOutputJson(tool_output_content_, &parsed);
 
  gui::ColoredText(ICON_MD_ACCOUNT_TREE " Result", gui::GetPrimaryVec4());
  if (ImGui::SmallButton(ICON_MD_CONTENT_COPY " Copy Result")) {
    ImGui::SetClipboardText(tool_output_content_.c_str());
  }
 
  if (has_json) {
    if (BeginPanelSection("Summary", ICON_MD_INFO, true)) {
      ImGui::PushID("summary");
      DrawToolOutputEntryActions(parsed, tool_output_actions_);
      if (!parsed.empty()) {
        ImGui::Spacing();
      }
      DrawJsonObjectFields(parsed);
      ImGui::PopID();
      EndPanelSection();
    }
    if (parsed.contains("source") && parsed["source"].is_object() &&
        BeginPanelSection("Resolved Source", ICON_MD_CODE, true)) {
      ImGui::PushID("resolved_source");
      DrawToolOutputEntryActions(parsed["source"], tool_output_actions_);
      if (!parsed["source"].empty()) {
        ImGui::Spacing();
      }
      DrawJsonObjectFields(parsed["source"]);
      ImGui::PopID();
      EndPanelSection();
    }
    DrawJsonObjectArraySection("Matching Symbols", parsed["matching_symbols"],
                               tool_output_actions_);
    DrawJsonObjectArraySection("Sources", parsed["sources"],
                               tool_output_actions_);
    DrawJsonObjectArraySection("Hooks", parsed["hooks"], tool_output_actions_);
    DrawJsonObjectArraySection("Writes", parsed["writes"],
                               tool_output_actions_);
    DrawJsonObjectArraySection("Banks", parsed["banks"], tool_output_actions_);
    DrawJsonObjectArraySection("Symbols", parsed["symbols"],
                               tool_output_actions_);
  }
 
  if (ImGui::CollapsingHeader(tr("Raw Output"),
                              has_json ? 0 : ImGuiTreeNodeFlags_DefaultOpen)) {
    if (ImGui::BeginChild("##tool_output_result", ImVec2(0.0f, 220.0f), true)) {
      ImGui::TextUnformatted(tool_output_content_.c_str());
    }
    ImGui::EndChild();
  }
}
 
bool RightDrawerManager::DrawSidebarToggleButton() {
  const bool sidebar_open = active_panel_ != PanelType::kNone;
  gui::StyleColorGuard button_colors({
      {ImGuiCol_Button, ImVec4(0, 0, 0, 0)},
      {ImGuiCol_ButtonHovered, gui::GetSurfaceContainerHighVec4()},
      {ImGuiCol_ButtonActive, gui::GetSurfaceContainerHighestVec4()},
      {ImGuiCol_Text,
       sidebar_open ? gui::GetPrimaryVec4() : gui::GetTextSecondaryVec4()},
  });
 
  bool interacted = false;
  if (ImGui::SmallButton(ICON_MD_VIEW_SIDEBAR "##RightSidebarToggle")) {
    ToggleLastDrawer();
    interacted = true;
  }
  if (ImGui::IsItemHovered()) {
    const std::string tooltip =
        sidebar_open ? tr("Close Right Sidebar")
                     : absl::StrFormat("Open Right Sidebar (%s)",
                                       GetPanelTypeName(last_active_panel_));
    ImGui::SetTooltip("%s", tooltip.c_str());
  }
 
  return interacted;
}
 
float RightDrawerManager::GetSidebarToggleWidth() {
  const float frame_padding = ImGui::GetStyle().FramePadding.x;
  const float icon_width = ImGui::CalcTextSize(ICON_MD_VIEW_SIDEBAR).x;
  return icon_width + frame_padding * 2.0f;
}
 
}  // namespace editor
}  // namespace yaze