Key.h

#ifndef MCC_KEY_KEY_H
#define MCC_KEY_KEY_H
 
#include <MCC_BuildSettings.h>
 
#include <stdint.h>
 
#include <Foundation/Math/Arithmetic.h>
 
#include <MCC/Key/KeySignature.h>
#include <MCC/Pitch/ChromaticIndex.h>
#include <MCC/Pitch/NoteName.h>
#include <MCC/Pitch/Pitch.h>
#include <MCC/Pitch/PitchClass.h>
#include <MCC/Scale/Scales.h>
 
namespace MCC {

enum class KeyMode : uint8_t {
    Lydian = 0,
    Major,
    Mixolydian,
    Dorian,
    Minor,
    Phrygian,
    Locrian
};

class Key {
    NoteName _tonic;
    KeyMode _mode;
 
    // Circle-of-fifths position of a letter relative to C: F -1 ... B 5.
    static constexpr int32_t LetterFifths(Letter letter) noexcept {
        return (DiatonicIndex(letter) * 2 + 1) % 7 - 1;
    }
 
    // Signature offset of a mode relative to major on the same tonic.
    static constexpr int32_t ModeOffset(KeyMode mode) noexcept {
        return 1 - static_cast<int32_t>(mode);
    }
 
    static constexpr int32_t SignatureFifths(NoteName tonic, KeyMode mode) noexcept {
        return LetterFifths(tonic.Letter()) + 7 * tonic.Accidental().Semitones() + ModeOffset(mode);
    }
 
    static constexpr bool IsMode(KeyMode mode) noexcept {
        return static_cast<uint8_t>(mode) <= static_cast<uint8_t>(KeyMode::Locrian);
    }
 
public:
    constexpr Key() noexcept : _tonic(), _mode(KeyMode::Major) {}

    constexpr Key(NoteName tonic, KeyMode mode) noexcept
        : _tonic(tonic.IsValid() && IsMode(mode) &&
                 KeySignature(SignatureFifths(tonic, mode)).IsValid()
              ? tonic : NoteName::Invalid()),
          _mode(IsMode(mode) ? mode : KeyMode::Major) {}

    static MCC_CONSTEXPR14 Key FromSignature(KeySignature signature, KeyMode mode) noexcept {
        if (!signature.IsValid() || !IsMode(mode)) {
            return Key();
        }
        // Tonic position on the circle of fifths, then its letter and accidental.
        const int32_t fifths = signature.Fifths() - ModeOffset(mode);
        const int32_t order = Foundation::Math::FloorMod(fifths + 1, 7);
        const int32_t accidental = Foundation::Math::FloorDiv(fifths + 1, 7);
        const Letter letter = static_cast<Letter>(((order + 6) * 4) % 7);
        return Key(NoteName(letter, Accidental(accidental)), mode);
    }

    static constexpr Key Invalid() noexcept { return Key(); }

    constexpr bool IsValid() const noexcept { return _tonic.IsValid(); }

    constexpr NoteName Tonic() const noexcept { return _tonic; }

    constexpr KeyMode Mode() const noexcept { return _mode; }

    constexpr KeySignature Signature() const noexcept {
        return IsValid() ? KeySignature(SignatureFifths(_tonic, _mode)) : KeySignature();
    }

    Scales::Id ScaleId() const noexcept;

    MCC::Scale Scale() const noexcept { return Scales::Make(_tonic, ScaleId()); }

    MCC_CONSTEXPR14 NoteName Spell(MCC::PitchClass pitchClass) const noexcept {
        if (!IsValid() || !pitchClass.IsValid()) {
            return NoteName::Invalid();
        }
        const KeySignature signature = Signature();
        const int32_t direction = signature.Fifths() < 0 ? -1 : 1;
        NoteName best;
        int32_t bestScore = 1000;
        for (int32_t index = 0; index < 7; ++index) {
            const Letter letter = static_cast<Letter>(index);
            const int32_t keyAccidental = signature.AccidentalOf(letter).Semitones();
            for (int32_t alteration = -1; alteration <= 1; ++alteration) {
                const NoteName candidate(letter, Accidental(keyAccidental + alteration));
                if (candidate.IsValid() && candidate.PitchClass() == pitchClass) {
                    // Diatonic first, then the fewest accidentals, then the
                    // key's direction: raised in sharp keys, lowered in flat keys.
                    const int32_t accidental = candidate.Accidental().Semitones();
                    const int32_t score = alteration == 0 ? 0
                        : 10 * (accidental < 0 ? -accidental : accidental) +
                          (alteration == direction ? 1 : 2);
                    if (score < bestScore) {
                        best = candidate;
                        bestScore = score;
                    }
                }
            }
        }
        return best;
    }

    MCC_CONSTEXPR14 MCC::Pitch Spell(MCC::ChromaticIndex index) const noexcept {
        if (!index.IsValid()) {
            return MCC::Pitch::Invalid();
        }
        const NoteName noteName = Spell(index.PitchClass());
        if (!noteName.IsValid()) {
            return MCC::Pitch::Invalid();
        }
        const int32_t offset =
            NaturalSemitone(noteName.Letter()) + noteName.Accidental().Semitones();
        return MCC::Pitch(noteName, Foundation::Math::FloorDiv(index.Value() - offset, 12) - 1);
    }

    friend constexpr bool operator==(const Key& a, const Key& b) noexcept {
        return a._tonic == b._tonic && (!a.IsValid() || a._mode == b._mode);
    }

    friend constexpr bool operator!=(const Key& a, const Key& b) noexcept {
        return !(a == b);
    }
};
 
} // namespace MCC
 
#endif // MCC_KEY_KEY_H