CommonClasses.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 <numeric>
#include <filesystem>
#include <array>
#include <string>
#include <string_view>
#include <optional>
#include <utility>
#include <vector>
 
#include "musx/util/EnigmaString.h"
#include "musx/util/Fraction.h"
#include "BaseClasses.h"
#include "EnumClasses.h"
 
namespace music_theory {
class Transposer;
enum class DiatonicMode : int;
struct Pitch;
} // namespace music_theory
 
namespace musx {
namespace dom {
 
class EntryInfoPtr;
 
namespace details { // forward declarations
class IndependentStaffDetails;
class LyricAssign;
} // namespace details
 
namespace others { // forward declarations
class FontDefinition;
class Measure;
class OssiaHeader;
class Staff;
} // namespace others
 
using Duration = std::pair<NoteType, unsigned>;
 
// This file contains common classes that are shared among Options, Others, and Details.
 
[[nodiscard]]
std::string normalizeFontName(std::string_view name);
 
[[nodiscard]]
std::optional<Cmper> importFontDefinitionInto(const DocumentPtr& target,
    const MusxInstance<others::FontDefinition>& source,
    const ImportObjectCallback& onImported = {});
 
class FontInfo : public CommonClassBase
{
public:
    FontInfo(const DocumentWeakPtr& document, bool sizeIsPercent = false)
        : CommonClassBase(document), m_sizeIsPercent(sizeIsPercent)
    {
    }
 
    Cmper fontId{};     
    int fontSize{};     
    bool bold{};        
    bool italic{};      
    bool underline{};   
    bool strikeout{};   
    bool absolute{};    
    bool hidden{};      
 
    bool calcIsSameTypeface(const FontInfo& src) const;
 
    bool isSame(const FontInfo& src) const;
 
    bool getSizeIsPercent() const { return m_sizeIsPercent; }
 
    inline static constexpr uint16_t EnigmaStyleBold = 0x01; 
    inline static constexpr uint16_t EnigmaStyleItalic = 0x02; 
    inline static constexpr uint16_t EnigmaStyleUnderline = 0x04; 
    inline static constexpr uint16_t EnigmaStyleStrikeout = 0x20; 
    inline static constexpr uint16_t EnigmaStyleAbsolute  = 0x40; 
    inline static constexpr uint16_t EnigmaStyleHidden    = 0x80; 
 
    std::string getName() const;
 
    void setFontIdByName(const std::string& name);
 
    void setEnigmaStyles(uint16_t efx)
    {
        bold = efx & EnigmaStyleBold;
        italic = efx & EnigmaStyleItalic;
        underline = efx & EnigmaStyleUnderline;
        strikeout = efx & EnigmaStyleStrikeout;
        absolute = efx & EnigmaStyleAbsolute;
        hidden = efx & EnigmaStyleHidden;
    }
 
    uint16_t getEnigmaStyles() const
    {
        uint16_t result = 0;
        if (bold) result |= EnigmaStyleBold;
        if (italic) result |= EnigmaStyleItalic;
        if (underline) result |= EnigmaStyleUnderline;
        if (strikeout) result |= EnigmaStyleStrikeout;
        if (absolute) result |= EnigmaStyleAbsolute;
        if (hidden) result |= EnigmaStyleHidden;
        return result;
    }
 
    bool calcIsDefaultMusic() const
    { return fontId == 0; }
 
    bool calcIsSymbolFont() const;
 
    static std::optional<std::filesystem::path> calcSMuFLMetaDataPath(const std::string& fontName);
 
    std::optional<std::filesystem::path> calcSMuFLMetaDataPath() const
    { return FontInfo::calcSMuFLMetaDataPath(getName()); }
 
    bool calcIsSMuFL() const;
 
    static std::vector<std::filesystem::path> calcSMuFLPaths();
 
    static const xml::XmlElementArray<FontInfo>& xmlMappingArray(); 
 
private:
    bool m_sizeIsPercent;
};
 
class KeySignature : public CommonClassBase
{
public:
    using CommonClassBase::CommonClassBase;
 
    enum class KeyContext {
        Concert,   
        Written    
    };
 
    uint16_t key{};
    bool keyless{};                 
    bool hideKeySigShowAccis{};     
 
    Cmper getKeyMode() const { return isLinear() ? key >> 8 : key;  }
 
    int getAlteration(KeyContext ctx) const
    { return isLinear() ? int(int8_t(key & 0xff)) + getAlterationOffset(ctx) : 0; }
 
