HarmonyConstants.h

// DSPark - Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi - MIT License
 
#pragma once
 
#include <array>
#include <string_view>
#include <cstddef>          // std::size_t (detail::copy, scalesForChordMask...)
#include <cstdint>
#include <algorithm>
#include <optional>
#include <type_traits>      // std::underlying_type_t (ChordTag operators)
#include <utility>          // std::pair (parseNote lookup table)
#include <initializer_list> // std::initializer_list (makeMask overload)
 
namespace dspark {
namespace harmony
{
    //==============================================================================
    // 0. CORE TYPEDEFS
    //==============================================================================
 
    using NoteSet = std::uint16_t;
 
    using Degree = int;
 
    //==============================================================================
    // 1. CHORDTAG - A FILTER FOR CHORD TYPES
    //==============================================================================
 
    enum class ChordTag : std::uint16_t
    {
        MajorTriad      = 1u << 0,   
        MinorTriad      = 1u << 1,   
        DiminishedTriad = 1u << 2,   
        AugmentedTriad  = 1u << 3,   
        Major7          = 1u << 4,   
        Dominant7       = 1u << 5,   
        Minor7          = 1u << 6,   
        HalfDim7        = 1u << 7,   
        Dim7            = 1u << 8,   
        Sus2Triad       = 1u << 9,   
        Sus4Triad       = 1u << 10,  
        Major9          = 1u << 11,  
        Dominant9       = 1u << 12,  
        Minor9          = 1u << 13,  
        Major11         = 1u << 14,  
        Dominant11      = 1u << 15,  
        All             = 0xFFFFu    
    };
 
    [[nodiscard]] constexpr ChordTag operator|(ChordTag lhs, ChordTag rhs) noexcept
    {
        using U = std::underlying_type_t<ChordTag>;
        return static_cast<ChordTag>(static_cast<U>(lhs) | static_cast<U>(rhs));
    }
 
    [[nodiscard]] constexpr ChordTag operator&(ChordTag lhs, ChordTag rhs) noexcept
    {
        using U = std::underlying_type_t<ChordTag>;
        return static_cast<ChordTag>(static_cast<U>(lhs) & static_cast<U>(rhs));
    }
 
    [[nodiscard]] constexpr bool hasTags(ChordTag tags, ChordTag wanted) noexcept
    {
        using U = std::underlying_type_t<ChordTag>;
        return (static_cast<U>(tags) & static_cast<U>(wanted)) == static_cast<U>(wanted);
    }
 
    //==============================================================================
    // 2. SCALE DESCRIPTOR
    //==============================================================================
 
    struct Scale
    {
        std::string_view name; 
        NoteSet          mask; 
        ChordTag         tags; 
    };
 
    //==============================================================================
    // 3. INTERNAL HELPERS & MASK GENERATION
    //==============================================================================
 
    [[nodiscard]] consteval NoteSet makeMask(
        bool b0, bool b1, bool b2, bool b3,
        bool b4, bool b5, bool b6, bool b7,
        bool b8, bool b9, bool b10, bool b11) noexcept
    {
        return (static_cast<NoteSet>(b0)  << 0)  | (static_cast<NoteSet>(b1)  << 1)  |
               (static_cast<NoteSet>(b2)  << 2)  | (static_cast<NoteSet>(b3)  << 3)  |
               (static_cast<NoteSet>(b4)  << 4)  | (static_cast<NoteSet>(b5)  << 5)  |
               (static_cast<NoteSet>(b6)  << 6)  | (static_cast<NoteSet>(b7)  << 7)  |
               (static_cast<NoteSet>(b8)  << 8)  | (static_cast<NoteSet>(b9)  << 9)  |
               (static_cast<NoteSet>(b10) << 10) | (static_cast<NoteSet>(b11) << 11);
    }
 
    [[nodiscard]] consteval NoteSet makeMask(std::initializer_list<int> degrees) noexcept
    {
        NoteSet m = 0;
        for (int d : degrees) {
            if (d >= 0) { m |= static_cast<NoteSet>(1u << (d % 12)); }
        }
        return m & 0x0FFFu;
    }
 
    namespace detail
    {
        constexpr void copy(char* dst, std::string_view src, std::size_t dstCapacity) noexcept
        {
            std::size_t toCopy = src.size();
            if (toCopy + 1u > dstCapacity) { toCopy = (dstCapacity > 0) ? dstCapacity - 1u : 0u; }
            for (std::size_t i = 0; i < toCopy; ++i) { dst[i] = src[i]; }
            if (dstCapacity > 0) { dst[toCopy] = '\0'; }
        }
 
