/**
 * @file
 * @brief Recursive version of Inorder, Preorder, and Postorder [Traversal of
 * the Tree] (https://en.wikipedia.org/wiki/Tree_traversal)
 *
 * @details
 *
 * ### Iterative Inorder Traversal of a tree
 * For traversing a (non-empty) binary tree in an inorder fashion, we must do
 * these three things for every node n starting from the tree’s root:
 *
 * (L) Recursively traverse its left subtree. When this step is finished,
 * we are back at n again.
 * (N) Process n itself.
 * (R) Recursively traverse its right subtree. When this step is finished,
 * we are back at n again.
 *
 * In normal inorder traversal, we visit the left subtree before the right
 * subtree. If we visit the right subtree before visiting the left subtree, it
 * is referred to as reverse inorder traversal.
 *
 * ### Iterative Preorder Traversal of a tree
 * For traversing a (non-empty) binary tree in a preorder fashion, we must do
 * these three things for every node n starting from the tree’s root:
 *
 * (N) Process n itself.
 * (L) Recursively traverse its left subtree. When this step is finished,
 * we are back at n again.
 * (R) Recursively traverse its right subtree. When this step is finished,
 * we are back at n again.
 *
 * In normal preorder traversal, visit the left subtree before the right
 * subtree. If we visit the right subtree before visiting the left subtree, it
 * is referred to as reverse preorder traversal.
 *
 * ### Iterative Postorder Traversal of a tree
 * For traversing a (non-empty) binary tree in a postorder fashion, we must do
 * these three things for every node n starting from the tree’s root:
 *
 * (L) Recursively traverse its left subtree. When this step is finished,
 * we are back at n again.
 * (R) Recursively traverse its right subtree. When this step is finished,
 * we are back at n again.
 * (N) Process n itself.
 *
 * In normal postorder traversal, visit the left subtree before the right
 * subtree. If we visit the right subtree before visiting the left subtree, it
 * is referred to as reverse postorder traversal.
 *
 * @author [Lajat Manekar](https://github.com/Lazeeez)
 *
 */

#include <cassert>   /// for assert
#include <iostream>  /// for I/O operations
#include <vector>    /// for vector

/**
 * @namespace others
 * @brief Other algorithms
 */
namespace others {

/**
 * @namespace interpolation_search
 * @brief Functions for the Recursive version of Inorder, Preorder, and
 * Postorder [Traversal of the
 * Tree](https://en.wikipedia.org/wiki/Tree_traversal) algorithm implementation
 */
namespace recursive_tree_traversals {

/**
 * @brief The structure to hold Nodes of the tree.
 * @param data Value that will be stored in the node.
 * @param left follow up left subtree.
 * @param right follow up right subtree.
 */
struct Node {
    uint64_t data = 0;     ///< The value/key of the node.
    struct Node *left{};   ///< struct pointer to left subtree.
    struct Node *right{};  ///< struct pointer to right subtree.
};
/**
 * @brief BT used to make the entire structure of the binary tree and the
 * functions associated with the binary tree
 */
class BT {
 public:
    std::vector<uint64_t>
        inorder_result;  // vector to store the inorder traversal of the tree.
    std::vector<uint64_t>
        preorder_result;  // vector to store the preorder traversal of the tree.
    std::vector<uint64_t> postorder_result;  // vector to store the preorder
                                             // traversal of the tree.

    Node *createNewNode(
        uint64_t);  // function that will create new node for insertion.

