clip_playback_service.h

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

class ClipPlaybackService : public QObject
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
public:
  explicit ClipPlaybackService (
    arrangement::ArrangerObjectRegistry &object_registry,
    const tracks::TrackCollection       &track_collection,
    QObject *                            parent = nullptr);
 
  // ========================================================================
  // Clip Operations
  // ========================================================================

  Q_INVOKABLE void launchClip (
    tracks::Track *                       track,
    ClipSlot *                            clipSlot,
    structure::tracks::ClipQuantizeOption quantize =
      structure::tracks::ClipQuantizeOption::NextBar);

  Q_INVOKABLE void stopClip (
    tracks::Track *                       track,
    ClipSlot *                            clipSlot,
    structure::tracks::ClipQuantizeOption quantize =
      structure::tracks::ClipQuantizeOption::NextBar);

  Q_INVOKABLE void launchScene (
    Scene *                               scene,
    structure::tracks::ClipQuantizeOption quantize =
      structure::tracks::ClipQuantizeOption::NextBar);

  Q_INVOKABLE void stopScene (
    Scene *                               scene,
    structure::tracks::ClipQuantizeOption quantize =
      structure::tracks::ClipQuantizeOption::NextBar);

  Q_INVOKABLE void stopAllClips (
    structure::tracks::ClipQuantizeOption quantize =
      structure::tracks::ClipQuantizeOption::NextBar);
 
  // ========================================================================
  // State Queries
  // ========================================================================

  Q_INVOKABLE bool isClipPlaying (ClipSlot * clipSlot) const;

  Q_INVOKABLE double getClipPlaybackPosition (ClipSlot * clipSlot) const;

  Q_INVOKABLE QList<ClipSlot *> getPlayingClips () const;
 
  // ========================================================================
  // Track Playback Mode Management
  // ========================================================================

  void setTrackToClipLauncherMode (tracks::Track * track);

  Q_INVOKABLE void setTrackToTimelineMode (tracks::Track * track);

  void cancelPendingClipOperations (tracks::Track * track);
 
Q_SIGNALS:
  void clipLaunched (tracks::Track * track, ClipSlot * clipSlot);

  void clipStopped (tracks::Track * track, ClipSlot * clipSlot);

  void sceneLaunched (Scene * scene);

  void sceneStopped (Scene * scene);
 
private:
  // ========================================================================
  // Internal Implementation
  // ========================================================================

  void scheduleClipLaunch (
    tracks::Track *                       track,
    ClipSlot *                            clipSlot,
    structure::tracks::ClipQuantizeOption quantize);

  void scheduleClipStop (
    tracks::Track *                       track,
    ClipSlot *                            clipSlot,
    structure::tracks::ClipQuantizeOption quantize);

  template <arrangement::RegionObject RegionT>
  void generateClipEvents (
    tracks::Track *                       track,
    const RegionT                        &region,
    structure::tracks::ClipQuantizeOption quantize)
  {
    if (track == nullptr)
      return;
 
    auto * processor = track->get_track_processor ();
    if (processor == nullptr)
      return;
 
    // Generate events using the clip launcher event provider
    if constexpr (std::is_same_v<RegionT, arrangement::MidiRegion>)
      {
        processor->clip_playback_data_provider ().generate_midi_events (
          region, quantize);
      }
    else if constexpr (std::is_same_v<RegionT, arrangement::AudioRegion>)
      {
        processor->clip_playback_data_provider ().generate_audio_events (
          region, quantize);
      }
  }

  void updateClipSlotState (ClipSlot * clipSlot, ClipSlot::ClipState newState);

  void startPlaybackStateMonitor (
    tracks::Track *     track,
    ClipSlot *          clipSlot,
    ClipSlot::ClipState targetState);

  void checkPlaybackState ();
 
private:
  arrangement::ArrangerObjectRegistry &object_registry_;
  const tracks::TrackCollection       &track_collection_;

  std::unordered_map<tracks::Track::Uuid, ClipSlot *> playing_clips_;

  std::unordered_map<
    tracks::Track::Uuid,
    std::tuple<utils::QObjectUniquePtr<QTimer>, ClipSlot *, ClipSlot::ClipState>>
    playback_state_monitors_;
};
 
}