popup_manager.cc

Go to the documentation of this file.

#include "popup_manager.h"
#include "util/i18n/tr.h"
 
#include <cstring>
#include <ctime>
#include <filesystem>
#include <functional>
#include <initializer_list>
 
#include "absl/status/status.h"
#include "absl/strings/ascii.h"
#include "absl/strings/match.h"
#include "absl/strings/str_format.h"
#include "app/editor/editor_manager.h"
#include "app/editor/layout/layout_presets.h"
#include "app/gui/app/feature_flags_menu.h"
#include "app/gui/automation/widget_id_registry.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.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_helpers.h"
#include "imgui/misc/cpp/imgui_stdlib.h"
#include "util/file_util.h"
#include "util/hex.h"
#include "yaze.h"
#include "zelda3/overworld/overworld.h"
 
namespace yaze {
namespace editor {
 
using namespace ImGui;
 
PopupManager::PopupManager(EditorManager* editor_manager)
    : editor_manager_(editor_manager), status_(absl::OkStatus()) {}
 
void PopupManager::Initialize() {
  // ============================================================================
  // POPUP REGISTRATION
  // ============================================================================
  // All popups must be registered here BEFORE any menu callbacks can trigger
  // them. This method is called in EditorManager constructor BEFORE
  // MenuOrchestrator and UICoordinator are created, ensuring safe
  // initialization order.
  //
  // Popup Registration Format:
  // popups_[PopupID::kConstant] = {
  //   .name = PopupID::kConstant,
  //   .type = PopupType::kXxx,
  //   .is_visible = false,
  //   .allow_resize = false/true,
  //   .draw_function = [this]() { DrawXxxPopup(); }
  // };
  // ============================================================================
 
  // File Operations
  popups_[PopupID::kSaveAs] = {PopupID::kSaveAs, PopupType::kFileOperation,
                               false, false, [this]() { DrawSaveAsPopup(); }};
  popups_[PopupID::kSaveScope] = {PopupID::kSaveScope, PopupType::kSettings,
                                  false, true,
                                  [this]() { DrawSaveScopePopup(); }};
  popups_[PopupID::kNewProject] = {PopupID::kNewProject,
                                   PopupType::kFileOperation, false, false,
                                   [this]() { DrawNewProjectPopup(); }};
  popups_[PopupID::kManageProject] = {PopupID::kManageProject,
                                      PopupType::kFileOperation, false, false,
                                      [this]() { DrawManageProjectPopup(); }};
  popups_[PopupID::kRomBackups] = {PopupID::kRomBackups,
                                   PopupType::kFileOperation, false, true,
                                   [this]() { DrawRomBackupManagerPopup(); }};
 
  // Information
  popups_[PopupID::kAbout] = {PopupID::kAbout, PopupType::kInfo, false, false,
                              [this]() { DrawAboutPopup(); }};
  popups_[PopupID::kRomInfo] = {PopupID::kRomInfo, PopupType::kInfo, false,
                                false, [this]() { DrawRomInfoPopup(); }};
  popups_[PopupID::kSupportedFeatures] = {
      PopupID::kSupportedFeatures, PopupType::kInfo, false, false,
      [this]() { DrawSupportedFeaturesPopup(); }};
  popups_[PopupID::kOpenRomHelp] = {PopupID::kOpenRomHelp, PopupType::kHelp,
                                    false, false,
                                    [this]() { DrawOpenRomHelpPopup(); }};
 
  // Help Documentation
  popups_[PopupID::kGettingStarted] = {PopupID::kGettingStarted,
                                       PopupType::kHelp, false, false,
                                       [this]() { DrawGettingStartedPopup(); }};
  popups_[PopupID::kAsarIntegration] = {
      PopupID::kAsarIntegration, PopupType::kHelp, false, false,
      [this]() { DrawAsarIntegrationPopup(); }};
  popups_[PopupID::kBuildInstructions] = {
      PopupID::kBuildInstructions, PopupType::kHelp, false, false,
      [this]() { DrawBuildInstructionsPopup(); }};
  popups_[PopupID::kCLIUsage] = {PopupID::kCLIUsage, PopupType::kHelp, false,
                                 false, [this]() { DrawCLIUsagePopup(); }};
  popups_[PopupID::kTroubleshooting] = {
      PopupID::kTroubleshooting, PopupType::kHelp, false, false,
      [this]() { DrawTroubleshootingPopup(); }};
  popups_[PopupID::kContributing] = {PopupID::kContributing, PopupType::kHelp,
                                     false, false,
                                     [this]() { DrawContributingPopup(); }};
  popups_[PopupID::kWhatsNew] = {PopupID::kWhatsNew, PopupType::kHelp, false,
                                 false, [this]() { DrawWhatsNewPopup(); }};
  popups_[PopupID::kComingFromZScream] = {
      PopupID::kComingFromZScream, PopupType::kHelp, false,
      true,  // Resizable — concept map is longer than a short tip
      [this]() { DrawComingFromZScreamPopup(); }};
 
  // Settings
  popups_[PopupID::kDisplaySettings] = {
      PopupID::kDisplaySettings, PopupType::kSettings, false,
      true,  // Resizable
      [this]() { DrawDisplaySettingsPopup(); }};
  popups_[PopupID::kFeatureFlags] = {
      PopupID::kFeatureFlags, PopupType::kSettings, false, true,  // Resizable
      [this]() { DrawFeatureFlagsPopup(); }};
 
  // Workspace
  popups_[PopupID::kWorkspaceHelp] = {PopupID::kWorkspaceHelp, PopupType::kHelp,
                                      false, false,
                                      [this]() { DrawWorkspaceHelpPopup(); }};
  popups_[PopupID::kSessionLimitWarning] = {
      PopupID::kSessionLimitWarning, PopupType::kWarning, false, false,
      [this]() { DrawSessionLimitWarningPopup(); }};
  popups_[PopupID::kLayoutResetConfirm] = {
      PopupID::kLayoutResetConfirm, PopupType::kConfirmation, false, false,
      [this]() { DrawLayoutResetConfirmPopup(); }};
 
  popups_[PopupID::kLayoutPresets] = {PopupID::kLayoutPresets,
                                      PopupType::kSettings, false, false,
                                      [this]() { DrawLayoutPresetsPopup(); }};
 
  popups_[PopupID::kSessionManager] = {PopupID::kSessionManager,
                                       PopupType::kSettings, false, true,
                                       [this]() { DrawSessionManagerPopup(); }};
 
  // Debug/Testing
  popups_[PopupID::kDataIntegrity] = {PopupID::kDataIntegrity, PopupType::kInfo,
                                      false, true,  // Resizable
                                      [this]() { DrawDataIntegrityPopup(); }};
 
  popups_[PopupID::kDungeonPotItemSaveConfirm] = {
      PopupID::kDungeonPotItemSaveConfirm, PopupType::kConfirmation, false,
      false, [this]() { DrawDungeonPotItemSaveConfirmPopup(); }};
  popups_[PopupID::kRomWriteConfirm] = {
      PopupID::kRomWriteConfirm, PopupType::kConfirmation, false, false,
      [this]() { DrawRomWriteConfirmPopup(); }};
  popups_[PopupID::kWriteConflictWarning] = {
      PopupID::kWriteConflictWarning, PopupType::kWarning, false, true,
      [this]() { DrawWriteConflictWarningPopup(); }};
  popups_[PopupID::kUnsavedSessionChanges] = {
      PopupID::kUnsavedSessionChanges, PopupType::kConfirmation, false, false,
      [this]() { DrawUnsavedSessionChangesPopup(); }};
}
 
void PopupManager::DrawPopups() {
  // Draw status popup if needed
  DrawStatusPopup();
 
  // Draw only the most recently shown popup. All popups open at the same
  // level, and opening one closes any other open there, so drawing every
  // visible popup reopened each of them every frame: none stayed on screen,
  // and the open modal blocked all input. Older popups stay visible and
  // return when the newer one is hidden.
  PopupParams* top = nullptr;
  for (auto& [name, params] : popups_) {
    if (params.is_visible &&
        (top == nullptr || params.shown_order > top->shown_order)) {
      top = &params;
    }
  }
  if (top == nullptr) {
    return;
  }
  OpenPopup(top->name.c_str());
 
  // Use allow_resize flag from popup definition
  ImGuiWindowFlags popup_flags = top->allow_resize
                                     ? ImGuiWindowFlags_None
                                     : ImGuiWindowFlags_AlwaysAutoResize;
 
  if (BeginPopupModal(top->name.c_str(), nullptr, popup_flags)) {
    top->draw_function();
    EndPopup();
  }
}
 
void PopupManager::Show(const char* name) {
  if (!name) {
    return;  // Safety check for null pointer
  }
 
  std::string name_str(name);
  auto it = popups_.find(name_str);
  if (it != popups_.end()) {
    if (!it->second.is_visible) {
      if (name_str == PopupID::kSaveAs) {
        ResetSaveAsState();
      }
      it->second.shown_order = next_shown_order_++;
    }
    it->second.is_visible = true;
  } else {
    // Log warning for unregistered popup
    printf(
        "[PopupManager] Warning: Popup '%s' not registered. Available popups: ",
        name);
    for (const auto& [key, _] : popups_) {
      printf("'%s' ", key.c_str());
    }
    printf("\n");
  }
}
 
void PopupManager::Hide(const char* name) {
  if (!name) {
    return;  // Safety check for null pointer
  }
 
  std::string name_str(name);
  auto it = popups_.find(name_str);
  if (it != popups_.end()) {
    it->second.is_visible = false;
    if (name_str == PopupID::kSaveAs) {
      ResetSaveAsState();
    }
    CloseCurrentPopup();
  }
}
 
void PopupManager::RegisterPopup(const std::string& name, PopupType type,
                                 std::function<void()> draw_function,
                                 bool allow_resize) {
  PopupParams params;
  params.name = name;
  params.type = type;
  params.allow_resize = allow_resize;
  params.draw_function = std::move(draw_function);
  popups_[name] = std::move(params);
}
 
bool PopupManager::IsVisible(const char* name) const {
  if (!name) {
    return false;  // Safety check for null pointer
  }
 
  std::string name_str(name);
  auto it = popups_.find(name_str);
  if (it != popups_.end()) {
    return it->second.is_visible;
  }
  return false;
}
 
void PopupManager::SetStatus(const absl::Status& status) {
  if (!status.ok()) {
    show_status_ = true;
    prev_status_ = status;
    status_ = status;
  }
}
 
bool PopupManager::BeginCentered(const char* name) {
  ImGuiIO const& io = GetIO();
  ImVec2 pos(io.DisplaySize.x * 0.5f, io.DisplaySize.y * 0.5f);
  SetNextWindowPos(pos, ImGuiCond_Always, ImVec2(0.5f, 0.5f));
  ImGuiWindowFlags flags =
      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration |
      ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoSavedSettings;
  return Begin(name, nullptr, flags);
}
 
void PopupManager::DrawStatusPopup() {
  if (show_status_ && BeginCentered("StatusWindow")) {
    Text("%s", ICON_MD_ERROR);
    Text("%s", prev_status_.ToString().c_str());
    Spacing();
    NextColumn();
    Columns(1);
    Separator();
    NewLine();
    SameLine(128);
    if (Button(tr("OK"), ::yaze::gui::kDefaultModalSize) ||
        IsKeyPressed(ImGuiKey_Space)) {
      show_status_ = false;
      status_ = absl::OkStatus();
    }
    SameLine();
    if (Button(ICON_MD_CONTENT_COPY, ImVec2(50, 0))) {
      SetClipboardText(prev_status_.ToString().c_str());
    }
    End();
  }
}
 
void PopupManager::DrawAboutPopup() {
  Text(tr("Yet Another Zelda3 Editor - v%s"),
       editor_manager_->version().c_str());
  Text(tr("Written by: scawful"));
  Spacing();
  Text(tr("Special Thanks: Zarby89, JaredBrian"));
  Separator();
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("About");
  }
}
 
void PopupManager::DrawRomInfoPopup() {
  auto* current_rom = editor_manager_->GetCurrentRom();
  if (!current_rom)
    return;
 
  Text(tr("Title: %s"), current_rom->title().c_str());
  Text(tr("ROM Size: %s"), util::HexLongLong(current_rom->size()).c_str());
  Text(tr("ROM Hash: %s"), editor_manager_->GetCurrentRomHash().empty()
                               ? "(unknown)"
                               : editor_manager_->GetCurrentRomHash().c_str());
 
  const auto profile = zelda3::DetectOverworldRomProfile(*current_rom);
  const auto& layout = profile.lyra_layout;
  if (layout.presence != rom::LyraLayoutPresence::kAbsent) {
    Separator();
    TextUnformatted("Overworld Format: Lyra descriptor");
    Text("ROM Format Revision: %u", layout.revision);
    Text("Area Capacity: %u", layout.capacity);
    Text("Active Areas: %u", layout.active_count);
    TextUnformatted(layout.presence == rom::LyraLayoutPresence::kValid
                        ? "Validation: valid"
                        : "Validation: invalid");
    TextUnformatted("Write Support: inspection only");
    if (!layout.error.empty()) {
      TextWrapped("Reason: %s", layout.error.c_str());
    }
  } else if (profile.layout_kind ==
             zelda3::OverworldRomProfile::LayoutKind::kOlderTailEa) {
    Separator();
    TextUnformatted("Overworld Format: older $EA tail-map expansion");
  } else if (profile.layout_kind ==
             zelda3::OverworldRomProfile::LayoutKind::kZScreamPerSheet) {
    Separator();
    Text("Overworld Format: %s",
         zelda3::zscream::LayoutName(profile.zscream_layout));
    TextUnformatted("Collision metadata: per-sheet, read-only");
    TextUnformatted("Preview: static full-load sheets");
    TextUnformatted("Tail-map expansion: unavailable");
  } else if (profile.layout_kind ==
             zelda3::OverworldRomProfile::LayoutKind::kUnknownCustom) {
    Separator();
    Text("Overworld Format: %s (raw marker $%02X)",
         zelda3::zscream::LayoutName(profile.zscream_layout),
         static_cast<unsigned>(profile.asm_version));
    TextUnformatted("Write Support: unqualified for this custom layout");
    TextUnformatted("Compatibility: unqualified");
  }
 
  auto* project = editor_manager_->GetCurrentProject();
  if (project && project->project_opened()) {
    Separator();
    Text(tr("Role: %s"),
         project::RomRoleToString(project->rom_metadata.role).c_str());
    Text(tr("Write Policy: %s"),
         project::RomWritePolicyToString(project->rom_metadata.write_policy)
             .c_str());
    Text(tr("Expected Hash: %s"),
         project->rom_metadata.expected_hash.empty()
             ? "(unset)"
             : project->rom_metadata.expected_hash.c_str());
    if (editor_manager_->IsRomHashMismatch()) {
      const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
      TextColored(gui::ConvertColorToImVec4(theme.warning),
                  tr("ROM hash mismatch detected"));
    }
  }
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize) ||
      IsKeyPressed(ImGuiKey_Escape)) {
    Hide("ROM Information");
  }
}
 
