map_properties.cc

Go to the documentation of this file.

#include "app/editor/overworld/map_properties.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <array>
#include <cstring>
#include <vector>
 
#include "absl/status/statusor.h"
#include "absl/strings/str_format.h"
#include "app/editor/overworld/overworld_editor.h"
#include "app/editor/overworld/overworld_map_metadata.h"
#include "app/editor/overworld/ui_constants.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/layout_helpers.h"
#include "app/gui/core/popup_id.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/themed_widgets.h"
#include "imgui/imgui.h"
#include "util/macro.h"
#include "zelda3/overworld/overworld_map.h"
#include "zelda3/overworld/overworld_version_helper.h"
 
namespace yaze {
namespace editor {
 
using ImGui::BeginTable;
// HOVER_HINT is defined in util/macro.h
using ImGui::Separator;
using ImGui::TableNextColumn;
using ImGui::Text;
 
// Using centralized UI constants
namespace {
 
bool IsValidMapId(int map_id) {
  return map_id >= 0 && map_id < zelda3::kNumOverworldMaps;
}
 
int EffectivePropertyMapId(zelda3::Overworld* overworld, int map_id) {
  if (!overworld || !IsValidMapId(map_id)) {
    return map_id;
  }
  auto* map = overworld->mutable_overworld_map(map_id);
  if (!map) {
    return map_id;
  }
  const int parent = map->parent();
  if (!IsValidMapId(parent)) {
    return map_id;
  }
  return parent;
}
 
absl::Status CheckFieldSupported(const Rom* rom,
                                 const OverworldPropertyEdit& edit) {
  if (!rom || !rom->is_loaded()) {
    return absl::FailedPreconditionError("ROM is not loaded");
  }
  const auto version = zelda3::OverworldVersionHelper::GetVersion(*rom);
  switch (edit.field) {
    case OverworldPropertyField::kAreaSize:
      if ((edit.value == static_cast<int>(zelda3::AreaSizeEnum::WideArea) ||
           edit.value == static_cast<int>(zelda3::AreaSizeEnum::TallArea)) &&
          !zelda3::OverworldVersionHelper::SupportsAreaEnum(version)) {
        return absl::FailedPreconditionError(
            "Wide and Tall areas require ZSCustomOverworld v3+");
      }
      return absl::OkStatus();
    case OverworldPropertyField::kMainPalette:
    case OverworldPropertyField::kAreaSpecificBgColor:
    case OverworldPropertyField::kMosaicExpanded:
      if (!zelda3::OverworldVersionHelper::SupportsCustomBGColors(version)) {
        return absl::FailedPreconditionError(
            "This field requires ZSCustomOverworld v2+");
      }
      return absl::OkStatus();
    case OverworldPropertyField::kAnimatedGraphics:
      if (!zelda3::OverworldVersionHelper::SupportsAnimatedGFX(version)) {
        return absl::FailedPreconditionError(
            "Animated GFX requires ZSCustomOverworld v3+");
      }
      return absl::OkStatus();
    case OverworldPropertyField::kCustomTileset:
      if (!zelda3::OverworldVersionHelper::SupportsExpandedSpace(version)) {
        return absl::FailedPreconditionError(
            "Custom tile graphics require ZSCustomOverworld v1+");
      }
      return absl::OkStatus();
    case OverworldPropertyField::kSubscreenOverlay:
      if (version == zelda3::OverworldVersion::kVanilla) {
        return absl::FailedPreconditionError(
            "Visual effect editing requires ZSCustomOverworld v1+");
      }
      return absl::OkStatus();
    default:
      return absl::OkStatus();
  }
}
 
int MusicRomAddressForMapState(int map_id, int state) {
  if (map_id >= 0 && map_id < zelda3::kDarkWorldMapIdStart) {
    switch (state) {
      case 0:
        return zelda3::kOverworldMusicBeginning + map_id;
      case 1:
        return zelda3::kOverworldMusicZelda + map_id;
      case 2:
        return zelda3::kOverworldMusicMasterSword + map_id;
      case 3:
        return zelda3::kOverworldMusicAgahnim + map_id;
      default:
        return -1;
    }
  }
  if (map_id >= zelda3::kDarkWorldMapIdStart &&
      map_id < zelda3::kSpecialWorldMapIdStart && state == 0) {
    return zelda3::kOverworldMusicDarkWorld +
           (map_id - zelda3::kDarkWorldMapIdStart);
  }
  return -1;
}
 
bool WriteRomByteIfValid(Rom* rom, int address, uint8_t value) {
  if (!rom || address < 0 || static_cast<size_t>(address) >= rom->size()) {
    return false;
  }
  (*rom)[address] = value;
  return true;
}
 
void WriteRomWordIfValid(Rom* rom, int address, uint16_t value) {
  if (!rom || address < 0 || static_cast<size_t>(address + 1) >= rom->size()) {
    return;
  }
  (*rom)[address] = value & 0xFF;
  (*rom)[address + 1] = (value >> 8) & 0xFF;
}
 
OverworldMapMetadataClipboard CaptureMapMetadataClipboard(
    const zelda3::Overworld& overworld, int map_id) {
  OverworldMapMetadataClipboard clipboard;
  if (!IsValidMapId(map_id)) {
    return clipboard;
  }
 
  const auto* selected_map = overworld.overworld_map(map_id);
  if (!selected_map) {
    return clipboard;
  }
 
  int source_map_id = map_id;
  if (IsValidMapId(selected_map->parent())) {
    source_map_id = selected_map->parent();
  }
  const auto* map = overworld.overworld_map(source_map_id);
  if (!map) {
    return clipboard;
  }
 
  clipboard.valid = true;
  clipboard.source_map_id = source_map_id;
  clipboard.area_size = static_cast<int>(map->area_size());
  clipboard.area_graphics = map->area_graphics();
  clipboard.area_palette = map->area_palette();
  clipboard.main_palette = map->main_palette();
  clipboard.animated_graphics = map->animated_gfx();
  clipboard.message_id = map->message_id();
  clipboard.subscreen_overlay = map->subscreen_overlay();
  clipboard.area_specific_bg_color = map->area_specific_bg_color();
  clipboard.mosaic = *const_cast<zelda3::OverworldMap*>(map)->mutable_mosaic();
  clipboard.mosaic_expanded = map->mosaic_expanded();
  for (int i = 0; i < 3; ++i) {
    clipboard.sprite_graphics[i] = map->sprite_graphics(i);
    clipboard.sprite_palette[i] = map->sprite_palette(i);
  }
  for (int i = 0; i < 4; ++i) {
    clipboard.music[i] = map->area_music(i);
  }
  for (int i = 0; i < 8; ++i) {
    clipboard.custom_tilesets[i] = map->custom_tileset(i);
  }
  return clipboard;
}
 
}  // namespace
 
int MapPropertiesSystem::CurrentGameState() const {
  return CurrentGameState(local_game_state_);
}
 
int MapPropertiesSystem::CurrentGameState(int fallback) const {
  return std::clamp(game_state_ ? *game_state_ : fallback, 0, 2);
}
 
void MapPropertiesSystem::SetCurrentGameState(int game_state) {
  const int clamped_state = std::clamp(game_state, 0, 2);
  local_game_state_ = clamped_state;
  if (game_state_) {
    *game_state_ = clamped_state;
  }
}
 
void MapPropertiesSystem::PrepareMapForGraphicsRefresh(int map_index) {
  if (!overworld_ || map_index < 0 || map_index >= zelda3::kNumOverworldMaps) {
    return;
  }
  auto* map = overworld_->mutable_overworld_map(map_index);
  if (!map) {
    return;
  }
  map->set_game_state(CurrentGameState(map->game_state()));
}
 
void MapPropertiesSystem::DrawCanvasToolbar(
    int& current_world, int& current_map, bool& current_map_lock,
    bool& show_map_properties_panel, bool& show_custom_bg_color_editor,
    bool& show_overlay_editor, bool& show_overlay_preview, int& game_state,
    EditingMode& current_mode, EntityEditMode& entity_edit_mode) {
  (void)show_overlay_editor;          // Reserved for future use
  (void)show_custom_bg_color_editor;  // Now handled by sidebar
  (void)game_state;                   // Now handled by sidebar
  (void)show_overlay_preview;         // Reserved
 
  // Simplified canvas toolbar - Navigation and Mode controls
  if (BeginTable("MapPropertiesCanvasToolbar", 7,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit,
                 ImVec2(0, 0), -1)) {
    ImGui::TableSetupColumn("World", ImGuiTableColumnFlags_WidthFixed,
                            kTableColumnWorld);
    ImGui::TableSetupColumn("Map", ImGuiTableColumnFlags_WidthFixed,
                            kTableColumnMap);
    ImGui::TableSetupColumn("Area Size", ImGuiTableColumnFlags_WidthFixed,
                            kTableColumnAreaSize);
    ImGui::TableSetupColumn("Lock", ImGuiTableColumnFlags_WidthFixed,
                            kTableColumnLock);
    ImGui::TableSetupColumn("Mode", ImGuiTableColumnFlags_WidthFixed,
                            80.0f);  // Mouse/Paint
    ImGui::TableSetupColumn(
        "Entity", ImGuiTableColumnFlags_WidthStretch);  // Entity status
    ImGui::TableSetupColumn("Sidebar", ImGuiTableColumnFlags_WidthFixed, 40.0f);
 
    TableNextColumn();
    const int clamped_world = std::clamp(current_world, 0, 2);
    ImGui::TextDisabled("%s", kWorldNames[clamped_world]);
 
    TableNextColumn();
    ImGui::Text(tr("%d (0x%02X)"), current_map, current_map);
 
    TableNextColumn();
    // Use centralized version detection
    auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
 
    // ALL ROMs support Small/Large. Only v3+ supports Wide/Tall.
    int current_area_size =
        static_cast<int>(overworld_->overworld_map(current_map)->area_size());
    ImGui::SetNextItemWidth(kComboAreaSizeWidth);
 
    if (zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version)) {
      // v3+ ROM: Show all 4 area size options
      if (ImGui::Combo("##AreaSize", &current_area_size, kAreaSizeNames, 4)) {
        ApplyPropertyEdit({current_map, OverworldPropertyField::kAreaSize, 0,
                           current_area_size});
      }
    } else {
      // Vanilla/v1/v2 ROM: Show only Small/Large (first 2 options)
      const char* limited_names[] = {"Small (1x1)", "Large (2x2)"};
      int limited_size = (current_area_size == 0 || current_area_size == 1)
                             ? current_area_size
                             : 0;
 
      if (ImGui::Combo("##AreaSize", &limited_size, limited_names, 2)) {
        ApplyPropertyEdit(
            {current_map, OverworldPropertyField::kAreaSize, 0, limited_size});
      }
 
      if (rom_version == zelda3::OverworldVersion::kVanilla ||
          !zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version)) {
        HOVER_HINT("Small (1x1) and Large (2x2) maps. Wide/Tall require v3+");
      }
    }
 
    TableNextColumn();
    if (ImGui::Button(current_map_lock ? ICON_MD_LOCK : ICON_MD_LOCK_OPEN,
                      ImVec2(40, 0))) {
      current_map_lock = !current_map_lock;
    }
    HOVER_HINT(current_map_lock ? "Unlock Map" : "Lock Map");
 
