// VERA panel — graphical VRAM viewers for the Commander X16's VERA.

//

// Tabs:

//   * Palette  — the 256-entry VERA palette ($1FA00..$1FBFF) as a 16x16 grid.

//   * Tiles    — a freeform tile/character viewer (base addr, bpp, tile size).

//   * Sprites  — the 128 sprite attribute entries ($1FC00..$1FFFF), decoded.

//   * Bitmap   — a layer's bitmap-mode image (from the layer registers).

//   * Tilemap  — a layer's tile/text map (from the layer registers).

//

// Technique: each viewer decodes VRAM into an RGBA (ABGR8888) pixel buffer,

// uploads it to a STREAMING SDL_Texture via the debugger's SDL_Renderer, and

// shows it with ImGui::Image. Textures are function-static and only recreated

// when their dimensions change, so there is no per-frame allocation/leak. Only

// the active tab decodes each frame (ImGui::BeginTabItem gates the work), so the

// cost of the heavier viewers is only paid when they are visible. All VRAM

// access goes through video_space_read()/debug_ui_vram_read_range(), which mask

// the address into the 17-bit VRAM space, so reads can never go out of bounds.

#include "imgui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h"

#include "debug_ui.h"

#include "debug_ui_widgets.h" // dbgui_hover_value_tooltip / dbgui_format_binary

#include "sprite_multiplex_tab.h"

#include <SDL.h>

#include <stdint.h>

#include <string.h>

namespace {

constexpr uint32_t ADDR_PALETTE     = 0x1FA00; // 256 * 2 bytes, 12-bit RGB

constexpr uint32_t ADDR_SPRITE_ATTR = 0x1FC00; // 128 * 8 bytes

constexpr int      NUM_SPRITES      = 128;

inline int clampi(int v, int lo, int hi) { return v < lo ? lo : (v > hi ? hi : v); }

// Expand a 4-bit VERA color channel (0..15) to 8 bits by nibble replication,

// exactly like refresh_palette() in video.c (x<<4 | x).

inline uint8_t expand4(uint8_t v) { return (uint8_t)((v << 4) | v); }

// Build the 256-entry palette as ABGR8888 (alpha forced opaque). VERA stores

// each entry as two bytes: byte0 = GGGGBBBB, byte1 = 0000RRRR.

void

build_palette(uint32_t out[256])

{

    for (int i = 0; i < 256; ++i) {

        uint8_t b0 = video_space_read(ADDR_PALETTE + i * 2);     // GGGGBBBB

        uint8_t b1 = video_space_read(ADDR_PALETTE + i * 2 + 1); // 0000RRRR

        uint8_t r  = expand4(b1 & 0x0f);

        uint8_t g  = expand4((b0 >> 4) & 0x0f);

        uint8_t b  = expand4(b0 & 0x0f);

        out[i] = 0xFF000000u | ((uint32_t)b << 16) | ((uint32_t)g << 8) | (uint32_t)r;

    }

}

// A lazily-created, resizable STREAMING texture. Kept as a file-/function-static

// so it lives for the app's lifetime; recreated only when the size changes.

struct GfxTexture {

    SDL_Texture *tex = nullptr;

    int          w   = 0;

    int          h   = 0;

    bool ensure(int width, int height)

    {

        if (width <= 0 || height <= 0)

            return false;

        if (tex && w == width && h == height)

            return true;

        if (tex) {

            SDL_DestroyTexture(tex);

            tex = nullptr;

        }

        SDL_Renderer *ren = debug_ui_get_renderer();

        if (!ren)

            return false;

        tex = SDL_CreateTexture(ren, SDL_PIXELFORMAT_ABGR8888,

                                SDL_TEXTUREACCESS_STREAMING, width, height);

        if (!tex)

            return false;

        SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);

        SDL_SetTextureScaleMode(tex, SDL_ScaleModeNearest); // crisp zoomed pixels

        w = width;

        h = height;

        return true;

    }

    void update(const uint32_t *pixels)

    {

        if (tex)

            SDL_UpdateTexture(tex, nullptr, pixels, w * (int)sizeof(uint32_t));

    }