    bool isLinear() const { return (key & 0xC000) == 0; }                   
    bool isNonLinear() const { return (key & 0xC000) != 0; }                
    bool isBuiltIn() const { return isLinear() && getKeyMode() <= 1; }      
    bool isMajor() const { return getKeyMode() == 0; }                      
    bool isMinor() const { return getKeyMode() == 1; }                      
 
    std::optional<music_theory::DiatonicMode> calcDiatonicMode() const;
 
    bool isSame(const KeySignature& src) const
    {
        return isSameConcert(src) && m_alterationOffset == src.m_alterationOffset && m_octaveDisplacement == src.m_octaveDisplacement;
    }
 
    bool isSameConcert(const KeySignature& src) const
    {
        return key == src.key && keyless == src.keyless && hideKeySigShowAccis == src.hideKeySigShowAccis;
    }
 
    int calcScaleDegree(int displacement) const;
 
    void setTransposition(int interval, int keyAdjustment, bool simplify);
 
    void setTransposition(const MusxInstance<others::Staff>& staff);
 
    int calcTonalCenterIndex(KeyContext ctx) const;
 
    int calcAlterationOnNote(unsigned noteIndex, KeyContext ctx ) const;
 
    [[nodiscard]]
    music_theory::Pitch calcPitch(int displacement, int alteration, KeyContext ctx) const;
 
    [[nodiscard]]
    music_theory::Pitch calcPitchFromStaffPosition(int staffPosition, ClefIndex clefIndex, KeyContext ctx,
        std::optional<int> actualAlteration = std::nullopt) const;
 
    int getOctaveDisplacement(KeyContext ctx) const
    { return ctx == KeyContext::Written ? m_octaveDisplacement : 0; }
 
    int calcEDODivisions() const;
 
    std::optional<std::vector<int>> calcKeyMap() const;
 
    std::unique_ptr<music_theory::Transposer> createTransposer(int displacement, int alteration) const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->CommonClassBase::integrityCheck(ptrToThis);
        if (key >= 0x8000) {
            MUSX_INTEGRITY_ERROR("Key signature has invalid key value: " + std::to_string(key));
        }
    }
 
    static const xml::XmlElementArray<KeySignature>& xmlMappingArray(); 
 
private:
    std::vector<unsigned> calcTonalCenterArrayForSharps() const;
    std::vector<unsigned> calcTonalCenterArrayForFlats() const;
    std::vector<unsigned> calcTonalCenterArray(KeyContext ctx) const;
    std::vector<int> calcAcciAmountsArray(KeyContext ctx) const;
    std::vector<unsigned> calcAcciOrderArray(KeyContext ctx) const;
 
    int m_octaveDisplacement{};         
    int m_alterationOffset{};           
 
    int getAlterationOffset(KeyContext ctx) const
    { return ctx == KeyContext::Written ? m_alterationOffset : 0; }
 
};
 
namespace texts {
class LyricsTextBase; // forward delcaration
} // namespace texts
 
class LyricsLineInfo : CommonClassBase
{
public:
    LyricsLineInfo(const DocumentWeakPtr& document, Cmper requestedPartId, std::string_view type, Cmper lyricNo, Evpu baseline) :
        CommonClassBase(document), baselinePosition(baseline), lyricsType(type), lyricNumber(lyricNo), assignments(document, requestedPartId)
    {
    }
 
    Evpu baselinePosition;              
    std::string_view lyricsType;        
    Cmper lyricNumber;                  
    MusxInstanceList<details::LyricAssign> assignments; 
};
 
class LyricsSyllableInfo : DocumentElementNoPart
{
public:
    class ElisionRun
    {
    public:
        std::optional<char32_t> joinMarker;     
        bool hasHyphenBefore{};                 
        bool hasHyphenAfter{};                  
 
        std::string text() const;
 
        bool iterateStyles(util::EnigmaString::TextChunkCallback callback) const;
 
    private:
        std::vector<std::pair<std::string, util::EnigmaStyles>> m_chunks;
 
        friend class LyricsSyllableInfo;
    };
 
    std::string syllable;       
    bool hasHyphenBefore;       
    bool hasHyphenAfter;        
    int strippedUnderscores;    
 
    bool iterateStyles(util::EnigmaString::TextChunkCallback callback) const;
 
    std::vector<ElisionRun> calcElisionRuns() const;
 
private:
    class StyleSpan
    {
    public:
        size_t start;        // start byte
        size_t end;          // end byte (exclusive)
        size_t styleIndex;   // index into LyricsTextBase's style table
    };
 
    LyricsSyllableInfo(const DocumentWeakPtr& document, const MusxInstance<texts::LyricsTextBase>& owner, const std::string text, bool before, bool after, int underscores, std::vector<StyleSpan>&& enigmaStyleMap)
        : DocumentElementNoPart(document), syllable(text), hasHyphenBefore(before), hasHyphenAfter(after), strippedUnderscores(underscores), m_owner(owner), m_enigmaStyleMap(std::move(enigmaStyleMap))
    {
    }
 
    bool iterateStylesInRange(size_t rangeStart, size_t rangeEnd, const util::EnigmaString::TextChunkCallback& callback) const;
 
    MusxInstanceWeak<texts::LyricsTextBase> m_owner; 
    std::vector<StyleSpan> m_enigmaStyleMap; 
 
    friend class texts::LyricsTextBase;
};
 
class MusicPoint
{
public:
    constexpr MusicPoint() = default;
 
    constexpr MusicPoint(MeasCmper measId, util::Fraction pos)
        : measureId(measId), position(pos)
    {
    }
 
    MeasCmper measureId{1};        
    util::Fraction position{};     
 
    [[nodiscard]]
    constexpr bool operator==(const MusicPoint& other) const
    { return measureId == other.measureId && position == other.position; }
 
    [[nodiscard]]
    constexpr bool operator!=(const MusicPoint& other) const
    { return !(*this == other); }
 
    [[nodiscard]]
    constexpr bool operator<(const MusicPoint& other) const
    { return measureId < other.measureId || (measureId == other.measureId && position < other.position); }
 
    [[nodiscard]]
    constexpr bool operator<=(const MusicPoint& other) const
    { return *this < other || *this == other; }
 
    [[nodiscard]]
    constexpr bool operator>(const MusicPoint& other) const
    { return other < *this; }
 
    [[nodiscard]]
    constexpr bool operator>=(const MusicPoint& other) const
    { return other <= *this; }
};
 
class MusicRange : public DocumentElementNoPart
{
public:
    explicit MusicRange(const DocumentWeakPtr& document, MeasCmper startMeasId, util::Fraction startPos, MeasCmper endMeasId, util::Fraction endPos)
        : MusicRange(document, MusicPoint(startMeasId, startPos), MusicPoint(endMeasId, endPos))
    {
    }
 
    explicit MusicRange(const DocumentWeakPtr& document, MusicPoint startPoint, MusicPoint endPoint)
        : DocumentElementNoPart(document), start(startPoint), end(endPoint)
    {
    }
 
    MusicPoint start;   
    MusicPoint end;     
 
    bool contains(MeasCmper measId, util::Fraction position) const
    { return contains(MusicPoint(measId, position)); }
 
    bool contains(const MusicPoint& point) const
    { return start <= point && point <= end; }
 
    // The MusicRange must be expressed in the Staff EDUs of the entry.
    bool contains(const EntryInfoPtr& entryInfo) const;
 
    [[nodiscard]]
    std::optional<MusicPoint> nextLocation(const std::optional<StaffCmper>& forStaff = std::nullopt) const;
};
 
class TimeSignature : public DocumentElementNoPart
{
public:
    enum class Abbreviation
    {
        NotApplicable, 
        Numeric,       
        Abbreviated    
    };
 
    struct TimeSigComponent
    {
        std::vector<util::Fraction> counts; 
        std::vector<Edu> units;             
 
        bool operator==(const TimeSigComponent& src) const
        { return counts == src.counts && units == src.units; }
 
        util::Fraction sumCounts() const
        { return std::accumulate(counts.begin(), counts.end(), util::Fraction{}); }
 
        Edu sumUnits() const
        { return std::accumulate(units.begin(), units.end(), Edu{}); }
 
        static std::pair<util::Fraction, Edu> normalizeCompoundUnit(util::Fraction count, Edu unit);
 
        TimeSigComponent normalizeCompound() const;
    };
 
    std::vector<TimeSigComponent> components;     
 
    std::pair<util::Fraction, NoteType> calcSimplified() const;
 
    util::Fraction calcTotalDuration() const
    {
        util::Fraction result = std::accumulate(components.begin(), components.end(), util::Fraction{},
            [](const util::Fraction& acc, const TimeSigComponent& comp)
            { return acc + (comp.sumCounts() * comp.sumUnits()); }
        );
        return result / Edu(NoteType::Whole);
    }
    
