PoolFactory.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 "FactoryBase.h"
#include "TypeRegistry.h"
#include "musx/xml/XmlInterface.h"
#include "musx/dom/BaseClasses.h"
#include "musx/dom/ObjectPool.h"
#include "musx/dom/Document.h"
 
#ifdef MUSX_DISPLAY_NODE_NAMES
#include <set>
#endif
 
namespace musx {
namespace factory {
 
template<typename DerivedType, typename ObjectBase, typename PoolType>
class PoolFactory : public FactoryBase
{
//    static_assert(std::is_base_of<PoolFactory<DerivedType, DerivedType>::value, 
//                "ObjectBase must derive from PoolFactory.");
 
public:    
    static std::shared_ptr<PoolType> create(const XmlElementPtr& element, const dom::DocumentPtr& document, ElementLinker& elementLinker)
    {
        auto pool = std::make_shared<PoolType>();
 
#ifdef MUSX_DISPLAY_NODE_NAMES
        std::set<std::string> alreadyDisplayed;
        util::Logger::log(util::Logger::LogLevel::Verbose, "============");
        util::Logger::log(util::Logger::LogLevel::Verbose, element->getTagName());
        util::Logger::log(util::Logger::LogLevel::Verbose, "============");
#endif
 
        for (auto childElement = element->getFirstChildElement(); childElement; childElement = childElement->getNextSibling()) {            
            auto basePtr = DerivedType::extractFromXml(childElement, document, elementLinker, pool);
            if (basePtr) {
#ifdef MUSX_DISPLAY_NODE_NAMES
                auto it = alreadyDisplayed.find(childElement->getTagName());
                if (it == alreadyDisplayed.end()) {
                    util::Logger::log(util::Logger::LogLevel::Verbose, "  " + childElement->getTagName());
                    alreadyDisplayed.emplace(childElement->getTagName());
                }
#endif
                auto typedPtr = std::dynamic_pointer_cast<ObjectBase>(basePtr);
                assert(typedPtr); // program bug if null
                if constexpr (std::is_same_v<PoolType, EntryPool>) {
                    pool->add(typedPtr->getEntryNumber(), typedPtr);
                } else {
                    pool->add(childElement->getTagName(), typedPtr);
                }
            }
        }
 
        return pool;
    }
};
 
class OptionsFactory : public PoolFactory<OptionsFactory, dom::OptionsBase, dom::OptionsPool>
{
public:
    using PoolFactory::create;
 
    static auto extractFromXml(const XmlElementPtr& element, const dom::DocumentPtr& document, ElementLinker& elementLinker, const OptionsPoolPtr& pool)
    {
        return RegisteredOptions::createInstance(pool, element, elementLinker, document);
    }
};
 
class OthersFactory : public PoolFactory<OthersFactory, dom::OthersBase, dom::OthersPool>
{
public:
    using PoolFactory::create;
 
    static auto extractFromXml(const XmlElementPtr& element, const dom::DocumentPtr& document, ElementLinker& elementLinker, const OthersPoolPtr& pool)
    {
        auto cmperAttribute = element->findAttribute("cmper");
        if (!cmperAttribute) {
            throw std::invalid_argument("missing cmper for others element " + element->getTagName());
        }
        auto inciAttribute = element->findAttribute("inci");
        if (inciAttribute) {
            return RegisteredOthers::createInstance(pool, element, elementLinker,
                document, cmperAttribute->getValueAs<dom::Cmper>(), inciAttribute->getValueAs<dom::Inci>());
        }
        else {
            return RegisteredOthers::createInstance(pool, element, elementLinker,
                document, cmperAttribute->getValueAs<dom::Cmper>());
        }
    }
};
 
class DetailsFactory : public PoolFactory<DetailsFactory, dom::DetailsBase, dom::DetailsPool>
{
public:
    using PoolFactory::create;
 
