palette_editor_widget.cc

Go to the documentation of this file.

#include "app/gui/widgets/palette_editor_widget.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <map>
 
#include "absl/strings/str_format.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gui/automation/widget_auto_register.h"
#include "app/gui/canvas/item_context_menu.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/popup_id.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/plots/implot_support.h"
#include "app/gui/widgets/themed_widgets.h"
#include "util/log.h"
 
#include <cstring>
#include <string>
#include <vector>
 
namespace yaze {
namespace gui {
 
namespace {
 
struct DungeonRenderColorTarget {
  DungeonRenderPaletteSource source;
  int palette_index;
  int color_index;
};
 
std::optional<DungeonRenderColorTarget> ResolveDungeonRenderColorTarget(
    int display_index, int dungeon_palette_id) {
  if (display_index < 0 || display_index >= 128) {
    return std::nullopt;
  }
  if (display_index < 32) {
    return DungeonRenderColorTarget{DungeonRenderPaletteSource::kHud, 0,
                                    display_index};
  }
 
  const int local_index = display_index - 32;
  const int row = local_index / 16;
  const int col = local_index % 16;
  if (row >= 6 || col == 0) {
    return std::nullopt;
  }
 
  return DungeonRenderColorTarget{DungeonRenderPaletteSource::kDungeonMain,
                                  dungeon_palette_id, row * 15 + (col - 1)};
}
 
const char* PaletteManagerGroupName(DungeonRenderPaletteSource source) {
  return source == DungeonRenderPaletteSource::kHud ? "hud" : "dungeon_main";
}
 
const gfx::PaletteGroup& PaletteGroupForTarget(
    const zelda3::GameData& game_data, const DungeonRenderColorTarget& target) {
  return target.source == DungeonRenderPaletteSource::kHud
             ? game_data.palette_groups.hud
             : game_data.palette_groups.dungeon_main;
}
 
std::string DungeonRenderColorSourceLabel(
    const DungeonRenderColorTarget& target) {
  if (target.source == DungeonRenderPaletteSource::kHud) {
    return "HUD / floor-ceiling";
  }
  return absl::StrFormat("Dungeon row %d", target.color_index / 15 + 2);
}
 
const char* RomPaletteGroupNameGetter(void* user_data, int idx) {
  auto* names = static_cast<std::vector<std::string>*>(user_data);
  if (!names || idx < 0 || idx >= static_cast<int>(names->size())) {
    return nullptr;
  }
  return (*names)[idx].c_str();
}
 
void DrawColorDropTargetOutline(ImVec2 min, ImVec2 max) {
  const auto& theme = ThemeManager::Get().GetCurrentTheme();
  ImGui::GetForegroundDrawList()->AddRect(
      min, max, ImGui::GetColorU32(ConvertColorToImVec4(theme.accent)), 0.0f, 0,
      2.0f);
}
 
bool AcceptImGuiColorDrop(gfx::SnesColor* color, ImVec2 min, ImVec2 max) {
  if (!color || !ImGui::BeginDragDropTarget()) {
    return false;
  }
 
  bool changed = false;
  constexpr ImGuiDragDropFlags kFlags =
      ImGuiDragDropFlags_AcceptBeforeDelivery |
      ImGuiDragDropFlags_AcceptNoDrawDefaultRect |
      ImGuiDragDropFlags_AcceptNoPreviewTooltip;
  auto accept = [&](const char* type, size_t components) {
    if (changed) {
      return;
    }
    if (const ImGuiPayload* payload =
            ImGui::AcceptDragDropPayload(type, kFlags)) {
      DrawColorDropTargetOutline(min, max);
      if (payload->IsDelivery()) {
        ImVec4 dropped(0, 0, 0, 1);
        std::memcpy(&dropped.x, payload->Data, sizeof(float) * components);
        if (components == 3) {
          dropped.w = 1.0f;
        }
        *color = gfx::SnesColor(dropped);
        changed = true;
      }
    }
  };
 
  accept(IMGUI_PAYLOAD_TYPE_COLOR_3F, 3);
  accept(IMGUI_PAYLOAD_TYPE_COLOR_4F, 4);
  ImGui::EndDragDropTarget();
  return changed;
}
 
}  // namespace
 
int ResolveDungeonRenderPaletteColumns(float available_width,
                                       float min_swatch_size,
                                       float item_spacing) {
  const float safe_width = std::max(available_width, 1.0f);
  const float safe_swatch = std::max(min_swatch_size, 1.0f);
  const float safe_spacing = std::max(item_spacing, 0.0f);
  for (const int columns : {16, 8, 4, 2, 1}) {
    const float required_width =
        safe_swatch * columns + safe_spacing * (columns - 1);
    if (safe_width >= required_width) {
      return columns;
    }
  }
  return 1;
}
 
// Merged implementation from PaletteWidget and PaletteEditorWidget
 
void PaletteEditorWidget::Initialize(zelda3::GameData* game_data) {
  game_data_ = game_data;
  rom_ = nullptr;
  rom_palettes_loaded_ = false;
  if (game_data_) {
    LoadROMPalettes();
  }
  current_palette_id_ = 0;
  selected_color_index_ = -1;
}
 
void PaletteEditorWidget::Initialize(Rom* rom) {
  rom_ = rom;
  game_data_ = nullptr;
  rom_palettes_loaded_ = false;
  // Legacy mode - no palette loading without game_data
  current_palette_id_ = 0;
  selected_color_index_ = -1;
}
 
absl::Status PaletteEditorWidget::ApplyDungeonRenderColorEdit(
    int display_index, std::optional<gfx::SnesColor> color) {
  if (!game_data_) {
    return absl::FailedPreconditionError("GameData not loaded");
  }
 
  const auto target =
      ResolveDungeonRenderColorTarget(display_index, current_palette_id_);
  if (!target.has_value()) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Dungeon render palette slot %d is reserved or out of range",
        display_index));
  }
 
  auto& palette_manager = gfx::PaletteManager::Get();
  if (!palette_manager.IsManaging(game_data_)) {
    return absl::FailedPreconditionError(
        "PaletteManager is bound to a different ROM session");
  }
  const char* group_name = PaletteManagerGroupName(target->source);
  absl::Status status =
      color.has_value()
          ? palette_manager.SetColor(group_name, target->palette_index,
                                     target->color_index, *color)
          : palette_manager.ResetColor(group_name, target->palette_index,
                                       target->color_index);
  if (!status.ok()) {
    return status;
  }
 
  if (on_palette_changed_) {
    on_palette_changed_({current_palette_id_, target->source});
  }
  return absl::OkStatus();
}
 