        [[nodiscard]] constexpr std::array<int, 7> activeDegrees(NoteSet mask) noexcept
        {
            std::array<int, 12> temp{};
            int tcount = 0;
            for (int i = 0; i < 12; ++i) {
                if (mask & (1u << i)) temp[tcount++] = i;
            }
 
            std::array<int, 7> out{};
            if (tcount == 0) {
                for (int i = 0; i < 7; ++i) out[i] = i;
                return out;
            }
 
            for (int i = 0; i < 7; ++i) {
                int idx = i % tcount;
                int octave = i / tcount;
                out[i] = temp[idx] + octave * 12;
            }
            return out;
        }
 
        [[nodiscard]] constexpr int interval(const std::array<int, 7>& deg, int degIdx, int skip) noexcept
        {
            int a = deg[degIdx];
            int b = deg[(degIdx + skip) % 7];
            while (b <= a) { b += 12; }
            return b - a;
        }
    } // namespace detail
 
    //==============================================================================
    // 4. DATABASE OF SCALES & CONSTANTS
    //==============================================================================
 
    inline constexpr std::array<Scale, 61> allScales = [](){
        std::array<Scale, 61> scales{};
 
        // Major modes
        scales[0]  = {"Ionian",          makeMask({0,2,4,5,7,9,11}), ChordTag::MajorTriad | ChordTag::Major7 | ChordTag::Dominant7};
        scales[1]  = {"Dorian",          makeMask({0,2,3,5,7,9,10}), ChordTag::MinorTriad | ChordTag::Minor7};
        scales[2]  = {"Phrygian",        makeMask({0,1,3,5,7,8,10}), ChordTag::MinorTriad | ChordTag::DiminishedTriad | ChordTag::HalfDim7};
        scales[3]  = {"Lydian",          makeMask({0,2,4,6,7,9,11}), ChordTag::MajorTriad | ChordTag::Major7};
        scales[4]  = {"Mixolydian",      makeMask({0,2,4,5,7,9,10}), ChordTag::MajorTriad | ChordTag::Dominant7};
        scales[5]  = {"Aeolian",         makeMask({0,2,3,5,7,8,10}), ChordTag::MinorTriad | ChordTag::Minor7};
        scales[6]  = {"Locrian",         makeMask({0,1,3,5,6,8,10}), ChordTag::MinorTriad | ChordTag::DiminishedTriad | ChordTag::HalfDim7};
 
        // Melodic-minor modes
        scales[7]  = {"MelodicMinor",    makeMask({0,2,3,5,7,9,11}), ChordTag::MinorTriad | ChordTag::Minor7};
        scales[8]  = {"Dorianb2",        makeMask({0,1,3,5,7,9,10}), ChordTag::MinorTriad};
        scales[9]  = {"LydianAugmented", makeMask({0,2,4,6,8,9,11}), ChordTag::MajorTriad | ChordTag::AugmentedTriad};
        scales[10] = {"LydianDominant",  makeMask({0,2,4,6,7,9,10}), ChordTag::Dominant7};
        scales[11] = {"Mixolydianb6",    makeMask({0,2,4,5,7,8,10}), ChordTag::MajorTriad | ChordTag::Dominant7};
        scales[12] = {"HalfDiminished",  makeMask({0,2,3,5,6,8,10}), ChordTag::MinorTriad | ChordTag::DiminishedTriad | ChordTag::HalfDim7};
        scales[13] = {"AlteredDominant", makeMask({0,1,3,4,6,8,10}), ChordTag::Dominant7};
 
        // Harmonic-minor modes
        scales[14] = {"HarmonicMinor",   makeMask({0,2,3,5,7,8,11}), ChordTag::MinorTriad | ChordTag::Minor7};
        scales[15] = {"Locrian6",        makeMask({0,1,3,5,6,9,10}), ChordTag::MinorTriad | ChordTag::DiminishedTriad};
        scales[16] = {"IonianAugmented", makeMask({0,2,4,5,8,9,11}), ChordTag::MajorTriad | ChordTag::AugmentedTriad};
        scales[17] = {"DorianSharp4",    makeMask({0,2,3,6,7,9,10}), ChordTag::MinorTriad};
        scales[18] = {"PhrygianDominant",makeMask({0,1,4,5,7,8,10}), ChordTag::MajorTriad | ChordTag::Dominant7};
        scales[19] = {"LydianSharp2",    makeMask({0,3,4,6,7,9,11}), ChordTag::MajorTriad | ChordTag::Major7};
        scales[20] = {"UltraLocrian",    makeMask({0,1,3,4,6,8,9}),  ChordTag::DiminishedTriad | ChordTag::Dim7};
 
        // Harmonic-major modes (each mask is the exact rotation of scales[21];
        // the mode test derives them by rotation and pins every one)
        scales[21] = {"HarmonicMajor",     makeMask({0,2,4,5,7,8,11}), ChordTag::MajorTriad | ChordTag::AugmentedTriad};
        scales[22] = {"Dorianb5",          makeMask({0,2,3,5,6,9,10}), ChordTag::DiminishedTriad | ChordTag::HalfDim7};
        scales[23] = {"Phrygianb4",        makeMask({0,1,3,4,7,8,10}), ChordTag::MinorTriad | ChordTag::Minor7};
        scales[24] = {"LydianDiminished",  makeMask({0,2,3,6,7,9,11}), ChordTag::MinorTriad};
        scales[25] = {"Mixolydianb9",      makeMask({0,1,4,5,7,9,10}), ChordTag::MajorTriad | ChordTag::Dominant7};
        scales[26] = {"LydianAugmented2",  makeMask({0,3,4,6,8,9,11}), ChordTag::AugmentedTriad | ChordTag::Major7};
        scales[27] = {"LocrianDiminished", makeMask({0,1,3,5,6,8,9}),  ChordTag::DiminishedTriad | ChordTag::Dim7};
 
        // Double-harmonic family
        scales[28] = {"DoubleHarmonic",    makeMask({0,1,4,5,7,8,11}), ChordTag::MajorTriad};
        scales[29] = {"HungarianMinor",    makeMask({0,2,3,6,7,8,11}), ChordTag::MinorTriad};
        scales[30] = {"Byzantine",         makeMask({0,1,4,5,7,8,11}), ChordTag::MajorTriad};
        scales[31] = {"Ionian b5",         makeMask({0,2,4,5,6,9,11}), ChordTag::MajorTriad | ChordTag::DiminishedTriad};
        scales[32] = {"Lydian #6",         makeMask({0,2,4,6,7,10,11}),ChordTag::MajorTriad | ChordTag::Major7};
 
        // Pentatonics
        scales[33] = {"MajorPentatonic",   makeMask({0,2,4,7,9}),      ChordTag::MajorTriad};
        scales[34] = {"MinorPentatonic",   makeMask({0,3,5,7,10}),     ChordTag::MinorTriad};
        scales[35] = {"EgyptianPentatonic",makeMask({0,2,5,7,10}),     ChordTag::MajorTriad};
        scales[36] = {"Hirajoshi",         makeMask({0,2,3,7,8}),      ChordTag::MinorTriad};
        scales[37] = {"InSen",             makeMask({0,1,5,7,10}),     ChordTag::MinorTriad};
        scales[38] = {"Yo",                makeMask({0,2,5,7,9}),      ChordTag::MajorTriad};
 
        // Symmetrical / exotic
        scales[39] = {"WholeTone",         makeMask({0,2,4,6,8,10}),               ChordTag::AugmentedTriad};
        scales[40] = {"Chromatic",         makeMask({0,1,2,3,4,5,6,7,8,9,10,11}),  ChordTag::All};
        scales[41] = {"Diminished",        makeMask({0,2,3,5,6,8,9,11}),           ChordTag::MinorTriad | ChordTag::DiminishedTriad | ChordTag::HalfDim7 | ChordTag::Dim7};
        scales[42] = {"Diminished2",       makeMask({0,1,3,4,6,7,9,10}),           ChordTag::MinorTriad | ChordTag::DiminishedTriad | ChordTag::HalfDim7 | ChordTag::Dim7};
        scales[43] = {"Augmented",         makeMask({0,3,4,7,8,11}),               ChordTag::AugmentedTriad};
 
        // Additional Scales
        scales[44] = {"Algerian",          makeMask({0,2,3,6,7,8,11}),   ChordTag::MinorTriad};
        scales[45] = {"Arabian",           makeMask({0,2,4,5,6,8,10}),   ChordTag::MajorTriad};
        scales[46] = {"Balinese",          makeMask({0,1,3,7,8}),        ChordTag::MinorTriad};
        scales[47] = {"Chinese",           makeMask({0,4,6,7,11}),       ChordTag::MajorTriad};
        scales[48] = {"Gypsy",             makeMask({0,1,4,5,7,8,10}),   ChordTag::MajorTriad | ChordTag::Dominant7};
        scales[49] = {"Hindu",             makeMask({0,2,4,5,7,8,10}),   ChordTag::MajorTriad | ChordTag::Dominant7};
        scales[50] = {"Hungarian",         makeMask({0,2,3,6,7,8,11}),   ChordTag::MinorTriad};
        scales[51] = {"Japanese",          makeMask({0,1,5,7,8}),        ChordTag::MinorTriad};
        scales[52] = {"Javanese",          makeMask({0,1,3,5,7,9,10}),   ChordTag::MinorTriad | ChordTag::Minor7};
        scales[53] = {"Mongolian",         makeMask({0,2,4,7,9}),        ChordTag::MajorTriad};
        scales[54] = {"Neapolitan",        makeMask({0,1,3,5,7,8,11}),   ChordTag::MinorTriad};
        scales[55] = {"Oriental",          makeMask({0,1,4,5,6,9,10}),   ChordTag::MajorTriad};
        scales[56] = {"Persian",           makeMask({0,1,4,5,6,8,11}),   ChordTag::MajorTriad};
        scales[57] = {"Prometheus",        makeMask({0,2,4,6,9,10}),     ChordTag::MajorTriad};
        scales[58] = {"Spanish",           makeMask({0,1,3,4,5,7,8,10}), ChordTag::DiminishedTriad};
        scales[59] = {"Tritone",           makeMask({0,1,4,6,7,10}),     ChordTag::Dominant7};
        scales[60] = {"Ukrainian",         makeMask({0,2,3,6,7,9,10}),   ChordTag::MinorTriad};
 
        return scales;
    }();
 
