Staff.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 <functional>
#include <type_traits>
#include <utility>
 
#include "musx/util/Logger.h"
#include "musx/util/Fraction.h"
 
#include "BaseClasses.h"
#include "CommonClasses.h"
 // do not add other dom class dependencies. Use .cpp files for implementations that need total class access.
 
namespace musx {
namespace dom {
 
namespace details {
class Baseline;
class BaselineNoInci;
class ShapeNoteBase;
}
 
namespace others {
 
class StaffStyle;
class Staff : public OthersBase
{
public:
    enum class AutoNumberingStyle
    {
        ArabicSuffix,       
        RomanSuffix,        
        OrdinalPrefix,      
        AlphaSuffix,        
        ArabicPrefix        
    };
 
    enum class NotationStyle
    {
        Standard,
        Percussion,
        Tablature
    };
 
    enum class HideMode
    {
        None,           
        Cutaway,        
        ScoreParts,     
        Score           
    };
 
    enum class AlternateNotation
    {
        Normal,         
        SlashBeats,     
        Rhythmic,       
        Blank,          
        OneBarRepeat,   
        TwoBarRepeat,   
        BlankWithRests  
    };
 
    class KeySigTransposition
    {
    public:
        int interval{};     
        int adjust{};       
 
        static const xml::XmlElementArray<KeySigTransposition>& xmlMappingArray(); 
    };
 
    class ChromaticTransposition
    {
    public:
        int alteration{};   
        int diatonic{};     
 
        static const xml::XmlElementArray<ChromaticTransposition>& xmlMappingArray(); 
    };
 
    class Transposition : public ContainedClassBase
    {
    public:
        using  ContainedClassBase::ContainedClassBase;
 
        bool setToClef{};               
        bool noSimplifyKey{};           
 
        std::shared_ptr<KeySigTransposition> keysig;
 
        std::shared_ptr<ChromaticTransposition> chromatic;
 
        bool isSame(const Transposition& other) const;
 
        void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
        {
            ContainedClassBase::integrityCheck(ptrToThis);
            Cmper thisCmper = 0;
            if (const auto parent = getParent<others::Staff>()) {
                thisCmper = parent->getCmper();
            }
            if (!keysig && !chromatic) {
                MUSX_INTEGRITY_ERROR("Transposition settings " + std::to_string(thisCmper) + " has neither a key signature nor chromatic settings.");
            } else if (keysig && chromatic) {
                MUSX_INTEGRITY_ERROR("Transposition settings " + std::to_string(thisCmper) + " has both key signature and chromatic settings.");
            }
        }
 
        static const xml::XmlElementArray<Transposition>& xmlMappingArray(); 
    };
 
