Entries.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 <tuple>
#include <map>
 
#include "musx/util/Fraction.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 music_theory {
enum class NoteName : int;
class Transposer;
} // namespace music_theory
    
namespace musx {
namespace dom {
 
namespace others {
class Frame;
class PercussionNoteInfo;
class Staff;
class StaffComposite;
} // namespace others
 
namespace details {
class TupletDef;
class GFrameHold;
 
class GFrameHoldContext {
public:
    GFrameHoldContext(const DocumentPtr& document, Cmper partId, Cmper staffId, Cmper meas);
 
    Cmper getRequestedPartId() const { return m_requestedPartId; }
 
    const GFrameHold* operator->() const { return m_hold.get(); }
 
    explicit operator bool() const { return static_cast<bool>(m_hold); }
 
    ClefIndex calcClefIndexAt(Edu position) const;
 
    ClefIndex calcClefIndexAt(util::Fraction position) const
    { return calcClefIndexAt(position.calcEduDuration()); }
 
    std::shared_ptr<const EntryFrame> createEntryFrame(LayerIndex layerIndex) const;
    
    bool iterateEntries(LayerIndex layerIndex, std::function<bool(const EntryInfoPtr&)> iterator);
 
    bool iterateEntries(std::function<bool(const EntryInfoPtr&)> iterator);
 
    std::map<LayerIndex, bool> calcVoices() const;
 
    bool calcIsCuesOnly(bool includeVisibleInScore = false) const;
 
private:
    std::pair<MusxInstance<others::Frame>, Edu> findLayerFrame(LayerIndex layerIndex) const;
 
    MusxInstance<GFrameHold> m_hold;      
    Cmper m_requestedPartId;                 
};
 
} // namespace details
 
std::pair<NoteType, unsigned> calcNoteInfoFromEdu(Edu duration);
 
unsigned calcNumberOfBeamsInEdu(Edu duration);
 
class Note : public Base
{
public:
    explicit Note(const DocumentWeakPtr& document, NoteNumber noteId)
        : Base(document, 0, ShareMode::All), m_noteId(noteId)
    {
    }
 
    static constexpr NoteNumber RESTID = 31;
 
    using NoteProperties = std::tuple<music_theory::NoteName, int, int, int>;
    
    int harmLev{};      
    int harmAlt{};      
    bool isValid{};     
    bool crossStaff{};  
    bool tieStart{};    
    bool tieEnd{};      
    bool upStemSecond{}; 
    bool downStemSecond{}; 
    bool upSplitStem{}; 
    bool showAcci{};    
    bool parenAcci{};   
    bool freezeAcci{};  
 
    NoteNumber getNoteId() const { return m_noteId; }
 
    std::pair<int, int> calcDefaultEnharmonic(const MusxInstance<KeySignature>& key) const;
 
    NoteProperties calcNoteProperties(const MusxInstance<KeySignature>& key, KeySignature::KeyContext ctx, ClefIndex clefIndex,
        const MusxInstance<others::Staff>& staff = nullptr, bool respellEnharmonic = false) const;
 
    bool requireAllFields() const override { return false; }
 
    static const xml::XmlElementArray<Note>& xmlMappingArray(); 
 
private:
    NoteNumber m_noteId{}; 
};
 
class Entry : public Base
{
public:
    explicit Entry(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum, EntryNumber prev, EntryNumber next)
        : Base(document, partId, shareMode), m_entnum(entnum), m_prev(prev), m_next(next)
    {
    }
 
    Edu duration{};
    int numNotes{};          
    Evpu hOffset{};          
    bool isValid{};          
    bool isNote{};           
    bool graceNote{};        
    bool floatRest{};        
    bool isHidden{};         
    bool voice2{};           
    bool articDetail{};      
    bool noteDetail{};       
    bool dotTieAlt{};        
    bool tupletStart{};      
    bool beamExt{};          
    bool beam{};             
    bool secBeam{};          
    bool doubleStem{};       
    bool splitStem{};        
    bool crossStaff{};       
    bool freezeStem{};       
    bool upStem{};           
    bool noLeger{};          
    bool stemDetail{};       
    bool reverseUpStem{};    
    bool reverseDownStem{};  
    bool slashGrace{};       
    bool smartShapeDetail{}; 
    bool sorted{};           
    bool noPlayback{};       
    bool lyricDetail{};      
    bool performanceData{};  
    bool freezeBeam{};       
 
    std::vector<std::shared_ptr<Note>> notes;
 
