#include "node.h"

uint32_t Node::node_id = 0;

Node::Node(const std::string& name)
{
    node_id++;

    if (name.empty())
    {
        std::stringstream str_sm;
        str_sm << node_id;
        std::string node_id_str = str_sm.str();

        this->name = "node" + node_id_str;
    }
    else
    {
        this->name = name;
    }
}

Node::~Node()
{
    std::cout << "enter ~node() of \"" << name << "\"" << std::endl;

    for (Node* child : children)
    {
        delete child;
    }

    std::cout << "leave ~node() of \"" << name << "\"" << std::endl;
}

std::string Node::get_name() const
{
    return name;
}

void Node::set_name(const std::string& new_name)
{
    name = new_name;
}

int Node::get_nr_children() const
{
    return children.size();
}

Node* Node::get_child(int i) const
{
    if (i < 0 || i >= static_cast<int>(children.size()))
    {
        return nullptr;
    }

    return children[i];
}

void Node::add_child(Node* child)
{
    children.emplace_back(child);
}

void Node::print(std::ostream& str, uint32_t depth) const
{
    auto predicate = [&str](const Node* node, uint32_t depth)
    {
        for (uint32_t i = 0; i < depth; i++)
        {
            str << "\t";
        }

        str << node->get_name() + "\n";
    };

    Node::traverse_tree(this, predicate);
}

Node* Node::create_complete_tree(uint32_t nr_child_nodes, uint32_t tree_depth)
{
    if (tree_depth == 0)
    {
        return nullptr;
    }

    Node* node = new Node;

    for (uint32_t j = 0; j < nr_child_nodes; j++)
    {
        Node* child = Node::create_complete_tree(nr_child_nodes, tree_depth - 1);

        if (child == nullptr)
        {
            break;
        }

        node->children.emplace_back(child);
    }

    return node;
}

void Node::traverse_tree(const Node* node, std::function<void(const Node*, uint32_t)> predicate, uint32_t depth)
{
    predicate(node, depth);

    for (Node* child : node->children)
    {
        Node::traverse_tree(child, predicate, depth + 1);
    }
}

std::ostream& operator<<(std::ostream &os, const Node *node)
{
    node->print(os);

    return os;
}