Controller.hpp

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <unordered_map>
 
// Third-party includes
#include <nlohmann/json.hpp>
 
// Project includes
#include "ConnectionValidator.hpp"
#include "NodeFactory.hpp"
#include "TransportFactory.hpp"
#include <dfx-hooks/Graph.hpp>
#include <dfx-utilities/CopyMoveControl.hpp>
#include <dfx-utilities/RecyclableIdAllocator.hpp>
 
namespace dfx::Graph
{
class Controller
{
public:
    Controller(NodeFactory & nodeFactory, TransportFactory & transportFactory);
    ~Controller() = default;
    DFX_DISABLE_COPY_AND_MOVE(Controller);


    Core::Node::Id addNode(std::string_view type, std::string_view name,
                           nlohmann::json config = {});

    Core::Node::Id addNode(Core::Node::Id id,
                           std::string_view type, std::string_view name,
                           nlohmann::json config = {});

    bool removeNode(Core::Node::Id id) noexcept;

    bool removeNode(std::string_view name) noexcept;

    bool hasNode(Core::Node::Id id) const noexcept;
    bool hasNode(std::string_view name) const noexcept;
    bool hasNodeType(std::string_view type) const noexcept;

    std::vector<std::string> allNodeType() const;
    std::vector<std::string> allNodeName() const;
    std::vector<Core::Node::Id> allNodeId() const;

    Core::NodePtr node(Core::Node::Id id) const;
    Core::NodePtr node(std::string_view name) const;
    std::vector<Core::NodePtr> nodes() const;



    Core::Channel::Id addChannel(std::string_view src, std::string_view dst,
                                 nlohmann::json srcConfig = {}, nlohmann::json dstConfig = {},
                                 std::size_t errorLimit = 0);

    Core::Channel::Id addChannel(Core::Endpoint::Descriptor src, Core::Endpoint::Descriptor dst,
                                 nlohmann::json srcConfig = {}, nlohmann::json dstConfig = {},
                                 std::size_t errorLimit = 0);

    bool removeChannel(Core::Channel::Id id) noexcept;

    bool hasChannel(Core::Channel::Id id) const noexcept;
    std::vector<Core::Channel::Id> allChannelId() const;

    Core::ChannelPtr channel(Core::Channel::Id id) const;

    std::vector<Core::ChannelPtr> channels() const;

 
public:

    NodeFactory & nodeFactory() noexcept             { return _nodeFactory; }

    NodeFactory const & nodeFactory() const noexcept { return _nodeFactory; }

    TransportFactory & transportFactory() noexcept             { return _transportFactory; }

    TransportFactory const & transportFactory() const noexcept { return _transportFactory; }

    ConnectionValidator & connectionValidator() noexcept             { return _connectionValidator; }

    ConnectionValidator const & connectionValidator() const noexcept { return _connectionValidator; }

 
public:

    void registerHook(Hooks::Graph * hook);

    void deregisterHook(Hooks::Graph * hook) noexcept;

 
private:
    void _addNode(Core::Node::Id nodeId, std::string_view type, std::string_view name,
                  nlohmann::json config);
    void _removeNode(std::unordered_map<Core::Node::Id, Core::NodePtr>::iterator itr) noexcept;
 
    Core::Channel::Id _addChannel(Core::SourceTransportPtr src, Core::DestinationTransportPtr dst, std::size_t errorLimit);
 
private:
    NodeFactory &       _nodeFactory;
    TransportFactory &  _transportFactory;
    ConnectionValidator _connectionValidator;
 
    std::unordered_map<Core::Node::Id, Core::NodePtr>       _nodes;
    std::unordered_map<Core::Channel::Id, Core::ChannelPtr> _channels;
 
    Utils::RecyclableIdAllocator<Core::Node::Id>    _nodeIdAllocator;
    Utils::RecyclableIdAllocator<Core::Channel::Id> _channelIdAllocator;
 
private:
    std::vector<Hooks::Graph *> _hooks;
};
} // !namespace dfx::Graph