Details.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 <vector>
#include <unordered_set>
#include <cmath>
 
#include "musx/util/EnigmaString.h"
#include "BaseClasses.h"
#include "CommonClasses.h"
// do not add other dom class dependencies. Use Implementations.h for implementations that need total class access.
 
namespace musx {
namespace dom {
 
class EntryInfoPtr;
class EntryFrame;
class EntryInfo;
 
namespace options {
class TupletOptions;
} // namespace options
 
namespace others {
class Measure;
class MultiStaffInstrumentGroup;
} // namespace others
 
namespace texts {
    class LyricsChorus;
    class LyricsSection;
    class LyricsVerse;
} // namespace others
 
namespace details {
 
class ArticulationAssign : public EntryDetailsBase
{
public:
    explicit ArticulationAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum, Inci inci)
        : EntryDetailsBase(document, partId, shareMode, entnum, inci) {}
 
    Cmper articDef{};               
    Evpu horzOffset{};              
    Evpu horzAdd{};                 
    Evpu vertOffset{};              
    Evpu vertAdd{};                 
    bool overridePlacement{};       
    bool aboveEntry{};              
    bool hide{};                    
    bool neverStack{};              
    bool avoidSlur{};               
    int numSlursAvoided{};          
 
    static const xml::XmlElementArray<ArticulationAssign>& xmlMappingArray();   
    constexpr static std::string_view XmlNodeName = "articAssign"; 
};
 
class Baseline : public DetailsBase
{
public:
    explicit Baseline(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper system, Cmper staff, std::optional<Inci> inci = std::nullopt)
        : DetailsBase(document, partId, shareMode, system, staff, inci) {}
 
    Evpu baselineDisplacement{};    
    Cmper lyricNumber{};            
 
    static const xml::XmlElementArray<Baseline>& xmlMappingArray();   
};
 
class BaselineLyricsChorus : public Baseline
{
public:
    using Baseline::Baseline;
 
 
    using TextType = texts::LyricsChorus; 
    constexpr static std::string_view XmlNodeName = "baselinesLyricsChorus"; 
};
 
class BaselineLyricsSection : public Baseline
{
public:
    using Baseline::Baseline;
 
    using TextType = texts::LyricsSection; 
    constexpr static std::string_view XmlNodeName = "baselinesLyricsSection"; 
};
 
class BaselineLyricsVerse : public Baseline
{
public:
    using Baseline::Baseline;
 
    using TextType = texts::LyricsVerse; 
    constexpr static std::string_view XmlNodeName = "baselinesLyricsVerse"; 
};
 
class BeamStubDirection : public EntryDetailsBase
{
public:
    explicit BeamStubDirection(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum)
        : EntryDetailsBase(document, partId, shareMode, entnum)
    {
    }
 
    unsigned mask{};        
 
    bool isLeft() const { return mask != 0; }
 
    constexpr static std::string_view XmlNodeName = "beamStub"; 
    static const xml::XmlElementArray<BeamStubDirection>& xmlMappingArray(); 
};
 
class ChordAssign : public DetailsBase
{
public:
    explicit ChordAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper inst, Cmper meas, Inci inci)
        : DetailsBase(document, partId, shareMode, inst, meas, inci)
    {
    }
 
    enum class BassPosition
    {
        AfterRoot,                  // default value may not appear in xml (but text appears in Finale binary)
        UnderRoot,
        Subtext
    };
    
    Cmper suffixId{};               
    Cmper fbStyleId{};              
    int rootScaleNum{};             
    int rootAlter{};                
    bool rootLowerCase{};           
    bool playSuffix{};              
    bool showRoot{};                
    bool playRoot{};                
    bool showFretboard{};           
    bool showSuffix{};              
    bool playFretboard{};           
    int bassScaleNum{};             
    int bassAlter{};                
    bool bassLowerCase{};           
    BassPosition bassPosition{};    
    bool showAltBass{};             
    bool playAltBass{};             
    int capoValue{};                
    bool useLocalCapo{};            
    Cmper fretInci{};               
    bool useFretFont{};             
    Evpu horzOff{};                 
    Evpu vertOff{};                 
    Evpu fbHorzOff{};               
    Evpu fbVertOff{};               
    Edu horzEdu{};                  
    int chPercent{};                
    int fbPercent{};                
 
    constexpr static std::string_view XmlNodeName = "chordAssign"; 
    static const xml::XmlElementArray<ChordAssign>& xmlMappingArray(); 
};
 
class CrossStaff : public NoteDetailsBase
{
public:
    explicit CrossStaff(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum, Inci inci)
        : NoteDetailsBase(document, partId, shareMode, entnum, inci)
    {
    }
 
    NoteNumber noteId{};    
    InstCmper staff{};      
 