    TableNextColumn();
    // Mode Controls
    {
      gui::StyleVarGuard spacing_guard(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
      if (gui::ToggleButton(ICON_MD_MOUSE, current_mode == EditingMode::MOUSE,
                            ImVec2(30, 0))) {
        current_mode = EditingMode::MOUSE;
        canvas_->SetUsageMode(gui::CanvasUsage::kEntityManipulation);
      }
      HOVER_HINT("Mouse Mode (1)\nNavigate, pan, and manage entities");
 
      ImGui::SameLine();
      if (gui::ToggleButton(ICON_MD_DRAW,
                            current_mode == EditingMode::DRAW_TILE,
                            ImVec2(30, 0))) {
        current_mode = EditingMode::DRAW_TILE;
        canvas_->SetUsageMode(gui::CanvasUsage::kTilePainting);
      }
      HOVER_HINT("Tile Paint Mode (2)\nDraw tiles on the map");
    }
 
    TableNextColumn();
    // Entity Status
    if (entity_edit_mode != EntityEditMode::NONE) {
      const char* entity_icon = "";
      const char* entity_label = "";
      switch (entity_edit_mode) {
        case EntityEditMode::ENTRANCES:
          entity_icon = ICON_MD_DOOR_FRONT;
          entity_label = "Entrances";
          break;
        case EntityEditMode::EXITS:
          entity_icon = ICON_MD_DOOR_BACK;
          entity_label = "Exits";
          break;
        case EntityEditMode::ITEMS:
          entity_icon = ICON_MD_GRASS;
          entity_label = "Items";
          break;
        case EntityEditMode::SPRITES:
          entity_icon = ICON_MD_PEST_CONTROL_RODENT;
          entity_label = "Sprites";
          break;
        case EntityEditMode::TRANSPORTS:
          entity_icon = ICON_MD_ADD_LOCATION;
          entity_label = "Transports";
          break;
        case EntityEditMode::MUSIC:
          entity_icon = ICON_MD_MUSIC_NOTE;
          entity_label = "Music";
          break;
        default:
          break;
      }
      ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "%s %s", entity_icon,
                         entity_label);
    }
 
    TableNextColumn();
    // Sidebar Toggle
    if (ImGui::Button(ICON_MD_TUNE, ImVec2(40, 0))) {
      show_map_properties_panel = !show_map_properties_panel;
    }
    HOVER_HINT("Toggle Map Properties Sidebar");
 
    ImGui::EndTable();
  }
}
 
void MapPropertiesSystem::DrawMapPropertiesPanel(
    int current_map, bool& show_map_properties_panel) {
  (void)show_map_properties_panel;  // Used by caller for window state
  if (!overworld_->is_loaded()) {
    Text(tr("No overworld loaded"));
    return;
  }
 
  // Header with map info and lock status
  ImGui::BeginGroup();
  Text(tr("Current Map: %d (0x%02X)"), current_map, current_map);
  ImGui::EndGroup();
 
  Separator();
 
  // Create tabs for different property categories
  if (gui::BeginThemedTabBar("MapPropertiesTabs",
                             ImGuiTabBarFlags_FittingPolicyScroll)) {
    // Basic Properties Tab
    if (ImGui::BeginTabItem(tr("Basic Properties"))) {
      DrawBasicPropertiesTab(current_map);
      ImGui::EndTabItem();
    }
 
    // Sprite Properties Tab
    if (ImGui::BeginTabItem(tr("Sprite Properties"))) {
      DrawSpritePropertiesTab(current_map);
      ImGui::EndTabItem();
    }
 
    // Custom Overworld Features Tab
    auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
    if (rom_version != zelda3::OverworldVersion::kVanilla &&
        ImGui::BeginTabItem(tr("Custom Features"))) {
      DrawCustomFeaturesTab(current_map);
      ImGui::EndTabItem();
    }
 
    // Tile Graphics Tab
    if (ImGui::BeginTabItem(tr("Tile Graphics"))) {
      DrawTileGraphicsTab(current_map);
      ImGui::EndTabItem();
    }
 
    // Music Tab
    if (ImGui::BeginTabItem(tr("Music"))) {
      DrawMusicTab(current_map);
      ImGui::EndTabItem();
    }
 
    gui::EndThemedTabBar();
  }
}
 
void MapPropertiesSystem::DrawCustomBackgroundColorEditor(
    int current_map, bool& show_custom_bg_color_editor) {
  (void)show_custom_bg_color_editor;  // Used by caller for window state
  if (!overworld_->is_loaded()) {
    Text(tr("No overworld loaded"));
    return;
  }
 
  auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
  if (!zelda3::OverworldVersionHelper::SupportsCustomBGColors(rom_version)) {
    Text(tr("Custom background colors require ZSCustomOverworld v2+"));
    return;
  }
 
  Text(tr("Custom Background Color Editor"));
  Separator();
 
  // Read enable flag from ROM (not static - must reflect current ROM state)
  bool use_area_specific_bg_color =
      (*rom_)[zelda3::OverworldCustomAreaSpecificBGEnabled] != 0x00;
  if (ImGui::Checkbox(tr("Use Area-Specific Background Color"),
                      &use_area_specific_bg_color)) {
    // Update ROM data when checkbox is toggled
    (*rom_)[zelda3::OverworldCustomAreaSpecificBGEnabled] =
        use_area_specific_bg_color ? 0x01 : 0x00;
  }
 
  if (use_area_specific_bg_color) {
    // Get current color
    uint16_t current_color =
        overworld_->overworld_map(current_map)->area_specific_bg_color();
    gfx::SnesColor snes_color(current_color);
 
    // Convert to ImVec4 for color picker
    ImVec4 color_vec = gui::ConvertSnesColorToImVec4(snes_color);
 
    if (ImGui::ColorPicker4(
            "Background Color", (float*)&color_vec,
            ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHex)) {
      // Convert back to SNES color and update
      gfx::SnesColor new_snes_color = gui::ConvertImVec4ToSnesColor(color_vec);
      ApplyPropertyEdit({current_map,
                         OverworldPropertyField::kAreaSpecificBgColor, 0,
                         new_snes_color.snes()});
    }
 
    Text(tr("SNES Color: 0x%04X"), current_color);
  }
}
 
void MapPropertiesSystem::DrawOverlayEditor(int current_map,
                                            bool& show_overlay_editor) {
  (void)show_overlay_editor;  // Used by caller for window state
  if (!overworld_->is_loaded()) {
    Text(tr("No overworld loaded"));
    return;
  }
 
  auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
 
  ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
                     ICON_MD_LAYERS " Visual Effects Configuration");
  ImGui::Text(tr("Map: 0x%02X"), current_map);
  Separator();
 
  if (rom_version == zelda3::OverworldVersion::kVanilla) {
    ImGui::TextColored(
        ImVec4(1.0f, 0.8f, 0.4f, 1.0f), ICON_MD_INFO
        " Enhanced overlay editing requires ZSCustomOverworld v1+");
    ImGui::Separator();
    ImGui::TextWrapped(tr(
        "Subscreen overlays are a vanilla feature used for atmospheric effects "
        "like fog, rain, and forest canopy. ZSCustomOverworld expands this by "
        "allowing per-area overlay configuration and additional "
        "customization."));
    return;
  }
 
  // Help section
  if (ImGui::CollapsingHeader(ICON_MD_HELP_OUTLINE " What are Visual Effects?",
                              ImGuiTreeNodeFlags_DefaultOpen)) {
    ImGui::Indent();
    ImGui::TextWrapped(tr(
        "Visual effects (subscreen overlays) are semi-transparent layers drawn "
        "on top of or behind your map. They reference special area maps "
        "(0x80-0x9F) "
        "for their tile16 graphics data."));
    ImGui::Spacing();
    ImGui::Text(tr("Common uses:"));
    ImGui::BulletText(tr("Fog effects (Lost Woods, Skull Woods)"));
    ImGui::BulletText(tr("Rain (Misery Mire)"));
    ImGui::BulletText(tr("Forest canopy (Lost Woods)"));
    ImGui::BulletText(tr("Sky backgrounds (Death Mountain)"));
    ImGui::BulletText(tr("Under bridge views"));
    ImGui::Unindent();
    ImGui::Separator();
  }
 
  // Read enable flag from ROM (not static - must reflect current ROM state)
  bool use_subscreen_overlay =
      (*rom_)[zelda3::OverworldCustomSubscreenOverlayEnabled] != 0x00;
  if (ImGui::Checkbox(ICON_MD_VISIBILITY " Enable Visual Effect for This Area",
                      &use_subscreen_overlay)) {
    // Update ROM data when checkbox is toggled
    (*rom_)[zelda3::OverworldCustomSubscreenOverlayEnabled] =
        use_subscreen_overlay ? 0x01 : 0x00;
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Enable/disable visual effect overlay for this map area"));
  }
 
  if (use_subscreen_overlay) {
    ImGui::Spacing();
    uint16_t current_overlay =
        overworld_->overworld_map(current_map)->subscreen_overlay();
    if (gui::InputHexWord(ICON_MD_PHOTO " Visual Effect Map ID",
                          &current_overlay, kInputFieldSize + 30)) {
      ApplyPropertyEdit({current_map, OverworldPropertyField::kSubscreenOverlay,
                         0, current_overlay});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("ID of the special area map (0x80-0x9F) to use for\n"
             "visual effects. That map's tile16 data will be drawn\n"
             "as a semi-transparent layer on this area."));
    }
 
    // Show description
    std::string overlay_desc = GetOverlayDescription(current_overlay);
    ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f), ICON_MD_INFO " %s",
                       overlay_desc.c_str());
 
    ImGui::Separator();
    if (ImGui::CollapsingHeader(ICON_MD_LIGHTBULB
                                " Common Visual Effect IDs")) {
      ImGui::Indent();
      ImGui::BulletText(tr("0x0093 - Triforce Room Curtain"));
      ImGui::BulletText(tr("0x0094 - Under the Bridge"));
      ImGui::BulletText(tr("0x0095 - Sky Background (LW Death Mountain)"));
      ImGui::BulletText(tr("0x0096 - Pyramid Background"));
      ImGui::BulletText(tr("0x0097 - Fog Overlay (Master Sword Area)"));
      ImGui::BulletText(tr("0x009C - Lava Background (DW Death Mountain)"));
      ImGui::BulletText(tr("0x009D - Fog Overlay (Lost/Skull Woods)"));
      ImGui::BulletText(tr("0x009E - Tree Canopy (Forest)"));
      ImGui::BulletText(tr("0x009F - Rain Effect (Misery Mire)"));
      ImGui::BulletText(tr("0x00FF - No Overlay (Disabled)"));
      ImGui::Unindent();
    }
  } else {
    ImGui::Spacing();
    ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), ICON_MD_BLOCK
                       " No visual effects enabled for this area");
  }
}
 
