Project.hpp

//
// Created by owd on 25/06/2026.
//
 
#ifndef ECHOMAP_PROJECT_HPP
#define ECHOMAP_PROJECT_HPP
 
#include <implot3d.h>
 
#include <flat_map>
#include <map>
#include <memory>
#include <ranges>
#include <string_view>
 
#include "BidirectionalUnorderedMapping.hpp"
#include "Object.hpp"
 
namespace echomap
{
 
class Signal;
class Sensor;
 
class Project : public Object<Project>
{
    std::flat_map<id_type, std::shared_ptr<Signal>> signals;
    std::flat_map<id_type, std::unique_ptr<Sensor>> sensors;
 
public:
    explicit Project(std::string_view project_name = {});
 
    // ReSharper disable once CppHidingFunction - We will never want destruct a Project through an Object pointer.
    virtual ~Project();

    const Signal* add_signal(std::shared_ptr<Signal>&& signal);

    const Sensor* add_sensor(std::unique_ptr<Sensor>&& sensor);

    void add_association(
            const Signal& signal,
            const Sensor& sensor
    );

    void add_association(
            id_type signal_id,
            id_type sensor_id
    );

    [[nodiscard]] auto observe_signals() const noexcept
    {
        return signals | std::views::values |
               std::views::transform([](const std::shared_ptr<Signal>& container) -> const Signal& {
                   /*
                    * N.B. for this functor and all similar ones: this is an assertion, not an exception. If the Project
                    * possesses a container for something, but that container is empty, it's definitely violated an
                    * invariant. Failing on a name-based lookup would be exceptional, but this assertion failing
                    * indicates a bug.
                    *
                    * We intentionally produce references (as opposed to raw pointers) to indicate the non-optionality
                    * of these containers.
                    */
                   assert(container);
                   return *container;
               });
    }

    [[nodiscard]] auto share_signals() const noexcept
    {
        return signals | std::views::values;
    }

    [[nodiscard]] size_t get_sensors_count() const noexcept;

    [[nodiscard]] auto observe_sensors() const noexcept
    {
        return sensors | std::views::values |
               std::views::transform([](const std::unique_ptr<Sensor>& container) -> const Sensor& {
                   assert(container);
                   return *container;
               });
    }

    [[nodiscard]] auto observe_associations() const
    {
        return requested_channel_mapping | std::views::transform([this](const auto& association) {
                   return resolve_pair(association.first, association.second);
               }) |
               std::views::filter([](const auto& optional) {
                   return optional.has_value();
               }) |
               std::views::transform([](const auto& optional) {
                   return *optional;
               });
    }
 
    [[nodiscard]] static ImPlot3DPoint get_sensor_point(
            int idx,
            const void* project_instance
    ) noexcept;

    [[nodiscard]] Sensor& get_mutable_sensor(id_type sensor_id);
 
private:
    [[nodiscard]] std::optional<std::pair<
            const Signal&,
            const Sensor&>>
    resolve_pair(
            id_type signal_id,
            id_type sensor_id
    ) const;

    BidirectionalUnorderedMapping<id_type, id_type> requested_channel_mapping;
};
 
template <> constexpr std::string_view Object<Project>::class_name = "Project";
 
} // namespace echomap
 
#endif // ECHOMAP_PROJECT_HPP