    NoteNumber getNoteId() const override { return noteId; }
 
    constexpr static std::string_view XmlNodeName = "crossStaff";    
    static const xml::XmlElementArray<CrossStaff>& xmlMappingArray();   
};
 
class GFrameHold : public DetailsBase
{
public:
    explicit GFrameHold(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper inst, Cmper meas)
        : DetailsBase(document, partId, shareMode, inst, meas), frames(MAX_LAYERS) {}
 
    // Public properties corresponding to the XML structure
    std::optional<ClefIndex> clefId;        
    Cmper clefListId{};                     
    ShowClefMode showClefMode{};            
    bool mirrorFrame{};                     
    int clefPercent{};                      
    std::vector<Cmper> frames;              
 
    InstCmper getStaff() const { return InstCmper(getCmper1()); }
 
    MeasCmper getMeasure() const { return MeasCmper(getCmper2()); }
 
    ClefIndex calcClefIndexAt(Edu position) const;
 
    ClefIndex calcClefIndexAt(util::Fraction position) const
    { return calcClefIndexAt(position.calcEduDuration()); }
 
    std::shared_ptr<const EntryFrame> createEntryFrame(LayerIndex layerIndex, bool forWrittenPitch = false) const;
    
    bool iterateEntries(LayerIndex layerIndex, std::function<bool(const EntryInfoPtr&)> iterator);
 
    bool iterateEntries(std::function<bool(const EntryInfoPtr&)> iterator);
 