void PopupManager::ResetSaveAsState() {
  save_as_ = {};
}
 
void PopupManager::DrawSaveAsPopup() {
  using namespace ImGui;
  namespace fs = std::filesystem;
 
  auto register_widget = [](const char* name, const char* type) {
    gui::WidgetIdRegistry::Instance().RegisterWidget(
        std::string("SaveAs/") + type + ":" + name, type, GetItemID());
  };
  auto* rom = editor_manager_ ? editor_manager_->GetCurrentRom() : nullptr;
  if (!rom || !rom->is_loaded()) {
    TextUnformatted(tr("No ROM loaded."));
    if (Button(tr("Close"))) {
      Hide(PopupID::kSaveAs);
    }
    return;
  }
 
  const auto session_id = editor_manager_->GetCurrentSessionId();
  if (!save_as_.initialized || save_as_.source_path != rom->filename() ||
      save_as_.session_id != session_id) {
    ResetSaveAsState();
    save_as_.initialized = true;
    save_as_.source_path = rom->filename();
    save_as_.session_id = session_id;
    std::error_code ec;
    auto source = fs::absolute(fs::path(rom->filename()), ec);
    if (ec || rom->filename().empty()) {
      save_as_.error =
          tr("The current ROM has no usable folder. Choose Browse.");
    } else {
      save_as_.folder = source.parent_path().string();
    }
    auto extension = source.extension().string();
    const auto lower_extension = absl::AsciiStrToLower(extension);
    if (lower_extension != ".sfc" && lower_extension != ".smc") {
      extension = ".sfc";
    }
    const auto stem =
        source.stem().empty() ? std::string("rom") : source.stem().string();
    save_as_.filename = stem + "-copy" + extension;
    for (int copy = 2;
         !save_as_.folder.empty() &&
         fs::exists(fs::path(save_as_.folder) / save_as_.filename, ec);
         ++copy) {
      save_as_.filename = stem + "-copy-" + std::to_string(copy) + extension;
    }
  }
 
  Text(tr("%s Save ROM to new location"), ICON_MD_SAVE_AS);
  Separator();
  TextUnformatted(tr("Folder:"));
  PushTextWrapPos(GetCursorPosX() + 480.0f);
  TextUnformatted(save_as_.folder.c_str());
  PopTextWrapPos();
  SetNextItemWidth(360.0f);
  InputText(tr("Filename"), &save_as_.filename);
  register_widget("Filename", "input");
  if (!save_as_.error.empty()) {
    TextWrapped("%s", save_as_.error.c_str());
  }
  Separator();
 
  const bool browse = Button(
      absl::StrFormat("%s Browse folder...", ICON_MD_FOLDER_OPEN).c_str(),
      ::yaze::gui::kDefaultModalSize);
  register_widget("Browse", "button");
  if (browse) {
    auto selected = util::FileDialogWrapper::ShowOpenFolderDialog();
    if (!selected.empty()) {
      std::error_code ec;
      const auto destination = fs::absolute(fs::path(selected), ec);
      if (!ec) {
        save_as_.folder = destination.string();
        save_as_.error.clear();
      }
    }
  }
 
  SameLine();
  const bool save = Button(absl::StrFormat("%s Save", ICON_MD_SAVE).c_str(),
                           ::yaze::gui::kDefaultModalSize);
  register_widget("Save", "button");
  if (save) {
    fs::path filename(save_as_.filename);
    if (filename.empty() || filename == "." || filename == ".." ||
        filename.has_parent_path() || save_as_.folder.empty()) {
      save_as_.error =
          tr("Enter a filename only. Use Browse to choose a different folder.");
    } else {
      const auto extension =
          absl::AsciiStrToLower(filename.extension().string());
      if (extension != ".sfc" && extension != ".smc") {
        filename += ".sfc";
      }
      // SaveRomAs owns the complete destination across any confirmation popup.
      const auto destination = (fs::path(save_as_.folder) / filename).string();
      const auto status = editor_manager_->SaveRomAs(destination);
      if (status.ok()) {
        Hide(PopupID::kSaveAs);
        return;
      }
      if (!absl::IsCancelled(status)) {
        save_as_.error = std::string(status.message());
      }
    }
  }
 
  SameLine();
  const bool cancel =
      Button(absl::StrFormat("%s Cancel", ICON_MD_CANCEL).c_str(),
             ::yaze::gui::kDefaultModalSize);
  register_widget("Cancel", "button");
  if (cancel || IsKeyPressed(ImGuiKey_Escape)) {
    Hide(PopupID::kSaveAs);
  }
}
 
