debugging.zig

const std = @import("std");
const Chunk = @import("chunk.zig").Chunk;
const Opc = @import("chunk.zig").OpCode;
const Value = @import("value.zig").Value;
const printValue = @import("value.zig").printValue;

pub fn disassembleChunk(chunk: *Chunk, name: []const u8) !void {
    std.debug.print("== {s} ==\n", .{name});

    var offset: usize = 0;
    while (offset < chunk.code.count) : (offset = disassembleInstruction(chunk, offset)) {}
}

pub fn disassembleInstruction(chunk: *Chunk, offset: usize) usize {
    std.debug.print("{d:0>4}", .{offset});

    const lines = chunk.lines;
    const instruction = Opc.fromU8(chunk.code.items[offset]);

    if (offset > 0 and lines.items[offset] == lines.items[offset - 1]) {
        std.debug.print("   | ", .{});
    } else {
        std.debug.print("{d: >4} ", .{lines.items[offset]});
    }

    return switch (instruction) {
        .op_return => simpleInstruction(instruction.toString(), offset),
        .op_class => constInstruction(instruction.toString(), chunk, offset),
        .op_print => simpleInstruction(instruction.toString(), offset),
        .op_constant => constInstruction(instruction.toString(), chunk, offset),
        .op_false => simpleInstruction(instruction.toString(), offset),
        .op_true => simpleInstruction(instruction.toString(), offset),
        .op_pop => simpleInstruction(instruction.toString(), offset),
        .op_duplicate => simpleInstruction(instruction.toString(), offset),
        .op_define_global => constInstruction(instruction.toString(), chunk, offset),
        .op_get_global => constInstruction(instruction.toString(), chunk, offset),
        .op_set_global => constInstruction(instruction.toString(), chunk, offset),
        .op_get_local => byteInstruction(instruction.toString(), chunk, offset),
        .op_set_local => byteInstruction(instruction.toString(), chunk, offset),
        .op_get_upvalue => byteInstruction(instruction.toString(), chunk, offset),
        .op_set_upvalue => byteInstruction(instruction.toString(), chunk, offset),
        .op_get_property => constInstruction(instruction.toString(), chunk, offset),
        .op_set_property => constInstruction(instruction.toString(), chunk, offset),
        .op_jump => jumpInstruction(instruction.toString(), 1, chunk, offset),
        .op_jump_if_false => jumpInstruction(instruction.toString(), 1, chunk, offset),
        .op_loop => jumpInstruction(instruction.toString(), -1, chunk, offset),
        .op_call => byteInstruction(instruction.toString(), chunk, offset),
        .op_closure => closureInstruction(instruction.toString(), chunk, offset),
        .op_close_upvalue => simpleInstruction(instruction.toString(), offset),
        .op_nil => simpleInstruction(instruction.toString(), offset),
        .op_not => simpleInstruction(instruction.toString(), offset),
        .op_greater => simpleInstruction(instruction.toString(), offset),
        .op_less => simpleInstruction(instruction.toString(), offset),
        .op_equal => simpleInstruction(instruction.toString(), offset),
        .op_negate => simpleInstruction(instruction.toString(), offset),
        .op_add => simpleInstruction(instruction.toString(), offset),
        .op_subtract => simpleInstruction(instruction.toString(), offset),
        .op_mult => simpleInstruction(instruction.toString(), offset),
        .op_divide => simpleInstruction(instruction.toString(), offset),
        .op_constant_long => longConstInstruction(instruction.toString(), chunk, offset),
    };
}

pub fn simpleInstruction(name: []const u8, offset: usize) usize {
    std.debug.print(" {s} \n", .{name});
    return offset + 1;
}

pub fn longConstInstruction(name: []const u8, chunk: *Chunk, offset: usize) usize {
    const constant: u32 = @as(u32, chunk.code.items[offset + 1]) |
        @as(u32, (chunk.code.items[offset + 2])) << 8 |
        @as(u32, (chunk.code.items[offset + 3])) << 16;

    const stdout = std.io.getStdOut().writer();

    // Use try to handle potential errors when printing the name
    _ = stdout.print("{s}\n", .{name}) catch |err| {
        std.debug.print("Failed to print name: {}\n", .{err});
    };

    const tag = @TypeOf(chunk.constants.items[constant]);
    std.debug.print("Type: {}\n", .{tag});
    printValue(chunk.constants.items[constant]);
    // Call the Zig equivalent of printValue
    //printValue(chunk.constants.items[constant]);

    // Print the ending quote and newline
    _ = stdout.print("'\n", .{}) catch |err| {
        std.debug.print("Failed to print ending quote: {}\n", .{err});
    };
    return offset + 4;
}

fn closureInstruction(name: []const u8, chunk: *Chunk, initialOffset: usize) usize {
    var offset = initialOffset + 1;
    const constant = chunk.code.items[offset];
    offset += 1;
    std.debug.print("{s} {} ", .{ name, constant });
    printValue(chunk.constants.items[constant]);
    std.debug.print("\n", .{});

    const function = chunk.constants.items[constant].obj.asFunction();
    var i: usize = 0;
    while (i < function.upvalueCount) : (i += 1) {
        const isLocal = chunk.code.items[offset] != 1;
        const valueType = if (isLocal) "local" else "upvalue";
        offset += 1;
        const index = chunk.code.items[offset];
        offset += 1;
        std.debug.print("{} | {s} {}\n", .{ offset - 2, valueType, index });
    }

    return offset;
}

fn jumpInstruction(name: []const u8, sign: isize, chunk: *Chunk, offset: usize) usize {
    var jump = @as(u16, chunk.code.items[offset + 1]) << 8;
    jump |= chunk.code.items[offset + 2];
    const target = @as(isize, @intCast(offset)) + 3 + sign * @as(isize, @intCast(jump));
    std.debug.print("{s} {d} -> {d}\n", .{ name, offset, target });
    return offset + 3;
}

pub fn constInstruction(name: []const u8, chunk: *Chunk, offset: usize) usize {
    const constant_idx = chunk.code.items[offset + 1];
    const constant = chunk.constants.items[constant_idx];
    printValue(constant);
    std.debug.print("{s: <16} '{}'\n", .{ name, constant });
    return offset + 2;
}
fn byteInstruction(name: []const u8, chunk: *Chunk, offset: usize) usize {
    const slot = chunk.code.items[offset + 1];
    std.debug.print("{s} {d} \n", .{ name, slot });
    std.debug.print("\n", .{});
    return offset + 2;
}
pub fn printStack(stack: []Value) void {
    std.debug.print("          ", .{});

    for (stack) |value| {
        std.debug.print("[{}]", .{value});
    }

    std.debug.print("\n", .{});
}