void MapPropertiesSystem::SetupCanvasContextMenu(
    gui::Canvas& canvas, int current_map, bool& current_map_lock,
    bool& show_map_properties_panel, bool& show_custom_bg_color_editor,
    bool& show_overlay_editor, int current_mode, project::YazeProject* project,
    SharedClipboard* shared_clipboard) {
  // Clear any existing context menu items
  canvas.ClearContextMenuItems();
 
  if (overworld_ && overworld_->is_loaded() && current_map >= 0 &&
      current_map < zelda3::kNumOverworldMaps &&
      overworld_->overworld_map(current_map) != nullptr) {
    const auto metadata = BuildOverworldMapMetadata(
        *overworld_, rom_, project, current_map, CurrentGameState());
 
    gui::CanvasMenuItem header_item =
        gui::CanvasMenuItem::Disabled(ICON_MD_MAP " " + metadata.map_title);
    header_item.separator_after = true;
    canvas.AddContextMenuItem(header_item);
 
    gui::CanvasMenuItem metadata_menu;
    metadata_menu.label = ICON_MD_INFO " Map Metadata";
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.version_label));
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.area_size_label));
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.parent_label));
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.area_gfx_label));
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.area_palette_label));
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.sprite_gfx_label));
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.sprite_palette_label));
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.music_label));
    metadata_menu.subitems.push_back(
        gui::CanvasMenuItem::Disabled(metadata.message_label));
    metadata_menu.separator_after = true;
    canvas.AddContextMenuItem(metadata_menu);
 
    if (const auto* current_map_ptr = overworld_->overworld_map(current_map);
        current_map_ptr) {
      const int parent = IsValidMapId(current_map_ptr->parent())
                             ? current_map_ptr->parent()
                             : current_map;
      gui::CanvasMenuItem related_maps_menu;
      related_maps_menu.label = ICON_MD_ACCOUNT_TREE " Related Maps";
 
      if (parent != current_map) {
        gui::CanvasMenuItem select_parent_item;
        select_parent_item.label =
            absl::StrFormat("Select Parent Map 0x%02X", parent);
        select_parent_item.callback = [this, parent]() {
          if (map_selection_callback_) {
            map_selection_callback_(parent, false);
          }
        };
        related_maps_menu.subitems.push_back(select_parent_item);
      }
 
      for (int map_id = 0; map_id < zelda3::kNumOverworldMaps; ++map_id) {
        if (map_id == current_map ||
            (map_id == parent && parent != current_map)) {
          continue;
        }
        const auto* sibling = overworld_->overworld_map(map_id);
        if (!sibling || sibling->parent() != parent) {
          continue;
        }
 
        gui::CanvasMenuItem sibling_item;
        sibling_item.label =
            map_id == parent
                ? absl::StrFormat("Select Parent Map 0x%02X", map_id)
                : absl::StrFormat("Select Sibling Map 0x%02X", map_id);
        sibling_item.callback = [this, map_id]() {
          if (map_selection_callback_) {
            map_selection_callback_(map_id, false);
          }
        };
        related_maps_menu.subitems.push_back(sibling_item);
      }
 
      if (!related_maps_menu.subitems.empty()) {
        canvas.AddContextMenuItem(related_maps_menu);
      }
    }
 
    if (shared_clipboard) {
      gui::CanvasMenuItem metadata_actions_menu;
      metadata_actions_menu.label =
          ICON_MD_CONTENT_COPY " Copy / Paste Metadata";
      if (shared_clipboard->has_overworld_map_metadata &&
          shared_clipboard->overworld_map_metadata.valid) {
        metadata_actions_menu.subitems.push_back(gui::CanvasMenuItem::Disabled(
            ICON_MD_CONTENT_PASTE " " +
            DescribeOverworldMapMetadataClipboard(
                shared_clipboard->overworld_map_metadata)));
      }
 
      auto add_metadata_actions = [&](OverworldMapMetadataClipboardScope scope,
                                      const char* copy_label,
                                      const char* paste_label) {
        gui::CanvasMenuItem copy_item;
        copy_item.label = copy_label;
        copy_item.callback = [this, current_map, shared_clipboard, scope]() {
          shared_clipboard->overworld_map_metadata =
              CaptureMapMetadataClipboard(*overworld_, current_map);
          shared_clipboard->overworld_map_metadata.scope = scope;
          shared_clipboard->has_overworld_map_metadata =
              shared_clipboard->overworld_map_metadata.valid;
        };
        metadata_actions_menu.subitems.push_back(copy_item);
 
        gui::CanvasMenuItem paste_item;
        paste_item.label = paste_label;
        paste_item.enabled_condition = [shared_clipboard, scope]() {
          return shared_clipboard->has_overworld_map_metadata &&
                 CanPasteOverworldMapMetadata(
                     shared_clipboard->overworld_map_metadata, scope);
        };
        paste_item.callback = [this, current_map, shared_clipboard, scope]() {
          const auto edits = BuildOverworldMetadataPasteEdits(
              current_map, shared_clipboard->overworld_map_metadata, scope);
          (void)ApplyPropertyEdits(
              edits,
              absl::StrFormat(
                  "Paste %s from 0x%02X",
                  OverworldMapMetadataClipboardScopeName(scope),
                  shared_clipboard->overworld_map_metadata.source_map_id));
        };
        paste_item.separator_after =
            scope != OverworldMapMetadataClipboardScope::kMusicMessages;
        metadata_actions_menu.subitems.push_back(paste_item);
      };
 
      add_metadata_actions(OverworldMapMetadataClipboardScope::kAll,
                           ICON_MD_CONTENT_COPY " Copy Map Metadata",
                           ICON_MD_CONTENT_PASTE " Paste Map Metadata");
      add_metadata_actions(OverworldMapMetadataClipboardScope::kGraphics,
                           ICON_MD_IMAGE " Copy Graphics Metadata",
                           ICON_MD_CONTENT_PASTE " Paste Graphics Metadata");
      add_metadata_actions(OverworldMapMetadataClipboardScope::kPalettes,
                           ICON_MD_PALETTE " Copy Palette Metadata",
                           ICON_MD_CONTENT_PASTE " Paste Palette Metadata");
      add_metadata_actions(OverworldMapMetadataClipboardScope::kMusicMessages,
                           ICON_MD_MUSIC_NOTE " Copy Music/Message Metadata",
                           ICON_MD_CONTENT_PASTE
                           " Paste Music/Message Metadata");
 
      canvas.AddContextMenuItem(metadata_actions_menu);
    }
 
    if (project) {
      const std::string popup_id =
          absl::StrFormat("RenameOverworldMapLabelContext%02X", current_map);
      gui::CanvasMenuItem rename_item = gui::CanvasMenuItem::WithPopup(
          ICON_MD_EDIT " Rename Map Label", popup_id,
          [this, project, current_map, initial_label = metadata.map_name,
           popup_id]() {
            static std::array<char, 128> label_buffer{};
            static int active_map = -1;
            static std::string error_message;
            if (active_map != current_map) {
              active_map = current_map;
              error_message.clear();
              std::strncpy(label_buffer.data(), initial_label.c_str(),
                           label_buffer.size() - 1);
              label_buffer[label_buffer.size() - 1] = '\0';
            }
 
            if (ImGui::BeginPopup(popup_id.c_str())) {
              ImGui::Text(tr("%s Map Label"), ICON_MD_LABEL);
              ImGui::TextDisabled(tr("Map 0x%02X"), current_map);
              ImGui::SetNextItemWidth(260.0f);
              ImGui::InputText("##OverworldContextMapLabel",
                               label_buffer.data(), label_buffer.size());
 
              if (ImGui::Button(ICON_MD_CHECK " Apply")) {
                auto status =
                    resource_label_edit_callback_
                        ? resource_label_edit_callback_(
                              "overworld_map", current_map, label_buffer.data())
                        : RenameProjectResourceLabel(project, "overworld_map",
                                                     current_map,
                                                     label_buffer.data());
                if (status.ok()) {
                  active_map = -1;
                  ImGui::CloseCurrentPopup();
                } else {
                  error_message = std::string(status.message());
                }
              }
              ImGui::SameLine();
              if (ImGui::Button(ICON_MD_CLEAR " Clear")) {
                auto status =
                    resource_label_edit_callback_
                        ? resource_label_edit_callback_("overworld_map",
                                                        current_map, "")
                        : RenameProjectResourceLabel(project, "overworld_map",
                                                     current_map, "");
                if (status.ok()) {
                  active_map = -1;
                  ImGui::CloseCurrentPopup();
                } else {
                  error_message = std::string(status.message());
                }
              }
              if (!error_message.empty()) {
                ImGui::TextWrapped("%s", error_message.c_str());
              }
              ImGui::EndPopup();
            }
          });
      canvas.AddContextMenuItem(rename_item);
    }
  }
 
  gui::CanvasMenuItem select_item;
  select_item.label = ICON_MD_CHECK " Select This Map";
  select_item.callback = [this, current_map]() {
    if (map_selection_callback_) {
      map_selection_callback_(current_map, false);
    }
  };
  canvas.AddContextMenuItem(select_item);
 
  // Add entity insertion submenu (only in MOUSE mode)
  if (current_mode == 0 && entity_insert_callback_) {  // 0 = EditingMode::MOUSE
    gui::CanvasMenuItem entity_menu;
    entity_menu.label = ICON_MD_ADD_LOCATION " Insert Entity";
 
    // Entrance submenu item
    gui::CanvasMenuItem entrance_item;
    entrance_item.label = ICON_MD_DOOR_FRONT " Entrance";
    entrance_item.callback = [this]() {
      if (entity_insert_callback_) {
        entity_insert_callback_("entrance");
      }
    };
    entity_menu.subitems.push_back(entrance_item);
 
    // Hole submenu item
    gui::CanvasMenuItem hole_item;
    hole_item.label = ICON_MD_CYCLONE " Hole";
    hole_item.callback = [this]() {
      if (entity_insert_callback_) {
        entity_insert_callback_("hole");
      }
    };
    entity_menu.subitems.push_back(hole_item);
 
    // Exit submenu item
    gui::CanvasMenuItem exit_item;
    exit_item.label = ICON_MD_DOOR_BACK " Exit";
    exit_item.callback = [this]() {
      if (entity_insert_callback_) {
        entity_insert_callback_("exit");
      }
    };
    entity_menu.subitems.push_back(exit_item);
 
    // Item submenu item
    gui::CanvasMenuItem item_item;
    item_item.label = ICON_MD_GRASS " Item";
    item_item.callback = [this]() {
      if (entity_insert_callback_) {
        entity_insert_callback_("item");
      }
    };
    entity_menu.subitems.push_back(item_item);
 
    // Sprite submenu item
    gui::CanvasMenuItem sprite_item;
    sprite_item.label = ICON_MD_PEST_CONTROL_RODENT " Sprite";
    sprite_item.callback = [this]() {
      if (entity_insert_callback_) {
        entity_insert_callback_("sprite");
      }
    };
    entity_menu.subitems.push_back(sprite_item);
 
    canvas.AddContextMenuItem(entity_menu);
 
    if (sample_tile16_callback_) {
      gui::CanvasMenuItem tile16_sample_item;
      tile16_sample_item.label = ICON_MD_COLORIZE " Sample Tile16";
      tile16_sample_item.callback = [this]() {
        if (sample_tile16_callback_) {
          (void)sample_tile16_callback_();
        }
      };
      canvas.AddContextMenuItem(tile16_sample_item);
    }
 
    if (edit_tile16_callback_) {
      gui::CanvasMenuItem tile16_edit_item;
      tile16_edit_item.label = ICON_MD_GRID_VIEW " Edit Tile16";
      tile16_edit_item.callback = [this]() {
        if (edit_tile16_callback_) {
          edit_tile16_callback_();
        }
      };
      canvas.AddContextMenuItem(tile16_edit_item);
    }
  }
 
  // Add overworld-specific context menu items
  gui::CanvasMenuItem lock_item;
  lock_item.label = current_map_lock ? ICON_MD_LOCK_OPEN " Unpin Map"
                                     : ICON_MD_PUSH_PIN " Pin This Map";
  lock_item.callback = [this, current_map, &current_map_lock]() {
    if (current_map_lock) {
      current_map_lock = false;
      return;
    }
    if (map_selection_callback_) {
      map_selection_callback_(current_map, false);
    }
    current_map_lock = true;
  };
  canvas.AddContextMenuItem(lock_item);
 
  // Area Configuration
  gui::CanvasMenuItem properties_item;
  properties_item.label = ICON_MD_TUNE " Area Configuration";
  properties_item.callback = [&show_map_properties_panel]() {
    show_map_properties_panel = true;
  };
  canvas.AddContextMenuItem(properties_item);
 
  // Custom overworld features (only show if v3+)
  auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
  if (zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version)) {
    // Custom Background Color
    gui::CanvasMenuItem bg_color_item;
    bg_color_item.label = ICON_MD_FORMAT_COLOR_FILL " Custom Background Color";
    bg_color_item.callback = [&show_custom_bg_color_editor]() {
      show_custom_bg_color_editor = true;
    };
    canvas.AddContextMenuItem(bg_color_item);
 
    // Visual Effects Editor
    gui::CanvasMenuItem overlay_item;
    overlay_item.label = ICON_MD_LAYERS " Visual Effects";
    overlay_item.callback = [&show_overlay_editor]() {
      show_overlay_editor = true;
    };
    canvas.AddContextMenuItem(overlay_item);
  }
 
  // Canvas controls
  gui::CanvasMenuItem reset_view_item;
  reset_view_item.label = ICON_MD_RESTORE " Reset View";
  reset_view_item.callback = [&canvas]() {
    canvas.set_global_scale(1.0f);
    canvas.set_scrolling(ImVec2(0, 0));
  };
  canvas.AddContextMenuItem(reset_view_item);
 
  gui::CanvasMenuItem zoom_in_item;
  zoom_in_item.label = ICON_MD_ZOOM_IN " Zoom In";
  zoom_in_item.callback = [&canvas]() {
    float scale =
        std::min(kOverworldMaxZoom, canvas.global_scale() + kOverworldZoomStep);
    canvas.set_global_scale(scale);
  };
  canvas.AddContextMenuItem(zoom_in_item);
 
  gui::CanvasMenuItem zoom_out_item;
  zoom_out_item.label = ICON_MD_ZOOM_OUT " Zoom Out";
  zoom_out_item.callback = [&canvas]() {
    float scale =
        std::max(kOverworldMinZoom, canvas.global_scale() - kOverworldZoomStep);
    canvas.set_global_scale(scale);
  };
  canvas.AddContextMenuItem(zoom_out_item);
}
 
