musical_scale.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <array>
 
#include "dsp/chord_descriptor.h"
#include "utils/icloneable.h"
 
#include <QtQmlIntegration/qqmlintegration.h>
 
#include <boost/describe.hpp>
#include <nlohmann/json_fwd.hpp>
 
namespace zrythm::dsp
{
using namespace std::string_view_literals;

class MusicalScale : public QObject
{
  Q_OBJECT
  Q_PROPERTY (
    ScaleType scaleType READ scaleType WRITE setScaleType NOTIFY scaleTypeChanged)
  Q_PROPERTY (
    zrythm::dsp::chords::MusicalNote rootKey READ rootKey WRITE setRootKey
      NOTIFY rootKeyChanged)
  QML_ELEMENT
  QML_EXTENDED_NAMESPACE (zrythm::dsp::chords)
 
public:
  /**
   * Scale type (name) eg Aeolian.
   */
  enum class ScaleType : std::uint8_t
  {
    Chromatic,
 
    /* --- popular scales --- */
 
    Major,

    Minor,

    Ionian,
 
    Dorian,
    Phrygian,
    Lydian,
    Mixolydian,

    Aeolian,
 
    Locrian,
    MelodicMinor,
    HarmonicMinor,
    WholeTone,
    MajorPentatonic,
    MinorPentatonic,
    OctatonicHalfWhole,
    OctatonicWholeHalf,
 
    /* --- exotic scales --- */

    Acoustic,
 
    HarmonicMajor,
    PhrygianDominant,
    MajorLocrian,
    Algerian,
    Augmented,
    DoubleHarmonic,
    Chinese,
    Diminished,
    DominantDiminished,
    Egyptian,
    EightToneSpanish,
    Enigmatic,
    Geez,
    Hindu,
    Hirajoshi,
    HungarianGypsy,
    Insen,
    NeapolitanMajor,
    NeapolitanMinor,
    Oriental,
    RomanianMinor,
    Altered,
    Maqam,
    Yo,
    BebopLocrian,
    BebopDominant,
    BebopMajor,
    SuperLocrian,
    EnigmaticMinor,
    Composite,
    Bhairav,
    HungarianMinor,
    Persian,
    Iwato,
    Kumoi,
    Pelog,
    Prometheus,
    PrometheusNeapolitan,
    PrometheusLiszt,
    Balinese,
    Ragatodi,
    Japanese1,
    Japanese2,
 
    /* --- TODO unimplemented --- */
 
    Blues,
    Flamenco,
    Gypsy,
    HalfDiminished,
    In,
    Istrian,
    LydianAugmented,
    Tritone,
    UkranianDorian,
  };
  Q_ENUM (ScaleType)
 
public:
  MusicalScale (QObject * parent = nullptr) : QObject (parent) { }
  MusicalScale (ScaleType type, MusicalNote root, QObject * parent = nullptr)
      : MusicalScale (parent)
  {
    setScaleType (type);
    setRootKey (root);
  }
  Q_DISABLE_COPY_MOVE (MusicalScale)
  ~MusicalScale () override = default;
 
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  auto scaleType () const { return type_; }
  void setScaleType (ScaleType type)
  {
    type = std::clamp (type, ScaleType::Chromatic, ScaleType::UkranianDorian);
    if (type_ != type)
      {
        type_ = type;
        Q_EMIT scaleTypeChanged (type);
      }
  }
  Q_SIGNAL void scaleTypeChanged (ScaleType type);
 
  auto rootKey () const { return root_key_; }
  void setRootKey (MusicalNote root_key)
  {
    root_key = std::clamp (root_key, MusicalNote::C, MusicalNote::B);
    if (root_key_ != root_key)
      {
        root_key_ = root_key;
        Q_EMIT rootKeyChanged (root_key);
      }
  }
  Q_SIGNAL void rootKeyChanged (MusicalNote root_key);
 
  Q_INVOKABLE QString toString () const;

  Q_INVOKABLE bool containsNote (MusicalNote note) const;
 
  Q_INVOKABLE static bool
  scaleContainsNote (ScaleType type, MusicalNote rootKey, MusicalNote note);
 
  Q_INVOKABLE static QString noteToString (MusicalNote note);

  Q_INVOKABLE static QStringList allNoteNames ();
 
  Q_INVOKABLE static QVariantList availableScaleTypes ();
  Q_INVOKABLE static QVariantList availableScaleTypesExotic ();

  Q_INVOKABLE static QVariantList availableScaleTypesWithTriads ();

  Q_INVOKABLE static QVariantList
  getDiatonicChords (ScaleType type, MusicalNote rootKey);
 
  // ========================================================================

  static std::array<bool, 12>
  get_notes_for_type (ScaleType type, bool ascending);

  static std::array<ChordType, 12>
  get_triad_types_for_type (ScaleType type, bool ascending);

  /**
   * @brief A diatonic triad: the root note and chord type for a scale degree.
   */
  struct DiatonicTriad
  {
    MusicalNote root_note;
    ChordType   chord_type;
  };

  static boost::container::static_vector<DiatonicTriad, 12>
  get_diatonic_triads (ScaleType type, MusicalNote root_note);
 
  static utils::Utf8String type_to_string (ScaleType type);

  utils::Utf8String to_string () const;

  Q_INVOKABLE bool containsChord (
    MusicalNote root,
    ChordType   type,
    ChordAccent accent = ChordAccent::None) const;

  Q_INVOKABLE bool isAccentInScale (
    MusicalNote chord_root,
    ChordType   type,
    ChordAccent chord_accent) const;
 
  bool is_same_scale (const MusicalScale &other) const
  {
    return type_ == other.type_ && root_key_ == other.root_key_;
  }
 
private:
  static constexpr auto kRootKeyKey = "rootKey"sv;
  static constexpr auto kTypeKey = "type"sv;
 
  friend void init_from (
    MusicalScale          &obj,
    const MusicalScale    &other,
    utils::ObjectCloneType clone_type);
 
  friend void to_json (nlohmann::json &j, const MusicalScale &s);
  friend void from_json (const nlohmann::json &j, MusicalScale &s);
 
private:
  ScaleType type_ = ScaleType::Aeolian;

  MusicalNote root_key_ = MusicalNote::A;
 
  BOOST_DESCRIBE_CLASS (MusicalScale, (), (), (), (type_, root_key_))
};
 
} // namespace zrythm::dsp