    ImTextureID id() const { return (ImTextureID)(intptr_t)tex; }

};

// A reusable, growable RGBA scratch buffer for building images.

struct PixelBuffer {

    uint32_t *data = nullptr;

    size_t    cap  = 0;

    uint32_t *ensure(size_t count)

    {

        if (count > cap) {

            free(data);

            data = (uint32_t *)malloc(count * sizeof(uint32_t));

            cap  = data ? count : 0;

        }

        return data;

    }

};

// Decode one indexed color to a display pixel. index 0 stays transparent when

// `transparent0` is set (sprites); otherwise it renders as palette[0] (tiles).

inline uint32_t

resolve_color(const uint32_t pal[256], int idx, int palette_offset, bool transparent0)

{

    if (idx == 0 && transparent0)

        return 0; // fully transparent

    int ci = idx;

    if (ci > 0 && ci < 16)

        ci += palette_offset;

    return pal[ci & 0xff];

}

// ---------------------------------------------------------------------------

// Palette tab

// ---------------------------------------------------------------------------

void

draw_palette_tab()

{

    ImGui::TextUnformatted("VERA palette — $1FA00..$1FBFF (256 entries, 12-bit RGB)");

    ImGui::Spacing();

    uint32_t pal[256];

    build_palette(pal);

    const ImGuiColorEditFlags flags =

        ImGuiColorEditFlags_NoTooltip | ImGuiColorEditFlags_NoAlpha |

        ImGuiColorEditFlags_NoDragDrop | ImGuiColorEditFlags_NoBorder;

    const ImVec2 sw(20.0f, 20.0f);

    for (int i = 0; i < 256; ++i) {

        ImGui::PushID(i);

        uint32_t c = pal[i];

        uint8_t  r = c & 0xff, g = (c >> 8) & 0xff, b = (c >> 16) & 0xff;

        ImVec4   col(r / 255.0f, g / 255.0f, b / 255.0f, 1.0f);

        ImGui::ColorButton("##sw", col, flags, sw);

        if (ImGui::IsItemHovered()) {

            uint8_t b0 = video_space_read(ADDR_PALETTE + i * 2);

            uint8_t b1 = video_space_read(ADDR_PALETTE + i * 2 + 1);

            ImGui::SetTooltip("Index %3d ($%02X)\nRGB $%X%X%X  (%d, %d, %d)\nVRAM $%05X: $%02X $%02X",

                              i, i, (b1 & 0x0f), (b0 >> 4) & 0x0f, b0 & 0x0f, r, g, b,

                              ADDR_PALETTE + i * 2, b0, b1);

        }

        if ((i % 16) != 15)

            ImGui::SameLine();

        ImGui::PopID();

    }

}

// ---------------------------------------------------------------------------

// Tile / character viewer tab

// ---------------------------------------------------------------------------

void

draw_tiles_tab(const uint32_t pal[256])

