#include <cassert>

#include "nodebuilder.h"
#include "yaml-cpp/node/detail/node.h"
#include "yaml-cpp/node/impl.h"
#include "yaml-cpp/node/node.h"
#include "yaml-cpp/node/type.h"

namespace YAML {
struct Mark;

NodeBuilder::NodeBuilder()
 : m_pMemory(std::make_shared<detail::memory_holder>()),
 m_pRoot(nullptr),
 m_stack{},
 m_anchors{},
 m_keys{},
 m_mapDepth(0) {
 m_anchors.push_back(nullptr); // since the anchors start at 1
}

NodeBuilder::~NodeBuilder() = default;

Node NodeBuilder::Root() {
 if (!m_pRoot)
 return Node();

 return Node(*m_pRoot, m_pMemory);
}

void NodeBuilder::OnDocumentStart(const Mark&) {}

void NodeBuilder::OnDocumentEnd() {}

void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor) {
 detail::node& node = Push(mark, anchor);
 node.set_null();
 Pop();
}

void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) {
 detail::node& node = *m_anchors[anchor];
 Push(node);
 Pop();
}

void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag,
 anchor_t anchor, const std::string& value) {
 detail::node& node = Push(mark, anchor);
 node.set_scalar(value);
 node.set_tag(tag);
 Pop();
}

void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag,
 anchor_t anchor, EmitterStyle::value style) {
 detail::node& node = Push(mark, anchor);
 node.set_tag(tag);
 node.set_type(NodeType::Sequence);
 node.set_style(style);
}

void NodeBuilder::OnSequenceEnd() { Pop(); }

void NodeBuilder::OnMapStart(const Mark& mark, const std::string& tag,
 anchor_t anchor, EmitterStyle::value style) {
 detail::node& node = Push(mark, anchor);
 node.set_type(NodeType::Map);
 node.set_tag(tag);
 node.set_style(style);
 m_mapDepth++;
}

void NodeBuilder::OnMapEnd() {
 assert(m_mapDepth > 0);
 m_mapDepth--;
 Pop();
}

detail::node& NodeBuilder::Push(const Mark& mark, anchor_t anchor) {
 detail::node& node = m_pMemory->create_node();
 node.set_mark(mark);
 RegisterAnchor(anchor, node);
 Push(node);
 return node;
}

void NodeBuilder::Push(detail::node& node) {
 const bool needsKey =
 (!m_stack.empty() && m_stack.back()->type() == NodeType::Map &&
 m_keys.size() < m_mapDepth);

 m_stack.push_back(&node);
 if (needsKey)
 m_keys.emplace_back(&node, false);
}

void NodeBuilder::Pop() {
 assert(!m_stack.empty());
 if (m_stack.size() == 1) {
 m_pRoot = m_stack[0];
 m_stack.pop_back();
 return;
 }

 detail::node& node = *m_stack.back();
 m_stack.pop_back();

 detail::node& collection = *m_stack.back();

 if (collection.type() == NodeType::Sequence) {
 collection.push_back(node, m_pMemory);
 } else if (collection.type() == NodeType::Map) {
 assert(!m_keys.empty());
 PushedKey& key = m_keys.back();
 if (key.second) {
 collection.insert(*key.first, node, m_pMemory);
 m_keys.pop_back();
 } else {
 key.second = true;
 }
 } else {
 assert(false);
 m_stack.clear();
 }
}

void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) {
 if (anchor) {
 assert(anchor == m_anchors.size());
 m_anchors.push_back(&node);
 }
}
} // namespace YAML