#ifndef FOSSIL_TOFU_TREE_H
#define FOSSIL_TOFU_TREE_H

#include "tofu.h"

#ifdef __cplusplus
extern "C"
{
#endif

// *****************************************************************************
// Type Definitions
// *****************************************************************************

typedef struct fossil_tofu_tree_node_t {
    fossil_tofu_t *value;
    struct fossil_tofu_tree_node_t *left;
    struct fossil_tofu_tree_node_t *right;
} fossil_tofu_tree_node_t;

typedef struct {
    fossil_tofu_tree_node_t *root;
    char *type;
    size_t size;
} fossil_tofu_tree_t;

/**
 * -----------------------------------------------------------------------------
 * Tree Management Functions
 * -----------------------------------------------------------------------------
 */

/**
 * @brief Creates a new tree structure.
 * 
 * @param type The type of values the tree will hold.
 * 
 * @return Pointer to the newly created fossil_tofu_tree_t structure.
 */
fossil_tofu_tree_t* fossil_tofu_tree_create(char *type);

/**
 * @brief Destroys the specified tree and releases its resources.
 * 
 * @param tree Pointer to the tree to be destroyed.
 */
void fossil_tofu_tree_destroy(fossil_tofu_tree_t *tree);

/**
 * -----------------------------------------------------------------------------
 * Node Operations
 * -----------------------------------------------------------------------------
 */

/**
 * @brief Creates a new tree node with the given value.
 * 
 * @param value Pointer to the value to store in the node.
 * @return Pointer to the newly created fossil_tofu_tree_node_t structure.
 */
fossil_tofu_tree_node_t* fossil_tofu_tree_create_node(fossil_tofu_t *value);

/**
 * @brief Inserts a value into the tree.
 * 
 * @param tree Pointer to the tree where the value will be inserted.
 * @param value Pointer to the value to insert.
 * @return 0 on success, non-zero on failure.
 */
int fossil_tofu_tree_insert(fossil_tofu_tree_t *tree, fossil_tofu_t *value);

/**
 * @brief Searches for a node with the specified value in the tree.
 * 
 * @param tree Pointer to the tree to search.
 * @param value Pointer to the value to search for.
 * @return Pointer to the found node, or NULL if not found.
 */
fossil_tofu_tree_node_t* fossil_tofu_tree_search(fossil_tofu_tree_t *tree, const fossil_tofu_t *value);

/**
 * -----------------------------------------------------------------------------
 * Traversal Functions
 * -----------------------------------------------------------------------------
 */

/**
 * @brief Function pointer type for visiting tree nodes during traversal.
 * 
 * @param value Pointer to the value in the node being visited.
 */
typedef void (*fossil_tofu_tree_visit_fn)(fossil_tofu_t *value);

/**
 * @brief Traverses the tree using the specified visit function.
 * 
 * @param tree Pointer to the tree to traverse.
 * @param visit Function to call for each node's value.
 */
void fossil_tofu_tree_traverse(fossil_tofu_tree_t *tree, fossil_tofu_tree_visit_fn visit);

/**
 * @brief Performs an inorder traversal of the tree nodes.
 * 
 * @param node Pointer to the current node.
 * @param visit Function to call for each node's value.
 */
void fossil_tofu_tree_traverse_inorder(fossil_tofu_tree_node_t *node, fossil_tofu_tree_visit_fn visit);

/**
 * @brief Performs a preorder traversal of the tree nodes.
 * 
 * @param node Pointer to the current node.
 * @param visit Function to call for each node's value.
 */
void fossil_tofu_tree_traverse_preorder(fossil_tofu_tree_node_t *node, fossil_tofu_tree_visit_fn visit);

/**
 * @brief Performs a postorder traversal of the tree nodes.
 * 
 * @param node Pointer to the current node.
 * @param visit Function to call for each node's value.
 */
void fossil_tofu_tree_traverse_postorder(fossil_tofu_tree_node_t *node, fossil_tofu_tree_visit_fn visit);

#ifdef __cplusplus
}
#include <stdexcept>
#include <string>

namespace fossil {

    namespace tofu {

        /**
         * @class Tree
         * @brief A C++ wrapper class for managing a binary tree using the Fossil Logic library and Tofu objects.
         */
        class Tree {
        public:
            /**
             * @brief Constructs a new Tree object.
             * @throws std::runtime_error If the tree cannot be created.
             */
            explicit Tree(const std::string& type) {
                tree_ = fossil_tofu_tree_create(const_cast<char*>(type.c_str()));
                if (!tree_) {
                    throw std::runtime_error("Failed to create tree.");
                }
            }

            /**
             * @brief Destroys the Tree object and releases its resources.
             */
            ~Tree() {
                fossil_tofu_tree_destroy(tree_);
            }

