palette_manager.cc

Go to the documentation of this file.

#include "palette_manager.h"
 
#include <algorithm>
#include <chrono>
#include <map>
#include <set>
#include <stdexcept>
#include <tuple>
 
#include "absl/strings/str_format.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/types/snes_palette_layout.h"
#include "rom/rom.h"
#include "util/macro.h"
#include "zelda3/game_data.h"
 
namespace yaze {
namespace gfx {
 
namespace {
 
std::vector<std::pair<uint32_t, uint32_t>> CoalescePaletteWriteRanges(
    std::vector<std::pair<uint32_t, uint32_t>> ranges) {
  std::sort(ranges.begin(), ranges.end());
  std::vector<std::pair<uint32_t, uint32_t>> coalesced;
  coalesced.reserve(ranges.size());
  for (const auto& range : ranges) {
    if (coalesced.empty() || coalesced.back().second < range.first) {
      coalesced.push_back(range);
      continue;
    }
    coalesced.back().second = std::max(coalesced.back().second, range.second);
  }
  return coalesced;
}
 
}  // namespace
 
PaletteManager::SessionState* PaletteManager::CurrentState() {
  if (!game_data_) {
    return &unbound_state_;
  }
  return &session_states_.try_emplace(game_data_).first->second;
}
 
const PaletteManager::SessionState* PaletteManager::CurrentState() const {
  if (!game_data_) {
    return &unbound_state_;
  }
  auto it = session_states_.find(game_data_);
  return it == session_states_.end() ? &unbound_state_ : &it->second;
}
 
const PaletteManager::SessionState* PaletteManager::FindState(
    const zelda3::GameData* game_data) const {
  if (!game_data) {
    return nullptr;
  }
  auto it = session_states_.find(game_data);
  return it == session_states_.end() ? nullptr : &it->second;
}
 
bool PaletteManager::IsInitialized() const {
  if (!game_data_) {
    return rom_ != nullptr;
  }
  const auto* state = FindState(game_data_);
  return state != nullptr && state->initialized && rom_ == game_data_->rom();
}
 
uint64_t PaletteManager::ColorRevision(
    const zelda3::GameData* game_data) const {
  const auto* state = FindState(game_data);
  return state ? state->color_revision : 0;
}
 
void PaletteManager::ActivateSession(zelda3::GameData* game_data) {
  game_data_ = game_data;
  rom_ = game_data ? game_data->rom() : nullptr;
  if (game_data) {
    session_states_.try_emplace(game_data);
  }
}
 
void PaletteManager::Initialize(zelda3::GameData* game_data) {
  if (!game_data) {
    return;
  }
 
  ActivateSession(game_data);
  auto* state = CurrentState();
  if (state->initialized) {
    return;
  }
 
  *state = SessionState{};
 
  // Load original palette snapshots for all groups
  auto* palette_groups = &game_data_->palette_groups;
 
  // Snapshot all palette groups
  const char* group_names[] = {"ow_main",      "ow_aux",         "ow_animated",
                               "hud",          "global_sprites", "armors",
                               "swords",       "shields",        "sprites_aux1",
                               "sprites_aux2", "sprites_aux3",   "dungeon_main",
                               "grass",        "3d_object",      "ow_mini_map"};
 
  for (const auto& group_name : group_names) {
    try {
      auto* group = palette_groups->get_group(group_name);
      if (group) {
        std::vector<SnesPalette> originals;
        for (size_t i = 0; i < group->size(); i++) {
          originals.push_back(group->palette(i));
        }
        state->original_palettes[group_name] = originals;
      }
    } catch (const std::exception& e) {
      // Group doesn't exist, skip
      continue;
    }
  }
 
  state->initialized = true;
}
 
bool PaletteManager::IsSessionActive(const zelda3::GameData* game_data) const {
  return game_data != nullptr && game_data_ == game_data &&
         rom_ == game_data->rom();
}
 
bool PaletteManager::IsManaging(const zelda3::GameData* game_data) const {
  return IsSessionActive(game_data) && IsInitialized();
}
 
void PaletteManager::ReleaseSession(const zelda3::GameData* game_data) {
  if (!game_data) {
    return;
  }
  if (game_data_ == game_data) {
    game_data_ = nullptr;
    rom_ = nullptr;
  }
  session_states_.erase(game_data);
}
 
void PaletteManager::Initialize(Rom* rom) {
  // Legacy initialization - not supported in new architecture
  // Keep ROM pointer for backwards compatibility but log warning
  if (!rom) {
    return;
  }
  game_data_ = nullptr;
  rom_ = rom;
  unbound_state_ = SessionState{};
}
 
void PaletteManager::ResetForTesting() {
  game_data_ = nullptr;
  rom_ = nullptr;
  session_states_.clear();
  unbound_state_ = SessionState{};
  change_listeners_.clear();
  next_callback_id_ = 1;
}
 
// ========== Color Operations ==========
 
SnesColor PaletteManager::GetColor(const std::string& group_name,
                                   int palette_index, int color_index) const {
  const auto* group = GetGroup(group_name);
  if (!group || palette_index < 0 || palette_index >= group->size()) {
    return SnesColor();
  }
 
  const auto& palette = group->palette_ref(palette_index);
  if (color_index < 0 || color_index >= palette.size()) {
    return SnesColor();
  }
 
  return palette[color_index];
}
 
absl::Status PaletteManager::SetColor(const std::string& group_name,
                                      int palette_index, int color_index,
                                      const SnesColor& new_color) {
  if (!IsInitialized()) {
    return absl::FailedPreconditionError("PaletteManager not initialized");
  }
 
  auto* group = GetMutableGroup(group_name);
  if (!group) {
    return absl::NotFoundError(
        absl::StrFormat("Palette group '%s' not found", group_name));
  }
 
  if (palette_index < 0 || palette_index >= group->size()) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Palette index %d out of range [0, %d)", palette_index, group->size()));
  }
 
