#pragma once

#include "../core/result_types.h"
#include <kcenon/common/interfaces/transport.h>
#include <memory>
#include <span>

namespace kcenon::monitoring {

class udp_transport {
public:
    virtual ~udp_transport() = default;
    virtual auto connect(const std::string& host, uint16_t port) -> result_void = 0;
    virtual auto send(std::span<const uint8_t> data) -> result_void = 0;
    virtual auto is_connected() const -> bool = 0;
};

/// Stub implementation for when network_system is unavailable
class stub_udp_transport : public udp_transport {
public:
    result_void connect(const std::string&, uint16_t) override { 
        return ok(); 
    }
    result_void send(std::span<const uint8_t> data) override {
        bytes_sent_ += data.size();
        return ok();
    }
    bool is_connected() const override { return true; }
    
    std::size_t bytes_sent() const { return bytes_sent_; }
private:
    std::size_t bytes_sent_ = 0;
};

#ifdef MONITORING_HAS_NETWORK_SYSTEM

/// Real implementation using common_system IUdpClient
class network_udp_transport : public udp_transport {
public:
    explicit network_udp_transport(
        std::shared_ptr<common::interfaces::IUdpClient> client)
        : client_(std::move(client)) {}

    result_void connect(const std::string& host, uint16_t port) override {
        return client_->connect(host, port)
            .map_err([](auto&& e) { 
                return make_error(monitoring_error_code::connection_failed, e.message()); 
            });
    }

    result_void send(std::span<const uint8_t> data) override {
        if (!client_->is_connected()) {
            return make_error(monitoring_error_code::not_connected, 
                             "UDP client not connected");
        }
        return client_->send(data)
            .map_err([](auto&& e) { 
                return make_error(monitoring_error_code::send_failed, e.message()); 
            });
    }

    bool is_connected() const override { 
        return client_->is_connected(); 
    }

private:
    std::shared_ptr<common::interfaces::IUdpClient> client_;
};

#endif // MONITORING_HAS_NETWORK_SYSTEM

/// Factory function with automatic backend selection
inline auto create_udp_transport() -> std::unique_ptr<udp_transport> {
#ifdef MONITORING_HAS_NETWORK_SYSTEM
    // Runtime: check if network_system client is available
    auto client = /* get from DI container or factory */;
    if (client) {
        return std::make_unique<network_udp_transport>(std::move(client));
    }
#endif
    return std::make_unique<stub_udp_transport>();
}

} // namespace kcenon::monitoring