// --- Embedded Draw Method (from simple editor) ---
void PaletteEditorWidget::Draw() {
  if (!game_data_) {
    ImGui::TextColored(ImVec4(1, 0, 0, 1), tr("GameData not loaded"));
    return;
  }
 
  ImGui::BeginGroup();
 
  DrawPaletteSelector();
  ImGui::Separator();
 
  auto& dungeon_pal_group = game_data_->palette_groups.dungeon_main;
  if (dungeon_pal_group.empty()) {
    ImGui::TextDisabled(tr("Dungeon palettes unavailable"));
    ImGui::EndGroup();
    return;
  }
 
  current_palette_id_ = std::clamp(
      current_palette_id_, 0, static_cast<int>(dungeon_pal_group.size()) - 1);
  if (current_palette_id_ >= 0 &&
      current_palette_id_ < (int)dungeon_pal_group.size()) {
    auto palette = dungeon_pal_group[current_palette_id_];
    if (dungeon_render_palette_mode_) {
      DrawDungeonRenderPalette();
    } else {
      DrawPaletteGrid(palette, 15);
      dungeon_pal_group[current_palette_id_] = palette;
    }
  }
 
  ImGui::Separator();
 
  if (selected_color_index_ >= 0) {
    if (dungeon_render_palette_mode_) {
      DrawDungeonRenderColorPicker();
    } else {
      DrawColorPicker();
    }
  } else {
    ImGui::TextDisabled(tr("Select a color to edit"));
  }
 
  ImGui::EndGroup();
}
 
void PaletteEditorWidget::DrawPaletteSelector() {
  if (!game_data_)
    return;
  auto& dungeon_pal_group = game_data_->palette_groups.dungeon_main;
  int num_palettes = dungeon_pal_group.size();
  if (num_palettes <= 0) {
    ImGui::TextDisabled(tr("No dungeon palettes"));
    return;
  }
 
  current_palette_id_ = std::clamp(current_palette_id_, 0, num_palettes - 1);
 
  ImGui::Text(tr("Dungeon Palette:"));
  ImGui::SameLine();
  ImGui::SetNextItemWidth(std::min(180.0f, ImGui::GetContentRegionAvail().x));
 
  if (ImGui::BeginCombo(
          "##PaletteSelect",
          absl::StrFormat("Palette %d", current_palette_id_).c_str())) {
    for (int i = 0; i < num_palettes; i++) {
      bool is_selected = (current_palette_id_ == i);
      if (ImGui::Selectable(absl::StrFormat("Palette %d", i).c_str(),
                            is_selected)) {
        current_palette_id_ = i;
        selected_color_index_ = -1;
      }
      if (is_selected) {
        ImGui::SetItemDefaultFocus();
      }
    }
    ImGui::EndCombo();
  }
 
  int requested_palette_id = current_palette_id_;
  ImGui::TextUnformatted(tr("Palette ID"));
  ImGui::SameLine();
  ImGui::SetNextItemWidth(72.0f);
  const bool palette_id_changed = gui::InputScalarDeferred(
      "##DungeonPaletteId", ImGuiDataType_S32, &requested_palette_id, "%d", 0,
      {reinterpret_cast<uintptr_t>(game_data_)});
  gui::AutoRegisterLastItem("input_int", "palette_id",
                            "Dungeon main palette ID");
  if (palette_id_changed) {
    current_palette_id_ = std::clamp(requested_palette_id, 0, num_palettes - 1);
    selected_color_index_ = -1;
  }
}
 
