#ifndef roza_NODE_HPP
#define roza_NODE_HPP

#include "commons.hpp"
#include "SrcLoc.hpp"

#define NODE_TYPE(G)                                                    \
  G(NODE_PROG), G(NODE_INSTR), G(NODE_EOI),                             \
    G(NODE_INT), G(NODE_ADD), G(NODE_SUB), G(NODE_MUL),                 \
    G(NODE_DIV), G(NODE_MOD), G(NODE_POW), G(NODE_OPAR),                \
    G(NODE_CPAR), G(NODE_UADD), G(NODE_USUB), G(NODE_BOOL),             \
    G(NODE_AND), G(NODE_OR), G(NODE_NOT), G(NODE_IMP),                  \
    G(NODE_EQ), G(NODE_NE), G(NODE_LT), G(NODE_LE), G(NODE_GT),         \
    G(NODE_GE), G(NODE_ASSERT), G(NODE_ASSERT_STATIC_FAIL),             \
    G(NODE_IDENT), G(NODE_ASSIGN), G(NODE_LET), G(NODE_LET_MUT),        \
    G(NODE_VARDECL), G(NODE_CONSTDECL), G(NODE_IF), G(NODE_ELSE),       \
    G(NODE_THEN), G(NODE_END), G(NODE_FUN), G(NODE_AS), G(NODE_TYPE),   \
    G(NODE_PARAMS), G(NODE_RET), G(NODE_BODY), G(NODE_ARROW),           \
    G(NODE_COMMA), G(NODE_PARAM), G(NODE_RETURN), G(NODE_OBRACE),       \
    G(NODE_CBRACE), G(NODE_CALL), G(NODE_ARGS)

namespace roza
{
  MAKE_ENUM(NODE_TYPE, NodeType);

  class Node
  {
  public:
    explicit Node(NodeType type, std::string const& repr, SrcLoc loc);
    virtual ~Node();

    NodeType type() const { return m_type; }
    std::string repr() const { return m_repr; }
    SrcLoc loc() const { return m_loc; }
    size_t size() const { return m_children.size(); }

    std::string string() const;

    void add_child(std::shared_ptr<Node> child);

    std::shared_ptr<Node> child(size_t index);
    Node const& child(size_t index) const;

  private:
    NodeType m_type;
    std::string m_repr;
    SrcLoc m_loc;
    std::vector<std::shared_ptr<Node>> m_children;
  };
}

#endif