dungeon_canvas_issue_report.cc

Go to the documentation of this file.

#include "app/editor/dungeon/dungeon_canvas_viewer.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <array>
#include <cstdio>
#include <filesystem>
#include <limits>
#include <optional>
#include <set>
#include <span>
#include <string>
#include <string_view>
#include <tuple>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "app/editor/dungeon/ui/reporting/dungeon_issue_report_storage.h"
#include "app/gfx/resource/arena.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/themed_widgets.h"
#ifdef YAZE_WITH_GRPC
#include "app/service/screenshot_utils.h"
#endif
#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"
#include "util/macro.h"
#include "util/platform_paths.h"
#include "util/rom_hash.h"
#include "zelda3/dungeon/dimension_service.h"
#include "zelda3/dungeon/object_drawer.h"
#include "zelda3/dungeon/object_layer_semantics.h"
#include "zelda3/dungeon/palette_debug.h"
#include "zelda3/dungeon/room_object.h"
#include "zelda3/resource_labels.h"
#include "zelda3/sprite/sprite.h"
 
namespace yaze::editor {
 
namespace {
 
constexpr float kIssueReportDialogWidth = 640.0f;
constexpr float kIssueReportDialogHeight = 620.0f;
constexpr float kIssueReportDialogMinWidth = 360.0f;
constexpr float kIssueReportDialogMinHeight = 340.0f;
constexpr float kIssueReportDialogViewportMargin = 16.0f;
constexpr float kIssueReportNotesHeight = 116.0f;
constexpr float kIssueReportDiagnosticsHeight = 168.0f;
constexpr char kIssueReportSummaryHint[] = "What looks wrong?";
constexpr char kIssueReportPopupIdDiagnostics[] = "##DungeonIssueDiagnostics";
constexpr char kIssueReportSectionPaths[] = "Local files";
constexpr char kIssueReportSectionDiagnostics[] = "Diagnostics";
constexpr char kIssueReportStatusIdle[] =
    "Local draft. Nothing is uploaded or submitted.";
constexpr char kIssueReportStatusSavedScreenshot[] =
    "Screenshot captured. Open Local files for its path.";
constexpr char kIssueReportStatusSavedLog[] = "Saved to the local issue log.";
constexpr char kIssueReportStatusCopiedReport[] =
    "Copied report to clipboard. Nothing was submitted.";
constexpr char kIssueReportStatusCopiedDiagnostics[] =
    "Copied diagnostics to clipboard. Nothing was submitted.";
constexpr char kIssueReportCaptureButtonLabel[] =
    ICON_MD_ADD_A_PHOTO " Capture Screenshot";
constexpr char kIssueReportRecaptureButtonLabel[] =
    ICON_MD_PHOTO_CAMERA " Re-capture Screenshot";
constexpr char kIssueReportSaveButtonLabel[] =
    ICON_MD_SAVE_AS " Save to Issue Log";
constexpr char kIssueReportCopyButtonLabel[] =
    ICON_MD_CONTENT_COPY " Copy Report";
constexpr char kIssueReportCloseButtonLabel[] = ICON_MD_CLOSE " Close";
 
struct IssueReportWindowLayout {
  ImVec2 center;
  ImVec2 initial_size;
  ImVec2 min_size;
  ImVec2 max_size;
};
 
IssueReportWindowLayout GetIssueReportWindowLayout() {
  const ImGuiViewport* viewport = ImGui::GetMainViewport();
  const ImVec2 work_size =
      viewport != nullptr ? viewport->WorkSize : ImGui::GetIO().DisplaySize;
  const ImVec2 center = viewport != nullptr
                            ? viewport->GetWorkCenter()
                            : ImVec2(work_size.x * 0.5f, work_size.y * 0.5f);
  const ImVec2 max_size(
      std::max(1.0f, work_size.x - kIssueReportDialogViewportMargin * 2.0f),
      std::max(1.0f, work_size.y - kIssueReportDialogViewportMargin * 2.0f));
  const ImVec2 min_size(std::min(kIssueReportDialogMinWidth, max_size.x),
                        std::min(kIssueReportDialogMinHeight, max_size.y));
  const ImVec2 initial_size(
      std::clamp(kIssueReportDialogWidth, min_size.x, max_size.x),
      std::clamp(kIssueReportDialogHeight, min_size.y, max_size.y));
  return {center, initial_size, min_size, max_size};
}
 
float GetIssueActionButtonWidth(const char* label) {
  float text_width = ImGui::CalcTextSize(label).x;
  if (label == kIssueReportCaptureButtonLabel ||
      label == kIssueReportRecaptureButtonLabel) {
    text_width =
        std::max(ImGui::CalcTextSize(kIssueReportCaptureButtonLabel).x,
                 ImGui::CalcTextSize(kIssueReportRecaptureButtonLabel).x);
  }
  return text_width + ImGui::GetStyle().FramePadding.x * 2.0f;
}
 
int CountWrappedIssueActionRows(std::span<const char* const> labels,
                                float available_width) {
  const float spacing = ImGui::GetStyle().ItemSpacing.x;
  float used_width = 0.0f;
  int rows = labels.empty() ? 0 : 1;
  for (const char* label : labels) {
    const float button_width = GetIssueActionButtonWidth(label);
    if (used_width > 0.0f &&
        used_width + spacing + button_width > available_width) {
      ++rows;
      used_width = button_width;
    } else {
      used_width += (used_width > 0.0f ? spacing : 0.0f) + button_width;
    }
  }
  return rows;
}
 
void PlaceNextIssueAction(const char* label, float available_width,
                          float* used_width) {
  const float spacing = ImGui::GetStyle().ItemSpacing.x;
  const float button_width = GetIssueActionButtonWidth(label);
  if (*used_width > 0.0f &&
      *used_width + spacing + button_width <= available_width) {
    ImGui::SameLine();
    *used_width += spacing + button_width;
    return;
  }
  *used_width = button_width;
}
 
const char* GetStoredPlacementLabel(const zelda3::RoomObject& object) {
  const int layer_value = object.GetLayerValue();
  if (!zelda3::UsesRoomObjectStream(object)) {
    if (layer_value == 0) {
      return "Upper layer (BG1)";
    }
    return layer_value == 1 ? "Lower layer (BG2)" : "Invalid selector";
  }
  switch (layer_value) {
    case 0:
      return "Primary";
    case 1:
      return "BG2 overlay";
    case 2:
      return "BG1 overlay";
    default:
      return "Unknown";
  }
}
 
const char* GetBlocksetGroupName(uint8_t blockset) {
  static const char* kGroupNames[] = {
      "HC/Sewers", "Eastern", "Desert", "Hera",   "A-Tower", "PoD", "Swamp",
      "Skull",     "Thieves", "Ice",    "Misery", "Turtle",  "GT",
  };
  constexpr size_t kCount = sizeof(kGroupNames) / sizeof(kGroupNames[0]);
  return blockset < kCount ? kGroupNames[blockset] : "Custom";
}
 
std::string BuildIssueTimestampSlug() {
  return absl::FormatTime("%Y%m%d-%H%M%S", absl::Now(), absl::LocalTimeZone());
}
 
std::string BuildIssueTimestampDisplay() {
  return absl::FormatTime("%Y-%m-%d %H:%M:%S %Z", absl::Now(),
                          absl::LocalTimeZone());
}
 
std::string BuildEffectiveBlockListSummary(const zelda3::Room& room) {
  const auto blocks = room.blocks();
  if (blocks.size() < 8) {
    return "BG sheets: unavailable";
  }
  return absl::StrFormat(
      "BG sheets: [%02X %02X %02X %02X %02X %02X %02X %02X]",
      static_cast<int>(blocks[0]), static_cast<int>(blocks[1]),
      static_cast<int>(blocks[2]), static_cast<int>(blocks[3]),
      static_cast<int>(blocks[4]), static_cast<int>(blocks[5]),
      static_cast<int>(blocks[6]), static_cast<int>(blocks[7]));
}
 
std::string BuildSelectedObjectSemanticsSummary(const zelda3::RoomObject& obj) {
  const auto semantics = zelda3::GetObjectLayerSemantics(obj);
  if (!zelda3::UsesRoomObjectStream(obj)) {
    return absl::StrFormat(
        "storage=special-table selector=%d (%s) routine=%d "
        "legacy_both_bgs=%s "
        "routing=%s",
        obj.GetLayerValue(), GetStoredPlacementLabel(obj), semantics.routine_id,
        semantics.draws_to_both_bgs ? "yes" : "no",
        zelda3::ObjectRenderRoutingToken(semantics.render_routing));
  }
  return absl::StrFormat(
      "stream=%s draw_layer=%d effective_bg=%s routine=%d "
      "legacy_both_bgs=%s "
      "routing=%s",
      GetStoredPlacementLabel(obj),
      static_cast<int>(
          zelda3::MapRoomObjectListIndexToDrawLayer(obj.GetLayerValue())),
      zelda3::EffectiveBgLayerLabel(semantics.effective_bg_layer),
      semantics.routine_id, semantics.draws_to_both_bgs ? "yes" : "no",
      zelda3::ObjectRenderRoutingToken(semantics.render_routing));
}
 
const char* TraceLayerLabel(uint8_t layer) {
  switch (static_cast<zelda3::RoomObject::LayerType>(layer)) {
    case zelda3::RoomObject::LayerType::BG1:
      return "BG1";
    case zelda3::RoomObject::LayerType::BG2:
      return "BG2";
    case zelda3::RoomObject::LayerType::BG3:
      return "BG3";
  }
  return "BG?";
}
 
std::string FormatObjectTileSample(std::span<const gfx::TileInfo> tiles,
                                   size_t max_count, std::string_view prefix) {
  std::string out = absl::StrFormat("%s count=%zu", std::string(prefix).c_str(),
                                    tiles.size());
  const size_t preview_count = std::min<size_t>(tiles.size(), max_count);
  for (size_t i = 0; i < preview_count; ++i) {
    const auto& tile = tiles[i];
    out += absl::StrFormat(" [%zu]=0x%03X/p%d/pr%d/h%d/v%d", i, tile.id_,
                           static_cast<int>(tile.palette_), tile.over_ ? 1 : 0,
                           tile.horizontal_mirror_ ? 1 : 0,
                           tile.vertical_mirror_ ? 1 : 0);
  }
  if (tiles.size() > preview_count) {
    out += absl::StrFormat(" ... %zu more", tiles.size() - preview_count);
  }
  return out;
}
 
struct ObjectTraceReport {
  std::string summary;
  std::vector<zelda3::ObjectDrawer::TileTrace> writes;
};
 
struct ScopedBitmapRetirement {
  std::array<gfx::Bitmap*, 2> bitmaps;
 
