PhaseManager.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/ConditionParser.hpp>
#include <icarus/core/Error.hpp>
#include <icarus/signal/Registry.hpp>
 
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
namespace icarus {

struct PhaseTransition {
    int32_t from_phase = -1; 
    int32_t to_phase = 0;    
    std::string condition;   
 
    PhaseTransition() = default;
    PhaseTransition(int32_t from, int32_t to, std::string cond)
        : from_phase(from), to_phase(to), condition(std::move(cond)) {}
};

struct PhaseConfig {
    std::map<std::string, int32_t> definitions;

    std::string initial_phase;

    std::vector<PhaseTransition> transitions;

    std::string entity_prefix;

    [[nodiscard]] std::optional<int32_t> GetPhaseValue(const std::string &name) const {
        auto it = definitions.find(name);
        if (it != definitions.end()) {
            return it->second;
        }
        return std::nullopt;
    }

    [[nodiscard]] std::string GetPhaseName(int32_t value) const {
        for (const auto &[name, val] : definitions) {
            if (val == value) {
                return name;
            }
        }
        return "";
    }
};

template <typename Scalar> class PhaseManager {
  public:
    PhaseManager() = default;

    void Configure(const PhaseConfig &config) {
        config_ = config;
 
        // Validate and set initial phase
        auto initial_value = config_.GetPhaseValue(config_.initial_phase);
        if (!initial_value.has_value()) {
            throw ConfigError("PhaseManager", "initial_phase '" + config_.initial_phase +
                                                  "' not found in definitions");
        }
        current_phase_ = *initial_value;
        previous_phase_ = current_phase_;
 
        // Pre-compile all transition conditions
        ConditionParser<Scalar> parser;
        compiled_conditions_.clear();
        compiled_conditions_.reserve(config_.transitions.size());
 
        for (size_t i = 0; i < config_.transitions.size(); ++i) {
            const auto &trans = config_.transitions[i];
            try {
                compiled_conditions_.push_back(parser.Parse(trans.condition));
            } catch (const ConditionError &e) {
                throw ConfigError("PhaseManager", "invalid condition in transition " +
                                                      std::to_string(i) + ": " + e.what());
            }
        }
 
        configured_ = true;
    }

    void EvaluateTransitions(const SignalRegistry<Scalar> &registry) {
        if (!configured_) {
            return;
        }
 
        previous_phase_ = current_phase_;
        phase_changed_ = false;
 
        for (size_t i = 0; i < config_.transitions.size(); ++i) {
            const auto &trans = config_.transitions[i];
 
            // Check if transition applies to current phase
            if (trans.from_phase != -1 && trans.from_phase != current_phase_) {
                continue;
            }
 
            // Evaluate condition
            try {
                if (compiled_conditions_[i].Evaluate(registry)) {
                    // Transition fires
                    current_phase_ = trans.to_phase;
                    phase_changed_ = true;
                    break; // No cascade: stop after first transition
                }
            } catch (const SignalNotFoundError &) {
                // Signal not found - condition cannot be evaluated
                // Skip this transition silently (signal may not exist yet)
            }
        }
    }

    [[nodiscard]] int32_t CurrentPhase() const { return current_phase_; }

    [[nodiscard]] std::string CurrentPhaseName() const {
        return config_.GetPhaseName(current_phase_);
    }

    [[nodiscard]] int32_t PreviousPhase() const { return previous_phase_; }

    [[nodiscard]] bool PhaseChangedThisStep() const { return phase_changed_; }

    [[nodiscard]] bool IsConfigured() const { return configured_; }

    [[nodiscard]] std::string GetPhaseSignalPath() const {
        if (config_.entity_prefix.empty()) {
            return "phase";
        }
        return config_.entity_prefix + ".phase";
    }

    [[nodiscard]] const PhaseConfig &GetConfig() const { return config_; }

    void Reset() {
        if (configured_) {
            auto initial_value = config_.GetPhaseValue(config_.initial_phase);
            if (initial_value.has_value()) {
                current_phase_ = *initial_value;
                previous_phase_ = current_phase_;
                phase_changed_ = false;
            }
        }
    }

    void SetPhase(const std::string &phase_name) {
        auto value = config_.GetPhaseValue(phase_name);
        if (!value.has_value()) {
            throw ConfigError("PhaseManager", "phase '" + phase_name + "' not found");
        }
        previous_phase_ = current_phase_;
        current_phase_ = *value;
        phase_changed_ = (current_phase_ != previous_phase_);
    }

    void SetPhaseValue(int32_t value) {
        previous_phase_ = current_phase_;
        current_phase_ = value;
        phase_changed_ = (current_phase_ != previous_phase_);
    }
 
  private:
    PhaseConfig config_;
    std::vector<CompiledCondition<Scalar>> compiled_conditions_;
 
    int32_t current_phase_ = 0;
    int32_t previous_phase_ = 0;
    bool phase_changed_ = false;
    bool configured_ = false;
};
 
} // namespace icarus