    inline constexpr std::array<std::string_view, 12> sharpNames{
        "C","C#","D","D#","E","F","F#","G","G#","A","A#","B"
    };
    inline constexpr std::array<std::string_view, 12> flatNames{
        "C","Db","D","Eb","E","F","Gb","G","Ab","A","Bb","B"
    };
    // Standard key-signature spelling per chromatic root: sharps for C, D, E,
    // F#, G, A, B (and C# > Db is resolved toward flats, Db being the common
    // key); flats for Db, Eb, F, Ab, Bb.
    inline constexpr std::array<bool,12> useSharpsForRoot{
        1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1
    };
 
    //==============================================================================
    // 5. CONTEXT-AWARE NOTE NAMES & PARSING
    //==============================================================================
 
    [[nodiscard]] constexpr std::string_view noteName(int midi, int root = 0) noexcept
    {
        int idx = (midi % 12 + 12) % 12;
        int r   = (root % 12 + 12) % 12;
        return useSharpsForRoot[r] ? sharpNames[idx] : flatNames[idx];
    }
 
    [[nodiscard]] constexpr std::optional<int> parseNote(std::string_view s) noexcept
    {
        // Exactly 21 entries: a larger array would value-initialize the rest
        // to {"", 0}, and the empty name would make parseNote("") "succeed"
        // as pitch-class 0 instead of returning nullopt.
        constexpr std::array<std::pair<std::string_view,int>, 21> lut{{
            {"C",0}, {"B#",0},
            {"C#",1}, {"Db",1},
            {"D",2}, {"D#",3}, {"Eb",3},
            {"E",4}, {"E#",5}, {"Fb",4},
            {"F",5}, {"F#",6}, {"Gb",6},
            {"G",7}, {"G#",8}, {"Ab",8},
            {"A",9}, {"A#",10},{"Bb",10},
            {"B",11}, {"Cb",11}
        }};
 
        for (const auto& [name,val] : lut) {
            if (name.size() == s.size() &&
                std::equal(name.begin(), name.end(), s.begin(),
                           [](char a, char b){ return (a|32) == (b|32); })) {
                return val;
            }
        }
        return std::nullopt;
    }
 