void PopupManager::DrawSaveScopePopup() {
  using namespace ImGui;
 
  Text(tr("%s Save Scope"), ICON_MD_SAVE);
  Separator();
  TextWrapped(
      tr("Controls which data is written during File > Save ROM. Dungeon "
         "choices also control Apply Room. "
         "Changes apply immediately."));
  Separator();
 
  if (CollapsingHeader(tr("Overworld"), ImGuiTreeNodeFlags_DefaultOpen)) {
    Checkbox(tr("Save Overworld Maps"),
             &core::FeatureFlags::get().overworld.kSaveOverworldMaps);
    Checkbox(tr("Save Overworld Entrances"),
             &core::FeatureFlags::get().overworld.kSaveOverworldEntrances);
    Checkbox(tr("Save Overworld Exits"),
             &core::FeatureFlags::get().overworld.kSaveOverworldExits);
    Checkbox(tr("Save Overworld Items"),
             &core::FeatureFlags::get().overworld.kSaveOverworldItems);
    Checkbox(tr("Save Overworld Sprites"),
             &core::FeatureFlags::get().overworld.kSaveOverworldSprites);
    Checkbox(tr("Save Overworld Properties"),
             &core::FeatureFlags::get().overworld.kSaveOverworldProperties);
  }
 
  if (CollapsingHeader(tr("Dungeon"), ImGuiTreeNodeFlags_DefaultOpen)) {
    Checkbox(tr("Save Dungeon Maps"),
             &core::FeatureFlags::get().kSaveDungeonMaps);
    Checkbox(tr("Save Objects"),
             &core::FeatureFlags::get().dungeon.kSaveObjects);
    Checkbox(tr("Save Sprites"),
             &core::FeatureFlags::get().dungeon.kSaveSprites);
    Checkbox(tr("Save Room Headers"),
             &core::FeatureFlags::get().dungeon.kSaveRoomHeaders);
    Checkbox(tr("Save Torches"),
             &core::FeatureFlags::get().dungeon.kSaveTorches);
    Checkbox(tr("Save Pits"), &core::FeatureFlags::get().dungeon.kSavePits);
    Checkbox(tr("Save Blocks"), &core::FeatureFlags::get().dungeon.kSaveBlocks);
    Checkbox(tr("Save Collision"),
             &core::FeatureFlags::get().dungeon.kSaveCollision);
    Checkbox(tr("Save Chests"), &core::FeatureFlags::get().dungeon.kSaveChests);
    Checkbox(tr("Save Pot Items"),
             &core::FeatureFlags::get().dungeon.kSavePotItems);
    if (IsItemHovered()) {
      SetTooltip(
          tr("Enable to save pending pot item edits, then retry Save "
             "or Apply Room. No project reopen is needed."));
    }
    Checkbox(tr("Save Entrances"),
             &core::FeatureFlags::get().dungeon.kSaveEntrances);
    Checkbox(tr("Save Palettes"),
             &core::FeatureFlags::get().dungeon.kSavePalettes);
  }
 
  if (CollapsingHeader(tr("Graphics"), ImGuiTreeNodeFlags_DefaultOpen)) {
    Checkbox(tr("Save Graphics Sheets"),
             &core::FeatureFlags::get().kSaveGraphicsSheet);
    Checkbox(tr("Save All Palettes"),
             &core::FeatureFlags::get().kSaveAllPalettes);
    Checkbox(tr("Save Gfx Groups"), &core::FeatureFlags::get().kSaveGfxGroups);
  }
 
  if (CollapsingHeader(tr("Messages"), ImGuiTreeNodeFlags_DefaultOpen)) {
    Checkbox(tr("Save Message Text"), &core::FeatureFlags::get().kSaveMessages);
  }
 
  Separator();
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide(PopupID::kSaveScope);
  }
}
 
void PopupManager::DrawRomBackupManagerPopup() {
  using namespace ImGui;
 
  auto* rom = editor_manager_->GetCurrentRom();
  if (!rom || !rom->is_loaded()) {
    Text(tr("No ROM loaded."));
    if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
      Hide(PopupID::kRomBackups);
    }
    return;
  }
 
  const auto* project = editor_manager_->GetCurrentProject();
  std::string backup_dir;
  if (project && project->project_opened() &&
      !project->rom_backup_folder.empty()) {
    backup_dir = project->GetAbsolutePath(project->rom_backup_folder);
  } else {
    backup_dir = std::filesystem::path(rom->filename()).parent_path().string();
  }
 
  Text(tr("%s ROM Backups"), ICON_MD_BACKUP);
  Separator();
  TextWrapped(tr("Backup folder: %s"), backup_dir.c_str());
 
  if (editor_manager_->IsRomBackupRestorePending()) {
    Separator();
    TextWrapped(
        tr("A restored backup is staged in this session. Save ROM to commit "
           "it. Discard reloads the backing ROM and abandons staged ROM-buffer "
           "edits; resolve pending graphics, dungeon, or palette edits "
           "first."));
    if (Button(ICON_MD_UNDO " Discard Restored Backup")) {
      auto status = editor_manager_->DiscardPendingRomBackupRestore();
      if (!status.ok()) {
        if (auto* toast = editor_manager_->toast_manager()) {
          toast->Show(absl::StrFormat("Discard failed: %s", status.message()),
                      ToastType::kError);
        }
      } else if (auto* toast = editor_manager_->toast_manager()) {
        toast->Show("Restored backup discarded; reloaded ROM from disk",
                    ToastType::kSuccess);
      }
    }
    Separator();
  }
 
  if (Button(ICON_MD_DELETE_SWEEP " Prune Backups")) {
    auto status = editor_manager_->PruneRomBackups();
    if (!status.ok()) {
      if (auto* toast = editor_manager_->toast_manager()) {
        toast->Show(absl::StrFormat("Prune failed: %s", status.message()),
                    ToastType::kError);
      }
    } else if (auto* toast = editor_manager_->toast_manager()) {
      toast->Show("Backups pruned", ToastType::kSuccess);
    }
  }
 
  Separator();
  auto backups = editor_manager_->GetRomBackups();
  if (backups.empty()) {
    TextDisabled(tr("No backups found."));
  } else if (BeginTable("RomBackupTable", 4,
                        ImGuiTableFlags_RowBg | ImGuiTableFlags_Borders |
                            ImGuiTableFlags_Resizable)) {
    TableSetupColumn("Timestamp");
    TableSetupColumn("Size");
    TableSetupColumn("Filename");
    TableSetupColumn("Actions");
    TableHeadersRow();
 
    auto format_size = [](uintmax_t bytes) {
      if (bytes > (1024 * 1024)) {
        return absl::StrFormat("%.2f MB",
                               static_cast<double>(bytes) / (1024 * 1024));
      }
      if (bytes > 1024) {
        return absl::StrFormat("%.1f KB", static_cast<double>(bytes) / 1024.0);
      }
      return absl::StrFormat("%llu B", static_cast<unsigned long long>(bytes));
    };
 
    for (size_t i = 0; i < backups.size(); ++i) {
      const auto& backup = backups[i];
      TableNextRow();
      TableNextColumn();
      char time_buffer[32] = "unknown";
      if (backup.timestamp != 0) {
        std::tm local_tm{};
#ifdef _WIN32
        localtime_s(&local_tm, &backup.timestamp);
#else
        localtime_r(&backup.timestamp, &local_tm);
#endif
        std::strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%d %H:%M:%S",
                      &local_tm);
      }
      TextUnformatted(time_buffer);
 
      TableNextColumn();
      TextUnformatted(format_size(backup.size_bytes).c_str());
 
      TableNextColumn();
      TextUnformatted(backup.filename.c_str());
 
      TableNextColumn();
      PushID(static_cast<int>(i));
      if (Button(ICON_MD_RESTORE " Restore")) {
        auto status = editor_manager_->RestoreRomBackup(backup.path);
        if (!status.ok()) {
          if (auto* toast = editor_manager_->toast_manager()) {
            toast->Show(absl::StrFormat("Restore failed: %s", status.message()),
                        ToastType::kError);
          }
        } else if (auto* toast = editor_manager_->toast_manager()) {
          toast->Show("Backup loaded; inspect it, then save ROM to commit",
                      ToastType::kSuccess);
        }
      }
      SameLine();
      if (Button(ICON_MD_OPEN_IN_NEW " Open")) {
        auto status = editor_manager_->OpenRomOrProject(backup.path);
        if (!status.ok()) {
          if (auto* toast = editor_manager_->toast_manager()) {
            toast->Show(absl::StrFormat("Open failed: %s", status.message()),
                        ToastType::kError);
          }
        }
      }
      SameLine();
      if (Button(ICON_MD_CONTENT_COPY " Copy")) {
        SetClipboardText(backup.path.c_str());
      }
      PopID();
    }
    EndTable();
  }
 
  Separator();
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide(PopupID::kRomBackups);
  }
}
 
