FactoryBase.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 <stdexcept>
#include <string>
#include <string_view>
#include <optional>
#include <functional>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <tuple>
#include <sstream>
#include <type_traits>
#include <charconv>
 
#include "musx/util/Logger.h"
#include "musx/xml/XmlInterface.h"
#include "musx/dom/BaseClasses.h"
#include "musx/dom/Document.h"
 
namespace musx {
 
namespace factory {
 
using namespace musx::xml;
using namespace musx::dom;
 
 
class unknown_xml_error : public std::runtime_error
{
public:
    using std::runtime_error::runtime_error;
};
 
 
class ElementLinker {
public:
    using Resolver = std::function<void(const dom::DocumentPtr&)>;
 
    void addResolver(Resolver resolver, const std::string_view& key)
    {
        assert(!key.empty());
        if (resolvers.count(std::string(key)) > 0) {
            return; // Skip if already registered
        }
 
        resolvers[std::string(key)] = std::move(resolver);
    }
 
    void resolveAll(const dom::DocumentPtr& document)
    {
        for (const auto& [key, resolver] : resolvers) {
            resolver(document);
        }
 
        resolvers.clear(); 
    }
 
private:
    std::map<std::string, Resolver> resolvers;
};
 
 
class FactoryBase
{
protected:
    template<typename DataType, typename ParserFunc>
    static void getFieldFromXml(const XmlElementPtr& element, const std::string& nodeName, DataType& dataField, ParserFunc parserFunc, bool expected = false)
    {
        if (auto childElement = element->getFirstChildElement(nodeName)) {
            dataField = parserFunc(childElement);
        } else if (expected) {
            std::stringstream msg;
            msg << "Expected field <" << element->getTagName() << "><" << nodeName << "> not found.";
            util::Logger::log(util::Logger::LogLevel::Warning, msg.str());
        }
    }
 
    static XmlElementPtr getFirstChildElement(const XmlElementPtr& element, const std::string& childElementName)
    {
        auto childElement = element->getFirstChildElement(childElementName);
        if (!childElement) {
            throw std::invalid_argument("Missing <" + childElementName + "> element.");
        }
        return childElement;
    }
 
    static std::optional<std::string> getOptionalChildText(const XmlElementPtr& element, const std::string& childElementName)
    {
        auto childElement = element->getFirstChildElement(childElementName);
        if (!childElement) {
            return std::nullopt;
        }
        return childElement->getText();
    }
 
