BaseTypes.h

/*
 * Copyright (C) 2025, Robert Patterson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <memory>
#include <unordered_map>
#include <cassert>
#include <iostream>
#include <optional>
#include <type_traits>
 
#include "nlohmann/json.hpp"
 
#define MNX_REQUIRED_PROPERTY(TYPE, NAME) \
    [[nodiscard]] TYPE NAME() const { \
        if (!ref().contains(#NAME)) { \
            throw std::runtime_error("Missing required property: " #NAME); \
        } \
        return ref()[#NAME].get<TYPE>(); \
    } \
    void set_##NAME(const TYPE& value) { ref()[#NAME] = value; } \
    static_assert(true, "") // require semicolon after macro
 
 #define MNX_ARRAY_ELEMENT_PROPERTY(TYPE, NAME, INDEX) \
    static_assert(std::is_integral_v<decltype(INDEX)>, "array index must be an integer type"); \
    [[nodiscard]] TYPE NAME() const { return (*this)[INDEX]; } \
    void set_##NAME(const TYPE& value) { (*this)[INDEX] = value; } \
    static_assert(true, "") // require semicolon after macro
 
 #define MNX_OPTIONAL_NAMED_PROPERTY(TYPE, NAME, KEY) \
    [[nodiscard]] std::optional<TYPE> NAME() const { \
        return ref().contains(KEY) ? std::optional<TYPE>(ref()[KEY].get<TYPE>()) : std::nullopt; \
    } \
    [[nodiscard]] TYPE NAME##_or(const TYPE& defaultVal) const { \
        return ref().contains(KEY) ? ref()[KEY].get<TYPE>() : defaultVal; \
    } \
    void set_##NAME(const TYPE& value) { ref()[KEY] = value; } \
    void clear_##NAME() { ref().erase(KEY); } \
    static_assert(true, "") // require semicolon after macro
 
 #define MNX_OPTIONAL_PROPERTY(TYPE, NAME) MNX_OPTIONAL_NAMED_PROPERTY(TYPE, NAME, #NAME)
 
#define MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(TYPE, NAME, DEFAULT) \
    [[nodiscard]] TYPE NAME() const { \
        return ref().contains(#NAME) ? ref()[#NAME].get<TYPE>() : DEFAULT; \
    } \
    void set_##NAME(const TYPE& value) { ref()[#NAME] = value; } \
    void clear_##NAME() { ref().erase(#NAME); } \
    void set_or_clear_##NAME(const TYPE& value) { \
        if (value == DEFAULT) clear_##NAME(); \
        else set_##NAME(value); \
    } \
    static_assert(true, "") // require semicolon after macro
 
 #define MNX_REQUIRED_CHILD(TYPE, NAME) \
    [[nodiscard]] TYPE NAME() const { return getChild<TYPE>(#NAME); } \
    template<typename... Args> \
    TYPE create_##NAME(Args&&... args) { \
        return setChild(#NAME, TYPE(*this, #NAME, std::forward<Args>(args)...)); \
    } \
    static_assert(true, "") // require semicolon after macro
 
 #define MNX_OPTIONAL_CHILD(TYPE, NAME) \
    [[nodiscard]] std::optional<TYPE> NAME() const { return getOptionalChild<TYPE>(#NAME); } \
    template<typename... Args> \
    TYPE create_##NAME(Args&&... args) { \
        if (auto child = getOptionalChild<TYPE>(#NAME)) return child.value(); \
        return setChild(#NAME, TYPE(*this, #NAME, std::forward<Args>(args)...)); \
    } \
    void clear_##NAME() { ref().erase(#NAME); } \
    static_assert(true, "") // require semicolon after macro
 
#define MNX_ASSERT_IF(TEST) \
assert(!(TEST)); \
if (TEST)
    
namespace mnx {
 
inline constexpr int MNX_VERSION = 1;
 
using json = nlohmann::ordered_json;        
using json_pointer = json::json_pointer;    
 
class Object;
class Document;
template <typename T> class Array;
 
namespace validation {
class SemanticValidator;
}; // namespace validation
 
class Base
{
public:
    virtual ~Base() = default;
 
    Base(const Base& src) : m_root(src.m_root), m_pointer(src.m_pointer)
    {}
 
    Base(Base&& src) noexcept : m_root(src.m_root),    // m_root must be copied (not moved)
        m_pointer(std::move(src.m_pointer))
    {}
 
    Base& operator=(const Base& src)
    {
        if (this != &src) {
            if (m_root != src.m_root) {
                throw std::logic_error("Assignment from a different JSON document is not allowed.");
            }
            m_pointer = src.m_pointer;
        }
        return *this;
    }
 
    Base& operator=(Base&& src)
    {
        if (this != &src) {
            if (m_root != src.m_root) {
                throw std::logic_error("Assignment from a different JSON document is not allowed.");
            }
            m_pointer = std::move(src.m_pointer);
        }
        return *this;
    }
 
    [[nodiscard]] std::string dump(int indents = -1) const
    {
        return ref().dump(indents);
    }
 
    template <typename T>
    [[nodiscard]] T parent() const
    {
        static_assert(std::is_base_of_v<Base, T>, "Template type mush be derived from Base.");
        return T(m_root, m_pointer.parent_pointer());
    }
 
    template <typename T>
    [[nodiscard]] std::optional<T> getEnclosingElement() const;
 
    [[nodiscard]] json_pointer pointer() const { return m_pointer; }
 
    [[nodiscard]] Document document() const;
 
protected:
    [[nodiscard]] json& ref() const { return resolve_pointer(); }
 
    [[nodiscard]] json& ref() { return resolve_pointer(); }
 
    [[nodiscard]] const std::shared_ptr<json>& root() const { return m_root; }
 
    Base(const std::shared_ptr<json>& root, json_pointer pointer)
        : m_root(root), m_pointer(std::move(pointer)) {}
 
    Base(json&& jsonRef, Base& parent, std::string_view key)
        : m_root(parent.m_root), m_pointer(parent.m_pointer / std::string(key))
    {
        (*m_root)[m_pointer] = std::move(jsonRef);
    }
 
    template <typename T>
    [[nodiscard]] T getChild(std::string_view key) const
    {
        static_assert(std::is_base_of_v<Base, T>, "template type must be derived from Base");
 
        json_pointer childPointer = m_pointer / std::string(key);
        if (!checkKeyIsValid<T>(childPointer)) {
            throw std::runtime_error("Missing required child node: " + std::string(key));
        }
 
        return T(m_root, childPointer);
    }
 
    template <typename T>
    T setChild(std::string_view key, const T& value)
    {
        static_assert(std::is_base_of_v<Base, T>, "template type must be derived from Base");
 
        json_pointer childPointer = m_pointer / std::string(key);
        (*m_root)[childPointer] = value.ref();
        return T(m_root, childPointer);
    }
 
    template <typename T>
    [[nodiscard]] std::optional<T> getOptionalChild(std::string_view key) const
    {
        static_assert(std::is_base_of_v<Base, T>, "template type must be derived from Base");
 
        json_pointer childPointer = m_pointer / std::string(key);
        if (!checkKeyIsValid<T>(childPointer)) {
            return std::nullopt;
        }
 
        return T(m_root, childPointer);
    }
 
private:
    template <typename T>
    [[nodiscard]] bool checkKeyIsValid(const json_pointer& pointer) const
    {
        if (!(*m_root).contains(pointer)) {
            return false;
        }
 
        const json& node = (*m_root).at(pointer);
 
        if constexpr (std::is_base_of_v<Object, T>) {
            if (!node.is_object()) {
                throw std::runtime_error("Expected an object for: " + pointer.to_string());
            }
        } else if constexpr (std::is_base_of_v<Array<typename T::value_type>, T>) {
            if (!node.is_array()) {
                throw std::runtime_error("Expected an array for: " + pointer.to_string());
            }
        }
 
        return true;
    }
 
    [[nodiscard]] json& resolve_pointer() const
    {
        return (*m_root).at(m_pointer);  // Throws if invalid
    }
 
    const std::shared_ptr<json> m_root;  
    json_pointer m_pointer;          
 
    friend class validation::SemanticValidator;
};
 
using ErrorHandler = std::function<void(const std::string& message, const Base& location)>;
 
class Object : public Base
{
public:
    Object(const std::shared_ptr<json>& root, json_pointer pointer) : Base(root, pointer)
    {
        if (!ref().is_object()) {
            throw std::invalid_argument("mnx::Object must wrap a JSON object.");
        }
    }
 
    Object(Base& parent, std::string_view key)
        : Base(json::object(), parent, key) {}
 
    MNX_OPTIONAL_PROPERTY(std::string, _c);     
    MNX_OPTIONAL_CHILD(Object, _x);             
    MNX_OPTIONAL_PROPERTY(std::string, id);     
};
 
template <typename T, std::enable_if_t<!std::is_base_of_v<Base, T>, int> = 0>
class SimpleType : public Base
{
    static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string>, "This template is for simple JSON classes");
 
public:
    using value_type = T; 
 
    SimpleType(const std::shared_ptr<json>& root, json_pointer pointer) : Base(root, pointer)
    {
    }
 
    operator T() const
    {
        return ref().template get<T>();
    }
 
    SimpleType& operator=(const T& src)
    {
        ref() = src;
        return *this;
    }
 
    bool operator==(const T& src) const
    {
        return src == ref().template get<T>();
    }
};
 
class ArrayElementObject;
template <typename T>
class Array : public Base
{
    static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string> ||
                  std::is_base_of_v<ArrayElementObject, T>, "Invalid MNX array element type.");
 
private:    
    template<typename ArrayType>
    struct iter
    {
    private:
        ArrayType* m_ptr;
        mutable size_t m_idx;
 
    public:
        iter(ArrayType* ptr, size_t idx) : m_ptr(ptr), m_idx(idx) {}
        T operator*() const { return (*m_ptr)[m_idx]; }
        iter& operator++() { ++m_idx; return *this; }
        bool operator!=(const iter& o) const { return m_idx != o.m_idx; }
    };
 
public:
    using value_type = T;
 
    using iterator = iter<Array>;               
    using const_iterator = iter<const Array>;   
 
    Array(const std::shared_ptr<json>& root, json_pointer pointer) : Base(root, pointer)
    {
        if (!ref().is_array()) {
            throw std::invalid_argument("mnx::Array must wrap a JSON array.");
        }
    }
 
    Array(Base& parent, std::string_view key)
        : Base(json::array(), parent, key) {}
 
    [[nodiscard]] size_t size() const { return ref().size(); }
 
    [[nodiscard]] bool empty() const { return ref().empty(); }
 
    void clear() { ref().clear(); }
 
    [[nodiscard]] T at(size_t index) const
    {
        return operator[](index);
    }
    
    [[nodiscard]] auto operator[](size_t index) const
    {
        checkIndex(index);
        if constexpr (std::is_base_of_v<Base, T>) {
            return getChild<T>(std::to_string(index));
        } else {
            return getChild<SimpleType<T>>(std::to_string(index));
        }
    }
 
    [[nodiscard]] auto operator[](size_t index)
    {
        checkIndex(index);
        if constexpr (std::is_base_of_v<Base, T>) {
            return getChild<T>(std::to_string(index));
        } else {
            return getChild<SimpleType<T>>(std::to_string(index));
        }
    }
 
    template <typename U = T>
    std::enable_if_t<!std::is_base_of_v<Base, U>, void>
    push_back(const U& value)
    {
        ref().push_back(value);
    }
 
    template <typename U = T, typename... Args,
              std::enable_if_t<std::is_base_of_v<Base, U>, int> = 0>
    U append(Args&&... args)
    {
        if constexpr (std::is_base_of_v<Object, U>) {
            ref().push_back(json::object());
        } else {
            ref().push_back(json::array());
        }
        return U(*this, std::to_string(ref().size() - 1), std::forward<Args>(args)...);
    }
 
    void erase(size_t index)
    {
        checkIndex(index);
        ref().erase(ref().begin() + index);
    }
 
    [[nodiscard]] auto begin() { return iterator(this, 0); }
 
    [[nodiscard]] auto end() { return iterator(this, size()); }
 
    [[nodiscard]] auto begin() const { return const_iterator(this, 0); }
 
    [[nodiscard]] auto end() const { return const_iterator(this, size()); }
 
protected:
    void checkIndex(size_t index) const
    {
        assert(index < ref().size());
        if (index >= ref().size()) {
            throw std::out_of_range("Index out of range");
        }
    }
};
 
class ArrayElementObject : public Object
{
public:
    using Object::Object;
 
    size_t calcArrayIndex() const
    {
        return std::stoul(pointer().back());
    }
 
    template <typename ContainerType>
    ContainerType container() const
    {
        return parent<Array<ArrayElementObject>>().parent<ContainerType>();
    }
};
 
class ContentArray;
class ContentObject : public ArrayElementObject
{
protected:
    static constexpr std::string_view ContentTypeValueDefault = "event"; 
 
public:
    using ArrayElementObject::ArrayElementObject;
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(std::string, type, std::string(ContentTypeValueDefault));   
 
    template <typename T, std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    [[nodiscard]] T get() const
    {
        return getTypedObject<T>();
    }
 
private:
    template <typename T, std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    [[nodiscard]] T getTypedObject() const
    {
        if (type() != T::ContentTypeValue) {
            throw std::invalid_argument("Type mismatch: expected " + std::string(T::ContentTypeValue) +
                                        ", got " + type());
        }
        return T(root(), pointer());
    }
 
    friend class ContentArray;
};
 
class ContentArray : public Array<ContentObject>
{
public:
    using BaseArray = Array<ContentObject>;     
    using BaseArray::BaseArray;  // Inherit constructors
 
    template <typename T, std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    [[nodiscard]] T get(size_t index) const
    {
        this->checkIndex(index);
        return operator[](index).get<T>();
    }
 
    template <typename T, typename... Args,
              std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    T append(Args&&... args)
    {
        auto result = BaseArray::append<T>(std::forward<Args>(args)...);
        if constexpr (T::ContentTypeValue != ContentObject::ContentTypeValueDefault) {
            result.set_type(std::string(T::ContentTypeValue));            
        }
        return result;
    }
 
private:
    template <typename T, std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    [[nodiscard]] T getTypedObject(size_t index) const
    {
        this->checkIndex(index);
        auto element = (*this)[index];
        if (element.type() != T::ContentTypeValue) {
            throw std::invalid_argument("Type mismatch: expected " + std::string(T::ContentTypeValue) +
                                        ", got " + element.type());
        }
        return T(root(), pointer() / std::to_string(index));
    }
};
 
template <typename E, typename = std::enable_if_t<std::is_enum_v<E>>>
struct EnumStringMapping
{
    static const std::unordered_map<std::string, E> stringToEnum();     
 
    static const std::unordered_map<E, std::string> enumToString()
    {
        static const std::unordered_map<E, std::string> reverseMap = []() {
            std::unordered_map<E, std::string> result;
            for (const auto& element : EnumStringMapping<E>::stringToEnum()) {
                result.emplace(element.second, element.first);
            }
            return result;
        }();
        return reverseMap;
    }
};
 
template <typename T>
class Dictionary : public Object
{
    static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string> ||
                  std::is_base_of_v<ArrayElementObject, T>, "Invalid MNX dictionary element type.");
 
private:    
    template <typename DictionaryType, typename IteratorType>
    struct iter
    {
        using value_type = std::pair<const std::string, T>;
        using difference_type = std::ptrdiff_t;
        using iterator_category = std::forward_iterator_tag;
        using pointer = value_type*;
        using reference = value_type&;
 
    private:
        DictionaryType* m_ptr;
        IteratorType m_it;
        mutable std::unique_ptr<value_type> m_pair;  // Cached key-value pair for operator*() and operator->()
 
        void update_pair() const {
            m_pair.reset();
            if (m_it != m_ptr->ref().end()) {
                m_pair = std::make_unique<value_type>(m_it.key(), m_ptr->operator[](m_it.key()));
            }
        }
    
    public:
        iter(DictionaryType* ptr, IteratorType it) : m_ptr(ptr), m_it(it)
        { update_pair(); }
 
        [[nodiscard]] reference operator*() const { return *m_pair.get(); }
        [[nodiscard]] pointer operator->() const { return m_pair.get(); }
 
        iter& operator++() { ++m_it; update_pair(); return *this; }
        iter operator++(int) { iter tmp = *this; ++(*this); return tmp; }
 
        [[nodiscard]] bool operator!=(const iter& o) const { return m_it != o.m_it; }
        [[nodiscard]] bool operator==(const iter& o) const { return m_it == o.m_it; }
    };
 
public:
    using value_type = T;
 
    using iterator = iter<Dictionary, json::iterator>;  
    using const_iterator = iter<const Dictionary, json::const_iterator>; 
 
    Dictionary(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    Dictionary(Base& parent, std::string_view key)
        : Object(parent, key) {}
 
    [[nodiscard]] size_t size() const { return ref().size(); }
 
    [[nodiscard]] bool empty() const { return ref().empty(); }
 
    void clear() { ref().clear(); }
 
    [[nodiscard]] T at(size_t index) const
    {
        return operator[](index);
    }
 
    [[nodiscard]] auto operator[](const std::string& key) const
    {
        if constexpr (std::is_base_of_v<Base, T>) {
            return getChild<T>(key);
        } else {
            return getChild<SimpleType<T>>(key);
        }
    }
 
    [[nodiscard]] auto operator[](const std::string& key)
    {
        if constexpr (std::is_base_of_v<Base, T>) {
            return getChild<T>(key);
        } else {
            return getChild<SimpleType<T>>(key);
        }
    }
 
    template <typename U = T>
    std::enable_if_t<!std::is_base_of_v<Base, U>, void>
    emplace(const std::string& key, const U& value)
    {
        ref()[key] = value;
    }
 
    template <typename U = T, typename... Args,
              std::enable_if_t<std::is_base_of_v<Base, U>, int> = 0>
    U append(const std::string& key, Args&&... args)
    {
        if constexpr (std::is_base_of_v<Object, U>) {
            ref()[key] = json::object();
        } else {
            ref()[key] = json::array();
        }
        return U(*this, key, std::forward<Args>(args)...);
    }
 
    void erase(const std::string& key)
    {
        ref().erase(key);
    }
 
    [[nodiscard]] auto find(const std::string& key)
    {
        auto it = ref().find(key);
        return (it != ref().end()) ? iterator(this, it) : end();
    }
 
    [[nodiscard]] auto find(const std::string& key) const
    {
        auto it = ref().find(key);
        return (it != ref().end()) ? const_iterator(this, it) : end();
    }
 
    [[nodiscard]] bool contains(const std::string& key) const
    { return find(key) != end(); }
 
    [[nodiscard]] auto begin() { return iterator(this, ref().begin()); }
 
    [[nodiscard]] auto end() { return iterator(this, ref().end()); }
 
    [[nodiscard]] auto begin() const { return const_iterator(this, ref().begin()); }
 
    [[nodiscard]] auto end() const { return const_iterator(this, ref().end()); }
};
 
} // namespace mnx
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
namespace nlohmann {
 
#if defined(_WIN32)
// This general adl_serializer is enabled only for enum types.
// For some reason MSC does not like the direct function definitions below.
template<typename EnumType>
struct adl_serializer<EnumType, std::enable_if_t<std::is_enum_v<EnumType>>>
{
    template<typename BasicJsonType>
    static EnumType from_json(const BasicJsonType& j)
    {
        // Lookup the string in the specialized map.
        const auto& map = ::mnx::EnumStringMapping<EnumType>::stringToEnum();
        auto it = map.find(j.get<std::string>());
        if (it != map.end()) {
            return it->second;
        }
        return EnumType{};
    }
 
    template<typename BasicJsonType>
    static void to_json(BasicJsonType& j, const EnumType& value)
    {
        const auto& map = ::mnx::EnumStringMapping<EnumType>::enumToString();
        auto it = map.find(value);
        if (it == map.end()) {
            j = BasicJsonType();
            return;
        }
        j = it->second;
    }
};
#else
// Clang works with the adl_specialization above, but GCC does not.
namespace detail {
 
template<typename BasicJsonType, typename EnumType,
         std::enable_if_t<std::is_enum<EnumType>::value, int> = 0>
inline void from_json(const BasicJsonType& j, EnumType& value)
{
    // Lookup the string in the specialized map.
    const auto& map = ::mnx::EnumStringMapping<EnumType>::stringToEnum();
    auto it = map.find(j.template get<std::string>());
    if (it != map.end()) {
        value = it->second;
    } else {
        value = EnumType{};
    }
}
 
template<typename BasicJsonType, typename EnumType,
         std::enable_if_t<std::is_enum<EnumType>::value, int> = 0>
inline void to_json(BasicJsonType& j, EnumType value) noexcept
{
    const auto& map = ::mnx::EnumStringMapping<EnumType>::enumToString();
    auto it = map.find(value);
    if (it != map.end()) {
        j = it->second;
    } else {
        j = BasicJsonType();
    }
}
 
} // namespace detail
#endif // defined(_WIN32)
 
} // namespace nlohmann
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS