Node.hpp

#pragma once
 
#include "PixelBullet/Application/Assert.hpp"
#include "PixelBullet/Filesystem/String.hpp"
 
#include <glm/glm.hpp>
 
#include <algorithm>
#include <charconv>
#include <cstdint>
#include <map>
#include <sstream>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace YAML
{
    class Node;
}
 
namespace PixelBullet
{
    enum class NodeType : uint8_t
    {
        Null,
        Object,
        Array,
        String,
        Boolean,
        Integer,
        Decimal,
        Unknown,
        Token,
        EndOfFile
    };
 
    using NodeValue = std::string;
    using NodeProperty = std::pair<std::string, class Node>;
    using NodeProperties = std::vector<NodeProperty>;
 
    class Node
    {
    public:
        struct Format
        {
            int8_t spacesPerIndent; 
            char newLine;           
            char space;             
            bool inlineArrays;      
 
            constexpr Format(int8_t s, char nl, char spc, bool inlineArr)
                : spacesPerIndent(s)
                , newLine(nl)
                , space(spc)
                , inlineArrays(inlineArr)
            {
            }
 
            std::string GetIndentation(int8_t indentLevel) const
            {
                return std::string(spacesPerIndent * indentLevel, ' ');
            }
 
            static const Format Beautified; 
            static const Format Minified;   
        };
 
        Node() = default;
        Node(const Node&) = default;
        Node(Node&&) noexcept = default;
        Node& operator=(const Node&) = default;
        Node& operator=(Node&&) noexcept = default;
        ~Node() = default;
 
        [[nodiscard]] const NodeValue& GetValue() const noexcept;
        void SetValue(const NodeValue& value);
        void SetValue(NodeValue&& value);
 
        [[nodiscard]] NodeType GetType() const noexcept;
        void SetType(NodeType type);
 
        void Clear();
 
        [[nodiscard]] bool IsValid() const noexcept;
 
        [[nodiscard]] const NodeProperties& GetProperties() const noexcept;
        NodeProperties& GetProperties();
 
        [[nodiscard]] bool HasProperty(const std::string& name) const;
        [[nodiscard]] const Node* GetProperty(const std::string& name) const;
        void SetProperty(const std::string& name, const Node& node);
        bool RemoveProperty(const std::string& name);
 
        // For object-style indexing
        Node& operator[](const std::string& key);
        const Node& operator[](const std::string& key) const;
 
        // For array-style indexing
        Node& operator[](size_t index);
        const Node& operator[](size_t index) const;
 
        // Convenience functions for type conversion.
        template <typename T>
        T As() const
        {
            T out{};
            (*this) >> out;
            return out;
        }
 
        template <typename T>
        void Set(const T& in)
        {
            (*this) << in;
        }
 
        // Iterators to properties
        auto begin()
        {
            return m_Properties.begin();
        }
        auto end()
        {
            return m_Properties.end();
        }
        auto begin() const
        {
            return m_Properties.begin();
        }
        auto end() const
        {
            return m_Properties.end();
        }
 
        // Optional: returns the number of properties (useful for arrays/objects)
        [[nodiscard]] size_t size() const noexcept
        {
            return m_Properties.size();
        }
 
        friend const Node& operator>>(const Node& node, Node& out)
        {
            out = node;
            return node;
        }
 
        friend Node& operator<<(Node& node, const Node& in)
        {
            node = in;
            return node;
        }
 
        friend const Node& operator>>(const Node& node, bool& b)
        {
            if (node.m_Value == "true" || node.m_Value == "1")
            {
                b = true;
            }
            else if (node.m_Value == "false" || node.m_Value == "0")
            {
                b = false;
            }
            else
            {
                ASSERT(false, "Invalid boolean value: {}", node.m_Value);
                b = false;
            }
            return node;
        }
 
        friend Node& operator<<(Node& node, bool b)
        {
            node.m_Value = b ? "true" : "false";
            node.m_Type = NodeType::Boolean;
            return node;
        }
 
        static bool ParseYAML(Node& node, std::string_view str);
        static bool WriteYAML(const Node& node, std::ostream& stream, const Format& format = Format::Minified);
 
    private:
        static Node YAMLToNode(const YAML::Node& yaml);
        static YAML::Node NodeToYAML(const Node& node);
 
        NodeProperties m_Properties;      
        NodeValue m_Value;                
        NodeType m_Type = NodeType::Null; 
    };
 
    // --- Free Conversion Operators ---
 
    // Arithmetic conversion using C++20 requires clause.
    template <typename T>
        requires std::is_arithmetic_v<T>
    Node& operator<<(Node& node, const T& value)
    {
        char buffer[64]{};
        auto [ptr, ec] = std::to_chars(buffer, buffer + sizeof(buffer), value);
        ASSERT(ec == std::errc(), "Conversion to string failed");
        node.SetValue(std::string(buffer, ptr));
        if constexpr (std::is_integral_v<T>)
        {
            node.SetType(NodeType::Integer);
        }
        else if constexpr (std::is_floating_point_v<T>)
        {
            node.SetType(NodeType::Decimal);
        }
        return node;
    }
 