    util::Fraction calcBeatValueAt(Edu eduPosition) const;
 
    bool isSame(const TimeSignature& src) const;
 
    MusxInstance<TimeSignature> createComponent(size_t index) const
    {
        checkIndex(index);
        return MusxInstance<TimeSignature>(new TimeSignature(getDocument(), components[index], m_abbreviation));
    }
 
    std::optional<char32_t> getAbbreviatedSymbol() const;
 
    bool isCommonTime() const;
    bool isCutTime() const;
 
private:
    void checkIndex(size_t index) const
    {
        if (index > components.size()) {
            throw std::invalid_argument("Index out of range. The time signature has " + std::to_string(components.size())
                + " elements. The index requested was " + std::to_string(index) + ".");
        }
    }
 
    explicit TimeSignature(const DocumentWeakPtr& document, int beats, Edu unit, bool hasCompositeTop, bool hasCompositeBottom,
        Abbreviation abbreviate = {});
 
    explicit TimeSignature(const DocumentWeakPtr& document, const TimeSigComponent& timeSigUnit, Abbreviation abbreviate = {})
        : DocumentElementNoPart(document), m_abbreviation(abbreviate)
    {
        components.push_back(timeSigUnit);
    }
 
    Abbreviation m_abbreviation{};
 
    friend class others::Measure;
    friend class others::OssiaHeader;
    friend class details::IndependentStaffDetails;
};
 
namespace others {
 
// The following classes are defined here because they are shared by multiple subclasses and container classes.
 
class Enclosure : public OthersBase
{
public:
    enum class Shape : uint8_t
    {
        NoEnclosure = 0,    
        Rectangle = 1,      
        Ellipse = 2,        
        Triangle = 3,       
        Diamond = 4,        
        Pentagon = 5,       
        Hexagon = 6,        
        Heptagon = 7,       
        Octogon = 8         
    };
 
    explicit Enclosure(const DocumentWeakPtr& document, Cmper partId = SCORE_PARTID, ShareMode shareMode = ShareMode::All, Cmper cmper = 0)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Evpu xAdd{};              
    Evpu yAdd{};              
    Evpu xMargin{};           
    Evpu yMargin{};           
    Efix lineWidth{};         
    Shape shape{};            
    Efix cornerRadius{};      
    bool fixedSize{};         
    bool equalAspect{};       
    bool notTall{};           
    bool opaque{};            
    bool roundCorners{};      
 
    static const xml::XmlElementArray<Enclosure>& xmlMappingArray(); 
};
 
class EnigmaMusicRange : public OthersBase
{
public:
    explicit EnigmaMusicRange(const DocumentWeakPtr& document, Cmper partId = SCORE_PARTID, ShareMode shareMode = ShareMode::All,
            Cmper cmper = 0, std::optional<Inci> inci = std::nullopt)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    MeasCmper startMeas{};      
    Edu startEdu{};             
    MeasCmper endMeas{};        
    Edu endEdu{};               
 
    bool contains(MeasCmper measId, Edu eduPosition) const
    {
        return (startMeas < measId || (startMeas == measId && startEdu <= eduPosition)) &&
               (endMeas > measId || (endMeas == measId && endEdu >= eduPosition));
    }
 
    MusicRange createMusicRange() const
    {
        return MusicRange(getDocument(), startMeas, util::Fraction::fromEdu(startEdu), endMeas, util::Fraction::fromEdu(endEdu));
    }
 
    std::optional<MusicPoint> nextLocation(const std::optional<StaffCmper>& forStaff = std::nullopt) const
    { return createMusicRange().nextLocation(forStaff); }
 
    static const xml::XmlElementArray<EnigmaMusicRange>& xmlMappingArray(); 
};
 
class NamePositioning : public OthersBase
{
public:
 
    explicit NamePositioning(const DocumentWeakPtr& document, Cmper partId = SCORE_PARTID, ShareMode shareMode = ShareMode::All, Cmper cmper = 0)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Evpu horzOff{};             
    Evpu vertOff{};             
    AlignJustify justify{};     
    bool indivPos{};            
    AlignJustify hAlign{};      
    bool expand{};              
    bool hidden{};              
 
    static const xml::XmlElementArray<NamePositioning>& xmlMappingArray(); 
};
 
} // namespace others
} // namespace dom
} // namespace mux