    explicit Staff(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // WARNING: Any fields added here must have a mask added in StaffStyle (if it does not already exist)
    //          and must be added to StaffComposite::applyStyle.
 
    // Public properties corresponding to the XML structure
    NotationStyle notationStyle{};  
    std::shared_ptr<FontInfo> noteFont; 
    bool useNoteShapes{};           
    bool useNoteFont{};             
    ClefIndex defaultClef{};        
    ClefIndex transposedClef{};     
    std::optional<int> staffLines{}; 
    std::optional<std::vector<int>> customStaff; 
    Evpu lineSpace{};               
    std::string instUuid;           
    int capoPos{};                  
    int lowestFret{};               
    bool floatKeys{};               
    bool floatTime{};               
    bool blineBreak{};              
    bool rbarBreak{};               
    bool hasStyles{};               
    bool showNameInParts{};         
    bool showNoteColors{};          
    // No fixture has a partially shared Staff (part-specific staffSpec records are fully unshared).
    // If one is found, Transposition must be copied and rebound before overlaying its nested fields.
    // See PartContextRebinder<details::CenterShape> and the CenterShape field mappings for the pattern.
    std::shared_ptr<Transposition> transposition; 
    bool hideNameInScore{};         
    Evpu botBarlineOffset{};        
    AlternateNotation altNotation{};
    LayerIndex altLayer{};          
    bool altHideArtics{};           
    bool altHideLyrics{};           
    bool altHideSmartShapes{};      
    bool altRhythmStemsUp{};        
    bool altSlashDots{};            
    bool altHideOtherNotes{};       
    bool altHideOtherArtics{};      
    bool altHideExpressions{};      
    bool altHideOtherLyrics{};      
    bool altHideOtherSmartShapes{}; 
    bool altHideOtherExpressions{}; 
    bool hideRepeatBottomDot{};     
    bool flatBeams{};               
    bool hideFretboards{};          
    bool blankMeasure{};            
    bool hideRepeatTopDot{};        
    bool hideLyrics{};              
    bool noOptimize{};              
    Evpu topBarlineOffset{};        
    bool hideMeasNums{};            
    bool hideRepeats{};             
    bool hideBarlines{};            
    bool hideRptBars{};             
    bool hideKeySigs{};             
    bool hideTimeSigs{};            
    bool hideClefs{};               
    bool hideStaffLines{};          
    bool hideChords{};              
    bool noKey{};                   
    Evpu dwRestOffset{};            
    Evpu wRestOffset{};             
    Evpu hRestOffset{};             
    Evpu otherRestOffset{};         
    bool hideRests{};               
    bool hideTies{};                
    bool hideDots{};                
    int stemReversal{};             
    Cmper fullNameTextId{};         
    Cmper abbrvNameTextId{};        
    Evpu botRepeatDotOff{};         
    Evpu topRepeatDotOff{};         
    Efix vertTabNumOff{};           
    bool showTabClefAllSys{};       
    bool useTabLetters{};           
    bool breakTabLinesAtNotes{};    
    bool hideTuplets{};             
    Cmper fretInstId{};             
    bool hideStems{};               
    StemDirection stemDirection{};  
    bool hideBeams{};               
    bool stemStartFromStaff{};      
    bool stemsFixedEnd{};           
    bool stemsFixedStart{};         
    Efix horzStemOffUp{};           
    Efix horzStemOffDown{};         
    Efix vertStemStartOffUp{};      
    Efix vertStemStartOffDown{};    
    Efix vertStemEndOffUp{};        
    Efix vertStemEndOffDown{};      
    HideMode hideMode{};            
    bool redisplayLayerAccis{};     
    bool hideTimeSigsInParts{};     
    AutoNumberingStyle autoNumbering{}; 
    bool useAutoNumbering{};        
    bool hideKeySigsShowAccis{};    
 
    // The following values are not in xml but computed by the factory.
 
    Cmper noteShapesId{};           
    bool noteShapesFromStyle{};     
    Cmper fullNamePosId{};          
    bool fullNamePosFromStyle{};    
    Cmper abrvNamePosId{};          
    bool abrvNamePosFromStyle{};    
    Cmper multiStaffInstId{};       
    std::optional<int> autoNumberValue; 
    std::optional<Cmper> percussionMapId; 
 
    std::string getFullName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    std::string getAbbreviatedName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    bool calcShowName() const;
 
    MusxInstance<MultiStaffInstrumentGroup> getMultiStaffInstGroup() const;
 
    MusxInstance<details::StaffGroup> getMultiStaffInstVisualGroup(Cmper forPartId) const;
 
    util::EnigmaParsingContext getFullInstrumentNameCtx(Cmper forPartId, bool preferStaffName = false) const;
 
    util::EnigmaParsingContext getAbbreviatedInstrumentNameCtx(Cmper forPartId, bool preferStaffName = false) const;
 
    std::string getFullInstrumentName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii, bool preferStaffName = false) const;
 
    std::string getAbbreviatedInstrumentName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii, bool preferStaffName = false) const;
 
    std::string getPlaybackRouteName() const;
 
    bool calcShowInstrumentName() const;
 
    MusxInstance<details::ShapeNoteBase> getNoteShapes() const;
 
    MusxInstance<NamePositioning> getFullNamePosition() const;
 
    MusxInstance<NamePositioning> getAbbreviatedNamePosition() const;
 
    bool showNamesForPart(Cmper partId) const
    { return partId == SCORE_PARTID ? !hideNameInScore : showNameInParts; }
 
    static void calcAllAutoNumberValues(const DocumentPtr& document);
 
    template <typename SubType>
    static void calcAllRuntimeValues(const DocumentPtr& document);
 
    std::pair<std::string, bool> calcAutoNumberingAffix() const;
 
    std::string addAutoNumbering(const std::string& plainName) const;
 
    ClefIndex calcClefIndexAt(MeasCmper measureId, Edu position, bool forWrittenPitch = false) const;
 
    ClefIndex calcFirstClefIndex(bool forWrittenPitch = false) const
    { return calcClefIndexAt(1, 0, forWrittenPitch); }
 
    static ClefIndex calcFirstClefIndex(const DocumentPtr& document, Cmper partId, StaffCmper staffCmper);
 