// Private method implementations
void MapPropertiesSystem::DrawGraphicsPopup(int current_map, int game_state) {
  const int current_game_state = CurrentGameState(game_state);
  if (ImGui::BeginPopup(gui::MakePopupId(gui::EditorNames::kOverworld,
                                         gui::PopupNames::kGraphicsPopup)
                            .c_str())) {
    ImGui::PushID("GraphicsPopup");  // Fix ImGui duplicate ID warnings
 
    // Use theme-aware spacing instead of hardcoded constants
    float spacing = gui::LayoutHelpers::GetStandardSpacing();
    float padding = gui::LayoutHelpers::GetButtonPadding();
    gui::StyleVarGuard popup_style_guard(
        {{ImGuiStyleVar_ItemSpacing, ImVec2(spacing, spacing)},
         {ImGuiStyleVar_FramePadding, ImVec2(padding, padding)}});
 
    ImGui::Text(tr("Graphics Settings"));
    ImGui::Separator();
 
    // Area Graphics
    uint8_t area_gfx = overworld_->overworld_map(current_map)->area_graphics();
    if (gui::InputHexByte(ICON_MD_IMAGE " Area Graphics", &area_gfx,
                          kHexByteInputWidth)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kAreaGraphics, 0, area_gfx});
    }
    HOVER_HINT("Main tileset graphics for this map area");
 
    // Sprite Graphics
    uint8_t sprite_gfx = overworld_->overworld_map(current_map)
                             ->sprite_graphics(current_game_state);
    if (gui::InputHexByte(absl::StrFormat(ICON_MD_PETS " Sprite GFX (%s)",
                                          kGameStateNames[current_game_state])
                              .c_str(),
                          &sprite_gfx, kHexByteInputWidth)) {
      ApplyPropertyEdit({current_map, OverworldPropertyField::kSpriteGraphics,
                         current_game_state, sprite_gfx});
    }
    HOVER_HINT("Sprite graphics sheet for current game state");
 
    auto rom_version_gfx = zelda3::OverworldVersionHelper::GetVersion(*rom_);
    if (zelda3::OverworldVersionHelper::SupportsAnimatedGFX(rom_version_gfx)) {
      uint8_t animated_gfx =
          overworld_->overworld_map(current_map)->animated_gfx();
      if (gui::InputHexByte(ICON_MD_ANIMATION " Animated GFX", &animated_gfx,
                            kHexByteInputWidth)) {
        ApplyPropertyEdit({current_map,
                           OverworldPropertyField::kAnimatedGraphics, 0,
                           animated_gfx});
      }
      HOVER_HINT("Animated tile graphics (water, lava, etc.)");
    }
 
    // Custom Tile Graphics - Only available for v1+ ROMs
    if (zelda3::OverworldVersionHelper::SupportsExpandedSpace(
            rom_version_gfx)) {
      ImGui::Separator();
      ImGui::Text(ICON_MD_GRID_VIEW " Custom Tile Graphics");
      ImGui::Separator();
 
      // Show the 8 custom graphics IDs in a 2-column layout for density
      if (BeginTable("CustomTileGraphics", 2, ImGuiTableFlags_SizingFixedFit)) {
        for (int i = 0; i < 8; i++) {
          TableNextColumn();
          std::string label = absl::StrFormat(ICON_MD_LAYERS " Sheet %d", i);
          uint8_t custom_gfx =
              overworld_->overworld_map(current_map)->custom_tileset(i);
          if (gui::InputHexByte(label.c_str(), &custom_gfx, 90.f)) {
            ApplyPropertyEdit({current_map,
                               OverworldPropertyField::kCustomTileset, i,
                               custom_gfx});
          }
          if (ImGui::IsItemHovered()) {
            ImGui::SetTooltip(tr("Custom graphics sheet %d (0x00-0xFF)"), i);
          }
        }
        ImGui::EndTable();
      }
    } else if (rom_version_gfx == zelda3::OverworldVersion::kVanilla) {
      ImGui::Separator();
      ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f),
                         ICON_MD_INFO " Custom Tile Graphics");
      ImGui::TextWrapped(
          tr("Custom tile graphics require ZSCustomOverworld v1+.\n"
             "Upgrade your ROM to access 8 customizable graphics sheets."));
    }
    ImGui::PopID();  // Pop GraphicsPopup ID scope
    ImGui::EndPopup();
  }
}
 
void MapPropertiesSystem::DrawPalettesPopup(int current_map, int game_state,
                                            bool& show_custom_bg_color_editor) {
  const int current_game_state = CurrentGameState(game_state);
  if (ImGui::BeginPopup(gui::MakePopupId(gui::EditorNames::kOverworld,
                                         gui::PopupNames::kPalettesPopup)
                            .c_str())) {
    ImGui::PushID("PalettesPopup");  // Fix ImGui duplicate ID warnings
 
    // Use theme-aware spacing instead of hardcoded constants
    float spacing = gui::LayoutHelpers::GetStandardSpacing();
    float padding = gui::LayoutHelpers::GetButtonPadding();
    gui::StyleVarGuard popup_style_guard(
        {{ImGuiStyleVar_ItemSpacing, ImVec2(spacing, spacing)},
         {ImGuiStyleVar_FramePadding, ImVec2(padding, padding)}});
 
    ImGui::Text(tr("Palette Settings"));
    ImGui::Separator();
 
    // Area Palette
    uint8_t area_palette =
        overworld_->overworld_map(current_map)->area_palette();
    if (gui::InputHexByte(ICON_MD_PALETTE " Area Palette", &area_palette,
                          kHexByteInputWidth)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kAreaPalette, 0, area_palette});
    }
    HOVER_HINT("Main color palette for background tiles");
 
    // Read fresh to reflect ROM upgrades
    auto rom_version_pal = zelda3::OverworldVersionHelper::GetVersion(*rom_);
    if (zelda3::OverworldVersionHelper::SupportsCustomBGColors(
            rom_version_pal)) {
      uint8_t main_palette =
          overworld_->overworld_map(current_map)->main_palette();
      if (gui::InputHexByte(ICON_MD_COLOR_LENS " Main Palette", &main_palette,
                            kHexByteInputWidth)) {
        ApplyPropertyEdit({current_map, OverworldPropertyField::kMainPalette, 0,
                           main_palette});
      }
      HOVER_HINT("Extended main palette (ZSCustomOverworld v2+)");
    }
 
    // Sprite Palette
    uint8_t sprite_palette = overworld_->overworld_map(current_map)
                                 ->sprite_palette(current_game_state);
    if (gui::InputHexByte(absl::StrFormat(ICON_MD_COLORIZE " Sprite Pal (%s)",
                                          kGameStateNames[current_game_state])
                              .c_str(),
                          &sprite_palette, kHexByteInputWidth)) {
      ApplyPropertyEdit({current_map, OverworldPropertyField::kSpritePalette,
                         current_game_state, sprite_palette});
    }
    HOVER_HINT("Color palette for sprites in current game state");
 
    ImGui::Separator();
    if (ImGui::Button(ICON_MD_FORMAT_COLOR_FILL " Custom Background Color",
                      ImVec2(-1, 0))) {
      show_custom_bg_color_editor = !show_custom_bg_color_editor;
    }
    HOVER_HINT("Open custom background color editor (v2+)");
    ImGui::PopID();  // Pop PalettesPopup ID scope
    ImGui::EndPopup();
  }
}
 