  auto* palette = group->mutable_palette(palette_index);
  if (color_index < 0 || color_index >= palette->size()) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Color index %d out of range [0, %d)", color_index, palette->size()));
  }
 
  auto* state = CurrentState();
  if (state->color_edit && (state->color_edit->group_name != group_name ||
                            state->color_edit->palette_index != palette_index ||
                            state->color_edit->color_index != color_index)) {
    CommitColorEdit();
  }
  const SnesColor original_color = (*palette)[color_index];
  if (original_color.snes() == new_color.snes()) {
    return absl::OkStatus();
  }
  (*palette)[color_index] = new_color;
  MarkModified(group_name, palette_index, color_index);
 
  const auto timestamp_ms =
      std::chrono::duration_cast<std::chrono::milliseconds>(
          std::chrono::system_clock::now().time_since_epoch())
          .count();
  PaletteColorChange change{group_name,  palette_index,
                            color_index, original_color,
                            new_color,   static_cast<uint64_t>(timestamp_ms)};
  if (state->color_edit) {
    state->color_edit->new_color = new_color;
    state->color_edit->timestamp_ms = change.timestamp_ms;
  } else if (InBatch()) {
    state->batch_changes.push_back(change);
    return absl::OkStatus();
  } else {
    RecordChange(change);
  }
  NotifyListeners({PaletteChangeEvent::Type::kColorChanged, group_name,
                   palette_index, color_index});
 
  return absl::OkStatus();
}
 
absl::Status PaletteManager::ApplyExternalChanges(
    const zelda3::GameData* owner,
    const std::vector<PaletteColorChange>& changes,
    const std::function<absl::Status()>& participant) {
  if (!owner || !IsManaging(owner) || !IsInitialized() || !participant) {
    return absl::FailedPreconditionError(
        "Palette command session is unavailable");
  }
  auto* state = CurrentState();
  if (state->color_edit || state->batch_depth ||
      state->save_transaction_snapshot) {
    return absl::FailedPreconditionError(
        "Finish the active palette operation first");
  }
  std::set<std::tuple<std::string, int, int>> addresses;
  std::vector<SnesColor*> slots;
  for (const auto& change : changes) {
    auto* group = GetMutableGroup(change.group_name);
    if (!group || change.palette_index < 0 ||
        change.palette_index >= group->size()) {
      return absl::InvalidArgumentError("Invalid command palette");
    }
    auto* palette = group->mutable_palette(change.palette_index);
    if (change.color_index < 0 || change.color_index >= palette->size() ||
        !addresses
             .emplace(change.group_name, change.palette_index,
                      change.color_index)
             .second) {
      return absl::InvalidArgumentError("Invalid or duplicate command color");
    }
    auto* slot = &(*palette)[change.color_index];
    if (slot->snes() != change.original_color.snes()) {
      return absl::FailedPreconditionError(
          "Palette changed since command planning");
    }
    slots.push_back(slot);
  }
  const auto before = *state;
  for (size_t i = 0; i < changes.size(); ++i) {
    *slots[i] = changes[i].new_color;
    MarkModified(changes[i].group_name, changes[i].palette_index,
                 changes[i].color_index);
  }
  const auto status = participant();
  if (!status.ok()) {
    for (size_t i = 0; i < changes.size(); ++i)
      *slots[i] = changes[i].original_color;
    *state = before;
    return status;
  }
  for (const auto& change : changes) {
    if (!IsManaging(owner))
      break;
    NotifyListeners({PaletteChangeEvent::Type::kColorChanged, change.group_name,
                     change.palette_index, change.color_index});
  }
  return absl::OkStatus();
}
 
