integrator_builder.hpp

#pragma once
 
#include "integrator_decorator.hpp"
#include "timeout_decorator.hpp"
#include "parallel_decorator.hpp"
#include "output_decorator.hpp"
#include "signal_decorator.hpp"
#include "interpolation_decorator.hpp"  // Fixed template parameter issues
#include "interprocess_decorator.hpp"   // Fixed template parameter issues
// #include "event_decorator.hpp"          // TODO: Fix remaining T template parameter references
#include <memory>
 
namespace diffeq::core::composable {
 
template<system_state S>
class IntegratorBuilder {
private:
    std::unique_ptr<AbstractIntegrator<S>> integrator_;
 
public:
    explicit IntegratorBuilder(std::unique_ptr<AbstractIntegrator<S>> integrator)
        : integrator_(std::move(integrator)) {
        
        if (!integrator_) {
            throw std::invalid_argument("Base integrator cannot be null");
        }
    }
 
    IntegratorBuilder& with_timeout(TimeoutConfig config = {}) {
        integrator_ = std::make_unique<TimeoutDecorator<S>>(
            std::move(integrator_), std::move(config));
        return *this;
    }
 
    IntegratorBuilder& with_parallel(ParallelConfig config = {}) {
        integrator_ = std::make_unique<ParallelDecorator<S>>(
            std::move(integrator_), std::move(config));
        return *this;
    }
 
    IntegratorBuilder& with_output(OutputConfig config = {}, 
                                  std::function<void(const S&, typename AbstractIntegrator<S>::time_type, size_t)> handler = nullptr) {
        integrator_ = std::make_unique<OutputDecorator<S>>(
            std::move(integrator_), std::move(config), std::move(handler));
        return *this;
    }
 
    IntegratorBuilder& with_signals(SignalConfig config = {}) {
        integrator_ = std::make_unique<SignalDecorator<S>>(
            std::move(integrator_), std::move(config));
        return *this;
    }
 
    IntegratorBuilder& with_interpolation(InterpolationConfig config = {}) {
        integrator_ = std::make_unique<InterpolationDecorator<S>>(
            std::move(integrator_), std::move(config));
        return *this;
    }
 
    IntegratorBuilder& with_interprocess(InterprocessConfig config = {}) {
        integrator_ = std::make_unique<InterprocessDecorator<S>>(
            std::move(integrator_), std::move(config));
        return *this;
    }
 
    // TODO: Uncomment when event decorator is fixed
    /*
    IntegratorBuilder& with_events(EventConfig config = {}) {
        integrator_ = std::make_unique<EventDecorator<S, T>>(
            std::move(integrator_), std::move(config));
        return *this;
    }
    */
 
    std::unique_ptr<AbstractIntegrator<S>> build() {
        if (!integrator_) {
            throw std::runtime_error("Builder has already been used or is in invalid state");
        }
        return std::move(integrator_);
    }
 
    template<typename DecoratorType>
    DecoratorType* get_as() {
        return dynamic_cast<DecoratorType*>(integrator_.get());
    }
 
    bool is_valid() const {
        return integrator_ != nullptr;
    }
 
