region.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/position.h"
#include "gui/dsp/arranger_object.h"
#include "gui/dsp/automation_point.h"
#include "gui/dsp/colored_object.h"
#include "gui/dsp/loopable_object.h"
#include "gui/dsp/muteable_object.h"
#include "gui/dsp/named_object.h"
#include "gui/dsp/timeline_object.h"
#include "utils/format.h"
 
class Track;
 
class RegionLinkGroup;
// class RegionOwner;
class MidiNote;
class MidiRegion;
class ChordRegion;
// class LaneOwnedObject;
class ChordObject;
class AudioRegion;
class AutomationRegion;
class AutomatableTrack;

 
#define DEFINE_REGION_QML_PROPERTIES(ClassType) \
public: \
  DEFINE_LOOPABLE_OBJECT_QML_PROPERTIES (ClassType) \
  DEFINE_NAMEABLE_OBJECT_QML_PROPERTIES (ClassType) \
  DEFINE_COLORED_OBJECT_QML_PROPERTIES (ClassType) \
  /* ================================================================ */ \
  /* helpers */ \
  /* ================================================================ */
 
template <typename RegionT> struct RegionChildType;
 
template <> struct RegionChildType<MidiRegion>
{
  using type = MidiNote;
};
 
template <> struct RegionChildType<ChordRegion>
{
  using type = ChordObject;
};
 
template <> struct RegionChildType<AutomationRegion>
{
  using type = AutomationPoint;
};
 
class DummyRegionOwnedObject
{
};
 
// avoid errors
template <> struct RegionChildType<AudioRegion>
{
  using type = DummyRegionOwnedObject;
};
 
template <typename RegionT>
using RegionChildType_t = typename RegionChildType<RegionT>::type;
 
template <typename RegionT>
concept RegionWithChildren =
  !std::is_same_v<RegionChildType_t<RegionT>, DummyRegionOwnedObject>;

enum class MusicalMode
{
  Inherit,
  Off,
  On,
};
 
using RegionVariant =
  std::variant<MidiRegion, ChordRegion, AutomationRegion, AudioRegion>;
using RegionPtrVariant = to_pointer_variant<RegionVariant>;
 
template <typename T>
concept RegionTypeWithMidiEvents =
  std::same_as<T, MidiRegion> || std::same_as<T, ChordRegion>;

class Region
    : virtual public TimelineObject,
      virtual public NamedObject,
      virtual public MuteableObject,
      virtual public LoopableObject,
      public ColoredObject
{
public:
  ~Region () override = default;
 
  bool is_midi () const { return get_type () == Type::MidiRegion; }
  bool is_audio () const { return get_type () == Type::AudioRegion; }
  bool is_automation () const { return get_type () == Type::AutomationRegion; }
  bool is_chord () const { return get_type () == Type::ChordRegion; }

  RegionLinkGroup * get_link_group ();
 
  bool has_link_group () const { return link_group_.has_value (); }

  [[gnu::hot]] signed_frame_t
  timeline_frames_to_local (signed_frame_t timeline_frames, bool normalize) const;

  [[gnu::nonnull]] void get_frames_till_next_loop_or_end (
    signed_frame_t   timeline_frames,
    signed_frame_t * ret_frames,
    bool *           is_loop) const;

  void update_link_group ();

  bool is_recording ();

  static std::optional<ArrangerObjectPtrVariant> get_at_pos (
    dsp::Position     pos,
    Track *           track,
    AutomationTrack * at,
    bool              include_region_end = false);
 
protected:
  Region (ArrangerObjectRegistry &object_registry)
      : object_registry_ (object_registry)
  {
  }
  Q_DISABLE_COPY_MOVE (Region)
 
  void copy_members_from (const Region &other, ObjectCloneType clone_type);
 
private:
  static constexpr std::string_view kLinkGroupKey = "linkGroup";
  friend void to_json (nlohmann::json &j, const Region &region)
  {
    j[kLinkGroupKey] = region.link_group_;
  }
  friend void from_json (const nlohmann::json &j, Region &region)
  {
    j.at (kLinkGroupKey).get_to (region.link_group_);
  }
 
public:
  ArrangerObjectRegistry &object_registry_;
 
  // FIXME: consider tracking link groups separately to decouple the link logic,
  // region (probably) shouldn't know if it's in a link group
  std::optional<int> link_group_;

  int bounce_ = 0;
 
  /* --- stretching related --- */

  bool stretching_ = false;

  double stretch_ratio_ = 1.0;

  double before_length_ = 0.0;
 
  /* --- stretching related end --- */
};

