track.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/port_connections_manager.h"
#include "gui/dsp/arranger_object_all.h"
#include "gui/dsp/automation_tracklist.h"
#include "gui/dsp/fader.h"
#include "gui/dsp/plugin.h"
#include "gui/dsp/track_lane.h"
#include "utils/format.h"
 
#include <QColor>
#include <QHash>
 
using namespace zrythm;
 
class FileDescriptor;
class FoldableTrack;
class ChannelTrack;
struct FileImportInfo;
class GroupTargetTrack;

 
class TrackFactory;
 
#define DECLARE_FINAL_TRACK_CONSTRUCTORS(ClassType) \
  /* FIXME: make private */ \
public: \
  ClassType ( \
    TrackRegistry &track_registry, PluginRegistry &plugin_registry, \
    PortRegistry &port_registry, ArrangerObjectRegistry &obj_registry, \
    bool new_identity);
 
#define DEFINE_TRACK_QML_PROPERTIES(ClassType) \
public: \
  /* ================================================================ */ \
  /* name */ \
  /* ================================================================ */ \
  Q_PROPERTY (QString name READ getName WRITE setName NOTIFY nameChanged) \
  QString getName () const \
  { \
    return name_.to_qstring (); \
  } \
  void setName (const QString &name) \
  { \
    const auto name_str = utils::Utf8String::from_qstring (name); \
    if (name_ == name_str) \
      return; \
\
    name_ = name_str; \
    Q_EMIT nameChanged (name); \
  } \
\
  Q_SIGNAL void nameChanged (const QString &name); \
\
  /* ================================================================ */ \
  /* color */ \
  /* ================================================================ */ \
  Q_PROPERTY (QColor color READ getColor WRITE setColor NOTIFY colorChanged) \
\
  QColor getColor () const \
  { \
    return color_.to_qcolor (); \
  } \
  void setColor (const QColor &color) \
  { \
    if (color_.to_qcolor () == color) \
      return; \
\
    color_ = color; \
    Q_EMIT colorChanged (color); \
  } \
\
  Q_SIGNAL void colorChanged (const QColor &color); \
\
  /* ================================================================ */ \
  /* comment */ \
  /* ================================================================ */ \
  Q_PROPERTY ( \
    QString comment READ getComment WRITE setComment NOTIFY commentChanged) \
\
  QString getComment () const \
  { \
    return comment_.to_qstring (); \
  } \
  void setComment (const QString &comment) \
  { \
    const auto comment_str = utils::Utf8String::from_qstring (comment); \
    if (comment_ == comment_str) \
      return; \
\
    comment_ = comment_str; \
    Q_EMIT commentChanged (comment); \
  } \
\
  Q_SIGNAL void commentChanged (const QString &comment); \
\
  /* ================================================================ */ \
  /* visible */ \
  /* ================================================================ */ \
  Q_PROPERTY ( \
    bool visible READ getVisible WRITE setVisible NOTIFY visibleChanged) \
  bool getVisible () const \
  { \
    return visible_; \
  } \
  void setVisible (bool visible) \
  { \
    if (visible_ == visible) \
      return; \
\
    visible_ = visible; \
    Q_EMIT visibleChanged (visible); \
  } \
\
  Q_SIGNAL void visibleChanged (bool visible); \
\
  /* ================================================================ */ \
  /* enabled */ \
  /* ================================================================ */ \
  Q_PROPERTY ( \
    bool enabled READ getEnabled WRITE setEnabled NOTIFY enabledChanged) \
  bool getEnabled () const \
  { \
    return enabled_; \
  } \
\
  void setEnabled (bool enabled) \
  { \
    set_enabled (enabled, true, true, true); \
  } \
  Q_SIGNAL void enabledChanged (bool enabled); \
\
  /* ================================================================ */ \
  /* selected */ \
  /* ================================================================ */ \
  Q_PROPERTY (bool selected READ getSelected NOTIFY selectedChanged) \
  bool getSelected () const \
  { \
    if (track_selection_status_getter_) \
      { \
        return (*track_selection_status_getter_) (get_uuid ()); \
      } \
    return false; \
  } \
  Q_SIGNAL void selectedChanged (bool selected); \
\
  /* ================================================================ */ \
  /* type */ \
  /* ================================================================ */ \
  Q_PROPERTY (int type READ getType CONSTANT) \
  int getType () const \
  { \
    return ENUM_VALUE_TO_INT (type_); \
  } \
  /* ================================================================ */ \
  /* isRecordable */ \
  /* ================================================================ */ \
  Q_PROPERTY (bool isRecordable READ getIsRecordable CONSTANT) \
  bool getIsRecordable () const \
  { \
    if constexpr (std::derived_from<ClassType, RecordableTrack>) \
      { \
        return true; \
      } \
    return false; \
  } \
