Sequence.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 "BaseTypes.h"
#include "ContentArray.h"
#include "CommonClasses.h"
#include "Enumerations.h"
#include "EventMarkings.h"
 
namespace mnx {
class Sequence; // forward declaration
 
namespace sequence {
class Event;
class Grace;
class MultiNoteTremolo;
class Space;
class Tuplet;
 
class SequenceContentObject : public ContentObject<SequenceContentObject>
{
public:
    using ContentObject::ContentObject;
    std::string_view defaultType() const override { return "event"; }
};
 
class SequenceContent : public ContentArray<SequenceContentObject>
{
public:
    using ContentArray<SequenceContentObject>::ContentArray;
 
    Event appendEvent(NoteValueBase base, unsigned dots = 0);
    Grace appendGrace();
    MultiNoteTremolo appendMultiNoteTremolo(int numberOfMarks, const NoteValueQuantity::Required& noteValueQuant);
    Space appendSpace(const FractionValue& duration);
    Tuplet appendTuplet(const NoteValueQuantity::Required& innerNoteValueQuant,
        const NoteValueQuantity::Required& outerNoteValueQuant);
};
 
class AccidentalEnclosure : public Object
{
public:
    struct Required
    {
        AccidentalEnclosureSymbol symbol{}; 
    };
 
    AccidentalEnclosure(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    AccidentalEnclosure(Base& parent, std::string_view key, AccidentalEnclosureSymbol symbol)
        : Object(parent, key)
    {
        set_symbol(symbol);
    }
 
    operator Required() const { return { symbol() }; }
 
    static Required make(AccidentalEnclosureSymbol symbol) { return { symbol }; }
 
    MNX_REQUIRED_PROPERTY(AccidentalEnclosureSymbol, symbol);      
};
 
class AccidentalDisplay : public Object
{
public:
    struct Required
    {
        bool show{}; 
    };
 
    AccidentalDisplay(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    AccidentalDisplay(Base& parent, std::string_view key, bool show)
        : Object(parent, key)
    {
        set_show(show);
    }
 
    operator Required() const { return { show() }; }
 
    static Required make(bool show) { return { show }; }
 
    MNX_OPTIONAL_CHILD(AccidentalEnclosure, enclosure,
        (AccidentalEnclosureSymbol, symbol)); 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(bool, force, false); 
    MNX_REQUIRED_PROPERTY(bool, show);                      
};
 
class Rest : public Object
{
public:
    using Object::Object;
 
    MNX_OPTIONAL_PROPERTY(int, staffPosition);              
};
 
class TransposeWritten : public Object
{
public:
    using Object::Object;
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(int, diatonicDelta, 0);  
};
 
class Pitch : public Object
{
public:
    struct Required
    {
        NoteStep step{};    
        int octave{};       
        int alter{};        
    };
 
    Pitch(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    Pitch(Base& parent, std::string_view key, NoteStep step, int octave, int alter = 0)
        : Object(parent, key)
    {
        set_step(step);
        set_octave(octave);
        set_or_clear_alter(alter);
    }
 
    operator Required() const { return { step(), octave(), alter() }; }
 
    static Required make(NoteStep step, int octave, int alter = 0) { return { step, octave, alter }; }
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(int, alter, 0);  
    MNX_REQUIRED_PROPERTY(int, octave);         
    MNX_REQUIRED_PROPERTY(NoteStep, step);      
 
    [[nodiscard]] bool isSamePitch(const Required& src) const;
 
    [[nodiscard]] Required calcTransposed() const;
};
 
class Slur : public ArrayElementObject
{
public:
    struct Required
    {
        std::string target; 
    };
 