void PaletteEditorWidget::DrawColorPicker() {
  if (!game_data_)
    return;
  auto& dungeon_pal_group = game_data_->palette_groups.dungeon_main;
  if (dungeon_pal_group.empty()) {
    return;
  }
  current_palette_id_ = std::clamp(
      current_palette_id_, 0, static_cast<int>(dungeon_pal_group.size()) - 1);
  ImGui::SeparatorText(
      absl::StrFormat("Edit Color %d", selected_color_index_).c_str());
 
  auto palette = dungeon_pal_group[current_palette_id_];
  if (selected_color_index_ < 0 ||
      selected_color_index_ >= static_cast<int>(palette.size())) {
    selected_color_index_ = -1;
    return;
  }
  auto original_color = palette[selected_color_index_];
 
  // Use standardized SnesColorEdit4 for consistency
  if (gui::SnesColorEdit4(
          "Color", &palette[selected_color_index_],
          ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_PickerHueWheel)) {
    // Update the palette group with the modified palette
    dungeon_pal_group[current_palette_id_] = palette;
 
    // Update editing_color_ to match (for consistency with other parts of the
    // widget)
    editing_color_ =
        gui::ConvertSnesColorToImVec4(palette[selected_color_index_]);
 
    if (on_palette_changed_) {
      on_palette_changed_(
          {current_palette_id_, DungeonRenderPaletteSource::kDungeonMain});
    }
  }
 
  ImGui::Text(tr("RGB (0-255): (%d, %d, %d)"),
              static_cast<int>(editing_color_.x * 255),
              static_cast<int>(editing_color_.y * 255),
              static_cast<int>(editing_color_.z * 255));
  ImGui::Text(tr("SNES BGR555: 0x%04X"), original_color.snes());
 
  if (gui::ThemedButton("Reset to Original")) {
    editing_color_ = gui::ConvertSnesColorToImVec4(original_color);
    // Also reset the actual palette color
    palette[selected_color_index_] = original_color;
    dungeon_pal_group[current_palette_id_] = palette;
    if (on_palette_changed_) {
      on_palette_changed_(
          {current_palette_id_, DungeonRenderPaletteSource::kDungeonMain});
    }
  }
}
 
void PaletteEditorWidget::DrawDungeonRenderPalette() {
  ImGui::TextDisabled(tr("Slots 00-1F: HUD / floor / ceiling"));
  ImGui::TextDisabled(tr("Slots 20-7F: Dungeon main"));
  constexpr float kSwatchSpacing = 2.0f;
  const ImVec2 previous_spacing = ImGui::GetStyle().ItemSpacing;
  ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing,
                      ImVec2(kSwatchSpacing, previous_spacing.y));
  const int columns = ResolveDungeonRenderPaletteColumns(
      ImGui::GetContentRegionAvail().x, /*min_swatch_size=*/14.0f,
      kSwatchSpacing);
  const float swatch_size = ComputeSwatchSize(columns, 14.0f, 28.0f);
 
  for (int i = 0; i < 128; ++i) {
    if (i % columns != 0) {
      ImGui::SameLine();
    }
 
    gfx::SnesColor color(0);
    bool editable = false;
    std::string tooltip_label = "Reserved / transparent";
    int source_index = -1;
 
    const auto target = ResolveDungeonRenderColorTarget(i, current_palette_id_);
    if (target.has_value()) {
      const auto& group = PaletteGroupForTarget(*game_data_, *target);
      if (target->palette_index >= 0 &&
          target->palette_index < static_cast<int>(group.size())) {
        const auto& palette = group.palette_ref(target->palette_index);
        if (target->color_index >= 0 &&
            target->color_index < static_cast<int>(palette.size())) {
          color = palette[target->color_index];
          editable = true;
          tooltip_label = DungeonRenderColorSourceLabel(*target);
          source_index = target->color_index;
        }
      }
    }
 
    ImVec4 display_color = gui::ConvertSnesColorToImVec4(color);
    ImGui::PushID(i);
    if (!editable) {
      ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.25f);
    }
    const bool clicked = ImGui::ColorButton("##render_color", display_color,
                                            ImGuiColorEditFlags_NoTooltip,
                                            ImVec2(swatch_size, swatch_size));
    gui::AutoRegisterLastItem("color_button",
                              absl::StrFormat("palette_swatch_%03d", i),
                              "Dungeon render palette swatch");
    const ImVec2 swatch_min = ImGui::GetItemRectMin();
    const ImVec2 swatch_max = ImGui::GetItemRectMax();
    const bool double_clicked =
        editable && ImGui::IsItemHovered() &&
        ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
    if (!editable) {
      ImGui::PopStyleVar();
    }
 
    if ((clicked || double_clicked) && editable) {
      editing_color_index_ = i;
      selected_color_index_ = i;
      temp_color_ = display_color;
      editing_color_ = display_color;
    }
    gfx::SnesColor dropped_color = color;
    if (editable &&
        AcceptImGuiColorDrop(&dropped_color, swatch_min, swatch_max)) {
      const absl::Status status = ApplyDungeonRenderColorEdit(i, dropped_color);
      if (status.ok()) {
        selected_color_index_ = i;
        editing_color_index_ = i;
        temp_color_ = gui::ConvertSnesColorToImVec4(dropped_color);
        editing_color_ = temp_color_;
      } else {
        LOG_ERROR("PaletteEditorWidget", "Failed to apply dropped color: %s",
                  status.message().data());
      }
    }
 
    if (ImGui::IsItemHovered()) {
      if (editable) {
        ImGui::SetTooltip(tr("%s\nSlot %d\nSNES: 0x%04X\nRGB: (%d, %d, %d)"),
                          tooltip_label.c_str(), source_index, color.snes(),
                          static_cast<int>(display_color.x * 255),
                          static_cast<int>(display_color.y * 255),
                          static_cast<int>(display_color.z * 255));
      } else {
        ImGui::SetTooltip("%s", tooltip_label.c_str());
      }
    }
    ImGui::PopID();
  }
  ImGui::PopStyleVar();
}
 