absl::Status PaletteManager::ResetColor(const std::string& group_name,
                                        int palette_index, int color_index) {
  SnesColor original = GetOriginalColor(group_name, palette_index, color_index);
  return SetColor(group_name, palette_index, color_index, original);
}
 
absl::Status PaletteManager::ResetPalette(const std::string& group_name,
                                          int palette_index) {
  CommitColorEdit();
  if (!IsInitialized()) {
    return absl::FailedPreconditionError("PaletteManager not initialized");
  }
 
  // Check if original snapshot exists
  auto* state = CurrentState();
  auto it = state->original_palettes.find(group_name);
  if (it == state->original_palettes.end() || palette_index < 0 ||
      palette_index >= it->second.size()) {
    return absl::NotFoundError("Original palette not found");
  }
 
  auto* group = GetMutableGroup(group_name);
  if (!group || palette_index >= group->size()) {
    return absl::NotFoundError("Palette group or index not found");
  }
 
  // Restore from original
  *group->mutable_palette(palette_index) = it->second[palette_index];
 
  // Clear modified flags for this palette
  if (auto modified_it = state->modified_palettes.find(group_name);
      modified_it != state->modified_palettes.end()) {
    modified_it->second.erase(palette_index);
    if (modified_it->second.empty()) {
      state->modified_palettes.erase(modified_it);
    }
  }
  if (auto colors_it = state->modified_colors.find(group_name);
      colors_it != state->modified_colors.end()) {
    colors_it->second.erase(palette_index);
    if (colors_it->second.empty()) {
      state->modified_colors.erase(colors_it);
    }
  }
 
  // Notify listeners
  PaletteChangeEvent event{PaletteChangeEvent::Type::kPaletteReset, group_name,
                           palette_index, -1};
  NotifyListeners(event);
 
  return absl::OkStatus();
}
 
absl::Status PaletteManager::BeginColorEdit(const std::string& group_name,
                                            int palette_index, int color_index,
                                            uint64_t caller_id) {
  if (!IsInitialized() || InBatch()) {
    return absl::FailedPreconditionError(
        "Color interaction requires an initialized session outside a batch");
  }
  const auto* group = GetGroup(group_name);
  if (!group || palette_index < 0 || palette_index >= group->size() ||
      color_index < 0 ||
      color_index >= group->palette_ref(palette_index).size()) {
    return absl::InvalidArgumentError("Invalid color interaction target");
  }
  CommitColorEdit();
  const auto color = group->palette_ref(palette_index)[color_index];
  CurrentState()->color_edit_caller = caller_id;
  CurrentState()->color_edit = PaletteColorChange{
      group_name, palette_index, color_index, color, color, 0};
  return absl::OkStatus();
}
 
void PaletteManager::CommitColorEdit(uint64_t caller_id) {
  auto* state = CurrentState();
  if (!HasColorEdit(caller_id)) {
    return;
  }
  auto change = std::move(*state->color_edit);
  state->color_edit.reset();
  if (change.original_color.snes() != change.new_color.snes()) {
    RecordChange(change);
  }
}
 
void PaletteManager::CancelColorEdit(uint64_t caller_id) {
  auto* state = CurrentState();
  if (!HasColorEdit(caller_id)) {
    return;
  }
  const auto change = std::move(*state->color_edit);
  state->color_edit.reset();
  auto* group = GetMutableGroup(change.group_name);
  if (group && change.palette_index < group->size()) {
    auto* palette = group->mutable_palette(change.palette_index);
    if (change.color_index < palette->size() &&
        (*palette)[change.color_index].snes() != change.original_color.snes()) {
      (*palette)[change.color_index] = change.original_color;
      MarkModified(change.group_name, change.palette_index, change.color_index);
      NotifyListeners({PaletteChangeEvent::Type::kColorChanged,
                       change.group_name, change.palette_index,
                       change.color_index});
    }
  }
}
 
bool PaletteManager::HasColorEdit(uint64_t caller_id) const {
  const auto* state = CurrentState();
  return state->color_edit.has_value() &&
         (caller_id == 0 || state->color_edit_caller == caller_id);
}
 
// ========== Dirty Tracking ==========
 
bool PaletteManager::HasUnsavedChanges() const {
  return !CurrentState()->modified_palettes.empty();
}
 
bool PaletteManager::HasUnsavedChanges(
    const zelda3::GameData* game_data) const {
  const auto* state = FindState(game_data);
  return state != nullptr && !state->modified_palettes.empty();
}
 
std::vector<std::string> PaletteManager::GetModifiedGroups() const {
  std::vector<std::string> groups;
  for (const auto& [group_name, _] : CurrentState()->modified_palettes) {
    groups.push_back(group_name);
  }
  return groups;
}
 
bool PaletteManager::IsGroupModified(const std::string& group_name) const {
  auto it = CurrentState()->modified_palettes.find(group_name);
  return it != CurrentState()->modified_palettes.end() && !it->second.empty();
}
 