    void integrityCheck() override
    {
        this->DetailsBase::integrityCheck();
        if (clefListId && clefId.has_value()) {
            MUSX_INTEGRITY_ERROR("GFrameHold for staff " + std::to_string(getCmper1()) + " and measure " + std::to_string(getCmper2()) + " has both clef and clef list.");
        }
        if (!clefListId && !clefId.has_value()) {
            MUSX_INTEGRITY_ERROR("GFrameHold for staff " + std::to_string(getCmper1()) + " and measure " + std::to_string(getCmper2()) + " has neither clef nor clef list.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "gfhold"; 
    static const xml::XmlElementArray<GFrameHold>& xmlMappingArray(); 
};
 
class IndependentStaffDetails : public DetailsBase
{
public:
    explicit IndependentStaffDetails(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper inst, Cmper meas)
        : DetailsBase(document, partId, shareMode, inst, meas)
    {
    }
 
    // Key signature info
    std::shared_ptr<KeySignature> keySig; 
    bool hasKey{};                        
 
    // Time signature info
    Cmper beats{};                      
    Cmper divBeat{};                    
    Cmper dispBeats{};                  
    Cmper dispDivBeat{};                
 
    bool displayAltNumTsig{};           
    bool displayAltDenTsig{};           
    bool altNumTsig{};                  
    bool altDenTsig{};                  
    bool displayAbbrvTime{};            
    bool hasDispTime{};                 
    bool hasTime{};                     
 
    std::shared_ptr<TimeSignature> createTimeSignature() const;
 
    std::shared_ptr<TimeSignature> createDisplayTimeSignature() const;
 
    void integrityCheck() override
    {
        DetailsBase::integrityCheck();
        if (hasKey && !keySig) {
            keySig = std::make_shared<KeySignature>(getDocument());
        }
    }
 
    constexpr static std::string_view XmlNodeName = "floats"; 
    static const xml::XmlElementArray<IndependentStaffDetails>& xmlMappingArray(); 
};
 
class LyricAssign : public EntryDetailsBase
{
public:
    explicit LyricAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum, Inci inci)
        : EntryDetailsBase(document, partId, shareMode, entnum, inci) {}
 
    Cmper lyricNumber{};            
    unsigned syllable{};            
    Evpu horzOffset{};              
    Evpu vertOffset{};              
    Evpu floatingHorzOff{};         
    int wext{};                     
    bool displayVerseNum{};         
 
    static const xml::XmlElementArray<LyricAssign>& xmlMappingArray();   
};
 
class LyricAssignChorus : public LyricAssign
{
public:
    using LyricAssign::LyricAssign;
 
    using TextType = texts::LyricsChorus; 
    constexpr static std::string_view XmlNodeName = "lyrDataChorus"; 
};
 
class LyricAssignSection : public LyricAssign
{
public:
    using LyricAssign::LyricAssign;
 
    using TextType = texts::LyricsSection; 
    constexpr static std::string_view XmlNodeName = "lyrDataSection"; 
};
 
class LyricAssignVerse : public LyricAssign
{
public:
    using LyricAssign::LyricAssign;
 
    using TextType = texts::LyricsVerse; 
    constexpr static std::string_view XmlNodeName = "lyrDataVerse"; 
};
 
class SecondaryBeamBreak : public EntryDetailsBase
{
public:
    explicit SecondaryBeamBreak(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum)
        : EntryDetailsBase(document, partId, shareMode, entnum)
    {
    }
 
    unsigned mask{};        
    bool breakThrough{};    
 
    BeamNumber calcLowestBreak() const
    {
        MUSX_ASSERT_IF(!mask || mask >= unsigned(NoteType::Eighth)) {
            return 0; // invalid mask values have already been flagged and supposedly corrected by #integrityCheck.
        }
        for (unsigned shift = 0; true; shift++) {
            if (mask & (unsigned(NoteType::Note16th) >> shift)) {
                return shift + 2; // the 2nd beam is the 16th beam and the first one we checked.
            }
        }
        assert(false); // should not be able to get here
        return 0;
    }
 
    void integrityCheck() override
    {
        EntryDetailsBase::integrityCheck();
        if (!mask) {
            mask = unsigned(NoteType::Note4096th);
            MUSX_INTEGRITY_ERROR("Secondary beam break for entry" + std::to_string(getEntryNumber()) + " has no breaks.");
        }
        if (mask >= unsigned(NoteType::Eighth)) {
            mask = unsigned(NoteType::Eighth) - 1;
            MUSX_INTEGRITY_ERROR("Secondary beam break for entry" + std::to_string(getEntryNumber()) + " specifies a value that cannot be a secondary beam.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "secBeamBreak"; 
    static const xml::XmlElementArray<SecondaryBeamBreak>& xmlMappingArray(); 
};
    
class StaffGroup : public DetailsBase {
public:
    StaffGroup(const DocumentWeakPtr& document, Cmper partId, Base::ShareMode shareMode, Cmper cmper1, Cmper cmper2)
        : DetailsBase(document, partId, shareMode, cmper1, cmper2) {}
 
    using BarlineType = others::Measure::BarlineType;
 
    using AlignJustify = others::NamePositioning::AlignJustify;
 
    enum class DrawBarlineStyle
    {
        OnlyOnStaves,       
        ThroughStaves,      
        Mensurstriche       
    };
 
    enum class HideStaves
    {
        Normally,       
        AsGroup,        
        None            
    };
 
    enum class BracketStyle : int
    {
        None = 0,                   
        ThickLine = 1,              
        BracketStraightHooks = 2,   
        PianoBrace = 3,             
        Unknown4,                   
        Unknown5,                   
        BracketCurvedHooks = 6,     
        Unknown7,                   
        DeskBracket = 8             
    };
 
    class Bracket
    {
    public:
        BracketStyle style{};       
        Evpu horzAdjLeft{};         
        Evpu vertAdjTop{};          
        Evpu vertAdjBot{};          
        bool showOnSingleStaff{};   
 
        Bracket() = default;
 
        static const xml::XmlElementArray<Bracket>& xmlMappingArray(); 
    };
 
    // Public properties corresponding to the XML structure, ordered as they appear in the XML
    InstCmper startInst{};                    
    InstCmper endInst{};                      
    MeasCmper startMeas{};                    
    MeasCmper endMeas{};                      
    Cmper fullNameId{};                       
    int fullNameXadj{};                       
    int fullNameYadj{};                       
    std::shared_ptr<Bracket> bracket{};       
    BarlineType barlineType{};                
    AlignJustify fullNameJustify{};           
    AlignJustify abbrvNameJustify{};          
    DrawBarlineStyle drawBarlines;            
    bool ownBarline{};                        
    bool fullNameIndivPos{};                  
    bool abbrvNameIndivPos{};                 
    bool hideName{};                          
    Cmper abbrvNameId{};                      
    int abbrvNameXadj{};                      
    int abbrvNameYadj{};                      
    AlignJustify fullNameAlign{};             
    AlignJustify abbrvNameAlign{};            
    bool fullNameExpand{};                    
    bool abbrvNameExpand{};                   
    HideStaves hideStaves{};                  
 
    Cmper multiStaffGroupId{};      
    std::unordered_set<InstCmper> staves; 
 
    std::string getFullName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    std::string getAbbreviatedName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    std::shared_ptr<others::MultiStaffInstrumentGroup> getMultiStaffInstGroup() const;
 
    std::string getFullInstrumentName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    std::string getAbbreviatedInstrumentName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    bool isAllMeasures() const
    { return (startMeas == 1 && endMeas == (std::numeric_limits<MeasCmper>::max)()); }
 
    void integrityCheck() override
    {
        this->DetailsBase::integrityCheck();
        if (endMeas <= startMeas || startMeas <= 0) {
            MUSX_INTEGRITY_ERROR("Staff group " + std::to_string(getCmper2()) + " for part " + std::to_string(getPartId())
                + " starts at measure " + std::to_string(startMeas) + " and ends at measure " + std::to_string(endMeas));
        }
        if (!bracket) {
            // this is not an error. Finale omits the bracket node for groups with entirely default bracket info.
            bracket = std::make_shared<Bracket>();
        }
    }
 
    constexpr static std::string_view XmlNodeName = "staffGroup"; 
    static const xml::XmlElementArray<StaffGroup>& xmlMappingArray(); 
};
 
class TieAlterBase : public NoteDetailsBase
{
public:
    explicit TieAlterBase(const DocumentWeakPtr& document, Cmper partId, Base::ShareMode shareMode, EntryNumber entnum, Inci inci)
        : NoteDetailsBase(document, partId, shareMode, entnum, inci)
    {
    }
 
    NoteNumber noteId{};                   
    Evpu xStart{};                         
    Evpu xEnd{};                           
    Evpu yStart{};                         
    Evpu yEnd{};                           
    bool outerLocal{};                     
    bool afterSingleDotLocal{};            
    bool afterSingleDotOn{};               
    bool afterMultiDotsLocal{};            
    bool afterMultiDotsOn{};               
    bool shiftForSecondsLocal{};           
    bool shiftForSecondsOn{};              
    bool beforeSingleAcciLocal{};          
    bool beforeSingleAcciOn{};             
    bool down{};                           
    bool breakTimeLocal{};                 
    bool breakTimeOn{};                    
    bool breakKeyLocal{};                  
    bool breakKeyOn{};                     
    bool freezeDirection{};                
    bool stPtAdjOn{};                      
    bool enPtAdjOn{};                      
    Evpu insetRatio1{};                    
    Evpu height1{};                        
    Evpu insetRatio2{};                    
    Evpu height2{};                        
    bool ctlPtAdjOn{};                     
 
    NoteNumber getNoteId() const override { return noteId; }
 
    bool requireAllFields() const override { return false; } 
    static const xml::XmlElementArray<TieAlterBase>& xmlMappingArray(); 
};
 
class TieAlterEnd : public TieAlterBase
{
public:
    using TieAlterBase::TieAlterBase;
 
    constexpr static std::string_view XmlNodeName = "tieAlterEnd"; 
    static const xml::XmlElementArray<TieAlterEnd>& xmlMappingArray(); 
};
 
class TieAlterStart : public TieAlterBase
{
public:
    using TieAlterBase::TieAlterBase;
 
    constexpr static std::string_view XmlNodeName = "tieAlterStart"; 
    static const xml::XmlElementArray<TieAlterStart>& xmlMappingArray(); 
};
    
class TupletDef : public EntryDetailsBase
{
public:
    explicit TupletDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum, Inci inci)
        : EntryDetailsBase(document, partId, shareMode, entnum, inci)
    {
    }
 
    using AutoBracketStyle = options::TupletOptions::AutoBracketStyle;
    using NumberStyle = options::TupletOptions::NumberStyle;
    using PositioningStyle = options::TupletOptions::PositioningStyle;
    using BracketStyle = options::TupletOptions::BracketStyle;
 
    int displayNumber{};                    
    Edu displayDuration{};                  
    int referenceNumber{};                  
    Edu referenceDuration{};                
    bool alwaysFlat{};                      
    bool fullDura{};                        
    bool metricCenter{};                    
    bool avoidStaff{};                      
    AutoBracketStyle autoBracketStyle{};    
    bool hidden{};                          
    Evpu tupOffX{};                         
    Evpu tupOffY{};                         
    Evpu brackOffX{};                       
    Evpu brackOffY{};                       
    NumberStyle numStyle{};                 
    PositioningStyle posStyle{};            
    bool allowHorz{};                       
    bool ignoreHorzNumOffset{};             
    bool breakBracket{};                    
    bool matchHooks{};                      
    bool useBottomNote{};                   
    BracketStyle brackStyle{};              
    bool smartTuplet{};                     
    Evpu leftHookLen{};                     
    Evpu leftHookExt{};                     
    Evpu rightHookLen{};                    
    Evpu rightHookExt{};                    
    Evpu manualSlopeAdj{};                  
 
    util::Fraction calcReferenceDuration() const { return util::Fraction(referenceNumber * referenceDuration, Edu(NoteType::Whole)); }
 
    util::Fraction calcDisplayDuration() const { return util::Fraction(displayNumber * displayDuration, Edu(NoteType::Whole)); }
 
    util::Fraction calcRatio() const { return util::Fraction(referenceNumber * referenceDuration, displayNumber * displayDuration); }
        
    constexpr static std::string_view XmlNodeName = "tupletDef";    
    static const xml::XmlElementArray<TupletDef>& xmlMappingArray();   
};
 
} // namespace details
} // namespace dom
} // namespace entries