#include "SymTable.hpp"

namespace jk
{
  /*explicit*/ SymTable::SymTable(Logger& logger,
                                  std::shared_ptr<SymTable> parent)
    : m_logger { logger }
    , m_parent { parent }
  {
  }

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

  size_t
  SymTable::declare(std::string const& name,
                    std::shared_ptr<Type> type,
                    Loc const& loc)
  {
    if (find_local(name))
      {
        m_logger.log<symbolic_error>(LOG_ERROR,
                                     loc,
                                     std::string()
                                     + "'"
                                     + name
                                     + "' is already defined");
      }

    size_t id = m_syms.size();

    m_syms.push_back(Sym {
        name,
        type,
        loc,
        false,
        id
      });

    return id;
  }

  size_t
  SymTable::declare_global(std::string const& name,
                           std::shared_ptr<Type> type,
                           Loc const& loc)
  {
    size_t addr = declare(name, type, loc);
    m_syms[addr].is_global = true;
    return addr;
  }

  std::optional<Sym> SymTable::find_local(std::string const& name) const
  {
    for (auto const& sym: m_syms)
      {
        if (sym.name == name)
          {
            return sym;
          }
      }

    return std::nullopt;
  }

  std::optional<Sym> SymTable::find(std::string const& name) const
  {
    auto entry = find_local(name);
    if (entry) { return entry; }

    if (m_parent)
      {
        return m_parent->find(name);
      }

    return std::nullopt;
  }
}