dungeon_editor_v2.cc

Go to the documentation of this file.

// Related header
#include "dungeon_editor_v2.h"
#include "util/i18n/tr.h"
 
// C system headers
#include <cctype>
#include <cstdio>
 
// C++ standard library headers
#include <algorithm>
#include <array>
#include <iterator>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
// Third-party library headers
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
#include "absl/types/span.h"
#include "imgui/imgui.h"
 
// Project headers
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_canvas_viewer.h"
#include "app/editor/dungeon/dungeon_room_store.h"
#include "app/editor/dungeon/inspectors/door_editor_content.h"
#include "app/editor/dungeon/inspectors/object_editor_content.h"
#include "app/editor/dungeon/inspectors/palette_editor_content.h"
#include "app/editor/dungeon/selectors/object_selector_content.h"
#include "app/editor/dungeon/ui/window/custom_collision_panel.h"
#include "app/editor/dungeon/ui/window/dungeon_entrance_list_panel.h"
#include "app/editor/dungeon/ui/window/dungeon_entrances_panel.h"
#include "app/editor/dungeon/ui/window/item_editor_panel.h"
#include "app/editor/dungeon/ui/window/minecart_track_editor_panel.h"
#include "app/editor/dungeon/ui/window/object_tile_editor_panel.h"
#include "app/editor/dungeon/ui/window/overlay_manager_panel.h"
#include "app/editor/dungeon/ui/window/room_tag_editor_panel.h"
#include "app/editor/dungeon/ui/window/sprite_editor_panel.h"
#include "app/editor/dungeon/ui/window/water_fill_panel.h"
#include "app/editor/dungeon/widgets/dungeon_status_bar.h"
#include "app/editor/dungeon/workspace/dungeon_workbench_content.h"
#include "app/editor/dungeon/workspace/room_browser_content.h"
#include "app/editor/dungeon/workspace/room_graphics_content.h"
#include "app/editor/dungeon/workspace/room_matrix_content.h"
#include "app/editor/editor_manager.h"
#include "app/editor/events/core_events.h"
#include "app/editor/graphics/graphics_editor.h"
#include "app/editor/menu/status_bar.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/system/session/hack_manifest_save_validation.h"
#include "app/editor/system/session/user_settings.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "app/emu/mesen/mesen_client_registry.h"
#include "app/emu/mesen/mesen_socket_client.h"
#include "app/emu/render/emulator_render_service.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/ui_config.h"
#include "core/features.h"
#include "core/project.h"
#include "rom/snes.h"
#include "util/log.h"
#include "util/macro.h"
#include "zelda3/dungeon/custom_object.h"
#include "zelda3/dungeon/draw_routines/draw_routine_registry.h"
#include "zelda3/dungeon/dungeon_editor_system.h"
#include "zelda3/dungeon/dungeon_rom_addresses.h"
#include "zelda3/dungeon/dungeon_validator.h"
#include "zelda3/dungeon/object_dimensions.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/water_fill_zone.h"
#include "zelda3/resource_labels.h"
 
namespace yaze::editor {
 
void DungeonEditorV2::SetDependencies(const EditorDependencies& deps) {
  Editor::SetDependencies(deps);
  if (minecart_track_editor_panel_) {
    const absl::Status status =
        minecart_track_editor_panel_->RebindProjectContext(deps.project);
    if (!status.ok()) {
      LOG_WARN("DungeonEditorV2", "Minecart project rebind failed: %s",
               status.message());
    }
    ConfigureMinecartProjectCallbacks();
  }
}
 
void DungeonEditorV2::ConfigureMinecartProjectCallbacks() {
  if (minecart_track_editor_panel_ == nullptr) {
    return;
  }
 
  auto* editor_manager = static_cast<EditorManager*>(dependencies_.custom_data);
  const size_t session_id = dependencies_.session_id;
  minecart_track_editor_panel_->SetCollisionBatchApplyCallback(
      [this, editor_manager, session_id](
          const std::vector<zelda3::TrackCollisionResult>& preview,
          const zelda3::GeneratorOptions& options) -> absl::Status {
        if (editor_manager != nullptr &&
            !editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Minecart collision apply requires its project context to be "
              "active");
        }
        return ApplyMinecartCollisionBatch(preview, options);
      });
  if (editor_manager == nullptr) {
    minecart_track_editor_panel_->SetProjectChangedCallback({});
    minecart_track_editor_panel_->SetProjectDraftChangedCallback({});
    minecart_track_editor_panel_->SetProjectSaveCallback({});
    return;
  }
 
  minecart_track_editor_panel_->SetProjectChangedCallback(
      [editor_manager, session_id](
          const project::DungeonOverlaySettings& overlay) -> absl::Status {
        if (!editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Minecart overlay edit requires its project context to be "
              "active");
        }
        editor_manager->GetCurrentProject()->dungeon_overlay = overlay;
        editor_manager->MarkCurrentProjectDirty();
        return absl::OkStatus();
      });
  minecart_track_editor_panel_->SetProjectDraftChangedCallback(
      [editor_manager, session_id]() -> absl::Status {
        if (!editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Minecart overlay draft requires its project context to be "
              "active");
        }
        editor_manager->MarkCurrentProjectDirty();
        return absl::OkStatus();
      });
  minecart_track_editor_panel_->SetProjectSaveCallback(
      [editor_manager, session_id]() -> absl::Status {
        if (!editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Minecart project save requires its project context to be "
              "active");
        }
        return editor_manager->SaveProject();
      });
}
 
absl::Status DungeonEditorV2::EnsureMinecartTrackEditorPanel() {
  if (minecart_track_editor_panel_ != nullptr) {
    return absl::OkStatus();
  }
  if (!core::FeatureFlags::get().kEnableCustomObjects) {
    return absl::FailedPreconditionError(
        "Enable Custom Dungeon Objects before opening Minecart Tracks");
  }
  if (dependencies_.window_manager != nullptr &&
      dependencies_.window_manager->GetActiveSessionId() !=
          dependencies_.session_id) {
    return absl::FailedPreconditionError(
        "Minecart Tracks can only be registered for the active project "
        "session");
  }
 
  auto minecart_panel = std::make_unique<MinecartTrackEditorPanel>();
  RETURN_IF_ERROR(minecart_panel->SetProject(dependencies_.project));
  minecart_panel->SetRooms(&rooms_);
  minecart_panel->SetRoomNavigationCallback(
      [this](int room_id) { OnRoomSelected(room_id); });
 
  minecart_track_editor_panel_ = minecart_panel.get();
  ConfigureMinecartProjectCallbacks();
  if (dependencies_.window_manager != nullptr) {
    dependencies_.window_manager->RegisterWindowContent(
        std::move(minecart_panel));
  } else {
    owned_minecart_track_editor_panel_ = std::move(minecart_panel);
  }
 
  room_viewers_.ForEach(
      [this](int, std::unique_ptr<DungeonCanvasViewer>& viewer) {
        if (viewer != nullptr) {
          viewer->SetMinecartTrackPanel(minecart_track_editor_panel_);
        }
      });
  if (workbench_viewer_ != nullptr) {
    workbench_viewer_->SetMinecartTrackPanel(minecart_track_editor_panel_);
  }
  if (workbench_compare_viewer_ != nullptr) {
    workbench_compare_viewer_->SetMinecartTrackPanel(
        minecart_track_editor_panel_);
  }
  if (workbench_panel_ != nullptr) {
    workbench_panel_->SetEmbeddedToolPanels(
        room_tag_editor_panel_, custom_collision_panel_, water_fill_panel_,
        minecart_track_editor_panel_);
  }
 
  return absl::OkStatus();
}
 
void DungeonEditorV2::SynchronizeCustomObjectAssets() {
  const bool custom_objects_enabled =
      core::FeatureFlags::get().kEnableCustomObjects;
  const bool custom_objects_state_changed =
      custom_objects_enabled != observed_custom_objects_enabled_;
  const uint64_t generation =
      zelda3::CustomObjectManager::Get().asset_generation();
  if (generation == observed_custom_object_generation_ &&
      !custom_objects_state_changed) {
    return;
  }
 
  if (custom_objects_state_changed) {
    zelda3::DrawRoutineRegistry::Get().RefreshFeatureFlagMappings();
  }
 
  rooms_.ForEachMaterialized(
      [](int, zelda3::Room& room) { room.MarkObjectsDirty(); });
  // Reload Assets also refreshes external sprite art in every session-owned
  // viewer, including hidden room windows and the comparison canvas.
  const auto invalidate_sprite_resources = [](DungeonCanvasViewer* viewer) {
    if (viewer != nullptr) {
      viewer->InvalidateExternalSpriteResources();
    }
  };
  room_viewers_.ForEach(
      [&](int, auto& viewer) { invalidate_sprite_resources(viewer.get()); });
  invalidate_sprite_resources(workbench_viewer_.get());
  invalidate_sprite_resources(workbench_compare_viewer_.get());
  if (object_selector_panel_ != nullptr) {
    object_selector_panel_->object_selector()
        .SynchronizeCustomObjectGeneration();
  }
  observed_custom_object_generation_ = generation;
  observed_custom_objects_enabled_ = custom_objects_enabled;
}
 
namespace {
 
bool IsTransientDungeonRoomWindowId(const std::string& card_id) {
  constexpr const char* kPrefix = "dungeon.room_";
  constexpr size_t kPrefixLength = 13;
  if (card_id.rfind(kPrefix, 0) != 0 || card_id.size() <= kPrefixLength) {
    return false;
  }
  return std::all_of(card_id.begin() + kPrefixLength, card_id.end(),
                     [](unsigned char ch) { return std::isdigit(ch) != 0; });
}
 
bool IsWorkbenchNavigationWindowId(const std::string& card_id) {
  constexpr std::array<const char*, 3> kWorkbenchNavigationPanelIds = {
      DungeonEditorV2::kRoomSelectorId,
      DungeonEditorV2::kEntranceListId,
      DungeonEditorV2::kRoomMatrixId,
  };
 
  return IsTransientDungeonRoomWindowId(card_id) ||
         std::any_of(kWorkbenchNavigationPanelIds.begin(),
                     kWorkbenchNavigationPanelIds.end(),
                     [&card_id](const char* navigation_id) {
                       return card_id == navigation_id;
                     });
}
 
}  // namespace
 
DungeonEditorV2::DungeonEditorV2(Rom* rom)
    : rom_(rom), room_loader_(rom), room_selector_(rom), rooms_(rom) {
  type_ = EditorType::kDungeon;
  if (rom) {
    dungeon_editor_system_ = zelda3::CreateDungeonEditorSystem(rom);
  }
}
 
DungeonEditorV2::~DungeonEditorV2() {
  if (palette_listener_id_ >= 0) {
    gfx::Arena::Get().UnregisterPaletteListener(palette_listener_id_);
    palette_listener_id_ = -1;
  }
 
  PrepareForSessionTeardown();
}
 
void DungeonEditorV2::PrepareForSessionTeardown() {
  // Clear runtime references in panels BEFORE editor-owned rooms and viewers are
  // destroyed. WorkspaceWindowManager panels may outlive this editor session.
  if (object_tile_editor_panel_) {
    object_tile_editor_panel_->Close();
    object_tile_editor_panel_->SetStandardWritePreflightCallback({});
    object_tile_editor_panel_->SetTilesAppliedCallback({});
    object_tile_editor_panel_ = nullptr;
  }
  if (object_selector_panel_) {
    object_selector_panel_->DetachRuntimeContext();
    object_selector_panel_ = nullptr;
  }
  if (object_editor_content_) {
    object_editor_content_->SetCanvasViewer(nullptr);
    object_editor_content_ = nullptr;
  }
  if (door_editor_panel_) {
    door_editor_panel_->SetCanvasViewer(nullptr);
    door_editor_panel_ = nullptr;
  }
  if (sprite_editor_panel_) {
    sprite_editor_panel_->SetCanvasViewer(nullptr);
    sprite_editor_panel_ = nullptr;
  }
  if (item_editor_panel_) {
    item_editor_panel_->SetCanvasViewer(nullptr);
    item_editor_panel_ = nullptr;
  }
  if (custom_collision_panel_) {
    custom_collision_panel_->SetCanvasViewer(nullptr);
    custom_collision_panel_->SetInteraction(nullptr);
    custom_collision_panel_ = nullptr;
  }
  if (water_fill_panel_) {
    water_fill_panel_->SetCanvasViewer(nullptr);
    water_fill_panel_->SetInteraction(nullptr);
    water_fill_panel_ = nullptr;
  }
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->DetachRuntimeContext();
    minecart_track_editor_panel_ = nullptr;
  }
}
 
