#pragma once
#include <cstddef>
#include <optional>
#include <stdexcept>
#include <vector>

template<typename T> class Tree;

template<typename T> class Tree {
    protected:
    std::optional<T> Value;
    std::vector<Tree<T>> Children;

    public:
    bool has_value() const noexcept {
        return Value.has_value();
    }

    bool has_children() const noexcept {
        return !Children.empty();
    }

    size_t size() const noexcept {
        return Children.size();
    }

    size_t recursive_size() const {
        size_t size_sum = 0;
        for(const Tree<T>& Child : Children)
            size_sum += Child.recursive_size();
        size_sum += size();
        return size_sum + 1;
    }

    Tree<T>& append(Tree<T> item) {
        Children.push_back(std::move(item));
        return *this;
    }

    Tree<T>& erase(size_t position) {
        if(position >= Children.size())
        Children.erase();
    }

    Tree<T>& insert(size_t position, Tree<T> item) {
        if(position > Children.size()) throw std::out_of_range("Attempted inserting tree child out of range!");
        Children.insert(Children.begin() + position, std::move(item));
        return *this;
    }

    Tree<T>& at(size_t index) {
        return Children.at(index);
    }

    const Tree<T>& at(size_t index) const {
        return Children.at(index);
    }

    // Will throw std::bad_optional_access if Value doesn't exist
    operator T&() { return Value.value(); }
    operator const T&() const { return Value.value(); }

    operator std::optional<T>&() { return Value; }
    operator const std::optional<T>&() const { return Value; }

    Tree<T>& operator[](size_t index) { return Children[index]; }
    const Tree<T>& operator[](size_t index) const { return Children[index]; }

    Tree<T>& operator+=(Tree<T> item) { append(std::move(item)); return *this; }

    Tree<T>& operator=(T value) {
        Value = std::move(value);
        return *this;
    }

    Tree<T>& operator=(const Tree&) = default;
    Tree<T>& operator=(Tree&&) = default;

    Tree(const Tree<T>& other) : Value(other.Value), Children(other.Children) {}
    Tree(Tree<T>&& other) : Value(std::move(other.Value)), Children(std::move(other.Children)) {}

    Tree() { }
    Tree(T Value) : Value(std::move(Value)) { }
    Tree(std::vector<Tree<T>> Children) : Children(std::move(Children)) { }
    Tree(T Value, std::vector<Tree<T>> Children) : Value(std::move(Value)), Children(std::move(Children)) { }
};