{

    static int   base       = 0x00000;

    static int   bpp_idx    = 2;   // 0:1bpp 1:2bpp 2:4bpp 3:8bpp

    static int   tw_idx     = 0;   // 0:8   1:16

    static int   th_idx     = 0;   // 0:8   1:16

    static int   cols       = 16;

    static int   rows       = 16;

    static int   pal_off    = 0;   // 0..15 (times 16)

    static float zoom       = 2.0f;

    static int   selected   = -1;

    static const int   bpp_vals[4] = { 1, 2, 4, 8 };

    static const char *bpp_names   = "1 bpp\0" "2 bpp\0" "4 bpp\0" "8 bpp\0";

    static const char *dim_names   = "8\0" "16\0";

    // Row 1 — base address (type any hex address to jump straight there) + format.

    // A plain "%05X" field (no "$" in the format) keeps hex text-entry unambiguous.

    ImGui::TextUnformatted("Base $");

    ImGui::SameLine(0.0f, 2.0f);

    ImGui::PushItemWidth(90);

    ImGui::InputScalar("##tilebase", ImGuiDataType_S32, &base, nullptr, nullptr, "%05X",

                       ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase);

    ImGui::SameLine();

    ImGui::Combo("Depth", &bpp_idx, bpp_names);

    ImGui::SameLine();

    ImGui::Combo("W", &tw_idx, dim_names);

    ImGui::SameLine();

    ImGui::Combo("H", &th_idx, dim_names);

    ImGui::PopItemWidth();

    // Geometry (computed here so the navigation controls below can use it).

    const int bpp = bpp_vals[bpp_idx];

    const int tw  = tw_idx ? 16 : 8;

    const int th  = th_idx ? 16 : 8;

    const int bytes_per_tile = tw * th * bpp / 8;

    cols = clampi(cols, 1, 64);

    rows = clampi(rows, 1, 64);

    const int row_step  = cols * bytes_per_tile;

    const int page_step = cols * rows * bytes_per_tile;

    base = clampi(base, 0, 0x1FFFF);

    // Row 2 — jump by tile index + alignment.

    int tile_no = bytes_per_tile ? base / bytes_per_tile : 0;

    ImGui::PushItemWidth(110);

    if (ImGui::InputInt("Tile #", &tile_no, 1, 16))

        base = clampi(tile_no * bytes_per_tile, 0, 0x1FFFF);

    ImGui::PopItemWidth();

    ImGui::SameLine();

    if (ImGui::SmallButton("Align"))          // snap to the current tile stride

        base -= base % bytes_per_tile;

    ImGui::SameLine();

    if (ImGui::SmallButton("Align $800"))     // snap to VERA tile-base granularity (2KB)

        base &= ~0x7FF;

    ImGui::SameLine();

    ImGui::TextDisabled("(?)");

    if (ImGui::IsItemHovered())

        ImGui::SetTooltip("Type a hex address in Base, or a tile index in Tile #, to jump.\n"

                          "Step with the buttons below, or drag the scrollbar for fast scrolling.\n"

                          "-1/+1 nudge by one byte; Align snaps to the tile stride ($800 = VERA tilebase).");

    // Row 3 — stepping: home / page / row / tile / byte-nudge.

    if (ImGui::SmallButton("|< Home")) base = 0;

    ImGui::SameLine(); if (ImGui::SmallButton("<< Page")) base -= page_step;

    ImGui::SameLine(); if (ImGui::SmallButton("< Row"))   base -= row_step;

    ImGui::SameLine(); if (ImGui::SmallButton("< Tile"))  base -= bytes_per_tile;

    ImGui::SameLine(); if (ImGui::SmallButton("-1"))      base -= 1;

    ImGui::SameLine(); if (ImGui::SmallButton("+1"))      base += 1;

    ImGui::SameLine(); if (ImGui::SmallButton("Tile >"))  base += bytes_per_tile;

    ImGui::SameLine(); if (ImGui::SmallButton("Row >"))   base += row_step;

    ImGui::SameLine(); if (ImGui::SmallButton("Page >>")) base += page_step;

    base = clampi(base, 0, 0x1FFFF);

    // Row 4 — full-width fast-scroll bar across all of VRAM (tile-aligned).

    ImGui::PushItemWidth(-1);

    if (ImGui::SliderInt("##tilescroll", &base, 0, 0x1FFFF, "scroll -> $%05X"))

        base -= base % bytes_per_tile; // keep tiles aligned while dragging

    ImGui::PopItemWidth();

    base = clampi(base, 0, 0x1FFFF);

    // Row 5 — grid geometry.

    ImGui::PushItemWidth(110);

    ImGui::SliderInt("Columns", &cols, 1, 64);

    ImGui::SameLine();

    ImGui::SliderInt("Rows", &rows, 1, 64);

    ImGui::SameLine();

    ImGui::SliderInt("Pal offset", &pal_off, 0, 15);

    ImGui::SameLine();

    ImGui::SliderFloat("Zoom", &zoom, 1.0f, 8.0f, "%.0fx");

    ImGui::PopItemWidth();

    cols = clampi(cols, 1, 64);

    rows = clampi(rows, 1, 64);

    const int img_w = cols * tw;

    const int img_h = rows * th;

    const int mask  = (1 << bpp) - 1;

    static PixelBuffer buf;

    uint32_t *px = buf.ensure((size_t)img_w * img_h);

    if (!px)

        return;

    for (int t = 0; t < cols * rows; ++t) {

        const int      tx        = t % cols;

        const int      ty        = t / cols;

        const uint32_t tile_addr = (uint32_t)base + (uint32_t)t * bytes_per_tile;

        for (int y = 0; y < th; ++y) {

            for (int x = 0; x < tw; ++x) {

                const uint32_t bitpos = (uint32_t)(y * tw + x) * bpp;

                const uint8_t  byte   = video_space_read(tile_addr + (bitpos >> 3));

                const int      shift  = 8 - bpp - (int)(bitpos & 7);

                const int      idx    = (byte >> shift) & mask;

                const uint32_t color  = resolve_color(pal, idx, pal_off << 4, false);

                px[(size_t)(ty * th + y) * img_w + (tx * tw + x)] = color;

            }

        }

    }

    static GfxTexture gt;

    if (!gt.ensure(img_w, img_h))

        return;

    gt.update(px);

    ImGui::Separator();

    const ImVec2 img_pos = ImGui::GetCursorScreenPos();

    ImGui::Image(gt.id(), ImVec2(img_w * zoom, img_h * zoom));

    int hovered = -1;

    if (ImGui::IsItemHovered()) {

        const ImVec2 m  = ImGui::GetIO().MousePos;

        const int    lx = (int)((m.x - img_pos.x) / zoom);

        const int    ly = (int)((m.y - img_pos.y) / zoom);

        const int    htx = lx / tw;

        const int    hty = ly / th;

        if (htx >= 0 && htx < cols && hty >= 0 && hty < rows) {

            hovered = hty * cols + htx;

            const uint32_t a = (uint32_t)base + (uint32_t)hovered * bytes_per_tile;

            ImGui::SetTooltip("Tile %d  (col %d, row %d)\nVRAM $%05X..$%05X",

                              hovered, htx, hty, a, a + bytes_per_tile - 1);

            if (ImGui::IsMouseClicked(ImGuiMouseButton_Left))

                selected = hovered;

        }

    }

    if (selected >= 0 && selected < cols * rows) {

        const uint32_t a = (uint32_t)base + (uint32_t)selected * bytes_per_tile;

        ImGui::Text("Selected tile %d — VRAM $%05X (%d bytes/tile)", selected, a, bytes_per_tile);

    } else {

        ImGui::TextUnformatted("Hover a tile for its address; click to select.");

    }

}