    EntryNumber getEntryNumber() const { return m_entnum; }
 
    MusxInstance<Entry> getNext() const;
 
    MusxInstance<Entry> getPrevious() const;
 
    std::pair<NoteType, unsigned> calcNoteInfo() const { return calcNoteInfoFromEdu(duration); }
 
    util::Fraction calcFraction() const { return util::Fraction::fromEdu(duration); }
 
    bool hasStem() const { return duration < Edu(NoteType::Whole); }
 
    bool isPossibleFullMeasureRest() const
    { return !isNote && !isHidden && !voice2 && duration == Edu(NoteType::Whole); }
 
    void integrityCheck(const std::shared_ptr<Base>& ptrToThis) override
    {
        this->Base::integrityCheck(ptrToThis);
        if (size_t(numNotes) != notes.size()) {
            MUSX_INTEGRITY_ERROR("Entry " + std::to_string(m_entnum) + " has an incorrect number of notes.");
        }
    }
 
    bool requireAllFields() const override { return false; }
 
    constexpr static std::string_view XmlNodeName = "entry"; 
    static const xml::XmlElementArray<Entry>& xmlMappingArray(); 
 
private:    
    EntryNumber m_entnum;   
    EntryNumber m_prev;     
    EntryNumber m_next;     
    
};
 
class EntryInfo;
class EntryFrame;
class NoteInfoPtr;
 
class EntryInfoPtr
{
public:
    EntryInfoPtr() : m_entryFrame(nullptr), m_indexInFrame(0) {}
        
    explicit EntryInfoPtr(const std::shared_ptr<const EntryFrame>& entryFrame, size_t index = 0)
        : m_entryFrame(entryFrame), m_indexInFrame(index) {}
 
    static EntryInfoPtr fromPositionOrNull(const DocumentPtr& document, Cmper partId, StaffCmper staffId, MeasCmper measureId, EntryNumber entryNumber);
 
    const std::shared_ptr<const EntryInfo> operator->() const;
 
    operator bool() const;
 
    bool isSameEntry(const EntryInfoPtr& src) const;
 
    std::shared_ptr<const EntryFrame> getFrame() const { return m_entryFrame; }
 
    size_t getIndexInFrame() const { return m_indexInFrame; }
 
    LayerIndex getLayerIndex() const;
 
    StaffCmper getStaff() const;
 
    MusxInstance<others::StaffComposite> createCurrentStaff(const std::optional<StaffCmper>& forStaffId = std::nullopt) const;
 
    MeasCmper getMeasure() const;
 
    MusxInstance<KeySignature> getKeySignature() const;
 
    unsigned calcReverseGraceIndex() const;
 
    std::optional<size_t> calcNextTupletIndex(std::optional<size_t> currentIndex) const;
 
    EntryInfoPtr getNextInFrame() const;
 
    EntryInfoPtr getNextInLayer() const;
 
    EntryInfoPtr getNextSameV() const;
 
    EntryInfoPtr getPreviousInLayer() const;
 
    EntryInfoPtr getPreviousInFrame() const;
 
    EntryInfoPtr getPreviousSameV() const;
 
    EntryInfoPtr getNextInVoice(int voice) const;
 
    EntryInfoPtr getPreviousInVoice(int voice) const;
 
    EntryInfoPtr getNextInBeamGroup(bool includeHiddenEntries = false) const
    { return iterateBeamGroup<&EntryInfoPtr::nextPotentialInBeam, &EntryInfoPtr::previousPotentialInBeam>(includeHiddenEntries); }
 
    EntryInfoPtr getPreviousInBeamGroup(bool includeHiddenEntries = false) const
    { return iterateBeamGroup<&EntryInfoPtr::previousPotentialInBeam, &EntryInfoPtr::nextPotentialInBeam>(includeHiddenEntries); }
 
    bool calcDisplaysAsRest() const;
 
    bool calcUnbeamed() const;
 
    bool calcIsBeamStart() const;
 
    bool calcIsFeatheredBeamStart(Evpu& outLeftY, Evpu& outRightY) const;
 
    EntryInfoPtr findBeamStartOrCurrent() const;
 
    EntryInfoPtr findBeamEnd() const;
 
    unsigned calcNumberOfBeams() const;
 
    unsigned calcLowestBeamStart() const;
 
    unsigned calcLowestBeamEnd() const;
 
    unsigned calcLowestBeamStub() const;
 
    bool calcBeamStubIsLeft() const;
 