    struct ClefChange
    {
        ClefIndex clefIndex{};                  
        util::Fraction position{};              
        ShowClefMode showClefMode{};            
        bool afterBarline{};                    
        Evpu yEvpuPos{};                        
        int percent{};                          
        int xEvpuOffset{};                      
    };
 
    bool iterateClefChangesAtMeasure(
        MeasCmper measureId,
        bool forWrittenPitch,
        std::function<bool(const ClefChange&)> iterator) const;
 
    int calcNumberOfStafflines() const;
 
    int calcMiddleStaffPosition() const;
 
    [[nodiscard]] Evpu calcRestOffset(Edu edu) const;
 
    [[nodiscard]] std::pair<Evpu, Evpu> calcBarlineOffsetsFromCenter() const;
 
    Evpu calcBaselineZeroPosition() const;
 
    template<typename BaselineType,
             std::enable_if_t<std::is_base_of<details::BaselineNoInci, BaselineType>::value, int> = 0>
    Evpu calcBaselinePosition(SystemCmper systemId) const
    {
        return calcBaselinePositionImpl<BaselineType>(systemId, std::nullopt);
    }
 
    template<typename BaselineType,
             std::enable_if_t<std::is_base_of<details::Baseline, BaselineType>::value &&
                              !std::is_base_of<details::BaselineNoInci, BaselineType>::value, int> = 0>
    Evpu calcBaselinePosition(SystemCmper systemId, Cmper lyricNumber) const
    {
        return calcBaselinePositionImpl<BaselineType>(systemId, lyricNumber);
    }
 
    std::vector<LyricsLineInfo> createLyricsLineInfo(SystemCmper systemId) const;
 
    int calcTopLinePosition() const;
 
    Evpu calcTopLineEvpu() const
    { return static_cast<Evpu>(calcTopLinePosition() * static_cast<int>(EVPU_PER_STAFF_POSITION)); }
 
    int calcBottomLinePosition() const;
 
    Evpu calcBottomLineEvpu() const
    { return static_cast<Evpu>(calcBottomLinePosition() * static_cast<int>(EVPU_PER_STAFF_POSITION)); }
 
    bool hasInstrumentAssigned() const;
 
    std::pair<int, int> calcTranspositionInterval() const;
 
    MusxInstanceList<PartDefinition> getContainingParts(bool includeScore = true) const;
 
    MusxInstance<PartDefinition> firstContainingPart() const;
 
    bool calcAlternateNotationHidesEntries(LayerIndex forLayerIndex) const;
 
    bool iterateEntries(std::function<bool(const EntryInfoPtr&)> iterator) const;
 
    bool calcIsSameNotationStyle(const Staff& other) const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
        if (!staffLines && !customStaff) {
            MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " has neither a standard nor a custom staff definition.");
        } else if (staffLines && customStaff) {
            MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " has both a standard and a custom staff definition.");
        }
        if (customStaff) { // guarantee ascending order of staves.
            std::sort(customStaff.value().begin(), customStaff.value().end(),
                [](const auto& a, const auto& b) { return a < b; });
        }
        if (transposition) {
            if (!transposition->chromatic && !transposition->keysig) {
                MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " has transposition with neither keysig nor chromatic transposition defined.");
            } else if (transposition->chromatic && transposition->keysig) {
                MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " has transposition with both keysig and chromatic transposition defined.");
            }
        }
        if (useNoteFont && !noteFont) {
            noteFont = std::make_shared<FontInfo>(getDocument()); // do this first to avoid unreachable code warning, since MUSX_INTEGRITY_ERROR might throw
            MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " specifies to use a custom notehead font, but no custom font was provided.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "staffSpec"; 
    static const xml::XmlElementArray<Staff>& xmlMappingArray(); 
 
private:
    template <typename NamePositionType>
    MusxInstance<NamePositioning> getNamePosition() const;
 
    template<typename BaselineType>
    Evpu calcBaselinePositionImpl(SystemCmper systemId, std::optional<Cmper> lyricNumber) const;
};
 
class StaffStyle : public Staff
{
protected:
    explicit StaffStyle(const MusxInstance<Staff>& staff)
        : Staff(*staff) {}
 
