EnigmaString.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 <cassert>
#include <string>
#include <string_view>
#include <vector>
#include <functional>
#include <memory>
#include <unordered_set>
 
#include "musx/dom/Fundamentals.h"
#include "musx/dom/MusxInstance.h"
 
namespace musx {
 
namespace dom {
class FontInfo;
class Document;
class TextsBase;
 
namespace options {
enum class AccidentalInsertSymbolType;
}
 
} // namespace dom
 
namespace util {
 
struct EnigmaStyles
{
    enum class CategoryTracking
    {
        None,           
        MusicFont,      
        TextFont,       
        NumberFont      
    };
 
    EnigmaStyles(const std::weak_ptr<dom::Document>& document)
        : font(std::make_shared<dom::FontInfo>(document))
    {
    }
 
    EnigmaStyles createDeepCopy() const
    {
        EnigmaStyles result = *this;
        result.font = std::make_shared<dom::FontInfo>(*this->font);
        return result;
    }
 
    std::shared_ptr<dom::FontInfo> font;    
    CategoryTracking categoryFont{};        
    dom::Evpu baseline{};                   
    dom::Evpu superscript{};                
    int tracking{};                         
};
 
class EnigmaParsingContext;
 
class EnigmaString
{
public:
    template <typename CharT>
    static std::string fromU8(const CharT* s)
    {
        static_assert(std::is_same<CharT, char>::value || std::is_same<CharT, decltype(u8'a')>::value,
            "fromU8() only accepts char or char8_t pointers");
        return std::string(reinterpret_cast<const char*>(s));
    }
 
    static std::string toU8(char32_t cp);
 
    enum class AccidentalInsertHandling
    {
        ParseToGlyphs,
 
        Substitute
    };
 
    enum class AccidentalStyle
    {
        Ascii,
 
        Unicode,
 
        Smufl
    };
 
    struct EnigmaParsingOptions
    {
        EnigmaParsingOptions() :
            insertHandling(AccidentalInsertHandling::ParseToGlyphs),
            substitutionStyle(AccidentalStyle::Unicode) {}
 
        EnigmaParsingOptions(AccidentalStyle accidentalStyle) :
            insertHandling(AccidentalInsertHandling::Substitute),
            substitutionStyle(accidentalStyle) {}
 
        AccidentalInsertHandling insertHandling;
 
        AccidentalStyle substitutionStyle;
 
        bool stripUnknownTags = true;
 
        bool ignoreStyleTags = false;
 
        std::unordered_set<std::string_view> ignoreTags;
    };
 
    static bool startsWithFontCommand(const std::string& text);
 
    static bool startsWithStyleCommand(const std::string& text);
 
    static std::optional<dom::options::AccidentalInsertSymbolType> commandIsAccidentalType(std::string_view commandText);
 
    static std::vector<std::string> parseComponents(const std::string& input, size_t* parsedLength = nullptr);
 
    using TextChunkCallback = std::function<bool(
        const std::string& text,
        const EnigmaStyles& styles
    )>;
 
    using TextInsertCallback = std::function<std::optional<std::string>(
        const std::vector<std::string>& parsedCommand
    )>;
 
    static inline TextInsertCallback defaultInsertsCallback = [](const std::vector<std::string>&) { return std::nullopt; };
 
    static bool parseEnigmaText(const std::shared_ptr<dom::Document>& document, dom::Cmper forPartId, const std::string& rawText,
        const TextChunkCallback& onText, const TextInsertCallback& onInsert,
        const EnigmaParsingOptions& options = {}, const EnigmaParsingContext* parsingContext = nullptr)
    {
        return parseEnigmaTextImpl(document, forPartId, rawText, onText, onInsert, options, parsingContext, EnigmaStyles(document));
    }
 
    static bool parseEnigmaText(const std::shared_ptr<dom::Document>& document, dom::Cmper forPartId, const std::string& rawText, const TextChunkCallback& onText,
        const EnigmaParsingOptions& options = {}, const EnigmaParsingContext* parsingContext = nullptr)
    {
        return parseEnigmaTextImpl(document, forPartId, rawText, onText, defaultInsertsCallback, options, parsingContext, EnigmaStyles(document));
    }
 
    static bool parseStyleCommand(std::vector<std::string> components, EnigmaStyles& styles);
 
    static std::string trimTags(const std::string& input);
 
private:
    static bool parseEnigmaTextImpl(const std::shared_ptr<dom::Document>& document, dom::Cmper forPartId, const std::string& rawText,
        const TextChunkCallback& onText, const TextInsertCallback& onInsert,
        const EnigmaParsingOptions& options, const EnigmaParsingContext* parsingContext,
        const EnigmaStyles& startingStyles);
};
 
class EnigmaParsingContext
{
private:
    dom::MusxInstance<dom::TextsBase> m_rawText;
    dom::Cmper m_forPartId;
    std::optional<int> m_forPageNumber;
    EnigmaString::TextInsertCallback m_insertFunc;
 
public:
    EnigmaParsingContext()
        : m_rawText(nullptr), m_forPartId(dom::SCORE_PARTID), m_insertFunc(EnigmaString::defaultInsertsCallback)
    {}
 
    EnigmaParsingContext(dom::MusxInstance<dom::TextsBase> rawText, dom::Cmper forPartId,
            std::optional<dom::Cmper> forPageId = std::nullopt,
            EnigmaString::TextInsertCallback insertFunc = EnigmaString::defaultInsertsCallback)
        : m_rawText(std::move(rawText)), m_forPartId(forPartId), m_forPageNumber(forPageId), m_insertFunc(insertFunc)
    {}
 
    explicit operator bool() const noexcept
    { return static_cast<bool>(m_rawText); }
 
    std::string affixText;          
    bool affixIsPrefix{};           
 
    std::string getText(bool trimTags = false,
        EnigmaString::AccidentalStyle accidentalStyle = EnigmaString::AccidentalStyle::Ascii,
        const std::unordered_set<std::string_view>& ignoreTags = {}) const;
 
    bool parseEnigmaText(const EnigmaString::TextChunkCallback& onText,
        const EnigmaString::TextInsertCallback& onInsert,
        const EnigmaString::EnigmaParsingOptions& options = {}) const;
 
    bool parseEnigmaText(const EnigmaString::TextChunkCallback& onText,
        const EnigmaString::EnigmaParsingOptions& options = {}) const
    {
        return parseEnigmaText(onText, EnigmaString::defaultInsertsCallback, options);
    }
 
    dom::MusxInstance<dom::FontInfo> parseFirstFontInfo() const;
 
    dom::MusxInstance<dom::TextsBase> getRawText() const { return m_rawText; }
 
    // If there is ever a need for a non-const version of the pointer, we can always
    // look it up again.
 
    dom::Cmper getRequestedPartId() const { return m_forPartId; }
 
    std::optional<int> getPageNumber() const { return m_forPageNumber; }
};
 
} // namespace util
} // namespace musx