bool PaletteManager::IsPaletteModified(const std::string& group_name,
                                       int palette_index) const {
  auto it = CurrentState()->modified_palettes.find(group_name);
  if (it == CurrentState()->modified_palettes.end()) {
    return false;
  }
  return it->second.contains(palette_index);
}
 
bool PaletteManager::IsColorModified(const std::string& group_name,
                                     int palette_index, int color_index) const {
  auto group_it = CurrentState()->modified_colors.find(group_name);
  if (group_it == CurrentState()->modified_colors.end()) {
    return false;
  }
 
  auto pal_it = group_it->second.find(palette_index);
  if (pal_it == group_it->second.end()) {
    return false;
  }
 
  return pal_it->second.contains(color_index);
}
 
size_t PaletteManager::GetModifiedColorCount() const {
  return GetModifiedColorCount(game_data_);
}
 
size_t PaletteManager::GetModifiedColorCount(
    const zelda3::GameData* game_data) const {
  const auto* state = FindState(game_data);
  if (state == nullptr) {
    return 0;
  }
 
  size_t count = 0;
  for (const auto& [_, palette_map] : state->modified_colors) {
    for (const auto& [__, color_set] : palette_map) {
      count += color_set.size();
    }
  }
  return count;
}
 
absl::StatusOr<uint32_t> PaletteManager::ResolveColorAddress(
    const zelda3::GameData* game_data, const std::string& group_name,
    int palette_index, int color_index) const {
  if (!game_data || !game_data->rom()) {
    return absl::FailedPreconditionError("No ROM session for palette address");
  }
  const PaletteGroup* group = nullptr;
  try {
    group = game_data->palette_groups.get_group(group_name);
  } catch (const std::out_of_range& e) {
    return absl::InvalidArgumentError(e.what());
  }
  if (!group || palette_index < 0 || palette_index >= group->size()) {
    return absl::OutOfRangeError("Modified palette no longer exists");
  }
  if (color_index < 0 ||
      color_index >= group->palette_ref(palette_index).size()) {
    return absl::OutOfRangeError("Modified palette color no longer exists");
  }
 
  const size_t rom_size = game_data->rom()->vector().size();
  if (group_name == "ow_main" || group_name == "ow_aux") {
    using palette_group_internal::OverworldPaletteKind;
    const auto kind = group_name == "ow_main"
                          ? OverworldPaletteKind::kMain
                          : OverworldPaletteKind::kAuxiliary;
    ASSIGN_OR_RETURN(
        const auto record,
        palette_group_internal::OverworldPaletteLayout::Legacy().Resolve(
            kind, palette_index, rom_size));
    return record.ColorAddress(color_index);
  }
 
  // Other groups retain their existing address layout.
  uint32_t address;
  try {
    address = GetPaletteAddress(group_name, palette_index, color_index);
  } catch (const std::out_of_range& e) {
    return absl::InvalidArgumentError(e.what());
  }
  if (address > rom_size || rom_size - address < 2) {
    return absl::OutOfRangeError("Modified palette color exceeds ROM bounds");
  }
  return address;
}
 
absl::StatusOr<std::vector<std::pair<uint32_t, uint32_t>>>
PaletteManager::GetModifiedColorWriteRanges() const {
  return GetModifiedColorWriteRanges(game_data_);
}
 
absl::StatusOr<std::vector<std::pair<uint32_t, uint32_t>>>
PaletteManager::GetModifiedColorWriteRanges(
    const zelda3::GameData* game_data) const {
  std::vector<std::pair<uint32_t, uint32_t>> ranges;
  const auto* state = FindState(game_data);
  if (state == nullptr) {
    return ranges;
  }
  ranges.reserve(GetModifiedColorCount(game_data));
 
  for (const auto& [group_name, palette_map] : state->modified_colors) {
    for (const auto& [palette_index, color_indices] : palette_map) {
      for (int color_index : color_indices) {
        ASSIGN_OR_RETURN(const auto begin,
                         ResolveColorAddress(game_data, group_name,
                                             palette_index, color_index));
        ranges.emplace_back(begin, begin + 2u);
      }
    }
  }
 
  return CoalescePaletteWriteRanges(std::move(ranges));
}
 
absl::StatusOr<std::vector<std::pair<uint32_t, uint32_t>>>
PaletteManager::GetModifiedGroupColorWriteRanges(
    const std::string& group_name) const {
  std::vector<std::pair<uint32_t, uint32_t>> ranges;
  const auto* state = CurrentState();
  const auto group_it = state->modified_colors.find(group_name);
  if (group_it == state->modified_colors.end()) {
    return ranges;
  }
 
  for (const auto& [palette_index, color_indices] : group_it->second) {
    for (int color_index : color_indices) {
      ASSIGN_OR_RETURN(const auto begin,
                       ResolveColorAddress(game_data_, group_name,
                                           palette_index, color_index));
      ranges.emplace_back(begin, begin + 2u);
    }
  }
  return CoalescePaletteWriteRanges(std::move(ranges));
}
 