    template<typename T>
    static std::optional<T> getOptionalChildTextAs(const XmlElementPtr& element, const std::string& childElementName, T defaultValue = {})
    {
        auto childElement = element->getFirstChildElement(childElementName);
        if (!childElement) {
            return std::nullopt;
        }
        return childElement->getTextAs<T>(defaultValue);
    }
 
public:
    virtual ~FactoryBase() {}
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
template <typename EnumClass, typename FromClass = std::string_view>
using XmlEnumMappingElement = std::unordered_map<FromClass, EnumClass>;
template <typename EnumClass, typename FromClass = std::string_view>
struct XmlEnumMapping
{
    static const XmlEnumMappingElement<EnumClass, FromClass> mapping;
};
 
#define MUSX_XML_ENUM_MAPPING(Type, ...) \
template <> \
const XmlEnumMappingElement<Type> XmlEnumMapping<Type>::mapping = __VA_ARGS__
 
template <typename EnumClass, bool IgnoreUnknown, typename FromClass = std::string_view>
class EnumMapper
{
    // If we ever need to, we can create a static lazy-initialize reverse mapping function here
 
public:
    static EnumClass xmlToEnum(const FromClass& value)
    {
        auto it = XmlEnumMapping<EnumClass>::mapping.find(value);
        if (it != XmlEnumMapping<EnumClass>::mapping.end()) {
            return it->second;
        }
        if constexpr (!IgnoreUnknown) {
            std::string msg = [value]() {
                if constexpr (std::is_arithmetic_v<FromClass>) {
                    return "Invalid enum value from xml: " + std::to_string(value);
                }
                else {
                    return "Invalid enum value from xml: " + std::string(value);
                }
            }();
            MUSX_UNKNOWN_XML(msg);
        }
        return {};
    }
};
 
template<typename EnumClass, typename FromClass, bool IgnoreUnknown = false>
EnumClass toEnum(const FromClass& value)
{
    if constexpr (std::is_convertible_v<FromClass, std::string_view>) {
        return EnumMapper<EnumClass, IgnoreUnknown, std::string_view>::xmlToEnum(value);
    } else {
        return EnumMapper<EnumClass, IgnoreUnknown, FromClass>::xmlToEnum(value);
    }
}
 
template<typename EnumClass, bool IgnoreUnknown = false>
EnumClass toEnum(const ::musx::xml::XmlElementPtr& e)
{
    return toEnum<EnumClass, std::string_view, IgnoreUnknown>(e->getTextTrimmed());
}
 
#define MUSX_XML_ELEMENT_ARRAY(Type, ...) \
const ::musx::xml::XmlElementArray<Type>& Type::xmlMappingArray() { \
    static const ::musx::xml::XmlElementArray<Type> instance = __VA_ARGS__; \
    return instance; \
} \
static_assert(true, "") // require semicolon after macro
 
using ResolverEntry = std::optional<ElementLinker::Resolver>;
template <typename T>
struct ResolverContainer
{
    inline static const ResolverEntry resolver = {};
};
 
#define MUSX_RESOLVER_ENTRY(Type, ...) \
template <> \
struct ResolverContainer<Type> { \
    inline static const ResolverEntry resolver = ElementLinker::Resolver(__VA_ARGS__); \
};
 
template <typename T>
struct FieldPopulator : public FactoryBase
{
    static void populateField(const std::shared_ptr<T>& instance, const XmlElementPtr& fieldElement)
    {
        auto it = elementXref().find(fieldElement->getTagName());
        if (it != elementXref().end()) {
            std::get<1>(*it)(fieldElement, instance);
        } else {
            const bool requireFields = [instance]() {
                if constexpr (std::is_base_of_v<Base, T>) {
                    return instance->requireAllFields();
                } else {
                    return true;
                }
            }();
            if (requireFields) {
                MUSX_UNKNOWN_XML("xml element <" + fieldElement->getParent()->getTagName() + "> has child <" + fieldElement->getTagName() + "> which is not in the element list.");
            }
        }    
    }
 
    static void populate(const std::shared_ptr<T>& instance, const XmlElementPtr& element)
    {
        if constexpr (std::is_base_of_v<TextsBase, T>) {
            instance->text = element->getText();
        } else {
            for (auto child = element->getFirstChildElement(); child; child = child->getNextSibling()) {
                populateField(instance, child);
            }
        }
        if constexpr (std::is_base_of_v<Base, T>) {
            instance->integrityCheck(instance);
        }
    }
 
    template <typename SubClass = T>
    static void populate(const std::shared_ptr<T>& instance, const XmlElementPtr& element, ElementLinker& elementLinker)
    {
        populate(instance, element);
        if (ResolverContainer<SubClass>::resolver.has_value()) {
            elementLinker.addResolver(ResolverContainer<SubClass>::resolver.value(), element->getTagName());
        }
    }
 
    template <typename... Args>
    static std::shared_ptr<T> createAndPopulate(const XmlElementPtr& element, Args&&... args)
    {
       return FieldPopulator<T>::createAndPopulateImpl(element, std::forward<Args>(args)...);
    }
    
private:
    static const std::unordered_map<std::string_view, XmlElementPopulator<T>>& elementXref()
    {
        static const std::unordered_map<std::string_view, XmlElementPopulator<T>> xref = []()
            {
                std::unordered_map<std::string_view, XmlElementPopulator<T>> retval;
                auto mappingArray = T::xmlMappingArray();
                for (std::size_t i = 0; i < mappingArray.size(); i++) {
                    const XmlElementDescriptor<T> descriptor = mappingArray[i];
                    retval[std::get<0>(descriptor)] = std::get<1>(descriptor);
                }
                return retval;
            }();
        return xref;
    }
 