            /**
             * @brief Inserts a new Tofu value into the tree.
             * @param value The Tofu object to insert.
             * @throws std::runtime_error If the insertion fails.
             */
            void insert(const Tofu& value) {
                fossil_tofu_t tofu_copy = value.get_c_struct();
                if (fossil_tofu_tree_insert(tree_, &tofu_copy) != 0) {
                    throw std::runtime_error("Failed to insert value into tree.");
                }
            }

            /**
             * @brief Searches for a node with the specified Tofu value in the tree.
             * @param value The Tofu object to search for.
             * @return Pointer to the found node, or nullptr if not found.
             */
            fossil_tofu_tree_node_t* search(const Tofu& value) const {
                return fossil_tofu_tree_search(tree_, &value.get_c_struct());
            }

            /**
             * @brief Gets the number of nodes in the tree.
             * @return The number of nodes in the tree.
             */
            size_t size() const {
                return tree_->size;
            }

            /**
             * @brief Checks if the tree is empty.
             * @return True if the tree is empty, false otherwise.
             */
            bool is_empty() const {
                return tree_->size == 0;
            }

            /**
             * @brief Traverses the tree using the specified visit function.
             * @param visit Function to call for each node's value.
             */
            void traverse(fossil_tofu_tree_visit_fn visit) {
                fossil_tofu_tree_traverse(tree_, visit);
            }

            /**
             * @brief Performs an inorder traversal of the tree nodes.
             * @param visit Function to call for each node's value.
             */
            void traverse_inorder(fossil_tofu_tree_visit_fn visit) {
                fossil_tofu_tree_traverse_inorder(tree_->root, visit);
            }

            /**
             * @brief Performs a preorder traversal of the tree nodes.
             * @param visit Function to call for each node's value.
             */
            void traverse_preorder(fossil_tofu_tree_visit_fn visit) {
                fossil_tofu_tree_traverse_preorder(tree_->root, visit);
            }

            /**
             * @brief Performs a postorder traversal of the tree nodes.
             * @param visit Function to call for each node's value.
             */
            void traverse_postorder(fossil_tofu_tree_visit_fn visit) {
                fossil_tofu_tree_traverse_postorder(tree_->root, visit);
            }

        private:
            fossil_tofu_tree_t* tree_; /**< Pointer to the underlying C tree structure. */
        };

    } // namespace tofu

} // namespace fossil

#endif

#endif /* FOSSIL_TOFU_FRAMEWORK_H */

#include "fossil/tofu/tree.h"

// Example visitor function
void print_node(fossil_tofu_t *value) {
    printf("Node value: %s\n", fossil_tofu_to_string(value));
}

int main(void) {
    // Create tree for storing string values
    fossil_tofu_tree_t *tree = fossil_tofu_tree_create("cstr");
    if (!tree) {
        fprintf(stderr, "Failed to create tree.\n");
        return 1;
    }

    // Create and insert some nodes
    fossil_tofu_t value1 = fossil_tofu_create_string("apple");
    fossil_tofu_t value2 = fossil_tofu_create_string("banana");
    fossil_tofu_t value3 = fossil_tofu_create_string("cherry");

    fossil_tofu_tree_insert(tree, &value1);
    fossil_tofu_tree_insert(tree, &value2);
    fossil_tofu_tree_insert(tree, &value3);

    // Traverse tree in-order
    printf("Inorder traversal:\n");
    fossil_tofu_tree_traverse_inorder(tree->root, print_node);

    // Search for a node
    fossil_tofu_tree_node_t *found = fossil_tofu_tree_search(tree, &value2);
    if (found) {
        printf("Found node with value: %s\n", fossil_tofu_to_string(found->value));
    }

    // Cleanup
    fossil_tofu_tree_destroy(tree);
    return 0;
}

#include <iostream>
#include "fossil/tofu/tree.h"

using namespace fossil::tofu;

// Example visitor function
void print_node(fossil_tofu_t *value) {
    std::cout << "Node value: " << fossil_tofu_to_string(value) << "\n";
}

int main() {
    try {
        // Create tree for storing string values
        Tree tree("cstr");

        // Insert nodes
        Tofu value1 = Tofu::from_string("apple");
        Tofu value2 = Tofu::from_string("banana");
        Tofu value3 = Tofu::from_string("cherry");

        tree.insert(value1);
        tree.insert(value2);
        tree.insert(value3);

        // Traverse tree
        std::cout << "Inorder traversal:" << std::endl;
        tree.traverse_inorder(print_node);

        // Search for a node
        auto found = tree.search(value2);
        if (found) {
            std::cout << "Found node with value: " 
                      << fossil_tofu_to_string(found->value) << std::endl;
        }

        std::cout << "Tree size: " << tree.size() << std::endl;

    } catch (const std::runtime_error& e) {
        std::cerr << "Tree error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}