#ifndef fk_VM_HPP
#define fk_VM_HPP

#include "commons.hpp"
#include "Program.hpp"
#include "NativeFunction.hpp"
#include "Lambda.hpp"

namespace fk
{
  using global_t = std::variant<std::shared_ptr<NativeFunction>,
                                std::shared_ptr<Lambda>
                                >;

  struct Frame {
    std::shared_ptr<Program> program;
    addr_t ret_addr;
    size_t stack_sz;
    std::unordered_map<addr_t, std::shared_ptr<Constant>> locals;
  };
  class Module;

  class VM
  {
  public:
    explicit VM(Module& mod);
    virtual ~VM();

    Frame& frame() { return m_frames.back(); }

    void mount(std::shared_ptr<Program> program);
    void run();

    std::shared_ptr<Constant>
    call(std::shared_ptr<Lambda> lambda,
         size_t ref,
         std::vector<std::shared_ptr<Constant>> const& args,
         Loc const& loc);

    global_t load_global(addr_t addr) const;
    void store_global(addr_t addr, global_t value);
    size_t store_global(global_t value);

    std::shared_ptr<Constant> load_local(addr_t addr);
    void store_local(addr_t addr, std::shared_ptr<Constant> constant);

    std::string string() const;

    void push(addr_t addr);
    addr_t top();
    addr_t pop();

    std::shared_ptr<Constant>
    run_lambda(VM const& parent,
               std::shared_ptr<Lambda> lambda,
               std::vector<std::shared_ptr<Constant>> args,
               size_t ref,
               Loc const& loc);

  private:
    Module& m_mod;
    addr_t m_pc = 0;
    std::vector<Frame> m_frames;
    std::vector<addr_t> m_stack;
    std::unordered_map<addr_t, global_t> m_globals;
    std::shared_ptr<Constant> m_return_const;
  };
}

#endif