absl::Status DungeonEditorV2::RefreshRomBackedState() {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  room_loader_.SetRom(rom_);
  room_loader_.SetGameData(game_data_);
 
  std::array<zelda3::RoomEntrance, zelda3::kNumDungeonEntranceSlots>
      refreshed_entrances;
  std::array<zelda3::DungeonSpawnPoint, zelda3::kNumDungeonSpawnPoints>
      refreshed_spawn_points;
  RETURN_IF_ERROR(room_loader_.LoadRoomEntrances(refreshed_entrances));
  RETURN_IF_ERROR(room_loader_.LoadDungeonSpawnPoints(refreshed_spawn_points));
 
  struct RefreshedRoom {
    int room_id;
    zelda3::Room room;
  };
  std::vector<std::pair<int, bool>> materialized_rooms;
  rooms_.ForEachMaterialized(
      [&materialized_rooms](int room_id, const zelda3::Room& room) {
        materialized_rooms.emplace_back(room_id, room.IsLoaded());
      });
 
  std::vector<RefreshedRoom> refreshed_rooms;
  refreshed_rooms.reserve(materialized_rooms.size());
  for (const auto& [room_id, was_loaded] : materialized_rooms) {
    zelda3::Room refreshed_room;
    if (was_loaded) {
      RETURN_IF_ERROR(room_loader_.LoadRoom(room_id, refreshed_room));
    } else {
      refreshed_room = zelda3::LoadRoomHeaderFromRom(rom_, room_id);
      refreshed_room.SetGameData(game_data_);
    }
    refreshed_rooms.push_back({room_id, std::move(refreshed_room)});
  }
 
  // All ROM reads succeeded. Clear every interaction that can retain indices
  // into Room vectors before replacing any Room contents.
  if (object_selector_panel_) {
    object_selector_panel_->CancelPlacement();
    object_selector_panel_->object_selector().InvalidatePreviewCache();
  }
  if (object_tile_editor_panel_) {
    object_tile_editor_panel_->Close();
  }
  auto prepare_viewer = [this](DungeonCanvasViewer* viewer, int room_id) {
    if (viewer) {
      viewer->RefreshRomBackedState(rom_, game_data_, &rooms_, room_id);
    }
  };
  room_viewers_.ForEach(
      [&prepare_viewer](int room_id,
                        std::unique_ptr<DungeonCanvasViewer>& viewer) {
        prepare_viewer(viewer.get(), room_id);
      });
  prepare_viewer(workbench_viewer_.get(), current_room_id_);
  const int compare_room_id =
      workbench_compare_viewer_ &&
              IsValidRoomId(workbench_compare_viewer_->current_room_id())
          ? workbench_compare_viewer_->current_room_id()
          : current_room_id_;
  prepare_viewer(workbench_compare_viewer_.get(), compare_room_id);
 
  if (dungeon_editor_system_) {
    dungeon_editor_system_->ClearHistory();
    if (auto object_editor = dungeon_editor_system_->GetObjectEditor()) {
      (void)object_editor->ClearSelection();
      object_editor->ClearHistory();
    }
  }
  undo_manager_.Clear();
  save_transaction_snapshot_.reset();
  pending_undo_ = {};
  has_pending_undo_ = false;
  pending_collision_undo_ = {};
  pending_water_fill_undo_ = {};
  pending_swap_ = {};
  pending_workflow_mode_ = {};
  pending_standalone_tool_window_ = {};
  undo_restore_triggered_ping_ = false;
 
  room_selector_.SetRom(rom_);
  rooms_.SetRom(rom_);
  rooms_.SetGameData(game_data_);
  for (auto& refreshed : refreshed_rooms) {
    auto* room = rooms_.GetIfMaterialized(refreshed.room_id);
    if (room) {
      *room = std::move(refreshed.room);
    }
  }
  entrances_ = std::move(refreshed_entrances);
  spawn_points_ = std::move(refreshed_spawn_points);
  ReloadWaterFillZones();
 
  room_selector_.set_rooms(&rooms_);
  room_selector_.set_entrances(&entrances_);
  room_selector_.set_spawn_points(&spawn_points_);
 
  if (dungeon_editor_system_) {
    dungeon_editor_system_->SetGameData(game_data_);
    auto* current_room = IsValidRoomId(current_room_id_)
                             ? rooms_.GetIfMaterialized(current_room_id_)
                             : nullptr;
    RETURN_IF_ERROR(dungeon_editor_system_->RefreshRomBackedState(
        current_room, current_room_id_));
  }
 
  current_palette_.clear();
  current_palette_group_ = gfx::PaletteGroup{};
  current_palette_id_ = 0;
  current_palette_group_id_ = 0;
  if (auto* current_room = rooms_.GetIfMaterialized(current_room_id_);
      current_room && game_data_ &&
      !game_data_->palette_groups.dungeon_main.empty()) {
    const int resolved_palette_id = current_room->ResolveDungeonPaletteId();
    current_palette_id_ =
        resolved_palette_id >= 0 &&
                resolved_palette_id <
                    static_cast<int>(
                        game_data_->palette_groups.dungeon_main.size())
            ? static_cast<uint64_t>(resolved_palette_id)
            : 0;
    current_palette_group_id_ = current_palette_id_;
    current_palette_ =
        game_data_->palette_groups.dungeon_main[current_palette_id_];
    current_palette_group_ = zelda3::BuildDungeonRenderPaletteGroupFromGameData(
        current_palette_, game_data_);
  }
 
  if (is_loaded_) {
    palette_editor_.Initialize(game_data_);
    palette_editor_.SetDungeonRenderPaletteMode(true);
    palette_editor_.SetCurrentPaletteId(current_palette_id_);
  }
 
  auto bind_viewer = [this](DungeonCanvasViewer* viewer, int room_id) {
    if (!viewer) {
      return;
    }
    viewer->SetRenderer(renderer_);
    viewer->SetCurrentPaletteId(current_palette_id_);
    viewer->SetCurrentPaletteGroup(current_palette_group_);
    viewer->SetEditorSystem(dungeon_editor_system_.get());
    viewer->SetMinecartTrackPanel(minecart_track_editor_panel_);
    viewer->SetProject(dependencies_.project);
    ConfigureViewerRenderContext(viewer, room_id);
    ApplyEntranceRenderContext(room_id);
  };
  room_viewers_.ForEach(
      [&bind_viewer](int room_id,
                     std::unique_ptr<DungeonCanvasViewer>& viewer) {
        bind_viewer(viewer.get(), room_id);
      });
  bind_viewer(workbench_viewer_.get(), current_room_id_);
  bind_viewer(workbench_compare_viewer_.get(), compare_room_id);
 
  if (object_selector_panel_) {
    object_selector_panel_->SetContext({rom_, game_data_});
    object_selector_panel_->SetRooms(&rooms_);
    object_selector_panel_->SetCurrentRoom(current_room_id_);
    object_selector_panel_->SetCurrentPaletteGroup(current_palette_group_);
  }
  if (room_graphics_panel_) {
    room_graphics_panel_->SetCurrentPaletteGroup(current_palette_group_);
  }
  if (object_tile_editor_panel_) {
    object_tile_editor_panel_->SetCurrentPaletteGroup(current_palette_group_);
  }
  if (room_tag_editor_panel_) {
    room_tag_editor_panel_->SetRooms(&rooms_);
  }
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->SetRooms(&rooms_);
  }
  if (workbench_panel_) {
    workbench_panel_->SetRom(rom_);
  }
 
  DungeonCanvasViewer* current_viewer = nullptr;
  if (IsWorkbenchWorkflowEnabled()) {
    current_viewer = workbench_viewer_.get();
  } else if (auto* viewer = room_viewers_.Get(current_room_id_)) {
    current_viewer = viewer->get();
  }
  if (current_viewer) {
    SyncPanelsToRoom(current_room_id_);
  }
 
  return absl::OkStatus();
}
 
void DungeonEditorV2::ReloadWaterFillZones() {
  rooms_.ForEachMaterialized([](int, zelda3::Room& room) {
    room.ClearWaterFillZone();
    room.ClearWaterFillDirty();
  });
 
  bool legacy_imported = false;
  const bool water_fill_save_enabled =
      core::FeatureFlags::get().dungeon.kSaveWaterFillZones;
  std::vector<zelda3::WaterFillZoneEntry> zones;
 
  auto zones_or = zelda3::LoadWaterFillTable(rom_);
  if (zones_or.ok()) {
    zones = std::move(zones_or.value());
  } else {
    LOG_WARN("DungeonEditorV2", "WaterFillTable parse failed: %s",
             zones_or.status().message().data());
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show(
          absl::StrFormat("WaterFill table parse failed: %s",
                          zones_or.status().message()),
          ToastType::kWarning);
    }
  }
 
  if (zones.empty()) {
    std::string sym_path;
    if (dependencies_.project &&
        !dependencies_.project->symbols_filename.empty()) {
      sym_path = dependencies_.project->GetAbsolutePath(
          dependencies_.project->symbols_filename);
    }
    auto legacy_or = zelda3::LoadLegacyWaterGateZones(rom_, sym_path);
    if (legacy_or.ok()) {
      zones = std::move(legacy_or.value());
      legacy_imported = !zones.empty();
    } else {
      LOG_WARN("DungeonEditorV2", "Legacy water gate import failed: %s",
               legacy_or.status().message().data());
    }
  }
 
  for (const auto& z : zones) {
    if (z.room_id < 0 || z.room_id >= static_cast<int>(rooms_.size())) {
      continue;
    }
    auto& room = rooms_[z.room_id];
    room.set_water_fill_sram_bit_mask(z.sram_bit_mask);
    for (uint16_t off : z.fill_offsets) {
      const int x = static_cast<int>(off % 64);
      const int y = static_cast<int>(off / 64);
      room.SetWaterFillTile(x, y, true);
    }
 
    // A passive legacy import is pending migration only when this project is
    // allowed to write the WaterFill table. Otherwise retain the overlay as
    // read-only reference data without creating unsavable room dirtiness.
    if (!legacy_imported || !water_fill_save_enabled) {
      room.ClearWaterFillDirty();
    }
  }
 
  if (legacy_imported && dependencies_.toast_manager) {
    dependencies_.toast_manager->Show(
        water_fill_save_enabled
            ? "Imported legacy water gate zones (save to write new table)"
            : "Loaded legacy water gate zones read-only (WaterFill saving is "
              "disabled)",
        ToastType::kInfo);
  }
}
 
