DocumentFactory.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 <algorithm>
#include <cstddef>
#include <cctype>
#include <filesystem>
#include <limits>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "musx/dom/Document.h"
#include "musx/factory/HeaderFactory.h"
#include "musx/factory/PoolFactory.h"
#include "musx/xml/XmlInterface.h"
 
namespace musx {
namespace factory {
 
class DocumentFactory : FactoryBase
{
    using Document = musx::dom::Document;
    using DocumentPtr = std::shared_ptr<Document>;
 
public:
    template <typename Container>
    using IsCharContainer = std::enable_if_t<
        (sizeof(std::remove_cv_t<typename Container::value_type>) == 1)
        && !std::is_same_v<std::remove_cv_t<typename Container::value_type>, bool>
    >;
 
    struct CreateOptions
    {
        struct EmbeddedGraphicFile
        {
            std::string filename;                 
            dom::EmbeddedGraphicBlob bytes;       
        };
 
        using EmbeddedGraphicFiles = std::vector<EmbeddedGraphicFile>; 
 
        CreateOptions() = default;
 
        CreateOptions(dom::PartVoicingPolicy policy) : partVoicingPolicy(policy) {}
 
        CreateOptions(std::filesystem::path inputFilepath,
                      std::vector<char> notationMetadata,
                      EmbeddedGraphicFiles embeddedGraphicFiles,
                      dom::PartVoicingPolicy policy = dom::PartVoicingPolicy::Ignore)
            : partVoicingPolicy(policy),
              m_notationMetadata(std::move(notationMetadata)),
              m_embeddedGraphics(parseEmbeddedGraphicFiles(std::move(embeddedGraphicFiles))),
              m_sourcePath(std::move(inputFilepath))
        {}
 
        dom::PartVoicingPolicy partVoicingPolicy = dom::PartVoicingPolicy::Ignore; 
 
        [[nodiscard]]
        const std::vector<char>& getNotationMetadata() const { return m_notationMetadata; }
 
        [[nodiscard]]
        const dom::EmbeddedGraphicsMap& getEmbeddedGraphics() const { return m_embeddedGraphics; }
 
        [[nodiscard]]
        const std::optional<std::filesystem::path>& getSourcePath() const { return m_sourcePath; }
 
        [[nodiscard]]
        dom::EmbeddedGraphicsMap takeEmbeddedGraphics() { return std::move(m_embeddedGraphics); }
 
    private:
        static dom::EmbeddedGraphicsMap parseEmbeddedGraphicFiles(EmbeddedGraphicFiles&& embeddedGraphicFiles)
        {
            dom::EmbeddedGraphicsMap embeddedGraphics;
            for (auto& file : embeddedGraphicFiles) {
                const auto parsed = parseEmbeddedGraphicFilename(file.filename);
                if (!parsed) {
                    continue;
                }
                auto& entry = embeddedGraphics[parsed->first];
                entry.extension = std::move(parsed->second);
                entry.bytes = std::move(file.bytes);
            }
            return embeddedGraphics;
        }
 
        static std::optional<std::pair<Cmper, std::string>> parseEmbeddedGraphicFilename(const std::string& filename)
        {
            const auto dotPos = filename.find('.');
            if (dotPos == std::string::npos || dotPos == 0 || dotPos + 1 >= filename.size()) {
                return std::nullopt;
            }
 
            const std::string_view cmperText(filename.data(), dotPos);
            if (cmperText.empty() || !std::all_of(cmperText.begin(), cmperText.end(),
                [](unsigned char ch) { return std::isdigit(ch) != 0; })) {
                return std::nullopt;
            }
 
            unsigned long long cmperValue = 0;
            try {
                cmperValue = std::stoull(std::string(cmperText));
            } catch (...) {
                return std::nullopt;
            }
            if (cmperValue > static_cast<unsigned long long>((std::numeric_limits<Cmper>::max)())) {
                return std::nullopt;
            }
 
            return std::make_pair(static_cast<Cmper>(cmperValue), filename.substr(dotPos + 1));
        }
 
        std::vector<char> m_notationMetadata;
        dom::EmbeddedGraphicsMap m_embeddedGraphics;
        std::optional<std::filesystem::path> m_sourcePath;
    };
 
    template <typename XmlDocumentType>
    [[nodiscard]]
    static DocumentPtr create(const char* data, size_t size)
    {
        return create<XmlDocumentType>(data, size, CreateOptions{});
    }
 
    template <typename XmlDocumentType, typename Container, typename = IsCharContainer<Container>>
    [[nodiscard]]
    static DocumentPtr create(const Container& xmlBuffer)
    {
        return create<XmlDocumentType>(asCharData(xmlBuffer), xmlBuffer.size(), CreateOptions{});
    }
 