    void createMasks(const MusxInstance<EnigmaBase>& ptrToSelf)
    {
        masks = std::make_shared<Masks>(ptrToSelf);
    }
 
public:
    explicit StaffStyle(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : Staff(document, partId, shareMode, cmper) {}
 
    class Masks : public ContainedClassBase
    {
    public:
        using ContainedClassBase::ContainedClassBase;
 
        bool floatNoteheadFont{};       
        bool useNoteShapes{};           
        bool flatBeams{};               
        bool blankMeasureRest{};        
        bool noOptimize{};              
        bool notationStyle{};           
        bool defaultClef{};             
        bool staffType{};               
        bool transposition{};           
        bool blineBreak{};              
        bool rbarBreak{};               
        bool negMnumb{};                
        bool negRepeat{};               
        bool negNameScore{};            
        bool hideBarlines{};            
        bool fullName{};                
        bool abrvName{};                
        bool floatKeys{};               
        bool floatTime{};               
        bool hideRptBars{};             
        bool negKey{};                  
        bool negTime{};                 
        bool negClef{};                 
        bool hideStaff{};               
        bool noKey{};                   
        bool fullNamePos{};             
        bool abrvNamePos{};             
        bool altNotation{};             
        bool showTies{};                
        bool showDots{};                
        bool showRests{};               
        bool showStems{};               
        bool hideChords{};              
        bool hideFretboards{};          
        bool hideLyrics{};              
        bool showNameParts{};           
        bool showNoteColors{};          
        bool hideStaffLines{};          
        bool redisplayLayerAccis{};     
        bool negTimeParts{};            
        bool hideKeySigsShowAccis{};    
 
        static const xml::XmlElementArray<Masks>& xmlMappingArray();    
    };
 
    std::string styleName;              
    bool copyable{};                    
    bool addToMenu{};                   
    // No fixture has a part-specific StaffStyle. If partial sharing is observed, both Masks and the
    // inherited Transposition will need part-context rebinding and copy-overlay population.
    // See PartContextRebinder<details::CenterShape> and the CenterShape field mappings for the pattern.
    std::shared_ptr<Masks> masks;       
 
    bool containsInstrumentChange() const;
 
    static MusxInstanceList<StaffStyle> findAllOverlappingStyles(const DocumentPtr& document,
        Cmper partId, StaffCmper staffId, MeasCmper measId, Edu eduPosition);
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        if (!masks) {
            // Finale allows creation of staff styles with no masks, so this is just a verbose comment
            util::Logger::log(util::Logger::LogLevel::Verbose, "StaffStyle " + styleName
                + " (" + std::to_string(getCmper()) + ") does not override anything.");
            createMasks(ptrToThis);
        }
        if (useNoteFont && !masks->floatNoteheadFont && !noteFont) {
            useNoteFont = false; // silence integrity check in Staff.
        }
        Staff::integrityCheck(ptrToThis);
    }
 
    constexpr static std::string_view XmlNodeName = "staffStyle"; 
    static const xml::XmlElementArray<StaffStyle>& xmlMappingArray(); 
};
 
class StaffStyleAssign : public EnigmaMusicRange
{
public:
    explicit StaffStyleAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : EnigmaMusicRange(document, partId, shareMode, cmper, inci) {}
 
    Cmper styleId{};        
 
    MusxInstance<StaffStyle> getStaffStyle() const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        EnigmaMusicRange::integrityCheck(ptrToThis);
        if (!styleId) {
            MUSX_INTEGRITY_ERROR(std::string("Staff style assignment has no staff style id:")
                + " Part " + std::to_string(getSourcePartId())
                + " Staff " + std::to_string(getCmper())
            );
        }
    }
 
    constexpr static std::string_view XmlNodeName = "staffStyleAssign"; 
    static const xml::XmlElementArray<StaffStyleAssign>& xmlMappingArray(); 
};
 
class StaffComposite : public StaffStyle
{
private:
    explicit StaffComposite(const MusxInstance<Staff>& staff, MeasCmper measId, Edu eduPosition)
        : StaffStyle(staff), m_measureId(measId), m_eduPosition(eduPosition) {}
 
    void applyStyle(const MusxInstance<StaffStyle>& staffStyle);
 
    const MeasCmper m_measureId;
    const Edu m_eduPosition;
    bool m_instUuidChanged{};
 
public:
    static MusxInstance<StaffComposite> createCurrent(const DocumentPtr& document, Cmper partId, StaffCmper staffId, MeasCmper measId, Edu eduPosition);
 
    MeasCmper getMeasureId() const { return m_measureId; }
 
    Edu getEduPosition() const { return m_eduPosition; }
 
    bool getInstrumentUuidChanged() const { return m_instUuidChanged; }
 
    ClefIndex calcClefIndex(bool forWrittenPitch = false) const
    { return this->calcClefIndexAt(m_measureId, m_eduPosition, forWrittenPitch); }
 
    MusxInstance<others::Staff> getRawStaff() const;
};
 
} // namespace others
} // namespace dom
} // namespace musx