void DungeonEditorV2::Initialize() {
  if (dependencies_.renderer) {
    renderer_ = dependencies_.renderer;
  }
  room_selector_.SetProject(dependencies_.project);
  const bool rom_changed = dependencies_.rom && dependencies_.rom != rom_;
  if (rom_changed) {
    SetRom(dependencies_.rom);
    // The system owns ROM-backed views; ensure it matches the current ROM.
    dungeon_editor_system_.reset();
  }
  if (rom_ && !dungeon_editor_system_) {
    dungeon_editor_system_ = zelda3::CreateDungeonEditorSystem(rom_);
    if (game_data_) {
      dungeon_editor_system_->SetGameData(game_data_);
    }
  }
 
  // Setup docking class for room windows
  room_window_class_.DockingAllowUnclassed = true;
  room_window_class_.DockingAlwaysTabBar = true;
 
  if (!dependencies_.window_manager)
    return;
  auto* window_manager = dependencies_.window_manager;
 
  // Legacy panel IDs persisted in older layouts/settings.
  window_manager->RegisterPanelAlias("dungeon.object_tools", kObjectSelectorId);
  window_manager->RegisterPanelAlias("dungeon.entrances",
                                     "dungeon.entrance_properties");
 
  // Register panels with WorkspaceWindowManager (no boolean flags - visibility is
  // managed entirely by WorkspaceWindowManager::ShowPanel/HidePanel/IsPanelVisible)
  // No default chord: Ctrl+Shift+W is reserved for Close Session. Toggle via
  // View / Window Browser / command palette instead.
  window_manager->RegisterPanel(
      {.card_id = "dungeon.workbench",
       .display_name = "Dungeon Workbench",
       .window_title = " Dungeon Workbench",
       .icon = ICON_MD_WORKSPACES,
       .category = "Dungeon",
       .workflow_group = "Core",
       .shortcut_hint = "",
       .visibility_flag = nullptr,
       .priority = 5,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to edit dungeon rooms"});
 
  window_manager->RegisterPanel(
      {.card_id = kRoomSelectorId,
       .display_name = "Room List",
       .window_title = " Room List",
       .icon = ICON_MD_LIST,
       .category = "Dungeon",
       .workflow_group = "Core",
       .shortcut_hint = "Ctrl+Shift+R",
       .visibility_flag = nullptr,
       .priority = 20,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to browse dungeon rooms"});
 
  window_manager->RegisterPanel(
      {.card_id = kEntranceListId,
       .display_name = "Entrance List",
       .window_title = " Entrance List",
       .icon = ICON_MD_DOOR_FRONT,
       .category = "Dungeon",
       .workflow_group = "Core",
       .shortcut_hint = "Ctrl+Shift+E",
       .visibility_flag = nullptr,
       .priority = 25,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to browse dungeon entrances"});
 
  window_manager->RegisterPanel(
      {.card_id = "dungeon.entrance_properties",
       .display_name = "Entrance Properties",
       .window_title = " Entrance Properties",
       .icon = ICON_MD_TUNE,
       .category = "Dungeon",
       .workflow_group = "Core",
       .shortcut_hint = "",
       .visibility_flag = nullptr,
       .priority = 26,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to edit entrance properties"});
 
  window_manager->RegisterPanel(
      {.card_id = kRoomMatrixId,
       .display_name = "Room Matrix",
       .window_title = " Room Matrix",
       .icon = ICON_MD_GRID_VIEW,
       .category = "Dungeon",
       .workflow_group = "Core",
       .shortcut_hint = "Ctrl+Shift+M",
       .visibility_flag = nullptr,
       .priority = 30,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to view the room matrix"});
 
  window_manager->RegisterPanel(
      {.card_id = kRoomGraphicsId,
       .display_name = "Room Graphics",
       .window_title = " Room Graphics",
       .icon = ICON_MD_IMAGE,
       .category = "Dungeon",
       .workflow_group = "Editors",
       .shortcut_hint = "Ctrl+Shift+G",
       .visibility_flag = nullptr,
       .priority = 50,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to view room graphics"});
 
  window_manager->RegisterPanel(
      {.card_id = kObjectSelectorId,
       .display_name = "Object Selector",
       .window_title = " Object Selector",
       .icon = ICON_MD_CATEGORY,
       .category = "Dungeon",
       .workflow_group = "Editors",
       .shortcut_hint = "",
       .visibility_flag = nullptr,
       .priority = 60,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to browse dungeon objects"});
 
  window_manager->RegisterPanel(
      {.card_id = kDoorEditorId,
       .display_name = "Door Editor",
       .window_title = " Door Editor",
       .icon = ICON_MD_DOOR_FRONT,
       .category = "Dungeon",
       .workflow_group = "Editors",
       .shortcut_hint = "",
       .visibility_flag = nullptr,
       .priority = 69,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to edit dungeon doors"});
 
  window_manager->RegisterPanel(
      {.card_id = kPaletteEditorId,
       .display_name = "Palette Editor",
       .window_title = " Palette Editor",
       .icon = ICON_MD_PALETTE,
       .category = "Dungeon",
       .workflow_group = "Editors",
       // Avoid conflicting with the global Command Palette (Ctrl/Cmd+Shift+P).
       .shortcut_hint = "Ctrl+Shift+Alt+P",
       .visibility_flag = nullptr,
       .priority = 70,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to edit dungeon palettes"});
 
  // Show default panels on startup.
  // Workbench mode intentionally suppresses parallel standalone defaults to
  // avoid two competing workflows being open at once.
  SetWorkbenchWorkflowMode(core::FeatureFlags::get().dungeon.kUseWorkbench,
                           /*show_toast=*/false);
 
  // Wire intent-aware callback for double-click / context menu
  room_selector_.SetRoomSelectedWithIntentCallback(
      [this](int room_id, RoomSelectionIntent intent) {
        OnRoomSelected(room_id, intent);
      });
 
  // Register WindowContent instances
  window_manager->RegisterWindowContent(std::make_unique<RoomBrowserContent>(
      &room_selector_, [this](int room_id) { OnRoomSelected(room_id); }));
 
  window_manager->RegisterWindowContent(
      std::make_unique<DungeonEntranceListPanel>(
          &room_selector_,
          [this](int entrance_id) { OnEntranceSelected(entrance_id); }));
 
  {
    auto matrix_panel = std::make_unique<RoomMatrixContent>(
        &current_room_id_, &active_rooms_,
        [this](int room_id) { OnRoomSelected(room_id); },
        [this](int old_room, int new_room) {
          SwapRoomInPanel(old_room, new_room);
        },
        &rooms_);
    matrix_panel->SetRoomIntentCallback(
        [this](int room_id, RoomSelectionIntent intent) {
          OnRoomSelected(room_id, intent);
        });
    window_manager->RegisterWindowContent(std::move(matrix_panel));
  }
 
  {
    auto workbench = std::make_unique<DungeonWorkbenchContent>(
        &room_selector_, &current_room_id_,
        [this](int room_id) { OnRoomSelected(room_id); },
        [this](int room_id, RoomSelectionIntent intent) {
          OnRoomSelected(room_id, intent);
        },
        [this](int room_id) {
          auto status = SaveRoom(room_id);
          if (!status.ok()) {
            LOG_ERROR("DungeonEditorV2", "Apply Room failed: %s",
                      status.message().data());
            if (dependencies_.toast_manager) {
              dependencies_.toast_manager->Show(
                  absl::StrFormat("Apply Room failed: %s", status.message()),
                  ToastType::kError);
            }
            return;
          }
          if (dependencies_.toast_manager) {
            dependencies_.toast_manager->Show("Applied room to ROM buffer",
                                              ToastType::kSuccess);
          }
        },
        [this]() { SaveAllRooms(); }, [this]() { return GetWorkbenchViewer(); },
        [this](int room_id) { return GetWorkbenchCompareViewer(room_id); },
        [this]() -> const std::deque<int>& { return recent_rooms_; },
        [this](int room_id) {
          recent_rooms_.erase(
              std::remove(recent_rooms_.begin(), recent_rooms_.end(), room_id),
              recent_rooms_.end());
        },
        [this](bool enabled) { QueueWorkbenchWorkflowMode(enabled); }, rom_);
    workbench_panel_ = workbench.get();
    workbench_panel_->SetPrimaryCanvasDrawnCallback(
        [this](DungeonCanvasViewer& viewer) {
          ConsumeRoomCanvasDeleteShortcut(viewer);
        });
    workbench_panel_->SetUndoRedoProvider(
        [this]() { return undo_manager_.CanUndo(); },
        [this]() { return undo_manager_.CanRedo(); },
        [this]() { Undo().IgnoreError(); }, [this]() { Redo().IgnoreError(); },
        [this]() { return undo_manager_.GetUndoDescription(); },
        [this]() { return undo_manager_.GetRedoDescription(); },
        [this]() { return static_cast<int>(undo_manager_.UndoStackSize()); });
    workbench_panel_->SetStandaloneToolCallbacks(
        [window_manager](const std::string& window_id) {
          const size_t session_id = window_manager->GetActiveSessionId();
          return window_manager->IsWindowOpen(session_id, window_id);
        },
        [this, window_manager](const std::string& window_id) {
          if (window_id.empty()) {
            return false;
          }
          pending_standalone_tool_window_.session_id =
              window_manager->GetActiveSessionId();
          pending_standalone_tool_window_.window_id = window_id;
          pending_standalone_tool_window_.pending = true;
          return true;
        });
    workbench_panel_->SetOpenKeyboardShortcutsCallback(
        [window_manager]() { window_manager->TriggerShowShortcuts(); });
    workbench_panel_->SetOnInspectorSideChanged([this](bool on_left) {
      if (dependencies_.user_settings) {
        dependencies_.user_settings->SetDungeonInspectorSide(on_left ? "left"
                                                                     : "right");
        dependencies_.user_settings->Save().IgnoreError();
      }
    });
    workbench_panel_->SetPitDamageTableProvider([this]() {
      return game_data_ ? &game_data_->pit_damage_table : nullptr;
    });
    window_manager->RegisterWindowContent(std::move(workbench));
  }
 
  window_manager->RegisterWindowContent(std::make_unique<DungeonEntrancesPanel>(
      &entrances_, &spawn_points_, &current_entrance_id_,
      [this](int entrance_id) { OnEntranceSelected(entrance_id); }));
 
  // Note: RoomGraphicsContent and PaletteEditorContent are registered
  // in Load() after their dependencies (renderer_, palette_editor_) are initialized
}
 
absl::Status DungeonEditorV2::Load() {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  // Initialize ObjectDimensionTable so DimensionService's fallback path works.
  // DimensionService::Get() queries this table internally but has no Load API.
  auto& dim_table = zelda3::ObjectDimensionTable::Get();
  if (!dim_table.IsLoaded()) {
    RETURN_IF_ERROR(dim_table.LoadFromRom(rom_));
  }
 
  RETURN_IF_ERROR(room_loader_.LoadRoomEntrances(entrances_));
  RETURN_IF_ERROR(room_loader_.LoadDungeonSpawnPoints(spawn_points_));
 
  if (!game_data()) {
    return absl::FailedPreconditionError("GameData not available");
  }
  auto dungeon_main_pal_group = game_data()->palette_groups.dungeon_main;
  current_palette_ = dungeon_main_pal_group[current_palette_group_id_];
  current_palette_group_ = zelda3::BuildDungeonRenderPaletteGroupFromGameData(
      current_palette_, game_data());
 
  room_selector_.set_rooms(&rooms_);
  room_selector_.set_entrances(&entrances_);
  room_selector_.set_spawn_points(&spawn_points_);
  room_selector_.set_active_rooms(active_rooms_);
  room_selector_.SetRoomSelectedCallback(
      [this](int room_id) { OnRoomSelected(room_id); });
  room_selector_.SetRoomSelectedWithIntentCallback(
      [this](int room_id, RoomSelectionIntent intent) {
        OnRoomSelected(room_id, intent);
      });
  room_selector_.SetEntranceSelectedCallback(
      [this](int entrance_id) { OnEntranceSelected(entrance_id); });
 
  // Canvas viewers are lazily created in GetViewerForRoom
 
  if (game_data()) {
    gfx::PaletteManager::Get().Initialize(game_data());
  } else {
    gfx::PaletteManager::Get().Initialize(rom_);
  }
 
  palette_editor_.Initialize(game_data());
  palette_editor_.SetDungeonRenderPaletteMode(true);
 
  // Register panels that depend on initialized state (renderer, palette_editor_)
  if (dependencies_.window_manager) {
    auto graphics_panel = std::make_unique<RoomGraphicsContent>(
        &current_room_id_, &rooms_, renderer_);
    room_graphics_panel_ = graphics_panel.get();
    dependencies_.window_manager->RegisterWindowContent(
        std::move(graphics_panel));
    auto palette_panel =
        std::make_unique<PaletteEditorContent>(&palette_editor_);
    palette_editor_panel_ = palette_panel.get();
    dependencies_.window_manager->RegisterWindowContent(
        std::move(palette_panel));
  }
 
  dungeon_editor_system_ = std::make_unique<zelda3::DungeonEditorSystem>(rom_);
  (void)dungeon_editor_system_->Initialize();
  dungeon_editor_system_->SetCurrentRoom(current_room_id_);
 
  // Initialize browse-only object selector and the dedicated object editor.
  auto object_selector = std::make_unique<ObjectSelectorContent>(
      rom_, nullptr, dungeon_editor_system_->GetObjectEditor(),
      dependencies_.toast_manager);
  auto object_editor = std::make_unique<ObjectEditorContent>(
      dungeon_editor_system_->GetObjectEditor());
 
  // Wire up object change callback to trigger room re-rendering
  dungeon_editor_system_->GetObjectEditor()->SetObjectChangedCallback(
      [this](size_t /*object_index*/, const zelda3::RoomObject& /*object*/) {
        if (current_room_id_ >= 0 && current_room_id_ < (int)rooms_.size()) {
          rooms_[current_room_id_].RenderRoomGraphics();
        }
      });
 
  // Set rooms and initial palette group for correct preview rendering
  object_selector->SetRooms(&rooms_);
  object_selector->SetCurrentPaletteGroup(current_palette_group_);
 
  auto open_workbench_selection_inspector = [this]() {
    if (workbench_panel_) {
      workbench_panel_->FocusSelectionInspector();
    }
    OpenWindow("dungeon.workbench");
  };
 
  object_selector->SetOpenObjectEditorCallback(
      open_workbench_selection_inspector);
 
  // Keep raw pointers for later access
  object_selector_panel_ = object_selector.get();
  object_editor_content_ = object_editor.get();
 
  auto jump_to_reciprocal_door = [this](int neighbor_room_id,
                                        size_t door_index) {
    if (neighbor_room_id < 0 ||
        neighbor_room_id >= static_cast<int>(rooms_.size())) {
      return;
    }
    OnRoomSelected(neighbor_room_id, true);
    if (auto* viewer = GetViewerForRoom(neighbor_room_id)) {
      viewer->object_interaction()
          .entity_coordinator()
          .door_handler()
          .SelectDoor(door_index);
    }
  };
  object_editor->SetJumpToReciprocalDoorCallback(jump_to_reciprocal_door);
  owned_object_editor_content_ = std::move(object_editor);
 
  auto door_editor = std::make_unique<DoorEditorContent>();
  door_editor->SetRooms(&rooms_);
  door_editor->SetOpenSelectionInspectorCallback(
      open_workbench_selection_inspector);
  door_editor->SetJumpToReciprocalDoorCallback(jump_to_reciprocal_door);
  door_editor_panel_ = door_editor.get();
 
  // Propagate game_data to the object editor panel if available
  if (game_data()) {
    object_selector_panel_->SetGameData(game_data());
  }
 
  // Room-scoped utility tools use the Workbench inspector by default, while the
  // same WindowContent instances remain available to users who prefer floating
  // windows. OpenTool keeps one presentation owner at a time so one content
  // instance is never drawn in both places during the same frame.
  auto custom_collision_panel =
      std::make_unique<CustomCollisionPanel>(nullptr, nullptr);
  custom_collision_panel_ = custom_collision_panel.get();
 
  auto water_fill_panel = std::make_unique<WaterFillPanel>(nullptr, nullptr);
  water_fill_panel_ = water_fill_panel.get();
 
  auto room_tag_panel = std::make_unique<RoomTagEditorPanel>();
  room_tag_panel->SetProject(dependencies_.project);
  room_tag_panel->SetRooms(&rooms_);
  room_tag_panel->SetCurrentRoomId(current_room_id_);
  room_tag_editor_panel_ = room_tag_panel.get();
 
  // Register the ObjectSelectorContent directly (it inherits from WindowContent)
  // Panel manager takes ownership
  if (dependencies_.window_manager) {
    dependencies_.window_manager->RegisterWindowContent(
        std::move(object_selector));
    dependencies_.window_manager->RegisterWindowContent(std::move(door_editor));
 
    // Register sprite and item editor panels with canvas viewer = nullptr
    // They will get the viewer reference in OnRoomSelected when a room is selected
    auto sprite_panel = std::make_unique<SpriteEditorPanel>(&current_room_id_,
                                                            &rooms_, nullptr);
    sprite_panel->SetOpenSelectionInspectorCallback(
        open_workbench_selection_inspector);
    sprite_editor_panel_ = sprite_panel.get();
    dependencies_.window_manager->RegisterWindowContent(
        std::move(sprite_panel));
 
    auto item_panel =
        std::make_unique<ItemEditorPanel>(&current_room_id_, &rooms_, nullptr);
    item_panel->SetOpenSelectionInspectorCallback(
        open_workbench_selection_inspector);
    item_editor_panel_ = item_panel.get();
    dependencies_.window_manager->RegisterWindowContent(std::move(item_panel));
 
    dependencies_.window_manager->RegisterWindowContent(
        std::move(custom_collision_panel));
    dependencies_.window_manager->RegisterWindowContent(
        std::move(water_fill_panel));
    dependencies_.window_manager->RegisterWindowContent(
        std::move(room_tag_panel));
    // Object Tile Editor Panel
    {
      auto tile_editor_panel =
          std::make_unique<ObjectTileEditorPanel>(renderer_, rom_);
      tile_editor_panel->SetCurrentPaletteGroup(current_palette_group_);
      tile_editor_panel->SetStandardWritePreflightCallback(
          [this](const std::vector<std::pair<uint32_t, uint32_t>>& ranges) {
            if (ranges.empty() || dependencies_.project == nullptr ||
                !dependencies_.project->hack_manifest.loaded()) {
              return absl::OkStatus();
            }
            return ValidateHackManifestSaveConflicts(
                dependencies_.project->hack_manifest,
                dependencies_.project->rom_metadata.write_policy, ranges,
                "dungeon object tile data", "ObjectTileEditorPanel",
                dependencies_.toast_manager);
          });
      tile_editor_panel->SetTilesAppliedCallback([this]() {
        if (object_selector_panel_) {
          object_selector_panel_->object_selector().InvalidatePreviewCache();
        }
      });
 
      object_tile_editor_panel_ = tile_editor_panel.get();
      dependencies_.window_manager->RegisterWindowContent(
          std::move(tile_editor_panel));
    }
 
    // Wire fixed-slot custom-object management actions to their workspace
    // windows.
    if (object_selector_panel_) {
      object_selector_panel_->object_selector().SetTileEditorPanel(
          object_tile_editor_panel_);
      object_selector_panel_->object_selector().SetOpenTileEditorWindowCallback(
          [this]() {
            return dependencies_.window_manager != nullptr &&
                   object_tile_editor_panel_ != nullptr &&
                   dependencies_.window_manager->OpenWindow(
                       object_tile_editor_panel_->GetId());
          });
      object_selector_panel_->object_selector()
          .SetOpenMinecartEditorWindowCallback([this]() {
            return dependencies_.window_manager != nullptr &&
                   minecart_track_editor_panel_ != nullptr &&
                   dependencies_.window_manager->OpenWindow(
                       minecart_track_editor_panel_->GetId());
          });
    }
 
    // Overlay Manager Panel
    {
      auto overlay_panel = std::make_unique<OverlayManagerPanel>();
      overlay_manager_panel_ = overlay_panel.get();
      dependencies_.window_manager->RegisterWindowContent(
          std::move(overlay_panel));
    }
 
  } else {
    owned_object_selector_panel_ = std::move(object_selector);
    owned_door_editor_panel_ = std::move(door_editor);
    owned_custom_collision_panel_ = std::move(custom_collision_panel);
    owned_water_fill_panel_ = std::move(water_fill_panel);
    owned_room_tag_editor_panel_ = std::move(room_tag_panel);
  }
 
  if (core::FeatureFlags::get().kEnableCustomObjects) {
    RETURN_IF_ERROR(EnsureMinecartTrackEditorPanel());
  }
 
  palette_editor_.SetOnDungeonPaletteChanged(
      [this](gui::DungeonPaletteChange change) {
        HandleDungeonPaletteChanged(change);
      });
  RegisterPaletteListener();
 
  // Oracle of Secrets: load editor-authored water fill zones (best-effort).
  ReloadWaterFillZones();
 
  if (workbench_panel_) {
    workbench_panel_->SetEmbeddedToolPanels(
        room_tag_editor_panel_, custom_collision_panel_, water_fill_panel_,
        minecart_track_editor_panel_);
    workbench_panel_->SetEmbeddedEditorPanels(
        object_selector_panel_, door_editor_panel_, sprite_editor_panel_,
        item_editor_panel_, room_graphics_panel_, palette_editor_panel_);
  }
 
  is_loaded_ = true;
  return absl::OkStatus();
}
 
void DungeonEditorV2::RegisterPaletteListener() {
  if (palette_listener_id_ >= 0) {
    return;
  }
 
  palette_listener_id_ = gfx::Arena::Get().RegisterPaletteListener(
      [this](const std::string& group_name, int palette_index) {
        HandleArenaPaletteChanged(group_name, palette_index);
      });
}
 
void DungeonEditorV2::HandleArenaPaletteChanged(const std::string& group_name,
                                                int palette_index) {
  if (!gfx::PaletteManager::Get().IsManaging(game_data_)) {
    return;
  }
 
  if (group_name == "hud") {
    HandleDungeonPaletteChanged({static_cast<int>(current_palette_id_),
                                 gui::DungeonRenderPaletteSource::kHud});
  } else if (group_name == "dungeon_main") {
    HandleDungeonPaletteChanged(
        {palette_index, gui::DungeonRenderPaletteSource::kDungeonMain});
  }
}
 
void DungeonEditorV2::HandleDungeonPaletteChanged(
    gui::DungeonPaletteChange change) {
  InvalidateDungeonPaletteUsers(change);
 
  std::array<bool, zelda3::kNumberOfRooms> rendered_rooms{};
  auto render_once = [this, &rendered_rooms](int room_id) {
    if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()) ||
        room_id >= static_cast<int>(rendered_rooms.size()) ||
        rendered_rooms[room_id]) {
      return;
    }
    rooms_[room_id].RenderRoomGraphics();
    rendered_rooms[room_id] = true;
  };
 
  for (int i = 0; i < active_rooms_.Size; i++) {
    render_once(active_rooms_[i]);
  }
 
  render_once(current_room_id_);
 
  auto apply_palette = [](DungeonCanvasViewer* viewer, uint64_t palette_id,
                          const gfx::PaletteGroup& palette_group,
                          bool force_shared_palette_refresh) {
    if (!viewer) {
      return;
    }
    viewer->SetCurrentPaletteId(palette_id);
    viewer->SetCurrentPaletteGroup(
        palette_group,
        /*force_refresh=*/force_shared_palette_refresh &&
            viewer->object_interaction().IsObjectLoaded());
  };
 
  if (current_room_id_ >= 0 &&
      current_room_id_ < static_cast<int>(rooms_.size()) && game_data()) {
    const bool force_shared_palette_refresh =
        change.source == gui::DungeonRenderPaletteSource::kHud;
    auto& dungeon_main_pal_group = game_data()->palette_groups.dungeon_main;
    if (current_palette_id_ <
        static_cast<uint64_t>(dungeon_main_pal_group.size())) {
      current_palette_group_id_ = current_palette_id_;
      current_palette_ = dungeon_main_pal_group[current_palette_id_];
      current_palette_group_ =
          zelda3::BuildDungeonRenderPaletteGroupFromGameData(current_palette_,
                                                             game_data());
      apply_palette(workbench_viewer_.get(), current_palette_id_,
                    current_palette_group_, force_shared_palette_refresh);
      apply_palette(workbench_compare_viewer_.get(), current_palette_id_,
                    current_palette_group_, force_shared_palette_refresh);
      room_viewers_.ForEach([this, change, &apply_palette,
                             &dungeon_main_pal_group, &render_once,
                             force_shared_palette_refresh](
                                int room_id,
                                std::unique_ptr<DungeonCanvasViewer>& viewer) {
        if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
          return;
        }
        const int palette_id = rooms_[room_id].ResolveDungeonPaletteId();
        if (palette_id < 0 ||
            palette_id >= static_cast<int>(dungeon_main_pal_group.size())) {
          return;
        }
        if (change.source == gui::DungeonRenderPaletteSource::kDungeonMain &&
            change.palette_id >= 0 && palette_id != change.palette_id) {
          return;
        }
        const auto room_palette_group =
            zelda3::BuildDungeonRenderPaletteGroupFromGameData(
                dungeon_main_pal_group.palette_ref(palette_id), game_data());
        if (viewer && viewer->object_interaction().IsObjectLoaded()) {
          render_once(room_id);
        }
        apply_palette(viewer.get(), palette_id, room_palette_group,
                      force_shared_palette_refresh);
      });
      if (object_selector_panel_) {
        object_selector_panel_->SetCurrentPaletteGroup(current_palette_group_);
      }
      if (room_graphics_panel_) {
        room_graphics_panel_->SetCurrentPaletteGroup(current_palette_group_);
      }
    }
  }
 
  // Tile edits remain bound to their original room even when the active room
  // changes or closes. Refresh that room's palette without reopening its session.
  if (!object_tile_editor_panel_ || !object_tile_editor_panel_->IsOpen() ||
      !game_data()) {
    return;
  }
  const int tile_room_id = object_tile_editor_panel_->current_room_id();
  const auto* tile_room = rooms_.GetIfLoaded(tile_room_id);
  if (!tile_room) {
    return;
  }
  const int tile_palette_id = tile_room->ResolveDungeonPaletteId();
  const auto& dungeon_palettes = game_data()->palette_groups.dungeon_main;
  if (tile_palette_id < 0 ||
      tile_palette_id >= static_cast<int>(dungeon_palettes.size()) ||
      (change.source == gui::DungeonRenderPaletteSource::kDungeonMain &&
       change.palette_id >= 0 && tile_palette_id != change.palette_id)) {
    return;
  }
  object_tile_editor_panel_->SetCurrentPaletteGroupForRoom(
      tile_room_id,
      zelda3::BuildDungeonRenderPaletteGroupFromGameData(
          dungeon_palettes.palette_ref(tile_palette_id), game_data()));
}
 
void DungeonEditorV2::InvalidateDungeonPaletteUsers(
    gui::DungeonPaletteChange change) {
  if (change.source == gui::DungeonRenderPaletteSource::kHud ||
      change.palette_id < 0) {
    rooms_.ForEachMaterialized(
        [](int, zelda3::Room& room) { room.MarkGraphicsDirty(); });
    return;
  }
 
  // Editing palette bytes does not change a room header, so the room's normal
  // property cache cannot detect this dependency change. Mark every cached
  // room that resolves to the edited concrete palette; inactive rooms will
  // redraw lazily the next time they are shown.
  rooms_.ForEachMaterialized([change](int, zelda3::Room& room) {
    if (room.ResolveDungeonPaletteId() == change.palette_id) {
      room.MarkGraphicsDirty();
    }
  });
}
 
absl::Status DungeonEditorV2::Update() {
  SynchronizeCustomObjectAssets();
  ProcessPendingWorkflowMode();
  ProcessPendingStandaloneToolWindow();
  ExpireStaleRoomCanvasDeleteShortcut();
 
  // Mirror the workbench inspector to the LEFT when user_settings says so.
  // Persisted across sessions via UserSettings::dungeon_inspector_side.
  if (workbench_panel_ && dependencies_.user_settings) {
    workbench_panel_->SetInspectorOnLeft(
        dependencies_.user_settings->GetDungeonInspectorSide() == "left");
  }
 
  const auto& theme = AgentUI::GetTheme();
  if (room_window_class_.ClassId == 0) {
    room_window_class_.ClassId = ImGui::GetID("DungeonRoomClass");
  }
 
  if (!is_loaded_) {
    gui::PanelWindow loading_card("Dungeon Editor Loading", ICON_MD_CASTLE);
    loading_card.SetDefaultSize(400, 200);
    if (loading_card.Begin()) {
      ImGui::TextColored(theme.text_secondary_gray,
                         tr("Loading dungeon data..."));
      ImGui::TextWrapped(
          tr("Independent editor cards will appear once ROM data is loaded."));
    }
    loading_card.End();
    return absl::OkStatus();
  }
 
  if (!IsWorkbenchWorkflowEnabled() || active_rooms_.Size > 0) {
    DrawRoomPanels();
  }
 
  // Keyboard Shortcuts (only if not typing in a text field)
  if (!ImGui::GetIO().WantTextInput) {
    // Room Cycling (Ctrl+Tab)
    if (ImGui::IsKeyPressed(ImGuiKey_Tab) && ImGui::GetIO().KeyCtrl) {
      if (IsWorkbenchWorkflowEnabled()) {
        if (recent_rooms_.size() > 1) {
          int current_idx = -1;
          for (int i = 0; i < static_cast<int>(recent_rooms_.size()); ++i) {
            if (recent_rooms_[i] == current_room_id_) {
              current_idx = i;
              break;
            }
          }
          if (current_idx != -1) {
            int next_idx;
            if (ImGui::GetIO().KeyShift) {
              next_idx =
                  (current_idx + 1) % static_cast<int>(recent_rooms_.size());
            } else {
              next_idx =
                  (current_idx - 1 + static_cast<int>(recent_rooms_.size())) %
                  static_cast<int>(recent_rooms_.size());
            }
            OnRoomSelected(recent_rooms_[next_idx]);
          }
        }
      } else if (active_rooms_.size() > 1) {
        int current_idx = -1;
        for (int i = 0; i < active_rooms_.size(); ++i) {
          if (active_rooms_[i] == current_room_id_) {
            current_idx = i;
            break;
          }
        }
 
        if (current_idx != -1) {
          int next_idx;
          if (ImGui::GetIO().KeyShift) {
            next_idx =
                (current_idx - 1 + active_rooms_.size()) % active_rooms_.size();
          } else {
            next_idx = (current_idx + 1) % active_rooms_.size();
          }
          OnRoomSelected(active_rooms_[next_idx]);
        }
      }
    }
 
    // Adjacent Room Navigation (Ctrl+Arrows)
    if (ImGui::GetIO().KeyCtrl) {
      int next_room = -1;
      const int kCols = 16;
 
      if (ImGui::IsKeyPressed(ImGuiKey_UpArrow)) {
        if (current_room_id_ >= kCols)
          next_room = current_room_id_ - kCols;
      } else if (ImGui::IsKeyPressed(ImGuiKey_DownArrow)) {
        if (IsValidRoomId(current_room_id_ + kCols))
          next_room = current_room_id_ + kCols;
      } else if (ImGui::IsKeyPressed(ImGuiKey_LeftArrow)) {
        if (current_room_id_ % kCols > 0)
          next_room = current_room_id_ - 1;
      } else if (ImGui::IsKeyPressed(ImGuiKey_RightArrow)) {
        if (current_room_id_ % kCols < kCols - 1 &&
            IsValidRoomId(current_room_id_ + 1))
          next_room = current_room_id_ + 1;
      }
 
      if (next_room != -1) {
        if (IsWorkbenchWorkflowEnabled()) {
          OnRoomSelected(next_room, /*request_focus=*/false);
        } else {
          SwapRoomInPanel(current_room_id_, next_room);
        }
      }
    }
  }
 
  // Process any pending room swaps after all drawing is complete
  // This prevents ImGui state corruption from modifying collections mid-frame
  ProcessPendingSwap();
 
  return absl::OkStatus();
}
 
void DungeonEditorV2::ContributeStatus(StatusBar* status_bar) {
  if (!status_bar)
    return;
  const int room_id = current_room_id();
 
  if (room_id >= 0) {
    StatusBarSegmentOptions room_opts;
    room_opts.tooltip = "Click to refocus viewer on this room";
    room_opts.on_click = [this, room_id]() {
      if (dependencies_.global_context) {
        dependencies_.global_context->GetEventBus().Publish(
            JumpToRoomRequestEvent::Create(room_id, dependencies_.session_id));
      }
    };
    status_bar->SetCustomSegment("Room", absl::StrFormat("0x%03X", room_id),
                                 std::move(room_opts));
  }
 
  const int loaded = LoadedRoomCount();
  const int total = TotalRoomCount();
  if (total > 0) {
    StatusBarSegmentOptions rooms_opts;
    rooms_opts.tooltip =
        absl::StrFormat("%d rooms loaded of %d total", loaded, total);
    status_bar->SetCustomSegment("Rooms",
                                 absl::StrFormat("%d/%d", loaded, total),
                                 std::move(rooms_opts));
  }
 
  if (room_id >= 0 && CurrentRoomHasPendingChanges()) {
    StatusBarSegmentOptions current_room_opts;
    current_room_opts.tooltip =
        "This room has pending editor changes that are not yet applied to the "
        "ROM buffer.";
    status_bar->SetCustomSegment("RoomState", "Pending",
                                 std::move(current_room_opts));
  }
 
  StatusBarSegmentOptions mode_opts;
  mode_opts.tooltip = "Click to toggle Workbench / Standalone workflow";
  mode_opts.on_click = [this]() {
    ToggleWorkbenchWorkflowMode(true);
  };
  status_bar->SetEditorMode(IsWorkbenchWorkflowEnabled()
                                ? workflow_mode_names::kWorkbench
                                : workflow_mode_names::kStandalone,
                            std::move(mode_opts));
}
 
int DungeonEditorV2::LoadedRoomCount() const {
  return rooms_.LoadedCount();
}
 
int DungeonEditorV2::PendingRoomCount() const {
  int count = 0;
  rooms_.ForEachMaterialized([&count](int, const zelda3::Room& room) {
    if (room.HasUnsavedChanges()) {
      ++count;
    }
  });
  return count;
}
 
bool DungeonEditorV2::HasPendingRoomChanges() const {
  return PendingRoomCount() > 0;
}
 
bool DungeonEditorV2::HasPendingDungeonChanges() const {
  if (minecart_track_editor_panel_ != nullptr &&
      minecart_track_editor_panel_->HasUnpublishedChanges()) {
    return true;
  }
  if (object_tile_editor_panel_ != nullptr &&
      object_tile_editor_panel_->HasUnappliedChanges()) {
    return true;
  }
  if (HasPendingRoomChanges()) {
    return true;
  }
  if (std::any_of(entrances_.begin(), entrances_.end(),
                  [](const zelda3::RoomEntrance& entrance) {
                    return entrance.dirty();
                  })) {
    return true;
  }
  if (std::any_of(spawn_points_.begin(), spawn_points_.end(),
                  [](const zelda3::DungeonSpawnPoint& spawn) {
                    return spawn.dirty();
                  })) {
    return true;
  }
  return game_data_ != nullptr && game_data_->pit_damage_table.dirty();
}
 
bool DungeonEditorV2::HasPendingProjectDraftChanges() const {
  return minecart_track_editor_panel_ != nullptr &&
         minecart_track_editor_panel_->HasPendingProjectDraftChanges();
}
 
absl::Status DungeonEditorV2::PrepareProjectSave() {
  return minecart_track_editor_panel_ != nullptr
             ? minecart_track_editor_panel_->PrepareProjectSave()
             : absl::OkStatus();
}
 
bool DungeonEditorV2::CurrentRoomHasPendingChanges() const {
  if (current_room_id_ < 0 ||
      current_room_id_ >= static_cast<int>(rooms_.size())) {
    return false;
  }
  if (const auto* room = rooms_.GetIfMaterialized(current_room_id_)) {
    return room->HasUnsavedChanges();
  }
  return false;
}
 
bool DungeonEditorV2::IsWorkbenchWorkflowEnabled() const {
  if (!core::FeatureFlags::get().dungeon.kUseWorkbench) {
    return false;
  }
  if (!dependencies_.window_manager) {
    return true;
  }
  return dependencies_.window_manager->IsWindowOpen("dungeon.workbench");
}
 
void DungeonEditorV2::SetWorkbenchWorkflowMode(bool enabled, bool show_toast) {
  auto* window_manager = dependencies_.window_manager;
  if (!window_manager) {
    return;
  }
 
  const size_t session_id = window_manager->GetActiveSessionId();
  const bool was_enabled = IsWorkbenchWorkflowEnabled();
 
  if (enabled) {
    window_manager->OpenWindow(session_id, "dungeon.workbench");
 
    if (!was_enabled) {
      workbench_suspended_navigation_window_ids_.clear();
 
      // The Workbench replaces room navigation, but not standalone editing
      // tools. Keep those tool windows open so user-owned HM/ZS-style layouts
      // survive workflow switches; the embedded inspector yields ownership to
      // any standalone tool that is already visible.
      for (const auto& descriptor :
           window_manager->GetWindowsInCategory(session_id, "Dungeon")) {
        const std::string& card_id = descriptor.card_id;
        if (!IsWorkbenchNavigationWindowId(card_id) ||
            !window_manager->IsWindowOpen(session_id, card_id) ||
            window_manager->IsWindowPinned(session_id, card_id)) {
          continue;
        }
        workbench_suspended_navigation_window_ids_.push_back(card_id);
        window_manager->CloseWindow(session_id, card_id);
      }
    }
  } else {
    window_manager->CloseWindow(session_id, "dungeon.workbench");
    window_manager->OpenWindow(session_id, kRoomSelectorId);
    window_manager->OpenWindow(session_id, kRoomMatrixId);
    if (current_room_id_ >= 0) {
      ShowRoomPanel(current_room_id_);
    }
    for (const std::string& card_id :
         workbench_suspended_navigation_window_ids_) {
      window_manager->OpenWindow(session_id, card_id);
    }
    workbench_suspended_navigation_window_ids_.clear();
  }
 
  if (show_toast && dependencies_.toast_manager && was_enabled != enabled) {
    dependencies_.toast_manager->Show(
        enabled ? "Dungeon workflow: Workbench"
                : "Dungeon workflow: Standalone Panels",
        ToastType::kInfo);
  }
}
 
void DungeonEditorV2::QueueWorkbenchWorkflowMode(bool enabled,
                                                 bool show_toast) {
  pending_workflow_mode_.enabled = enabled;
  pending_workflow_mode_.show_toast = show_toast;
  pending_workflow_mode_.pending = true;
}
 
void DungeonEditorV2::ToggleWorkbenchWorkflowMode(bool show_toast) {
  QueueWorkbenchWorkflowMode(!IsWorkbenchWorkflowEnabled(), show_toast);
}
 
void DungeonEditorV2::DrawRoomPanels() {
  for (int i = 0; i < active_rooms_.Size; i++) {
    int room_id = active_rooms_[i];
    std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
    bool panel_visible = true;
    if (dependencies_.window_manager) {
      panel_visible = dependencies_.window_manager->IsWindowOpen(card_id);
    }
 
    if (!panel_visible) {
      dependencies_.window_manager->UnregisterWindow(card_id);
      room_cards_.erase(room_id);
      active_rooms_.erase(active_rooms_.Data + i);
      ReleaseRoomPanelSlotId(room_id);
      // Clean up viewer
      room_viewers_.Erase(room_id);
      i--;
      continue;
    }
 
    bool is_pinned = dependencies_.window_manager &&
                     dependencies_.window_manager->IsWindowPinned(card_id);
    std::string active_category =
        dependencies_.window_manager
            ? dependencies_.window_manager->GetActiveCategory()
            : "";
 
    if (active_category != "Dungeon" && !is_pinned) {
      continue;
    }
 
    // Ensure room card exists (should have been created by ShowRoomPanel/ShowPanel)
    if (room_cards_.find(room_id) == room_cards_.end()) {
      ShowRoomPanel(room_id);
    }
 
    auto& room_card = room_cards_[room_id];
    bool open = true;
 
    ImGui::SetNextWindowClass(&room_window_class_);
    if (room_dock_id_ == 0) {
      room_dock_id_ = ImGui::GetID("DungeonRoomDock");
    }
    ImGui::SetNextWindowDockID(room_dock_id_, ImGuiCond_FirstUseEver);
 
    if (room_card->Begin(&open)) {
      if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) {
        OnRoomSelected(room_id, /*request_focus=*/false);
      }
      DrawRoomTab(room_id);
    }
    room_card->End();
 
    if (!open) {
      if (dependencies_.window_manager) {
        dependencies_.window_manager->UnregisterWindow(card_id);
      }
 
      room_cards_.erase(room_id);
      active_rooms_.erase(active_rooms_.Data + i);
      room_viewers_.Erase(room_id);
      ReleaseRoomPanelSlotId(room_id);
      i--;
    }
  }
}
 
int DungeonEditorV2::GetOrCreateRoomPanelSlotId(int room_id) {
  if (auto it = room_panel_slot_ids_.find(room_id);
      it != room_panel_slot_ids_.end()) {
    return it->second;
  }
  const int slot_id = next_room_panel_slot_id_++;
  room_panel_slot_ids_[room_id] = slot_id;
  return slot_id;
}
 
void DungeonEditorV2::ReleaseRoomPanelSlotId(int room_id) {
  room_panel_slot_ids_.erase(room_id);
}
 
void DungeonEditorV2::DrawRoomTab(int room_id) {
  const auto& theme = AgentUI::GetTheme();
  if (room_id < 0 || room_id >= 0x128) {
    ImGui::Text(tr("Invalid room ID: %d"), room_id);
    return;
  }
 
  auto& room = rooms_[room_id];
 
  if (!room.IsLoaded()) {
    auto status = room_loader_.LoadRoom(room_id, room);
    if (!status.ok()) {
      ImGui::TextColored(theme.text_error_red, tr("Failed to load room: %s"),
                         status.message().data());
      return;
    }
 
    if (dungeon_editor_system_) {
      auto sys_status = dungeon_editor_system_->ReloadRoom(room_id);
      if (!sys_status.ok()) {
        LOG_ERROR("DungeonEditorV2", "Failed to load system data: %s",
                  sys_status.message().data());
      }
    }
  }
 
  if (room.IsLoaded()) {
    bool needs_render = false;
 
    if (room.blocks().empty()) {
      ApplyEntranceRenderContext(room_id);
      room.LoadRoomGraphics();
      needs_render = true;
    }
 
    if (!room.AreObjectsLoaded()) {
      room.LoadObjects();
      needs_render = true;
    }
 
    auto& bg1_bitmap = room.bg1_buffer().bitmap();
    if (needs_render || !bg1_bitmap.is_active() || bg1_bitmap.width() == 0) {
      room.RenderRoomGraphics();
    }
  }
 
  if (room.IsLoaded()) {
    ImGui::TextColored(theme.text_success_green, ICON_MD_CHECK " Loaded");
  } else {
    ImGui::TextColored(theme.text_error_red, ICON_MD_PENDING " Not Loaded");
  }
  ImGui::SameLine();
  ImGui::TextDisabled(tr("Objects: %zu"), room.GetTileObjects().size());
 
  if (core::FeatureFlags::get().dungeon.kUseWorkbench &&
      !IsWorkbenchWorkflowEnabled()) {
    ImGui::SameLine();
    const std::string return_label = absl::StrFormat(
        ICON_MD_WORKSPACES " Workbench##return_workbench_%03X", room_id);
    if (ImGui::SmallButton(return_label.c_str())) {
      QueueWorkbenchWorkflowMode(true);
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Switch back to the integrated Dungeon Workbench workflow."));
    }
  }
 
  // Warp to Room button — sends room ID to running Mesen2 emulator
  ImGui::SameLine();
  {
    auto client = emu::mesen::MesenClientRegistry::GetClient();
    bool connected = client && client->IsConnected();
    if (!connected) {
      ImGui::BeginDisabled();
    }
    std::string warp_label =
        absl::StrFormat(ICON_MD_ROCKET_LAUNCH " Warp##warp_%03X", room_id);
    if (ImGui::SmallButton(warp_label.c_str())) {
      auto status = client->WriteWord(0x7E00A0, static_cast<uint16_t>(room_id));
      if (status.ok()) {
        if (dependencies_.toast_manager) {
          dependencies_.toast_manager->Show(
              absl::StrFormat("Warped to room 0x%03X", room_id),
              ToastType::kSuccess);
        }
      } else {
        if (dependencies_.toast_manager) {
          dependencies_.toast_manager->Show(
              absl::StrFormat("Warp failed: %s", status.message()),
              ToastType::kError);
        }
      }
    }
    if (!connected) {
      ImGui::EndDisabled();
      if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
        ImGui::SetTooltip(tr("Connect to Mesen2 first"));
      }
    } else {
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(tr("Warp to room 0x%03X in Mesen2"), room_id);
      }
    }
  }
 
  ImGui::Separator();
 
  // Use per-room viewer; reserve a bottom strip for the shared dungeon
  // status bar so this Windows-mode standalone window mirrors the Workbench
  // canvas pane's affordances.
  if (auto* viewer = GetViewerForRoom(room_id)) {
    const float status_bar_reserved =
        std::max(ImGui::GetFontSize() + ImGui::GetStyle().FramePadding.y * 2.0f,
                 gui::UIConfig::kStatusBarHeight) +
        ImGui::GetStyle().ItemSpacing.y;
    if (ImGui::BeginChild("##StandaloneRoomBody",
                          ImVec2(0.0f, -status_bar_reserved), false)) {
      viewer->DrawDungeonCanvas(room_id);
      ConsumeRoomCanvasDeleteShortcut(*viewer);
    }
    ImGui::EndChild();
 
    bool room_dirty = false;
    if (room_id >= 0 && room_id < static_cast<int>(rooms_.size())) {
      room_dirty = rooms_[room_id].HasUnsavedChanges();
    }
    const char* tool_mode =
        viewer->object_interaction().mode_manager().GetModeName();
    auto status = DungeonStatusBar::BuildState(*viewer, tool_mode, room_dirty);
    status.workflow_mode = workflow_mode_names::kStandalone;
    status.workflow_primary = false;
    status.can_undo = undo_manager_.CanUndo();
    status.can_redo = undo_manager_.CanRedo();
    status.undo_depth = static_cast<int>(undo_manager_.UndoStackSize());
    status.on_undo = [this]() {
      Undo().IgnoreError();
    };
    status.on_redo = [this]() {
      Redo().IgnoreError();
    };
    DungeonStatusBar::Draw(status);
  }
}
 
void DungeonEditorV2::QueueRoomCanvasDeleteShortcut() {
  if (ImGui::GetCurrentContext() == nullptr) {
    room_canvas_delete_shortcut_frame_.reset();
    return;
  }
  room_canvas_delete_shortcut_frame_ = ImGui::GetFrameCount();
}
 
void DungeonEditorV2::ExpireStaleRoomCanvasDeleteShortcut() {
  if (!room_canvas_delete_shortcut_frame_.has_value()) {
    return;
  }
  if (ImGui::GetCurrentContext() == nullptr ||
      *room_canvas_delete_shortcut_frame_ != ImGui::GetFrameCount()) {
    room_canvas_delete_shortcut_frame_.reset();
  }
}
 
bool DungeonEditorV2::ConsumeRoomCanvasDeleteShortcut(
    DungeonCanvasViewer& viewer) {
  ExpireStaleRoomCanvasDeleteShortcut();
  if (!room_canvas_delete_shortcut_frame_.has_value() ||
      ImGui::GetIO().WantTextInput || ImGui::IsAnyItemActive() ||
      !viewer.CanHandleRoomCanvasShortcut()) {
    return false;
  }
 
  room_canvas_delete_shortcut_frame_.reset();
  viewer.DeleteSelectedObjects();
  return true;
}
 
void DungeonEditorV2::OnRoomSelected(int room_id, RoomSelectionIntent intent) {
  switch (intent) {
    case RoomSelectionIntent::kFocusInWorkbench:
      OnRoomSelected(room_id, /*request_focus=*/true);
      break;
    case RoomSelectionIntent::kOpenStandalone: {
      // Explicitly pivot to panel workflow when user asks for standalone room.
      if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
        return;
      }
      if (IsWorkbenchWorkflowEnabled()) {
        SetWorkbenchWorkflowMode(false);
      }
      // Update shared state (same as OnRoomSelected with request_focus=true)
      OnRoomSelected(room_id, /*request_focus=*/false);
      // Now force-open a standalone panel for this room
      ShowRoomPanel(room_id);
      break;
    }
    case RoomSelectionIntent::kPreview:
      OnRoomSelected(room_id, /*request_focus=*/false);
      break;
  }
}
 
void DungeonEditorV2::OnRoomSelected(int room_id, bool request_focus) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    LOG_WARN("DungeonEditorV2", "Ignoring invalid room selection: %d", room_id);
    return;
  }
  if (room_id != current_room_id_ && workbench_panel_) {
    workbench_panel_->NotifyRoomChanged(current_room_id_);
  }
  current_room_id_ = room_id;
  room_selector_.set_current_room_id(static_cast<uint16_t>(room_id));
 
  // Track recent rooms (remove if already present, add to front)
  recent_rooms_.erase(
      std::remove(recent_rooms_.begin(), recent_rooms_.end(), room_id),
      recent_rooms_.end());
  recent_rooms_.push_front(room_id);
  if (recent_rooms_.size() > kMaxRecentRooms) {
    recent_rooms_.pop_back();
  }
 
  if (dungeon_editor_system_) {
    dungeon_editor_system_->SetExternalRoom(&rooms_[room_id]);
  }
 
  // Update all sub-panels (Object Editor, Sprite Editor, etc.)
  SyncPanelsToRoom(room_id);
 
  // Sync palette with current room (must happen before early return for focus changes)
 
  // Sync palette with current room (must happen before early return for focus changes)
  if (room_id >= 0 && room_id < (int)rooms_.size()) {
    auto& room = rooms_[room_id];
    if (!room.IsLoaded()) {
      room_loader_.LoadRoom(room_id, room);
    }
 
    if (room.IsLoaded()) {
      ApplyEntranceRenderContext(room_id);
      current_palette_id_ = room.ResolveDungeonPaletteId();
      current_palette_group_id_ = current_palette_id_;
      palette_editor_.SetCurrentPaletteId(current_palette_id_);
 
      // Update viewer and object editor palette
      if (auto* viewer = GetViewerForRoom(room_id)) {
        ConfigureViewerRenderContext(viewer, room_id);
        viewer->SetCurrentPaletteId(current_palette_id_);
 
        if (game_data()) {
          auto dungeon_main_pal_group =
              game_data()->palette_groups.dungeon_main;
          if (current_palette_id_ < (int)dungeon_main_pal_group.size()) {
            current_palette_ = dungeon_main_pal_group[current_palette_id_];
            current_palette_group_ =
                zelda3::BuildDungeonRenderPaletteGroupFromGameData(
                    current_palette_, game_data());
            viewer->SetCurrentPaletteGroup(current_palette_group_);
            if (object_selector_panel_) {
              object_selector_panel_->SetCurrentPaletteGroup(
                  current_palette_group_);
            }
            // Sync palette to graphics panel for proper sheet coloring
            if (room_graphics_panel_) {
              room_graphics_panel_->SetCurrentPaletteGroup(
                  current_palette_group_);
            }
            if (object_tile_editor_panel_) {
              object_tile_editor_panel_->SetCurrentPaletteGroupForRoom(
                  room_id, current_palette_group_);
            }
          }
        }
      }
    }
  }
 
  // Workbench mode uses a single stable window and does not spawn per-room
  // panels. Keep selection + panels in sync and return.
  if (IsWorkbenchWorkflowEnabled()) {
    if (dependencies_.window_manager && request_focus) {
      // Only force-show if it's already visible or if it's the first initialization
      // This avoids obtrusive behavior when the user explicitly closed it.
      if (dependencies_.window_manager->IsWindowOpen("dungeon.workbench")) {
        dependencies_.window_manager->OpenWindow("dungeon.workbench");
      }
    }
    return;
  }
 
  // Check if room is already open
  for (int i = 0; i < active_rooms_.Size; i++) {
    if (active_rooms_[i] == room_id) {
      // Always ensure panel is visible, even if already in active_rooms_
      if (dependencies_.window_manager) {
        std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
        dependencies_.window_manager->OpenWindow(card_id);
      }
      if (request_focus) {
        FocusRoom(room_id);
      }
      return;
    }
  }
 
  active_rooms_.push_back(room_id);
  room_selector_.set_active_rooms(active_rooms_);
 
  if (dependencies_.window_manager) {
    // Use unified ResourceLabelProvider for room names
    std::string room_name = absl::StrFormat(
        "[%03X] %s", room_id, zelda3::GetRoomLabel(room_id).c_str());
 
    std::string base_card_id = absl::StrFormat("dungeon.room_%d", room_id);
 
    dependencies_.window_manager->RegisterWindow(
        {.card_id = base_card_id,
         .display_name = room_name,
         .window_title = ICON_MD_GRID_ON " " + room_name,
         .icon = ICON_MD_GRID_ON,
         .category = "Dungeon",
         .workflow_group = "Rooms",
         .shortcut_hint = "",
         .visibility_flag = nullptr,
         .priority = 200 + room_id});
 
    dependencies_.window_manager->OpenWindow(base_card_id);
  }
}
 
void DungeonEditorV2::OnEntranceSelected(int entrance_id) {
  if (entrance_id < 0 || entrance_id >= static_cast<int>(entrances_.size())) {
    return;
  }
  current_entrance_id_ = entrance_id;
  room_selector_.set_current_entrance_id(entrance_id);
 
  const int room_id = ResolveEntranceRoomId(entrance_id);
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return;
  }
  OnRoomSelected(room_id);
}
 
int DungeonEditorV2::ResolveEntranceRoomId(int entrance_id) const {
  if (entrance_id < 0 || entrance_id >= static_cast<int>(entrances_.size())) {
    return -1;
  }
  if (entrance_id < zelda3::kNumDungeonSpawnPoints) {
    const auto& spawn = spawn_points_[entrance_id];
    return spawn.spawn_id() == entrance_id ? spawn.room_id : -1;
  }
  return entrances_[entrance_id].room_;
}
 
uint8_t DungeonEditorV2::ResolveSelectedEntranceBlocksetForRoom(
    int room_id) const {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return 0xFF;
  }
  if (current_entrance_id_ < 0 ||
      current_entrance_id_ >= static_cast<int>(entrances_.size())) {
    return 0xFF;
  }
  if (current_entrance_id_ < zelda3::kNumDungeonSpawnPoints) {
    const auto& spawn = spawn_points_[current_entrance_id_];
    if (spawn.spawn_id() != current_entrance_id_ || spawn.room_id != room_id) {
      return 0xFF;
    }
    return spawn.main_gfx;
  }
 
  const auto& entrance = entrances_[current_entrance_id_];
  if (entrance.room_ != room_id) {
    return 0xFF;
  }
  return entrance.blockset_;
}
 
void DungeonEditorV2::ApplyEntranceRenderContext(int room_id) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return;
  }
  auto& room = rooms_[room_id];
  if (!room.IsLoaded()) {
    return;
  }
  room.SetRenderEntranceBlockset(
      ResolveSelectedEntranceBlocksetForRoom(room_id));
}
 
void DungeonEditorV2::ConfigureViewerRenderContext(DungeonCanvasViewer* viewer,
                                                   int room_id) {
  if (viewer == nullptr) {
    return;
  }
  const uint8_t entrance_blockset =
      ResolveSelectedEntranceBlocksetForRoom(room_id);
  if (entrance_blockset == 0xFF) {
    viewer->ClearEntranceRenderContext();
  } else {
    viewer->SetEntranceRenderContext(current_entrance_id_, entrance_blockset);
  }
}
 
void DungeonEditorV2::add_room(int room_id) {
  OnRoomSelected(room_id);
}
 
void DungeonEditorV2::FocusRoom(int room_id) {
  auto it = room_cards_.find(room_id);
  if (it != room_cards_.end()) {
    it->second->Focus();
  }
}
 
void DungeonEditorV2::SelectObject(int obj_id) {
  if (object_selector_panel_) {
    object_selector_panel_->SelectObject(obj_id);
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenObjectSelectorTool();
      OpenWindow("dungeon.workbench");
    } else {
      OpenWindow(kObjectSelectorId);
    }
  }
}
 
void DungeonEditorV2::SetAgentMode(bool enabled) {
  if (enabled && dependencies_.window_manager) {
    if (IsWorkbenchWorkflowEnabled()) {
      OpenWindow("dungeon.workbench");
      if (workbench_panel_) {
        workbench_panel_->OpenObjectSelectorTool();
      }
    } else {
      OpenWindow(kRoomSelectorId);
      OpenWindow(kObjectSelectorId);
      OpenWindow(kRoomGraphicsId);
    }
    if (object_selector_panel_) {
      object_selector_panel_->SetAgentOptimizedLayout(true);
    }
  }
}
 
void DungeonEditorV2::ProcessDeferredTextures() {
  gfx::Arena::Get().ProcessTextureQueue(renderer_);
}
 
void DungeonEditorV2::HandleObjectPlaced(const zelda3::RoomObject& obj) {
  if (!IsValidRoomId(current_room_id_)) {
    LOG_ERROR("DungeonEditorV2", "Cannot place object: Invalid room ID %d",
              current_room_id_);
    const std::string message = absl::StrFormat(
        "Cannot place 0x%02X: invalid room %d", obj.id_, current_room_id_);
    if (object_selector_panel_) {
      object_selector_panel_->SetPlacementError(message);
    } else if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show(message, ToastType::kError);
    }
    return;
  }
 
  auto& room = rooms_[current_room_id_];
 
  LOG_INFO("DungeonEditorV2",
           "Placing object ID=0x%02X at position (%d,%d) in room %03X", obj.id_,
           obj.x_, obj.y_, current_room_id_);
 
  room.RenderRoomGraphics();
  LOG_DEBUG("DungeonEditorV2",
            "Object placed and room re-rendered successfully");
  // Brief success feedback so the user knows the placement was accepted.
  // Kept minimal (no inline panel update) — success is non-spammy by design.
  if (dependencies_.toast_manager) {
    dependencies_.toast_manager->Show(
        absl::StrFormat("Placed 0x%02X in room %03X", obj.id_,
                        current_room_id_),
        ToastType::kSuccess);
  }
}
 
void DungeonEditorV2::OpenGraphicsEditorForObject(
    int room_id, const zelda3::RoomObject& object) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    LOG_WARN("DungeonEditorV2", "Edit Graphics ignored (invalid room id %d)",
             room_id);
    return;
  }
 
  auto* editor_manager = static_cast<EditorManager*>(dependencies_.custom_data);
  if (!editor_manager) {
    LOG_WARN("DungeonEditorV2",
             "Edit Graphics ignored (editor manager unavailable)");
    return;
  }
 
  auto& room = rooms_[room_id];
  ApplyEntranceRenderContext(room_id);
  room.LoadRoomGraphics();
 
  uint16_t sheet_id = 0;
  uint16_t tile_index = 0;
  bool resolved_sheet = false;
  if (auto tiles_or = object.GetTiles();
      tiles_or.ok() && !tiles_or.value().empty()) {
    const uint16_t tile_id = tiles_or.value().front().id_;
    const size_t block_index = static_cast<size_t>(tile_id / 64);
    const auto blocks = room.blocks();
    if (block_index < blocks.size()) {
      sheet_id = blocks[block_index];
      resolved_sheet = true;
    }
    const int tiles_per_row = gfx::kTilesheetWidth / 8;
    const int tiles_per_col = gfx::kTilesheetHeight / 8;
    const int tiles_per_sheet = tiles_per_row * tiles_per_col;
    if (tiles_per_sheet > 0) {
      tile_index = static_cast<uint16_t>(tile_id % tiles_per_sheet);
    }
  }
 
  editor_manager->SwitchToEditor(EditorType::kGraphics, true);
  if (auto* editor_set = editor_manager->GetCurrentEditorSet()) {
    if (auto* graphics = editor_set->GetGraphicsEditor()) {
      if (resolved_sheet) {
        graphics->SelectSheet(sheet_id);
        graphics->HighlightTile(sheet_id, tile_index,
                                absl::StrFormat("Object 0x%02X", object.id_));
      }
    }
  }
 
  if (dependencies_.window_manager) {
    dependencies_.window_manager->ShowAllWindowsInCategory("Graphics");
  }
}
 
absl::Status DungeonEditorV2::OpenObjectTileEditorForObject(
    int room_id, const zelda3::RoomObject& object) {
  if (object_tile_editor_panel_ == nullptr) {
    return absl::FailedPreconditionError(
        "Object Tile Editor panel is unavailable");
  }
  if (dependencies_.window_manager == nullptr) {
    return absl::FailedPreconditionError(
        "Workspace window manager is unavailable");
  }
  if (rom_ == nullptr || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return absl::OutOfRangeError("Dungeon room id is outside the room store");
  }
  if (!zelda3::ObjectTileEditor::IsEditableStandardObject(object.id_)) {
    return absl::UnimplementedError(
        "Object tile editing is supported only for audited objects 0x11F and "
        "0x120");
  }
  if (game_data_ == nullptr ||
      game_data_->palette_groups.dungeon_main.empty()) {
    return absl::FailedPreconditionError("Dungeon palette data is unavailable");
  }
 
  auto& room = rooms_[room_id];
  if (!room.IsLoaded()) {
    RETURN_IF_ERROR(room_loader_.LoadRoom(room_id, room));
  }
  ApplyEntranceRenderContext(room_id);
  room.PrepareForRender();
 
  const int palette_id = room.ResolveDungeonPaletteId();
  const auto& dungeon_palettes = game_data_->palette_groups.dungeon_main;
  if (palette_id < 0 ||
      palette_id >= static_cast<int>(dungeon_palettes.size())) {
    return absl::OutOfRangeError(
        "Room resolves to an unavailable dungeon palette");
  }
  auto room_palette = dungeon_palettes[palette_id];
  const auto palette_group = zelda3::BuildDungeonRenderPaletteGroupFromGameData(
      room_palette, game_data_);
 
  const absl::Status open_status = object_tile_editor_panel_->OpenForObject(
      object.id_, room_id, &rooms_, palette_group);
  if (!open_status.ok()) {
    // A modified hidden session rejects replacement to prevent data loss.
    // Surface that existing session so the user can apply, revert, or use the
    // explicit discard action described by the returned status.
    if (object_tile_editor_panel_->IsOpen()) {
      (void)dependencies_.window_manager->OpenWindow(
          object_tile_editor_panel_->GetId());
    }
    return open_status;
  }
  if (!dependencies_.window_manager->OpenWindow(
          object_tile_editor_panel_->GetId())) {
    object_tile_editor_panel_->Close();
    return absl::NotFoundError(
        "Object Tile Editor window is not registered in this session");
  }
  return absl::OkStatus();
}
 
void DungeonEditorV2::SwapRoomInPanel(int old_room_id, int new_room_id) {
  // Defer the swap until after the current frame's draw phase completes
  // This prevents modifying data structures while ImGui is still using them
  if (new_room_id < 0 || new_room_id >= static_cast<int>(rooms_.size())) {
    return;
  }
  pending_swap_.old_room_id = old_room_id;
  pending_swap_.new_room_id = new_room_id;
  pending_swap_.pending = true;
}
 
void DungeonEditorV2::ProcessPendingSwap() {
  if (!pending_swap_.pending) {
    return;
  }
 
  int old_room_id = pending_swap_.old_room_id;
  int new_room_id = pending_swap_.new_room_id;
  pending_swap_.pending = false;
 
  // Find the position of old_room in active_rooms_
  int swap_index = -1;
  for (int i = 0; i < active_rooms_.Size; i++) {
    if (active_rooms_[i] == old_room_id) {
      swap_index = i;
      break;
    }
  }
 
  if (swap_index < 0) {
    // Old room not found in active rooms, just select the new one
    OnRoomSelected(new_room_id);
    return;
  }
 
  // Avoid swapping into an already-open room panel (the per-room maps assume
  // room IDs are unique). In this case, just focus/select the existing room.
  for (int i = 0; i < active_rooms_.Size; i++) {
    if (i != swap_index && active_rooms_[i] == new_room_id) {
      OnRoomSelected(new_room_id);
      return;
    }
  }
 
  // Preserve the old panel's stable ImGui window identity by transferring its
  // slot id to the new room id.
  int slot_id = -1;
  if (auto it = room_panel_slot_ids_.find(old_room_id);
      it != room_panel_slot_ids_.end()) {
    slot_id = it->second;
    room_panel_slot_ids_.erase(it);
  } else {
    slot_id = next_room_panel_slot_id_++;
  }
  room_panel_slot_ids_[new_room_id] = slot_id;
 
  // Preserve the viewer instance so canvas pan/zoom and UI state don't reset
  // when navigating with arrows (swap-in-panel).
  room_viewers_.Rename(old_room_id, new_room_id);
 
  // Replace old room with new room in active_rooms_
  active_rooms_[swap_index] = new_room_id;
  room_selector_.set_active_rooms(active_rooms_);
 
  // Unregister old panel
  if (dependencies_.window_manager) {
    std::string old_card_id = absl::StrFormat("dungeon.room_%d", old_room_id);
    const bool old_pinned =
        dependencies_.window_manager->IsWindowPinned(old_card_id);
    dependencies_.window_manager->UnregisterWindow(old_card_id);
 
    // Register new panel
    // Use unified ResourceLabelProvider for room names
    std::string new_room_name = absl::StrFormat(
        "[%03X] %s", new_room_id, zelda3::GetRoomLabel(new_room_id).c_str());
 
    std::string new_card_id = absl::StrFormat("dungeon.room_%d", new_room_id);
 
    dependencies_.window_manager->RegisterWindow(
        {.card_id = new_card_id,
         .display_name = new_room_name,
         .window_title = ICON_MD_GRID_ON " " + new_room_name,
         .icon = ICON_MD_GRID_ON,
         .category = "Dungeon",
         .workflow_group = "Rooms",
         .shortcut_hint = "",
         .visibility_flag = nullptr,
         .priority = 200 + new_room_id});
 
    if (old_pinned) {
      dependencies_.window_manager->SetWindowPinned(new_card_id, true);
    }
    dependencies_.window_manager->OpenWindow(new_card_id);
  }
 
  // Clean up old room's card and viewer
  room_cards_.erase(old_room_id);
 
  // Update current selection
  OnRoomSelected(new_room_id, /*request_focus=*/false);
}
 
void DungeonEditorV2::ProcessPendingWorkflowMode() {
  if (!pending_workflow_mode_.pending) {
    return;
  }
 
  const bool enabled = pending_workflow_mode_.enabled;
  const bool show_toast = pending_workflow_mode_.show_toast;
  pending_workflow_mode_.pending = false;
  SetWorkbenchWorkflowMode(enabled, show_toast);
}
 
void DungeonEditorV2::ProcessPendingStandaloneToolWindow() {
  if (!pending_standalone_tool_window_.pending) {
    return;
  }
 
  PendingStandaloneToolWindow request =
      std::move(pending_standalone_tool_window_);
  pending_standalone_tool_window_ = {};
 
  auto* window_manager = dependencies_.window_manager;
  if (!window_manager) {
    return;
  }
 
  if (!window_manager->OpenWindow(request.session_id, request.window_id)) {
    return;
  }
 
  if (ImGui::GetCurrentContext() != nullptr) {
    const std::string window_name = window_manager->GetWorkspaceWindowName(
        request.session_id, request.window_id);
    if (!window_name.empty()) {
      ImGui::SetWindowFocus(window_name.c_str());
    }
  }
}
 
void DungeonEditorV2::TouchViewerLru(int room_id) {
  room_viewers_.Touch(room_id);
}
 
void DungeonEditorV2::RemoveViewerFromLru(int room_id) {
  // No-op: LruCache handles removal internally via Erase()
  (void)room_id;
}
 
void DungeonEditorV2::WireViewerPanelCallbacks(DungeonCanvasViewer* viewer) {
  if (!viewer) {
    return;
  }
 
  viewer->SetShowObjectPanelCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenObjectSelectorTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow(kObjectSelectorId);
  });
  viewer->SetShowSpritePanelCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenSpriteTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow("dungeon.sprite_editor");
  });
  viewer->SetShowItemPanelCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenItemTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow("dungeon.item_editor");
  });
  viewer->SetShowRoomListCallback([this]() {
    OpenWindow(IsWorkbenchWorkflowEnabled() ? "dungeon.workbench"
                                            : DungeonEditorV2::kRoomSelectorId);
  });
  viewer->SetShowRoomMatrixCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->ShowConnectedGraph();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow(kRoomMatrixId);
  });
  viewer->SetShowEntranceListCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->FocusEntranceBrowser();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow(kEntranceListId);
  });
  viewer->SetShowRoomGraphicsCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenRoomGraphicsTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow(kRoomGraphicsId);
  });
  viewer->SetShowDoorEditorCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenDoorTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow("dungeon.door_editor");
  });
  viewer->SetShowDungeonSettingsCallback([this]() {
    if (workbench_panel_) {
      workbench_panel_->FocusRoomInspector();
    }
    OpenWindow("dungeon.workbench");
  });
  viewer->SetEditGraphicsCallback(
      [this](int target_room_id, const zelda3::RoomObject& object) {
        OpenGraphicsEditorForObject(target_room_id, object);
      });
  viewer->SetEditObjectTilesCallback(
      [this](int target_room_id, const zelda3::RoomObject& object) {
        const absl::Status status =
            OpenObjectTileEditorForObject(target_room_id, object);
        if (status.ok()) {
          return;
        }
        LOG_ERROR("DungeonEditorV2", "Edit Object Tiles failed: %s",
                  status.message().data());
        if (dependencies_.toast_manager) {
          dependencies_.toast_manager->Show(
              absl::StrFormat("Edit Object Tiles failed: %s", status.message()),
              ToastType::kError);
        }
      });
  viewer->SetSaveRoomCallback([this](int target_room_id) {
    auto status = SaveRoom(target_room_id);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Apply Room failed: %s",
                status.message().data());
      if (dependencies_.toast_manager) {
        dependencies_.toast_manager->Show(
            absl::StrFormat("Apply Room failed: %s", status.message()),
            ToastType::kError);
      }
      return;
    }
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show("Applied room to ROM buffer",
                                        ToastType::kSuccess);
    }
  });
 
  viewer->SetMinecartTrackPanel(minecart_track_editor_panel_);
  viewer->SetProject(dependencies_.project);
}
 