float PaletteEditorWidget::ComputeSwatchSize(int columns, float min_size,
                                             float max_size) const {
  const float available_width =
      std::max(ImGui::GetContentRegionAvail().x, 1.0f);
  const float spacing =
      std::max(ImGui::GetStyle().ItemSpacing.x, 2.0f) * (columns - 1);
  const float raw = (available_width - spacing) / std::max(columns, 1);
  return std::clamp(raw, min_size, max_size);
}
 
void PaletteEditorWidget::DrawDungeonRenderColorPicker() {
  const auto target = ResolveDungeonRenderColorTarget(selected_color_index_,
                                                      current_palette_id_);
  if (!game_data_ || !target.has_value()) {
    selected_color_index_ = -1;
    editing_color_index_ = -1;
    return;
  }
 
  const auto& group = PaletteGroupForTarget(*game_data_, *target);
  if (target->palette_index < 0 ||
      target->palette_index >= static_cast<int>(group.size())) {
    selected_color_index_ = -1;
    editing_color_index_ = -1;
    return;
  }
  const auto& palette = group.palette_ref(target->palette_index);
  if (target->color_index < 0 ||
      target->color_index >= static_cast<int>(palette.size())) {
    selected_color_index_ = -1;
    editing_color_index_ = -1;
    return;
  }
 
  ImGui::SeparatorText(absl::StrFormat("%s Color %d",
                                       DungeonRenderColorSourceLabel(*target),
                                       target->color_index)
                           .c_str());
 
  const gfx::SnesColor current_color = palette[target->color_index];
  gfx::SnesColor edited_color = current_color;
  if (gui::SnesColorEdit4(
          "Color", &edited_color,
          ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_PickerHueWheel)) {
    const absl::Status status =
        ApplyDungeonRenderColorEdit(selected_color_index_, edited_color);
    if (status.ok()) {
      editing_color_ = gui::ConvertSnesColorToImVec4(edited_color);
    } else {
      LOG_ERROR("PaletteEditorWidget", "Failed to apply palette color: %s",
                status.message().data());
    }
  }
 
  uint16_t raw_color = current_color.snes();
  ImGui::AlignTextToFramePadding();
  ImGui::TextUnformatted(tr("Raw BGR555"));
  ImGui::SameLine();
  ImGui::SetNextItemWidth(96.0f);
  const bool raw_changed = gui::InputScalarDeferred(
      "##SelectedDungeonPaletteBgr555", ImGuiDataType_U16, &raw_color, "%04X",
      ImGuiInputTextFlags_CharsHexadecimal,
      {reinterpret_cast<uintptr_t>(game_data_),
       static_cast<uint64_t>(target->source),
       static_cast<uint64_t>(target->palette_index),
       static_cast<uint64_t>(target->color_index)});
  gui::AutoRegisterLastItem("input_scalar", "selected_palette_bgr555",
                            "Selected dungeon palette raw BGR555 color");
  if (raw_changed) {
    raw_color &= 0x7FFF;
    const gfx::SnesColor raw_edited_color(raw_color);
    const absl::Status status =
        ApplyDungeonRenderColorEdit(selected_color_index_, raw_edited_color);
    if (status.ok()) {
      editing_color_ = gui::ConvertSnesColorToImVec4(raw_edited_color);
    } else {
      LOG_ERROR("PaletteEditorWidget", "Failed to apply raw palette color: %s",
                status.message().data());
    }
  }
 
  ImGui::Text(tr("RGB (0-255): (%d, %d, %d)"),
              static_cast<int>(editing_color_.x * 255),
              static_cast<int>(editing_color_.y * 255),
              static_cast<int>(editing_color_.z * 255));
  ImGui::Text(tr("SNES BGR555: 0x%04X"), current_color.snes());
 
  if (gui::ThemedButton("Reset to Original")) {
    const absl::Status status =
        ApplyDungeonRenderColorEdit(selected_color_index_, std::nullopt);
    if (status.ok()) {
      const gfx::SnesColor reset_color = gfx::PaletteManager::Get().GetColor(
          PaletteManagerGroupName(target->source), target->palette_index,
          target->color_index);
      editing_color_ = gui::ConvertSnesColorToImVec4(reset_color);
    } else {
      LOG_ERROR("PaletteEditorWidget", "Failed to reset palette color: %s",
                status.message().data());
    }
  }
}
 