    util::Fraction calcGlobalElapsedDuration() const;
 
    util::Fraction calcGlobalActualDuration() const;
 
    bool canBeBeamed() const;
 
    int calcEntrySize() const;
 
    bool calcIsCue(bool includeVisibleInScore = false) const;
 
    bool calcIsFullMeasureRest() const;
 
    bool calcIsBeamedRestWorkaroud() const;
 
    bool operator<(const EntryInfoPtr& other) const
    {
        if (m_entryFrame != other.m_entryFrame)
            return m_entryFrame < other.m_entryFrame;
        return m_indexInFrame < other.m_indexInFrame;
    }
 
private:
    unsigned calcVisibleBeams() const;
 
    template<EntryInfoPtr(EntryInfoPtr::* Iterator)() const>
    std::optional<unsigned> iterateFindRestsInSecondaryBeam(const EntryInfoPtr nextOrPrevInBeam) const;
 
    template<EntryInfoPtr(EntryInfoPtr::* Iterator)() const>
    EntryInfoPtr iteratePotentialEntryInBeam() const;
 
    template<EntryInfoPtr(EntryInfoPtr::* Iterator)() const>
    bool iterateNotesExistLeftOrRight() const;
 
    EntryInfoPtr nextPotentialInBeam(bool includeHiddenEntries) const;
 
    EntryInfoPtr previousPotentialInBeam(bool includeHiddenEntries) const;
 
    template<EntryInfoPtr(EntryInfoPtr::* Iterator)(bool) const, EntryInfoPtr(EntryInfoPtr::* ReverseIterator)(bool) const>
    EntryInfoPtr iterateBeamGroup(bool includeHiddenEntries) const;
 
    std::shared_ptr<const EntryFrame> m_entryFrame;
    size_t m_indexInFrame{};              
};
 
class EntryFrame : public std::enable_shared_from_this<EntryFrame>
{
public:
    explicit EntryFrame(const details::GFrameHoldContext& gfhold, LayerIndex layerIndex, util::Fraction timeStretch) :
        m_context(gfhold),
        m_layerIndex(layerIndex),
        m_timeStretch(timeStretch)
    {
    }
 
    struct TupletInfo
    {
        MusxInstance<details::TupletDef> tuplet;  
        size_t startIndex;                              
        size_t endIndex;                                
        util::Fraction startDura;                       
        util::Fraction endDura;                         
        bool voice2;                                    
 
        TupletInfo(const std::weak_ptr<const EntryFrame>& parent, const MusxInstance<details::TupletDef>& tup, size_t index, util::Fraction start, bool forVoice2)
            : tuplet(tup), startIndex(index), endIndex((std::numeric_limits<size_t>::max)()),
                startDura(start), endDura(-1), voice2(forVoice2), m_parent(parent)
        {}
 
        bool calcIsTremolo() const;
 
        bool calcCreatesSingletonRight() const { return calcCreatesSingleton(false); }
 
        bool calcCreatesSingletonLeft() const { return calcCreatesSingleton(true); }
 
        bool calcCreatesBeamContinuationRight() const;
 
        bool calcCreatesBeamContinuationLeft() const;
 
        //      - the independent display time signature matches the tuplet's total display duration
        bool calcCreatesTimeStretch() const;
 
    private:
        bool calcCreatesSingleton(bool left) const;
 
        const std::shared_ptr<const EntryFrame> getParent() const
        {
            auto result = m_parent.lock();
            MUSX_ASSERT_IF(!result) {
                throw std::logic_error("Unable to obtain lock on parent entry frame.");               
            }
            return result;
        }
 
        const std::weak_ptr<const EntryFrame> m_parent;
    };
 
    std::vector<TupletInfo> tupletInfo;
    MusxInstance<KeySignature> keySignature; 
 
    DocumentPtr getDocument() const;
 
    Cmper getRequestedPartId() const { return m_context.getRequestedPartId(); }
 
    StaffCmper getStaff() const;
 
    MeasCmper getMeasure() const;
 
    LayerIndex getLayerIndex() const { return m_layerIndex; }
 
    util::Fraction getTimeStretch() const { return m_timeStretch; }
 
    const std::vector<std::shared_ptr<const EntryInfo>>& getEntries() const
    { return m_entries; }
 
    EntryInfoPtr getFirstInVoice(int voice) const;
 
    EntryInfoPtr getLastInVoice(int voice) const;
 
    void addEntry(const std::shared_ptr<const EntryInfo>& entry)
    { m_entries.emplace_back(entry); }
 