// ---------------------------------------------------------------------------

// Sprite viewer tab

// ---------------------------------------------------------------------------

struct SpriteInfo {

    uint32_t address;

    int      mode; // 0:4bpp 1:8bpp

    int      w, h;

    int      x, y;

    int      zdepth;

    int      pal_off;

    bool     hflip, vflip;

    int      collision;

};

SpriteInfo

decode_sprite_attr(int i)

{

    uint8_t a[8];

    for (int b = 0; b < 8; ++b)

        a[b] = video_space_read(ADDR_SPRITE_ATTR + i * 8 + b);

    SpriteInfo s;

    s.address   = ((uint32_t)a[0] << 5) | ((uint32_t)(a[1] & 0x0f) << 13);

    s.mode      = (a[1] >> 7) & 1;

    s.w         = 1 << (((a[7] >> 4) & 3) + 3);

    s.h         = 1 << (((a[7] >> 6) & 3) + 3);

    s.pal_off   = (a[7] & 0x0f) << 4;

    s.zdepth    = (a[6] >> 2) & 3;

    s.collision = a[6] & 0xf0;

    s.hflip     = a[6] & 1;

    s.vflip     = (a[6] >> 1) & 1;

    s.x         = a[2] | ((a[3] & 3) << 8);

    s.y         = a[4] | ((a[5] & 3) << 8);

    if (s.x >= 0x400 - s.w)

        s.x -= 0x400;

    if (s.y >= 0x400 - s.h)

        s.y -= 0x400;

    return s;

}