    static auto extractFromXml(const XmlElementPtr& element, const dom::DocumentPtr& document, ElementLinker& elementLinker, const DetailsPoolPtr& pool)
    {
        std::optional<dom::Inci> inci;
        if (auto inciAttribute = element->findAttribute("inci")) {
            inci = inciAttribute->getValueAs<dom::Inci>();
        }
        if (auto entnumAttribute = element->findAttribute("entnum")) {
            if (inci.has_value()) {
                return RegisteredDetails::createInstance(pool, element, elementLinker,
                    document, entnumAttribute->getValueAs<dom::EntryNumber>(), inci.value());
            } else {
                return RegisteredDetails::createInstance(pool, element, elementLinker,
                    document, entnumAttribute->getValueAs<dom::EntryNumber>());
            }
        }
        auto cmper1Attribute = element->findAttribute("cmper1");
        if (!cmper1Attribute) {
            throw std::invalid_argument("missing cmper1 for details element " + element->getTagName());
        }
        auto cmper2Attribute = element->findAttribute("cmper2");
        if (!cmper2Attribute) {
            throw std::invalid_argument("missing cmper2 for details element " + element->getTagName());
        }
        if (inci.has_value()) {
            return RegisteredDetails::createInstance(pool, element, elementLinker,
                document, cmper1Attribute->getValueAs<dom::Cmper>(), cmper2Attribute->getValueAs<dom::Cmper>(), inci.value());
        } else {
            return RegisteredDetails::createInstance(pool, element, elementLinker,
                document, cmper1Attribute->getValueAs<dom::Cmper>(), cmper2Attribute->getValueAs<dom::Cmper>());
        }
    }
};
 
class EntryFactory : public PoolFactory<EntryFactory, dom::Entry, dom::EntryPool>
{
public:
    using PoolFactory::create;
 
    static auto extractFromXml(const XmlElementPtr& element, const dom::DocumentPtr& document, ElementLinker& elementLinker, const EntryPoolPtr& pool)
    {
        auto entnumAttr = element->findAttribute("entnum");
        if (!entnumAttr) {
            throw std::invalid_argument("missing entum attribute for entry");
        }
        auto prevAttr = element->findAttribute("prev");
        if (!entnumAttr) {
            throw std::invalid_argument("missing prev attribute for entry");
        }
        auto nextAttr = element->findAttribute("next");
        if (!entnumAttr) {
            throw std::invalid_argument("missing next attribute for entry");
        }
        return RegisteredEntries::createInstance(pool, element, elementLinker, document,
            entnumAttr->getValueAs<EntryNumber>(),
            prevAttr->getValueAs<EntryNumber>(),
            nextAttr->getValueAs<EntryNumber>());
    }
};
 
class TextsFactory : public PoolFactory<TextsFactory, dom::TextsBase, dom::TextsPool>
{
public:
    using PoolFactory::create;
 
    static auto extractFromXml(const XmlElementPtr& element, const dom::DocumentPtr& document, ElementLinker& elementLinker, const TextsPoolPtr& pool)
    {
        auto textAttributeName = [element]() -> std::string {
            if (element->getTagName() == texts::FileInfoText::XmlNodeName) {
                return "type";
            }
            return "number";
        }();
        auto textAttribute = element->findAttribute(textAttributeName);
        if (!textAttribute) {
            throw std::invalid_argument("Element <" + element->getTagName() + "> does not have attribute " + textAttributeName);
        }
        auto textNumber = [textAttribute]() -> Cmper {
            if (textAttribute->getName() == "type") {
                return toCmper(textAttribute->getValue());
            }
            return textAttribute->getValueAs<Cmper>();
        }();
        return RegisteredTexts::createInstance(pool, element, elementLinker, document, textNumber);
    }
 
private:
    static Cmper toCmper(const std::string& type) {
        using TextType = texts::FileInfoText::TextType;
        
        if (type == "title") {
            return Cmper(TextType::Title);
        } else if (type == "composer") {
            return Cmper(TextType::Composer);
        } else if (type == "copyright") {
            return Cmper(TextType::Copyright);
        } else if (type == "description") {
            return Cmper(TextType::Description);
        } else if (type == "lyricist") {
            return Cmper(TextType::Lyricist);
        } else if (type == "arranger") {
            return Cmper(TextType::Arranger);
        } else if (type == "subtitle") {
            return Cmper(TextType::Subtitle);
        } else {
            throw std::invalid_argument("Unknown type attribute value for <fileInfo> node: " + type);
        }
    }
};
 
} // namespace factory
} // namespace musx