void PopupManager::DrawNewProjectPopup() {
  using namespace ImGui;
 
  static std::string project_name = "";
  static std::string project_filepath = "";
  static std::string rom_filename = "";
  static std::string labels_filename = "";
  static std::string code_folder = "";
 
  InputText(tr("Project Name"), &project_name);
 
  if (Button(absl::StrFormat("%s Destination Folder", ICON_MD_FOLDER).c_str(),
             ::yaze::gui::kDefaultModalSize)) {
    project_filepath = util::FileDialogWrapper::ShowOpenFolderDialog();
  }
  SameLine();
  Text("%s", project_filepath.empty() ? "(Not set)" : project_filepath.c_str());
 
  if (Button(absl::StrFormat("%s ROM File", ICON_MD_VIDEOGAME_ASSET).c_str(),
             ::yaze::gui::kDefaultModalSize)) {
    rom_filename = util::FileDialogWrapper::ShowOpenFileDialog(
        util::MakeRomFileDialogOptions(false));
  }
  SameLine();
  Text("%s", rom_filename.empty() ? "(Not set)" : rom_filename.c_str());
 
  if (Button(absl::StrFormat("%s Labels File", ICON_MD_LABEL).c_str(),
             ::yaze::gui::kDefaultModalSize)) {
    labels_filename = util::FileDialogWrapper::ShowOpenFileDialog();
  }
  SameLine();
  Text("%s", labels_filename.empty() ? "(Not set)" : labels_filename.c_str());
 
  if (Button(absl::StrFormat("%s Code Folder", ICON_MD_CODE).c_str(),
             ::yaze::gui::kDefaultModalSize)) {
    code_folder = util::FileDialogWrapper::ShowOpenFolderDialog();
  }
  SameLine();
  Text("%s", code_folder.empty() ? "(Not set)" : code_folder.c_str());
 
  Separator();
 
  if (Button(absl::StrFormat("%s Choose Project File Location", ICON_MD_SAVE)
                 .c_str(),
             ::yaze::gui::kDefaultModalSize)) {
    auto project_file_path =
        util::FileDialogWrapper::ShowSaveFileDialog(project_name, "yaze");
    if (!project_file_path.empty()) {
      if (!(absl::EndsWith(project_file_path, ".yaze") ||
            absl::EndsWith(project_file_path, ".yazeproj"))) {
        project_file_path += ".yaze";
      }
      project_filepath = project_file_path;
    }
  }
 
  if (Button(absl::StrFormat("%s Create Project", ICON_MD_ADD).c_str(),
             ::yaze::gui::kDefaultModalSize)) {
    if (!project_filepath.empty() && !project_name.empty() &&
        !rom_filename.empty()) {
      auto status = editor_manager_->CreateNewProjectFromRom(
          "Basic ROM Hack", rom_filename, project_name, project_filepath);
      if (status.ok()) {
        auto* project = editor_manager_->GetCurrentProject();
        if (project) {
          if (!labels_filename.empty()) {
            project->labels_filename = labels_filename;
          }
          if (!code_folder.empty()) {
            project->code_folder = code_folder;
          }
          if (!labels_filename.empty() || !code_folder.empty()) {
            editor_manager_->MarkCurrentProjectDirty();
            status = editor_manager_->SaveProject();
          }
        }
      }
      if (status.ok()) {
        // Clear fields
        project_name = "";
        project_filepath = "";
        rom_filename = "";
        labels_filename = "";
        code_folder = "";
        Hide(PopupID::kNewProject);
      } else {
        SetStatus(status);
      }
    }
  }
  SameLine();
  if (Button(absl::StrFormat("%s Cancel", ICON_MD_CANCEL).c_str(),
             ::yaze::gui::kDefaultModalSize)) {
    // Clear fields
    project_name = "";
    project_filepath = "";
    rom_filename = "";
    labels_filename = "";
    code_folder = "";
    Hide(PopupID::kNewProject);
  }
}
 
void PopupManager::DrawSupportedFeaturesPopup() {
  const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
  const ImVec4 status_ok = gui::ConvertColorToImVec4(theme.success);
  const ImVec4 status_warn = gui::ConvertColorToImVec4(theme.warning);
  const ImVec4 status_info = gui::ConvertColorToImVec4(theme.info);
  const ImVec4 status_error = gui::ConvertColorToImVec4(theme.error);
 
  auto status_color = [&](const char* status) -> ImVec4 {
    if (strcmp(status, "Stable") == 0 || strcmp(status, "Working") == 0) {
      return status_ok;
    }
    if (strcmp(status, "Beta") == 0 || strcmp(status, "Experimental") == 0) {
      return status_warn;
    }
    if (strcmp(status, "Preview") == 0) {
      return status_info;
    }
    if (strcmp(status, "Not available") == 0) {
      return status_error;
    }
    return status_info;
  };
 
  struct FeatureRow {
    const char* feature;
    const char* status;
    const char* persistence;
    const char* notes;
  };
 
  auto draw_table = [&](const char* table_id,
                        std::initializer_list<FeatureRow> rows) {
    ImGuiTableFlags flags = ImGuiTableFlags_BordersInnerH |
                            ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable;
    if (!BeginTable(table_id, 4, flags)) {
      return;
    }
    TableSetupColumn("Feature", ImGuiTableColumnFlags_WidthStretch);
    TableSetupColumn("Status", ImGuiTableColumnFlags_WidthFixed, 120.0f);
    TableSetupColumn("Save/Load", ImGuiTableColumnFlags_WidthFixed, 180.0f);
    TableSetupColumn("Notes", ImGuiTableColumnFlags_WidthStretch);
    TableHeadersRow();
 
    for (const auto& row : rows) {
      TableNextRow();
      TableSetColumnIndex(0);
      TextUnformatted(row.feature);
      TableSetColumnIndex(1);
      TextColored(status_color(row.status), "%s", row.status);
      TableSetColumnIndex(2);
      TextUnformatted(row.persistence);
      TableSetColumnIndex(3);
      TextWrapped("%s", row.notes);
    }
 
    EndTable();
  };
 
  TextDisabled(
      tr("Status: Stable = production ready, Beta = usable with gaps, "
         "Experimental = WIP, Preview = web parity in progress."));
  TextDisabled(tr("See Settings > Feature Flags for ROM-specific toggles."));
  Spacing();
 
  if (CollapsingHeader(tr("Desktop App (yaze)"),
                       ImGuiTreeNodeFlags_DefaultOpen)) {
    draw_table("desktop_features",
               {
                   {"ROM load/save", "Stable", "ROM + backups",
                    "Backups on save when enabled."},
                   {"Overworld Editor", "Stable", "ROM",
                    "Maps/entrances/exits/items; version-gated."},
                   {"Dungeon Editor", "Stable", "ROM",
                    "Room objects/tiles/palettes persist."},
                   {"Palette Editor", "Stable", "ROM",
                    "Palette edits persist; JSON IO pending."},
                   {"Graphics Editor", "Beta", "ROM",
                    "Sheet edits persist; tooling still expanding."},
                   {"Sprite Editor", "Stable", "ROM", "Sprite edits persist."},
                   {"Message Editor", "Stable", "ROM", "Text edits persist."},
                   {"Screen Editor", "Experimental", "ROM (partial)",
                    "Save coverage incomplete."},
                   {"Hex Editor", "Beta", "ROM", "Search UX incomplete."},
                   {"Assembly/Asar", "Beta", "ROM + project",
                    "Patch apply + symbol export."},
                   {"Emulator", "Beta", "Runtime only",
                    "Save-state UI partially wired."},
                   {"Music Editor", "Experimental", "ROM (partial)",
                    "Serialization in progress."},
                   {"Agent UI", "Experimental", ".yaze/agent",
                    "Requires AI provider configuration."},
                   {"Settings/Layouts", "Beta", ".yaze config",
                    "Layout serialization improving."},
               });
  }
 
  if (CollapsingHeader(tr("z3ed CLI"))) {
    draw_table("cli_features",
               {
                   {"ROM read/write/validate", "Stable", "ROM file",
                    "Direct command execution."},
                   {"Agent workflows", "Stable", ".yaze/proposals + sandboxes",
                    "Commit writes ROM; revert reloads."},
                   {"Snapshots/restore", "Stable", "Sandbox copies",
                    "Supports YAZE_SANDBOX_ROOT override."},
                   {"Doctor/test suites", "Stable", "Reports",
                    "Structured output for automation."},
                   {"TUI/REPL", "Stable", "Session history",
                    "Interactive command palette + logs."},
               });
  }
 
  if (CollapsingHeader(tr("Web/WASM Preview"))) {
    draw_table(
        "web_features",
        {
            {"ROM load/save", "Preview", "IndexedDB + download",
             "Drag/drop or picker; download for backups."},
            {"Editors (OW/Dungeon/Palette/etc.)", "Preview",
             "IndexedDB + download", "Parity work in progress."},
            {"Hex Editor", "Working", "IndexedDB + download",
             "Direct ROM editing available."},
            {"Asar patching", "Preview", "ROM", "Basic patch apply support."},
            {"Emulator", "Not available", "N/A", "Desktop only."},
            {"Collaboration", "Experimental", "Server",
             "Requires yaze-server."},
            {"AI features", "Preview", "Server", "Requires AI-enabled server."},
        });
  }
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide(PopupID::kSupportedFeatures);
  }
}
 
