// Commander X16 Emulator — ImGui "Call Stack" panel.
//
// The 6502/65C816 has no frame pointer, so this heuristically unwinds the
// hardware stack: frame 0 is the current PC, then it scans the stack for
// candidate return addresses whose preceding instruction is a JSR ($20). Each
// plausible caller is resolved to a symbol + source line. Click a frame to jump
// the Disassembly + Memory views there. Heuristic by nature (a stray stack byte
// pair can occasionally look like a return address), so treat deep frames as a
// hint, not gospel — but the JSR-precedes check keeps false positives low.
#include "imgui.h"
#include "debug_ui_panels.h"
#include "debug_ui_bridge.h"
#include "debug_ui_widgets.h" // regs, debug_ui_read6502, dbg_info_*, request_goto

#include <stdint.h>
#include <stdio.h>

extern "C" {
#include "dbg_info.h" // dbg_info_addr_to_source_nearest (not in the bridge)
}

namespace {

struct Frame {
    uint16_t addr;  // frame 0: current PC; callers: return address
    bool     is_pc; // frame 0 marker
};

void
callstack_panel_render(bool *p_open)
{
    if (!ImGui::Begin("Call Stack", p_open)) {
        dbgui_window_end();
        return;
    }
    dbgui_window_zoom("callstack");

    const uint8_t bank   = regs.k;
    const bool    native = regs.is65c816 && !regs.e;

    // Frame 0 = current PC; then heuristically unwind.
    Frame frames[64];
    int   nf     = 0;
    frames[nf++] = {regs.pc, true};

    // Stack scan range. 6502/emulation: page 1 ($0100-$01FF). Native: 16-bit SP,
    // scan a bounded window upward from SP+1.
    uint32_t sp    = regs.sp;
    uint32_t start = native ? (sp + 1) : (0x100 + (sp & 0xFF) + 1);
    uint32_t end   = native ? (sp + 1 + 256) : 0x200;

    for (uint32_t a = start; a + 1 < end && nf < 64;) {
        uint8_t  lo     = debug_ui_read6502((uint16_t)a, 0, DEBUG_UI_CURRENT_BANK);
        uint8_t  hi     = debug_ui_read6502((uint16_t)(a + 1), 0, DEBUG_UI_CURRENT_BANK);
        uint16_t pushed = (uint16_t)(lo | (hi << 8)); // JSR pushes (return-1)
        // A JSR ($20) at pushed-2 means execution resumes at pushed+1.
        uint8_t opc = debug_ui_read6502((uint16_t)(pushed - 2), bank, DEBUG_UI_CURRENT_BANK);
        if (opc == 0x20) {
            frames[nf++] = {(uint16_t)(pushed + 1), false};
            a += 2; // consume the return-address pair
        } else {
            a += 1;
        }
    }

    if (!dbg_info_is_loaded()) {
        ImGui::TextDisabled("(no .dbg loaded — addresses only; load debug info for source/symbols)");
    }
    ImGui::TextDisabled("Heuristic unwind (JSR-based). Click a frame to go there.");

    if (ImGui::BeginTable("callstack", 3,
                          ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |
                              ImGuiTableFlags_ScrollY | DBGUI_TABLE_FLAGS_RESIZABLE)) {
        ImGui::TableSetupColumn("#", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("#", "99"));
        ImGui::TableSetupColumn("Address / Symbol", ImGuiTableColumnFlags_WidthStretch);
        ImGui::TableSetupColumn("Source", ImGuiTableColumnFlags_WidthStretch);
        ImGui::TableHeadersRow();

        for (int i = 0; i < nf; i++) {
            const Frame &f = frames[i];
            ImGui::TableNextRow();
            ImGui::PushID(i);

            ImGui::TableSetColumnIndex(0);
            if (f.is_pc)
                ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.35f, 1.0f), "%d", i);
            else
                ImGui::Text("%d", i);

            ImGui::TableSetColumnIndex(1);
            const char *label = nullptr;
            char        buf[128];
            bool        has_src =
                dbg_info_addr_to_source_banked(f.addr, (int)memory_get_ram_bank(), nullptr, nullptr);
            const char *nosrc = has_src ? "" : "  (no src)";

            // Frame 0 is the PC and often sits exactly on a label. Caller frames
            // are return addresses - the instruction after a JSR - which almost
            // never are, so an exact lookup left every caller anonymous: a frame
            // showed its symbol only while it was frame 0, then blanked the
            // moment a deeper call pushed it down. Fall back to the label the
            // address falls inside and show the offset from it.
            uint16_t    label_at = 0;
            if (dbg_info_addr_to_label(f.addr, &label) && label) {
                snprintf(buf, sizeof buf, "$%04X  %s%s", f.addr, label, nosrc);
            } else if (has_src && debug_ui_addr_to_label_nearest(f.addr, &label, &label_at) && label) {
                // Only when the address is really covered by the debug info -
                // the nearest label of an uncovered address is meaningless.
                snprintf(buf, sizeof buf, "$%04X  %s+%u", f.addr, label,
                         (unsigned)(f.addr - label_at));
            } else {
                snprintf(buf, sizeof buf, "$%04X%s", f.addr, nosrc);
            }
            if (ImGui::Selectable(buf, f.is_pc, ImGuiSelectableFlags_SpanAllColumns))
                debug_ui_request_goto(f.addr, bank);

            ImGui::TableSetColumnIndex(2);
            const char *file = nullptr;
            int         line = 0;
            if (dbg_info_addr_to_source_banked(f.addr, (int)memory_get_ram_bank(), &file, &line) && file) {
                const char *base = file;
                for (const char *p = file; *p; ++p)
                    if (*p == '/' || *p == '\\')
                        base = p + 1;
                ImGui::Text("%s:%d", base, line);
            } else {
                // No debug info for this frame — say WHY rather than just "-",
                // so a KERNAL call or a low-RAM far-call thunk (e.g. JSRFAR at
                // $02xx) is obvious instead of looking like missing symbols.
                const char *what;
                if (f.addr >= 0xC000)
                    what = "[KERNAL/ROM] no source";
                else if (f.addr >= 0xA000)
                    what = "[banked] no source";
                else if (f.addr < 0x0800)
                    what = "[stub/KERNAL RAM] no source";
                else
                    what = "[NOSRC]";
                ImGui::TextColored(ImVec4(0.70f, 0.70f, 0.78f, 1.0f), "%s", what);
                if (ImGui::IsItemHovered())
                    ImGui::SetTooltip("$%04X is not covered by the loaded .dbg.\n"
                                      "$C000-$FFFF is banked ROM (KERNAL/BASIC);\n"
                                      "$0200-$07FF usually holds KERNAL RAM routines\n"
                                      "such as the JSRFAR far-call trampoline.", f.addr);
            }

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

    dbgui_window_end();
}

DebugPanelRegistration s_reg("Call Stack", callstack_panel_render, true);

} // namespace