#include "Compiler.hpp"
#include "lib/Node.hpp"
#include "lib/opcodes.hpp"
#include "StaticPass.hpp"

namespace roza
{
  /*explicit*/ Compiler::Compiler(StatusLog& log)
    : m_log { log }
  {
  }

  /*virtual*/ Compiler::~Compiler()
  {
  }

  std::shared_ptr<Program> Compiler::compile(std::shared_ptr<Node> root)
  {
    auto program = std::make_shared<Program>();
    compile_node(root, program);
    return program;
  }

  void Compiler::compile_node(std::shared_ptr<Node> root, std::shared_ptr<Program> prog)
  {
    switch (root->type())
      {

      case NODE_IF: {
        m_sym.enter_scope();

        std::vector<size_t> to_end;

        std::function<void(std::shared_ptr<Node>)>
          f = [&](std::shared_ptr<Node> n){
            auto cond = n->child(0);
            auto then = n->child(1);

            compile_node(cond, prog);
            size_t cond_addr = prog->size();
            prog->push_instr(OP_BRF, 0);

            compile_node(then, prog);

            to_end.push_back(prog->size());
            prog->push_instr(OP_BR, 0);

            prog->set_param(cond_addr, prog->size());

            if (n->size() > 2)
              {
                auto next = n->child(2);
                compile_node(next, prog);
              }
          };

        f(root);

        for (auto addr: to_end)
          {
            prog->set_param(addr, prog->size());
          }

        m_sym.leave_scope();

      } break;

      case NODE_ELSE:
      case NODE_THEN: {
        compile_children(root, prog);
      } break;

      case NODE_ASSERT: {
        compile_children(root, prog);
        prog->push_instr(OP_ASSERT);
      } break;

      case NODE_ASSERT_STATIC_FAIL: {
        bool failed = false;

        try
          {
            StaticPass static_pass {m_log, m_sym};
            static_pass.check_children(root);

            compile_children(root, prog);

            failed = true;
          }
        catch(...)
          {
          }

        if (failed)
          {
            m_log.fatal(root->loc(), "static assertion failed");
          }

      } break;

      case NODE_IDENT: {
        SymEntry const& entry = m_sym.find(root->repr());
        prog->push_instr(OP_LOAD_GLOBAL, entry.addr);
      } break;

      case NODE_VARDECL: {
        std::string name = root->child(0)->repr();
        compile_node(root->child(1), prog);
        int addr = m_sym.declare_mut(name, root->child(1));
        prog->push_instr(OP_STORE_GLOBAL, addr);

      } break;

      case NODE_CONSTDECL: {
        std::string name = root->child(0)->repr();
        compile_node(root->child(1), prog);
        int addr = m_sym.declare(name, root->child(1));
        prog->push_instr(OP_STORE_GLOBAL, addr);

      } break;

      case NODE_ASSIGN: {
        int addr = m_sym.find(root->child(0)->repr()).addr;
        compile_node(root->child(1), prog);
        prog->push_instr(OP_STORE_GLOBAL, addr);
      } break;

      case NODE_INT: {
        auto value = std::make_shared<Value>(std::stoi(root->repr()), root->loc());
        prog->push_instr(OP_PUSH_CONST, prog->push_value(value));
      } break;

      case NODE_BOOL: {
        auto value = std::make_shared<Value>(root->repr() == "true", root->loc());
        prog->push_instr(OP_PUSH_CONST, prog->push_value(value));
      } break;

      case NODE_EQ: {
        compile_children(root, prog);
        prog->push_instr(OP_EQ);
      } break;

      case NODE_NE: {
        compile_children(root, prog);
        prog->push_instr(OP_EQ);
        prog->push_instr(OP_NOT);
      } break;

      case NODE_LT: {
        compile_children(root, prog);
        prog->push_instr(OP_ILT);
      } break;

      case NODE_GT: {
        compile_children(root, prog);
        prog->push_instr(OP_IGT);
      } break;

      case NODE_LE: {
        compile_children(root, prog);
        prog->push_instr(OP_IGT);
        prog->push_instr(OP_NOT);
      } break;

      case NODE_GE: {
        compile_children(root, prog);
        prog->push_instr(OP_ILT);
        prog->push_instr(OP_NOT);
      } break;

      case NODE_IMP: {
        compile_children(root, prog);
        prog->push_instr(OP_IMP);
      } break;

      case NODE_AND: {
        compile_children(root, prog);
        prog->push_instr(OP_AND);
      } break;

      case NODE_OR: {
        compile_children(root, prog);
        prog->push_instr(OP_OR);
      } break;

      case NODE_NOT: {
        compile_children(root, prog);
        prog->push_instr(OP_NOT);
      } break;

      case NODE_ADD: {
        compile_children(root, prog);
        prog->push_instr(OP_IADD);
      } break;

      case NODE_SUB: {
        compile_children(root, prog);
        prog->push_instr(OP_ISUB);
      } break;

      case NODE_MUL: {
        compile_children(root, prog);
        prog->push_instr(OP_IMUL);
      } break;

      case NODE_DIV: {
        compile_children(root, prog);
        prog->push_instr(OP_IDIV);
      } break;

      case NODE_MOD: {
        compile_children(root, prog);
        prog->push_instr(OP_IMOD);
      } break;

      case NODE_POW: {
        compile_children(root, prog);
        prog->push_instr(OP_IPOW);
      } break;

      case NODE_UADD: {
        compile_children(root, prog);
        prog->push_instr(OP_IUADD);
      } break;

      case NODE_USUB: {
        compile_children(root, prog);
        prog->push_instr(OP_IUSUB);
      } break;

      case NODE_PROG: {
        compile_children(root, prog);
      } break;

      default:
        m_log.fatal(root->loc(), "cannot compile node '" + root->string() + "'.");
      }
  }

  void Compiler::compile_children(std::shared_ptr<Node> root, std::shared_ptr<Program> prog)
  {
    for (size_t i=0; i<root->size(); i++)
      {
        compile_node(root->child(i), prog);
      }
  }
}