track_collection.h

// SPDX-FileCopyrightText: © 2025-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <concepts>
 
#include "structure/tracks/track_span.h"
 
#include <QtQmlIntegration/qqmlintegration.h>
 
namespace zrythm::structure::tracks
{

class TrackCollection : public QAbstractListModel
{
  Q_OBJECT
  Q_PROPERTY (
    int numSoloedTracks READ numSoloedTracks NOTIFY numSoloedTracksChanged)
  Q_PROPERTY (
    int numMutedTracks READ numMutedTracks NOTIFY numMutedTracksChanged)
  Q_PROPERTY (
    int numListenedTracks READ numListenedTracks NOTIFY numListenedTracksChanged)
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
public:
  enum TrackRoles
  {
    TrackPtrRole = Qt::UserRole + 1,
 
    // Whether a track is foldable
    TrackFoldableRole,
 
    // Whether a foldable track is expanded
    TrackExpandedRole,
 
    // A foldable track's depth
    TrackDepthRole,
 
    TrackNameRole,
  };
  Q_ENUM (TrackRoles)
 
  TrackCollection (
    TrackRegistry &track_registry,
    QObject *      parent = nullptr) noexcept;
  ~TrackCollection () noexcept override;
  Q_DISABLE_COPY_MOVE (TrackCollection)
 
  // ========================================================================
  // 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 setTrackExpanded (const Track * track, bool expanded);
 
  int           numSoloedTracks () const;
  Q_SIGNAL void numSoloedTracksChanged ();
  int           numMutedTracks () const;
  Q_SIGNAL void numMutedTracksChanged ();
  int           numListenedTracks () const;
  Q_SIGNAL void numListenedTracksChanged ();

  Q_SIGNAL void tracksMoved (const QList<int> &rows);
 
  Q_SIGNAL void trackRecordingArmedChanged (Track * track, bool armed);
 
  // ========================================================================
  // Track Management
  // ========================================================================

  TrackPtrVariant get_track_at_index (size_t index) const;

  TrackUuidReference get_track_ref_at_index (size_t index) const;

  /**
   * @brief Get the index of the track with the given UUID.
   */
  auto get_track_index (const Track::Uuid &track_id) const
  {
    return std::distance (
      tracks_.begin (),
      std::ranges::find (tracks_, track_id, &TrackUuidReference::id));
  }
 
  TrackUuidReference track_ref_at_id (const Track::Uuid &track_id) const
  {
    return tracks ().at (get_track_index (track_id));
  }

  auto track_count () const { return tracks_.size (); }

  bool contains (const Track::Uuid &track_id) const;

  void add_track (const TrackUuidReference &track_id);

  void insert_track (const TrackUuidReference &track_id, int pos);

  void remove_track (const Track::Uuid &track_id);

  void detach_track (const Track::Uuid &track_id);

  void reattach_track (const TrackUuidReference &track_id, int pos);

  template <typename Container>
    requires requires (const Container &c, const Track::Uuid &uuid) {
      { c.contains (uuid) } -> std::convertible_to<bool>;
    }
  void notify_tracks_moved (const Container &uuids)
  {
    QList<int> rows;
    for (const auto &ref : tracks_)
      {
        if (uuids.contains (ref.id ()))
          {
            rows.push_back (static_cast<int> (get_track_index (ref.id ())));
          }
      }
    if (!rows.isEmpty ())
      {
        Q_EMIT tracksMoved (rows);
      }
  }

  void move_track (const Track::Uuid &track_id, int pos);

  auto get_track_span () const { return TrackSpan{ tracks_ }; }

  const std::vector<TrackUuidReference> &tracks () const { return tracks_; }

  TrackRegistry &get_track_registry () const { return track_registry_; }

  void set_track_expanded (const Track::Uuid &track_id, bool expanded);

  bool get_track_expanded (const Track::Uuid &track_id) const;

  void set_folder_parent (
    const Track::Uuid &child_id,
    const Track::Uuid &parent_id,
    bool               auto_reposition = false);

  std::optional<Track::Uuid>
  get_folder_parent (const Track::Uuid &child_id) const;

  void remove_folder_parent (
    const Track::Uuid &child_id,
    bool               auto_reposition = false);

  bool is_track_foldable (const Track::Uuid &track_id) const;

  bool is_ancestor_of (
    const Track::Uuid &possible_ancestor,
    const Track::Uuid &track_id) const;

  std::optional<Track::Uuid> get_enclosing_folder (size_t index) const;

  size_t get_child_count (const Track::Uuid &parent_id) const;

  std::vector<Track::Uuid>
  get_all_descendants (const Track::Uuid &parent_id) const;

  size_t get_last_child_index (const Track::Uuid &parent_id) const;
 
private:
  // ========================================================================
  // Serialization
  // ========================================================================
 
  static constexpr auto kTracksKey = "tracks"sv;
  static constexpr auto kExpandedTracksKey = "expandedTracks"sv;
  static constexpr auto kFolderParentsKey = "folderParents"sv;
  friend void to_json (nlohmann::json &j, const TrackCollection &collection);
  friend void from_json (const nlohmann::json &j, TrackCollection &collection);
 
private:
  TrackRegistry                  &track_registry_;
  std::vector<TrackUuidReference> tracks_;

  std::unordered_set<Track::Uuid> expanded_tracks_;

  std::unordered_map<Track::Uuid, Track::Uuid> folder_parent_;
 
  std::unordered_map<Track::Uuid, QMetaObject::Connection>
    recording_param_connections_;
};
 
} // namespace zrythm::structure::tracks