timeline_data_cache.h

// SPDX-FileCopyrightText: © 2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#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 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,
    const juce::MidiMessageSequence &sequence);

  const juce::MidiMessageSequence &get_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, juce::MidiMessageSequence> midi_sequences_;

  juce::MidiMessageSequence merged_midi_events_;
};

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

  struct AudioRegionEntry
  {
    juce::AudioSampleBuffer audio_buffer;

    units::sample_t start_sample;

    units::sample_t end_sample;
  };

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

  const std::vector<AudioRegionEntry> &get_audio_regions () const
  {
    return audio_regions_;
  }
 
  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<AudioRegionEntry> audio_regions_;
};

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

  struct AutomationCacheEntry
  {
    std::vector<float> automation_values;

    units::sample_t start_sample;

    units::sample_t end_sample;
  };

  void add_automation_sequence (
    IntervalType              interval,
    const std::vector<float> &automation_values);

  const std::vector<AutomationCacheEntry> &get_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>)