    //==============================================================================
    // 6. TRANSPOSE A SCALE
    //==============================================================================
 
    [[nodiscard]] constexpr NoteSet scaleAtRoot(NoteSet base, int root) noexcept
    {
        root = (root % 12 + 12) % 12;
        std::uint32_t b = static_cast<std::uint32_t>(base) & 0x0FFFu;
        std::uint32_t res = ((b << root) | (b >> (12 - root))) & 0x0FFFu;
        return static_cast<NoteSet>(res);
    }
 
    //==============================================================================
    // 7. CHORD DESCRIPTOR
    //==============================================================================
 
    struct Chord
    {
        std::string_view   name;
        std::array<int, 7> intervals; 
    };
 
    inline constexpr std::array<Chord, 15> allChords{{
        {"Major",      {0, 4, 7, -1, -1, -1, -1}},
        {"Minor",      {0, 3, 7, -1, -1, -1, -1}},
        {"Diminished", {0, 3, 6, -1, -1, -1, -1}},
        {"Augmented",  {0, 4, 8, -1, -1, -1, -1}},
        {"Major7",     {0, 4, 7, 11, -1, -1, -1}},
        {"Dominant7",  {0, 4, 7, 10, -1, -1, -1}},
        {"Minor7",     {0, 3, 7, 10, -1, -1, -1}},
        {"HalfDim7",   {0, 3, 6, 10, -1, -1, -1}},
        {"Dim7",       {0, 3, 6,  9, -1, -1, -1}},
        {"Sus2",       {0, 2, 7, -1, -1, -1, -1}},
        {"Sus4",       {0, 5, 7, -1, -1, -1, -1}},
        {"Major9",     {0, 4, 7, 11, 14, -1, -1}},
        {"Dominant9",  {0, 4, 7, 10, 14, -1, -1}},
        {"Minor9",     {0, 3, 7, 10, 14, -1, -1}},
        {"Major13",    {0, 4, 7, 11, 14, 17, 21}}
    }};
 