DungeonCanvasViewer* DungeonEditorV2::GetViewerForRoom(int room_id) {
  if (IsWorkbenchWorkflowEnabled()) {
    (void)room_id;
    return GetWorkbenchViewer();
  }
 
  // Set eviction predicate to protect active rooms from eviction
  room_viewers_.SetEvictionPredicate([this](const int& candidate) {
    for (int i = 0; i < active_rooms_.size(); ++i) {
      if (active_rooms_[i] == candidate)
        return false;
    }
    return true;
  });
 
  if (auto* existing = room_viewers_.Get(room_id)) {
    // Viewer already exists - Get() already touched LRU
    auto* viewer_ptr = existing->get();
    ConfigureViewerRenderContext(viewer_ptr, room_id);
    ApplyEntranceRenderContext(room_id);
 
    // Update pinned state from manager
    if (dependencies_.window_manager) {
      std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
      viewer_ptr->SetPinned(
          dependencies_.window_manager->IsWindowPinned(card_id));
      viewer_ptr->SetPinCallback([this, card_id, room_id](bool pinned) {
        if (dependencies_.window_manager) {
          dependencies_.window_manager->SetWindowPinned(card_id, pinned);
          if (auto* v = GetViewerForRoom(room_id)) {
            v->SetPinned(pinned);
          }
        }
      });
    }
 
    return viewer_ptr;
  }
 
  // Creating a new viewer - Insert will handle LRU and eviction
  {
    auto viewer = std::make_unique<DungeonCanvasViewer>(rom_);
    viewer->SetCompactHeaderMode(false);
    viewer->SetRoomDetailsExpanded(true);
    DungeonCanvasViewer* viewer_ptr = viewer.get();
    viewer->SetRooms(&rooms_);
    viewer->SetRenderer(renderer_);
    viewer->SetCurrentPaletteGroup(current_palette_group_);
    viewer->SetCurrentPaletteId(current_palette_id_);
    viewer->SetGameData(game_data_);
    ConfigureViewerRenderContext(viewer_ptr, room_id);
    ApplyEntranceRenderContext(room_id);
 
    // These hooks must remain correct even when a room panel swaps rooms while
    // keeping the same viewer instance (to preserve canvas pan/zoom + UI
    // state). Use the viewer's best-effort current room context instead of
    // capturing room_id at creation time.
    viewer->object_interaction().SetMutationCallback([this, viewer_ptr]() {
      const int rid = viewer_ptr ? viewer_ptr->current_room_id() : -1;
      if (rid >= 0 && rid < static_cast<int>(rooms_.size())) {
        const auto domain =
            viewer_ptr->object_interaction().last_mutation_domain();
        if (domain == MutationDomain::kTileObjects) {
          BeginUndoSnapshot(rid);
        } else if (domain == MutationDomain::kCustomCollision) {
          BeginCollisionUndoSnapshot(rid);
        } else if (domain == MutationDomain::kWaterFill) {
          BeginWaterFillUndoSnapshot(rid);
        }
      }
    });
 
    viewer->object_interaction().SetCacheInvalidationCallback([this,
                                                               viewer_ptr]() {
      const int rid = viewer_ptr ? viewer_ptr->current_room_id() : -1;
      if (rid >= 0 && rid < static_cast<int>(rooms_.size())) {
        const auto domain =
            viewer_ptr->object_interaction().last_invalidation_domain();
        if (domain == MutationDomain::kTileObjects) {
          rooms_[rid].MarkObjectsDirty();
          rooms_[rid].RenderRoomGraphics();
          // Drag edits invalidate incrementally; finalize once the drag ends
          // (TileObjectHandler emits an extra invalidation on release).
          const auto mode =
              viewer_ptr->object_interaction().mode_manager().GetMode();
          if (mode != InteractionMode::DraggingObjects) {
            FinalizeUndoAction(rid);
          }
        } else if (domain == MutationDomain::kCustomCollision) {
          const auto mode =
              viewer_ptr->object_interaction().mode_manager().GetMode();
          const auto& st =
              viewer_ptr->object_interaction().mode_manager().GetModeState();
          if (mode == InteractionMode::PaintCollision && st.is_painting) {
            return;
          }
          FinalizeCollisionUndoAction(rid);
        } else if (domain == MutationDomain::kWaterFill) {
          const auto mode =
              viewer_ptr->object_interaction().mode_manager().GetMode();
          const auto& st =
              viewer_ptr->object_interaction().mode_manager().GetModeState();
          if (mode == InteractionMode::PaintWaterFill && st.is_painting) {
            return;
          }
          FinalizeWaterFillUndoAction(rid);
        }
      }
    });
 
    viewer->object_interaction().SetObjectPlacedCallback(
        [this](const zelda3::RoomObject& obj) { HandleObjectPlaced(obj); });
 
    if (dungeon_editor_system_) {
      viewer->SetEditorSystem(dungeon_editor_system_.get());
    }
    viewer->SetRoomNavigationCallback([this](int target_room) {
      if (target_room >= 0 && target_room < static_cast<int>(rooms_.size())) {
        OnRoomSelected(target_room);
      }
    });
    // Swap callback swaps the room in the current panel instead of opening new
    viewer->SetRoomSwapCallback([this](int old_room, int new_room) {
      SwapRoomInPanel(old_room, new_room);
    });
    WireViewerPanelCallbacks(viewer.get());
 
    // Wire up pinning for room panels.
    if (dependencies_.window_manager) {
      std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
      viewer->SetPinned(dependencies_.window_manager->IsWindowPinned(card_id));
      viewer->SetPinCallback([this, card_id, room_id](bool pinned) {
        if (dependencies_.window_manager) {
          dependencies_.window_manager->SetWindowPinned(card_id, pinned);
          // Sync state back to viewer in all panels showing this room
          if (auto* v = GetViewerForRoom(room_id)) {
            v->SetPinned(pinned);
          }
        }
      });
    }
 
    auto* stored = room_viewers_.Insert(room_id, std::move(viewer));
    return stored->get();
  }
}
 
