Note.h

#ifndef MCC_RHYTHM_NOTE_H
#define MCC_RHYTHM_NOTE_H
 
#include <stdint.h>
 
#include <MCC_BuildSettings.h>
#include <MCC/Pitch/Pitch.h>
#include <MCC/Rhythm/NoteValue.h>
 
namespace MCC {

class Note {
    MCC::Pitch _pitch;
    MCC::NoteValue _value;
 
public:
    constexpr Note() noexcept : _pitch(), _value() {}

    constexpr explicit Note(
        MCC::Pitch pitch,
        MCC::NoteValue value = MCC::NoteValue::Quarter()) noexcept
        : _pitch(pitch.IsValid() && value.IsValid()
              ? pitch
              : MCC::Pitch::Invalid()),
          _value(pitch.IsValid() && value.IsValid()
              ? value
              : MCC::NoteValue::Invalid()) {}

    constexpr Note(
        MCC::NoteName noteName,
        int32_t octave,
        MCC::NoteValue value = MCC::NoteValue::Quarter()) noexcept
        : Note(MCC::Pitch(noteName, octave), value) {}

    constexpr Note(
        MCC::Letter letter,
        int32_t octave,
        MCC::NoteValue value = MCC::NoteValue::Quarter()) noexcept
        : Note(MCC::Pitch(letter, octave), value) {}

    constexpr Note(
        MCC::Letter letter,
        MCC::Accidental accidental,
        int32_t octave,
        MCC::NoteValue value = MCC::NoteValue::Quarter()) noexcept
        : Note(MCC::Pitch(letter, accidental, octave), value) {}

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

    constexpr bool IsValid() const noexcept {
        return _pitch.IsValid() && _value.IsValid();
    }

    constexpr MCC::Pitch Pitch() const noexcept { return _pitch; }

    constexpr MCC::NoteValue Value() const noexcept { return _value; }

    constexpr MCC::NoteName NoteName() const noexcept {
        return _pitch.NoteName();
    }

    constexpr MCC::Letter Letter() const noexcept { return _pitch.Letter(); }

    constexpr MCC::Accidental Accidental() const noexcept {
        return _pitch.Accidental();
    }

    constexpr int8_t Octave() const noexcept { return _pitch.Octave(); }

    MCC_CONSTEXPR14 MCC::PitchClass PitchClass() const noexcept {
        return _pitch.PitchClass();
    }

    MCC_CONSTEXPR14 MCC::ChromaticIndex ChromaticIndex() const noexcept {
        return _pitch.ChromaticIndex();
    }

    constexpr Note WithPitch(MCC::Pitch pitch) const noexcept {
        return Note(pitch, _value);
    }

    constexpr Note WithValue(MCC::NoteValue value) const noexcept {
        return Note(_pitch, value);
    }

    constexpr Note WithDots(int32_t dots) const noexcept {
        return Note(_pitch, _value.WithDots(dots));
    }

    MCC_CONSTEXPR14 Note MovedDiatonically(int32_t steps) const noexcept {
        return Note(_pitch.MovedDiatonically(steps), _value);
    }

    MCC_CONSTEXPR14 Note Altered(int32_t semitones) const noexcept {
        return Note(_pitch.Altered(semitones), _value);
    }

    MCC_CONSTEXPR14 Note MovedByOctaves(int32_t octaves) const noexcept {
        return Note(_pitch.MovedByOctaves(octaves), _value);
    }

    friend constexpr bool operator==(Note a, Note b) noexcept {
        return a._pitch == b._pitch && a._value == b._value;
    }
 
    friend constexpr bool operator!=(Note a, Note b) noexcept {
        return !(a == b);
    }

    friend MCC_CONSTEXPR14 bool operator<(Note a, Note b) noexcept {
        if (!a.IsValid() || !b.IsValid()) {
            return a.IsValid() && !b.IsValid();
        }
        return a._pitch != b._pitch ? a._pitch < b._pitch : a._value < b._value;
    }
 
    friend MCC_CONSTEXPR14 bool operator>(Note a, Note b) noexcept {
        return b < a;
    }
 
    friend MCC_CONSTEXPR14 bool operator<=(Note a, Note b) noexcept {
        return !(b < a);
    }
 
    friend MCC_CONSTEXPR14 bool operator>=(Note a, Note b) noexcept {
        return !(a < b);
    }
};

MCC_CONSTEXPR14 bool IsNoteLowerThan(Note a, Note b) noexcept {
    if (!a.IsValid() || !b.IsValid()) {
        return a.IsValid() && !b.IsValid();
    }
    if (a.ChromaticIndex() != b.ChromaticIndex()) {
        return a.ChromaticIndex() < b.ChromaticIndex();
    }
    return a.Pitch() != b.Pitch() ? a.Pitch() < b.Pitch() : a.Value() < b.Value();
}
 
} // namespace MCC
 
#endif // MCC_RHYTHM_NOTE_H