#pragma once

#include "common.hpp"

class VM {
 public:
  VM() {}
  VM(Stack&& stack, Stack&& callstack)
      : _stack(std::move(stack)), _callstack(std::move(callstack)) {}
  VM(VM&& vm)
      : _stack(std::move(vm._stack)), _callstack(std::move(vm._callstack)) {}
  VM(const VM&) = delete;

  static Result<VM> create() {
    auto stack = TRY(Stack::create(16 * 1024));
    auto callstack = TRY(Stack::create(16 * 1024));
    return VM(std::move(stack), std::move(callstack));
  }

  Result<Value> run(const Module& mod);
  Result<Value> run(const Module& mod, const Dict& globals);

  Result<void> step();
  Result<void> vm_mov(Opcode& oc);
  Result<void> vm_add(Opcode& oc);
  Result<void> vm_mul(Opcode& oc);
  Result<void> vm_sub(Opcode& oc);
  Result<void> vm_div(Opcode& oc);
  Result<void> vm_call(Opcode& oc);
  Result<void> vm_selfcall(Opcode& oc);
  Result<void> vm_call_lisp(Opcode& oc, Function& fun);
  Result<void> vm_call_stdlib(Opcode& oc, StdlibFunction& fun);
  Result<void> vm_ret(Opcode& oc);

  Result<void> vm_equal(Opcode& oc);
  Result<void> vm_less(Opcode& oc);
  Result<void> vm_less_equal(Opcode& oc);
  Result<void> vm_jump(Opcode& oc);

  Result<void> vm_make_closure(Opcode& oc);
  Result<void> vm_closure_load(Opcode& oc);

  Result<void> vm_global_load(Opcode& oc);
  Result<void> vm_global_store(Opcode& oc);

  Result<Value> get(bool is_const, uint64_t idx);
  Result<Value> getconst(uint64_t idx);
  Result<Value> getreg(uint64_t idx);
  Result<void> setreg(uint64_t idx, const Value& value);

  Result<Dict> globals() {
    return _globals.copy();
  }

 private:
  Stack _stack;
  Stack _callstack;
  Function _fun;
  Array _code;
  Array _constants;
  Array _closure;
  Dict _globals;
  uint64_t _pc;
  uint64_t _base;
  Value _res;
};