void MapPropertiesSystem::DrawPropertiesPopup(int current_map,
                                              bool& show_map_properties_panel,
                                              bool& show_overlay_preview,
                                              int& game_state) {
  if (ImGui::BeginPopup(gui::MakePopupId(gui::EditorNames::kOverworld,
                                         gui::PopupNames::kConfigPopup)
                            .c_str())) {
    ImGui::PushID("ConfigPopup");  // Fix ImGui duplicate ID warnings
 
    // Use theme-aware spacing instead of hardcoded constants
    float spacing = gui::LayoutHelpers::GetStandardSpacing();
    float padding = gui::LayoutHelpers::GetButtonPadding();
    gui::StyleVarGuard popup_style_guard(
        {{ImGuiStyleVar_ItemSpacing, ImVec2(spacing, spacing)},
         {ImGuiStyleVar_FramePadding, ImVec2(padding, padding)}});
 
    ImGui::Text(ICON_MD_TUNE " Area Configuration");
    ImGui::Separator();
 
    // Basic Properties in 2-column layout for density
    if (BeginTable("BasicProps", 2, ImGuiTableFlags_SizingFixedFit)) {
      // Message ID
      TableNextColumn();
      ImGui::Text(ICON_MD_MESSAGE " Message");
      TableNextColumn();
      uint16_t message_id =
          overworld_->overworld_map(current_map)->message_id();
      if (gui::InputHexWordCustom("##MsgId", &message_id, kHexWordInputWidth)) {
        ApplyPropertyEdit(
            {current_map, OverworldPropertyField::kMessageId, 0, message_id});
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(tr("Message ID shown when entering this area"));
      }
 
      // Game State
      TableNextColumn();
      ImGui::Text(ICON_MD_GAMEPAD " Game State");
      TableNextColumn();
      ImGui::SetNextItemWidth(kComboGameStateWidth);
      int current_game_state = CurrentGameState(game_state);
      if (ImGui::Combo("##GameState", &current_game_state, kGameStateNames,
                       3)) {
        game_state = current_game_state;
        SetCurrentGameState(current_game_state);
        RefreshMapProperties();
        RefreshOverworldMap();
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(
            tr("Affects sprite graphics/palettes based on story progress"));
      }
 
      ImGui::EndTable();
    }
 
    // Area Configuration Section
    ImGui::Separator();
    ImGui::Text(ICON_MD_ASPECT_RATIO " Area Configuration");
    ImGui::Separator();
 
    // ALL ROMs support Small/Large. Only v3+ supports Wide/Tall.
    uint8_t asm_version = (*rom_)[zelda3::OverworldCustomASMHasBeenApplied];
 
    int current_area_size =
        static_cast<int>(overworld_->overworld_map(current_map)->area_size());
    ImGui::SetNextItemWidth(kComboAreaSizeWidth);
 
    if (asm_version >= 3 && asm_version != 0xFF) {
      // v3+ ROM: Show all 4 area size options
      if (ImGui::Combo(ICON_MD_PHOTO_SIZE_SELECT_LARGE " Size",
                       &current_area_size, kAreaSizeNames, 4)) {
        ApplyPropertyEdit({current_map, OverworldPropertyField::kAreaSize, 0,
                           current_area_size});
      }
      HOVER_HINT("Map area size (1x1, 2x2, 2x1, 1x2 screens)");
    } else {
      // Vanilla/v1/v2 ROM: Show only Small/Large
      const char* limited_names[] = {"Small (1x1)", "Large (2x2)"};
      int limited_size = (current_area_size == 0 || current_area_size == 1)
                             ? current_area_size
                             : 0;
 
      if (ImGui::Combo(ICON_MD_PHOTO_SIZE_SELECT_LARGE " Size", &limited_size,
                       limited_names, 2)) {
        ApplyPropertyEdit(
            {current_map, OverworldPropertyField::kAreaSize, 0, limited_size});
      }
      HOVER_HINT("Small (1x1) and Large (2x2) maps. Wide/Tall require v3+");
    }
 
    // Visual Effects Section
    ImGui::Separator();
    ImGui::Text(ICON_MD_AUTO_FIX_HIGH " Visual Effects");
    ImGui::Separator();
 
    DrawMosaicControls(current_map);
    DrawOverlayControls(current_map, show_overlay_preview);
 
    // Advanced Options Section
    ImGui::Separator();
    if (ImGui::Button(ICON_MD_OPEN_IN_NEW " Full Configuration Panel",
                      ImVec2(-1, 0))) {
      show_map_properties_panel = true;
      ImGui::CloseCurrentPopup();
    }
    HOVER_HINT("Open detailed area configuration with all settings tabs");
 
    ImGui::PopID();  // Pop ConfigPopup ID scope
    ImGui::EndPopup();
  }
}
 
void MapPropertiesSystem::DrawBasicPropertiesTab(int current_map) {
  if (BeginTable("BasicProperties", 2,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) {
    ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed, 180);
    ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
 
    TableNextColumn();
    ImGui::Text(ICON_MD_IMAGE " Area Graphics");
    TableNextColumn();
    uint8_t area_gfx = overworld_->overworld_map(current_map)->area_graphics();
    if (gui::InputHexByte("##AreaGfx", &area_gfx, kInputFieldSize)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kAreaGraphics, 0, area_gfx});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Main tileset graphics for this map area"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_PALETTE " Area Palette");
    TableNextColumn();
    uint8_t area_pal = overworld_->overworld_map(current_map)->area_palette();
    if (gui::InputHexByte("##AreaPal", &area_pal, kInputFieldSize)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kAreaPalette, 0, area_pal});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Color palette for background tiles"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_MESSAGE " Message ID");
    TableNextColumn();
    uint16_t message_id = overworld_->overworld_map(current_map)->message_id();
    if (gui::InputHexWord("##MsgId", &message_id, kInputFieldSize + 20)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kMessageId, 0, message_id});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Message displayed when entering this area"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_BLUR_ON " Mosaic Effect");
    TableNextColumn();
    bool mosaic =
        *overworld_->mutable_overworld_map(current_map)->mutable_mosaic();
    if (ImGui::Checkbox("##mosaic", &mosaic)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kMosaic, 0, mosaic ? 1 : 0});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Enable pixelated mosaic transition effect"));
    }
 
    // Add music editing controls with icons
    TableNextColumn();
    ImGui::Text(ICON_MD_MUSIC_NOTE " Music (Beginning)");
    TableNextColumn();
    uint8_t music0 = overworld_->overworld_map(current_map)->area_music(0);
    if (gui::InputHexByte("##Music0", &music0, kInputFieldSize)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kMusic, 0, music0});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Music track before rescuing Zelda"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_MUSIC_NOTE " Music (Zelda)");
    TableNextColumn();
    uint8_t music1 = overworld_->overworld_map(current_map)->area_music(1);
    if (gui::InputHexByte("##Music1", &music1, kInputFieldSize)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kMusic, 1, music1});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Music track after rescuing Zelda"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_MUSIC_NOTE " Music (Master Sword)");
    TableNextColumn();
    uint8_t music2 = overworld_->overworld_map(current_map)->area_music(2);
    if (gui::InputHexByte("##Music2", &music2, kInputFieldSize)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kMusic, 2, music2});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Music track after obtaining Master Sword"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_MUSIC_NOTE " Music (Agahnim)");
    TableNextColumn();
    uint8_t music3 = overworld_->overworld_map(current_map)->area_music(3);
    if (gui::InputHexByte("##Music3", &music3, kInputFieldSize)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kMusic, 3, music3});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Music track after defeating Agahnim (Dark World)"));
    }
 
    ImGui::EndTable();
  }
}
 
void MapPropertiesSystem::DrawSpritePropertiesTab(int current_map) {
  if (BeginTable("SpriteProperties", 2,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) {
    ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed, 180);
    ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
 
    TableNextColumn();
    ImGui::Text(ICON_MD_GAMEPAD " Game State");
    TableNextColumn();
    int game_state = CurrentGameState();
    ImGui::SetNextItemWidth(120.f);
    if (ImGui::Combo("##GameState", &game_state, kGameStateNames, 3)) {
      SetCurrentGameState(game_state);
      RefreshMapProperties();
      RefreshOverworldMap();
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Affects which sprite graphics/palettes are used"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_PETS " Sprite Graphics 1");
    TableNextColumn();
    uint8_t sprite_gfx1 =
        overworld_->overworld_map(current_map)->sprite_graphics(1);
    if (gui::InputHexByte("##SprGfx1", &sprite_gfx1, kInputFieldSize)) {
      ApplyPropertyEdit({current_map, OverworldPropertyField::kSpriteGraphics,
                         1, sprite_gfx1});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("First sprite graphics sheet for Zelda rescued state"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_PETS " Sprite Graphics 2");
    TableNextColumn();
    uint8_t sprite_gfx2 =
        overworld_->overworld_map(current_map)->sprite_graphics(2);
    if (gui::InputHexByte("##SprGfx2", &sprite_gfx2, kInputFieldSize)) {
      ApplyPropertyEdit({current_map, OverworldPropertyField::kSpriteGraphics,
                         2, sprite_gfx2});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Second sprite graphics sheet for Master Sword obtained state"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_COLORIZE " Sprite Palette 1");
    TableNextColumn();
    uint8_t sprite_pal1 =
        overworld_->overworld_map(current_map)->sprite_palette(1);
    if (gui::InputHexByte("##SprPal1", &sprite_pal1, kInputFieldSize)) {
      ApplyPropertyEdit({current_map, OverworldPropertyField::kSpritePalette, 1,
                         sprite_pal1});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Color palette for sprites - Zelda rescued state"));
    }
 
    TableNextColumn();
    ImGui::Text(ICON_MD_COLORIZE " Sprite Palette 2");
    TableNextColumn();
    uint8_t sprite_pal2 =
        overworld_->overworld_map(current_map)->sprite_palette(2);
    if (gui::InputHexByte("##SprPal2", &sprite_pal2, kInputFieldSize)) {
      ApplyPropertyEdit({current_map, OverworldPropertyField::kSpritePalette, 2,
                         sprite_pal2});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Color palette for sprites - Master Sword obtained state"));
    }
 
    ImGui::EndTable();
  }
}
 
void MapPropertiesSystem::DrawCustomFeaturesTab(int current_map) {
  if (BeginTable("CustomFeatures", 2,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) {
    ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed, 180);
    ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
 
    TableNextColumn();
    ImGui::Text(ICON_MD_PHOTO_SIZE_SELECT_LARGE " Area Size");
    TableNextColumn();
    // ALL ROMs support Small/Large. Only v3+ supports Wide/Tall.
    auto rom_version_basic = zelda3::OverworldVersionHelper::GetVersion(*rom_);
 
    int current_area_size =
        static_cast<int>(overworld_->overworld_map(current_map)->area_size());
    ImGui::SetNextItemWidth(130.f);
 
    if (zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version_basic)) {
      // v3+ ROM: Show all 4 area size options
      static const char* all_sizes[] = {"Small (1x1)", "Large (2x2)",
                                        "Wide (2x1)", "Tall (1x2)"};
      if (ImGui::Combo("##AreaSize", &current_area_size, all_sizes, 4)) {
        ApplyPropertyEdit({current_map, OverworldPropertyField::kAreaSize, 0,
                           current_area_size});
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(
            tr("Map size: Small (1x1), Large (2x2), Wide (2x1), Tall (1x2)"));
      }
    } else {
      // Vanilla/v1/v2 ROM: Show only Small/Large
      static const char* limited_sizes[] = {"Small (1x1)", "Large (2x2)"};
      int limited_size = (current_area_size == 0 || current_area_size == 1)
                             ? current_area_size
                             : 0;
 
      if (ImGui::Combo("##AreaSize", &limited_size, limited_sizes, 2)) {
        auto size = (limited_size == 1) ? zelda3::AreaSizeEnum::LargeArea
                                        : zelda3::AreaSizeEnum::SmallArea;
        ApplyPropertyEdit({current_map, OverworldPropertyField::kAreaSize, 0,
                           static_cast<int>(size)});
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(
            tr("Map size: Small (1x1), Large (2x2). Wide/Tall require v3+"));
      }
    }
 
    if (zelda3::OverworldVersionHelper::SupportsCustomBGColors(
            rom_version_basic)) {
      TableNextColumn();
      ImGui::Text(ICON_MD_COLOR_LENS " Main Palette");
      TableNextColumn();
      uint8_t main_palette =
          overworld_->overworld_map(current_map)->main_palette();
      if (gui::InputHexByte("##MainPal", &main_palette, kInputFieldSize)) {
        ApplyPropertyEdit({current_map, OverworldPropertyField::kMainPalette, 0,
                           main_palette});
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(tr("Extended main palette (ZSCustomOverworld v2+)"));
      }
    }
 
    if (zelda3::OverworldVersionHelper::SupportsAnimatedGFX(
            rom_version_basic)) {
      TableNextColumn();
      ImGui::Text(ICON_MD_ANIMATION " Animated GFX");
      TableNextColumn();
      uint8_t animated_gfx =
          overworld_->overworld_map(current_map)->animated_gfx();
      if (gui::InputHexByte("##AnimGfx", &animated_gfx, kInputFieldSize)) {
        ApplyPropertyEdit({current_map,
                           OverworldPropertyField::kAnimatedGraphics, 0,
                           animated_gfx});
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(tr("Animated tile graphics ID (water, lava, etc.)"));
      }
 
      TableNextColumn();
      ImGui::Text(ICON_MD_LAYERS " Subscreen Overlay");
      TableNextColumn();
      uint16_t subscreen_overlay =
          overworld_->overworld_map(current_map)->subscreen_overlay();
      if (gui::InputHexWord("##SubOverlay", &subscreen_overlay,
                            kInputFieldSize + 20)) {
        ApplyPropertyEdit({current_map,
                           OverworldPropertyField::kSubscreenOverlay, 0,
                           subscreen_overlay});
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(
            tr("Visual effects overlay ID (fog, rain, backgrounds)"));
      }
    }
 
    ImGui::EndTable();
  }
}
 
void MapPropertiesSystem::DrawTileGraphicsTab(int current_map) {
  auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
 
  // Only show custom tile graphics for v1+ ROMs
  if (zelda3::OverworldVersionHelper::SupportsExpandedSpace(rom_version)) {
    ImGui::Text(ICON_MD_GRID_VIEW " Custom Tile Graphics (8 sheets)");
    Separator();
 
    if (BeginTable("TileGraphics", 2,
                   ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) {
      ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed,
                              180);
      ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
 
      for (int i = 0; i < 8; i++) {
        TableNextColumn();
        ImGui::Text(ICON_MD_LAYERS " Sheet %d", i);
        TableNextColumn();
        uint8_t custom_tileset =
            overworld_->overworld_map(current_map)->custom_tileset(i);
        if (gui::InputHexByte(absl::StrFormat("##TileGfx%d", i).c_str(),
                              &custom_tileset, kInputFieldSize)) {
          ApplyPropertyEdit({current_map,
                             OverworldPropertyField::kCustomTileset, i,
                             custom_tileset});
        }
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip(tr("Custom graphics sheet %d (0x00-0xFF)"), i);
        }
      }
 
      ImGui::EndTable();
    }
 
    Separator();
    ImGui::TextWrapped(
        tr("These 8 sheets allow custom tile graphics per map. "
           "Each sheet references a graphics ID loaded into VRAM."));
  } else {
    // Vanilla ROM - show info message
    ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f),
                       ICON_MD_INFO " Custom Tile Graphics");
    ImGui::Separator();
    ImGui::TextWrapped(
        tr("Custom tile graphics are not available in vanilla ROMs.\n\n"
           "To enable this feature, upgrade your ROM to ZSCustomOverworld v1+, "
           "which provides 8 customizable graphics sheets per map for advanced "
           "tileset customization."));
  }
}
 