void DungeonEditorV2::RefreshWorkbenchViewerRuntimeContext(
    DungeonCanvasViewer* viewer, int room_id) {
  if (!viewer) {
    return;
  }
 
  if (viewer->rom() != rom_) {
    viewer->SetRom(rom_);
  }
  if (viewer->rooms() != &rooms_) {
    viewer->SetRooms(&rooms_);
  }
  if (viewer->game_data() != game_data_) {
    viewer->SetGameData(game_data_);
  }
  viewer->SetRenderer(renderer_);
  viewer->SetCurrentPaletteGroup(current_palette_group_);
  viewer->SetCurrentPaletteId(current_palette_id_);
  ConfigureViewerRenderContext(viewer, room_id);
  viewer->SetEditorSystem(dungeon_editor_system_.get());
  viewer->SetMinecartTrackPanel(minecart_track_editor_panel_);
  if (viewer->project() != dependencies_.project) {
    viewer->SetProject(dependencies_.project);
  }
}
 
DungeonCanvasViewer* DungeonEditorV2::GetWorkbenchViewer() {
  if (!workbench_viewer_) {
    workbench_viewer_ = std::make_unique<DungeonCanvasViewer>(rom_);
    auto* viewer = workbench_viewer_.get();
    viewer->SetCompactHeaderMode(true);
    viewer->SetRoomDetailsExpanded(false);
    viewer->SetHeaderVisible(false);
    viewer->SetHeaderHiddenMetadataHudVisible(false);
    viewer->SetRooms(&rooms_);
    viewer->SetRenderer(renderer_);
    viewer->SetCurrentPaletteGroup(current_palette_group_);
    viewer->SetCurrentPaletteId(current_palette_id_);
    viewer->SetGameData(game_data_);
 
    // Workbench uses a single viewer; these hooks use the viewer's current room
    // context (set at DrawDungeonCanvas start) so room switching stays correct.
    viewer->object_interaction().SetMutationCallback([this, viewer]() {
      const int rid = viewer ? viewer->current_room_id() : -1;
      if (rid >= 0 && rid < static_cast<int>(rooms_.size())) {
        const auto domain = viewer->object_interaction().last_mutation_domain();
        if (domain == MutationDomain::kTileObjects) {
          BeginUndoSnapshot(rid);
        } else if (domain == MutationDomain::kCustomCollision) {
          BeginCollisionUndoSnapshot(rid);
        } else if (domain == MutationDomain::kWaterFill) {
          BeginWaterFillUndoSnapshot(rid);
        }
      }
    });
    viewer->object_interaction().SetCacheInvalidationCallback([this, viewer]() {
      const int rid = viewer ? viewer->current_room_id() : -1;
      if (rid >= 0 && rid < static_cast<int>(rooms_.size())) {
        const auto domain =
            viewer->object_interaction().last_invalidation_domain();
        if (domain == MutationDomain::kTileObjects) {
          rooms_[rid].MarkObjectsDirty();
          rooms_[rid].RenderRoomGraphics();
          const auto mode =
              viewer->object_interaction().mode_manager().GetMode();
          if (mode != InteractionMode::DraggingObjects) {
            FinalizeUndoAction(rid);
          }
        } else if (domain == MutationDomain::kCustomCollision) {
          const auto mode =
              viewer->object_interaction().mode_manager().GetMode();
          const auto& st =
              viewer->object_interaction().mode_manager().GetModeState();
          if (mode == InteractionMode::PaintCollision && st.is_painting) {
            return;
          }
          FinalizeCollisionUndoAction(rid);
        } else if (domain == MutationDomain::kWaterFill) {
          const auto mode =
              viewer->object_interaction().mode_manager().GetMode();
          const auto& st =
              viewer->object_interaction().mode_manager().GetModeState();
          if (mode == InteractionMode::PaintWaterFill && st.is_painting) {
            return;
          }
          FinalizeWaterFillUndoAction(rid);
        }
      }
    });
 
    viewer->object_interaction().SetObjectPlacedCallback(
        [this](const zelda3::RoomObject& obj) { HandleObjectPlaced(obj); });
 
    if (dungeon_editor_system_) {
      viewer->SetEditorSystem(dungeon_editor_system_.get());
    }
 
    // In workbench mode, arrow navigation swaps the current room without
    // changing window identities.
    viewer->SetRoomSwapCallback([this](int /*old_room*/, int new_room) {
      OnRoomSelected(new_room, /*request_focus=*/false);
    });
    viewer->SetRoomNavigationCallback([this](int target_room) {
      OnRoomSelected(target_room, /*request_focus=*/false);
    });
 
    WireViewerPanelCallbacks(viewer);
  }
 
  auto* viewer = workbench_viewer_.get();
  RefreshWorkbenchViewerRuntimeContext(viewer, current_room_id_);
  return viewer;
}
 