\
  /* ================================================================ */ \
  /* hasLanes */ \
  /* ================================================================ */ \
  Q_PROPERTY (bool hasLanes READ getHasLanes CONSTANT) \
  bool getHasLanes () const \
  { \
    if constexpr (std::derived_from<ClassType, LanedTrack>) \
      { \
        return true; \
      } \
    return false; \
  } \
\
  /* ================================================================ */ \
  /* hasChannel */ \
  /* ================================================================ */ \
  Q_PROPERTY (bool hasChannel READ getHasChannel CONSTANT) \
  bool getHasChannel () const \
  { \
    if constexpr (std::derived_from<ClassType, ChannelTrack>) \
      { \
        return true; \
      } \
    return false; \
  } \
\
  /* ================================================================ */ \
  /* isAutomatable */ \
  /* ================================================================ */ \
  Q_PROPERTY (bool isAutomatable READ getIsAutomatable CONSTANT) \
  bool getIsAutomatable () const \
  { \
    if constexpr (std::derived_from<ClassType, AutomatableTrack>) \
      { \
        return true; \
      } \
    return false; \
  } \
\
  /* ================================================================ */ \
  /* height */ \
  /* ================================================================ */ \
  Q_PROPERTY ( \
    double height READ getHeight WRITE setHeight NOTIFY heightChanged) \
  double getHeight () const \
  { \
    return main_height_; \
  } \
  void setHeight (double height) \
  { \
    if (utils::math::floats_equal (height, main_height_)) \
      { \
        return; \
      } \
    main_height_ = height; \
    Q_EMIT heightChanged (height); \
  } \
  Q_SIGNAL void heightChanged (double height); \
  Q_PROPERTY ( \
    double fullVisibleHeight READ getFullVisibleHeight NOTIFY \
      fullVisibleHeightChanged) \
  double getFullVisibleHeight () const \
  { \
    return get_full_visible_height (); \
  } \
  Q_SIGNAL void fullVisibleHeightChanged (); \
  /* ================================================================ */ \
  /* icon */ \
  /* ================================================================ */ \
  Q_PROPERTY (QString icon READ getIcon WRITE setIcon NOTIFY iconChanged) \
  QString getIcon () const \
  { \
    return icon_name_.to_qstring (); \
  } \
  void setIcon (const QString &icon) \
  { \
    const auto icon_str = utils::Utf8String::from_qstring (icon); \
    if (icon_name_ == icon_str) \
      { \
        return; \
      } \
    icon_name_ = icon_str; \
    Q_EMIT iconChanged (icon); \
  } \
  Q_SIGNAL void iconChanged (const QString &icon);

using TracksReadyCallback = void (*) (const FileImportInfo *);