void PopupManager::DrawOpenRomHelpPopup() {
  Text(tr("File -> Open"));
  Text(tr("Select a ROM file to open"));
  Text(tr("Supported ROMs (headered or unheadered):"));
  Text(tr("The Legend of Zelda: A Link to the Past"));
  Text(tr("US Version 1.0"));
  Text(tr("JP Version 1.0"));
  Spacing();
  TextWrapped(
      tr("ROM files are not bundled. Use a clean, legally obtained copy."));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Open a ROM");
  }
}
 
void PopupManager::DrawManageProjectPopup() {
  Text(tr("Project Menu"));
  Text(tr("Create a new project or open an existing one."));
  Text(tr("Save the project to save the current state of the project."));
  TextWrapped(
      tr("To save a project, you need to first open a ROM and initialize your "
         "code path and labels file. Label resource manager can be found in "
         "the View menu. Code path is set in the Code editor after opening a "
         "folder."));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Manage Project");
  }
}
 
void PopupManager::DrawGettingStartedPopup() {
  TextWrapped(tr("Welcome to YAZE v%s!"), YAZE_VERSION_STRING);
  TextWrapped(tr(
      "YAZE lets you modify 'The Legend of Zelda: A Link to the Past' (US or "
      "JP) ROMs with modern tooling."));
  Spacing();
  TextWrapped(tr("Release Highlights:"));
  BulletText(
      tr("AI-assisted workflows via z3ed agent and in-app panels "
         "(Ollama/Gemini/OpenAI/Anthropic)"));
  BulletText(tr("Clear feature status panels and improved help/tooltips"));
  BulletText(tr("Unified .yaze storage across desktop/CLI/web"));
  Spacing();
  TextWrapped(tr("General Tips:"));
  BulletText(tr("Open a clean ROM and save a backup before editing"));
  BulletText(tr("Use Help (F1) for context-aware guidance and shortcuts"));
  BulletText(tr("Coming from ZScream? Open Help → Coming from ZScream"));
  BulletText(tr(
      "Configure AI providers (Ollama/Gemini/OpenAI/Anthropic) in Settings > "
      "Agent"));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Getting Started");
  }
}
 
void PopupManager::DrawAsarIntegrationPopup() {
  TextWrapped(tr("Asar 65816 Assembly Integration"));
  TextWrapped(
      tr("YAZE includes full Asar assembler support for ROM patching."));
  Spacing();
  TextWrapped(tr("Features:"));
  BulletText(tr("Cross-platform ROM patching with assembly code"));
  BulletText(tr("Symbol export with addresses and opcodes"));
  BulletText(tr("Assembly validation with detailed error reporting"));
  BulletText(tr("Memory-safe patch application with size checks"));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Asar Integration");
  }
}
 
void PopupManager::DrawBuildInstructionsPopup() {
  TextWrapped(tr("Build Instructions"));
  TextWrapped(tr("YAZE uses modern CMake for cross-platform builds."));
  Spacing();
  TextWrapped(tr("Quick Start (examples):"));
  BulletText(tr("cmake --preset mac-dbg | lin-dbg | win-dbg"));
  BulletText(tr("cmake --build --preset <preset> --target yaze"));
  Spacing();
  TextWrapped(tr("AI Builds:"));
  BulletText(tr("cmake --preset mac-ai | lin-ai | win-ai"));
  BulletText(tr("cmake --build --preset <preset> --target yaze z3ed"));
  Spacing();
  TextWrapped(tr("Docs: docs/public/build/quick-reference.md"));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Build Instructions");
  }
}
 
void PopupManager::DrawCLIUsagePopup() {
  TextWrapped(tr("Command Line Interface (z3ed)"));
  TextWrapped(tr("Scriptable ROM editing and AI agent workflows."));
  Spacing();
  TextWrapped(tr("Commands:"));
  BulletText(tr("z3ed rom-info --rom=zelda3.sfc"));
  BulletText(tr("z3ed agent simple-chat --rom=zelda3.sfc --ai_provider=auto"));
  BulletText(tr("z3ed agent plan --rom=zelda3.sfc"));
  BulletText(tr("z3ed test-list --format json"));
  BulletText(tr("z3ed patch apply-asar patch.asm --rom=zelda3.sfc"));
  BulletText(tr("z3ed help dungeon-place-sprite"));
  Spacing();
  TextWrapped(tr("Storage:"));
  BulletText(
      tr("Agent plans/proposals live under ~/.yaze (see docs for details)"));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("CLI Usage");
  }
}
 
void PopupManager::DrawTroubleshootingPopup() {
  TextWrapped(tr("Troubleshooting"));
  TextWrapped(tr("Common issues and solutions:"));
  Spacing();
  BulletText(tr("ROM won't load: Check file format (SFC/SMC supported)"));
  BulletText(
      tr("AI agent missing: Start Ollama or set GEMINI_API_KEY/OPENAI_API_KEY/"
         "ANTHROPIC_API_KEY (web uses AI_AGENT_ENDPOINT)"));
  BulletText(tr("Graphics issues: Disable experimental flags in Settings"));
  BulletText(
      tr("Performance: Enable hardware acceleration in display settings"));
  BulletText(tr("Crashes: Check ROM file integrity and available memory"));
  BulletText(tr("Layout issues: Reset workspace layouts from View > Layouts"));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Troubleshooting");
  }
}
 
void PopupManager::DrawContributingPopup() {
  TextWrapped(tr("Contributing to YAZE"));
  TextWrapped(tr("YAZE is open source and welcomes contributions!"));
  Spacing();
  TextWrapped(tr("How to contribute:"));
  BulletText(tr("Fork the repository on GitHub"));
  BulletText(tr("Create feature branches for new work"));
  BulletText(tr("Follow C++ coding standards"));
  BulletText(tr("Include tests for new features"));
  BulletText(tr("Submit pull requests for review"));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Contributing");
  }
}
 