template <typename RegionT> class RegionImpl : virtual public Region
{
protected:
  RegionImpl () noexcept { }
 
public:
  ~RegionImpl () override = default;
  Z_DISABLE_COPY_MOVE (RegionImpl)
 
  using RegionTPtr = RegionT *;
 
  static constexpr bool is_midi ()
  {
    return std::is_same_v<RegionT, MidiRegion>;
  }
  static constexpr bool is_audio ()
  {
    return std::is_same_v<RegionT, AudioRegion>;
  }
  static constexpr bool is_automation ()
  {
    return std::is_same_v<RegionT, AutomationRegion>;
  }
  static constexpr bool is_chord ()
  {
    return std::is_same_v<RegionT, ChordRegion>;
  }
  static constexpr bool is_laned ()
  {
    return std::is_same_v<MidiRegion, RegionT>
           || std::is_same_v<AudioRegion, RegionT>;
  }
 
  static constexpr bool has_children ()
  {
    return !std::is_same_v<RegionT, AudioRegion>;
  }
 
  using ChildT = RegionChildType_t<RegionT>;
  using ChildTPtr = ChildT *;

  void
  append_children (this RegionT &self, std::vector<RegionOwnedObject *> &children)
    requires RegionWithChildren<RegionT>
  {
    for (auto * obj : self.get_children_view ())
      {
        children.push_back (obj);
      }
  }

  void fill_midi_events (
    TrackPtrVariant              track_var,
    const EngineProcessTimeInfo &time_nfo,
    bool                         note_off_at_end,
    bool                         is_note_off_for_loop_or_region_end,
    dsp::MidiEventVector        &midi_events) const
    requires RegionTypeWithMidiEvents<RegionT>;
 
  auto get_object_ptr (const ArrangerObject::Uuid id) const
    requires RegionWithChildren<RegionT>
  {
    return std::get<ChildT *> (
      get_arranger_object_registry ().find_by_id_or_throw (id));
  }
  auto get_object_ptr (const ArrangerObjectUuidReference &id) const
    requires RegionWithChildren<RegionT>
  {
    return std::get<ChildT *> (id.get_object ());
  }
 
#if 0
  auto * get_region_owner (this const RegionT &self)
  {
    if constexpr (is_laned ())
      {
        auto &lane = self.get_lane ();
        return std::addressof (lane);
      }
    else if constexpr (is_automation ())
      {
        return std::visit (
          [&] (auto &&automatable_track) -> AutomationTrack * {
            using TrackT = base_type<decltype (automatable_track)>;
            if constexpr (std::derived_from<TrackT, AutomatableTrack>)
              {
                auto * at =
                  automatable_track->get_automation_tracklist ()
                    .get_automation_track_by_port_id (self.automatable_port_id_);
                return at;
              }
            else
              {
                throw std::runtime_error ("Invalid track");
              }
          },
          self.get_track ());
      }
    else if constexpr (is_chord ())
      {
        return std::get<ChordTrack *> (self.get_track ());
      }
  }
#endif
 
  auto &get_arranger_object_registry () const { return object_registry_; }
  auto &get_arranger_object_registry () { return object_registry_; }

  void remove_all_children (this RegionT &self)
    requires RegionWithChildren<RegionT>
  {
    z_debug ("removing all children from {} ", self.get_name ());
 
    auto vec = self.get_children_vector ();
    for (auto &obj : vec)
      {
        self.remove_object (obj.id ());
      }
  }
 
  bool get_muted (bool check_parent) const override;
 
  ArrangerObjectPtrVariant add_clone_to_project (bool fire_events) const final
  {
    return insert_clone_to_project_at_index (-1, fire_events);
  }
 
  ArrangerObjectPtrVariant insert_clone_to_project () const final
  {
    return insert_clone_to_project_at_index (-1, true);
  }

  void set_link_group (int group_idx, bool update_identifier);

  // void disconnect_region ();

  void update_identifier (this RegionT &self)
  {
    /* reset link group */
    // set_link_group (id_.link_group_, false);
 
    // track_id_ = id_.track_uuid_;
    if constexpr (RegionWithChildren<RegionT>)
      {
        for (auto * obj : self.get_children_view ())
          {
            obj->set_region_and_index (self);
          }
      }
  }

  static RegionT *
  at_position (const Track * track, const AutomationTrack * at, dsp::Position pos);

  void unlink ();
 
  bool
  are_members_valid (bool is_project, dsp::FramesPerTick frames_per_tick) const;

  void stretch (double ratio);
 
  void create_link_group_if_none ();
 
private:
  RegionTPtr
  insert_clone_to_project_at_index (int index, bool fire_events) const;

  [[gnu::hot]] void send_note_offs (
    dsp::MidiEventVector &events,
    EngineProcessTimeInfo time_nfo,
    bool                  is_note_off_for_loop_or_region_end) const
    requires RegionTypeWithMidiEvents<RegionT>;
 
  const RegionT &get_derived () const
  {
    return static_cast<const RegionT &> (*this);
  }
  RegionT &get_derived () { return static_cast<RegionT &> (*this); }
};
 
template <typename RegionT>
concept FinalRegionSubclass =
  std::derived_from<RegionImpl<RegionT>, Region> && FinalClass<RegionT>;
 
DEFINE_ENUM_FORMATTER (
  MusicalMode,
  MusicalMode,
  QT_TRANSLATE_NOOP_UTF8 ("MusicalMode", "Inherit"),
  QT_TRANSLATE_NOOP_UTF8 ("MusicalMode", "Off"),
  QT_TRANSLATE_NOOP_UTF8 ("MusicalMode", "On"));
 
DEFINE_OBJECT_FORMATTER (Region, Region, [] (const Region &r) {
  return fmt::format (
    "Region[id: {}, name: {}, "
    "<{}> to <{}> ({} frames, {} ticks) - loop end <{}> - link group {}"
    "]",
    r.get_uuid (), r.get_name (), r.get_position (), *r.end_pos_,
    r.end_pos_->frames_ - r.get_position ().frames_,
    r.end_pos_->ticks_ - r.get_position ().ticks_, r.loop_end_pos_,
    r.link_group_);
})
 
using RegionVariant =
  std::variant<MidiRegion, ChordRegion, AutomationRegion, AudioRegion>;
using RegionPtrVariant = to_pointer_variant<RegionVariant>;
 
template <typename RegionT>
concept RegionSubclass = DerivedButNotBase<RegionT, Region>;
 
extern template class RegionImpl<MidiRegion>;
extern template class RegionImpl<AudioRegion>;
extern template class RegionImpl<AutomationRegion>;
extern template class RegionImpl<ChordRegion>;