class Track
    : public dsp::graph::IProcessable,
      public IPortOwner,
      public utils::UuidIdentifiableObject<Track>
{
  Q_GADGET
  QML_ELEMENT
 
public:
  using PortType = dsp::PortType;
  using PluginRegistry = gui::old_dsp::plugins::PluginRegistry;
  using PluginPtrVariant = PluginRegistry::VariantType;
  using PluginSlot = plugins::PluginSlot;
 
  using TrackSelectionStatusGetter = std::function<bool (const TrackUuid &)>;
 
  static constexpr int MIN_HEIGHT = 26;
  static constexpr int DEF_HEIGHT = 52;

  enum class Type
  {
    Instrument,

    Audio,

    Master,

    Chord,

    Marker,

    Tempo,

    Modulator,

    AudioBus,

    AudioGroup,

    Midi,

    MidiBus,

    MidiGroup,

    Folder,
  };
  Q_ENUM (Type)
 
  using Color = zrythm::utils::Color;
  using Position = zrythm::dsp::Position;

  static Fader::Type type_get_prefader_type (const Type type)
  {
    switch (type)
      {
      case Type::Midi:
      case Type::MidiBus:
      case Type::Chord:
      case Type::MidiGroup:
        return Fader::Type::MidiChannel;
      case Type::Instrument:
      case Type::Audio:
      case Type::AudioBus:
      case Type::Master:
      case Type::AudioGroup:
        return Fader::Type::AudioChannel;
      case Type::Marker:
      case Type::Folder:
        return Fader::Type::None;
      default:
        z_return_val_if_reached (Fader::Type::None);
      }
  }
 
  static constexpr bool type_can_have_direct_out (Type type)
  {
    return type != Type::Master;
  }
 
  static bool
  type_can_have_region_type (Type type, ArrangerObject::Type region_type)
  {
    switch (region_type)
      {
      case ArrangerObject::Type::AudioRegion:
        return type == Type::Audio;
      case ArrangerObject::Type::MidiRegion:
        return type == Type::Midi || type == Type::Instrument;
      case ArrangerObject::Type::ChordRegion:
        return type == Type::Chord;
      case ArrangerObject::Type::AutomationRegion:
        return true;
      default:
        throw std::runtime_error ("Invalid region type");
      }
  }
 
  static constexpr bool type_is_copyable (Type type)
  {
    return type != Type::Master && type != Type::Tempo && type != Type::Chord
           && type != Type::Modulator && type != Type::Marker;
  }

  static constexpr bool type_is_deletable (Type type)
  {
    return type_is_copyable (type);
  }
 
  static Type type_get_from_plugin_descriptor (
    const zrythm::plugins::PluginDescriptor &descr);
 
  static consteval bool type_has_mono_compat_switch (const Type tt)
  {
    return tt == Type::AudioGroup || tt == Type::Master;
  }

  static constexpr bool
  type_is_compatible_for_moving (const Type type1, const Type type2)
  {
    return type1 == type2 || (type1 == Type::Midi && type2 == Type::Instrument)
           || (type1 == Type::Instrument && type2 == Type::Midi);
  }

  [[gnu::const]]
  static constexpr bool type_has_piano_roll (const Type type)
  {
    return type == Type::Midi || type == Type::Instrument;
  }

  static constexpr bool type_has_inputs (const Type type)
  {
    return type == Type::Midi || type == Type::Instrument || type == Type::Audio;
  }

  static bool type_can_be_group_target (const Type type)
  {
    return type == Type::AudioGroup || type == Type::MidiGroup
           || type == Type::Instrument || type == Type::Master;
  }
 
  template <typename T> static consteval Type get_type_for_class ()
  {
    if constexpr (std::is_same_v<T, MidiTrack>)
      return Type::Midi;
    else if constexpr (std::is_same_v<T, AudioTrack>)
      return Type::Audio;
    else if constexpr (std::is_same_v<T, ChordTrack>)
      return Type::Chord;
    else if constexpr (std::is_same_v<T, InstrumentTrack>)
      return Type::Instrument;
    else if constexpr (std::is_same_v<T, AudioBusTrack>)
      return Type::AudioBus;
    else if constexpr (std::is_same_v<T, MidiBusTrack>)
      return Type::MidiBus;
    else if constexpr (std::is_same_v<T, MasterTrack>)
      return Type::Master;
    else if constexpr (std::is_same_v<T, TempoTrack>)
      return Type::Tempo;
    else if constexpr (std::is_same_v<T, ModulatorTrack>)
      return Type::Modulator;
    else if constexpr (std::is_same_v<T, MarkerTrack>)
      return Type::Marker;
    else if constexpr (std::is_same_v<T, FolderTrack>)
      return Type::Folder;
    else if constexpr (std::is_same_v<T, AudioGroupTrack>)
      return Type::AudioGroup;
    else if constexpr (std::is_same_v<T, MidiGroupTrack>)
      return Type::MidiGroup;
    else
      {
        static_assert (dependent_false_v<T>, "Unknown track type");
      }
  }
 
public:
  ~Track () override;
  Q_DISABLE_COPY_MOVE (Track)
 
  [[nodiscard]] static TrackUniquePtrVariant
  create_unique_from_type (Type type);
 
protected:
  Track (
    Type                    type,
    PortType                in_signal_type,
    PortType                out_signal_type,
    PluginRegistry         &plugin_registry,
    PortRegistry           &port_registry,
    ArrangerObjectRegistry &obj_registry);
 
public:
  virtual void
  init_loaded (PluginRegistry &plugin_registry, PortRegistry &port_registry) = 0;
 
  Tracklist * get_tracklist () const;
 
  dsp::PortConnectionsManager * get_port_connections_manager () const;
 
  bool has_piano_roll () const { return type_has_piano_roll (type_); }

  bool should_be_visible () const;
 
  bool is_tempo () const { return type_ == Type::Tempo; }
  bool is_folder () const { return type_ == Type::Folder; }
  bool is_audio_group () const { return type_ == Type::AudioGroup; }
  bool is_midi_group () const { return type_ == Type::MidiGroup; }
  bool is_audio_bus () const { return type_ == Type::AudioBus; }
  bool is_midi_bus () const { return type_ == Type::MidiBus; }
  bool is_modulator () const { return type_ == Type::Modulator; }
  bool is_chord () const { return type_ == Type::Chord; }
  bool is_marker () const { return type_ == Type::Marker; }
  bool is_audio () const { return type_ == Type::Audio; }
  bool is_instrument () const { return type_ == Type::Instrument; }
  bool is_midi () const { return type_ == Type::Midi; }
  bool is_master () const { return type_ == Type::Master; }
 
  static Track * from_variant (const TrackPtrVariant &variant);
 
  // bool has_lanes () const { return type_has_lanes (type_); }
 
  bool is_deletable () const { return type_is_deletable (type_); }
  bool is_copyable () const { return type_is_copyable (type_); }
  // bool has_automation () const { return type_has_automation (type_); }

  template <typename DerivedT>
  double get_full_visible_height (this DerivedT &&self)
    requires std::derived_from<base_type<DerivedT>, Track>
             && FinalClass<base_type<DerivedT>>
  {
    double height = self.main_height_;
 
    if constexpr (std::derived_from<DerivedT, LanedTrack>)
      {
        height += self.get_visible_lane_heights ();
      }
    if constexpr (std::derived_from<DerivedT, AutomatableTrack>)
      {
        if (self.automation_visible_)
          {
            const AutomationTracklist &atl = self.get_automation_tracklist ();
            for (const auto &at : atl.get_visible_automation_tracks ())
              {
                z_warn_if_fail (at->height_ > 0);
                if (at->visible_)
                  height += at->height_;
              }
          }
      }
    return height;
  }
 
  template <typename DerivedT>
  bool multiply_heights (
    this DerivedT &&self,
    double          multiplier,
    bool            visible_only,
    bool            check_only)
    requires std::derived_from<base_type<DerivedT>, Track>
             && FinalClass<base_type<DerivedT>>
  {
    if (self.main_height_ * multiplier < MIN_HEIGHT)
      return false;
 
    if (!check_only)
      {
        self.main_height_ *= multiplier;
      }
 
    if constexpr (std::derived_from<DerivedT, LanedTrack>)
      {
        if (!visible_only || self.lanes_visible_)
          {
            for (auto &lane_var : self.lanes_)
              {
                using TrackLaneT = DerivedT::TrackLaneType;
                auto lane = std::get<TrackLaneT *> (lane_var);
                if (lane->height_ * multiplier < MIN_HEIGHT)
                  {
                    return false;
                  }
 
                if (!check_only)
                  {
                    lane->height_ *= multiplier;
                  }
              }
          }
      }
    if constexpr (std::derived_from<DerivedT, AutomatableTrack>)
      {
        if (!visible_only || self.automation_visible_)
          {
            auto &atl = self.get_automation_tracklist ();
            for (auto &at : atl.ats_)
              {
                if (visible_only && !at->visible_)
                  continue;
 
                if (at->height_ * multiplier < MIN_HEIGHT)
                  {
                    return false;
                  }
 
                if (!check_only)
                  {
                    at->height_ *= multiplier;
                  }
              }
          }
      }
 
    return true;
  }

  bool is_auditioner () const;
 
  bool can_be_group_target () const { return type_can_be_group_target (type_); }
 
  bool is_frozen () const { return frozen_clip_id_.has_value (); }

  template <FinalRegionSubclass RegionT, FinalClass SelfT>
  void insert_region (
    this SelfT                 &self,
    ArrangerObjectUuidReference region_ref,
    AutomationTrack *           at,
    std::optional<int>          lane_pos,
    std::optional<int>          idx,
    bool                        gen_name)
  {
    auto * region = std::get<RegionT *> (region_ref.get_object ());
    // assert (region->validate (false, 0));
    assert (type_can_have_region_type (self.type_, region->get_type ()));
 
    if (gen_name)
      {
        if (at)
          {
            region->generate_name_from_automation_track (self, *at);
          }
        else
          {
            region->generate_name_from_track (self);
          }
      }
 
    assert (!region->get_name ().empty ());
    z_debug (
      "inserting region '{}' to track '{}' at lane {} (idx {})",
      region->get_name (), self.name_, lane_pos, idx);
 
    region->set_track_id (self.get_uuid ());
 
    if constexpr (
      std::derived_from<RegionT, LaneOwnedObject>
      && std::derived_from<SelfT, LanedTrack>)
      {
        /* enable extra lane if necessary */
        self.create_missing_lanes (*lane_pos);
 
        auto lane = std::get<typename SelfT::TrackLaneType *> (
          self.lanes_.at (*lane_pos));
        if (idx.has_value ())
          {
            lane->insert_object (region_ref, *idx);
          }
        else
          {
            lane->add_object (region_ref);
          }
      }
    else if constexpr (std::is_same_v<RegionT, AutomationRegion>)
      {
        assert (at != nullptr);
        if (idx.has_value ())
          {
            at->insert_object (region_ref, *idx);
          }
        else
          {
            at->add_object (region_ref);
          }
      }
    else if constexpr (
      std::is_same_v<RegionT, ChordRegion> && std::is_same_v<SelfT, ChordTrack>)
      {
        if (idx.has_value ())
          {
            self.ArrangerObjectOwner<ChordRegion>::insert_object (
              region_ref, *idx);
          }
        else
          {
            self.ArrangerObjectOwner<ChordRegion>::add_object (region_ref);
          }
      }
 
    /* write clip if audio region */
    if constexpr (std::is_same_v<RegionT, AudioRegion>)
      {
        if (!self.is_auditioner ())
          {
            auto * clip = region->get_clip ();
            self.write_audio_clip_to_pool_after_adding_audio_region (*clip);
          }
      }
 
    z_debug ("inserted: {}", *region);
  }
 
  // FIXME: break this dependency on AudioPool
  void
  write_audio_clip_to_pool_after_adding_audio_region (AudioClip &clip) const;

  template <FinalRegionSubclass RegionT>
  void add_region (
    this auto         &self,
    auto               region_ref,
    AutomationTrack *  at,
    std::optional<int> lane_pos,
    bool               gen_name)
  {
    return self.Track::template insert_region<RegionT> (
      region_ref, at, lane_pos, std::nullopt, gen_name);
  }

  void append_objects (std::vector<ArrangerObjectPtrVariant> &objects) const;

  void unselect_all ();
 
  template <typename DerivedT>
  bool contains_uninstantiated_plugin (this DerivedT &&self)
    requires std::derived_from<base_type<DerivedT>, Track>
             && FinalClass<base_type<DerivedT>>
  {
    std::vector<zrythm::gui::old_dsp::plugins::Plugin *> plugins;
    self.get_plugins (plugins);
    return std::ranges::any_of (plugins, [] (auto pl) {
      return pl->instantiation_failed_;
    });
  }
 
  utils::Utf8String get_node_name () const override { return get_name (); }

  virtual void clear_objects () { };

  virtual bool validate () const = 0;

  void
  add_folder_parents (std::vector<FoldableTrack *> &parents, bool prepend) const;

  FoldableTrack * get_direct_folder_parent () const
  {
    std::vector<FoldableTrack *> parents;
    add_folder_parents (parents, true);
    if (!parents.empty ())
      {
        return parents.front ();
      }
    return nullptr;
  }

  void remove_from_folder_parents ();

  utils::Utf8String get_name () const { return name_; };

  bool set_name_with_action_full (const utils::Utf8String &name);

  void set_name_with_action (const utils::Utf8String &name);

  void set_name (
    const Tracklist         &tracklist,
    const utils::Utf8String &name,
    bool                     pub_events);

  utils::Utf8String
  get_unique_name (const Tracklist &tracklist, const utils::Utf8String &name);

  void update_positions (
    bool               from_ticks,
    bool               bpm_change,
    dsp::FramesPerTick frames_per_tick);

  virtual void get_regions_in_range (
    std::vector<Region *> &regions,
    const dsp::Position *  p1,
    const dsp::Position *  p2)
  {
  }
 
  // FIXME: this member is likely not needed
  int  get_index () const { return pos_; }
  void set_index (int index) { pos_ = index; }
 
  auto get_input_signal_type () const { return in_signal_type_; }
  auto get_output_signal_type () const { return out_signal_type_; }

  template <typename DerivedT>
  void get_plugins (
    this DerivedT                                       &&self,
    std::vector<zrythm::gui::old_dsp::plugins::Plugin *> &arr)
    requires std::derived_from<base_type<DerivedT>, Track>
             && FinalClass<base_type<DerivedT>>
  {
    if constexpr (std::derived_from<DerivedT, ChannelTrack>)
      {
        self.channel_->get_plugins (arr);
      }
 
    if constexpr (std::is_same_v<DerivedT, ModulatorTrack>)
      {
        for (const auto &modulator : self.modulators_)
          {
            if (modulator)
              {
                arr.push_back (modulator.get ());
              }
          }
      }
  }

  template <typename DerivedT>
  void activate_all_plugins (this DerivedT &&self, bool activate)
    requires std::derived_from<base_type<DerivedT>, Track>
             && FinalClass<base_type<DerivedT>>
  {
    std::vector<zrythm::gui::old_dsp::plugins::Plugin *> pls;
    self.get_plugins (pls);
 
    for (auto &pl : pls)
      {
        if (!pl->instantiated_ && !pl->instantiation_failed_)
          {
            try
              {
                pl->instantiate ();
              }
            catch (const ZrythmException &e)
              {
                e.handle ("Failed to instantiate plugin");
              }
          }
 
        if (pl->instantiated_)
          {
            pl->activate (activate);
          }
      }
  }
 
  utils::Utf8String get_comment () const { return comment_; }

  void set_comment (const utils::Utf8String &comment, bool undoable);
 
  void set_comment_with_action (const utils::Utf8String &comment)
  {
    set_comment (comment, true);
  }

  void set_color (const Color &color, bool undoable, bool fire_events);

  void
  set_icon (const utils::Utf8String &icon_name, bool undoable, bool fire_events);

  virtual void
  append_ports (std::vector<Port *> &ports, bool include_plugins) const = 0;

  void track_freeze (bool freeze);

  template <typename DerivedT>
  PluginPtrVariant insert_plugin (
    this DerivedT     &&self,
    PluginUuid          plugin_id,
    plugins::PluginSlot slot,
    bool                instantiate_plugin,
    bool                replacing_plugin,
    bool                moving_plugin,
    bool                confirm,
    bool                gen_automatables,
    bool                recalc_graph,
    bool                fire_events)
    requires std::derived_from<base_type<DerivedT>, Track>
             && FinalClass<base_type<DerivedT>>
  {
    if (!slot.validate_slot_type_slot_combo ())
      {
        throw std::runtime_error ("Invalid slot type and slot combo");
      }
 
    PluginPtrVariant plugin_var{};
 
    if (slot.is_modulator ())
      {
        if constexpr (std::is_same_v<DerivedT, ModulatorTrack>)
          {
            plugin_var = self.insert_modulator (
              slot.get_slot_with_index ().second, plugin_id, replacing_plugin,
              confirm, gen_automatables, recalc_graph, fire_events);
          }
      }
    else
      {
        if constexpr (std::derived_from<DerivedT, ChannelTrack>)
          {
            plugin_var = self.get_channel ()->add_plugin (
              plugin_id, slot, confirm, moving_plugin, gen_automatables,
              recalc_graph, fire_events);
          }
      }
 
    std::visit (
      [&] (auto &&plugin) {
        if (plugin && !plugin->instantiated_ && !plugin->instantiation_failed_)
          {
            try
              {
                plugin->instantiate ();
              }
            catch (const ZrythmException &e)
              {
                e.handle ("Failed to instantiate plugin");
              }
          }
      },
      plugin_var);
 
    return plugin_var;
  }

  template <typename SelfT>
  void remove_plugin (this SelfT &self, plugins::PluginSlot slot)
    requires (
      std::derived_from<SelfT, ChannelTrack>
      || std::is_same_v<SelfT, ModulatorTrack>)
  {
    z_debug ("removing plugin from track {}", self.name_);
    if constexpr (std::is_same_v<SelfT, ModulatorTrack>)
      {
        assert (slot.is_modulator ());
        self.remove_modulator (slot.get_slot_with_index ().second);
      }
    else if constexpr (std::derived_from<SelfT, ChannelTrack>)
      {
        assert (!slot.is_modulator ());
        self.get_channel ()->remove_plugin_from_channel (slot, false, true);
      }
  }
 
  template <typename SelfT>
  plugins::PluginSlot
  get_plugin_slot (this const SelfT &self, const PluginUuid &plugin_id)
    requires (
      std::derived_from<SelfT, ChannelTrack>
      || std::is_same_v<SelfT, ModulatorTrack>)
  {
    if constexpr (std::derived_from<SelfT, ChannelTrack>)
      {
        return self.channel_->get_plugin_slot (plugin_id);
      }
    else if constexpr (std::is_same_v<SelfT, ModulatorTrack>)
      {
        return self.modulator_->get_plugin_slot (plugin_id);
      }
  }

  static bool is_plugin_descriptor_valid_for_slot_type (
    const plugins::PluginDescriptor &descr,
    zrythm::plugins::PluginSlotType  slot_type,
    Track::Type                      track_type)
  {
    switch (slot_type)
      {
      case zrythm::plugins::PluginSlotType::Insert:
        if (track_type == Track::Type::Midi)
          {
            return descr.num_midi_outs_ > 0;
          }
        else
          {
            return descr.num_audio_outs_ > 0;
          }
      case zrythm::plugins::PluginSlotType::MidiFx:
        return descr.num_midi_outs_ > 0;
        break;
      case zrythm::plugins::PluginSlotType::Instrument:
        return track_type == Track::Type::Instrument && descr.is_instrument ();
      default:
        break;
      }
 
    z_return_val_if_reached (false);
  }

  void disconnect_track ();
 
  bool is_enabled () const { return enabled_; }
  bool get_enabled () const { return enabled_; }
  bool get_disabled () const { return !enabled_; }
  void set_enabled (bool enabled) { enabled_ = enabled; }
 
  void set_enabled (
    bool enabled,
    bool trigger_undo,
    bool auto_select,
    bool fire_events);
 
  int get_total_bars (const Transport &transport, int total_bars) const;

  void set_caches (CacheType types);

  static void create_with_action (
    Type                                         type,
    const zrythm::plugins::PluginConfiguration * pl_setting,
    const FileDescriptor *                       file_descr,
    const dsp::Position *                        pos,
    int                                          index,
    int                                          num_tracks,
    int                                          disable_track_idx,
    TracksReadyCallback                          ready_cb);

  static Track * create_empty_at_idx_with_action (Type type, int index);

  static Track * create_for_plugin_at_idx_w_action (
    Type                                         type,
    const zrythm::plugins::PluginConfiguration * pl_setting,
    int                                          index);
 
  template <typename T = Track>
  static T * create_for_plugin_at_idx_w_action (
    const zrythm::plugins::PluginConfiguration * pl_setting,
    int                                          index)
  {
    return dynamic_cast<T *> (create_for_plugin_at_idx_w_action (
      get_type_for_class<T> (), pl_setting, index));
  }

  static Track * create_empty_with_action (Type type);
 
  template <typename T = Track> static T * create_empty_with_action ()
  {
    return dynamic_cast<T *> (
      create_empty_with_action (get_type_for_class<T> ()));
  }

  [[nodiscard]] static TrackUniquePtrVariant
  create_track (Type type, const utils::Utf8String &name, int pos);
 
  // GMenu * generate_edit_context_menu (int num_selected);
 
  bool is_in_active_project () const override;
 
  void set_port_metadata_from_owner (dsp::PortIdentifier &id, PortRange &range)
    const override;
 
  utils::Utf8String
  get_full_designation_for_port (const dsp::PortIdentifier &id) const override;
 
  virtual bool get_muted () const { return false; }
 
  virtual bool get_listened () const { return false; }

  virtual bool get_implied_soloed () const { return false; }
 
  virtual bool get_soloed () const { return false; }
 
  void set_selection_status_getter (TrackSelectionStatusGetter getter)
  {
    track_selection_status_getter_ = getter;
  }
  void unset_selection_status_getter ()
  {
    track_selection_status_getter_.reset ();
  }
 
  auto &get_plugin_registry () const { return plugin_registry_; }
  auto &get_plugin_registry () { return plugin_registry_; }
  auto &get_port_registry () const { return port_registry_; }
  auto &get_port_registry () { return port_registry_; }
  auto &get_object_registry () const { return object_registry_; }
  auto &get_object_registry () { return object_registry_; }
 
  auto get_type () const { return type_; }
  auto get_icon_name () const { return icon_name_; }
 
  friend bool operator< (const Track &lhs, const Track &rhs)
  {
    return lhs.pos_ < rhs.pos_;
  }
 
protected:
  void copy_members_from (const Track &other, ObjectCloneType clone_type);
 
  bool validate_base () const;

  virtual void set_playback_caches () { }
 
  void add_region_if_in_range (
    const dsp::Position *  p1,
    const dsp::Position *  p2,
    std::vector<Region *> &regions,
    Region *               region);
 
private:
  static constexpr std::string_view kTypeKey = "type";
  static constexpr std::string_view kNameKey = "name";
  static constexpr std::string_view kIconNameKey = "iconName";
  static constexpr std::string_view kIndexKey = "index";
  static constexpr std::string_view kVisibleKey = "visible";
  static constexpr std::string_view kMainHeightKey = "mainHeight";
  static constexpr std::string_view kEnabledKey = "enabled";
  static constexpr std::string_view kColorKey = "color";
  static constexpr std::string_view kInputSignalTypeKey = "inSignalType";
  static constexpr std::string_view kOutputSignalTypeKey = "outSignalType";
  static constexpr std::string_view kCommentKey = "comment";
  static constexpr std::string_view kFrozenClipIdKey = "frozenClipId";
  friend void to_json (nlohmann::json &j, const Track &track)
  {
    to_json (j, static_cast<const UuidIdentifiableObject &> (track));
    j[kTypeKey] = track.type_;
    j[kNameKey] = track.name_;
    j[kIconNameKey] = track.icon_name_;
    j[kIndexKey] = track.pos_;
    j[kVisibleKey] = track.visible_;
    j[kMainHeightKey] = track.main_height_;
    j[kEnabledKey] = track.enabled_;
    j[kColorKey] = track.color_;
    j[kInputSignalTypeKey] = track.in_signal_type_;
    j[kOutputSignalTypeKey] = track.out_signal_type_;
    j[kCommentKey] = track.comment_;
    j[kFrozenClipIdKey] = track.frozen_clip_id_;
  }
  friend void from_json (const nlohmann::json &j, Track &track)
  {
    from_json (j, static_cast<UuidIdentifiableObject &> (track));
    j.at (kTypeKey).get_to (track.type_);
    j.at (kNameKey).get_to (track.name_);
    j.at (kIconNameKey).get_to (track.icon_name_);
    j.at (kIndexKey).get_to (track.pos_);
    j.at (kVisibleKey).get_to (track.visible_);
    j.at (kMainHeightKey).get_to (track.main_height_);
    j.at (kEnabledKey).get_to (track.enabled_);
    j.at (kColorKey).get_to (track.color_);
    j.at (kInputSignalTypeKey).get_to (track.in_signal_type_);
    j.at (kOutputSignalTypeKey).get_to (track.out_signal_type_);
    j.at (kCommentKey).get_to (track.comment_);
    j.at (kFrozenClipIdKey).get_to (track.frozen_clip_id_);
  }

  static Track * create_without_file_with_action (
    Type                                         type,
    const zrythm::plugins::PluginConfiguration * pl_setting,
    int                                          index);
 
protected:
  PluginRegistry         &plugin_registry_;
  PortRegistry           &port_registry_;
  ArrangerObjectRegistry &object_registry_;

  int pos_ = 0;

  Type type_ = {};

  utils::Utf8String name_;

  utils::Utf8String icon_name_;

  // TrackWidget * widget_ = nullptr;

  bool visible_ = true;

  bool filtered_ = false;

  double main_height_{ DEF_HEIGHT };

  bool enabled_ = true;

  Color color_;

  PortType in_signal_type_ = {};

  PortType out_signal_type_ = {};

  utils::Utf8String comment_;
 
public:
  bool bounce_{};

  bool bounce_to_master_ = false;

  bool disconnecting_ = false;

  bool trigger_midi_activity_ = false;

  std::optional<AudioClip::Uuid> frozen_clip_id_;

  Tracklist * tracklist_ = nullptr;

  std::optional<TrackSelectionStatusGetter> track_selection_status_getter_;
};
 