    template <typename... Args>
    static std::shared_ptr<T> createAndPopulateImpl(const XmlElementPtr& element, Args&&... args)
    {
        auto instance = std::make_shared<T>(std::forward<Args>(args)...);
        FieldPopulator<T>::populate(instance, element);
        return instance;
    }
};
 
template <typename EnumClass, typename EmbeddedClass, typename... Args>
inline void populateEmbeddedClass(const XmlElementPtr& e, std::unordered_map<EnumClass, std::shared_ptr<EmbeddedClass>>& listArray, Args&&... args)
{
    auto typeAttr = e->findAttribute("type");
    if (!typeAttr) {
        throw std::invalid_argument("<" + e->getTagName() + "> element has no type attribute");
    }
    listArray.emplace(toEnum<EnumClass>(typeAttr->getValueTrimmed()), FieldPopulator<EmbeddedClass>::createAndPopulate(e, std::forward<Args>(args)...));
}
 
template <typename T>
inline std::vector<T> populateEmbeddedArray(const XmlElementPtr& e, const std::string_view& elementNodeName)
{
    std::vector<T> result;
    for (auto child = e->getFirstChildElement(); child; child = child->getNextSibling()) {
        if (child->getTagName() != elementNodeName) {
            MUSX_UNKNOWN_XML("Unknown tag <" + child->getTagName() + "> while processing embedded xml array <" + e->getTagName() + ">");
            continue;
        }
        if constexpr (std::is_fundamental_v<T>) {
            result.push_back(child->getTextAs<T>());
        } else if constexpr (std::is_same_v<T, std::string>) {
            result.push_back(child->getText());
        } else {
            result.push_back(FieldPopulator<T>::createAndPopulate(child));
        }
    }
    return result;
}
 
template <>
template <typename... Args>
inline std::shared_ptr<FontInfo> FieldPopulator<FontInfo>::createAndPopulate(const XmlElementPtr& element, Args&&... args)
{
    if (!element->getFirstChildElement()) return nullptr;
    return FieldPopulator<FontInfo>::createAndPopulateImpl(element, std::forward<Args>(args)...);
}
 
void populateFontEfx(const XmlElementPtr& e, const std::shared_ptr<dom::FontInfo>& i);
 
template <typename T>
inline bool populateBoolean(const XmlElementPtr& element, const std::shared_ptr<T>& instance)
{
    MUSX_ASSERT_IF(!element) {
        throw std::logic_error("Null element passed to populateBoolean function.");
    }
 
    if (!element->getFirstChildElement("offInPart")) {
        return true;
    }
 
    if constexpr (std::is_base_of_v<Base, T>) {
        const Base& instAsBase = *instance;
        return instAsBase.getSourcePartId() == SCORE_PARTID; // return false if this is a part
    } else {
        return false; // I don't think we'll ever get an `offInPart` for the score, so assume it is for a part if we aren't a Base subclass
    }
}
 
inline std::vector<std::uint8_t> hexToBytes(std::string_view hex)
{
    std::vector<std::uint8_t> out;
 
    if (hex.size() % 2 == 0) {
        out.reserve(hex.size() / 2);
        for (std::size_t i = 0; i < hex.size(); i += 2) {
            unsigned value = 0;
            const char* first = hex.data() + i;
            const char* last  = first + 2;          // OK even when last == data()+size()
            auto [ptr, ec] = std::from_chars(first, last, value, 16);
            if (ec != std::errc()) {
                i = hex.size(); // break out of loop if MUSX_INTEGRITY_ERROR does not throw
                MUSX_INTEGRITY_ERROR("Invalid hex digit in hex string.");
            }
            out.push_back(static_cast<std::uint8_t>(value));
        }
    } else {
        MUSX_INTEGRITY_ERROR("Encountered odd-length hex string.");
    }
 
    return out;
}
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
} // namespace factory
} // namespace musx