void PopupManager::DrawWhatsNewPopup() {
  TextWrapped(tr("What's New in YAZE v%s"), YAZE_VERSION_STRING);
  Spacing();
 
  if (CollapsingHeader(
          absl::StrFormat("%s User Interface & Theming", ICON_MD_PALETTE)
              .c_str(),
          ImGuiTreeNodeFlags_DefaultOpen)) {
    BulletText(
        tr("Feature status/persistence summaries across desktop/CLI/web"));
    BulletText(tr("Shortcut/help panels now match configured keybindings"));
    BulletText(tr("Refined onboarding tips and error messaging"));
    BulletText(tr("Help text refreshed across desktop, CLI, and web"));
  }
 
  if (CollapsingHeader(
          absl::StrFormat("%s Development & Build System", ICON_MD_BUILD)
              .c_str(),
          ImGuiTreeNodeFlags_DefaultOpen)) {
    BulletText(tr("Asar 65816 assembler integration for ROM patching"));
    BulletText(tr("z3ed CLI + TUI for scripting, test/doctor, and automation"));
    BulletText(tr("Modern CMake presets for desktop, AI, and web builds"));
    BulletText(tr("Unified version + storage references for 0.5.1"));
  }
 
  if (CollapsingHeader(
          absl::StrFormat("%s Core Improvements", ICON_MD_SETTINGS).c_str())) {
    BulletText(tr("Improved project metadata + .yaze storage alignment"));
    BulletText(tr("Stronger error reporting and status feedback"));
    BulletText(tr("Performance and stability improvements across editors"));
    BulletText(tr("Expanded logging and diagnostics tooling"));
  }
 
  if (CollapsingHeader(
          absl::StrFormat("%s Editor Features", ICON_MD_EDIT).c_str())) {
    BulletText(tr("Music editor updates with SPC parsing/playback"));
    BulletText(
        tr("AI agent-assisted editing workflows (multi-provider + vision)"));
    BulletText(tr("Expanded overworld/dungeon tooling and palette accuracy"));
    BulletText(tr("Web/WASM preview with collaboration hooks"));
  }
 
  Spacing();
  if (Button(
          absl::StrFormat("%s View Release Notes", ICON_MD_DESCRIPTION).c_str(),
          ImVec2(-1, 30))) {
    // Close this popup and show theme settings
    Hide(PopupID::kWhatsNew);
    // Could trigger release notes panel opening here
  }
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide(PopupID::kWhatsNew);
  }
}
 
void PopupManager::DrawComingFromZScreamPopup() {
  TextWrapped(tr("Coming from ZScream?"));
  TextWrapped(tr(
      "yaze covers the same Zelda 3 editing surfaces with a modern workspace, "
      "projects, and CLI. Use this map to find familiar tools."));
  Spacing();
 
  if (CollapsingHeader(absl::StrFormat("%s Editors", ICON_MD_APPS).c_str(),
                       ImGuiTreeNodeFlags_DefaultOpen)) {
    BulletText(tr("Overworld Editor ≈ ZScream overworld map canvas + tile16"));
    BulletText(
        tr("Dungeon Editor ≈ underworld rooms (objects, sprites, properties)"));
    BulletText(tr("Graphics / Sprite Editors ≈ GFX + sprite drawing"));
    BulletText(tr("Palette Editor ≈ palette groups and edits"));
    BulletText(tr("Message Editor ≈ dialogue / text"));
    BulletText(
        tr("Screen Editor → Overworld Map ≈ pause-menu map art "
           "(not the playable overworld)"));
  }
 
  if (CollapsingHeader(
          absl::StrFormat("%s Layout & navigation", ICON_MD_DASHBOARD).c_str(),
          ImGuiTreeNodeFlags_DefaultOpen)) {
    BulletText(
        tr("Left activity bar opens editor categories (like ZScream "
           "tool tabs)"));
    BulletText(
        tr("Dungeon workbench defaults to ZScream-style: selectors "
           "left, inspector right"));
    BulletText(tr("Ctrl+Shift+P opens the command palette for any action"));
    BulletText(
        tr("F1 / Help drawer shows context shortcuts for the active "
           "editor"));
  }
 
  if (CollapsingHeader(
          absl::StrFormat("%s Projects & ROM files", ICON_MD_FOLDER).c_str(),
          ImGuiTreeNodeFlags_DefaultOpen)) {
    BulletText(
        tr(".yaze / .yazeproj track ROM path, flags, and workspace "
           "settings"));
    BulletText(
        tr(".zsproj can be opened when present — same Open ROM / "
           "Project flow"));
    BulletText(
        tr("Always keep a clean backup; Backup Before Save is on by "
           "default"));
    BulletText(
        tr("ZSO / ZSCustomOverworld versions are detected from the ROM "
           "(vanilla, v1, v2, v3)"));
  }
 
  if (CollapsingHeader(
          absl::StrFormat("%s Overworld specifics", ICON_MD_LANDSCAPE).c_str(),
          ImGuiTreeNodeFlags_DefaultOpen)) {
    BulletText(tr("Tile16 selector / workbench ≈ ZScream tile picker + paint"));
    BulletText(
        tr("Map Properties gates ZSO fields (area size, BG colors, "
           "animated GFX) by detected version"));
    BulletText(tr("Screen Editor → Overworld Map is pause-menu art only"));
  }
 
  if (CollapsingHeader(absl::StrFormat("%s Saving", ICON_MD_SAVE).c_str())) {
    BulletText(tr("File → Save Scope chooses ROM, project, or both"));
    BulletText(tr("Autosave can be tuned under Settings → Editor Behavior"));
    BulletText(tr("ROM Backups lists timestamped copies for restore"));
  }
 
  Spacing();
  TextWrapped(tr(
      "Tip: first-run toasts point at this guide once per tip. Reset tips in "
      "Settings → Editor Behavior if you want them again."));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide(PopupID::kComingFromZScream);
  }
}
 
void PopupManager::DrawWorkspaceHelpPopup() {
  TextWrapped(tr("Workspace Management"));
  TextWrapped(tr(
      "YAZE supports multiple ROM sessions and flexible workspace layouts."));
  Spacing();
 
  TextWrapped(tr("Session Management:"));
  BulletText(tr("Ctrl+Shift+N: Create new session"));
  BulletText(tr("Ctrl+Shift+W: Close current session"));
  BulletText(tr("Ctrl+Tab: Quick session switcher"));
  BulletText(tr("Each session maintains its own ROM and editor state"));
 
  Spacing();
  TextWrapped(tr("Layout Management:"));
  BulletText(tr("Drag window tabs to dock/undock"));
  BulletText(tr("Ctrl+Shift+S: Save current layout"));
  BulletText(tr("Ctrl+Shift+O: Load saved layout"));
  BulletText(tr("F11: Maximize current window"));
 
  Spacing();
  TextWrapped(tr("Preset Layouts:"));
  BulletText(tr("Developer: Code, memory, testing tools"));
  BulletText(tr("Designer: Graphics, palettes, sprites"));
  BulletText(tr("Modder: All gameplay editing tools"));
 
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Workspace Help");
  }
}
 
