#include "forth.h"

// Dynamic storage
int64_t *data_stack = NULL;
int32_t data_sp = -1;
int32_t data_cap = 0;

Cell *ret_stack = NULL;
int32_t rp = -1;
int32_t ret_cap = 0;
Cell* ip = NULL;

Word* dict_head = NULL;

int state = 0;
Cell *compile_buf = NULL;
int32_t compile_idx = 0;
int32_t compile_cap = 0;
char compiling_name[MAX_NAME_LEN + 1] = {0};

char input_buf[1024] = {0};
char* input_ptr = NULL;

int64_t *compile_stack = NULL;
int32_t compile_sp = -1;
int32_t compile_stack_cap = 0;

Cell *user_mem = NULL;
int64_t user_mem_size = 0;
Cell* here = NULL;

// ---------- Data stack ----------
void data_push(int64_t val) {
    if (data_sp + 1 >= data_cap) {
        int32_t new_cap = data_cap ? data_cap * 2 : 128;
        int64_t *tmp = realloc(data_stack, new_cap * sizeof(int64_t));
        if (!tmp) {
            fprintf(stderr, "Out of memory\n");
            exit(1);
        }
        data_stack = tmp;
        data_cap = new_cap;
    }
    data_stack[++data_sp] = val;
}

int64_t data_pop(void) {
    if (data_sp < 0) {
        fprintf(stderr, "Data stack underflow\n");
        return 0;
    }
    return data_stack[data_sp--];
}

// ---------- Return stack (holds Cell values) ----------
static void ensure_ret_stack(void) {
    if (rp + 1 >= ret_cap) {
        int32_t new_cap = ret_cap ? ret_cap * 2 : 128;
        Cell *tmp = realloc(ret_stack, new_cap * sizeof(Cell));
        if (!tmp) {
            fprintf(stderr, "Out of memory\n");
            exit(1);
        }
        ret_stack = tmp;
        ret_cap = new_cap;
    }
}

void ret_push_ip(Cell* val) {
    ensure_ret_stack();
    rp++;
    ret_stack[rp].ptr = val;   // store pointer in the 'ptr' member
}

Cell* ret_pop_ip(void) {
    if (rp < 0) {
        fprintf(stderr, "Return stack underflow\n");
        return NULL;
    }
    return ret_stack[rp--].ptr;
}

void ret_push_num(int64_t val) {
    ensure_ret_stack();
    rp++;
    ret_stack[rp].num = val;
}

int64_t ret_pop_num(void) {
    if (rp < 0) {
        fprintf(stderr, "Return stack underflow (num)\n");
        return 0;
    }
    return ret_stack[rp--].num;
}

// ---------- Compile stack (indices) ----------
static void ensure_compile_stack(void) {
    if (compile_sp + 1 >= compile_stack_cap) {
        int32_t new_cap = compile_stack_cap ? compile_stack_cap * 2 : 64;
        int64_t *tmp = realloc(compile_stack, new_cap * sizeof(int64_t));
        if (!tmp) {
            fprintf(stderr, "Out of memory\n");
            exit(1);
        }
        compile_stack = tmp;
        compile_stack_cap = new_cap;
    }
}

void compile_push(int64_t idx) {
    ensure_compile_stack();
    compile_stack[++compile_sp] = idx;
}

int64_t compile_pop(void) {
    if (compile_sp < 0) {
        fprintf(stderr, "Compile stack underflow\n");
        return -1;
    }
    return compile_stack[compile_sp--];
}