timeline_data_cache.h

// SPDX-FileCopyrightText: © 2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <span>
 
#include "dsp/curve.h"
#include "dsp/midi_event.h"
#include "utils/units.h"
 
#include <QObject>
 
#include <juce_audio_basics/juce_audio_basics.h>
 
namespace zrythm::dsp
{

class TimelineDataCache : public QObject
{
  Q_OBJECT
 
public:
  using IntervalType = std::pair<units::sample_t, units::sample_t>;
 
  explicit TimelineDataCache (QObject * parent = nullptr) : QObject (parent) { }
 
  ~TimelineDataCache () override;

  void clear ()
  {
    clear_impl ();
    Q_EMIT cachedRangesChanged (compute_cached_sample_ranges ());
  }

  virtual void remove_sequences_matching_interval (IntervalType interval) = 0;

  void finalize_changes ()
  {
    finalize_changes_impl ();
    Q_EMIT cachedRangesChanged (compute_cached_sample_ranges ());
  }

  virtual bool has_content () const = 0;

  Q_SIGNAL void cachedRangesChanged (std::vector<IntervalType> ranges) const;
 
protected:
  static void validate_interval (IntervalType interval)
  {
    if (interval.first >= interval.second)
      {
        throw std::invalid_argument (
          "Interval start must be strictly less than end");
      }
  }

  static bool intervals_overlap (IntervalType a, IntervalType b) noexcept
  {
    return a.second > b.first && a.first < b.second;
  }
 
private:
  virtual void clear_impl () = 0;
  virtual void finalize_changes_impl () = 0;

  virtual std::vector<IntervalType> compute_cached_sample_ranges () const = 0;
};

class MidiTimelineDataCache : public TimelineDataCache
{
public:
  explicit MidiTimelineDataCache (QObject * parent = nullptr)
      : TimelineDataCache (parent)
  {
  }

  void add_midi_sequence (
    IntervalType                          interval,
    std::span<const SampleBasedMidiEvent> events);

  std::span<const SampleBasedMidiEvent> midi_events () const
  {
    return merged_midi_events_;
  }
 
  void remove_sequences_matching_interval (IntervalType interval) override;
  bool has_content () const override;
 
private:
  void                      clear_impl () override;
  void                      finalize_changes_impl () override;
  std::vector<IntervalType> compute_cached_sample_ranges () const override;
  std::map<IntervalType, std::vector<SampleBasedMidiEvent>> midi_sequences_;

  std::vector<SampleBasedMidiEvent> merged_midi_events_;
};

class AudioTimelineDataCache : public TimelineDataCache
{
public:
  explicit AudioTimelineDataCache (QObject * parent = nullptr)
      : TimelineDataCache (parent)
  {
  }

  struct AudioClipEntry
  {
    juce::AudioSampleBuffer audio_buffer;

    units::sample_t start_sample;

    units::sample_t end_sample;
  };

  void add_audio_clip (
    IntervalType                   interval,
    const juce::AudioSampleBuffer &audio_buffer);

  std::span<const AudioClipEntry> audio_clips () const { return audio_clips_; }
 
  void remove_sequences_matching_interval (IntervalType interval) override;
  bool has_content () const override;
 
private:
  void                      clear_impl () override;
  void                      finalize_changes_impl () override;
  std::vector<IntervalType> compute_cached_sample_ranges () const override;
  std::vector<AudioClipEntry> audio_clips_;
};

class AutomationTimelineDataCache : public TimelineDataCache
{
public:
  explicit AutomationTimelineDataCache (QObject * parent = nullptr)
      : TimelineDataCache (parent)
  {
  }

  struct CachedAutomationSegment
  {
    units::sample_t start_sample;
    units::sample_t end_sample;

    float ratio_start;
    float ratio_end;

    float point_a_value;
    float point_b_value;

    dsp::CurveOptions::Algorithm curve_algo;
    float                        curve_curviness;
  };

  struct AutomationCacheEntry
  {
    std::vector<CachedAutomationSegment> segments;

    units::sample_t start_sample;

    units::sample_t end_sample;
  };

  void
  add_automation_sequence (IntervalType interval, AutomationCacheEntry &&entry);

  std::span<const AutomationCacheEntry> automation_sequences () const
  {
    return automation_sequences_;
  }
 
  void remove_sequences_matching_interval (IntervalType interval) override;
  bool has_content () const override;
 
private:
  void                      clear_impl () override;
  void                      finalize_changes_impl () override;
  std::vector<IntervalType> compute_cached_sample_ranges () const override;
  std::vector<AutomationCacheEntry> automation_sequences_;
};
 
} // namespace zrythm::dsp
 
Q_DECLARE_METATYPE (std::vector<zrythm::dsp::TimelineDataCache::IntervalType>)