    //==============================================================================
    // 8. CHORD GENERATION & REVERSE LOOKUP
    //==============================================================================
 
    [[nodiscard]] constexpr std::array<int, 7>
    chordAtRootMidi(const Chord& c, int rootMidi, int inversion = 0) noexcept
    {
        std::array<int, 7> notes{};
        int count = 0;
 
        for (int i = 0; i < 7; ++i) {
            const int deg = c.intervals[i];
            if (deg < 0) break;
            notes[count++] = rootMidi + deg;
        }
 
        if (count == 0) return { -1,-1,-1,-1,-1,-1,-1 };
 
        if (count > 0) {
            inversion = (inversion >= 0) ? (inversion % count) : 0;
            for (int i = 0; i < inversion; ++i) { notes[i] += 12; }
            std::sort(notes.begin(), notes.begin() + count);
        }
 
        for (int i = count; i < 7; ++i) { notes[i] = -1; }
        return notes;
    }
 
    [[nodiscard]] constexpr std::array<const Scale*, 16>
    scalesForChordMask(NoteSet chordMask) noexcept
    {
        std::array<const Scale*, 16> out{};
        std::size_t idx = 0;
        for (const auto& s : allScales) {
            if (((s.mask & chordMask) == chordMask) && idx < out.size()) {
                out[idx++] = &s;
            }
        }
        return out;
    }
 
    [[nodiscard]] constexpr std::array<const Scale*, 16>
    scalesForChord(const Chord& chord) noexcept
    {
        NoteSet chordMask = 0;
        for (int d : chord.intervals) {
            if (d >= 0) { chordMask |= static_cast<NoteSet>(1u << (d % 12)); }
        }
        return scalesForChordMask(chordMask);
    }
 
    //==============================================================================
    // 9. DIATONIC CHORD GENERATION
    //==============================================================================
 
    enum class ChordLevel : std::uint8_t
    {
        TriadsOnly   = 0, 
        Triads7      = 1, 
        Triads79     = 2, 
        Triads7911   = 3, 
        Triads791113 = 4  
    };
 
    struct DiatonicChord
    {
        std::array<char, 24> name;      
        std::array<int, 7>   intervals; 
 
        [[nodiscard]] constexpr std::string_view view() const noexcept
        {
            std::size_t len = 0;
            while (len < name.size() && name[len] != '\0') { ++len; }
            return std::string_view(name.data(), len);
        }
    };
 