// Decode sprite `s` into the atlas cell at (cx, cy). Cells are 64x64 and the

// atlas is atlas_w wide; the sprite is drawn top-left in its cell.

void

decode_sprite_pixels(const SpriteInfo &s, const uint32_t pal[256],

                     uint32_t *atlas, int atlas_w, int cx, int cy)

{

    for (int y = 0; y < s.h; ++y) {

        for (int x = 0; x < s.w; ++x) {

            int idx;

            if (s.mode) { // 8bpp

                idx = video_space_read(s.address + (uint32_t)y * s.w + x);

            } else {      // 4bpp, high nibble = left pixel

                uint8_t byte = video_space_read(s.address + (uint32_t)y * (s.w / 2) + (x / 2));

                idx = (x & 1) ? (byte & 0x0f) : (byte >> 4);

            }

            atlas[(size_t)(cy + y) * atlas_w + (cx + x)] =

                resolve_color(pal, idx, s.pal_off, true);

        }

    }

}

void

draw_sprites_tab(const uint32_t pal[256])

{

    static bool  hide_disabled = false;

    static float zoom          = 2.0f;

    ImGui::Checkbox("Hide disabled (z=0)", &hide_disabled);

    ImGui::SameLine();

    ImGui::PushItemWidth(120);

    ImGui::SliderFloat("Preview zoom", &zoom, 1.0f, 4.0f, "%.0fx");

    ImGui::PopItemWidth();

    // One atlas texture holds every sprite: 16 columns x 8 rows of 64x64 cells.

    constexpr int CELL       = 64;

    constexpr int ATLAS_COLS = 16;

    constexpr int ATLAS_ROWS = 8;

    constexpr int ATLAS_W    = CELL * ATLAS_COLS; // 1024

    constexpr int ATLAS_H    = CELL * ATLAS_ROWS; // 512

    static PixelBuffer buf;

    uint32_t *atlas = buf.ensure((size_t)ATLAS_W * ATLAS_H);

    if (!atlas)

        return;

    memset(atlas, 0, (size_t)ATLAS_W * ATLAS_H * sizeof(uint32_t));

    SpriteInfo info[NUM_SPRITES];

    for (int i = 0; i < NUM_SPRITES; ++i) {

        info[i] = decode_sprite_attr(i);

        const int cx = (i % ATLAS_COLS) * CELL;

        const int cy = (i / ATLAS_COLS) * CELL;

        decode_sprite_pixels(info[i], pal, atlas, ATLAS_W, cx, cy);

    }

    static GfxTexture gt;

    if (!gt.ensure(ATLAS_W, ATLAS_H))

        return;

    gt.update(atlas);

    ImGui::Separator();

    const ImGuiTableFlags tflags = ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |

                                   ImGuiTableFlags_ScrollY | ImGuiTableFlags_SizingFixedFit |

                                   DBGUI_TABLE_FLAGS_RESIZABLE;

    if (ImGui::BeginTable("sprites", 9, tflags, ImVec2(0, 0))) {

        ImGui::TableSetupScrollFreeze(0, 1);

        ImGui::TableSetupColumn("#");

        ImGui::TableSetupColumn("Image");

        ImGui::TableSetupColumn("Addr");

        ImGui::TableSetupColumn("Mode");

        ImGui::TableSetupColumn("Size");

        ImGui::TableSetupColumn("X,Y");

        ImGui::TableSetupColumn("Z");

        ImGui::TableSetupColumn("PalOff");

        ImGui::TableSetupColumn("Flip");

        ImGui::TableHeadersRow();

        for (int i = 0; i < NUM_SPRITES; ++i) {

            const SpriteInfo &s = info[i];

            if (hide_disabled && s.zdepth == 0)

                continue;

            ImGui::TableNextRow();

            ImGui::TableNextColumn();

            ImGui::Text("%d", i);

            ImGui::TableNextColumn();

            const int cx = (i % ATLAS_COLS) * CELL;