Context.h

// Copyright 2026 Matteo Fusi and Contributors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef SIMO_SIMULATIONCONTEXT_H
#define SIMO_SIMULATIONCONTEXT_H
 
#include <cstdint>
#include <expected>
#include <functional>
#include <string>
#include <vector>
 
#include "./Time.h"
#include "./internal/RadixHeap.h"
#include "Simo/compiler/Compiler.h"
#include "Simo/module/Module.h"
#include "Simo/parameter/ParameterTrie.h"
 
namespace Simo {
 
namespace Parameter {
class Parameter;
template <typename T>
class ParameterTyped;
}  // namespace Parameter
 
class Module;
class Parameters;
 
class Period;
using SimulationCallable = std::function<void(Time)>;

class SIMO_PUBLIC Context {
 public:
  enum struct State : uint8_t {
    INITIALIZATION,
    PORT_CONNECTION,
    RUNNING,
    STOPPED,
    ERROR
  };
 
  enum struct RunStatus : uint8_t {
    EVENTS_IN_QUEUE,
    STOPPED,
  };
 
  Context();
 
  ~Context() = default;

  [[nodiscard]]
  InitializationStatus initialize();

  std::expected<RunStatus, InitializationStatus> run(const Time& time_delta);

  std::expected<RunStatus, InitializationStatus> run_at(const Time& final_time);

  void schedule_at(const Time& time_target, const SimulationCallable& callable);
  void schedule_at(const Time& time_target,
                   const std::function<void()>& callable);

  void schedule_in(const Time& time_delta, const SimulationCallable& callable);
  void schedule_in(const Time& time_delta,
                   const std::function<void()>& callable);
 
  // Methods to initialize the context

  template <typename T>
  [[maybe_unused]]
  Parameter::ParameterTyped<T>& add_parameter(const std::string& name,
                                              const T& value) {
    return parameters.add<T>(name, value);
  }

  void add(Module& module, Parameters&);

  void remove(const Module& module);
 
  template <typename Function>
  void foreach_module(Function f) const {
    for (const auto& module : modules | std::views::keys) {
      f(*module);
    }
  }
 
  [[nodiscard]] State get_state() const;
  [[nodiscard]] Time current_time() const;
 
 private:
  State state{State::INITIALIZATION};
  Time currentTime = Time::zero;
  std::unique_ptr<Internal::RadixHeap> nextTickHeap;
  std::unordered_map<Time, std::vector<SimulationCallable>> scheduledTasks;
 
  Parameter::ParameterTrie parameters;
 
  std::vector<std::pair<Module*, Parameters*>> modules;
};
}  // namespace Simo
 
#endif  // SIMO_SIMULATIONCONTEXT_H