timestep.hpp

 
// File: timestep.hpp                                                         //
// Project: respond                                                           //
// Created Date: 2026-06-30                                                   //
// Author: Matthew Carroll                                                    //
// -----                                                                      //
// Last Modified: 2026-09-24                                                  //
// Modified By: Matthew Carroll                                               //
// -----                                                                      //
// Copyright (c) 2026 Syndemics Lab at Boston Medical Center                  //
#ifndef RESPOND_TIMESTEP_HPP_
#define RESPOND_TIMESTEP_HPP_
 
#include <memory>
#include <ostream>
#include <vector>
 
#include <respond/constants.hpp>
#include <respond/logging.hpp>
#include <respond/logging_config.hpp>
#include <respond/transition.hpp>
 
namespace respond {
 
class Timestep {
public:
    class TransitionSlotProxy {
    public:
        TransitionSlotProxy(Timestep &owner, size_t idx)
            : _owner(&owner), _idx(idx) {}
 
        Transition *operator->() {
            return &_owner->GetTransitionRefOrThrow(_idx);
        }
 
        Transition &operator*() {
            return _owner->GetTransitionRefOrThrow(_idx);
        }
 
        operator Transition &() {
            return _owner->GetTransitionRefOrThrow(_idx);
        }
 
        TransitionSlotProxy &operator=(const TransitionSlotProxy &other) {
            return *this = static_cast<const Transition &>(
                       other._owner->GetTransitionRefOrThrow(other._idx));
        }
 
        TransitionSlotProxy &operator=(const Transition &transition) {
            _owner->GetTransitionRefOrThrow(_idx);
            _owner->_transitions[_idx] = transition.clone();
            return *this;
        }
 
        TransitionSlotProxy &
        operator=(const std::unique_ptr<Transition> &transition) {
            if (!transition) {
                LogError(_owner->_log_name,
                         "Cannot assign null model pointer to simulation "
                         "slot.");
                throw std::invalid_argument(
                    "Error attempting to assign null model pointer.");
            }
            _owner->GetTransitionRefOrThrow(_idx);
            _owner->_transitions[_idx] = transition->clone();
            return *this;
        }
 
    private:
        Timestep *_owner;
        size_t _idx;
    };
 
    //
    // Rule of Five: Copy and Move Semantics
    //
 
    Timestep() : Timestep(LoggingConfig{}) {}
 
    [[deprecated("Use Timestep(LoggingConfig) instead")]]
    Timestep(const std::string &log_name)
        : Timestep(log_name, RESPOND_DEFAULT_LOG_FILE) {}
 
    [[deprecated("Use Timestep(LoggingConfig) instead")]]
    Timestep(const std::string &log_name, const std::string &log_filepath)
        : Timestep(LoggingConfig{log_name, log_filepath, false}) {}
 
    explicit Timestep(const LoggingConfig &logging_config)
        : _log_name(logging_config.logger_name),
          _logging_config(logging_config) {
        if (ConfigureLogger(_logging_config) == CreationStatus::kError) {
            throw std::runtime_error(
                "Error attempting to initialize timestep logger.");
        }
    }
 
    ~Timestep() = default;
 
    Timestep(const Timestep &other)
        : _log_name(other._log_name), _logging_config(other._logging_config) {
        for (const auto &t : other._transitions) {
            _transitions.push_back(std::move(t->clone()));
        }
    }
 
    Timestep &operator=(const Timestep &other) {
        if (this != &other) {
            std::vector<std::unique_ptr<Transition>> transitions;
            for (const auto &t : other._transitions) {
                transitions.push_back(t->clone());
            }
            _log_name = other._log_name;
            _logging_config = other._logging_config;
            _transitions = std::move(transitions);
        }
        return *this;
    }
 
    Timestep(Timestep &&other) noexcept
        : _log_name(std::move(other._log_name)),
          _logging_config(std::move(other._logging_config)),
          _transitions(std::move(other._transitions)) {
        other._transitions.clear();
    }
 
    Timestep &operator=(Timestep &&other) noexcept {
        if (this != &other) {
            _log_name = std::move(other._log_name);
            _logging_config = std::move(other._logging_config);
            _transitions = std::move(other._transitions);
            other._transitions.clear();
        }
        return *this;
    }
 
    //
    // Timestep Behavior Methods: Transition Management
    //
 
    const std::unique_ptr<Transition> &
    CreateTransition(const std::string &transition_name) {
        _transitions.push_back(Transition::Create(
            transition_name, transition_name, _logging_config));
        return _transitions.back();
    }
 
    void AddTransition(const std::unique_ptr<Transition> &transition) {
        if (!transition) {
            LogError(_log_name,
                     "Cannot add a null transition to the timestep.");
            throw std::invalid_argument(
                "Error attempting to add a null transition to timestep.");
        }
        _transitions.push_back(transition->clone());
    }
 