// ========== Persistence ==========
 
absl::Status PaletteManager::SaveGroup(const std::string& group_name) {
  if (!IsInitialized()) {
    return absl::FailedPreconditionError("PaletteManager not initialized");
  }
 
  Rom* rom = rom_;
  if (!rom && game_data_) {
    rom = game_data_->rom();
  }
  if (!rom) {
    return absl::FailedPreconditionError("No ROM available for palette save");
  }
 
  auto* group = GetMutableGroup(group_name);
  if (!group) {
    return absl::NotFoundError(
        absl::StrFormat("Palette group '%s' not found", group_name));
  }
 
  // Get modified palettes for this group
  auto pal_it = CurrentState()->modified_palettes.find(group_name);
  if (pal_it == CurrentState()->modified_palettes.end() ||
      pal_it->second.empty()) {
    // No changes to save
    CommitColorEdit();
    return absl::OkStatus();
  }
 
  // Resolve every modified color before writing or committing edit metadata.
  std::vector<std::pair<uint32_t, uint16_t>> writes;
  for (int palette_idx : pal_it->second) {
    const auto group_it = CurrentState()->modified_colors.find(group_name);
    if (group_it == CurrentState()->modified_colors.end()) {
      continue;
    }
    const auto color_it = group_it->second.find(palette_idx);
    if (color_it != group_it->second.end()) {
      for (int color_idx : color_it->second) {
        ASSIGN_OR_RETURN(const auto address,
                         ResolveColorAddress(game_data_, group_name,
                                             palette_idx, color_idx));
        writes.emplace_back(address,
                            group->palette_ref(palette_idx)[color_idx].snes());
      }
    }
  }
  CommitColorEdit();
  for (const auto& [address, color] : writes) {
    RETURN_IF_ERROR(rom->WriteShort(address, color));
  }
 
  // Update original snapshots
  auto& originals = CurrentState()->original_palettes[group_name];
  for (size_t i = 0; i < group->size() && i < originals.size(); i++) {
    originals[i] = group->palette(i);
  }
 
  // Clear modified flags for this group
  ClearModifiedFlags(group_name);
 
  // Mark ROM as dirty
  rom->set_dirty(true);
 
  // Notify listeners
  PaletteChangeEvent event{PaletteChangeEvent::Type::kGroupSaved, group_name,
                           -1, -1};
  NotifyListeners(event);
 
  // Notify Arena for bitmap propagation to other editors
  Arena::Get().NotifyPaletteModified(group_name, -1);
 
  return absl::OkStatus();
}
 
absl::Status PaletteManager::SaveAllToRom() {
  if (!IsInitialized()) {
    return absl::FailedPreconditionError("PaletteManager not initialized");
  }
 
  // A bad later group must not leave earlier groups saved or marked clean.
  const auto ranges = GetModifiedColorWriteRanges();
  RETURN_IF_ERROR(ranges.status());
 
  // Save all modified groups
  for (const auto& group_name : GetModifiedGroups()) {
    RETURN_IF_ERROR(SaveGroup(group_name));
  }
 
  // Notify listeners
  PaletteChangeEvent event{PaletteChangeEvent::Type::kAllSaved, "", -1, -1};
  NotifyListeners(event);
 
  return absl::OkStatus();
}
 
absl::Status PaletteManager::BeginSaveTransaction() {
  CommitColorEdit();
  if (!IsInitialized()) {
    return absl::FailedPreconditionError("PaletteManager not initialized");
  }
 
  auto* state = CurrentState();
  if (state->save_transaction_snapshot.has_value()) {
    return absl::FailedPreconditionError(
        "Palette save transaction is already active");
  }
  state->save_transaction_snapshot =
      SaveTransactionSnapshot{state->original_palettes,
                              state->modified_palettes, state->modified_colors};
  return absl::OkStatus();
}
 
void PaletteManager::RollbackSaveTransaction() {
  auto* state = CurrentState();
  if (!state->save_transaction_snapshot.has_value()) {
    return;
  }
  state->original_palettes =
      std::move(state->save_transaction_snapshot->original_palettes);
  state->modified_palettes =
      std::move(state->save_transaction_snapshot->modified_palettes);
  state->modified_colors =
      std::move(state->save_transaction_snapshot->modified_colors);
  state->save_transaction_snapshot.reset();
}
 
void PaletteManager::CommitSaveTransaction() {
  CurrentState()->save_transaction_snapshot.reset();
}
 