  ~ScopedBitmapRetirement() {
    for (gfx::Bitmap* bitmap : bitmaps) {
      if (bitmap != nullptr) {
        gfx::Arena::Get().RetireBitmap(*bitmap);
      }
    }
  }
};
 
ObjectTraceReport BuildObjectTraceReport(
    Rom* rom, const zelda3::Room& room, size_t selected_index,
    const gfx::PaletteGroup& palette_group) {
  if (rom == nullptr || !rom->is_loaded()) {
    return {.summary = "\nDrawer trace: unavailable (ROM not loaded)"};
  }
 
  const auto& objects = room.GetTileObjects();
  if (selected_index >= objects.size()) {
    return {.summary = "\nDrawer trace: unavailable (stale selection)"};
  }
  if (!zelda3::UsesRoomObjectStream(objects[selected_index])) {
    return {.summary =
                "\nDrawer trace: unavailable (special-table object uses the "
                "dedicated room pass)"};
  }
 
  // The report must follow the same primary -> BG2 overlay -> BG1 overlay
  // order as Room::RenderObjectsToBackground. Earlier object writes can own a
  // physical tilemap entry and therefore override the matching layout word
  // used by conditional edge/cap routines.
  zelda3::ObjectDrawer drawer(rom, room.id(), room.get_gfx_buffer().data());
  drawer.SetRoomFloorGraphics(room.floor1(), room.floor2());
  drawer.SetBG1RevealMaskSource(gfx::BG1RevealMaskSource::kBG2Objects);
  gfx::BackgroundBuffer bg1(512, 512);
  gfx::BackgroundBuffer bg2(512, 512);
  gfx::BackgroundBuffer layout_bg1(512, 512);
  gfx::BackgroundBuffer layout_bg2(512, 512);
  ScopedBitmapRetirement retire_trace_bitmaps{{&bg1.bitmap(), &bg2.bitmap()}};
  for (auto* buffer : {&bg1, &bg2}) {
    buffer->EnsureBitmapInitialized();
    buffer->bitmap().Fill(255);
    buffer->ClearBuffer();
  }
  layout_bg1.buffer() = room.bg1_buffer().buffer();
  layout_bg2.buffer() = room.bg2_buffer().buffer();
 
  std::vector<zelda3::ObjectDrawer::TileTrace> trace;
  absl::Status status = absl::NotFoundError("selected object not replayed");
  bool selected_was_replayed = false;
  for (uint8_t pass = 0; pass < 3 && !selected_was_replayed; ++pass) {
    for (size_t index = 0; index < objects.size(); ++index) {
      const auto& stored_obj = objects[index];
      if (!zelda3::UsesRoomObjectStream(stored_obj)) {
        continue;
      }
      const uint8_t list_index =
          std::min<uint8_t>(stored_obj.GetLayerValue(), 2);
      if (list_index != pass) {
        continue;
      }
 
      zelda3::RoomObject render_obj = stored_obj;
      render_obj.layer_ = zelda3::MapRoomObjectListIndexToDrawLayer(list_index);
      if (index == selected_index) {
        drawer.SetTraceCollector(&trace, /*trace_only=*/false);
        status =
            drawer.DrawObject(render_obj, bg1, bg2, palette_group,
                              room.GetDungeonState(), &layout_bg1, &layout_bg2);
        drawer.ClearTraceCollector();
        selected_was_replayed = true;
        break;
      }
 
      status =
          drawer.DrawObject(render_obj, bg1, bg2, palette_group,
                            room.GetDungeonState(), &layout_bg1, &layout_bg2);
      if (!status.ok()) {
        break;
      }
    }
    if (!status.ok() && !selected_was_replayed) {
      break;
    }
  }
  if (!status.ok()) {
    return {.summary = absl::StrFormat("\nDrawer trace: unavailable (%s)",
                                       std::string(status.message()).c_str())};
  }
 
  if (trace.empty()) {
    return {.summary = "\nDrawer trace: status=ok writes=0"};
  }
 
  int min_x = std::numeric_limits<int>::max();
  int min_y = std::numeric_limits<int>::max();
  int max_x = std::numeric_limits<int>::min();
  int max_y = std::numeric_limits<int>::min();
  std::array<int, 3> layer_counts = {0, 0, 0};
  std::set<std::tuple<int, int, uint8_t>> unique_cells;
  for (const auto& write : trace) {
    min_x = std::min<int>(min_x, write.x_tile);
    min_y = std::min<int>(min_y, write.y_tile);
    max_x = std::max<int>(max_x, write.x_tile);
    max_y = std::max<int>(max_y, write.y_tile);
    if (write.layer < layer_counts.size()) {
      ++layer_counts[write.layer];
    }
    unique_cells.insert({write.x_tile, write.y_tile, write.layer});
  }
 
  std::string out = absl::StrFormat(
      "\nDrawer trace: status=ok context=room-stream-prefix+layout-tilewords "
      "writes=%zu unique_cells=%zu "
      "bounds_tiles=(%d,%d)..(%d,%d) layer_counts BG1=%d BG2=%d BG3=%d",
      trace.size(), unique_cells.size(), min_x, min_y, max_x, max_y,
      layer_counts[zelda3::RoomObject::LayerType::BG1],
      layer_counts[zelda3::RoomObject::LayerType::BG2],
      layer_counts[zelda3::RoomObject::LayerType::BG3]);
 
  const size_t preview_count = std::min<size_t>(trace.size(), 12);
  for (size_t i = 0; i < preview_count; ++i) {
    const auto& write = trace[i];
    const int palette = (write.flags >> 3) & 0x7;
    out += absl::StrFormat(
        "\n  write[%zu] %s tile=(%d,%d) id=0x%03X pal=%d pri=%d h=%d v=%d", i,
        TraceLayerLabel(write.layer), write.x_tile, write.y_tile, write.tile_id,
        palette, (write.flags & 0x4) ? 1 : 0, (write.flags & 0x1) ? 1 : 0,
        (write.flags & 0x2) ? 1 : 0);
  }
  if (trace.size() > preview_count) {
    out += absl::StrFormat("\n  ... %zu more write(s)",
                           trace.size() - preview_count);
  }
  return {.summary = std::move(out), .writes = std::move(trace)};
}
 
struct PaletteSamplePoint {
  std::string label;
  int x = 0;
  int y = 0;
};
 
bool PaletteIndexMatchesTracePalette(int palette_index, uint8_t trace_flags) {
  if (palette_index < 0 || (palette_index & 0x0F) == 0) {
    return false;
  }
  const uint8_t trace_palette = static_cast<uint8_t>((trace_flags >> 3) & 0x7);
  return static_cast<uint8_t>((palette_index >> 4) & 0x7) == trace_palette;
}
 
std::optional<PaletteSamplePoint> ChooseObjectTracePaletteSample(
    std::span<const zelda3::ObjectDrawer::TileTrace> trace,
    const zelda3::PaletteDebugger& palette_debugger) {
  constexpr std::array<std::pair<int, int>, 6> kPreferredOffsets = {
      std::pair{4, 4}, std::pair{3, 3}, std::pair{0, 0},
      std::pair{7, 7}, std::pair{0, 7}, std::pair{7, 0},
  };
 
  for (size_t i = 0; i < trace.size(); ++i) {
    const auto& write = trace[i];
    const int tile_origin_x = write.x_tile * 8;
    const int tile_origin_y = write.y_tile * 8;
    const auto label = absl::StrFormat(
        "object-trace[%zu] tile=(%d,%d) pal=%d", i, write.x_tile, write.y_tile,
        static_cast<int>((write.flags >> 3) & 0x7));
 
    for (const auto& [dx, dy] : kPreferredOffsets) {
      const int sample_x = tile_origin_x + dx;
      const int sample_y = tile_origin_y + dy;
      const auto comp = palette_debugger.SamplePixelAt(sample_x, sample_y);
      if (PaletteIndexMatchesTracePalette(comp.palette_index, write.flags)) {
        return PaletteSamplePoint{.label = label, .x = sample_x, .y = sample_y};
      }
    }
 
    for (int dy = 0; dy < 8; ++dy) {
      for (int dx = 0; dx < 8; ++dx) {
        const int sample_x = tile_origin_x + dx;
        const int sample_y = tile_origin_y + dy;
        const auto comp = palette_debugger.SamplePixelAt(sample_x, sample_y);
        if (PaletteIndexMatchesTracePalette(comp.palette_index, write.flags)) {
          return PaletteSamplePoint{
              .label = label, .x = sample_x, .y = sample_y};
        }
      }
    }
  }
 
  if (!trace.empty()) {
    const auto& write = trace.front();
    return PaletteSamplePoint{
        .label = absl::StrFormat("object-trace[0] tile=(%d,%d) pal=%d fallback",
                                 write.x_tile, write.y_tile,
                                 static_cast<int>((write.flags >> 3) & 0x7)),
        .x = write.x_tile * 8 + 4,
        .y = write.y_tile * 8 + 4};
  }
 
  return std::nullopt;
}
 
std::string BuildObjectTraceBoundsSummary(
    std::span<const zelda3::ObjectDrawer::TileTrace> trace, int selection_x_px,
    int selection_y_px, int selection_w_px, int selection_h_px) {
  if (trace.empty()) {
    return "trace: writes=0";
  }
 
  int min_x = std::numeric_limits<int>::max();
  int min_y = std::numeric_limits<int>::max();
  int max_x = std::numeric_limits<int>::min();
  int max_y = std::numeric_limits<int>::min();
  std::set<std::tuple<int, int, uint8_t>> unique_cells;
  for (const auto& write : trace) {
    min_x = std::min<int>(min_x, write.x_tile);
    min_y = std::min<int>(min_y, write.y_tile);
    max_x = std::max<int>(max_x, write.x_tile);
    max_y = std::max<int>(max_y, write.y_tile);
    unique_cells.insert({write.x_tile, write.y_tile, write.layer});
  }
 
  const int trace_x_px = min_x * 8;
  const int trace_y_px = min_y * 8;
  const int trace_w_px = (max_x - min_x + 1) * 8;
  const int trace_h_px = (max_y - min_y + 1) * 8;
  return absl::StrFormat(
      "trace: writes=%zu unique_cells=%zu bounds_px=(%d,%d,%d,%d) "
      "delta_vs_selection_px=(%+d,%+d,%+d,%+d)",
      trace.size(), unique_cells.size(), trace_x_px, trace_y_px, trace_w_px,
      trace_h_px, trace_x_px - selection_x_px, trace_y_px - selection_y_px,
      trace_w_px - selection_w_px, trace_h_px - selection_h_px);
}
 
std::string BuildDoorIssueSummary(const zelda3::Room::Door& door, size_t index,
                                  std::string_view label) {
  const auto [tile_x, tile_y] = door.GetTileCoords();
  const auto [pixel_x, pixel_y] = door.GetPixelCoords();
  const auto dims = door.GetDimensions();
  const auto editor_dims = door.GetEditorDimensions();
  const auto [bounds_x, bounds_y, bounds_w, bounds_h] = door.GetBounds();
  const auto [editor_x, editor_y, editor_w, editor_h] = door.GetEditorBounds();
  const auto [encoded_b1, encoded_b2] = door.EncodeBytes();
 
  return absl::StrFormat(
      "\n%s[%zu]:\n"
      "- type=%s (0x%02X)\n"
      "- direction=%s (%d)\n"
      "- position=%d\n"
      "- tile_coords=(%d,%d) pixel_coords=(%d,%d)\n"
      "- dims_tiles=(%d,%d) editor_dims_tiles=(%d,%d)\n"
      "- bounds_px=(%d,%d,%d,%d) editor_bounds_px=(%d,%d,%d,%d)\n"
      "- encoded=(0x%02X,0x%02X) original=(0x%02X,0x%02X)",
      std::string(label).c_str(), index,
      std::string(zelda3::GetDoorTypeName(door.type)).c_str(),
      static_cast<int>(door.type),
      std::string(zelda3::GetDoorDirectionName(door.direction)).c_str(),
      static_cast<int>(door.direction), static_cast<int>(door.position), tile_x,
      tile_y, pixel_x, pixel_y, dims.width_tiles, dims.height_tiles,
      editor_dims.width_tiles, editor_dims.height_tiles, bounds_x, bounds_y,
      bounds_w, bounds_h, editor_x, editor_y, editor_w, editor_h, encoded_b1,
      encoded_b2, door.byte1, door.byte2);
}
 
std::string BuildRomDisplayName(const Rom& rom) {
  if (!rom.short_name().empty()) {
    return rom.short_name();
  }
  if (!rom.filename().empty()) {
    return std::filesystem::path(rom.filename()).filename().string();
  }
  const std::string title = rom.title();
  return title.empty() ? "in-memory ROM" : title;
}
 
std::string BuildReportSessionSummary(const Rom* rom,
                                      const project::YazeProject* project) {
  std::string summary;
  if (rom && rom->is_loaded()) {
    const std::string rom_path =
        rom->filename().empty()
            ? std::string("in-memory")
            : util::PlatformPaths::NormalizePathForDisplay(rom->filename());
    summary += absl::StrFormat(
        "ROM: %s | CRC32:%s | Path:%s", BuildRomDisplayName(*rom).c_str(),
        util::ComputeRomHash(rom->data(), rom->size()).c_str(),
        rom_path.c_str());
  } else {
    summary += "ROM: unavailable";
  }
 
  if (project && project->project_opened()) {
    summary += absl::StrFormat(
        "\nProject: %s | Path:%s", project->GetDisplayName().c_str(),
        util::PlatformPaths::NormalizePathForDisplay(project->filepath)
            .c_str());
  }
 
  return summary;
}
 
std::string FormatPaletteDebugEventForReport(
    const zelda3::PaletteDebugEvent& event) {
  if (event.palette_id >= 0 && event.color_count > 0) {
    return absl::StrFormat("- [%s] palette=%d colors=%d %s",
                           event.location.c_str(), event.palette_id,
                           event.color_count, event.message.c_str());
  }
  if (event.palette_id >= 0) {
    return absl::StrFormat("- [%s] palette=%d %s", event.location.c_str(),
                           event.palette_id, event.message.c_str());
  }
  if (event.color_count > 0) {
    return absl::StrFormat("- [%s] colors=%d %s", event.location.c_str(),
                           event.color_count, event.message.c_str());
  }
  return absl::StrFormat("- [%s] %s", event.location.c_str(),
                         event.message.c_str());
}
 
using zelda3::GetObjectName;
 
}  // namespace
 
std::string DungeonCanvasViewer::BuildRoomMetadataSummary(
    const zelda3::Room& room, int room_id) const {
  const int resolved_palette_id = room.ResolveDungeonPaletteId();
  const uint8_t entrance_blockset = room.render_entrance_blockset();
  std::string entrance_context = "Entrance:none";
  if (current_entrance_id_ >= 0 || entrance_blockset != 0xFF) {
    const std::string entrance_id_text =
        current_entrance_id_ >= 0
            ? absl::StrFormat("%02X", current_entrance_id_)
            : std::string("--");
    const std::string entrance_blockset_text =
        entrance_blockset != 0xFF
            ? absl::StrFormat("%02X", static_cast<int>(entrance_blockset))
            : std::string("--");
    entrance_context =
        absl::StrFormat("Entrance:%s EB:%s", entrance_id_text.c_str(),
                        entrance_blockset_text.c_str());
  }
 
  std::string summary = absl::StrFormat(
      "Room 0x%03X [%s] | B:%02X P:%02X->%02X L:%02X S:%02X | %s | Group:%s | "
      "Floor1:%d Floor2:%d Effect:%d Tag1:%d Tag2:%d\n%s\n%s",
      room_id, zelda3::GetRoomLabel(room_id).c_str(), room.blockset(),
      room.palette(), resolved_palette_id, room.layout_id(), room.spriteset(),
      entrance_context, GetBlocksetGroupName(room.blockset()), room.floor1(),
      room.floor2(), room.effect(), room.tag1(), room.tag2(),
      BuildReportSessionSummary(rom_, project_).c_str(),
      BuildEffectiveBlockListSummary(room).c_str());
 
  // Connectivity diagnostics: enumerate doors/staircases/holewarp without
  // reciprocity filtering so the report captures the room's actual link
  // configuration. Staircase configuration issues (stale headers, missing
  // destinations, extra placed objects beyond 4 slots) are listed
  // separately so a reader can spot phantom or unreachable connections.
  const auto link_diagnostics =
      CollectDungeonConnectedRoomLinkDiagnostics(room_id, room, nullptr);
  if (!link_diagnostics.links.empty() ||
      !link_diagnostics.staircase_issues.empty()) {
    summary += "\nConnectivity:";
    for (const auto& link : link_diagnostics.links) {
      summary += "\n  ";
      summary += FormatDungeonConnectedLinkDescription(link);
    }
    for (const auto& issue : link_diagnostics.staircase_issues) {
      summary += "\n  ";
      summary += FormatDungeonStaircaseIssueDescription(issue);
    }
  }
 
  return summary;
}
 
std::string DungeonCanvasViewer::BuildDrawIssueReport(const zelda3::Room& room,
                                                      int room_id) {
  // Context-menu actions run inside BeginCanvas, before the normal room draw
  // pass. Rebind at the diagnostic boundary too, so palette sampling remains
  // correct even if the surrounding canvas order changes in the future.
  if (rooms_ != nullptr && room_id >= 0 && room_id < zelda3::kNumberOfRooms &&
      rooms_->GetIfMaterialized(room_id) == &room) {
    PrepareRoomCompositeBitmap(room_id);
  }
 
  std::string report = "Dungeon Draw Issue Report\n";
  report += BuildRoomMetadataSummary(room, room_id);
  report += absl::StrFormat(
      "\nResolved palette group: 0x%02X\nInteraction mode: %s\nView: BG1=%s "
      "BG2=%s Grid=%s Bounds=%s Sprites=%s Pots=%s Collision=%s Camera=%s",
      room.ResolveDungeonPaletteId(),
      object_interaction_.mode_manager().GetModeName(),
      IsBG1Visible(room_id) ? "on" : "off",
      IsBG2Visible(room_id) ? "on" : "off", show_grid_ ? "on" : "off",
      show_object_bounds_ ? "on" : "off",
      entity_visibility_.show_sprites ? "on" : "off",
      entity_visibility_.show_pot_items ? "on" : "off",
      show_custom_collision_overlay_ ? "on" : "off",
      show_camera_quadrant_overlay_ ? "on" : "off");
 
  const auto selected = object_interaction_.GetSelectedObjectIndices();
  if (!selected.empty()) {
    report += absl::StrFormat("\nSelected objects: %zu", selected.size());
    if (selected.size() == 1) {
      const auto& objects = room.GetTileObjects();
      const size_t index = selected.front();
      if (index < objects.size()) {
        const auto& obj = objects[index];
        report += absl::StrFormat(
            "\nObject: id=0x%03X name=%s pos=(%d,%d) size=0x%02X %s", obj.id_,
            GetObjectName(obj.id_).c_str(), obj.x_, obj.y_, obj.size_,
            BuildSelectedObjectSemanticsSummary(obj).c_str());
        if (auto tiles = obj.GetTiles(); tiles.ok()) {
          report += "\n";
          report += FormatObjectTileSample(*tiles, 16, "Descriptor tiles:");
        }
        if (obj.id_ == 0x00C4 || obj.id_ == 0x00DB) {
          const bool uses_floor1 = obj.id_ == 0x00C4;
          const uint8_t floor_pattern =
              uses_floor1 ? room.floor1() : room.floor2();
          report += absl::StrFormat(
              "\nFloor copy source: Floor %d (room.floor%d) pattern=%d",
              uses_floor1 ? 1 : 2, uses_floor1 ? 1 : 2,
              static_cast<int>(floor_pattern));
          if (rom_ != nullptr && rom_->is_loaded()) {
            const auto effective_tiles = gfx::DecodeDungeonFloorTilePattern(
                rom_->vector(), zelda3::kRoomObjectTileAddress,
                zelda3::kRoomObjectTileAddressFloor, floor_pattern);
            if (effective_tiles.has_value()) {
              report += "\n";
              report += FormatObjectTileSample(*effective_tiles,
                                               effective_tiles->size(),
                                               "Effective floor-copy tiles:");
            } else {
              report +=
                  "\nEffective floor-copy tiles: unavailable "
                  "(ROM tables out of range)";
            }
          } else {
            report +=
                "\nEffective floor-copy tiles: unavailable (ROM not loaded)";
          }
        }
 
        auto [bounds_x, bounds_y, bounds_w, bounds_h] =
            zelda3::DimensionService::Get().GetSelectionBoundsPixels(obj);
        bounds_w = std::max(bounds_w, 8);
        bounds_h = std::max(bounds_h, 8);
        const int origin_x = obj.x_ * 8;
        const int origin_y = obj.y_ * 8;
        const int center_x = bounds_x + std::max(0, (bounds_w / 2) - 1);
        const int center_y = bounds_y + std::max(0, (bounds_h / 2) - 1);
        report += absl::StrFormat(
            "\nObject geometry: selection_bounds_px=(%d,%d,%d,%d) "
            "object_origin_px=(%d,%d) center_px=(%d,%d)",
            bounds_x, bounds_y, bounds_w, bounds_h, origin_x, origin_y,
            center_x, center_y);
        const auto trace_report =
            BuildObjectTraceReport(rom_, room, index, current_palette_group_);
        report += trace_report.summary;
 
        auto& palette_debugger = zelda3::PaletteDebugger::Get();
        auto append_sample = [&](std::string_view label, int sample_x,
                                 int sample_y) {
          const auto comp = palette_debugger.SamplePixelAt(sample_x, sample_y);
          palette_debugger.AddComparison(comp);
          const std::string label_text(label);
          if (comp.palette_index < 0) {
            report += absl::StrFormat(
                "\nComposite sample %s (%d,%d): RGB=(%d,%d,%d), after color "
                "math; no palette index",
                label_text, sample_x, sample_y, comp.actual_r, comp.actual_g,
                comp.actual_b);
            return;
          }
          report += absl::StrFormat(
              "\nPalette sample %s (%d,%d): idx=%d expected=(%d,%d,%d) "
              "actual=(%d,%d,%d) match=%s",
              label_text.c_str(), sample_x, sample_y,
              static_cast<int>(comp.palette_index),
              static_cast<int>(comp.expected_r),
              static_cast<int>(comp.expected_g),
              static_cast<int>(comp.expected_b),
              static_cast<int>(comp.actual_r), static_cast<int>(comp.actual_g),
              static_cast<int>(comp.actual_b), comp.matches ? "yes" : "no");
        };
 
        if (auto trace_sample = ChooseObjectTracePaletteSample(
                trace_report.writes, palette_debugger)) {
          append_sample(trace_sample->label, trace_sample->x, trace_sample->y);
        } else {
          append_sample("selection-origin", bounds_x, bounds_y);
          if (center_x != bounds_x || center_y != bounds_y) {
            append_sample("selection-center", center_x, center_y);
          }
        }
      } else {
        report += absl::StrFormat(
            "\nSelected object index %zu is stale; room currently has %zu "
            "object(s). Reselect the object and report again if this issue "
            "still reproduces.",
            index, objects.size());
      }
    }
  }
 
  if (object_interaction_.HasEntitySelection()) {
    const auto selected_entity = object_interaction_.GetSelectedEntity();
    switch (selected_entity.type) {
      case EntityType::Door: {
        const auto& doors = room.GetDoors();
        if (selected_entity.index < doors.size()) {
          const auto& door = doors[selected_entity.index];
          report += BuildDoorIssueSummary(door, selected_entity.index,
                                          "Selected door");
        }
        break;
      }
      case EntityType::Sprite: {
        const auto& sprites = room.GetSprites();
        if (selected_entity.index < sprites.size()) {
          const auto& sprite = sprites[selected_entity.index];
          report += absl::StrFormat(
              "\nSelected entity: sprite id=0x%02X name=%s pos=(%d,%d) "
              "layer=%d",
              sprite.id(), zelda3::ResolveSpriteName(sprite.id()), sprite.x(),
              sprite.y(), sprite.layer());
        }
        break;
      }
      case EntityType::Item: {
        const auto& items = room.GetPotItems();
        if (selected_entity.index < items.size()) {
          const auto& item = items[selected_entity.index];
          report +=
              absl::StrFormat("\nSelected entity: pot item=0x%02X pos=(%d,%d)",
                              item.item, item.GetPixelX(), item.GetPixelY());
        }
        break;
      }
      default:
        break;
    }
  }
 
  const auto& palette_events = zelda3::PaletteDebugger::Get().GetEvents();
  if (!palette_events.empty()) {
    report +=
        absl::StrFormat("\nPalette debug events: %zu", palette_events.size());
    const size_t preview_count = std::min<size_t>(palette_events.size(), 4);
    const size_t start = palette_events.size() - preview_count;
    for (size_t i = start; i < palette_events.size(); ++i) {
      const auto& event = palette_events[i];
      report += "\n";
      report += FormatPaletteDebugEventForReport(event);
    }
  }
 
  return report;
}
 
std::string DungeonCanvasViewer::BuildSelectionIssueReport(
    const zelda3::Room& room, int room_id) const {
  std::string report = "Dungeon Selection Issue Report\n";
  report += BuildRoomMetadataSummary(room, room_id);
  report +=
      absl::StrFormat("\nInteraction mode: %s\nResolved palette group: 0x%02X",
                      object_interaction_.mode_manager().GetModeName(),
                      room.ResolveDungeonPaletteId());
 
  const auto selected_objects = object_interaction_.GetSelectedObjectIndices();
  if (!selected_objects.empty()) {
    report +=
        absl::StrFormat("\nSelected objects: %zu", selected_objects.size());
    const auto& objects = room.GetTileObjects();
    const size_t preview_count = std::min<size_t>(selected_objects.size(), 4);
    for (size_t i = 0; i < preview_count; ++i) {
      const size_t index = selected_objects[i];
      if (index >= objects.size()) {
        report += absl::StrFormat(
            "\n- object[%zu] unavailable; room currently has %zu object(s) "
            "(selection is stale)",
            index, objects.size());
        continue;
      }
      const auto& obj = objects[index];
      report += absl::StrFormat(
          "\n- object[%zu] id=0x%03X name=%s pos=(%d,%d) size=0x%02X %s", index,
          obj.id_, GetObjectName(obj.id_).c_str(), obj.x_, obj.y_, obj.size_,
          BuildSelectedObjectSemanticsSummary(obj).c_str());
      auto [bounds_x, bounds_y, bounds_w, bounds_h] =
          zelda3::DimensionService::Get().GetSelectionBoundsPixels(obj);
      bounds_w = std::max(bounds_w, 8);
      bounds_h = std::max(bounds_h, 8);
      report += absl::StrFormat(
          "\n  geometry: selection_bounds_px=(%d,%d,%d,%d) "
          "object_origin_px=(%d,%d)",
          bounds_x, bounds_y, bounds_w, bounds_h, obj.x_ * 8, obj.y_ * 8);
      if (auto tiles = obj.GetTiles(); tiles.ok() && !tiles->empty()) {
        report += "\n  ";
        report += FormatObjectTileSample(*tiles, 10, "tiles:");
      }
      const auto trace_report =
          BuildObjectTraceReport(rom_, room, index, current_palette_group_);
      report += "\n  ";
      report += BuildObjectTraceBoundsSummary(trace_report.writes, bounds_x,
                                              bounds_y, bounds_w, bounds_h);
    }
    if (selected_objects.size() > preview_count) {
      report += absl::StrFormat("\n- ... %zu more object(s)",
                                selected_objects.size() - preview_count);
    }
    return report;
  }
 
  if (object_interaction_.HasEntitySelection()) {
    const auto selected_entity = object_interaction_.GetSelectedEntity();
    switch (selected_entity.type) {
      case EntityType::Door: {
        const auto& doors = room.GetDoors();
        if (selected_entity.index < doors.size()) {
          const auto& door = doors[selected_entity.index];
          report += BuildDoorIssueSummary(door, selected_entity.index,
                                          "Selected door");
          return report;
        }
        break;
      }
      case EntityType::Sprite: {
        const auto& sprites = room.GetSprites();
        if (selected_entity.index < sprites.size()) {
          const auto& sprite = sprites[selected_entity.index];
          report += absl::StrFormat(
              "\nSelected sprite[%zu]:\n"
              "- id=0x%02X\n"
              "- name=%s\n"
              "- pos=(%d,%d)\n"
              "- layer=%d",
              selected_entity.index, sprite.id(),
              zelda3::ResolveSpriteName(sprite.id()), sprite.x(), sprite.y(),
              sprite.layer());
          return report;
        }
        break;
      }
      case EntityType::Item: {
        const auto& items = room.GetPotItems();
        if (selected_entity.index < items.size()) {
          const auto& item = items[selected_entity.index];
          report += absl::StrFormat(
              "\nSelected pot item[%zu]:\n"
              "- item=0x%02X\n"
              "- pixel_pos=(%d,%d)",
              selected_entity.index, item.item, item.GetPixelX(),
              item.GetPixelY());
          return report;
        }
        break;
      }
      default:
        break;
    }
  }
 
  report += "\nNo active object or entity selection.";
  return report;
}
 
void DungeonCanvasViewer::RefreshIssueReportOutputTargets() {
  issue_report_popup_log_target_path_.clear();
  issue_report_popup_screenshot_dir_.clear();
 
  auto paths_or = ResolveDungeonIssueReportPaths();
  if (!paths_or.ok()) {
    SetIssueReportPopupStatus(std::string(paths_or.status().message()), true);
    return;
  }
 
  issue_report_popup_log_target_path_ =
      util::PlatformPaths::NormalizePathForDisplay(paths_or->log_path);
  issue_report_popup_screenshot_dir_ =
      util::PlatformPaths::NormalizePathForDisplay(paths_or->screenshots_dir);
}
 
void DungeonCanvasViewer::SetIssueReportPopupStatus(std::string message,
                                                    bool is_error) {
  issue_report_popup_status_message_ = std::move(message);
  issue_report_popup_status_is_error_ = is_error;
}
 
void DungeonCanvasViewer::MarkIssueReportDirty() {
  issue_report_popup_persisted_ = false;
}
 
void DungeonCanvasViewer::DrawIssueReportStorageSummary() const {
  if (issue_report_popup_log_target_path_.empty() &&
      issue_report_popup_screenshot_dir_.empty() &&
      issue_report_popup_screenshot_path_.empty() &&
      issue_report_popup_last_log_path_.empty()) {
    return;
  }
 
  if (!ImGui::CollapsingHeader(kIssueReportSectionPaths)) {
    return;
  }
  if (!issue_report_popup_log_target_path_.empty()) {
    ImGui::TextWrapped(tr("Log target: %s"),
                       issue_report_popup_log_target_path_.c_str());
  }
  if (!issue_report_popup_screenshot_dir_.empty() &&
      issue_report_popup_screenshot_path_.empty()) {
    ImGui::TextWrapped(tr("Screenshot dir: %s"),
                       issue_report_popup_screenshot_dir_.c_str());
  }
  if (!issue_report_popup_screenshot_path_.empty()) {
    ImGui::TextWrapped(tr("Screenshot: %s"),
                       issue_report_popup_screenshot_path_.c_str());
  }
  if (!issue_report_popup_last_log_path_.empty()) {
    ImGui::TextWrapped(tr("Issue log: %s"),
                       issue_report_popup_last_log_path_.c_str());
  }
}
 
void DungeonCanvasViewer::DrawIssueReportStatusMessage() const {
  const bool idle = issue_report_popup_status_message_.empty();
  const std::string_view message =
      idle ? std::string_view(tr(kIssueReportStatusIdle))
           : std::string_view(issue_report_popup_status_message_);
  const size_t line_end = message.find_first_of("\r\n");
  std::string visible_line(message.substr(0, line_end));
  if (line_end != std::string_view::npos) {
    visible_line += "...";
  }
  const ImVec4 color =
      idle ? ImGui::GetStyleColorVec4(ImGuiCol_TextDisabled)
           : (issue_report_popup_status_is_error_ ? gui::GetErrorColor()
                                                  : gui::GetSuccessColor());
  const ImVec2 start = ImGui::GetCursorScreenPos();
  const ImVec2 size(std::max(ImGui::GetContentRegionAvail().x, 1.0f),
                    ImGui::GetTextLineHeight());
  const ImVec2 end(start.x + size.x, start.y + size.y);
  {
    gui::StyleColorGuard status_color(ImGuiCol_Text, color);
    ImGui::RenderTextEllipsis(ImGui::GetWindowDrawList(), start, end, end.x,
                              visible_line.c_str(), nullptr, nullptr);
  }
  ImGui::Dummy(size);
  if (ImGui::IsItemHovered()) {
    ImGui::BeginTooltip();
    ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
    ImGui::TextUnformatted(message.data(), message.data() + message.size());
    ImGui::PopTextWrapPos();
    ImGui::EndTooltip();
  }
}
 
absl::Status DungeonCanvasViewer::PrepareIssueReportPopup(
    const std::string& title, const std::string& summary,
    const std::string& kind_label, const std::string& diagnostics, int room_id,
    int default_category_index) {
  issue_report_popup_title_ = title;
  issue_report_popup_kind_ = kind_label;
  issue_report_popup_diagnostics_ = diagnostics;
  issue_report_popup_room_id_ = room_id;
  issue_report_category_index_ =
      std::clamp(default_category_index, 0,
                 static_cast<int>(kDungeonIssueCategoryLabels.size()) - 1);
  issue_report_popup_screenshot_path_.clear();
  issue_report_popup_last_log_path_.clear();
  issue_report_popup_persisted_ = false;
  SetIssueReportPopupStatus("", false);
  RefreshIssueReportOutputTargets();
  std::snprintf(issue_report_summary_, sizeof(issue_report_summary_), "%s",
                summary.c_str());
  issue_report_notes_[0] = '\0';
  return absl::OkStatus();
}
 
void DungeonCanvasViewer::OpenIssueReportPopup(const std::string& title,
                                               const std::string& summary,
                                               const std::string& kind_label,
                                               const std::string& diagnostics,
                                               int room_id,
                                               int default_category_index) {
  (void)PrepareIssueReportPopup(title, summary, kind_label, diagnostics,
                                room_id, default_category_index);
  canvas_.OpenPersistentPopup(issue_report_popup_id_, [this]() {
    const IssueReportWindowLayout window_layout = GetIssueReportWindowLayout();
    ImGui::SetNextWindowPos(window_layout.center, ImGuiCond_Appearing,
                            ImVec2(0.5f, 0.5f));
    ImGui::SetNextWindowSize(window_layout.initial_size, ImGuiCond_Appearing);
    ImGui::SetNextWindowSizeConstraints(window_layout.min_size,
                                        window_layout.max_size);
 
    if (ImGui::BeginPopupModal(issue_report_popup_id_.c_str(), nullptr,
                               ImGuiWindowFlags_NoSavedSettings)) {
#ifdef YAZE_WITH_GRPC
      const char* capture_label = issue_report_popup_screenshot_path_.empty()
                                      ? kIssueReportCaptureButtonLabel
                                      : kIssueReportRecaptureButtonLabel;
      const std::array<const char*, 4> action_labels = {
          kIssueReportSaveButtonLabel, capture_label,
          kIssueReportCopyButtonLabel, kIssueReportCloseButtonLabel};
#else
      const std::array<const char*, 3> action_labels = {
          kIssueReportSaveButtonLabel, kIssueReportCopyButtonLabel,
          kIssueReportCloseButtonLabel};
#endif
      const float footer_width =
          std::max(ImGui::GetContentRegionAvail().x, 1.0f);
      const int action_rows = CountWrappedIssueActionRows(
          std::span<const char* const>(action_labels), footer_width);
      const ImGuiStyle& style = ImGui::GetStyle();
      const float action_height =
          action_rows * ImGui::GetFrameHeight() +
          std::max(0, action_rows - 1) * style.ItemSpacing.y;
      const float footer_height = ImGui::GetTextLineHeightWithSpacing() +
                                  action_height + style.ItemSpacing.y * 2.0f +
                                  1.0f;
 
      if (ImGui::BeginChild("##DungeonIssueReportBody",
                            ImVec2(0.0f, -footer_height), false,
                            ImGuiWindowFlags_None)) {
        if (!issue_report_popup_title_.empty()) {
          ImGui::TextUnformatted(issue_report_popup_title_.c_str());
          if (!issue_report_popup_kind_.empty()) {
            ImGui::TextDisabled("%s", issue_report_popup_kind_.c_str());
          }
          ImGui::Separator();
        }
 
        ImGui::TextUnformatted(tr("Category"));
        ImGui::SetNextItemWidth(
            std::max(ImGui::GetContentRegionAvail().x, 1.0f));
        const char* category_preview =
            GetIssueCategoryLabel(issue_report_category_index_);
        if (ImGui::BeginCombo("##DungeonIssueCategory", category_preview)) {
          for (size_t i = 0; i < kDungeonIssueCategoryLabels.size(); ++i) {
            const bool selected =
                issue_report_category_index_ == static_cast<int>(i);
            if (ImGui::Selectable(kDungeonIssueCategoryLabels[i], selected)) {
              issue_report_category_index_ = static_cast<int>(i);
              MarkIssueReportDirty();
            }
            if (selected) {
              ImGui::SetItemDefaultFocus();
            }
          }
          ImGui::EndCombo();
        }
 
        ImGui::TextUnformatted(tr("Summary"));
        ImGui::SetNextItemWidth(
            std::max(ImGui::GetContentRegionAvail().x, 1.0f));
        if (ImGui::InputTextWithHint(
                "##DungeonIssueSummary", kIssueReportSummaryHint,
                issue_report_summary_, sizeof(issue_report_summary_))) {
          MarkIssueReportDirty();
        }
 
        ImGui::TextUnformatted(tr("Observed issue"));
        if (ImGui::InputTextMultiline("##DungeonIssueObserved",
                                      issue_report_notes_,
                                      sizeof(issue_report_notes_),
                                      ImVec2(-1.0f, kIssueReportNotesHeight))) {
          MarkIssueReportDirty();
        }
 
        DrawIssueReportStorageSummary();
 
        if (ImGui::CollapsingHeader(kIssueReportSectionDiagnostics)) {
          ImGui::InputTextMultiline(
              kIssueReportPopupIdDiagnostics,
              issue_report_popup_diagnostics_.data(),
              issue_report_popup_diagnostics_.size() + 1,
              ImVec2(-1.0f, kIssueReportDiagnosticsHeight),
              ImGuiInputTextFlags_ReadOnly);
          if (ImGui::Button(ICON_MD_ASSIGNMENT " Copy Diagnostics")) {
            ImGui::SetClipboardText(issue_report_popup_diagnostics_.c_str());
            SetIssueReportPopupStatus(kIssueReportStatusCopiedDiagnostics,
                                      false);
          }
        }
      }
      ImGui::EndChild();
 
      ImGui::Separator();
      DrawIssueReportStatusMessage();
 
      float used_action_width = 0.0f;
      PlaceNextIssueAction(kIssueReportSaveButtonLabel, footer_width,
                           &used_action_width);
      if (gui::PrimaryButton(kIssueReportSaveButtonLabel)) {
        const auto status = EnsureIssueReportPersisted();
        if (status.ok()) {
          SetIssueReportPopupStatus(kIssueReportStatusSavedLog, false);
        } else {
          SetIssueReportPopupStatus(std::string(status.message()), true);
        }
      }
 
#ifdef YAZE_WITH_GRPC
      PlaceNextIssueAction(capture_label, footer_width, &used_action_width);
      if (ImGui::Button(
              capture_label,
              ImVec2(GetIssueActionButtonWidth(capture_label), 0.0f))) {
        const auto status = CaptureIssueReportScreenshot();
        if (status.ok()) {
          MarkIssueReportDirty();
          SetIssueReportPopupStatus(kIssueReportStatusSavedScreenshot, false);
        } else {
          SetIssueReportPopupStatus(std::string(status.message()), true);
        }
      }
#endif
 
      PlaceNextIssueAction(kIssueReportCopyButtonLabel, footer_width,
                           &used_action_width);
      if (ImGui::Button(kIssueReportCopyButtonLabel)) {
        std::string report = BuildIssueReportClipboardText();
        ImGui::SetClipboardText(report.c_str());
        SetIssueReportPopupStatus(kIssueReportStatusCopiedReport, false);
      }
 
      PlaceNextIssueAction(kIssueReportCloseButtonLabel, footer_width,
                           &used_action_width);
      if (ImGui::Button(kIssueReportCloseButtonLabel)) {
        canvas_.ClosePersistentPopup(issue_report_popup_id_);
        ImGui::CloseCurrentPopup();
      }
      ImGui::EndPopup();
      return;
    }
  });
}
 
std::string DungeonCanvasViewer::BuildIssueReportClipboardText() const {
  std::string report;
  if (!issue_report_popup_kind_.empty()) {
    report += issue_report_popup_kind_ + "\n";
  }
  report += absl::StrFormat(
      "Category: %s\n", GetIssueCategoryLabel(issue_report_category_index_));
  if (issue_report_summary_[0] != '\0') {
    report += absl::StrFormat("Summary: %s\n", issue_report_summary_);
  }
  if (!issue_report_popup_screenshot_path_.empty()) {
    report += absl::StrFormat("Screenshot: %s\n",
                              issue_report_popup_screenshot_path_.c_str());
  }
  if (issue_report_notes_[0] != '\0') {
    report += absl::StrFormat("\nObserved issue:\n%s\n", issue_report_notes_);
  }
  report += "\nDiagnostics:\n";
  report += issue_report_popup_diagnostics_;
  return report;
}
 
absl::Status DungeonCanvasViewer::CaptureIssueReportScreenshot() {
#ifdef YAZE_WITH_GRPC
  if (!has_canvas_capture_region_ || canvas_capture_width_ <= 0 ||
      canvas_capture_height_ <= 0) {
    return absl::FailedPreconditionError(
        "Room canvas region is not available for screenshot capture");
  }
 
  const std::string timestamp = BuildIssueTimestampSlug();
  auto screenshot_path_or = BuildDungeonIssueScreenshotPath(
      issue_report_popup_room_id_,
      GetIssueCategoryLabel(issue_report_category_index_), timestamp);
  if (!screenshot_path_or.ok()) {
    return screenshot_path_or.status();
  }
 
  yaze::test::CaptureRegion region;
  region.x = canvas_capture_x_;
  region.y = canvas_capture_y_;
  region.width = canvas_capture_width_;
  region.height = canvas_capture_height_;
 
  auto artifact_or = yaze::test::CaptureHarnessScreenshotRegion(
      std::optional<yaze::test::CaptureRegion>(region),
      screenshot_path_or->string(),
      /*reveal_to_user=*/false);
  if (!artifact_or.ok()) {
    return artifact_or.status();
  }
 
  issue_report_popup_screenshot_path_ =
      util::PlatformPaths::NormalizePathForDisplay(artifact_or->file_path);
  return absl::OkStatus();
#else
  return absl::UnimplementedError(
      "Screenshot capture is unavailable without YAZE_WITH_GRPC");
#endif
}
 
absl::Status DungeonCanvasViewer::AppendIssueReportToLog() {
  DungeonIssueLogEntry entry;
  entry.timestamp_display = BuildIssueTimestampDisplay();
  entry.heading = (issue_report_summary_[0] != '\0') ? issue_report_summary_
                                                     : issue_report_popup_kind_;
  entry.category_label = GetIssueCategoryLabel(issue_report_category_index_);
  entry.scope = issue_report_popup_kind_;
  entry.room_id = issue_report_popup_room_id_;
  entry.screenshot_path = issue_report_popup_screenshot_path_;
  entry.observed_issue = issue_report_notes_;
  entry.diagnostics = issue_report_popup_diagnostics_;
 
  auto log_path_or = AppendDungeonIssueLogEntry(entry);
  if (!log_path_or.ok()) {
    return log_path_or.status();
  }
 
  issue_report_popup_last_log_path_ =
      util::PlatformPaths::NormalizePathForDisplay(*log_path_or);
  return absl::OkStatus();
}
 
absl::Status DungeonCanvasViewer::EnsureIssueReportPersisted() {
  if (issue_report_popup_persisted_ &&
      !issue_report_popup_last_log_path_.empty()) {
    return absl::OkStatus();
  }
 
  RETURN_IF_ERROR(AppendIssueReportToLog());
  issue_report_popup_persisted_ = true;
  return absl::OkStatus();
}
 
}  // namespace yaze::editor