    template <typename XmlDocumentType>
    [[nodiscard]]
    static DocumentPtr create(const char* data, size_t size, CreateOptions&& createOptions)
    {
        static_assert(std::is_base_of<musx::xml::IXmlDocument, XmlDocumentType>::value,
                      "XmlReaderType must derive from IXmlDocument.");
 
        std::unique_ptr<musx::xml::IXmlDocument> xmlDocument = std::make_unique<XmlDocumentType>();
        xmlDocument->loadFromBuffer(data, size);
 
        auto rootElement = xmlDocument->getRootElement();
        if (!rootElement || rootElement->getTagName() != "finale") {
            throw std::invalid_argument("Missing <finale> element.");
        }
 
        DocumentPtr document(new Document);
        document->m_self = document;
        document->m_partVoicingPolicy = createOptions.partVoicingPolicy;
        document->m_scoreDurationSeconds = parseScoreDurationSeconds<XmlDocumentType>(createOptions.getNotationMetadata());
        document->m_embeddedGraphics = createOptions.takeEmbeddedGraphics();
        document->m_sourcePath = createOptions.getSourcePath();
 
        ElementLinker elementLinker;
        for (auto element = rootElement->getFirstChildElement(); element; element = element->getNextSibling()) {
            if (element->getTagName() == "header") {
                document->getHeader() = musx::factory::HeaderFactory::create(element);
            } else if (element->getTagName() == "options") {
                document->getOptions() = musx::factory::OptionsFactory::create(element, document, elementLinker);
            } else if (element->getTagName() == "others") {
                document->getOthers() = musx::factory::OthersFactory::create(element, document, elementLinker);
            } else if (element->getTagName() == "details") {
                document->getDetails() = musx::factory::DetailsFactory::create(element, document, elementLinker);
            } else if (element->getTagName() == "entries") {
                document->getEntries() = musx::factory::EntryFactory::create(element, document, elementLinker);
            } else if (element->getTagName() == "texts") {
                document->getTexts() = musx::factory::TextsFactory::create(element, document, elementLinker);
            }
        }
        if (!document->getHeader()) document->getHeader() = std::make_shared<musx::dom::Header>();
        if (!document->getOptions()) document->getOptions() = std::make_shared<musx::dom::OptionsPool>(document);
        if (!document->getOthers()) document->getOthers() = std::make_shared<musx::dom::OthersPool>(document);
        if (!document->getDetails()) document->getDetails() = std::make_shared<musx::dom::DetailsPool>(document);
        if (!document->getEntries()) document->getEntries() = std::make_shared<musx::dom::EntryPool>(document);
        if (!document->getTexts()) document->getTexts() = std::make_shared<musx::dom::TextsPool>(document);
 
#ifdef MUSX_DISPLAY_NODE_NAMES
        util::Logger::log(util::Logger::LogLevel::Verbose, "============");
#endif
        elementLinker.resolveAll(document);
        document->m_instruments = document->createInstrumentMap(SCORE_PARTID);
 
        document->m_maxBlankPages = 0;
        auto linkedParts = document->getOthers()->getArray<PartDefinition>(SCORE_PARTID);
        for (const auto& part : linkedParts) {
            auto mutablePart = const_cast<PartDefinition*>(part.get());
            mutablePart->numberOfLeadingBlankPages = 0;
            auto pages = document->getOthers()->getArray<Page>(part->getCmper());
            mutablePart->numberOfPages = int(pages.size());
            for (const auto& page : pages) {
                if (!page->isBlank()) {
                    break;
                }
                mutablePart->numberOfLeadingBlankPages++;
            }
            if (mutablePart->numberOfLeadingBlankPages > document->m_maxBlankPages) {
                document->m_maxBlankPages = part->numberOfLeadingBlankPages;
            }
        }
 
        return document;
    }
 
    template <typename XmlDocumentType, typename Container, typename = IsCharContainer<Container>>
    [[nodiscard]]
    static DocumentPtr create(const Container& xmlBuffer, CreateOptions&& createOptions)
    {
        return create<XmlDocumentType>(asCharData(xmlBuffer), xmlBuffer.size(), std::move(createOptions));
    }
 
private:
    template <typename Container>
    static const char* asCharData(const Container& buffer)
    {
        return reinterpret_cast<const char*>(buffer.data());
    }
 
    template <typename XmlDocumentType>
    static std::optional<double> parseScoreDurationSeconds(const std::vector<char>& notationMetadata)
    {
        if (notationMetadata.empty()) {
            return std::nullopt;
        }
 
        std::unique_ptr<musx::xml::IXmlDocument> xmlDocument = std::make_unique<XmlDocumentType>();
        try {
            xmlDocument->loadFromBuffer(notationMetadata.data(), notationMetadata.size());
        } catch (...) {
            return std::nullopt;
        }
 
        auto rootElement = xmlDocument->getRootElement();
        if (!rootElement || rootElement->getTagName() != "metadata") {
            return std::nullopt;
        }
        if (auto fileInfo = rootElement->getFirstChildElement("fileInfo")) {
            auto creatorString = fileInfo->getFirstChildElement("creatorString");
            if (!creatorString || creatorString->getTextTrimmed().rfind("Finale", 0) != 0) {
                return std::nullopt;
            }
            if (auto scoreDuration = fileInfo->getFirstChildElement("scoreDuration")) {
                try {
                    return scoreDuration->getTextAs<double>();
                } catch (...) {
                    return std::nullopt;
                }
            }
        }
        return std::nullopt;
    }
};
 
} // namespace factory
} // namespace musx