    Slur(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    Slur(Base& parent, std::string_view key, const std::string& target)
        : ArrayElementObject(parent, key)
    {
        set_target(target);
    }
 
    operator Required() const { return { target() }; }
 
    static Required make(const std::string& target) { return { target }; }
 
    MNX_OPTIONAL_PROPERTY(std::string, endNote);            
    MNX_OPTIONAL_PROPERTY(LineType, lineType);              
    MNX_OPTIONAL_PROPERTY(SlurTieSide, side);               
    MNX_OPTIONAL_PROPERTY(SlurTieSide, sideEnd);            
    MNX_OPTIONAL_PROPERTY(std::string, startNote);          
    MNX_REQUIRED_PROPERTY(std::string, target);             
};
 
class Tie : public ArrayElementObject
{
public:
    Tie(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    Tie(Base& parent, std::string_view key)
        : ArrayElementObject(parent, key)
    {}
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(bool, lv, false);    
    MNX_OPTIONAL_PROPERTY(SlurTieSide, side);               
    MNX_OPTIONAL_PROPERTY(std::string, target);             
    MNX_OPTIONAL_PROPERTY(TieTargetType, targetType);       
};
 
class PerformOptions : public Object
{
public:
    using Object::Object;
};
 
class NoteBase : public ArrayElementObject
{
public:
    using ArrayElementObject::ArrayElementObject;
 
    MNX_OPTIONAL_CHILD(PerformOptions, perform);                    
    MNX_OPTIONAL_PROPERTY(int, staff);                              
    MNX_OPTIONAL_CHILD(Array<Tie>, ties);                           
};
 
class KitNote : public NoteBase
{
public:
    struct Required
    {
        std::string kitComponentId; 
    };
 
    KitNote(const std::shared_ptr<json>& root, json_pointer pointer)
        : NoteBase(root, pointer)
    {
    }
 
    KitNote(Base& parent, std::string_view key, const std::string& kitComponentId)
        : NoteBase(parent, key)
    {
        set_kitComponent(kitComponentId);
    }
 
    operator Required() const { return { kitComponent() }; }
 
    static Required make(const std::string& kitComponentId) { return { kitComponentId }; }
 
    MNX_REQUIRED_PROPERTY(std::string, kitComponent);               
 
    inline static constexpr std::string_view JsonSchemaTypeName = "kit-note";     
};
 
class Note : public NoteBase
{
public:
    struct Required
    {
        Pitch::Required pitch{}; 
    };
 
    Note(const std::shared_ptr<json>& root, json_pointer pointer)
        : NoteBase(root, pointer)
    {
    }
 
    Note(Base& parent, std::string_view key, const Pitch::Required& pitch)
        : NoteBase(parent, key)
    {
        create_pitch(pitch.step, pitch.octave, pitch.alter);
    }
 
    operator Required() const { return { pitch() }; }
 
    static Required make(const Pitch::Required& pitch) { return { pitch }; }
 
    MNX_OPTIONAL_CHILD(
        AccidentalDisplay, accidentalDisplay,
        (bool, show)); 
    MNX_REQUIRED_CHILD(Pitch, pitch, (NoteStep, step), (int, octave), (int, alter)); 
    MNX_OPTIONAL_CHILD(TransposeWritten, written);                  
 
    inline static constexpr std::string_view JsonSchemaTypeName = "note";     
};
 
class EventLyricLine : public ArrayElementObject
{
public:
    struct Required
    {
        std::string syllableText; 
    };
 
    EventLyricLine(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    EventLyricLine(Base& parent, std::string_view key, const std::string& syllableText)
        : ArrayElementObject(parent, key)
    {
        set_text(syllableText);
    }
 
    operator Required() const { return { text() }; }
 
    static Required make(const std::string& syllableText) { return { syllableText }; }
 
    MNX_REQUIRED_PROPERTY(std::string, text);           
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(LyricLineType, type, LyricLineType::Whole);  
};
 
class EventLyrics : public Object
{
public:
    using Object::Object;
 
    MNX_OPTIONAL_CHILD(Dictionary<EventLyricLine>, lines);      
};
 
class Event : public SequenceContentObject
{
public:
    struct Required
    {
        NoteValue::Required duration{}; 
    };
 
    Event(const std::shared_ptr<json>& root, json_pointer pointer)
        : SequenceContentObject(root, pointer)
    {
    }
 
    Event(Base& parent, std::string_view key, NoteValueBase base, unsigned dots = 0)
        : SequenceContentObject(parent, key)
    {
        create_duration(base, dots);
    }
 