// --- Modal/Popup Methods (from feature-rich widget) ---
 
void PaletteEditorWidget::ShowPaletteEditor(gfx::SnesPalette& palette,
                                            const std::string& title) {
  if (ImGui::BeginPopupModal(title.c_str(), nullptr,
                             ImGuiWindowFlags_AlwaysAutoResize)) {
    ImGui::Text(tr("Enhanced Palette Editor"));
    ImGui::Separator();
 
    DrawPaletteGrid(palette);
    ImGui::Separator();
 
    if (ImGui::CollapsingHeader(tr("Palette Analysis"))) {
      DrawPaletteAnalysis(palette);
    }
 
    if (ImGui::CollapsingHeader(tr("ROM Palette Manager")) && rom_) {
      DrawROMPaletteSelector();
 
      if (gui::PrimaryButton("Apply ROM Palette") &&
          !rom_palette_groups_.empty()) {
        if (current_group_index_ <
            static_cast<int>(rom_palette_groups_.size())) {
          palette = rom_palette_groups_[current_group_index_];
        }
      }
    }
 
    ImGui::Separator();
 
    if (gui::ThemedButton("Save Backup")) {
      SavePaletteBackup(palette);
    }
    ImGui::SameLine();
    if (gui::ThemedButton("Restore Backup")) {
      RestorePaletteBackup(palette);
    }
    ImGui::SameLine();
    if (gui::ThemedButton("Close")) {
      ImGui::CloseCurrentPopup();
    }
 
    ImGui::EndPopup();
  }
}
 
void PaletteEditorWidget::ShowROMPaletteManager() {
  if (!show_rom_manager_)
    return;
 
  if (ImGui::Begin("ROM Palette Manager", &show_rom_manager_)) {
    if (!rom_) {
      ImGui::Text(tr("No ROM loaded"));
      ImGui::End();
      return;
    }
 
    if (!rom_palettes_loaded_) {
      LoadROMPalettes();
    }
 
    DrawROMPaletteSelector();
 
    if (current_group_index_ < static_cast<int>(rom_palette_groups_.size())) {
      ImGui::Separator();
      ImGui::Text(tr("Preview of %s:"),
                  palette_group_names_[current_group_index_].c_str());
 
      const auto& preview_palette = rom_palette_groups_[current_group_index_];
      DrawPaletteGrid(const_cast<gfx::SnesPalette&>(preview_palette));
      DrawPaletteAnalysis(preview_palette);
    }
  }
  ImGui::End();
}
 
void PaletteEditorWidget::ShowColorAnalysis(const gfx::Bitmap& bitmap,
                                            const std::string& title) {
  if (!show_color_analysis_)
    return;
 
  if (ImGui::Begin(title.c_str(), &show_color_analysis_)) {
    ImGui::Text(tr("Bitmap Color Analysis"));
    ImGui::Separator();
 
    if (!bitmap.is_active()) {
      ImGui::Text(tr("Bitmap is not active"));
      ImGui::End();
      return;
    }
 
    std::map<uint8_t, int> pixel_counts;
    const auto& data = bitmap.vector();
 
    for (uint8_t pixel : data) {
      uint8_t palette_index = pixel & 0x0F;
      pixel_counts[palette_index]++;
    }
 
    ImGui::Text(tr("Bitmap Size: %d x %d (%zu pixels)"), bitmap.width(),
                bitmap.height(), data.size());
 
    ImGui::Separator();
    ImGui::Text(tr("Pixel Distribution:"));
 
    int total_pixels = static_cast<int>(data.size());
    plotting::PlotStyleScope plot_style(
        gui::ThemeManager::Get().GetCurrentTheme());
    plotting::PlotConfig plot_cfg{.id = "Pixel Distribution",
                                  .x_label = "Palette Index",
                                  .y_label = "Count",
                                  .flags = ImPlotFlags_NoBoxSelect,
                                  .x_axis_flags = ImPlotAxisFlags_AutoFit,
                                  .y_axis_flags = ImPlotAxisFlags_AutoFit};
    std::vector<double> x;
    std::vector<double> y;
    x.reserve(pixel_counts.size());
    y.reserve(pixel_counts.size());
    for (const auto& [index, count] : pixel_counts) {
      x.push_back(static_cast<double>(index));
      y.push_back(static_cast<double>(count));
    }
    plotting::PlotGuard plot(plot_cfg);
    if (plot && !x.empty()) {
      ImPlot::PlotBars("Usage", x.data(), y.data(), static_cast<int>(x.size()),
                       0.67, 0.0, ImPlotBarsFlags_None);
    }
  }
  ImGui::End();
}
 