    std::shared_ptr<const EntryFrame> getNext() const;
 
    std::shared_ptr<const EntryFrame> getPrevious() const;
    
    MusxInstance<others::StaffComposite> createCurrentStaff(Edu eduPosition, const std::optional<StaffCmper>& forStaffId = std::nullopt) const;
 
    MusxInstance<others::Measure> getMeasureInstance() const;
 
    bool calcIsCueFrame(bool includeVisibleInScore = false) const;
 
private:
    details::GFrameHoldContext m_context;
    LayerIndex m_layerIndex;
    util::Fraction m_timeStretch;
 
    std::vector<std::shared_ptr<const EntryInfo>> m_entries;
};
 
namespace details {
class GFrameHold;
} // namespace details
 
class EntryInfo
{
    explicit EntryInfo(const MusxInstance<Entry>& entry)
        : m_entry(entry) {}
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    friend details::GFrameHoldContext;
#endif
 
public:
    util::Fraction elapsedDuration{};   
    util::Fraction actualDuration{};    
    bool v2Launch{};                    
    unsigned graceIndex{};              
    ClefIndex clefIndex{};              
    ClefIndex clefIndexConcert{};       
 
    MusxInstance<Entry> getEntry() const
    {
        auto retval = m_entry.lock();
        if (!retval) {
            throw std::logic_error("Entry pointer is no longer valid");
        }
        return retval;
    }
 
    util::Fraction calcNextElapsedDuration() const
    { return elapsedDuration + actualDuration; }
 
private:
    MusxInstanceWeak<Entry> m_entry;
};
 
class NoteInfoPtr
{
public:
    NoteInfoPtr() : m_entry(), m_noteIndex(0) {}
 
    NoteInfoPtr(const EntryInfoPtr& entryInfo, size_t noteIndex)
        : m_entry(entryInfo), m_noteIndex(noteIndex)
    {}
 
    operator bool() const
    { return m_entry && m_noteIndex < m_entry->getEntry()->notes.size(); }
 
    bool isSameNote(const NoteInfoPtr& src) const
    { return m_entry.isSameEntry(src.m_entry) && m_noteIndex == src.m_noteIndex; }
 
    NoteInfoPtr findEqualPitch(const EntryInfoPtr& entry) const;
 
    MusxInstance<Note> operator->() const
    {
        MUSX_ASSERT_IF(m_noteIndex >= m_entry->getEntry()->notes.size()) {
            throw std::logic_error("Note index is too large for notes array.");
        }
        return m_entry->getEntry()->notes[m_noteIndex];
    }
 
    EntryInfoPtr getEntryInfo() const
    { return m_entry; }
 
    Note::NoteProperties calcNoteProperties(const std::optional<bool>& enharmonicRespell = std::nullopt) const;
 
    Note::NoteProperties calcNotePropertiesConcert() const;
 
    Note::NoteProperties calcNotePropertiesInView() const;
 
    MusxInstance<others::PercussionNoteInfo> calcPercussionNoteInfo() const;
 
    NoteInfoPtr calcTieTo() const;
 
    NoteInfoPtr calcTieFrom(bool requireTie = true) const;
 
    StaffCmper calcStaff() const;
 
    std::unique_ptr<music_theory::Transposer> createTransposer() const;
 
    NoteInfoPtr getNext() const
    {
        if (m_noteIndex >= m_entry->getEntry()->notes.size()) {
            return NoteInfoPtr();
        }
        return NoteInfoPtr(m_entry, m_noteIndex + 1);
    }
 
    NoteInfoPtr getPrevious() const
    {
        if (m_noteIndex <= 0) {
            return NoteInfoPtr();
        }
        return NoteInfoPtr(m_entry, m_noteIndex - 1);
    }
 
    bool calcIsEnharmonicRespell() const;
 
    std::pair<int, int> calcDefaultEnharmonic() const
    { return (*this)->calcDefaultEnharmonic(m_entry.getKeySignature()); }
 
    bool operator<(const NoteInfoPtr& other) const
    {
        if (m_entry != other.m_entry)
            return m_entry < other.m_entry;
        return m_noteIndex < other.m_noteIndex;
    }
 
private:
    bool isSamePitch(const NoteInfoPtr& src) const;
 
    bool isSamePitchValues(const NoteInfoPtr& src) const;
 
    EntryInfoPtr m_entry;
    size_t m_noteIndex;
};
 
} // namespace dom
} // namespace entries