port_connections_manager.h

// SPDX-FileCopyrightText: © 2021, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/port_connection.h"
#include "utils/icloneable.h"
#include "utils/qt.h"
 
#include <nlohmann/json_fwd.hpp>
 
namespace zrythm::dsp
{

class PortConnectionsManager : public QObject
{
  Q_OBJECT
  QML_ELEMENT
 
public:
  using PortConnection = dsp::PortConnection;
  using ConnectionsVector = std::vector<PortConnection *>;
 
  explicit PortConnectionsManager (QObject * parent = nullptr);
 
private:
  using ConnectionHashTable = std::unordered_map<PortUuid, ConnectionsVector>;
 
  static const auto &
  connection_ref_predicate (const utils::QObjectUniquePtr<PortConnection> &conn)
  {
    return *conn;
  }
 
public:
  void regenerate_hashtables ();

  int
  get_sources_or_dests (ConnectionsVector * arr, const PortUuid &id, bool sources)
    const;
 
  int get_sources (ConnectionsVector * arr, const PortUuid &id) const
  {
    return get_sources_or_dests (arr, id, true);
  }
 
  int get_dests (ConnectionsVector * arr, const PortUuid &id) const
  {
    return get_sources_or_dests (arr, id, false);
  }
 
  int get_num_sources (const PortUuid &id) const
  {
    return get_sources (nullptr, id);
  }
  int get_num_dests (const PortUuid &id) const
  {
    return get_dests (nullptr, id);
  }
 
  auto get_connection_count () const noexcept { return connections_.size (); }

  int get_unlocked_sources_or_dests (
    ConnectionsVector * arr,
    const PortUuid     &id,
    bool                sources) const;

  PortConnection * get_source_or_dest (const PortUuid &id, bool sources) const;

  PortConnection *
  get_connection (const PortUuid &src, const PortUuid &dest) const;
 
  bool connection_exists (const PortUuid &src, const PortUuid &dest) const
  {
    return get_connection (src, dest) != nullptr;
  }

  bool
  update_connection (const PortConnection &before, const PortConnection &after);
 
  bool update_connection (
    const PortUuid &src,
    const PortUuid &dest,
    float           multiplier,
    bool            locked,
    bool            enabled);

  const PortConnection * add_connection (
    const PortUuid &src,
    const PortUuid &dest,
    float           multiplier,
    bool            locked,
    bool            enabled);

  const PortConnection *
  add_default_connection (const PortUuid &src, const PortUuid &dest, bool locked)
  {
    return add_connection (src, dest, 1.0f, locked, true);
  }
 
  const PortConnection * add_connection (const PortConnection &conn)
  {
    return add_connection (
      conn.src_id_, conn.dest_id_, conn.multiplier_, conn.locked_,
      conn.enabled_);
  }

  bool remove_connection (const PortUuid &src, const PortUuid &dest);

  void remove_all_connections (const PortUuid &pi);

  void reset_connections_from_other (const PortConnectionsManager * other);
 
  bool contains_connection (const PortConnection &conn) const;
 
  void print_ht (const ConnectionHashTable &ht);
 
  void print () const;
 
  friend void init_from (
    PortConnectionsManager       &obj,
    const PortConnectionsManager &other,
    utils::ObjectCloneType        clone_type);
 
  void clear_all ()
  {
    connections_.clear ();
    regenerate_hashtables ();
  }
 
  auto &connections () const { return connections_; }
 
private:
  friend void to_json (nlohmann::json &j, const PortConnectionsManager &pcm);
  friend void from_json (const nlohmann::json &j, PortConnectionsManager &pcm);
 
  void add_or_replace_connection (
    ConnectionHashTable  &ht,
    const PortUuid       &id,
    const PortConnection &conn);
 
  void remove_connection (size_t idx);
 
private:
  std::vector<utils::QObjectUniquePtr<PortConnection>> connections_;

  ConnectionHashTable src_ht_;

  ConnectionHashTable dest_ht_;
};
 
} // namespace zrythm::dsp