DEFINE_ENUM_FORMATTER (
  Track::Type,
  Track_Type,
  QT_TR_NOOP_UTF8 ("Instrument"),
  QT_TR_NOOP_UTF8 ("Audio"),
  QT_TR_NOOP_UTF8 ("Master"),
  QT_TR_NOOP_UTF8 ("Chord"),
  QT_TR_NOOP_UTF8 ("Marker"),
  QT_TR_NOOP_UTF8 ("Tempo"),
  QT_TR_NOOP_UTF8 ("Modulator"),
  QT_TR_NOOP_UTF8 ("Audio FX"),
  QT_TR_NOOP_UTF8 ("Audio Group"),
  QT_TR_NOOP_UTF8 ("MIDI"),
  QT_TR_NOOP_UTF8 ("MIDI FX"),
  QT_TR_NOOP_UTF8 ("MIDI Group"),
  QT_TR_NOOP_UTF8 ("Folder"));
 
template <typename T>
concept TrackSubclass = std::derived_from<T, Track>;
 
template <typename TrackT>
concept FinalTrackSubclass = TrackSubclass<TrackT> && FinalClass<TrackT>;
 
template <typename TrackT>
concept TrackWithPlugins =
  FinalTrackSubclass<TrackT>
  && (std::derived_from<TrackT, ChannelTrack> || std::is_same_v<TrackT, ModulatorTrack>);
 
using TrackRegistry = utils::OwningObjectRegistry<TrackPtrVariant, Track>;
using TrackRegistryRef = std::reference_wrapper<TrackRegistry>;
using TrackUuidReference = utils::UuidReference<TrackRegistry>;
using TrackSelectionManager =
  utils::UuidIdentifiableObjectSelectionManager<TrackRegistry>;