#include "TypeResolver.hpp"

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

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

  std::shared_ptr<Type> TypeResolver::find(std::shared_ptr<Node> root,
                                           SymTable const& sym)
  {
    switch (root->type())
      {
      case NODE_PROG: {
        return find(root->child(root->size() - 1), sym);
      } break;

      case NODE_IDENT: {
        std::string name = root->repr();
        SymEntry const& entry = sym.find(name);
        return find(entry.node, sym);
      } break;

      case NODE_CONSTDECL:
      case NODE_VARDECL: {
        auto ty = find(root->child(1), sym);
      } break;

      case NODE_INT: {
        return std::make_shared<Type>(BaseType::TY_INT);
      } break;

      case NODE_EQ:
      case NODE_NE:
      case NODE_LT:
      case NODE_LE:
      case NODE_GT:
      case NODE_GE:
      case NODE_IMP:
      case NODE_AND:
      case NODE_OR:
      case NODE_NOT:
      case NODE_BOOL: {
        return std::make_shared<Type>(BaseType::TY_BOOL);
      } break;

      case NODE_ADD:
      case NODE_SUB:
      case NODE_MUL:
      case NODE_DIV:
      case NODE_MOD:
      case NODE_POW:
      case NODE_UADD:
      case NODE_USUB:{
        return find(root->child(0), sym);
      } break;

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

    return nullptr;
  }
}