// Commander X16 Emulator — ImGui "Symbols" panel.
//
// A filterable, sortable list of the address labels parsed from the loaded cc65
// .dbg info (dbg_info's `lab` records). Each row shows the label's address and
// its live byte + 16-bit word value. Double-click a row to jump the Disassembly
// and Memory views there (via the cross-panel goto service); right-click for
// set-breakpoint / run-to. This is the "where is X / what's in X right now" view.
#include "imgui.h"
#include "debug_ui_panels.h"
#include "debug_ui_bridge.h"  // dbg_info_symbol_*, debug_ui_read6502, DEBUG*, request_goto
#include "debug_ui_widgets.h" // dbgui_value_lines

#include <stdint.h>
#include <string.h>
#include <cctype>
#include <vector>
#include <algorithm>

namespace {

char s_filter[64] = "";

// Case-insensitive substring test.
bool
contains_ci(const char *hay, const char *needle)
{
    if (!needle[0])
        return true;
    size_t nl = strlen(needle);
    for (const char *p = hay; *p; ++p) {
        size_t i = 0;
        while (i < nl && p[i] &&
               tolower((unsigned char)p[i]) == tolower((unsigned char)needle[i]))
            i++;
        if (i == nl)
            return true;
    }
    return false;
}

// Case-insensitive strcmp (portable; the CRT one differs by platform).
int
sym_stricmp(const char *a, const char *b)
{
    for (;; a++, b++) {
        int ca = tolower((unsigned char)*a);
        int cb = tolower((unsigned char)*b);
        if (ca != cb)
            return ca - cb;
        if (!ca)
            return 0;
    }
}

// Toggle a breakpoint at a symbol's address (CPU program bank 0).
void
sym_toggle_bp(uint16_t addr)
{
    // Resolve the bank first: it keys the remove as well as the add.
    int x16 = (addr >= 0xA000)
                  ? (addr < 0xC000 ? (int)memory_get_ram_bank() : (int)memory_get_rom_bank())
                  : -1;
    if (!DEBUGRemoveBreakPoint((int)addr, 0, x16)) {
        struct breakpoint bp = {};
        bp.pc      = (int)addr;
        bp.bank    = 0;
        bp.x16Bank = x16;
        DEBUGAddBreakPoint(bp);
    }
}

struct SymRow {
    const char *name;
    uint16_t    addr;
};

void
symbols_panel_render(bool *p_open)
{
    if (!ImGui::Begin("Symbols", p_open)) {
        dbgui_window_end();
        return;
    }
    dbgui_window_zoom("symbols");

    const ImVec4 orange(1.0f, 0.78f, 0.35f, 1.0f);

    if (!dbg_info_is_loaded() || dbg_info_symbol_count() == 0) {
        ImGui::TextColored(orange, "No symbols loaded.");
        ImGui::Spacing();
        ImGui::TextWrapped("Symbols come from cc65 .dbg address labels. Start with "
                           "-dbgfile <prog.dbg> (and -srcpath if needed), or LOAD a "
                           "program whose matching .dbg auto-loads.");
        dbgui_window_end();
        return;
    }

    // Toolbar: name filter.
    ImGui::SetNextItemWidth(220);
    ImGui::InputTextWithHint("##symfilter", "filter by name...", s_filter, sizeof s_filter);
    ImGui::SameLine();
    ImGui::TextDisabled("%d symbols", dbg_info_symbol_count());
    ImGui::SameLine();
    ImGui::TextDisabled("(double-click = go to; right-click for more)");

    // Materialize the filtered rows (symbol counts are modest; rebuild per frame).
    static std::vector<SymRow> rows;
    rows.clear();
    int n = dbg_info_symbol_count();
    for (int i = 0; i < n; i++) {
        const char *nm = nullptr;
        uint16_t    a;
        if (debug_ui_symbol_at(i, &nm, &a) && nm && contains_ci(nm, s_filter))
            rows.push_back({nm, a});
    }

    ImGuiTableFlags tflags = ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |
                             ImGuiTableFlags_ScrollY | ImGuiTableFlags_Sortable |
                             ImGuiTableFlags_Resizable;
    if (ImGui::BeginTable("symbols", 4, tflags, ImVec2(0, 0))) {
        ImGui::TableSetupScrollFreeze(0, 1);
        ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_DefaultSort);
        ImGui::TableSetupColumn("Addr", ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableSetupColumn("Byte", ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableSetupColumn("Word", ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableHeadersRow();

        // Apply the requested sort (default: by name, ascending).
        if (ImGuiTableSortSpecs *ss = ImGui::TableGetSortSpecs()) {
            if (ss->SpecsCount > 0) {
                const ImGuiTableColumnSortSpecs &s = ss->Specs[0];
                bool asc = s.SortDirection != ImGuiSortDirection_Descending;
                if (s.ColumnIndex == 0) {
                    std::sort(rows.begin(), rows.end(), [asc](const SymRow &a, const SymRow &b) {
                        int c = sym_stricmp(a.name, b.name);
                        return asc ? c < 0 : c > 0;
                    });
                } else {
                    std::sort(rows.begin(), rows.end(), [asc](const SymRow &a, const SymRow &b) {
                        return asc ? a.addr < b.addr : a.addr > b.addr;
                    });
                }
            }
        }

        ImGuiListClipper clip;
        clip.Begin((int)rows.size());
        while (clip.Step()) {
            for (int i = clip.DisplayStart; i < clip.DisplayEnd; i++) {
                const SymRow &r  = rows[i];
                uint8_t       b  = debug_ui_read6502(r.addr, 0, DEBUG_UI_CURRENT_BANK);
                uint8_t       b2 = debug_ui_read6502((uint16_t)(r.addr + 1), 0, DEBUG_UI_CURRENT_BANK);
                uint16_t      w  = (uint16_t)(b | (b2 << 8));

                ImGui::TableNextRow();
                ImGui::PushID(i);

                ImGui::TableSetColumnIndex(0);
                if (ImGui::Selectable(r.name, false,
                                      ImGuiSelectableFlags_SpanAllColumns |
                                          ImGuiSelectableFlags_AllowDoubleClick) &&
                    ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
                    debug_ui_request_goto(r.addr, 0);
                }
                if (ImGui::BeginPopupContextItem("symctx")) {
                    if (ImGui::MenuItem("Go to (disasm + memory)"))
                        debug_ui_request_goto(r.addr, 0);
                    if (ImGui::MenuItem("Toggle breakpoint"))
                        sym_toggle_bp(r.addr);
                    ImGui::BeginDisabled(!DEBUGIsPaused());
                    if (ImGui::MenuItem("Run to here"))
                        DEBUGRunTo(r.addr, 0, DEBUG_OWNER_UI);
                    ImGui::EndDisabled();
                    ImGui::EndPopup();
                }

                ImGui::TableSetColumnIndex(1);
                ImGui::Text("$%04X", r.addr);
                ImGui::TableSetColumnIndex(2);
                ImGui::Text("$%02X", b);
                ImGui::TableSetColumnIndex(3);
                ImGui::Text("$%04X", w);

                ImGui::PopID();
            }
        }
        ImGui::EndTable();
    }

    dbgui_window_end();
}

DebugPanelRegistration s_reg("Symbols", symbols_panel_render, true);

} // namespace