tracklist.h

// SPDX-FileCopyrightText: © 2018-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/tempo_map.h"
#include "structure/arrangement/arranger_object_span.h"
#include "structure/tracks/track.h"
#include "structure/tracks/track_span.h"
 
#include <QtQmlIntegration>
 
struct FileImportInfo;
 
#define TRACKLIST (PROJECT->tracklist_)
 
namespace zrythm::engine::session
{
class Router;
}
 
class Project;
 
namespace zrythm::structure::tracks
{
class ChordTrack;
class ModulatorTrack;
class MasterTrack;
class MarkerTrack;

class Tracklist final : public QAbstractListModel
{
  Q_OBJECT
  QML_ELEMENT
 
public:
  using TrackUuid = Track::Uuid;
  using ArrangerObjectPtrVariant = arrangement::ArrangerObjectPtrVariant;
  using Region = arrangement::Region;
  using ArrangerObject = arrangement::ArrangerObject;

  enum class PinOption
  {
    PinnedOnly,
    UnpinnedOnly,
    Both,
  };
 
  enum TrackRoles
  {
    TrackPtrRole = Qt::UserRole + 1,
    TrackNameRole,
  };
 
public:
  explicit Tracklist (
    Project                     &project,
    PortRegistry                &port_registry,
    TrackRegistry               &track_registry,
    dsp::PortConnectionsManager &port_connections_manager,
    const dsp::TempoMap         &tempo_map);
  explicit Tracklist (
    engine::session::SampleProcessor &sample_processor,
    PortRegistry                     &port_registry,
    TrackRegistry                    &track_registry,
    dsp::PortConnectionsManager      &port_connections_manager,
    const dsp::TempoMap              &tempo_map);
  Z_DISABLE_COPY_MOVE (Tracklist)
  ~Tracklist () override;
 