absl::Status PaletteManager::ApplyPreviewChanges() {
  if (!IsInitialized()) {
    return absl::FailedPreconditionError("PaletteManager not initialized");
  }
 
  // Get all modified groups and notify Arena for each
  // This triggers bitmap refresh in other editors WITHOUT saving to ROM
  auto modified_groups = GetModifiedGroups();
 
  if (modified_groups.empty()) {
    return absl::OkStatus();  // Nothing to preview
  }
 
  ++CurrentState()->color_revision;
  for (const auto& group_name : modified_groups) {
    Arena::Get().NotifyPaletteModified(group_name, -1);
  }
 
  // Notify listeners that preview was applied
  PaletteChangeEvent event{PaletteChangeEvent::Type::kAllSaved, "", -1, -1};
  NotifyListeners(event);
 
  return absl::OkStatus();
}
 
void PaletteManager::DiscardGroup(const std::string& group_name) {
  if (HasColorEdit() && CurrentState()->color_edit->group_name == group_name) {
    CancelColorEdit();
  }
  if (!IsInitialized()) {
    return;
  }
 
  auto* group = GetMutableGroup(group_name);
  if (!group) {
    return;
  }
 
  // Get modified palettes
  auto pal_it = CurrentState()->modified_palettes.find(group_name);
  if (pal_it == CurrentState()->modified_palettes.end()) {
    return;
  }
 
  // Restore from original snapshots
  auto orig_it = CurrentState()->original_palettes.find(group_name);
  if (orig_it != CurrentState()->original_palettes.end()) {
    for (int palette_idx : pal_it->second) {
      if (palette_idx < orig_it->second.size()) {
        *group->mutable_palette(palette_idx) = orig_it->second[palette_idx];
      }
    }
  }
 
  // Clear modified flags
  ClearModifiedFlags(group_name);
 
  // Notify listeners
  PaletteChangeEvent event{PaletteChangeEvent::Type::kGroupDiscarded,
                           group_name, -1, -1};
  NotifyListeners(event);
}
 
void PaletteManager::DiscardAllChanges() {
  if (!IsInitialized()) {
    return;
  }
 
  // Discard all modified groups
  for (const auto& group_name : GetModifiedGroups()) {
    DiscardGroup(group_name);
  }
 
  // Clear undo/redo
  ClearHistory();
 
  // Notify listeners
  PaletteChangeEvent event{PaletteChangeEvent::Type::kAllDiscarded, "", -1, -1};
  NotifyListeners(event);
}
 
// ========== Undo/Redo ==========
 
void PaletteManager::Undo() {
  if (!CanUndo()) {
    return;
  }
  CommitColorEdit();
 
  auto* state = CurrentState();
  auto changes = std::move(state->undo_stack.back());
  state->undo_stack.pop_back();
 
  // Apply the whole step before publishing any color notifications. Reverse
  // order preserves the first value when a batch edits one slot repeatedly.
  for (auto it = changes.rbegin(); it != changes.rend(); ++it) {
    const auto& change = *it;
    auto* group = GetMutableGroup(change.group_name);
    if (group && change.palette_index >= 0 &&
        change.palette_index < group->size()) {
      auto* palette = group->mutable_palette(change.palette_index);
      if (change.color_index >= 0 && change.color_index < palette->size()) {
        (*palette)[change.color_index] = change.original_color;
        MarkModified(change.group_name, change.palette_index,
                     change.color_index);
      }
    }
  }
 
  state->redo_stack.push_back(changes);
  const auto* owner = game_data_;
  const auto* owner_rom = rom_;
  for (const auto& change : changes) {
    if (game_data_ != owner || rom_ != owner_rom) {
      break;  // A listener activated another ROM session.
    }
    NotifyListeners({PaletteChangeEvent::Type::kColorChanged, change.group_name,
                     change.palette_index, change.color_index});
  }
}
 
void PaletteManager::Redo() {
  if (!CanRedo()) {
    return;
  }
  CommitColorEdit();
 
  auto* state = CurrentState();
  auto changes = std::move(state->redo_stack.back());
  state->redo_stack.pop_back();
 
  for (const auto& change : changes) {
    auto* group = GetMutableGroup(change.group_name);
    if (group && change.palette_index >= 0 &&
        change.palette_index < group->size()) {
      auto* palette = group->mutable_palette(change.palette_index);
      if (change.color_index >= 0 && change.color_index < palette->size()) {
        (*palette)[change.color_index] = change.new_color;
        MarkModified(change.group_name, change.palette_index,
                     change.color_index);
      }
    }
  }
 
  state->undo_stack.push_back(changes);
  const auto* owner = game_data_;
  const auto* owner_rom = rom_;
  for (const auto& change : changes) {
    if (game_data_ != owner || rom_ != owner_rom) {
      break;  // A listener activated another ROM session.
    }
    NotifyListeners({PaletteChangeEvent::Type::kColorChanged, change.group_name,
                     change.palette_index, change.color_index});
  }
}
 
