#ifndef BDL_VM_H
#define BDL_VM_H

#include "types.h"
#include "errors.h"
#include "chunk.h"
#include "ops.h"
#include "debug.h"

#define VM_STACK_CAP 1024

typedef struct VM {
    // Program code.
    Chunk *chunk;
    // Program counter.
    u8 *pc;
    // Stack.
    Object *stack;
} VM;

void vm_init(VM *vm);
void vm_free(VM *vm);
void vm_reset(VM *vm);
void vm_interpret(VM *vm, Chunk *chunk);

void
vm_init(VM *vm) {
    *vm = (VM){0};
    array_init(vm->stack, VM_STACK_CAP);
}

void
vm_free(VM *vm) {
    array_free(vm->stack);
}

void
vm_reset(VM *vm) {
    vm_free(vm);
    vm_init(vm);
}

// Helper macros for a more clear VM switch.
#define WRONG_ARG_ERR() \
    error_push((Error){ \
        .type = ERR_TYPE_RUNTIME, \
        .value = ERR_WRONG_ARG_TYPE, \
        .line = vm->chunk->lines[vm->pc - vm->chunk->code - 1].line, \
        .col = vm->chunk->lines[vm->pc - vm->chunk->code - 1].col, \
    })

#define FIXNUM_ARITHMETIC_OP(OP) \
    do { \
        ssize_t n = AS_FIXNUM(array_pop(vm->stack)); \
        size_t stack_size = array_size(vm->stack) - n; \
        Object obj = array_peek(vm->stack, n - 1); \
        if (!IS_FIXNUM(obj)) { \
            WRONG_ARG_ERR(); \
            return; \
        } \
        ssize_t acc = AS_FIXNUM(obj); \
        while (n > 1) { \
            obj = array_peek(vm->stack, n - 2); \
            if (!IS_FIXNUM(obj)) { \
                WRONG_ARG_ERR(); \
                return; \
            } \
            ssize_t current = AS_FIXNUM(obj); \
            acc = acc OP current; \
            n--; \
        } \
        array_head(vm->stack)->size = stack_size; \
        array_push(vm->stack, FIXNUM_VAL(acc)); \
    } while (false)

#define FIXNUM_COMPARE_OP(OP) \
    do { \
        ssize_t n = AS_FIXNUM(array_pop(vm->stack)); \
        size_t stack_size = array_size(vm->stack) - n; \
        Object obj = array_peek(vm->stack, n - 1); \
        if (!IS_FIXNUM(obj)) { \
            WRONG_ARG_ERR(); \
            return; \
        } \
        ssize_t prev = AS_FIXNUM(obj); \
        bool ret = true; \
        while (n > 1) { \
            obj = array_peek(vm->stack, n - 2); \
            if (!IS_FIXNUM(obj)) { \
                WRONG_ARG_ERR(); \
                return; \
            } \
            ssize_t current = AS_FIXNUM(obj); \
            ret = ret && (prev OP current); \
            prev = current; \
            n--; \
        } \
        array_head(vm->stack)->size = stack_size; \
        array_push(vm->stack, BOOL_VAL(ret)); \
    } while (false)

#define LOGIC_OP(OP) \
    do { \
        Object a = array_pop(vm->stack); \
        Object b = array_pop(vm->stack); \
        bool x = IS_TRUE(a); \
        bool y = IS_TRUE(b); \
        Object result = y OP x ? TRUE_VAL : FALSE_VAL; \
        array_push(vm->stack, result); \
    } while (false)

void
vm_interpret(VM *vm, Chunk *chunk) {
    vm->chunk = chunk;
    vm->pc = vm->chunk->code;

    if (vm->chunk->code == NULL || array_size(vm->chunk->code) == 0) {
        error_push((Error){
            .type = ERR_TYPE_RUNTIME,
            .value = ERR_EMPTY_CHUNK,
        });
        return;
    }

    u8 *last = vm->chunk->code + array_size(vm->chunk->code);
    while (vm->pc < last) {
#ifdef DEBUG_TRACE_EXECUTION
        printf("stack:  [ ");
        for (size_t i = 0; i < array_size(vm->stack); i++) {
            display(vm->stack[i]);
            if (i < array_size(vm->stack) - 1) {
                printf(" | ");
            }
        }
        printf(" ]\nop: ");
        disassemble_instruction(vm->chunk, (vm->pc - vm->chunk->code));
#endif
        u8 instruction = *vm->pc++;
        switch (instruction) {
            case OP_CONSTANT: {
                u8 constant = *vm->pc++;
                Object obj = vm->chunk->constants[constant];
                array_push(vm->stack, obj);
            } break;
            case OP_SUM: { FIXNUM_ARITHMETIC_OP(+); } break;
            case OP_SUB: { FIXNUM_ARITHMETIC_OP(-); } break;
            case OP_MUL: { FIXNUM_ARITHMETIC_OP(*); } break;
            case OP_DIV: { FIXNUM_ARITHMETIC_OP(/); } break;
            case OP_MOD: { FIXNUM_ARITHMETIC_OP(%); } break;
            case OP_NOT: {
                Object prev = array_pop(vm->stack);
                Object new = IS_TRUE(prev) ? FALSE_VAL : TRUE_VAL;
                array_push(vm->stack, new);
            } break;
            case OP_AND: { LOGIC_OP(&&); } break;
            case OP_OR: { LOGIC_OP(||); } break;
            case OP_EQUAL: { FIXNUM_COMPARE_OP(==); } break;
            case OP_LESS: { FIXNUM_COMPARE_OP(<); } break;
            case OP_GREATER: { FIXNUM_COMPARE_OP(>); } break;
            case OP_LESS_EQUAL: { FIXNUM_COMPARE_OP(<=); } break;
            case OP_GREATER_EQUAL: { FIXNUM_COMPARE_OP(>=); } break;
            case OP_DISPLAY: {
                display(array_pop(vm->stack));
            } break;
            case OP_PRINT: {
                Object obj = array_pop(vm->stack);
                if (!IS_STRING(obj)) {
                    WRONG_ARG_ERR();
                }
                StringView scanner = (StringView) {
                    .start = obj.text,
                    .n = array_size(obj.text),
                };
                while (scanner.n != 0) {
                    char c = sv_next(&scanner);
                    if (c == '\\' && sv_peek(&scanner) == 'n') {
                        putchar('\n');
                        sv_next(&scanner);
                        continue;
                    }
                    if (c == '\\' && sv_peek(&scanner) == '"') {
                        putchar('"');
                        sv_next(&scanner);
                        continue;
                    }
                    putchar(c);
                }
            } break;
            case OP_NEWLINE: {
                printf("\n");
            } break;
            case OP_RETURN: {
                printf("\n");
                return;
            } break;
            default: {
                error_push((Error){
                    .type = ERR_TYPE_RUNTIME,
                    .value = ERR_NOT_IMPLEMENTED,
                    .line = vm->chunk->lines[vm->pc - vm->chunk->code - 1].line,
                    .col = vm->chunk->lines[vm->pc - vm->chunk->code - 1].col,
                });
                return;
            } break;
        }
    }

    error_push((Error){
        .type = ERR_TYPE_RUNTIME,
        .value = ERR_PC_OOB,
        .line = vm->chunk->lines[0].line,
        .col = vm->chunk->lines[0].col,
    });
}

#undef FIXNUM_ARITHMETIC_OP
#undef FIXNUM_COMPARE_OP
#undef LOGIC_OP

#endif // BDL_VM_H