    operator Required() const { return { duration() }; }
 
    static Required make(NoteValueBase base, unsigned dots = 0) { return { { base, dots } }; }
 
    MNX_REQUIRED_CHILD(NoteValue, duration,
        (NoteValueBase, base), (unsigned, dots));           
    MNX_OPTIONAL_CHILD(Fermata, fermata);                   
    MNX_OPTIONAL_CHILD(Array<KitNote>, kitNotes);           
    MNX_OPTIONAL_CHILD(EventLyrics, lyrics);                
    MNX_OPTIONAL_CHILD(EventMarkings, markings);            
    MNX_OPTIONAL_CHILD(Array<Note>, notes);                 
    MNX_OPTIONAL_CHILD(Rest, rest);                         
    MNX_OPTIONAL_CHILD(Array<Slur>, slurs);                 
    MNX_OPTIONAL_PROPERTY(int, staff);                      
    MNX_OPTIONAL_PROPERTY(StemDirection, stemDirection);    
 
    [[nodiscard]] std::optional<Note> findNote(const std::string& noteId) const;
 
    [[nodiscard]] bool isGrace() const;
 
    [[nodiscard]] bool isTremolo() const;
 
    [[nodiscard]] Sequence getSequence() const;
 
    [[nodiscard]] size_t getSequenceIndex() const;
 
    [[nodiscard]] FractionValue calcStartTime() const;
 
    inline static constexpr std::string_view ContentTypeValue = "event";    
    inline static constexpr std::string_view JsonSchemaTypeName = "event";  
};
 
class Space : public SequenceContentObject
{
public:
    struct Required
    {
        FractionValue duration{}; 
    };
 
    Space(const std::shared_ptr<json>& root, json_pointer pointer)
        : SequenceContentObject(root, pointer)
    {
    }
 
    Space(Base& parent, std::string_view key, const FractionValue& duration)
        : SequenceContentObject(parent, key)
    {
        create_duration(duration);
    }
 
    operator Required() const { return { duration() }; }
 
    static Required make(const FractionValue& duration) { return { duration }; }
 
    MNX_REQUIRED_CHILD(
        Fraction, duration,
        (const FractionValue&, value)); 
 
    inline static constexpr std::string_view ContentTypeValue = "space";   
};
 
class Grace : public SequenceContentObject
{
public:
    Grace(const std::shared_ptr<json>& root, json_pointer pointer)
        : SequenceContentObject(root, pointer)
    {
    }
 
    Grace(Base& parent, std::string_view key)
        : SequenceContentObject(parent, key)
    {
        create_content();
    }
 
    MNX_OPTIONAL_PROPERTY(std::string, color);                      
    MNX_REQUIRED_CHILD(SequenceContent, content);                      
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(GraceType, graceType, GraceType::StealPrevious); 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(bool, slash, true);          
 
    inline static constexpr std::string_view ContentTypeValue = "grace";   
};
 
class MultiNoteTremolo : public SequenceContentObject
{
public:
    struct Required
    {
        int numberOfMarks{};                   
        NoteValueQuantity::Required noteValueQuant{}; 
    };
 
    MultiNoteTremolo(const std::shared_ptr<json>& root, json_pointer pointer)
        : SequenceContentObject(root, pointer)
    {
    }
 
    MultiNoteTremolo(Base& parent, std::string_view key, int numberOfMarks, const NoteValueQuantity::Required& noteValueQuant)
        : SequenceContentObject(parent, key)
    {
        create_content();
        set_marks(numberOfMarks);
        create_outer(noteValueQuant.count, noteValueQuant.noteValue);
    }
 
    operator Required() const { return { marks(), outer() }; }
 
    static Required make(int numberOfMarks, const NoteValueQuantity::Required& noteValueQuant)
    { return { numberOfMarks, noteValueQuant }; }
 
    MNX_REQUIRED_CHILD(SequenceContent, content);                      
    MNX_OPTIONAL_CHILD(
        NoteValue, individualDuration,
        (NoteValueBase, base), (unsigned, dots)); 
    MNX_REQUIRED_PROPERTY(int, marks);                              
    MNX_REQUIRED_CHILD(NoteValueQuantity, outer,
        (unsigned, count), (const NoteValue::Required&, noteValue)); 
 