void PaletteManager::ClearHistory() {
  CommitColorEdit();
  CurrentState()->undo_stack.clear();
  CurrentState()->redo_stack.clear();
}
 
bool PaletteManager::CanUndo() const {
  const auto* state = CurrentState();
  if (state->batch_depth || state->save_transaction_snapshot)
    return false;
  if (state->color_edit && state->color_edit->original_color.snes() !=
                               state->color_edit->new_color.snes()) {
    return CanReplayHistory({*state->color_edit}, /*redo=*/false);
  }
  return !state->undo_stack.empty() &&
         CanReplayHistory(state->undo_stack.back(), /*redo=*/false);
}
 
bool PaletteManager::CanRedo() const {
  const auto* state = CurrentState();
  return !state->redo_stack.empty() && !state->batch_depth &&
         !state->save_transaction_snapshot &&
         (!state->color_edit || state->color_edit->original_color.snes() ==
                                    state->color_edit->new_color.snes()) &&
         CanReplayHistory(state->redo_stack.back(), /*redo=*/true);
}
 
bool PaletteManager::CanReplayHistory(
    const std::vector<PaletteColorChange>& changes, bool redo) const {
  if (changes.empty())
    return false;
  std::map<std::tuple<std::string, int, int>, uint16_t> staged;
  for (size_t step = 0; step < changes.size(); ++step) {
    const auto& change = changes[redo ? step : changes.size() - 1 - step];
    const auto* group = GetGroup(change.group_name);
    if (!group || change.palette_index < 0 ||
        change.palette_index >= group->size())
      return false;
    const auto& palette = group->palette_ref(change.palette_index);
    if (change.color_index < 0 || change.color_index >= palette.size())
      return false;
    const auto [at, inserted] = staged.try_emplace(
        std::make_tuple(change.group_name, change.palette_index,
                        change.color_index),
        palette[change.color_index].snes());
    const auto expected = redo ? change.original_color : change.new_color;
    if (at->second != expected.snes())
      return false;
    at->second = (redo ? change.new_color : change.original_color).snes();
  }
  return true;
}
 
size_t PaletteManager::GetUndoStackSize() const {
  return CurrentState()->undo_stack.size();
}
 
size_t PaletteManager::GetRedoStackSize() const {
  return CurrentState()->redo_stack.size();
}
 
// ========== Change Notifications ==========
 
int PaletteManager::RegisterChangeListener(ChangeCallback callback) {
  int id = next_callback_id_++;
  change_listeners_[id] = callback;
  return id;
}
 
void PaletteManager::UnregisterChangeListener(int callback_id) {
  change_listeners_.erase(callback_id);
}
 
// ========== Batch Operations ==========
 
void PaletteManager::BeginBatch() {
  CommitColorEdit();
  CurrentState()->batch_depth++;
  if (CurrentState()->batch_depth == 1) {
    CurrentState()->batch_changes.clear();
  }
}
 
void PaletteManager::EndBatch() {
  if (CurrentState()->batch_depth == 0) {
    return;
  }
 
  CurrentState()->batch_depth--;
 
  auto* state = CurrentState();
  if (state->batch_depth == 0 && !state->batch_changes.empty()) {
    // Coalesce repeated writes to one slot. A batch that returns every slot
    // to its starting value has no history entry and preserves Redo.
    std::vector<PaletteColorChange> changes;
    for (const auto& change : state->batch_changes) {
      auto existing = std::find_if(
          changes.begin(), changes.end(), [&](const PaletteColorChange& entry) {
            return entry.group_name == change.group_name &&
                   entry.palette_index == change.palette_index &&
                   entry.color_index == change.color_index;
          });
      if (existing == changes.end()) {
        changes.push_back(change);
      } else {
        existing->new_color = change.new_color;
        existing->timestamp_ms = change.timestamp_ms;
      }
    }
    changes.erase(std::remove_if(changes.begin(), changes.end(),
                                 [](const PaletteColorChange& change) {
                                   return change.original_color.snes() ==
                                          change.new_color.snes();
                                 }),
                  changes.end());
    state->batch_changes.clear();
    if (!changes.empty()) {
      RecordChanges(changes);
      const auto* owner = game_data_;
      const auto* owner_rom = rom_;
      for (const auto& change : changes) {
        if (game_data_ != owner || rom_ != owner_rom) {
          break;  // Do not publish this batch in another ROM session.
        }
        NotifyListeners({PaletteChangeEvent::Type::kColorChanged,
                         change.group_name, change.palette_index,
                         change.color_index});
      }
    }
  }
}
 
bool PaletteManager::InBatch() const {
  return CurrentState()->batch_depth > 0;
}
 
// ========== Private Helpers ==========
 