    std::vector<uint64_t> inorder(
        Node *);  // function that takes root of the tree as an argument and
                  // returns its inorder traversal.
    std::vector<uint64_t> preorder(
        Node *);  // function that takes root of the tree as an argument and
                  // returns its preorder traversal.
    std::vector<uint64_t> postorder(
        Node *);  // function that takes root of the tree as an argument and
                  // returns its postorder traversal.
};

/**
 * @brief will allocate the memory for a node and, along the data and return the
 * node.
 * @param data value that a particular node will contain.
 * @return pointer to the newly created node with assigned data.
 */
Node *BT::createNewNode(uint64_t data) {
    Node *node = new Node();
    node->data = data;
    node->left = node->right = nullptr;
    return node;
}

/*
 * @brief inorder() function that will perform the inorder traversal
 * recursively, and return the resultant vector that contain the inorder
 * traversal of a tree.
 * @param root head/root node of a tree
 * @return result that is containing the inorder traversal of a tree
 **/
std::vector<uint64_t> BT::inorder(Node *root) {
    if (root == nullptr) {  // return if the current node is empty
        return {};
    }

    inorder(root->left);  // Traverse the left subtree
    BT::inorder_result.push_back(
        root->data);  // Display the data part of the root (or current node)
    inorder(root->right);  // Traverse the right subtree

    return inorder_result;
}

/**
 * @brief preorder function that will perform the preorder traversal
 * recursively, and return the resultant vector that contain the preorder
 * traversal of a tree.
 * @param root head/root node of a tree
 * @return result that is containing the preorder traversal of a tree
 */
std::vector<uint64_t> BT::preorder(Node *root) {
    if (root == nullptr) {  // if the current node is empty
        return {};
    }

    BT::preorder_result.push_back(
        root->data);  // Display the data part of the root (or current node)
    preorder(root->left);   // Traverse the left subtree
    preorder(root->right);  // Traverse the right subtree

    return preorder_result;
}

/**
 * @brief postorder function that will perform the postorder traversal
 * recursively, and return the result vector that contain the postorder
 * traversal of a tree.
 * @param root head/root node of a tree
 * @return result that is containing the postorder traversal of a tree
 */
std::vector<uint64_t> BT::postorder(Node *root) {
    if (root == nullptr) {  // if the current node is empty
        return {};
    }

    postorder(root->left);   // Traverse the left subtree
    postorder(root->right);  // Traverse the right subtree
    BT::postorder_result.push_back(
        root->data);  // Display the data part of the root (or current node)

    return postorder_result;
}

}  // namespace recursive_tree_traversals

}  // namespace others

/**
 * @brief 1st test-case
 * @returns void
 */
void test1() {
    others::recursive_tree_traversals::BT obj1;
    others::recursive_tree_traversals::Node *root = obj1.createNewNode(2);
    root->left = obj1.createNewNode(7);
    root->right = obj1.createNewNode(5);
    root->left->left = obj1.createNewNode(2);
    root->left->right = obj1.createNewNode(6);
    root->right->right = obj1.createNewNode(9);
    root->left->right->left = obj1.createNewNode(5);
    root->left->right->right = obj1.createNewNode(11);
    root->right->right->left = obj1.createNewNode(4);

    std::vector<uint64_t> actual_result_inorder{2, 7, 5, 6, 11, 2, 5, 4, 9};
    std::vector<uint64_t> actual_result_preorder{2, 7, 2, 6, 5, 11, 5, 9, 4};
    std::vector<uint64_t> actual_result_postorder{2, 5, 11, 6, 7, 4, 9, 5, 2};
    std::vector<uint64_t> result_inorder;    ///< result stores the inorder
                                             ///< traversal of the binary tree
    std::vector<uint64_t> result_preorder;   ///< result stores the preorder
                                             ///< traversal of the binary tree
    std::vector<uint64_t> result_postorder;  ///< result stores the postorder
                                             ///< traversal of the binary tree

    uint64_t size = actual_result_inorder.size();

    // Calling inorder() function by passing a root node,
    // and storing the inorder traversal in result_inorder.
    result_inorder = obj1.inorder(root);
    std::cout << "Testcase #1: Inorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_inorder[i] == result_inorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    // Calling preorder() function by passing a root node,
    // and storing the preorder traversal in result_preorder.
    result_preorder = obj1.preorder(root);
    std::cout << "Testcase #1: Preorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_preorder[i] == result_preorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    // Calling postorder() function by passing a root node,
    // and storing the postorder traversal in result_postorder.
    result_postorder = obj1.postorder(root);
    std::cout << "Testcase #1: Postorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_postorder[i] == result_postorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    std::cout << std::endl;
}

/**
 * @brief 2nd test-case
 * @returns void
 */