void PopupManager::DrawSessionLimitWarningPopup() {
  TextColored(gui::GetWarningColor(), tr("%s Warning"), ICON_MD_WARNING);
  TextWrapped(tr("You have reached the recommended session limit."));
  TextWrapped(tr("Having too many sessions open may impact performance."));
  Spacing();
  TextWrapped(tr("Consider closing unused sessions or saving your work."));
 
  if (Button(tr("Understood"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Session Limit Warning");
  }
  SameLine();
  if (Button(tr("Open Session Manager"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Session Limit Warning");
    // This would trigger the session manager to open
  }
}
 
void PopupManager::DrawLayoutResetConfirmPopup() {
  TextColored(gui::GetWarningColor(), tr("%s Confirm Reset"), ICON_MD_WARNING);
  TextWrapped(tr("This will reset your current workspace layout to default."));
  TextWrapped(tr("Any custom window arrangements will be lost."));
  Spacing();
  TextWrapped(tr("Do you want to continue?"));
 
  if (Button(tr("Reset Layout"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Layout Reset Confirm");
    // This would trigger the actual reset
  }
  SameLine();
  if (Button(tr("Cancel"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Layout Reset Confirm");
  }
}
 
void PopupManager::DrawLayoutPresetsPopup() {
  TextColored(gui::GetInfoColor(), tr("%s Layout Presets"), ICON_MD_DASHBOARD);
  Separator();
  Spacing();
 
  TextWrapped(
      tr("Choose a workspace preset to quickly configure your layout:"));
  Spacing();
 
  // Get named presets from LayoutPresets
  struct PresetInfo {
    const char* name;
    const char* icon;
    const char* description;
    std::function<PanelLayoutPreset()> getter;
  };
 
  PresetInfo presets[] = {
      {"Minimal", ICON_MD_CROP_FREE,
       "Essential cards only - maximum editing space",
       []() { return LayoutPresets::GetMinimalPreset(); }},
      {"Developer", ICON_MD_BUG_REPORT,
       "Debug and development focused - CPU/Memory/Breakpoints",
       []() { return LayoutPresets::GetDeveloperPreset(); }},
      {"Designer", ICON_MD_PALETTE,
       "Visual and artistic focused - Graphics/Palettes/Sprites",
       []() { return LayoutPresets::GetDesignerPreset(); }},
      {"Modder", ICON_MD_BUILD,
       "Full-featured - All tools available for comprehensive editing",
       []() { return LayoutPresets::GetModderPreset(); }},
      {"Overworld Expert", ICON_MD_MAP,
       "Complete overworld editing toolkit with all map tools",
       []() { return LayoutPresets::GetOverworldArtistPreset(); }},
      {"Dungeon Expert", ICON_MD_DOOR_SLIDING,
       "Complete dungeon editing toolkit with room tools",
       []() { return LayoutPresets::GetDungeonMasterPreset(); }},
      {"Testing", ICON_MD_SCIENCE, "Quality assurance and ROM testing layout",
       []() { return LayoutPresets::GetLogicDebuggerPreset(); }},
      {"Audio", ICON_MD_MUSIC_NOTE, "Music and sound editing layout",
       []() { return LayoutPresets::GetAudioEngineerPreset(); }},
  };
 
  constexpr int kPresetCount = 8;
 
  // Draw preset buttons in a grid
  float button_width = 200.0f;
  float button_height = 50.0f;
 
  for (int i = 0; i < kPresetCount; i++) {
    if (i % 2 != 0)
      SameLine();
 
    {
      gui::StyleVarGuard align_guard(ImGuiStyleVar_ButtonTextAlign,
                                     ImVec2(0.0f, 0.5f));
      if (Button(absl::StrFormat("%s %s", presets[i].icon, presets[i].name)
                     .c_str(),
                 ImVec2(button_width, button_height))) {
        // Apply the preset
        auto preset = presets[i].getter();
        auto& window_manager = editor_manager_->window_manager();
        // Hide all panels first
        window_manager.HideAll();
        // Show preset panels
        for (const auto& panel_id : preset.default_visible_panels) {
          window_manager.OpenWindow(panel_id);
        }
        Hide(PopupID::kLayoutPresets);
      }
    }
 
    if (IsItemHovered()) {
      BeginTooltip();
      TextUnformatted(presets[i].description);
      EndTooltip();
    }
  }
 
  Spacing();
  Separator();
  Spacing();
 
  // Reset current editor to defaults
  if (Button(
          absl::StrFormat("%s Reset Current Editor", ICON_MD_REFRESH).c_str(),
          ImVec2(-1, 0))) {
    auto& window_manager = editor_manager_->window_manager();
    auto* current_editor = editor_manager_->GetCurrentEditor();
    if (current_editor) {
      auto current_type = current_editor->type();
      window_manager.ResetToDefaults(0, current_type);
    }
    Hide(PopupID::kLayoutPresets);
  }
 
  Spacing();
  if (Button(tr("Close"), ImVec2(-1, 0))) {
    Hide(PopupID::kLayoutPresets);
  }
}
 
void PopupManager::DrawSessionManagerPopup() {
  TextColored(gui::GetInfoColor(), tr("%s Session Manager"), ICON_MD_TAB);
  Separator();
  Spacing();
 
  size_t session_count = editor_manager_->GetActiveSessionCount();
  size_t active_session = editor_manager_->GetCurrentSessionIndex();
 
  Text(tr("Active Sessions: %zu"), session_count);
  Spacing();
 
  // Session table
  if (BeginTable("SessionTable", 4,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
    TableSetupColumn("#", ImGuiTableColumnFlags_WidthFixed, 30.0f);
    TableSetupColumn("ROM", ImGuiTableColumnFlags_WidthStretch);
    TableSetupColumn("Status", ImGuiTableColumnFlags_WidthFixed, 80.0f);
    TableSetupColumn("Actions", ImGuiTableColumnFlags_WidthFixed, 120.0f);
    TableHeadersRow();
 
    for (size_t i = 0; i < session_count; i++) {
      TableNextRow();
 
      // Session number
      TableSetColumnIndex(0);
      Text("%zu", i + 1);
 
      // ROM name (simplified - show current ROM for active session)
      TableSetColumnIndex(1);
      if (i == active_session) {
        auto* rom = editor_manager_->GetCurrentRom();
        if (rom && rom->is_loaded()) {
          TextUnformatted(rom->filename().c_str());
        } else {
          TextDisabled(tr("(No ROM loaded)"));
        }
      } else {
        TextDisabled(tr("Session %zu"), i + 1);
      }
 
      // Status indicator
      TableSetColumnIndex(2);
      if (i == active_session) {
        TextColored(gui::GetSuccessColor(), tr("%s Active"),
                    ICON_MD_CHECK_CIRCLE);
      } else {
        TextDisabled(tr("Inactive"));
      }
 
      // Actions
      TableSetColumnIndex(3);
      PushID(static_cast<int>(i));
 
      if (i != active_session) {
        if (SmallButton(tr("Switch"))) {
          editor_manager_->SwitchToSession(i);
        }
        SameLine();
      }
 
      BeginDisabled(session_count <= 1);
      if (SmallButton(tr("Close"))) {
        editor_manager_->RemoveSession(i);
      }
      EndDisabled();
 
      PopID();
    }
 
    EndTable();
  }
 
  Spacing();
  Separator();
  Spacing();
 
  // New session button
  if (Button(absl::StrFormat("%s New Session", ICON_MD_ADD).c_str(),
             ImVec2(-1, 0))) {
    editor_manager_->CreateNewSession();
  }
 
  Spacing();
  if (Button(tr("Close"), ImVec2(-1, 0))) {
    Hide(PopupID::kSessionManager);
  }
}
 
void PopupManager::DrawDisplaySettingsPopup() {
  // Set a comfortable default size with natural constraints
  SetNextWindowSize(ImVec2(900, 700), ImGuiCond_FirstUseEver);
  SetNextWindowSizeConstraints(ImVec2(600, 400), ImVec2(FLT_MAX, FLT_MAX));
 
  Text(tr("%s Display & Theme Settings"), ICON_MD_DISPLAY_SETTINGS);
  TextWrapped(tr("Customize your YAZE experience - accessible anytime!"));
  Separator();
 
  // Create a child window for scrollable content to avoid table conflicts
  // Use remaining space minus the close button area
  float available_height =
      GetContentRegionAvail().y - 60;  // Reserve space for close button
  if (BeginChild("DisplaySettingsContent", ImVec2(0, available_height), true,
                 ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
    // Use the popup-safe version to avoid table conflicts
    gui::DrawDisplaySettingsForPopup();
 
    Separator();
    gui::TextWithSeparators("Font Manager");
    gui::DrawFontManager();
 
    // Global font scale (moved from the old display settings window)
    ImGuiIO& io = GetIO();
    Separator();
    Text(tr("Global Font Scale"));
    float font_global_scale = io.FontGlobalScale;
    if (SliderFloat("##global_scale", &font_global_scale, 0.5f, 2.0f, "%.2f")) {
      if (editor_manager_) {
        editor_manager_->SetFontGlobalScale(font_global_scale);
      } else {
        io.FontGlobalScale = font_global_scale;
      }
    }
  }
  EndChild();
 
  Separator();
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide("Display Settings");
  }
}
 
void PopupManager::DrawFeatureFlagsPopup() {
  using namespace ImGui;
 
  // Display feature flags editor using the existing FlagsMenu system
  Text(tr("Feature Flags Configuration"));
  Separator();
 
  BeginChild("##FlagsContent", ImVec2(0, -30), true);
 
  // Use the feature flags menu system
  static gui::FlagsMenu flags_menu;
 
  if (BeginTabBar("FlagCategories")) {
    if (BeginTabItem(tr("Overworld"))) {
      flags_menu.DrawOverworldFlags();
      EndTabItem();
    }
    if (BeginTabItem(tr("Dungeon"))) {
      flags_menu.DrawDungeonFlags();
      EndTabItem();
    }
    if (BeginTabItem(tr("Resources"))) {
      flags_menu.DrawResourceFlags();
      EndTabItem();
    }
    if (BeginTabItem(tr("System"))) {
      flags_menu.DrawSystemFlags();
      EndTabItem();
    }
    EndTabBar();
  }
 
  EndChild();
 
  Separator();
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide(PopupID::kFeatureFlags);
  }
}
 
void PopupManager::DrawDataIntegrityPopup() {
  using namespace ImGui;
 
  Text(tr("Data Integrity Check Results"));
  Separator();
 
  BeginChild("##IntegrityContent", ImVec2(0, -30), true);
 
  // Placeholder for data integrity results
  // In a full implementation, this would show test results
  Text(tr("ROM Data Integrity:"));
  Separator();
  TextColored(gui::GetSuccessColor(), tr("✓ ROM header valid"));
  TextColored(gui::GetSuccessColor(), tr("✓ Checksum valid"));
  TextColored(gui::GetSuccessColor(), tr("✓ Graphics data intact"));
  TextColored(gui::GetSuccessColor(), tr("✓ Map data intact"));
 
  Spacing();
  Text(tr("No issues detected."));
 
  EndChild();
 
  Separator();
  if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
    Hide(PopupID::kDataIntegrity);
  }
}
 
void PopupManager::DrawDungeonPotItemSaveConfirmPopup() {
  using namespace ImGui;
 
  if (!editor_manager_) {
    Text(tr("Editor manager unavailable."));
    if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
      Hide(PopupID::kDungeonPotItemSaveConfirm);
    }
    return;
  }
 
  const int unloaded = editor_manager_->pending_pot_item_unloaded_rooms();
  const int total = editor_manager_->pending_pot_item_total_rooms();
 
  Text(tr("Pot Item Save Confirmation"));
  Separator();
  TextWrapped(tr("Dungeon pot item saving is enabled, but %d of %d rooms are "
                 "not loaded."),
              unloaded, total);
  Spacing();
  TextWrapped(
      tr("Saving now can overwrite pot items in unloaded rooms. Choose how to "
         "proceed:"));
 
  Spacing();
  if (Button(tr("Save without pot items"), ImVec2(0, 0))) {
    editor_manager_->ResolvePotItemSaveConfirmation(
        EditorManager::PotItemSaveDecision::kSaveWithoutPotItems);
    Hide(PopupID::kDungeonPotItemSaveConfirm);
    return;
  }
  SameLine();
  const bool save_anyway = Button(tr("Save anyway"), ImVec2(0, 0));
  if (ImGui::GetItemID() != 0) {
    gui::WidgetIdRegistry::Instance().RegisterWidget(
        "dungeon.pot_item_save_confirm/button:Save anyway", "button",
        ImGui::GetItemID(),
        "Continue the pending dungeon save with pot item writes enabled");
  }
  if (save_anyway) {
    editor_manager_->ResolvePotItemSaveConfirmation(
        EditorManager::PotItemSaveDecision::kSaveWithPotItems);
    Hide(PopupID::kDungeonPotItemSaveConfirm);
    return;
  }
  SameLine();
  if (Button(tr("Cancel"), ImVec2(0, 0))) {
    editor_manager_->ResolvePotItemSaveConfirmation(
        EditorManager::PotItemSaveDecision::kCancel);
    Hide(PopupID::kDungeonPotItemSaveConfirm);
  }
}
 
void PopupManager::DrawRomWriteConfirmPopup() {
  using namespace ImGui;
 
  if (!editor_manager_) {
    Text(tr("Editor manager unavailable."));
    if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
      Hide(PopupID::kRomWriteConfirm);
    }
    return;
  }
 
  auto role = project::RomRoleToString(editor_manager_->GetProjectRomRole());
  auto policy = project::RomWritePolicyToString(
      editor_manager_->GetProjectRomWritePolicy());
  const auto expected = editor_manager_->GetProjectExpectedRomHash();
  const auto actual = editor_manager_->GetCurrentRomHash();
  const auto* project = editor_manager_->GetCurrentProject();
  const auto actual_path = editor_manager_->GetCurrentRom()
                               ? editor_manager_->GetCurrentRom()->filename()
                               : std::string();
  const auto editable_path =
      project && project->hack_manifest.loaded() &&
              !project->hack_manifest.build_pipeline().dev_rom.empty()
          ? project->GetAbsolutePath(
                project->hack_manifest.build_pipeline().dev_rom)
          : (project ? project->rom_filename : std::string());
 
  Text(tr("ROM Write Confirmation"));
  Separator();
  TextWrapped(
      tr("The loaded ROM hash does not match the project's expected hash."));
  Spacing();
  Text(tr("Role: %s"), role.c_str());
  Text(tr("Write policy: %s"), policy.c_str());
  Text(tr("Loaded ROM: %s"),
       actual_path.empty() ? "(unknown)" : actual_path.c_str());
  Text(tr("Editable target: %s"),
       editable_path.empty() ? "(unset)" : editable_path.c_str());
  Text(tr("Expected: %s"), expected.empty() ? "(unset)" : expected.c_str());
  Text(tr("Actual:   %s"), actual.empty() ? "(unknown)" : actual.c_str());
  Spacing();
  TextWrapped(tr(
      "Proceeding will write to the current ROM file. This may corrupt a base "
      "or release ROM if it is not the intended editable project ROM."));
 
  Spacing();
  const bool save_anyway = Button(tr("Save anyway"), ImVec2(0, 0));
  gui::WidgetIdRegistry::Instance().RegisterWidget(
      "RomWriteConfirm/button:Save anyway", "button", GetItemID());
  if (save_anyway) {
    editor_manager_->ConfirmRomWrite();
    Hide(PopupID::kRomWriteConfirm);
    auto status = editor_manager_->ResumePendingRomSave();
    if (!status.ok() && !absl::IsCancelled(status)) {
      if (auto* toast = editor_manager_->toast_manager()) {
        toast->Show(absl::StrFormat("Save failed: %s", status.message()),
                    ToastType::kError);
      }
    }
    return;
  }
  SameLine();
  if (Button(tr("Cancel"), ImVec2(0, 0)) || IsKeyPressed(ImGuiKey_Escape)) {
    editor_manager_->CancelRomWriteConfirm();
    Hide(PopupID::kRomWriteConfirm);
  }
}
 
void PopupManager::DrawWriteConflictWarningPopup() {
  using namespace ImGui;
 
  if (!editor_manager_) {
    Text(tr("Editor manager unavailable."));
    if (Button(tr("Close"), ::yaze::gui::kDefaultModalSize)) {
      Hide(PopupID::kWriteConflictWarning);
    }
    return;
  }
 
  const auto& conflicts = editor_manager_->pending_write_conflicts();
 
  TextColored(gui::GetWarningColor(), tr("%s Write Conflict Warning"),
              ICON_MD_WARNING);
  Separator();
  TextWrapped(
      tr("The following ROM addresses are owned by ASM hooks and will be "
         "overwritten on next build. Saving now will write data that asar "
         "will replace."));
  Spacing();
 
  if (!conflicts.empty()) {
    if (BeginTable("WriteConflictTable", 3,
                   ImGuiTableFlags_RowBg | ImGuiTableFlags_Borders |
                       ImGuiTableFlags_Resizable)) {
      TableSetupColumn("Address", ImGuiTableColumnFlags_WidthFixed, 120.0f);
      TableSetupColumn("Ownership", ImGuiTableColumnFlags_WidthFixed, 140.0f);
      TableSetupColumn("Module", ImGuiTableColumnFlags_WidthStretch);
      TableHeadersRow();
 
      for (const auto& conflict : conflicts) {
        TableNextRow();
        TableNextColumn();
        Text("$%06X", conflict.address);
        TableNextColumn();
        TextUnformatted(
            core::AddressOwnershipToString(conflict.ownership).c_str());
        TableNextColumn();
        if (!conflict.module.empty()) {
          TextUnformatted(conflict.module.c_str());
        } else {
          TextDisabled(tr("(unknown)"));
        }
      }
      EndTable();
    }
  }
 
  Spacing();
  Text(tr("%zu conflict(s) detected."), conflicts.size());
  Spacing();
 
  if (Button(tr("Save Anyway"), ImVec2(0, 0))) {
    editor_manager_->BypassWriteConflictOnce();
    Hide(PopupID::kWriteConflictWarning);
    auto status = editor_manager_->ResumePendingRomSave();
    if (!status.ok() && !absl::IsCancelled(status)) {
      if (auto* toast = editor_manager_->toast_manager()) {
        toast->Show(absl::StrFormat("Save failed: %s", status.message()),
                    ToastType::kError);
      }
    }
    return;
  }
  SameLine();
  if (Button(tr("Cancel"), ImVec2(0, 0)) || IsKeyPressed(ImGuiKey_Escape)) {
    editor_manager_->ClearPendingWriteConflicts();
    Hide(PopupID::kWriteConflictWarning);
  }
}
 
void PopupManager::DrawUnsavedSessionChangesPopup() {
  using namespace ImGui;
 
  if (!editor_manager_) {
    Hide(PopupID::kUnsavedSessionChanges);
    return;
  }
 
  if (!editor_manager_->HasPendingUnsavedSessionAction()) {
    Hide(PopupID::kUnsavedSessionChanges);
    return;
  }
 
  Text(tr("%s Unsaved Session Changes"), ICON_MD_WARNING);
  Separator();
  TextWrapped("%s",
              editor_manager_->GetPendingUnsavedSessionActionPrompt().c_str());
  Spacing();
 
  // An empty save label means saving first is meaningless for this action
  // (for example Revert to Saved), so only Continue and Cancel are offered.
  const std::string save_label =
      editor_manager_->GetPendingUnsavedSessionActionSaveLabel();
  if (!save_label.empty()) {
    if (Button(save_label.c_str(), ::yaze::gui::kDefaultModalSize)) {
      editor_manager_->ConfirmPendingUnsavedSessionActionSaveAndContinue();
      return;
    }
    SameLine();
  }
  const std::string continue_label =
      editor_manager_->GetPendingUnsavedSessionActionContinueLabel();
  if (Button(continue_label.c_str(), ::yaze::gui::kDefaultModalSize)) {
    editor_manager_->ConfirmPendingUnsavedSessionActionDiscardAndContinue();
    return;
  }
 
  SameLine();
  if (Button(tr("Cancel"), ::yaze::gui::kDefaultModalSize) ||
      IsKeyPressed(ImGuiKey_Escape)) {
    editor_manager_->CancelPendingUnsavedSessionAction();
  }
}
 
}  // namespace editor
}  // namespace yaze