    inline static constexpr std::string_view ContentTypeValue = "tremolo";   
};
 
class Tuplet : public SequenceContentObject
{
public:
    struct Required
    {
        NoteValueQuantity::Required innerNoteValueQuant{}; 
        NoteValueQuantity::Required outerNoteValueQuant{}; 
    };
 
    Tuplet(const std::shared_ptr<json>& root, json_pointer pointer)
        : SequenceContentObject(root, pointer)
    {
    }
 
    Tuplet(Base& parent, std::string_view key, const NoteValueQuantity::Required& innerNoteValueQuant, const NoteValueQuantity::Required& outerNoteValueQuant)
        : SequenceContentObject(parent, key)
    {
        create_inner(innerNoteValueQuant.count, innerNoteValueQuant.noteValue);
        create_outer(outerNoteValueQuant.count, outerNoteValueQuant.noteValue);
        create_content();
    }
 
    operator Required() const { return { inner(), outer() }; }
 
    static Required make(const NoteValueQuantity::Required& innerNoteValueQuant, const NoteValueQuantity::Required& outerNoteValueQuant)
    { return { innerNoteValueQuant, outerNoteValueQuant }; }
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(AutoYesNo, bracket, AutoYesNo::Auto); 
    MNX_REQUIRED_CHILD(SequenceContent, content);                      
    MNX_REQUIRED_CHILD(NoteValueQuantity, inner,
        (unsigned, count), (const NoteValue::Required&, noteValue)); 
    MNX_REQUIRED_CHILD(NoteValueQuantity, outer,
        (unsigned, count), (const NoteValue::Required&, noteValue)); 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(TupletDisplaySetting, showNumber, TupletDisplaySetting::Inner); 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(TupletDisplaySetting, showValue, TupletDisplaySetting::NoNumber); 
    MNX_OPTIONAL_PROPERTY(int, staff);                              
 
    [[nodiscard]] FractionValue ratio() const
    { return outer() / inner(); }
 
    inline static constexpr std::string_view ContentTypeValue = "tuplet";   
};
 
class FullMeasureRest : public Object
{
public:
    using Object::Object;
 
    FullMeasureRest(Base& parent, std::string_view key)
        : Object(parent, key)
    {}
 
    MNX_OPTIONAL_CHILD(Fermata, fermata);           
    MNX_OPTIONAL_PROPERTY(int, staffPosition);      
    MNX_OPTIONAL_CHILD(NoteValue, visualDuration,
        (NoteValueBase, base), (unsigned, dots));   
};
inline Event SequenceContent::appendEvent(NoteValueBase base, unsigned dots)
{ return appendWithType<Event>(base, dots); }
 
inline Grace SequenceContent::appendGrace()
{ return appendWithType<Grace>(); }
 
inline MultiNoteTremolo SequenceContent::appendMultiNoteTremolo(int numberOfMarks, const NoteValueQuantity::Required& noteValueQuant)
{ return appendWithType<MultiNoteTremolo>(numberOfMarks, noteValueQuant); }
 
inline Space SequenceContent::appendSpace(const FractionValue& duration)
{ return appendWithType<Space>(duration); }
 
inline Tuplet SequenceContent::appendTuplet(const NoteValueQuantity::Required& innerNoteValueQuant,
    const NoteValueQuantity::Required& outerNoteValueQuant)
{ return appendWithType<Tuplet>(innerNoteValueQuant, outerNoteValueQuant); }
 
} // namespace sequence
 
class Sequence : public ArrayElementObject
{
public:
    Sequence(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    Sequence(Base& parent, std::string_view key)
        : ArrayElementObject(parent, key)
    {
        create_content();
    }
 
    MNX_REQUIRED_CHILD(sequence::SequenceContent, content);          
    MNX_OPTIONAL_CHILD(sequence::FullMeasureRest, fullMeasure); 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(int, staff, 1);  
    MNX_OPTIONAL_PROPERTY(std::string, voice);          
};
 
} // namespace mnx