DungeonCanvasViewer* DungeonEditorV2::GetWorkbenchCompareViewer(int room_id) {
  if (!workbench_compare_viewer_) {
    workbench_compare_viewer_ = std::make_unique<DungeonCanvasViewer>(rom_);
    auto* viewer = workbench_compare_viewer_.get();
    viewer->SetCompactHeaderMode(true);
    viewer->SetRoomDetailsExpanded(false);
    viewer->SetHeaderHiddenMetadataHudVisible(false);
    viewer->SetRooms(&rooms_);
    viewer->SetRenderer(renderer_);
    viewer->SetCurrentPaletteGroup(current_palette_group_);
    viewer->SetCurrentPaletteId(current_palette_id_);
    viewer->SetGameData(game_data_);
 
    // Compare viewer is read-only by default: no object selection/mutation, but
    // still allows canvas pan/zoom.
    viewer->SetObjectInteractionEnabled(false);
    viewer->SetHeaderReadOnly(true);
    viewer->SetHeaderVisible(false);
 
    if (dungeon_editor_system_) {
      // Allows consistent rendering paths that depend on the editor system, but
      // interaction is still disabled.
      viewer->SetEditorSystem(dungeon_editor_system_.get());
    }
 
    viewer->SetMinecartTrackPanel(minecart_track_editor_panel_);
    viewer->SetProject(dependencies_.project);
  }
 
  auto* viewer = workbench_compare_viewer_.get();
  RefreshWorkbenchViewerRuntimeContext(viewer, room_id);
  viewer->SetObjectInteractionEnabled(false);
  viewer->SetHeaderReadOnly(true);
  viewer->SetHeaderVisible(false);
  return viewer;
}
 