PaletteGroup* PaletteManager::GetMutableGroup(const std::string& group_name) {
  if (!IsInitialized()) {
    return nullptr;
  }
  try {
    if (game_data_) {
      return game_data_->palette_groups.get_group(group_name);
    }
    return nullptr;  // Legacy ROM-only mode not supported
  } catch (const std::exception&) {
    return nullptr;
  }
}
 
const PaletteGroup* PaletteManager::GetGroup(
    const std::string& group_name) const {
  if (!IsInitialized()) {
    return nullptr;
  }
  try {
    if (game_data_) {
      return const_cast<PaletteGroupMap*>(&game_data_->palette_groups)
          ->get_group(group_name);
    }
    return nullptr;  // Legacy ROM-only mode not supported
  } catch (const std::exception&) {
    return nullptr;
  }
}
 
SnesColor PaletteManager::GetOriginalColor(const std::string& group_name,
                                           int palette_index,
                                           int color_index) const {
  const auto* state = CurrentState();
  auto it = state->original_palettes.find(group_name);
  if (it == state->original_palettes.end() || palette_index < 0 ||
      palette_index >= it->second.size()) {
    return SnesColor();
  }
 
  const auto& palette = it->second[palette_index];
  if (color_index < 0 || color_index >= palette.size()) {
    return SnesColor();
  }
 
  return palette[color_index];
}
 
void PaletteManager::RecordChange(const PaletteColorChange& change) {
  RecordChanges({change});
}
 
void PaletteManager::RecordChanges(std::vector<PaletteColorChange> changes) {
  if (changes.empty()) {
    return;
  }
  CurrentState()->undo_stack.push_back(std::move(changes));
 
  // Limit history size
  if (CurrentState()->undo_stack.size() > kMaxUndoHistory) {
    CurrentState()->undo_stack.pop_front();
  }
 
  // Clear redo stack (can't redo after a new change)
  CurrentState()->redo_stack.clear();
}
 
void PaletteManager::NotifyListeners(const PaletteChangeEvent& event) {
  // Publish changes after the model and history agree. Saved notifications do
  // not change colors; discard-all already publishes each affected group.
  if (event.type == PaletteChangeEvent::Type::kColorChanged ||
      event.type == PaletteChangeEvent::Type::kPaletteReset ||
      event.type == PaletteChangeEvent::Type::kGroupDiscarded) {
    ++CurrentState()->color_revision;
    Arena::Get().NotifyPaletteModified(event.group_name, event.palette_index);
  }
  const auto* owner = game_data_;
  const auto* owner_rom = rom_;
  for (const auto& [_, callback] : change_listeners_) {
    if (game_data_ != owner || rom_ != owner_rom) {
      break;
    }
    callback(event);
  }
}
 
void PaletteManager::MarkModified(const std::string& group_name,
                                  int palette_index, int color_index) {
  auto* state = CurrentState();
  const auto* group = GetGroup(group_name);
  const auto original_it = state->original_palettes.find(group_name);
  const bool matches_original =
      group != nullptr && palette_index >= 0 && palette_index < group->size() &&
      color_index >= 0 &&
      color_index < group->palette_ref(palette_index).size() &&
      original_it != state->original_palettes.end() &&
      palette_index < original_it->second.size() &&
      color_index < original_it->second[palette_index].size() &&
      group->palette_ref(palette_index)[color_index].snes() ==
          original_it->second[palette_index][color_index].snes();
 
  if (!matches_original) {
    state->modified_palettes[group_name].insert(palette_index);
    state->modified_colors[group_name][palette_index].insert(color_index);
    return;
  }
 
  if (auto group_it = state->modified_colors.find(group_name);
      group_it != state->modified_colors.end()) {
    if (auto palette_it = group_it->second.find(palette_index);
        palette_it != group_it->second.end()) {
      palette_it->second.erase(color_index);
      if (palette_it->second.empty()) {
        group_it->second.erase(palette_it);
      }
    }
    if (group_it->second.empty()) {
      state->modified_colors.erase(group_it);
    }
  }
 
  const auto colors_group_it = state->modified_colors.find(group_name);
  const bool palette_still_modified =
      colors_group_it != state->modified_colors.end() &&
      colors_group_it->second.contains(palette_index);
  if (!palette_still_modified) {
    if (auto group_it = state->modified_palettes.find(group_name);
        group_it != state->modified_palettes.end()) {
      group_it->second.erase(palette_index);
      if (group_it->second.empty()) {
        state->modified_palettes.erase(group_it);
      }
    }
  }
}
 
void PaletteManager::ClearModifiedFlags(const std::string& group_name) {
  CurrentState()->modified_palettes.erase(group_name);
  CurrentState()->modified_colors.erase(group_name);
}
 
}  // namespace gfx
}  // namespace yaze