    template <typename T>
        requires std::is_arithmetic_v<T>
    void operator>>(const Node& node, T& value)
    {
        const std::string& s = node.GetValue();
        auto result = std::from_chars(s.data(), s.data() + s.size(), value);
        ASSERT(result.ec == std::errc(), "Conversion failed for value: {}", s);
    }
 
    inline Node& operator<<(Node& node, const std::string& value)
    {
        node.SetValue(value);
        node.SetType(NodeType::String);
        return node;
    }
 
    inline const Node& operator>>(const Node& node, std::string& value)
    {
        value = node.GetValue();
        return node;
    }
 
    template <typename T>
    Node& operator<<(Node& node, const std::vector<T>& vec)
    {
        node.SetType(NodeType::Array);
        auto& props = node.GetProperties();
        props.clear();
        for (const T& item : vec)
        {
            Node child;
            child << item;
            props.emplace_back("", child);
        }
        return node;
    }
 
    template <typename T>
    void operator>>(const Node& node, std::vector<T>& vec)
    {
        ASSERT(node.GetType() == NodeType::Array, "Node is not an array");
        vec.clear();
        for (const auto& [key, child] : node.GetProperties())
        {
            T item;
            child >> item;
            vec.push_back(std::move(item));
        }
    }
 
    template <typename T>
    Node& operator<<(Node& node, const std::map<std::string, T>& mapData)
    {
        node.SetType(NodeType::Object);
        auto& props = node.GetProperties();
        props.clear();
        for (const auto& [key, value] : mapData)
        {
            Node child;
            child << value;
            props.emplace_back(key, child);
        }
        return node;
    }
 
    template <typename T>
    void operator>>(const Node& node, std::map<std::string, T>& mapData)
    {
        ASSERT(node.GetType() == NodeType::Object, "Node is not an object");
        mapData.clear();
        for (const auto& [key, child] : node.GetProperties())
        {
            T item;
            child >> item;
            mapData.emplace(key, std::move(item));
        }
    }
 
    inline bool operator==(const Node& lhs, const Node& rhs)
    {
        return lhs.GetType() == rhs.GetType() && lhs.GetValue() == rhs.GetValue() &&
               lhs.GetProperties() == rhs.GetProperties();
    }
 
    inline bool operator!=(const Node& lhs, const Node& rhs)
    {
        return !(lhs == rhs);
    }
 
    inline bool operator<(const Node& lhs, const Node& rhs)
    {
        if (lhs.GetType() != rhs.GetType())
        {
            return lhs.GetType() < rhs.GetType();
        }
        if (lhs.GetValue() != rhs.GetValue())
        {
            return lhs.GetValue() < rhs.GetValue();
        }
        return lhs.GetProperties() < rhs.GetProperties();
    }
 
    // Enum conversions – now enabled only for enums.
    template <typename T>
        requires std::is_enum_v<T>
    const Node& operator>>(const Node& node, T& object)
    {
        object = String::From<T>(node.GetValue());
        return node;
    }
 
    template <typename T>
        requires std::is_enum_v<T>
    Node& operator<<(Node& node, T object)
    {
        node.SetValue(String::To(object));
        node.SetType(NodeType::Integer);
        return node;
    }
 
    inline const Node& operator>>(const Node& node, std::pair<std::string, std::string>& p)
    {
        ASSERT(node.GetType() == NodeType::Object, "Expected object type for a pair");
        const auto& props = node.GetProperties();
        ASSERT(props.size() == 1, "Expected exactly one property for a pair");
        p.first = props[0].first;
        props[0].second >> p.second;
        return node;
    }
 
    inline Node& operator<<(Node& node, const std::pair<std::string, std::string>& p)
    {
        node.SetType(NodeType::Object);
        auto& props = node.GetProperties();
        props.clear();
        Node valueNode;
        valueNode << p.second;
        props.emplace_back(p.first, valueNode);
        return node;
    }
 
    inline Node& operator<<(Node& node, const glm::vec3& v)
    {
        node.SetType(NodeType::Array);
        auto& props = node.GetProperties();
        props.clear();
 
        Node x, y, z;
        x << v.x;
        y << v.y;
        z << v.z;
        props.emplace_back("", std::move(x));
        props.emplace_back("", std::move(y));
        props.emplace_back("", std::move(z));
        return node;
    }
 
    inline void operator>>(const Node& node, glm::vec3& v)
    {
        ASSERT(node.GetType() == NodeType::Array, "Node is not an array");
        const auto& props = node.GetProperties();
        ASSERT(props.size() >= 3, "Insufficient elements for glm::vec3");
        props[0].second >> v.x;
        props[1].second >> v.y;
        props[2].second >> v.z;
    }
} // namespace PixelBullet