void test2() {
    others::recursive_tree_traversals::BT obj2;
    others::recursive_tree_traversals::Node *root = obj2.createNewNode(1);
    root->left = obj2.createNewNode(2);
    root->right = obj2.createNewNode(3);
    root->left->left = obj2.createNewNode(4);
    root->right->left = obj2.createNewNode(5);
    root->right->right = obj2.createNewNode(6);
    root->right->left->left = obj2.createNewNode(7);
    root->right->left->right = obj2.createNewNode(8);

    std::vector<uint64_t> actual_result_inorder{4, 2, 1, 7, 5, 8, 3, 6};
    std::vector<uint64_t> actual_result_preorder{1, 2, 4, 3, 5, 7, 8, 6};
    std::vector<uint64_t> actual_result_postorder{4, 2, 7, 8, 5, 6, 3, 1};
    std::vector<uint64_t> result_inorder;    ///< result stores the inorder
                                             ///< traversal of the binary tree
    std::vector<uint64_t> result_preorder;   ///< result stores the preorder
                                             ///< traversal of the binary tree
    std::vector<uint64_t> result_postorder;  ///< result stores the postorder
                                             ///< traversal of the binary tree

    uint64_t size = actual_result_inorder.size();

    // Calling inorder() function by passing a root node,
    // and storing the inorder traversal in result_inorder.
    result_inorder = obj2.inorder(root);
    std::cout << "Testcase #2: Inorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_inorder[i] == result_inorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    // Calling preorder() function by passing a root node,
    // and storing the preorder traversal in result_preorder.
    result_preorder = obj2.preorder(root);
    std::cout << "Testcase #2: Preorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_preorder[i] == result_preorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    // Calling postorder() function by passing a root node,
    // and storing the postorder traversal in result_postorder.
    result_postorder = obj2.postorder(root);
    std::cout << "Testcase #2: Postorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_postorder[i] == result_postorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    std::cout << std::endl;
}

/**
 * @brief 3rd test-case
 * @returns void
 */
void test3() {
    others::recursive_tree_traversals::BT obj3;
    others::recursive_tree_traversals::Node *root = obj3.createNewNode(1);
    root->left = obj3.createNewNode(2);
    root->right = obj3.createNewNode(3);
    root->left->left = obj3.createNewNode(4);
    root->left->right = obj3.createNewNode(5);

    std::vector<uint64_t> actual_result_inorder{4, 2, 5, 1, 3};
    std::vector<uint64_t> actual_result_preorder{1, 2, 4, 5, 3};
    std::vector<uint64_t> actual_result_postorder{4, 5, 2, 3, 1};
    std::vector<uint64_t> result_inorder;    ///< result stores the inorder
                                             ///< traversal of the binary tree
    std::vector<uint64_t> result_preorder;   ///< result stores the preorder
                                             ///< traversal of the binary tree
    std::vector<uint64_t> result_postorder;  ///< result stores the postorder
                                             ///< traversal of the binary tree

    uint64_t size = actual_result_inorder.size();

    // Calling inorder() function by passing a root node,
    // and storing the inorder traversal in result_inorder.

    result_inorder = obj3.inorder(root);
    std::cout << "Testcase #3: Inorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_inorder[i] == result_inorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    // Calling preorder() function by passing a root node,
    // and storing the preorder traversal in result_preorder.
    result_preorder = obj3.preorder(root);
    std::cout << "Testcase #3: Preorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_preorder[i] == result_preorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    // Calling postorder() function by passing a root node,
    // and storing the postorder traversal in result_postorder.
    result_postorder = obj3.postorder(root);
    std::cout << "Testcase #3: Postorder Traversal...";
    for (auto i = 0; i < size; ++i) {
        assert(actual_result_postorder[i] == result_postorder[i]);
    }
    std::cout << "Passed!" << std::endl;

    std::cout << std::endl;
}

/**
 * @brief Self-test implementations
 * @returns void
 */
static void tests() {
    std::cout << "1st test-case" << std::endl;
    test1();  // run 1st test-case
    std::cout << "2nd test-case" << std::endl;
    test2();  // run 2nd test-case
    std::cout << "3rd test-case" << std::endl;
    test3();  // run 3rd test-case
}
/**
 * @brief Main function
 * @returns 0 on exit
 */
int main() {
    tests();  // run self-test implementations
    return 0;
}