bool PaletteEditorWidget::ApplyROMPalette(gfx::Bitmap* bitmap, int group_index,
                                          int palette_index) {
  if (!bitmap || !rom_palettes_loaded_ || group_index < 0 ||
      group_index >= static_cast<int>(rom_palette_groups_.size())) {
    return false;
  }
 
  try {
    const auto& selected_palette = rom_palette_groups_[group_index];
    SavePaletteBackup(bitmap->palette());
 
    if (palette_index >= 0 && palette_index < 8) {
      bitmap->SetPaletteWithTransparent(selected_palette, palette_index);
    } else {
      bitmap->SetPalette(selected_palette);
    }
 
    gfx::Arena::Get().QueueTextureCommand(
        gfx::Arena::TextureCommandType::UPDATE, bitmap);
 
    current_group_index_ = group_index;
    current_palette_index_ = palette_index;
    return true;
  } catch (const std::exception& e) {
    return false;
  }
}
 
const gfx::SnesPalette* PaletteEditorWidget::GetSelectedROMPalette() const {
  if (!rom_palettes_loaded_ || current_group_index_ < 0 ||
      current_group_index_ >= static_cast<int>(rom_palette_groups_.size())) {
    return nullptr;
  }
  return &rom_palette_groups_[current_group_index_];
}
 
void PaletteEditorWidget::SavePaletteBackup(const gfx::SnesPalette& palette) {
  backup_palette_ = palette;
}
 
bool PaletteEditorWidget::RestorePaletteBackup(gfx::SnesPalette& palette) {
  if (backup_palette_.size() == 0) {
    return false;
  }
  palette = backup_palette_;
  return true;
}
 
// Unified grid drawing function
void PaletteEditorWidget::DrawPaletteGrid(gfx::SnesPalette& palette, int cols) {
  const float swatch_size =
      ComputeSwatchSize(cols, /*min_size=*/16.0f, /*max_size=*/30.0f);
  for (int i = 0; i < static_cast<int>(palette.size()); i++) {
    if (i % cols != 0)
      ImGui::SameLine();
 
    auto color = palette[i];
    ImVec4 display_color = gui::ConvertSnesColorToImVec4(color);
 
    ImGui::PushID(i);
    const bool clicked = ImGui::ColorButton("##color", display_color,
                                            ImGuiColorEditFlags_NoTooltip,
                                            ImVec2(swatch_size, swatch_size));
    const ImVec2 swatch_min = ImGui::GetItemRectMin();
    const ImVec2 swatch_max = ImGui::GetItemRectMax();
    const bool double_clicked =
        ImGui::IsItemHovered() &&
        ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
    if (clicked || double_clicked) {
      editing_color_index_ = i;
      selected_color_index_ = i;
      temp_color_ = display_color;
      editing_color_ = display_color;
    }
    if (AcceptImGuiColorDrop(&palette[i], swatch_min, swatch_max)) {
      selected_color_index_ = i;
      editing_color_index_ = i;
      temp_color_ = gui::ConvertSnesColorToImVec4(palette[i]);
      editing_color_ = temp_color_;
      if (on_palette_changed_) {
        on_palette_changed_(
            {current_palette_id_, DungeonRenderPaletteSource::kDungeonMain});
      }
    }
 
    if (ImGui::BeginPopupContextItem()) {
      ImGui::TextDisabled(tr("Color %d (0x%04X)"), i, color.snes());
      ImGui::Separator();
      std::vector<MenuItemSpec> items;
      items.emplace_back(tr("Edit Color..."), ICON_MD_EDIT, [&, i]() {
        editing_color_index_ = i;
        selected_color_index_ = i;
        temp_color_ = display_color;
        editing_color_ = display_color;
      });
      items.back().separator_after = true;
      RenderMenuItems(items);
      SnesColorCopyMenuItems(palette[i]);
      ImGui::Separator();
      RenderMenuItem(MenuItemSpec::Destructive(
          tr("Reset to Black"), ICON_MD_FORMAT_COLOR_RESET,
          [&, i]() {
            palette[i] = gfx::SnesColor(0);
            if (on_palette_changed_) {
              on_palette_changed_({current_palette_id_,
                                   DungeonRenderPaletteSource::kDungeonMain});
            }
          },
          /*confirm=*/false));
      ImGui::EndPopup();
    }
 
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Color %d\nSNES: 0x%04X\nRGB: (%d, %d, %d)"), i,
                        color.snes(), static_cast<int>(display_color.x * 255),
                        static_cast<int>(display_color.y * 255),
                        static_cast<int>(display_color.z * 255));
    }
 
    ImGui::PopID();
  }
 
  if (editing_color_index_ >= 0) {
    // Use a unique ID for the popup to prevent conflicts
    std::string popup_id =
        gui::MakePopupIdWithInstance("PaletteEditorWidget", "EditColor", this);
 
    ImGui::OpenPopup(popup_id.c_str());
    if (ImGui::BeginPopupModal(popup_id.c_str(), nullptr,
                               ImGuiWindowFlags_AlwaysAutoResize)) {
      ImGui::Text(tr("Editing Color %d"), editing_color_index_);
      if (ImGui::ColorEdit4(
              "Color", &temp_color_.x,
              ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_DisplayRGB)) {
        auto new_snes_color = gfx::SnesColor(temp_color_);
        palette[editing_color_index_] = new_snes_color;
        if (selected_color_index_ == editing_color_index_) {
          editing_color_ = temp_color_;
        }
        if (on_palette_changed_) {
          on_palette_changed_(
              {current_palette_id_, DungeonRenderPaletteSource::kDungeonMain});
        }
      }
      if (gui::PrimaryButton("Apply")) {
        editing_color_index_ = -1;
        ImGui::CloseCurrentPopup();
      }
      ImGui::SameLine();
      if (gui::ThemedButton("Cancel")) {
        editing_color_index_ = -1;
        ImGui::CloseCurrentPopup();
      }
      ImGui::EndPopup();
    }
  }
}
 