    std::unique_ptr<Transition> RemoveTransition(size_t idx) {
        if (idx >= _transitions.size()) {
            LogWarning(_log_name, "Index out of range in RemoveTransition: " +
                                      std::to_string(idx));
            throw std::out_of_range(
                "Error attempting to RemoveTransition by index.");
        }
        auto removed_transition = std::move(_transitions[idx]);
        _transitions.erase(_transitions.begin() + idx);
        return removed_transition;
    }
 
    void AddMatrixToTransition(const size_t &idx,
                               const Eigen::Ref<const Eigen::MatrixXd> &m) {
        if (idx >= _transitions.size()) {
            LogError(_log_name,
                     "Index out of range in AddMatrixToTransition: " +
                         std::to_string(idx));
            throw std::out_of_range(
                "Error attempting to AddMatrixToTransition by index.");
        }
        _transitions[idx]->AddMatrix(m);
    }
 
    void AddMatrixToTransition(const std::string &transition_name,
                               const Eigen::Ref<const Eigen::MatrixXd> &m) {
        for (size_t i = 0; i < _transitions.size(); ++i) {
            if (_transitions[i]->GetName() == transition_name) {
                _transitions[i]->AddMatrix(m);
                return;
            }
        }
        LogError(_log_name, "Transition not found in AddMatrixToTransition: " +
                                transition_name);
        throw std::invalid_argument(
            "Error attempting to AddMatrixToTransition by name: " +
            transition_name);
    }
 
    //
    // Getters and Setters for Transitions and Metadata
    //
 
    const std::unique_ptr<Transition> &GetTransition(const size_t &idx) const {
        if (idx >= _transitions.size()) {
            LogError(_log_name, "Index out of range in GetTransition: " +
                                    std::to_string(idx));
            throw std::out_of_range(
                "Error attempting to GetTransition by index.");
        }
        return _transitions[idx];
    }
 
    const std::unique_ptr<Transition> &
    GetTransition(const std::string &transition_name) const {
        for (const auto &t : _transitions) {
            if (t->GetName() == transition_name) {
                return t;
            }
        }
        LogError(_log_name,
                 "Transition not found in GetTransition: " + transition_name);
        throw std::invalid_argument(
            "Error attempting to GetTransition by name.");
    }
 
    std::vector<std::unique_ptr<Transition>> GetTransitions() const {
        std::vector<std::unique_ptr<Transition>> _ret;
        for (const auto &t : _transitions) {
            _ret.push_back(t->clone());
        }
        return _ret;
    }
 
    std::vector<std::string> GetTransitionNames() const {
        std::vector<std::string> names;
        for (const auto &t : _transitions) {
            names.push_back(t->GetName());
        }
        return names;
    }
 
    //
    // Logging and Output Methods
    //
 
    TransitionSlotProxy operator[](size_t idx) {
        GetTransitionRefOrThrow(idx);
        return TransitionSlotProxy(*this, idx);
    }
 
    const Transition &operator[](size_t idx) const {
        return GetTransitionRefOrThrow(idx);
    }
 
    friend std::ostream &operator<<(std::ostream &os, const Timestep &other) {
        os << "Timestep with the following transitions:\n";
        for (const auto &t : other._transitions) {
            os << " - " << t->GetName() << "\n";
        }
        return os;
    }
 
    bool operator==(const Timestep &other) const {
        if (_transitions.size() != other._transitions.size()) {
            return false;
        }
        for (size_t i = 0; i < _transitions.size(); ++i) {
            if (_transitions[i]->GetName() !=
                other._transitions[i]->GetName()) {
                return false;
            }
            if (_transitions[i]->GetMatrices().size() !=
                other._transitions[i]->GetMatrices().size()) {
                return false;
            }
            for (size_t j = 0; j < _transitions[i]->GetMatrices().size(); ++j) {
                if (!_transitions[i]->GetMatrices()[j].isApprox(
                        other._transitions[i]->GetMatrices()[j])) {
                    return false;
                }
            }
        }
        return true;
    }
 
    bool operator!=(const Timestep &other) const { return !(*this == other); }
 
private:
    Transition &GetTransitionRefOrThrow(size_t idx) {
        if (idx >= _transitions.size()) {
            LogError(_log_name, "Index out of range in transition access: " +
                                    std::to_string(idx));
            throw std::out_of_range("Error attempting to access transition by "
                                    "index.");
        }
        return *_transitions[idx];
    }
 
    const Transition &GetTransitionRefOrThrow(size_t idx) const {
        if (idx >= _transitions.size()) {
            LogError(_log_name, "Index out of range in transition access: " +
                                    std::to_string(idx));
            throw std::out_of_range("Error attempting to access transition by "
                                    "index.");
        }
        return *_transitions[idx];
    }
 
    std::string _log_name;
    LoggingConfig _logging_config;
    std::vector<std::unique_ptr<Transition>> _transitions;
};
} // namespace respond
 
#endif // RESPOND_TIMESTEP_HPP_