    [[nodiscard]] constexpr DiatonicChord
    diatonicChord(const Scale& sc, Degree degree, ChordLevel level) noexcept
    {
        const auto deg = detail::activeDegrees(sc.mask);
        if (degree < 0 || degree >= 7) return {}; // Invalid input protection
 
        const int third      = detail::interval(deg, degree, 2);
        const int fifth      = detail::interval(deg, degree, 4);
        const int seventh    = detail::interval(deg, degree, 6);
        const int ninth      = detail::interval(deg, degree, 1);
        const int eleventh   = detail::interval(deg, degree, 3);
        const int thirteenth = detail::interval(deg, degree, 5);
 
        DiatonicChord c{};
        c.intervals = {0, third, fifth,
                       (level >= ChordLevel::Triads7)      ? seventh    : -1,
                       (level >= ChordLevel::Triads79)     ? ninth      : -1,
                       (level >= ChordLevel::Triads7911)   ? eleventh   : -1,
                       (level >= ChordLevel::Triads791113) ? thirteenth : -1};
 
        auto buildName = [&](std::string_view baseName, ChordLevel lvl)
        {
            char buf[24]{}; // Match DiatonicChord::name capacity (fits longest symbol)
            std::size_t pos = 0;
            detail::copy(buf + pos, baseName, sizeof(buf) - pos);
            pos += baseName.size();
 
            if (lvl >= ChordLevel::Triads79)     { detail::copy(buf + pos, "(9)",  sizeof(buf) - pos);  pos += 3; }
            if (lvl >= ChordLevel::Triads7911)   { detail::copy(buf + pos, "(11)", sizeof(buf) - pos);  pos += 4; }
            if (lvl >= ChordLevel::Triads791113) { detail::copy(buf + pos, "(13)", sizeof(buf) - pos);  pos += 4; }
 
            detail::copy(c.name.data(), std::string_view(buf, pos), c.name.size());
        };
 
        std::string_view base;
        if      (third == 4 && fifth == 7) base = "M";
        else if (third == 3 && fifth == 7) base = "m";
        else if (third == 3 && fifth == 6) base = "dim";
        else if (third == 4 && fifth == 8) base = "aug";
        else                               base = "?";
 
        std::string_view name7;
        if      (base == "dim" && seventh == 10) name7 = "m7b5";
        else if (base == "dim" && seventh == 9)  name7 = "dim7";
        else if (base == "M"   && seventh == 10) name7 = "7";
        else if (base == "M"   && seventh == 11) name7 = "maj7";
        else if (base == "m"   && seventh == 10) name7 = "m7";
        else if (base == "m"   && seventh == 11) name7 = "m(maj7)";
        else if (base == "aug" && seventh == 10) name7 = "aug7";
        else                                     name7 = base;
 
        switch (level)
        {
            case ChordLevel::TriadsOnly:   buildName(base,  ChordLevel::TriadsOnly);   break;
            case ChordLevel::Triads7:      buildName(name7, ChordLevel::Triads7);      break;
            case ChordLevel::Triads79:     buildName(name7, ChordLevel::Triads79);     break;
            case ChordLevel::Triads7911:   buildName(name7, ChordLevel::Triads7911);   break;
            case ChordLevel::Triads791113: buildName(name7, ChordLevel::Triads791113); break;
        }
 
        return c;
    }
 
    [[nodiscard]] constexpr std::array<int, 7>
    diatonicChordToMidi(const DiatonicChord& c, int rootMidi) noexcept
    {
        std::array<int, 7> notes{};
        for (std::size_t i = 0; i < 7; ++i) {
            notes[i] = (c.intervals[i] >= 0) ? rootMidi + c.intervals[i] : -1;
        }
        return notes;
    }
 
    //==============================================================================
    // 10. OCTAVE & NOTE HELPERS
    //==============================================================================
 
    [[nodiscard]] constexpr std::optional<int> parseNoteWithOctave(std::string_view note) noexcept
    {
        std::size_t len = note.size();
        while (len > 0 && note[len - 1] >= '0' && note[len - 1] <= '9') { --len; }
        if (len > 0 && note[len - 1] == '-') { --len; }
 
        std::string_view baseNote = note.substr(0, len);
        return parseNote(baseNote);
    }
 
    [[nodiscard]] constexpr int getOctaveFromNote(std::string_view note) noexcept
    {
        if (note.empty()) return 4;
        std::size_t len = note.size();
 
        while (len > 0 && note[len - 1] >= '0' && note[len - 1] <= '9') { --len; }
 
        bool isNegative = false;
        if (len > 0 && note[len - 1] == '-') {
            isNegative = true;
            --len;
        }
 
        if (len < note.size() && !(isNegative && len + 1 == note.size())) {
            int parsed = 0;
            std::size_t start = isNegative ? len + 1 : len;
            for (std::size_t i = start; i < note.size(); ++i) {
                parsed = parsed * 10 + (note[i] - '0');
            }
            return isNegative ? -parsed : parsed;
        }
 
        return 4;
    }
 
    [[nodiscard]] constexpr int transposeByOctaves(int midi, int octaveDelta) noexcept
    {
        return midi + octaveDelta * 12;
    }
 
} // namespace harmony
} // namespace dspark