void MapPropertiesSystem::DrawMusicTab(int current_map) {
  ImGui::Text(ICON_MD_MUSIC_NOTE " Music Settings for Game States");
  Separator();
 
  if (BeginTable("MusicSettings", 2,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) {
    ImGui::TableSetupColumn("Game State", ImGuiTableColumnFlags_WidthFixed,
                            220);
    ImGui::TableSetupColumn("Music Track ID",
                            ImGuiTableColumnFlags_WidthStretch);
 
    const char* music_state_names[] = {
        ICON_MD_PLAY_ARROW " Beginning (Pre-Zelda)",
        ICON_MD_FAVORITE " Zelda Rescued",
        ICON_MD_OFFLINE_BOLT " Master Sword Obtained",
        ICON_MD_CASTLE " Agahnim Defeated"};
 
    const char* music_descriptions[] = {
        "Music before rescuing Zelda from the castle",
        "Music after rescuing Zelda from Hyrule Castle",
        "Music after obtaining the Master Sword from the Lost Woods",
        "Music after defeating Agahnim (Dark World music)"};
 
    for (int i = 0; i < 4; i++) {
      TableNextColumn();
      ImGui::Text("%s", music_state_names[i]);
 
      TableNextColumn();
      uint8_t music = overworld_->overworld_map(current_map)->area_music(i);
      if (gui::InputHexByte(absl::StrFormat("##Music%d", i).c_str(), &music,
                            kInputFieldSize)) {
        ApplyPropertyEdit(
            {current_map, OverworldPropertyField::kMusic, i, music});
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip("%s", music_descriptions[i]);
      }
    }
 
    ImGui::EndTable();
  }
 
  Separator();
  ImGui::TextWrapped(
      tr("Music tracks control the background music for different "
         "game progression states on this overworld map."));
 
  // Show common music track IDs for reference in a collapsing section
  Separator();
  if (ImGui::CollapsingHeader(ICON_MD_HELP_OUTLINE " Common Music Track IDs",
                              ImGuiTreeNodeFlags_DefaultOpen)) {
    ImGui::Indent();
    ImGui::BulletText(tr("0x02 - Overworld Theme"));
    ImGui::BulletText(tr("0x05 - Kakariko Village"));
    ImGui::BulletText(tr("0x07 - Lost Woods"));
    ImGui::BulletText(tr("0x09 - Dark World Theme"));
    ImGui::BulletText(tr("0x0F - Ganon's Tower"));
    ImGui::BulletText(tr("0x11 - Death Mountain"));
    ImGui::Unindent();
  }
}
 
absl::Status MapPropertiesSystem::ApplyPropertyEdit(
    const OverworldPropertyEdit& edit) {
  if (property_edit_callback_) {
    return property_edit_callback_(edit);
  }
  return ApplyPropertyEditDirect(edit);
}
 
absl::Status MapPropertiesSystem::ApplyPropertyEdits(
    const std::vector<OverworldPropertyEdit>& edits,
    const std::string& description) {
  if (property_edit_batch_callback_) {
    return property_edit_batch_callback_(edits, description);
  }
  for (const auto& edit : edits) {
    if (!CheckPropertyEditSupported(edit).ok()) {
      continue;
    }
    RETURN_IF_ERROR(ApplyPropertyEdit(edit));
  }
  return absl::OkStatus();
}
 
absl::Status MapPropertiesSystem::CheckPropertyEditSupported(
    const OverworldPropertyEdit& edit) const {
  return CheckFieldSupported(rom_, edit);
}
 
absl::StatusOr<int> MapPropertiesSystem::ReadPropertyValue(
    const OverworldPropertyEdit& edit) const {
  if (!overworld_) {
    return absl::FailedPreconditionError("Overworld is not available");
  }
  const int map_id = EffectivePropertyMapId(
      const_cast<zelda3::Overworld*>(overworld_), edit.map_id);
  if (!IsValidMapId(map_id)) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Invalid overworld map: %d", edit.map_id));
  }
  const auto* map = overworld_->overworld_map(map_id);
  if (!map) {
    return absl::NotFoundError(
        absl::StrFormat("Overworld map 0x%02X is unavailable", map_id));
  }
 
  switch (edit.field) {
    case OverworldPropertyField::kAreaSize:
      return static_cast<int>(map->area_size());
    case OverworldPropertyField::kAreaGraphics:
      return map->area_graphics();
    case OverworldPropertyField::kAreaPalette:
      return map->area_palette();
    case OverworldPropertyField::kMainPalette:
      return map->main_palette();
    case OverworldPropertyField::kSpriteGraphics:
      return map->sprite_graphics(std::clamp(edit.index, 0, 2));
    case OverworldPropertyField::kSpritePalette:
      return map->sprite_palette(std::clamp(edit.index, 0, 2));
    case OverworldPropertyField::kAnimatedGraphics:
      return map->animated_gfx();
    case OverworldPropertyField::kCustomTileset:
      return map->custom_tileset(std::clamp(edit.index, 0, 7));
    case OverworldPropertyField::kMessageId:
      return map->message_id();
    case OverworldPropertyField::kMusic:
      return map->area_music(std::clamp(edit.index, 0, 3));
    case OverworldPropertyField::kMosaic:
      return *const_cast<zelda3::OverworldMap*>(map)->mutable_mosaic() ? 1 : 0;
    case OverworldPropertyField::kMosaicExpanded:
      return map->mosaic_expanded()[std::clamp(edit.index, 0, 3)] ? 1 : 0;
    case OverworldPropertyField::kAreaSpecificBgColor:
      return map->area_specific_bg_color();
    case OverworldPropertyField::kSubscreenOverlay:
      return map->subscreen_overlay();
  }
  return absl::InvalidArgumentError("Unknown overworld property field");
}
 
