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 "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 {
    class Transposer;
} // namespace music_theory
    
namespace musx {
namespace dom {
 
namespace others {
class PercussionNoteInfo;
class Staff;
class StaffComposite;
} // namespace others
 
namespace details {
class TupletDef;
class GFrameHoldContext;
} // 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;
 
    enum class NoteName : int
    {
        C = 0,
        D = 1,
        E = 2,
        F = 3,
        G = 4,
        A = 5,
        B = 6
    };
    
    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 std::shared_ptr<KeySignature>& key) const;
 
    std::tuple<NoteName, int, int, int> calcNoteProperties(const std::shared_ptr<KeySignature>& key, ClefIndex clefIndex,
        const std::shared_ptr<const 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 smartShapeDetail{}; 
    bool sorted{};           
    bool noPlayback{};       
    bool lyricDetail{};      
    bool performanceData{};  
    bool freezeBeam{};       
 
    std::vector<std::shared_ptr<Note>> notes;
 
    EntryNumber getEntryNumber() const { return m_entnum; }
 
    std::shared_ptr<Entry> getNext() const;
 
    std::shared_ptr<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); }
 
    void integrityCheck() override
    {
        this->Base::integrityCheck();
        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) {}
    
    EntryInfoPtr(const std::shared_ptr<const EntryFrame>& entryFrame, size_t index = 0)
        : m_entryFrame(entryFrame), m_indexInFrame(index) {}
 
    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;
 
    InstCmper getStaff() const;
 
    MeasCmper getMeasure() const;
 
    std::shared_ptr<others::StaffComposite> createCurrentStaff(const std::optional<InstCmper>& forStaffId = std::nullopt) const;
 
    std::shared_ptr<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 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;
 
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, InstCmper staff, MeasCmper measure, LayerIndex layerIndex,
        bool forWrittenPitch, util::Fraction timeStretch);
 
    struct TupletInfo
    {
        std::shared_ptr<const 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 std::shared_ptr<const 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;
 
    private:
        bool calcCreatesSingleton(bool left) const;
 
        const std::weak_ptr<const EntryFrame> m_parent;
    };
 
    std::vector<TupletInfo> tupletInfo;
    std::shared_ptr<KeySignature> keySignature; 
 
    DocumentPtr getDocument() const { return m_document; }
 
    Cmper getRequestedPartId() const { return m_requestedPartId; }
 
    InstCmper getStaff() const { return m_staff; }
 
    MeasCmper getMeasure() const { return m_measure; }
 
    LayerIndex getLayerIndex() const { return m_layerIndex; }
 
    bool isForWrittenPitch() const { return m_forWrittenPitch; }
 
    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;
 
private:
    DocumentPtr m_document;
    Cmper m_requestedPartId;
    InstCmper m_staff;
    MeasCmper m_measure;
    LayerIndex m_layerIndex;
    bool m_forWrittenPitch;
    util::Fraction m_timeStretch;
 
    std::vector<std::shared_ptr<const EntryInfo>> m_entries;
};
 
namespace details {
class GFrameHold;
} // namespace details
 
class EntryInfo
{
    explicit EntryInfo(const std::shared_ptr<const 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{};              
 
    std::shared_ptr<const Entry> getEntry() const
    {
        auto retval = m_entry.lock();
        if (!retval) {
            throw std::logic_error("Entry pointer is no longer valid");
        }
        return retval;
    }
 
private:
    std::weak_ptr<const 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;
 
    std::shared_ptr<const 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; }
 
    std::tuple<Note::NoteName, int, int, int> calcNoteProperties(const std::optional<bool>& enharmonicRespell = std::nullopt) const;
 
    std::shared_ptr<others::PercussionNoteInfo> calcPercussionNoteInfo() const;
 
    NoteInfoPtr calcTieTo() const;
 
    NoteInfoPtr calcTieFrom() const;
 
    InstCmper 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);
    }
 
private:
    bool isSamePitchValues(const NoteInfoPtr& src) const
    {
        if (!*this || !src) {
            return false;
        }
        return (*this)->harmLev == src->harmLev
            && (*this)->harmAlt == src->harmAlt;
    }
 
    EntryInfoPtr m_entry;
    size_t m_noteIndex;
};
 
} // namespace dom
} // namespace entries