void PaletteEditorWidget::DrawROMPaletteSelector() {
  if (!rom_palettes_loaded_) {
    LoadROMPalettes();
  }
 
  if (rom_palette_groups_.empty()) {
    ImGui::Text(tr("No ROM palettes available"));
    return;
  }
 
  ImGui::Text(tr("Palette Group:"));
  if (ImGui::Combo("##PaletteGroup", &current_group_index_,
                   RomPaletteGroupNameGetter, &palette_group_names_,
                   static_cast<int>(palette_group_names_.size()))) {}
 
  ImGui::Text(tr("Palette Index:"));
  ImGui::SliderInt("##PaletteIndex", &current_palette_index_, 0, 7, "%d");
 
  if (current_group_index_ < static_cast<int>(rom_palette_groups_.size())) {
    ImGui::Text(tr("Preview:"));
    const auto& preview_palette = rom_palette_groups_[current_group_index_];
    for (int i = 0; i < 8 && i < static_cast<int>(preview_palette.size());
         i++) {
      if (i > 0)
        ImGui::SameLine();
      auto color = preview_palette[i];
      ImVec4 display_color = gui::ConvertSnesColorToImVec4(color);
      ImGui::ColorButton(("##preview" + std::to_string(i)).c_str(),
                         display_color, ImGuiColorEditFlags_NoTooltip,
                         ImVec2(20, 20));
    }
  }
}
 
void PaletteEditorWidget::DrawColorEditControls(gfx::SnesColor& color,
                                                int color_index) {
  ImVec4 rgba = gui::ConvertSnesColorToImVec4(color);
 
  ImGui::PushID(color_index);
 
  if (ImGui::ColorEdit4(
          "##color_edit", &rgba.x,
          ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_DisplayRGB)) {
    color = gfx::SnesColor(rgba);
  }
 
  ImGui::Text(tr("SNES Color: 0x%04X"), color.snes());
 
  int r = (color.snes() & 0x1F);
  int g = (color.snes() >> 5) & 0x1F;
  int b = (color.snes() >> 10) & 0x1F;
 
  if (ImGui::SliderInt(tr("Red"), &r, 0, 31)) {
    uint16_t new_color = (color.snes() & 0xFFE0) | (r & 0x1F);
    color = gfx::SnesColor(new_color);
  }
  if (ImGui::SliderInt(tr("Green"), &g, 0, 31)) {
    uint16_t new_color = (color.snes() & 0xFC1F) | ((g & 0x1F) << 5);
    color = gfx::SnesColor(new_color);
  }
  if (ImGui::SliderInt(tr("Blue"), &b, 0, 31)) {
    uint16_t new_color = (color.snes() & 0x83FF) | ((b & 0x1F) << 10);
    color = gfx::SnesColor(new_color);
  }
 
  ImGui::PopID();
}
 
