#include <llvm/IR/Value.h>
#include <llvm/IR/Function.h>

#include "Package.hpp"

namespace wg
{
  /*explicit*/ Package::Package(llvm::LLVMContext& context,
                                llvm::Module& mod)
    : m_context { context }
    , m_module { mod }
  {
  }

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

  void Package::scan(std::shared_ptr<Node> node, SymTable& sym)
  {
    switch (node->type())
      {
      case NODE_DIR: {
        if (node->child(0)->repr() == "package")
          {
            m_name = node->child(1)->repr();
          }
      } break;

      case NODE_FUNDECL: {
        std::string name = node->child(0)->repr();
        std::vector<llvm::Type*> params;
        std::vector<std::shared_ptr<Node>> buffer;

        for (size_t i=0; i<node->child(1)->size(); i++)
          {
            auto param = node->child(1)->child(i);

            if (param->type() == NODE_IDENT)
              {
                buffer.push_back(param);
              }
            else if (param->type() == NODE_TYPE)
              {
                for (auto p: buffer)
                  {
                    params.push_back((llvm::Type*)
                                     llvm::Type::getInt32Ty(m_context));
                  }

                buffer.clear();
              }
          }

        auto* ret = llvm::Type::getVoidTy(m_context);

        if (node->child(2)->size() > 0)
          {
            ret = (llvm::Type*) llvm::Type::getInt32Ty(m_context);
          }

        auto* fun_ty = llvm::FunctionType::get(ret, params, false);

        sym.declare_prototype(name, fun_ty, node->loc());

        llvm::Function::Create(fun_ty,
                               llvm::Function::ExternalLinkage,
                               name,
                               m_module);

      } break;

      default: {
        for (size_t i=0; i<node->size(); i++)
          {
            scan(node->child(i), sym);
          }
      } break;
      }
  }
}