absl::Status MapPropertiesSystem::ApplyPropertyEditDirect(
    const OverworldPropertyEdit& edit) {
  if (!overworld_ || !rom_) {
    return absl::FailedPreconditionError(
        "Overworld property editing requires loaded overworld data and ROM");
  }
  const int map_id = EffectivePropertyMapId(overworld_, edit.map_id);
  if (!IsValidMapId(map_id)) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Invalid overworld map: %d", edit.map_id));
  }
  auto* map = overworld_->mutable_overworld_map(map_id);
  if (!map) {
    return absl::NotFoundError(
        absl::StrFormat("Overworld map 0x%02X is unavailable", map_id));
  }
 
  const absl::Status supported = CheckFieldSupported(rom_, edit);
  if (!supported.ok()) {
    return supported;
  }
 
  const int game_state = std::clamp(edit.index, 0, 2);
  switch (edit.field) {
    case OverworldPropertyField::kAreaSize: {
      const auto size = static_cast<zelda3::AreaSizeEnum>(edit.value);
      auto status = overworld_->ConfigureMultiAreaMap(map_id, size);
      if (!status.ok()) {
        return status;
      }
      RefreshSiblingMapGraphics(map_id, true);
      RefreshOverworldMap();
      break;
    }
    case OverworldPropertyField::kAreaGraphics:
      map->set_area_graphics(static_cast<uint8_t>(edit.value));
      RefreshMapProperties();
      if (maps_bmp_) {
        (*maps_bmp_)[map_id].set_modified(true);
      }
      PrepareMapForGraphicsRefresh(map_id);
      map->LoadAreaGraphics();
      RefreshSiblingMapGraphics(map_id);
      RefreshTile16Blockset();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kAreaPalette:
      map->set_area_palette(static_cast<uint8_t>(edit.value));
      RefreshMapProperties();
      RefreshMapPalette();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kMainPalette:
      map->set_main_palette(static_cast<uint8_t>(edit.value));
      RefreshMapProperties();
      RefreshMapPalette();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kSpriteGraphics:
      map->set_sprite_graphics(game_state, static_cast<uint8_t>(edit.value));
      ForceRefreshGraphics(map_id);
      RefreshMapProperties();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kSpritePalette:
      map->set_sprite_palette(game_state, static_cast<uint8_t>(edit.value));
      RefreshMapProperties();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kAnimatedGraphics:
      map->set_animated_gfx(static_cast<uint8_t>(edit.value));
      ForceRefreshGraphics(map_id);
      RefreshMapProperties();
      RefreshTile16Blockset();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kCustomTileset: {
      const int slot = std::clamp(edit.index, 0, 7);
      map->set_custom_tileset(slot, static_cast<uint8_t>(edit.value));
      PrepareMapForGraphicsRefresh(map_id);
      map->LoadAreaGraphics();
      ForceRefreshGraphics(map_id);
      RefreshSiblingMapGraphics(map_id);
      RefreshMapProperties();
      RefreshTile16Blockset();
      RefreshOverworldMap();
      break;
    }
    case OverworldPropertyField::kMessageId:
      map->set_message_id(static_cast<uint16_t>(edit.value));
      RefreshMapProperties();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kMusic: {
      const int music_state = std::clamp(edit.index, 0, 3);
      *map->mutable_area_music(music_state) = static_cast<uint8_t>(edit.value);
      WriteRomByteIfValid(rom_, MusicRomAddressForMapState(map_id, music_state),
                          static_cast<uint8_t>(edit.value));
      RefreshMapProperties();
      break;
    }
    case OverworldPropertyField::kMosaic:
      *map->mutable_mosaic() = edit.value != 0;
      RefreshMapProperties();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kMosaicExpanded:
      map->set_mosaic_expanded(std::clamp(edit.index, 0, 3), edit.value != 0);
      RefreshMapProperties();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kAreaSpecificBgColor:
      map->set_area_specific_bg_color(static_cast<uint16_t>(edit.value));
      WriteRomWordIfValid(
          rom_, zelda3::OverworldCustomAreaSpecificBGPalette + (map_id * 2),
          static_cast<uint16_t>(edit.value));
      RefreshMapProperties();
      RefreshOverworldMap();
      break;
    case OverworldPropertyField::kSubscreenOverlay:
      map->set_subscreen_overlay(static_cast<uint16_t>(edit.value));
      WriteRomWordIfValid(
          rom_, zelda3::OverworldCustomSubscreenOverlayArray + (map_id * 2),
          static_cast<uint16_t>(edit.value));
      RefreshMapProperties();
      RefreshOverworldMap();
      break;
  }
 
  rom_->set_dirty(true);
  return absl::OkStatus();
}
 
void MapPropertiesSystem::RefreshMapProperties() {
  if (refresh_map_properties_) {
    refresh_map_properties_();
  }
}
 
void MapPropertiesSystem::RefreshOverworldMap() {
  if (refresh_overworld_map_) {
    refresh_overworld_map_();
  }
}
 
absl::Status MapPropertiesSystem::RefreshMapPalette() {
  if (refresh_map_palette_) {
    return refresh_map_palette_();
  }
  return absl::OkStatus();
}
 
absl::Status MapPropertiesSystem::RefreshTile16Blockset() {
  if (refresh_tile16_blockset_) {
    return refresh_tile16_blockset_();
  }
  return absl::OkStatus();
}
 
void MapPropertiesSystem::ForceRefreshGraphics(int map_index) {
  if (force_refresh_graphics_) {
    force_refresh_graphics_(map_index);
  }
}
 
void MapPropertiesSystem::RefreshSiblingMapGraphics(int map_index,
                                                    bool include_self) {
  if (!overworld_ || !maps_bmp_ || map_index < 0 ||
      map_index >= zelda3::kNumOverworldMaps) {
    return;
  }
 
  auto* map = overworld_->mutable_overworld_map(map_index);
  if (map->area_size() == zelda3::AreaSizeEnum::SmallArea) {
    return;  // No siblings for small areas
  }
 
  int parent_id = map->parent();
  std::vector<int> siblings;
 
  switch (map->area_size()) {
    case zelda3::AreaSizeEnum::LargeArea:
      siblings = {parent_id, parent_id + 1, parent_id + 8, parent_id + 9};
      break;
    case zelda3::AreaSizeEnum::WideArea:
      siblings = {parent_id, parent_id + 1};
      break;
    case zelda3::AreaSizeEnum::TallArea:
      siblings = {parent_id, parent_id + 8};
      break;
    default:
      return;
  }
 
  for (int sibling : siblings) {
    if (sibling >= 0 && sibling < zelda3::kNumOverworldMaps) {
      // Skip self unless include_self is true
      if (sibling == map_index && !include_self) {
        continue;
      }
 
      // Mark as modified FIRST
      (*maps_bmp_)[sibling].set_modified(true);
 
      // Load graphics from ROM
      PrepareMapForGraphicsRefresh(sibling);
      overworld_->mutable_overworld_map(sibling)->LoadAreaGraphics();
 
      // CRITICAL FIX: Force immediate refresh on the sibling
      // This will trigger the callback to OverworldEditor's
      // RefreshChildMapOnDemand
      ForceRefreshGraphics(sibling);
    }
  }
 
  // After marking all siblings, trigger a refresh
  // This ensures all marked maps get processed
  RefreshOverworldMap();
}
 
void MapPropertiesSystem::DrawMosaicControls(int current_map) {
  auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
  if (zelda3::OverworldVersionHelper::SupportsCustomBGColors(rom_version)) {
    ImGui::Separator();
    ImGui::Text(tr("Mosaic Effects (per direction):"));
 
    auto* current_map_ptr = overworld_->mutable_overworld_map(current_map);
    std::array<bool, 4> mosaic_expanded = current_map_ptr->mosaic_expanded();
    const char* direction_names[] = {"North", "South", "East", "West"};
 
    for (int i = 0; i < 4; i++) {
      if (ImGui::Checkbox(direction_names[i], &mosaic_expanded[i])) {
        ApplyPropertyEdit({current_map, OverworldPropertyField::kMosaicExpanded,
                           i, mosaic_expanded[i] ? 1 : 0});
      }
    }
  } else {
    bool mosaic =
        *overworld_->mutable_overworld_map(current_map)->mutable_mosaic();
    if (ImGui::Checkbox(tr("Mosaic Effect"), &mosaic)) {
      ApplyPropertyEdit(
          {current_map, OverworldPropertyField::kMosaic, 0, mosaic ? 1 : 0});
    }
  }
}
 
void MapPropertiesSystem::DrawOverlayControls(int current_map,
                                              bool& show_overlay_preview) {
  auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
 
  // Determine if this is a special overworld map (0x80-0x9F)
  bool is_special_overworld_map = (current_map >= 0x80 && current_map < 0xA0);
 
  if (is_special_overworld_map) {
    // Special overworld maps (0x80-0x9F) serve as visual effect sources
    ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
                       ICON_MD_INFO " Special Area Map (0x%02X)", current_map);
    ImGui::Separator();
    ImGui::TextWrapped(tr(
        "This is a special area map (0x80-0x9F) used as a visual effect "
        "source. These maps provide the graphics data for subscreen overlays "
        "like fog, rain, forest canopy, and sky backgrounds that appear on "
        "normal maps (0x00-0x7F)."));
    ImGui::Spacing();
    ImGui::TextWrapped(tr(
        "You can edit the tile16 data here to customize how the visual effects "
        "appear when referenced by other maps."));
  } else {
    // Light World (0x00-0x3F) and Dark World (0x40-0x7F) maps support subscreen
    // overlays
 
    // Comprehensive help section
    ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
                       ICON_MD_HELP_OUTLINE " Visual Effects Overview");
    ImGui::SameLine();
    if (ImGui::Button(ICON_MD_INFO "##HelpButton")) {
      ImGui::OpenPopup(gui::MakePopupId(gui::EditorNames::kOverworld,
                                        gui::PopupNames::kOverlayTypesHelp)
                           .c_str());
    }
 
    if (ImGui::BeginPopup(gui::MakePopupId(gui::EditorNames::kOverworld,
                                           gui::PopupNames::kOverlayTypesHelp)
                              .c_str())) {
      ImGui::Text(ICON_MD_HELP " Understanding Overlay Types");
      ImGui::Separator();
 
      ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f), ICON_MD_LAYERS
                         " 1. Subscreen Overlays (Visual Effects)");
      ImGui::Indent();
      ImGui::BulletText(tr("Displayed as semi-transparent layers"));
      ImGui::BulletText(tr("Reference special area maps (0x80-0x9F)"));
      ImGui::BulletText(tr("Examples: fog, rain, forest canopy, sky"));
      ImGui::BulletText(tr("Purely visual - don't affect collision"));
      ImGui::Unindent();
 
      ImGui::Spacing();
      ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
                         ICON_MD_EDIT_NOTE " 2. Map Overlays (Interactive)");
      ImGui::Indent();
      ImGui::BulletText(tr("Dynamic tile16 changes on the map"));
      ImGui::BulletText(tr("Used for bridges appearing, holes opening"));
      ImGui::BulletText(tr("Stored as tile16 ID arrays"));
      ImGui::BulletText(tr("Affect collision and interaction"));
      ImGui::BulletText(tr("Triggered by game events/progression"));
      ImGui::Unindent();
 
      ImGui::Separator();
      ImGui::TextWrapped(
          tr("Note: Subscreen overlays are what you configure here. "
             "Map overlays are event-driven and edited separately."));
 
      ImGui::EndPopup();
    }
    ImGui::Separator();
 
    // Subscreen Overlay Section
    ImGui::Text(ICON_MD_LAYERS " Subscreen Overlay (Visual Effects)");
 
    uint16_t current_overlay =
        overworld_->overworld_map(current_map)->subscreen_overlay();
    if (gui::InputHexWord("Visual Effect Map ID", &current_overlay,
                          kInputFieldSize + 20)) {
      ApplyPropertyEdit({current_map, OverworldPropertyField::kSubscreenOverlay,
                         0, current_overlay});
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("References a special area map (0x80-0x9F) for visual effects.\n"
             "The referenced map's tile16 data is drawn as a semi-transparent\n"
             "layer on top of or behind this area for atmospheric effects."));
    }
 
    // Show subscreen overlay description with color coding
    std::string overlay_desc = GetOverlayDescription(current_overlay);
    if (current_overlay == 0x00FF) {
      ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), ICON_MD_CHECK " %s",
                         overlay_desc.c_str());
    } else if (current_overlay >= 0x80 && current_overlay < 0xA0) {
      ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f),
                         ICON_MD_VISIBILITY " %s", overlay_desc.c_str());
    } else {
      ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
                         ICON_MD_HELP_OUTLINE " %s", overlay_desc.c_str());
    }
 
    // Preview checkbox with better labeling
    ImGui::Spacing();
    if (ImGui::Checkbox(ICON_MD_PREVIEW " Preview Visual Effect on Map",
                        &show_overlay_preview)) {
      // Toggle subscreen overlay preview
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr(
          "Shows a semi-transparent preview of the visual effect overlay\n"
          "drawn on top of the current map in the editor canvas.\n\n"
          "This preview shows how the subscreen overlay will appear in-game."));
    }
 
    ImGui::Separator();
 
    // Interactive/Dynamic Map Overlay Section (for vanilla ROMs)
    if (rom_version == zelda3::OverworldVersion::kVanilla) {
      ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
                         ICON_MD_EDIT_NOTE " Map Overlay (Interactive)");
      ImGui::SameLine();
      if (ImGui::Button(ICON_MD_INFO "##MapOverlayHelp")) {
        ImGui::OpenPopup(
            gui::MakePopupId(gui::EditorNames::kOverworld,
                             gui::PopupNames::kInteractiveOverlayHelp)
                .c_str());
      }
      if (ImGui::BeginPopup(
              gui::MakePopupId(gui::EditorNames::kOverworld,
                               gui::PopupNames::kInteractiveOverlayHelp)
                  .c_str())) {
        ImGui::Text(ICON_MD_HELP " Map Overlays (Interactive Tile Changes)");
        ImGui::Separator();
        ImGui::TextWrapped(
            tr("Map overlays are different from visual effect overlays. "
               "They contain tile16 data that dynamically replaces tiles on "
               "the map based on game events or progression."));
        ImGui::Spacing();
        ImGui::Text(tr("Common uses:"));
        ImGui::BulletText(tr("Bridges appearing over water"));
        ImGui::BulletText(tr("Holes revealing secret passages"));
        ImGui::BulletText(tr("Rocks/bushes being moved"));
        ImGui::BulletText(tr("Environmental changes from story events"));
        ImGui::Spacing();
        ImGui::TextWrapped(
            tr("These are triggered by game code and stored as separate "
               "tile data arrays in the ROM. ZSCustomOverworld v3+ provides "
               "extended control over these features."));
        ImGui::EndPopup();
      }
 
      auto* current_map_ptr = overworld_->overworld_map(current_map);
      ImGui::Spacing();
      if (current_map_ptr->has_overlay()) {
        ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f),
                           ICON_MD_CHECK " Overlay ID: 0x%04X",
                           current_map_ptr->overlay_id());
        ImGui::Text(ICON_MD_STORAGE " Data Size: %d bytes",
                    static_cast<int>(current_map_ptr->overlay_data().size()));
        ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.4f, 1.0f),
                           ICON_MD_INFO " Read-only in vanilla ROM");
      } else {
        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f),
                           ICON_MD_BLOCK " No map overlay data for this area");
      }
    }
 
    // Show version and capability info
    ImGui::Separator();
    if (rom_version == zelda3::OverworldVersion::kVanilla) {
      ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f),
                         ICON_MD_INFO " Vanilla ROM");
      ImGui::BulletText(tr("Visual effects use maps 0x80-0x9F"));
      ImGui::BulletText(tr("Map overlays are read-only"));
    } else {
      const char* version_name =
          zelda3::OverworldVersionHelper::GetVersionName(rom_version);
      ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f), ICON_MD_UPGRADE " %s",
                         version_name);
      ImGui::BulletText(tr("Enhanced visual effect control"));
      if (zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version)) {
        ImGui::BulletText(tr("Extended overlay system"));
        ImGui::BulletText(tr("Custom area sizes support"));
      }
    }
  }
}
 