void DungeonEditorV2::SyncPanelsToRoom(int room_id) {
  // Update object editor card with current viewer
  if (object_selector_panel_) {
    object_selector_panel_->SetCanvasViewerProvider(
        [this]() { return GetViewerForRoom(current_room_id_); });
    object_selector_panel_->SetCurrentRoom(room_id);
    object_selector_panel_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
  if (object_editor_content_) {
    object_editor_content_->SetCanvasViewerProvider(
        [this]() { return GetViewerForRoom(current_room_id_); });
    object_editor_content_->SetCurrentRoom(room_id);
    object_editor_content_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
  if (door_editor_panel_) {
    door_editor_panel_->SetCanvasViewerProvider(
        [this]() { return GetViewerForRoom(current_room_id_); });
    door_editor_panel_->SetCurrentRoom(room_id);
    door_editor_panel_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
 
  // Update sprite and item editor panels with current viewer
  if (sprite_editor_panel_) {
    sprite_editor_panel_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
  if (item_editor_panel_) {
    item_editor_panel_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
  if (custom_collision_panel_) {
    auto* viewer = GetViewerForRoom(room_id);
    custom_collision_panel_->SetCanvasViewer(viewer);
    if (viewer) {
      custom_collision_panel_->SetInteraction(&viewer->object_interaction());
    }
  }
  if (water_fill_panel_) {
    auto* viewer = GetViewerForRoom(room_id);
    water_fill_panel_->SetCanvasViewer(viewer);
    if (viewer) {
      water_fill_panel_->SetInteraction(&viewer->object_interaction());
    }
  }
 
  if (room_tag_editor_panel_) {
    room_tag_editor_panel_->SetCurrentRoomId(room_id);
  }
 
  if (overlay_manager_panel_) {
    auto* viewer = GetViewerForRoom(room_id);
    if (viewer) {
      OverlayManagerPanel::OverlayState overlay_state;
      overlay_state.show_grid = viewer->mutable_show_grid();
      overlay_state.show_object_bounds = viewer->mutable_show_object_bounds();
      overlay_state.show_coordinate_overlay =
          viewer->mutable_show_coordinate_overlay();
      overlay_state.show_room_debug_info =
          viewer->mutable_show_room_debug_info();
      overlay_state.show_texture_debug = viewer->mutable_show_texture_debug();
      overlay_state.show_layer_info = viewer->mutable_show_layer_info();
      overlay_state.show_minecart_tracks =
          viewer->mutable_show_minecart_tracks();
      overlay_state.show_custom_collision =
          viewer->mutable_show_custom_collision_overlay();
      overlay_state.show_track_collision =
          viewer->mutable_show_track_collision_overlay();
      overlay_state.show_camera_quadrants =
          viewer->mutable_show_camera_quadrant_overlay();
      overlay_state.show_minecart_sprites =
          viewer->mutable_show_minecart_sprite_overlay();
      overlay_state.show_collision_legend =
          viewer->mutable_show_track_collision_legend();
      overlay_manager_panel_->SetState(overlay_state);
    }
  }
}
 
void DungeonEditorV2::ShowRoomPanel(int room_id) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return;
  }
 
  bool already_active = false;
  for (int i = 0; i < active_rooms_.Size; ++i) {
    if (active_rooms_[i] == room_id) {
      already_active = true;
      break;
    }
  }
  if (!already_active) {
    active_rooms_.push_back(room_id);
    room_selector_.set_active_rooms(active_rooms_);
  }
 
  std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
 
  if (dependencies_.window_manager) {
    if (!dependencies_.window_manager->GetWindowDescriptor(
            dependencies_.window_manager->GetActiveSessionId(), card_id)) {
      std::string room_name = absl::StrFormat(
          "[%03X] %s", room_id, zelda3::GetRoomLabel(room_id).c_str());
      dependencies_.window_manager->RegisterWindow(
          {.card_id = card_id,
           .display_name = room_name,
           .window_title = ICON_MD_GRID_ON " " + room_name,
           .icon = ICON_MD_GRID_ON,
           .category = "Dungeon",
           .workflow_group = "Rooms",
           .shortcut_hint = "",
           .visibility_flag = nullptr,
           .priority = 200 + room_id});
    }
    dependencies_.window_manager->OpenWindow(card_id);
  }
 
  // Create or update the PanelWindow for this room
  if (room_cards_.find(room_id) == room_cards_.end()) {
    std::string base_name = absl::StrFormat(
        "[%03X] %s", room_id, zelda3::GetRoomLabel(room_id).c_str());
    const int slot_id = GetOrCreateRoomPanelSlotId(room_id);
    std::string card_name_str = absl::StrFormat(
        "%s###RoomPanelSlot%d", MakePanelTitle(base_name).c_str(), slot_id);
 
    auto card = std::make_shared<gui::PanelWindow>(card_name_str.c_str(),
                                                   ICON_MD_GRID_ON);
    card->SetDefaultSize(620, 700);
    room_cards_[room_id] = card;
  }
}
 
}  // namespace yaze::editor