    std::string get_composition_info() const {
        if (!integrator_) {
            return "Builder is empty or has been built";
        }
        
        std::string info = "Composition: ";
        
        // Try to identify decorators in the chain
        // This is a simplified version - a real implementation might maintain
        // a list of applied decorators for better introspection
        
        if (dynamic_cast<TimeoutDecorator<S>*>(integrator_.get())) {
            info += "Timeout -> ";
        }
        if (dynamic_cast<ParallelDecorator<S>*>(integrator_.get())) {
            info += "Parallel -> ";
        }
        if (dynamic_cast<OutputDecorator<S>*>(integrator_.get())) {
            info += "Output -> ";
        }
        if (dynamic_cast<SignalDecorator<S>*>(integrator_.get())) {
            info += "Signal -> ";
        }
        if (dynamic_cast<InterpolationDecorator<S>*>(integrator_.get())) {
            info += "Interpolation -> ";
        }
        if (dynamic_cast<InterprocessDecorator<S>*>(integrator_.get())) {
            info += "Interprocess -> ";
        }
        // TODO: Uncomment when event decorator is fixed
        /*
        if (dynamic_cast<EventDecorator<S>*>(integrator_.get())) {
            info += "Events -> ";
        }
        */
        
        info += "Base";
        return info;
    }
};
 
// ============================================================================
// FACTORY FUNCTIONS (Easy creation)
// ============================================================================
 
template<system_state S>
auto make_builder(std::unique_ptr<AbstractIntegrator<S>> integrator) {
    return IntegratorBuilder<S>(std::move(integrator));
}
 
template<typename Integrator>
auto make_builder_copy(const Integrator& integrator) {
    return IntegratorBuilder<typename Integrator::state_type>(
        std::make_unique<Integrator>(integrator));
}
 
// ============================================================================
// CONVENIENCE FUNCTIONS (Common single-decorator use cases)
// ============================================================================
 
template<system_state S>
auto with_timeout_only(std::unique_ptr<AbstractIntegrator<S>> integrator, 
                      TimeoutConfig config = {}) {
    return make_builder(std::move(integrator)).with_timeout(std::move(config)).build();
}
 
template<system_state S>
auto with_parallel_only(std::unique_ptr<AbstractIntegrator<S>> integrator,
                       ParallelConfig config = {}) {
    return make_builder(std::move(integrator)).with_parallel(std::move(config)).build();
}
 
template<system_state S>
auto with_interpolation_only(std::unique_ptr<AbstractIntegrator<S>> integrator,
                             InterpolationConfig config = {}) {
    return make_builder(std::move(integrator)).with_interpolation(std::move(config)).build();
}
 
template<system_state S>
auto with_interprocess_only(std::unique_ptr<AbstractIntegrator<S>> integrator,
                            InterprocessConfig config = {}) {
    return make_builder(std::move(integrator)).with_interprocess(std::move(config)).build();
}
 
// TODO: Uncomment when event decorator is fixed
/*
template<system_state S>
auto with_events_only(std::unique_ptr<AbstractIntegrator<S>> integrator,
                      EventConfig config = {}) {
    return make_builder(std::move(integrator)).with_events(std::move(config)).build();
}
*/
 
template<system_state S>
auto with_output_only(std::unique_ptr<AbstractIntegrator<S>> integrator,
                     OutputConfig config = {},
                     std::function<void(const S&, typename AbstractIntegrator<S>::time_type, size_t)> handler = nullptr) {
    return make_builder(std::move(integrator))
        .with_output(std::move(config), std::move(handler)).build();
}
 
template<system_state S>
auto with_signals_only(std::unique_ptr<AbstractIntegrator<S>> integrator,
                      SignalConfig config = {}) {
    return make_builder(std::move(integrator)).with_signals(std::move(config)).build();
}
 
// ============================================================================
// COMMON COMPOSITIONS (Frequently used combinations)
// ============================================================================
 
template<system_state S>
auto for_realtime(std::unique_ptr<AbstractIntegrator<S>> integrator,
                  std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{100}) {
    return make_builder(std::move(integrator))
        .with_timeout(TimeoutConfig{.timeout_duration = timeout_ms})
        .with_signals()
        .build();
}
 
template<system_state S>
auto for_research(std::unique_ptr<AbstractIntegrator<S>> integrator,
                  size_t max_threads = 0) {
    return make_builder(std::move(integrator))
        .with_timeout(TimeoutConfig{.timeout_duration = std::chrono::hours{24}})
        .with_parallel(ParallelConfig{.max_threads = max_threads})
        .with_output(OutputConfig{.mode = OutputMode::OFFLINE})
        .build();
}
 
template<system_state S>
auto for_production(std::unique_ptr<AbstractIntegrator<S>> integrator) {
    return make_builder(std::move(integrator))
        .with_timeout(TimeoutConfig{
            .timeout_duration = std::chrono::seconds{30},
            .throw_on_timeout = false  // Don't crash server
        })
        .with_output(OutputConfig{.mode = OutputMode::HYBRID})
        .build();
}
 
} // namespace diffeq::core::composable