  // ========================================================================
  // QML Interface
  // ========================================================================
  QHash<int, QByteArray> roleNames () const override;
  int rowCount (const QModelIndex &parent = QModelIndex ()) const override;
  QVariant
  data (const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
  Q_INVOKABLE void setExclusivelySelectedTrack (QVariant track);
 
  // ========================================================================

  static constexpr std::array<Track::Type, 4> unique_track_types_ = {
    Track::Type::Chord, Track::Type::Marker, Track::Type::Modulator
  };
 
  auto get_track_span () const { return TrackSpan{ tracks_ }; }
 
  bool is_auditioner () const { return sample_processor_ != nullptr; }
 
  friend void init_from (
    Tracklist             &obj,
    const Tracklist       &other,
    utils::ObjectCloneType clone_type);

  void init_loaded (
    PortRegistry                      &port_registry,
    Project *                          project,
    engine::session::SampleProcessor * sample_processor);
 
  void init_loaded (PortRegistry &port_registry, Project &project)
  {
    init_loaded (port_registry, &project, nullptr);
  }
  void init_loaded (
    PortRegistry                     &port_registry,
    engine::session::SampleProcessor &sample_processor)
  {
    init_loaded (port_registry, nullptr, &sample_processor);
  }

  TrackPtrVariant insert_track (
    const TrackUuidReference       &track_id,
    int                             pos,
    engine::device_io::AudioEngine &engine,
    bool                            publish_events,
    bool                            recalc_graph);

  TrackPtrVariant append_track (
    auto                            track_id,
    engine::device_io::AudioEngine &engine,
    bool                            publish_events,
    bool                            recalc_graph)
  {
    return insert_track (
      track_id, tracks_.size (), engine, publish_events, recalc_graph);
  }

  void remove_track (const TrackUuid &track_id);

  void move_track (
    TrackUuid track_id,
    int       pos,
    bool      always_before_pos,
    std::optional<std::reference_wrapper<engine::session::Router>> router);
 
  std::optional<TrackPtrVariant> get_track (const TrackUuid &id) const
  {
    auto span = get_track_span ();
    auto it = std::ranges::find (span, id, TrackSpan::uuid_projection);
    if (it == span.end ()) [[unlikely]]
      {
        return std::nullopt;
      }
    return std::make_optional (*it);
  }

  void set_track_pinned (
    TrackUuid track_id,
    bool      pinned,
    int       publish_events,
    int       recalc_graph);
 
  ChordTrack * get_chord_track () const;

  std::optional<TrackPtrVariant> get_first_visible_track (bool pinned) const;

  std::optional<TrackPtrVariant>
  get_prev_visible_track (Track::TrackUuid track_id) const;

  std::optional<TrackPtrVariant>
  get_next_visible_track (Track::TrackUuid track_id) const;

  int
  get_last_pos (PinOption pin_opt = PinOption::Both, bool visible_only = false)
    const;

  std::optional<TrackPtrVariant>
  get_last_track (PinOption pin_opt = PinOption::Both, bool visible_only = false)
    const
  {
    return get_track_span ().get_track_by_pos (
      get_last_pos (pin_opt, visible_only));
  }

  std::optional<TrackPtrVariant>
  get_visible_track_after_delta (Track::TrackUuid track_id, int delta) const;

  int get_visible_track_diff (
    Track::TrackUuid src_track,
    Track::TrackUuid dest_track) const;

  bool multiply_track_heights (
    double multiplier,
    bool   visible_only,
    bool   check_only,
    bool   fire_events);

  void handle_click (TrackUuid track_id, bool ctrl, bool shift, bool dragged);
 
  std::vector<ArrangerObjectPtrVariant> get_timeline_objects_in_range (
    std::optional<std::pair<dsp::Position, dsp::Position>> range = std::nullopt)
    const;

  void
  clear_selections_for_object_siblings (const ArrangerObject::Uuid &object_id);

  AutomationTrack *
  get_automation_track_for_port (const Port::Uuid &port_id) const;

  void import_regions (
    std::vector<std::vector<std::shared_ptr<Region>>> &region_arrays,
    const FileImportInfo *                             import_info,
    TracksReadyCallback                                ready_cb);

  void move_region_to_track (
    ArrangerObjectPtrVariant region,
    const Track::Uuid       &to_track_id,
    int                      lane_or_at_index,
    int                      index);

  void move_plugin_automation (
    const Plugin::Uuid         &plugin_id,
    const Track::Uuid          &prev_track_id,
    const Track::Uuid          &track_id_to_move_to,
    zrythm::plugins::PluginSlot new_slot);

  void move_plugin (
    const Plugin::Uuid &plugin_id,
    const Track::Uuid  &target_track_id,
    plugins::PluginSlot slot,
    bool                confirm_overwrite);
 
  Channel * get_channel_for_plugin (const Plugin::Uuid &plugin_id);

  void import_files (
    std::optional<std::vector<utils::Utf8String>> uri_list,
    const FileDescriptor *                        orig_file,
    const Track *                                 track,
    const TrackLane *                             lane,
    int                                           index,
    const zrythm::dsp::Position *                 pos,
    TracksReadyCallback                           ready_cb);
 
#if 0
  void handle_move_or_copy (
    Track               &this_track,
    TrackWidgetHighlight location,
    GdkDragAction        action);
#endif

  bool
  track_name_is_unique (const utils::Utf8String &name, TrackUuid track_to_skip)
    const;

  bool is_track_pinned (size_t index) const
  {
    return index < pinned_tracks_cutoff_;
  }
 
  auto get_track_index (const Track::TrackUuid &track_id) const
  {
    return std::distance (
      tracks_.begin (),
      std::ranges::find (tracks_, track_id, &TrackUuidReference::id));
  }
 
  auto get_track_at_index (size_t index) const
  {
    if (index >= tracks_.size ())
      throw std::out_of_range ("Track index out of range");
    return get_track_span ().at (index);
  }
 
  auto get_track_ref_at_index (size_t index) const
  {
    if (index >= tracks_.size ())
      throw std::out_of_range ("Track index out of range");
    return tracks_.at (index);
  }
 
  bool is_track_pinned (Track::TrackUuid track_id) const
  {
    return is_track_pinned (get_track_index (track_id));
  }
 
  auto get_selection_manager ()
  {
    return TrackSelectionManager{ selected_tracks_, *track_registry_ };
  }

  void select_foldable_children_of_current_selections ()
  {
    auto      selected_vec = std::ranges::to<std::vector> (selected_tracks_);
    TrackSpan span{ *track_registry_, selected_vec };
    std::ranges::for_each (span, [&] (auto &&track_var) {
      std::visit (
        [&] (auto &&track_ref) {
          using TrackT = base_type<decltype (track_ref)>;
          if constexpr (std::derived_from<TrackT, FoldableTrack>)
            {
              for (int i = 1; i < track_ref->size_; ++i)
                {
                  const size_t child_pos =
                    get_track_index (track_ref->get_uuid ()) + i;
                  const auto &child_track_var = get_track_at_index (child_pos);
                  get_selection_manager ().append_to_selection (
                    TrackSpan::uuid_projection (child_track_var));
                }
            }
        },
        track_var);
    });
  }
 
  auto get_pinned_tracks_cutoff_index () const { return pinned_tracks_cutoff_; }
  void set_pinned_tracks_cutoff_index (size_t index)
  {
    pinned_tracks_cutoff_ = index;
  }
  auto track_count () const { return tracks_.size (); }

  void mark_track_for_bounce (
    TrackPtrVariant track_var,
    bool            bounce,
    bool            mark_regions,
    bool            mark_children,
    bool            mark_parents);
 
  void mark_all_tracks_for_bounce (bool bounce)
  {
    get_track_span ().mark_all_tracks_for_bounce (*this, bounce);
  }
 
  void disconnect_plugin (const Plugin::Uuid &plugin_id);
 
  std::string print_port_connection (const dsp::PortConnection &conn) const;
 
private:
  static constexpr auto kPinnedTracksCutoffKey = "pinnedTracksCutoff"sv;
  static constexpr auto kTracksKey = "tracks"sv;
  static constexpr auto kSelectedTracksKey = "selectedTracks"sv;
  friend void           to_json (nlohmann::json &j, const Tracklist &t)
  {
    j = nlohmann::json{
      { kPinnedTracksCutoffKey, t.pinned_tracks_cutoff_ },
      { kTracksKey,             t.tracks_               },
      { kSelectedTracksKey,     t.selected_tracks_      },
    };
  }
  friend void from_json (const nlohmann::json &j, Tracklist &t)
  {
    j.at (kPinnedTracksCutoffKey).get_to (t.pinned_tracks_cutoff_);
    j.at (kTracksKey).get_to (t.tracks_);
    j.at (kSelectedTracksKey).get_to (t.selected_tracks_);
  }
 
  void swap_tracks (size_t index1, size_t index2);

  void disconnect_port (const Port::Uuid &port_id);

  void disconnect_channel (Channel &channel);
 
  // FIXME: public access
public:
  void disconnect_fader (Fader &fader);
 
private:
  void disconnect_track_processor (TrackProcessor &track_processor);

  void disconnect_track (Track &track);
 
  auto &get_track_registry () const { return *track_registry_; }
  auto &get_track_registry () { return *track_registry_; }
 
private:
  const dsp::TempoMap &tempo_map_;
 
  OptionalRef<TrackRegistry>  track_registry_;
  OptionalRef<PortRegistry>   port_registry_;
  OptionalRef<PluginRegistry> plugin_registry_;

  std::vector<TrackUuidReference> tracks_;

  TrackSelectionManager::UuidSet selected_tracks_;
 
public:
  ChordTrack * chord_track_ = nullptr;

  MarkerTrack * marker_track_ = nullptr;

  ModulatorTrack * modulator_track_ = nullptr;

  MasterTrack * master_track_ = nullptr;
 
private:
  size_t pinned_tracks_cutoff_ = 0;

  std::atomic<bool> swapping_tracks_ = false;

  engine::session::SampleProcessor * sample_processor_ = nullptr;

  mutable QHash<Port::Uuid, AutomationTrack *> port_to_at_mappings_;
 
public:
  Project * project_ = nullptr;

  // int width_ = 0;
 
  QPointer<dsp::PortConnectionsManager> port_connections_manager_;
};
}