#include <vector>
#include <variant>
#include <string>
#include <iostream>
#include "cpp-httplib/httplib.h"

const std::string cSite { "http://kit.local" };
const std::string cUrlComment { "/comment/?id=" };

using StatusT = httplib::StatusCode;
using ResultT = std::variant<std::string, StatusT>;
using ErrorsList = std::vector<StatusT>;

/* define << for ResultT and Node<T> (below) to print results */
static std::ostream& operator <<(std::ostream& os, const ResultT& val) {
  if (const std::string* pval = std::get_if<std::string>(&val))
    std::cout << "'" << *pval << "'";
  else if (const StatusT* code = std::get_if<StatusT>(&val))
    std::cout << "Error " << *code << ": " << httplib::status_message(*code);
  return os;
}

/* tree */
template<typename T>
struct Node {
  T value;
  std::vector<Node<T>> children;
  Node() = delete;
  Node(const T& val) : value(val) {}
  void insert(Node<T>& node)
  {
    if (node.value == value)
      return;
    children.push_back(node);
  }

  friend std::ostream& operator <<(std::ostream& os, const Node<T>& val)
  {
    os << "[" << val.value << "]";
    if (!val.children.empty())
      os << "\nChildren:\t";
    std::for_each(val.children.cbegin(), val.children.cend(),
      [&os] (const Node<T> node) { os << node; });
    return os;
  }
};
using CommentTree = Node<ResultT>;

template<typename T1, typename T2, typename T3>
Node<T2> traverse(const Node<T1>& src, T3 f) {
  Node<T2> result(f(src.value));
  std::for_each(src.children.cbegin(), src.children.cend(),
    [&] (const Node<T1>& node) {
      result.children.push_back(traverse<T1, T2, T3>(node, f));
    });
  return result;
}

template<typename T1, typename T2, typename T3>
void forAll(const Node<T1> &src, std::vector<T2> &result, T3 f) {
  f(src.value, result);
  std::for_each(src.children.cbegin(), src.children.cend(),
    [&] (const Node<T1>& node) {
      forAll<T1, T2, T3>(node, result, f);
    });
}

static ResultT tryGetContent(httplib::Client &c, const int x) {
  auto res = c.Get(cUrlComment + std::to_string(x));
  if (res->status == StatusT::OK_200)
    return res->body;
  return static_cast<StatusT>(res->status);
}

static std::variant<CommentTree, ErrorsList>
    tryGetContent(const Node<int> &src, ErrorsList &errors) {
  httplib::Client cli(cSite);

  auto actionGet = [&] (const int x) {
    return tryGetContent(cli, x);
  };
  CommentTree result = traverse<int, ResultT, decltype(actionGet)>(src, actionGet);

  auto collectErrors = [&] (const CommentTree& node, ErrorsList& list) {
    if (const StatusT* code = std::get_if<StatusT>(&node.value))
      list.push_back(*code);
  };
  forAll<ResultT, StatusT, decltype(collectErrors)>(result, errors, collectErrors);

  if (errors.size() > 0)
    return errors;
  return result;
}

int main() {
  using IntNode = Node<int>;

  IntNode tree { 10 };
  IntNode a { 100 }, b { 101 }, c { 102 };
  IntNode bb { 1001 };
  b.insert(bb);

  tree.insert(a);
  tree.insert(b);
  tree.insert(c);

  IntNode root { 1 };
  root.insert(tree);
  std::cout << "\n Source:\n";
  std::cout << root;

  ErrorsList errors;
  auto result = tryGetContent(root, errors);

  /* print result */
  if (const auto *list = std::get_if<ErrorsList>(&result)) {
    std::for_each(list->cbegin(), list->cend(), [&](const StatusT code) {
      std::cout << "\nError " << code << ": " << httplib::status_message(code);
    });
  } else if (const auto* node = std::get_if<CommentTree>(&result)) {
    std::cout << "\n Result:\n";
    std::cout << *node;
  }
  return 0;
}