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 <unordered_set>
#include <unordered_map>
#include <tuple>
#include <sstream>
#include <type_traits>
#include <charconv>
 
#include "musx/util/Logger.h"
#include "musx/factory/FactoryExceptions.h"
#include "musx/xml/XmlInterface.h"
#include "musx/dom/BaseClasses.h"
#include "musx/dom/Document.h"
#include "musx/factory/ConstructionContext.h"
 
namespace musx {
 
namespace factory {
 
using namespace musx::xml;
using namespace musx::dom;
 
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__
 
#if defined(_MSC_VER)
#define MUSX_ENUM_CONVERSION_SIGNATURE __FUNCSIG__
#else
#define MUSX_ENUM_CONVERSION_SIGNATURE __PRETTY_FUNCTION__
#endif
 
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) + "`";
                }
            }();
            msg += " in " + std::string(MUSX_ENUM_CONVERSION_SIGNATURE);
            MUSX_UNKNOWN_XML(msg);
        }
        return {};
    }
};
 
#undef MUSX_ENUM_CONVERSION_SIGNATURE
 
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
 
template <typename T>
struct FieldPopulator : public FactoryBase
{
    static void populateField(ConstructionContext& context, const std::shared_ptr<T>& instance, const XmlElementPtr& fieldElement)
    {
        auto it = elementXref().find(fieldElement->getTagName());
        if (it != elementXref().end()) {
            std::get<1>(*it)(context, fieldElement, instance);
        } else {
            const bool requireFields = [instance]() {
                if constexpr (std::is_base_of_v<EnigmaBase, 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(ConstructionContext& context, 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(context, instance, child);
            }
        }
    }
 
    template <typename... Args>
    static std::shared_ptr<T> createAndPopulate(ConstructionContext& context, const XmlElementPtr& element, Args&&... args)
    {
       return FieldPopulator<T>::createAndPopulateImpl(context, element, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    static std::shared_ptr<T> populateExistingOrCreate(
        ConstructionContext& context, const XmlElementPtr& element, std::shared_ptr<T> instance, Args&&... args)
    {
        if (!instance) {
            instance = std::make_shared<T>(std::forward<Args>(args)...);
        }
        FieldPopulator<T>::populate(context, instance, element);
        return instance;
    }
 
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(ConstructionContext& context, const XmlElementPtr& element, Args&&... args)
    {
        auto instance = std::make_shared<T>(std::forward<Args>(args)...);
        FieldPopulator<T>::populate(context, instance, element);
        return instance;
    }
};
 
template <typename EnumClass, typename EmbeddedClass, typename... Args>
inline void populateEmbeddedClass(ConstructionContext& context, 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(context, e, std::forward<Args>(args)...));
}
 
template <typename T>
inline std::vector<T> populateEmbeddedArray(ConstructionContext& context, 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(context, child));
        }
    }
    return result;
}
 
void populateFontEfx(ConstructionContext& context, const XmlElementPtr& e, const std::shared_ptr<dom::FontInfo>& i);
 
inline void populateFontId(ConstructionContext& context, const XmlElementPtr& e, dom::Cmper& fontId)
{
    fontId = e->getTextAs<dom::Cmper>();
    context.registerFontId(fontId);
}
 
template <typename T>
inline bool populateBoolean(ConstructionContext&, 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<EnigmaBase, T>) {
        const EnigmaBase& 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