void PaletteEditorWidget::DrawPaletteAnalysis(const gfx::SnesPalette& palette) {
  ImGui::Text(tr("Palette Information:"));
  ImGui::Text(tr("Size: %zu colors"), palette.size());
 
  std::map<uint16_t, int> color_frequency;
  for (int i = 0; i < static_cast<int>(palette.size()); i++) {
    color_frequency[palette[i].snes()]++;
  }
 
  ImGui::Text(tr("Unique Colors: %zu"), color_frequency.size());
 
  if (color_frequency.size() < palette.size()) {
    ImGui::TextColored(ImVec4(1, 1, 0, 1),
                       tr("Warning: Duplicate colors detected!"));
    if (ImGui::TreeNode("Duplicate Colors")) {
      for (const auto& [snes_color, count] : color_frequency) {
        if (count > 1) {
          ImVec4 display_color =
              gui::ConvertSnesColorToImVec4(gfx::SnesColor(snes_color));
          ImGui::ColorButton(("##dup" + std::to_string(snes_color)).c_str(),
                             display_color, ImGuiColorEditFlags_NoTooltip,
                             ImVec2(16, 16));
          ImGui::SameLine();
          ImGui::Text(tr("0x%04X appears %d times"), snes_color, count);
        }
      }
      ImGui::TreePop();
    }
  }
 
  // Visual histogram of color reuse
  {
    plotting::PlotStyleScope plot_style(
        gui::ThemeManager::Get().GetCurrentTheme());
    plotting::PlotConfig plot_cfg{.id = "Palette Color Frequency",
                                  .x_label = "Color Index",
                                  .y_label = "Count",
                                  .flags = ImPlotFlags_NoBoxSelect,
                                  .x_axis_flags = ImPlotAxisFlags_AutoFit,
                                  .y_axis_flags = ImPlotAxisFlags_AutoFit};
    std::vector<double> x;
    std::vector<double> y;
    x.reserve(color_frequency.size());
    y.reserve(color_frequency.size());
    for (const auto& [snes_color, count] : color_frequency) {
      x.push_back(static_cast<double>(snes_color));
      y.push_back(static_cast<double>(count));
    }
    plotting::PlotGuard plot(plot_cfg);
    if (plot && !x.empty()) {
      ImPlot::PlotBars("Count", x.data(), y.data(), static_cast<int>(x.size()),
                       0.5, 0.0, ImPlotBarsFlags_None);
    }
  }
 
  float total_brightness = 0.0f;
  float min_brightness = 1.0f;
  float max_brightness = 0.0f;
 
  for (int i = 0; i < static_cast<int>(palette.size()); i++) {
    ImVec4 color = gui::ConvertSnesColorToImVec4(palette[i]);
    float brightness = (color.x + color.y + color.z) / 3.0f;
    total_brightness += brightness;
    min_brightness = std::min(min_brightness, brightness);
    max_brightness = std::max(max_brightness, brightness);
  }
 
  float avg_brightness = total_brightness / palette.size();
 
  ImGui::Separator();
  ImGui::Text(tr("Brightness Analysis:"));
  ImGui::Text(tr("Average: %.2f"), avg_brightness);
  ImGui::Text(tr("Range: %.2f - %.2f"), min_brightness, max_brightness);
 
  ImGui::Text(tr("Brightness Distribution:"));
  ImGui::ProgressBar(avg_brightness, ImVec2(-1, 0), "Avg");
}
 
void PaletteEditorWidget::LoadROMPalettes() {
  if (!game_data_ || rom_palettes_loaded_)
    return;
 
  try {
    const auto& palette_groups = game_data_->palette_groups;
    rom_palette_groups_.clear();
    palette_group_names_.clear();
 
    if (palette_groups.overworld_main.size() > 0) {
      rom_palette_groups_.push_back(palette_groups.overworld_main[0]);
      palette_group_names_.push_back("Overworld Main");
    }
    if (palette_groups.overworld_aux.size() > 0) {
      rom_palette_groups_.push_back(palette_groups.overworld_aux[0]);
      palette_group_names_.push_back("Overworld Aux");
    }
    if (palette_groups.overworld_animated.size() > 0) {
      rom_palette_groups_.push_back(palette_groups.overworld_animated[0]);
      palette_group_names_.push_back("Overworld Animated");
    }
    if (palette_groups.dungeon_main.size() > 0) {
      rom_palette_groups_.push_back(palette_groups.dungeon_main[0]);
      palette_group_names_.push_back("Dungeon Main");
    }
    if (palette_groups.global_sprites.size() > 0) {
      rom_palette_groups_.push_back(palette_groups.global_sprites[0]);
      palette_group_names_.push_back("Global Sprites");
    }
    if (palette_groups.armors.size() > 0) {
      rom_palette_groups_.push_back(palette_groups.armors[0]);
      palette_group_names_.push_back("Armor");
    }
    if (palette_groups.swords.size() > 0) {
      rom_palette_groups_.push_back(palette_groups.swords[0]);
      palette_group_names_.push_back("Swords");
    }
 
    rom_palettes_loaded_ = true;
  } catch (const std::exception& e) {
    LOG_ERROR("Enhanced Palette Editor", "Failed to load ROM palettes");
  }
}
 
}  // namespace gui
}  // namespace yaze