history.hpp

 
// File: history.hpp                                                          //
// Project: respond                                                           //
// Created Date: 2026-02-05                                                   //
// Author: Matthew Carroll                                                    //
// -----                                                                      //
// Last Modified: 2026-05-06                                                  //
// Modified By: Matthew Carroll                                               //
// -----                                                                      //
// Copyright (c) 2026 Syndemics Lab at Boston Medical Center                  //
#ifndef RESPOND_HISTORY_HPP_
#define RESPOND_HISTORY_HPP_
 
#include <algorithm>
#include <map>
#include <utility>
#include <vector>
 
#include <Eigen/Dense>
 
namespace respond {
enum class HistoryMode { Snapshot, Accumulated };
 
inline HistoryMode GetDefaultHistoryMode(const std::string &name) {
    if (name == "intervention_admission" || name == "total_overdose" ||
        name == "fatal_overdose" || name == "background_death") {
        return HistoryMode::Accumulated;
    }
    return HistoryMode::Snapshot;
}
 
class History {
public:
    History(const std::string &name = "state",
            const std::string &log_name = "console")
        : History(name, log_name, GetDefaultHistoryMode(name)) {}
 
    History(const std::string &name, const std::string &log_name,
            HistoryMode mode)
        : _log_name(log_name), _name(name), _mode(mode) {}
 
    ~History() = default;
    History(const History &other) {
        _timesteps = other.GetRecordedTimesteps();
        _states = other.GetRecordedStates();
        _name = other.GetHistoryName();
        _log_name = other.GetLogName();
        _mode = other.GetHistoryMode();
        _pending_state = other.GetPendingState();
    }
 
    History &operator=(const History &other) {
        if (this != &other) {
            _timesteps = other.GetRecordedTimesteps();
            _states = other.GetRecordedStates();
            _name = other.GetHistoryName();
            _log_name = other.GetLogName();
            _mode = other.GetHistoryMode();
            _pending_state = other.GetPendingState();
        }
        return *this;
    }
 
    History(History &&other) noexcept {
        _timesteps = std::move(other._timesteps);
        _states = std::move(other._states);
        _name = other.GetHistoryName();
        _log_name = other.GetLogName();
        _mode = other.GetHistoryMode();
        _pending_state = std::move(other._pending_state);
    }
 
    History &operator=(History &&other) noexcept {
        if (this != &other) {
            _timesteps = std::move(other._timesteps);
            _states = std::move(other._states);
            _name = other.GetHistoryName();
            _log_name = other.GetLogName();
            _mode = other.GetHistoryMode();
            _pending_state = std::move(other._pending_state);
        }
        return *this;
    }
 
    bool operator==(const History &other) const {
        return GetHistoryName() == other.GetHistoryName() &&
               GetLogName() == other.GetLogName() &&
               GetHistoryMode() == other.GetHistoryMode() &&
               GetStateMap() == other.GetStateMap() &&
               GetPendingState().isApprox(other.GetPendingState());
    }
 
    bool operator!=(const History &other) const { return !(*this == other); }
 
    std::map<int, Eigen::VectorXd> GetStateMap() const {
        std::map<int, Eigen::VectorXd> state_map;
        for (size_t index = 0; index < _timesteps.size(); ++index) {
            state_map[_timesteps[index]] = _states[index];
        }
        return state_map;
    }
 
    const std::vector<int> &GetRecordedTimesteps() const { return _timesteps; }
 
    const std::vector<Eigen::VectorXd> &GetRecordedStates() const {
        return _states;
    }
 
    HistoryMode GetHistoryMode() const { return _mode; }
 
    bool HasPendingState() const { return _pending_state.size() > 0; }
 
    Eigen::VectorXd GetPendingState() const { return _pending_state; }
 
    int GetLatestRecordedTimestep() const {
        if (_timesteps.empty()) {
            return -1;
        }
        return _timesteps.back();
    }
 
    std::string GetHistoryName() const { return _name; }
 
    std::string GetLogName() const { return _log_name; }
 
    std::vector<Eigen::VectorXd> GetStateAsVector() const {
        std::vector<Eigen::VectorXd> ret;
        if (_states.empty()) {
            // warn empty state vector - no states recorded
            return {};
        }
        int default_size = _states.front().size();
        int tstep = 0;
        for (size_t index = 0; index < _timesteps.size(); ++index) {
            const int recorded_timestep = _timesteps[index];
            const auto &recorded_state = _states[index];
            if (recorded_timestep > tstep) {
                // Fill gap: raise error if timestep mapping is invalid
            }
            while (recorded_timestep > tstep) {
                ret.push_back(GetZeroVector(default_size));
                tstep++;
            }
            ret.push_back(recorded_state);
            tstep++;
        }
        return ret;
    }
 
    void AddState(const Eigen::VectorXd &state, int timestep = -1) {
        if (timestep < 0) {
            timestep = GetNextTimestep();
        }
 
        const auto existing =
            std::find(_timesteps.begin(), _timesteps.end(), timestep);
        if (existing != _timesteps.end()) {
            const auto index =
                static_cast<size_t>(existing - _timesteps.begin());
            _states[index] = state;
            return;
        }
 
        _timesteps.push_back(timestep);
        _states.push_back(state);
    }
 
    void RecordSnapshot(const Eigen::VectorXd &state, int timestep) {
        AddState(state, timestep);
    }
 
    void AccumulateState(const Eigen::VectorXd &state) {
        if (_mode != HistoryMode::Accumulated) {
            AddState(state);
            return;
        }
 
        if (_pending_state.size() == 0) {
            _pending_state = state;
            return;
        }
        _pending_state += state;
    }
 
    void FlushPendingState(int timestep, Eigen::Index state_size) {
        if (_mode != HistoryMode::Accumulated) {
            return;
        }
 
        Eigen::VectorXd value;
        if (_pending_state.size() > 0) {
            value = _pending_state;
        } else {
            value = Eigen::VectorXd::Zero(state_size);
        }
 
        AddState(value, timestep);
        _pending_state.resize(0);
    }
 
    void Clear() {
        _timesteps.clear();
        _states.clear();
        _pending_state.resize(0);
    }
 
private:
    std::string _log_name;
    std::string _name;
    HistoryMode _mode;
    std::vector<int> _timesteps;
    std::vector<Eigen::VectorXd> _states;
    Eigen::VectorXd _pending_state;
 
    int GetNextTimestep() {
        if (_timesteps.empty()) {
            return 0;
        }
        return _timesteps.back() + 1;
    }
 
    Eigen::VectorXd GetZeroVector(const int &size) const {
        return Eigen::VectorXd::Zero(size);
    }
};
} // namespace respond
 
#endif // RESPOND_HISTORY_HPP_