integration_interface.hpp

#pragma once
 
#include <core/concepts.hpp>
#include <signal/signal_processor.hpp>
#include <functional>
#include <memory>
#include <vector>
#include <chrono>
#include <optional>
#include <any>
 
namespace diffeq::interfaces {
 
template<system_state StateType, can_be_time TimeType>
class IntegrationInterface {
public:
    using state_type = StateType;
    using time_type = TimeType;
    using signal_processor_type = signal::SignalProcessor<StateType>;
    
    enum class InfluenceMode {
        DISCRETE_EVENT,     // Signal causes instantaneous state jump
        CONTINUOUS_SHIFT,   // Signal modifies ODE trajectory continuously  
        PARAMETER_UPDATE,   // Signal updates integration parameters
        OUTPUT_TRIGGER      // Signal triggers output/logging
    };
    
    struct SignalInfluence {
        InfluenceMode mode;
        std::string signal_type;
        std::function<void(const std::any&, state_type&, time_type)> handler;
        double priority = 1.0;
        bool is_active = true;
    };
    
    struct OutputStream {
        std::string stream_id;
        std::function<void(const state_type&, time_type)> output_func;
        std::chrono::microseconds interval{1000}; // Output frequency
        std::chrono::steady_clock::time_point last_output;
        bool is_active = true;
    };
    
private:
    std::shared_ptr<signal_processor_type> signal_processor_;
    std::vector<SignalInfluence> signal_influences_;
    std::vector<OutputStream> output_streams_;
    
    // Current integration state
    std::optional<state_type> current_state_;
    time_type current_time_ = {};
    
    // Trajectory modification functions
    std::vector<std::function<void(time_type, state_type&, state_type&)>> trajectory_modifiers_;
    
public:
    explicit IntegrationInterface(std::shared_ptr<signal_processor_type> processor = nullptr)
        : signal_processor_(processor ? processor : signal::make_signal_processor<StateType>()) {
        setup_signal_handling();
    }
    
    template<typename SignalDataType>
    void register_signal_influence(
        std::string_view signal_type,
        InfluenceMode mode,
        std::function<void(const SignalDataType&, state_type&, time_type)> handler,
        double priority = 1.0) {
        
        SignalInfluence influence{
            .mode = mode,
            .signal_type = std::string(signal_type),
            .handler = [h = std::move(handler)](const std::any& signal_data, state_type& state, time_type t) {
                try {
                    const auto& typed_data = std::any_cast<const SignalDataType&>(signal_data);
                    h(typed_data, state, t);
                } catch (const std::bad_any_cast&) {
                    // Type mismatch - ignore silently
                }
            },
            .priority = priority,
            .is_active = true
        };
        
        signal_influences_.push_back(std::move(influence));
        
        // Register with signal processor
        signal_processor_->template register_handler<SignalDataType>(signal_type,
            [this, signal_type_str = std::string(signal_type)](const signal::Signal<SignalDataType>& sig) {
                handle_signal(signal_type_str, sig.data);
            });
    }
    
    void register_output_stream(
        std::string_view stream_id,
        std::function<void(const state_type&, time_type)> output_func,
        std::chrono::microseconds interval = std::chrono::microseconds{1000}) {
        
        OutputStream stream{
            .stream_id = std::string(stream_id),
            .output_func = std::move(output_func),
            .interval = interval,
            .last_output = std::chrono::steady_clock::now(),
            .is_active = true
        };
        
        output_streams_.push_back(std::move(stream));
    }
    
    void add_trajectory_modifier(
        std::function<void(time_type, state_type&, state_type&)> modifier) {
        trajectory_modifiers_.push_back(std::move(modifier));
    }
    
    template<typename OriginalODE>
    auto make_signal_aware_ode(OriginalODE&& original_ode) {
        return [this, ode = std::forward<OriginalODE>(original_ode)]
               (time_type t, const state_type& y, state_type& dydt) {
            
            // Update current state for signal handling
            current_state_ = y;
            current_time_ = t;
            
            // Compute original dynamics
            ode(t, y, dydt);
            
            // Apply trajectory modifiers from continuous signal influences
            state_type modified_state = y;
            for (auto& modifier : trajectory_modifiers_) {
                modifier(t, modified_state, dydt);
            }
            
            // Handle real-time outputs
            process_output_streams(y, t);
        };
    }
    
    void apply_discrete_event(const std::string& signal_type, const std::any& signal_data) {
        if (!current_state_) return;
        
        for (auto& influence : signal_influences_) {
            if (influence.signal_type == signal_type && 
                influence.mode == InfluenceMode::DISCRETE_EVENT &&
                influence.is_active) {
                
                influence.handler(signal_data, *current_state_, current_time_);
            }
        }
    }
    
    std::optional<state_type> get_current_state() const {
        return current_state_;
    }
    
    time_type get_current_time() const {
        return current_time_;
    }
    
    void set_signal_influence_active(const std::string& signal_type, bool active) {
        for (auto& influence : signal_influences_) {
            if (influence.signal_type == signal_type) {
                influence.is_active = active;
            }
        }
    }
    
    void set_output_stream_active(const std::string& stream_id, bool active) {
        for (auto& stream : output_streams_) {
            if (stream.stream_id == stream_id) {
                stream.is_active = active;
            }
        }
    }
    
    std::shared_ptr<signal_processor_type> get_signal_processor() {
        return signal_processor_;
    }
    
private:
    void setup_signal_handling() {
        // Basic signal handling is set up when influences are registered
    }
    
    void handle_signal(const std::string& signal_type, const std::any& signal_data) {
        // Handle different influence modes
        for (auto& influence : signal_influences_) {
            if (influence.signal_type == signal_type && influence.is_active) {
                
                if (influence.mode == InfluenceMode::DISCRETE_EVENT && current_state_) {
                    // Apply immediate state modification
                    influence.handler(signal_data, *current_state_, current_time_);
                    
                } else if (influence.mode == InfluenceMode::CONTINUOUS_SHIFT) {
                    // Add to trajectory modifiers for continuous influence
                    add_trajectory_modifier([influence, signal_data]
                        (time_type t, state_type& state, state_type& /* dydt */) {
                        influence.handler(signal_data, state, t);
                    });
                    
                } else if (influence.mode == InfluenceMode::PARAMETER_UPDATE) {
                    // Handle parameter updates (integrator-specific)
                    if (current_state_) {
                        influence.handler(signal_data, *current_state_, current_time_);
                    }
                    
                } else if (influence.mode == InfluenceMode::OUTPUT_TRIGGER && current_state_) {
                    // Trigger immediate output
                    for (auto& stream : output_streams_) {
                        if (stream.is_active) {
                            stream.output_func(*current_state_, current_time_);
                        }
                    }
                }
            }
        }
    }
    
    void process_output_streams(const state_type& state, time_type t) {
        auto now = std::chrono::steady_clock::now();
        
        for (auto& stream : output_streams_) {
            if (!stream.is_active) continue;
            
            if (now - stream.last_output >= stream.interval) {
                stream.output_func(state, t);
                stream.last_output = now;
            }
        }
    }
};
 
template<system_state StateType, can_be_time TimeType = double>
auto make_integration_interface(
    std::shared_ptr<signal::SignalProcessor<StateType>> processor) {
    return std::make_unique<IntegrationInterface<StateType, TimeType>>(processor);
}
 
template<system_state StateType, can_be_time TimeType = double>
auto make_integration_interface() {
    return std::make_unique<IntegrationInterface<StateType, TimeType>>();
}
 
} // namespace diffeq::interfaces