std::string MapPropertiesSystem::GetOverlayDescription(uint16_t overlay_id) {
  if (overlay_id == 0x0093) {
    return "Triforce Room Curtain";
  } else if (overlay_id == 0x0094) {
    return "Under the Bridge";
  } else if (overlay_id == 0x0095) {
    return "Sky Background (LW Death Mountain)";
  } else if (overlay_id == 0x0096) {
    return "Pyramid Background";
  } else if (overlay_id == 0x0097) {
    return "First Fog Overlay (Master Sword Area)";
  } else if (overlay_id == 0x009C) {
    return "Lava Background (DW Death Mountain)";
  } else if (overlay_id == 0x009D) {
    return "Second Fog Overlay (Lost Woods/Skull Woods)";
  } else if (overlay_id == 0x009E) {
    return "Tree Canopy (Forest)";
  } else if (overlay_id == 0x009F) {
    return "Rain Effect (Misery Mire)";
  } else if (overlay_id == 0x00FF) {
    return "No Overlay";
  } else {
    return "Custom overlay";
  }
}
 
void MapPropertiesSystem::DrawOverlayPreviewOnMap(int current_map,
                                                  int current_world,
                                                  bool show_overlay_preview) {
  gfx::ScopedTimer timer("map_properties_draw_overlay_preview");
 
  if (!show_overlay_preview || !maps_bmp_ || !canvas_)
    return;
 
  // Get subscreen overlay information based on ROM version and map type
  uint16_t overlay_id = 0x00FF;
  bool has_subscreen_overlay = false;
 
  bool is_special_overworld_map = (current_map >= 0x80 && current_map < 0xA0);
 
  if (is_special_overworld_map) {
    // Special overworld maps (0x80-0x9F) do not support subscreen overlays
    return;
  }
 
  // Light World (0x00-0x3F) and Dark World (0x40-0x7F) maps support subscreen
  // overlays for all versions
  overlay_id = overworld_->overworld_map(current_map)->subscreen_overlay();
  has_subscreen_overlay = (overlay_id != 0x00FF);
 
  if (!has_subscreen_overlay)
    return;
 
  // Map subscreen overlay ID to special area map for bitmap
  int overlay_map_index = -1;
  if (overlay_id >= 0x80 && overlay_id < 0xA0) {
    overlay_map_index = overlay_id;
  }
 
  if (overlay_map_index < 0 || overlay_map_index >= zelda3::kNumOverworldMaps)
    return;
 
  // Get the subscreen overlay map's bitmap
  const auto& overlay_bitmap = (*maps_bmp_)[overlay_map_index];
  if (!overlay_bitmap.is_active() || !overlay_bitmap.texture())
    return;
 
  // Calculate position for subscreen overlay preview on the current map
  int current_map_x = current_map % 8;
  int current_map_y = current_map / 8;
  if (current_world == 1) {
    current_map_x = (current_map - 0x40) % 8;
    current_map_y = (current_map - 0x40) / 8;
  } else if (current_world == 2) {
    current_map_x = (current_map - 0x80) % 8;
    current_map_y = (current_map - 0x80) / 8;
  }
 
  int scale = static_cast<int>(canvas_->global_scale());
  int map_x = current_map_x * kOverworldMapSize * scale;
  int map_y = current_map_y * kOverworldMapSize * scale;
 
  // Determine if this is a background or foreground subscreen overlay
  bool is_background_overlay =
      (overlay_id == 0x0095 || overlay_id == 0x0096 || overlay_id == 0x009C);
 
  // Set alpha for semi-transparent preview
  ImU32 overlay_color =
      is_background_overlay ? IM_COL32(255, 255, 255, 128)
                            :  // Background subscreen overlays - lighter
          IM_COL32(255, 255, 255,
                   180);  // Foreground subscreen overlays - more opaque
 
  // Draw the subscreen overlay bitmap with semi-transparency
  canvas_->draw_list()->AddImage(
      (ImTextureID)(intptr_t)overlay_bitmap.texture(), ImVec2(map_x, map_y),
      ImVec2(map_x + kOverworldMapSize * scale,
             map_y + kOverworldMapSize * scale),
      ImVec2(0, 0), ImVec2(1, 1), overlay_color);
}
 
void MapPropertiesSystem::DrawViewPopup() {
  if (ImGui::BeginPopup(gui::MakePopupId(gui::EditorNames::kOverworld,
                                         gui::PopupNames::kViewPopup)
                            .c_str())) {
    ImGui::PushID("ViewPopup");  // Fix ImGui duplicate ID warnings
 
    // Use theme-aware spacing instead of hardcoded constants
    float spacing = gui::LayoutHelpers::GetStandardSpacing();
    float padding = gui::LayoutHelpers::GetButtonPadding();
    gui::StyleVarGuard popup_style_guard(
        {{ImGuiStyleVar_ItemSpacing, ImVec2(spacing, spacing)},
         {ImGuiStyleVar_FramePadding, ImVec2(padding, padding)}});
 
    ImGui::Text(tr("View Controls"));
    ImGui::Separator();
 
    // Horizontal layout for view controls
    if (ImGui::Button(ICON_MD_ZOOM_OUT, ImVec2(kIconButtonWidth, 0))) {
      float new_scale = std::max(kOverworldMinZoom,
                                 canvas_->global_scale() - kOverworldZoomStep);
      canvas_->set_global_scale(new_scale);
    }
    HOVER_HINT("Zoom out on the canvas");
    ImGui::SameLine();
    if (ImGui::Button(ICON_MD_ZOOM_IN, ImVec2(kIconButtonWidth, 0))) {
      float new_scale = std::min(kOverworldMaxZoom,
                                 canvas_->global_scale() + kOverworldZoomStep);
      canvas_->set_global_scale(new_scale);
    }
    HOVER_HINT("Zoom in on the canvas");
    ImGui::SameLine();
    if (ImGui::Button(ICON_MD_OPEN_IN_FULL, ImVec2(kIconButtonWidth, 0))) {
      canvas_->set_global_scale(1.0f);
    }
    HOVER_HINT("Reset zoom to 100%");
 
    ImGui::PopID();  // Pop ViewPopup ID scope
    ImGui::EndPopup();
  }
}
 
void MapPropertiesSystem::DrawQuickAccessPopup() {
  if (ImGui::BeginPopup(gui::MakePopupId(gui::EditorNames::kOverworld,
                                         gui::PopupNames::kQuickPopup)
                            .c_str())) {
    ImGui::PushID("QuickPopup");  // Fix ImGui duplicate ID warnings
 
    // Use theme-aware spacing instead of hardcoded constants
    float spacing = gui::LayoutHelpers::GetStandardSpacing();
    float padding = gui::LayoutHelpers::GetButtonPadding();
    gui::StyleVarGuard popup_style_guard(
        {{ImGuiStyleVar_ItemSpacing, ImVec2(spacing, spacing)},
         {ImGuiStyleVar_FramePadding, ImVec2(padding, padding)}});
 
    ImGui::Text(tr("Quick Access"));
    ImGui::Separator();
 
    // Horizontal layout for quick access buttons
    if (ImGui::Button(ICON_MD_GRID_VIEW, ImVec2(kIconButtonWidth, 0))) {
      // This would need to be connected to the Tile16 editor toggle
      // For now, just show the option
    }
    HOVER_HINT("Open Tile16 Editor (Ctrl+T)");
    ImGui::SameLine();
 
    if (ImGui::Button(ICON_MD_CONTENT_COPY, ImVec2(kIconButtonWidth, 0))) {
      // This would need to be connected to the copy map function
      // For now, just show the option
    }
    HOVER_HINT("Copy current map to clipboard");
    ImGui::SameLine();
 
    if (ImGui::Button(ICON_MD_LOCK, ImVec2(kIconButtonWidth, 0))) {
      // This would need to be connected to the map lock toggle
      // For now, just show the option
    }
    HOVER_HINT("Lock/unlock current map (Ctrl+L)");
 
    ImGui::PopID();  // Pop QuickPopup ID scope
    ImGui::EndPopup();
  }
}
 
}  // namespace editor
}  // namespace yaze