midi_mapping.h

// SPDX-FileCopyrightText: © 2019-2022, 2024-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/parameter.h"
#include "utils/icloneable.h"
#include "utils/iobject_registry.h"
 
#include <nlohmann/json_fwd.hpp>
 
#define MIDI_MAPPINGS (PROJECT->midi_mappings_)
 
namespace zrythm::engine::session
{
class MidiMapping : public QObject
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
public:
  MidiMapping (utils::IObjectRegistry &registry, QObject * parent = nullptr);
  Q_DISABLE_COPY_MOVE (MidiMapping)
 
public:
  friend void init_from (
    MidiMapping           &obj,
    const MidiMapping     &other,
    utils::ObjectCloneType clone_type);
 
  void set_enabled (bool enabled) { enabled_.store (enabled); }
 
  void apply (std::array<midi_byte_t, 3> buf);
 
private:
  static constexpr auto kKeyKey = "key"sv;
  static constexpr auto kDeviceIdKey = "deviceIdentifier"sv;
  static constexpr auto kDestIdKey = "destId"sv;
  static constexpr auto kEnabledKey = "enabled"sv;
  friend void           to_json (nlohmann::json &j, const MidiMapping &mapping);
  friend void from_json (const nlohmann::json &j, MidiMapping &mapping);
 
public:
  utils::IObjectRegistry &registry_;

  std::array<midi_byte_t, 3> key_ = {};

  std::optional<utils::Utf8String> device_id_;

  std::optional<dsp::ProcessorParameterUuidReference> dest_id_;

  /* TODO: check if really should be atomic */
  std::atomic<bool> enabled_ = false;
};

class MidiMappings final
{
public:
  MidiMappings (utils::IObjectRegistry &registry);

  void bind_at (
    std::array<midi_byte_t, 3>           buf,
    std::optional<utils::Utf8String>     device_id,
    dsp::ProcessorParameterUuidReference dest_port,
    int                                  idx,
    bool                                 fire_events);

  void unbind (int idx, bool fire_events);
 
  void bind_device (
    std::array<midi_byte_t, 3>           buf,
    std::optional<utils::Utf8String>     device_id,
    dsp::ProcessorParameterUuidReference dest_port,
    bool                                 fire_events)
  {
    bind_at (
      buf, device_id, dest_port, static_cast<int> (mappings_.size ()),
      fire_events);
  }
 
  void bind_track (
    std::array<midi_byte_t, 3>           buf,
    dsp::ProcessorParameterUuidReference dest_port,
    bool                                 fire_events)
  {
    bind_at (
      buf, std::nullopt, dest_port, static_cast<int> (mappings_.size ()),
      fire_events);
  }
 
  int get_mapping_index (const MidiMapping &mapping) const;

  void apply_from_cc_events (const dsp::MidiEventVector &events);

  void apply (const midi_byte_t * buf);

  int get_for_port (
    const dsp::ProcessorParameter &dest_port,
    std::vector<MidiMapping *> *   arr) const;
 
  friend void init_from (
    MidiMappings          &obj,
    const MidiMappings    &other,
    utils::ObjectCloneType clone_type)
  {
    // TODO
    // utils::clone_unique_ptr_container (obj.mappings_, other.mappings_);
  }
 
private:
  static constexpr auto kMappingsKey = "mappings"sv;
  friend void to_json (nlohmann::json &j, const MidiMappings &mappings);
  friend void from_json (const nlohmann::json &j, MidiMappings &mappings);
 
public:
  std::vector<std::unique_ptr<MidiMapping>> mappings_;
 
private:
  utils::IObjectRegistry &registry_;
};
 
}