namespace kcenon::network::tracing {

class trace_context {
public:
    // Get current trace context from thread-local storage
    static auto current() -> trace_context;
    
    // Create new root span
    static auto create_span(std::string_view name) -> span;
    
    // Create child span
    auto create_child_span(std::string_view name) const -> span;
    
    // Propagation
    auto to_headers() const -> std::vector<std::pair<std::string, std::string>>;
    static auto from_headers(const std::vector<http_header>& headers) 
        -> trace_context;
    
private:
    std::string trace_id_;
    std::string span_id_;
    std::string parent_span_id_;
    bool sampled_{true};
};

}  // namespace kcenon::network::tracing

class span {
public:
    span(std::string_view name, trace_context ctx);
    ~span();  // Auto-end on destruction
    
    // Set attributes
    auto set_attribute(std::string_view key, std::string_view value) -> span&;
    auto set_attribute(std::string_view key, int64_t value) -> span&;
    auto set_attribute(std::string_view key, double value) -> span&;
    
    // Record events
    auto add_event(std::string_view name) -> span&;
    auto add_event(std::string_view name, 
                   const std::map<std::string, std::string>& attrs) -> span&;
    
    // Status
    auto set_status(span_status status) -> span&;
    auto set_error(std::string_view message) -> span&;
    
    // Manual end
    void end();
    
    // Get context for propagation
    [[nodiscard]] auto context() const -> trace_context;

private:
    struct impl;
    std::unique_ptr<impl> impl_;
};

// RAII helper
#define NETWORK_TRACE_SPAN(name) \
    auto _span = kcenon::network::tracing::trace_context::create_span(name)

auto messaging_client::start_client(host, port) -> VoidResult {
    NETWORK_TRACE_SPAN("tcp.client.connect");
    _span.set_attribute("net.peer.name", host);
    _span.set_attribute("net.peer.port", port);
    
    auto result = do_connect(host, port);
    if (result.is_err()) {
        _span.set_error(result.error().message);
    }
    return result;
}

auto messaging_client::send_packet(data) -> VoidResult {
    NETWORK_TRACE_SPAN("tcp.client.send");
    _span.set_attribute("message.size", data.size());
    
    return do_send(std::move(data));
}

auto http2_client::get(path, headers) -> Result<http2_response> {
    NETWORK_TRACE_SPAN("http2.request");
    _span.set_attribute("http.method", "GET");
    _span.set_attribute("http.url", build_url(path));
    
    // Inject trace context into request headers
    auto trace_headers = trace_context::current().to_headers();
    for (const auto& [k, v] : trace_headers) {
        headers.push_back({k, v});
    }
    
    auto result = do_request("GET", path, headers, {});
    if (result.is_ok()) {
        _span.set_attribute("http.status_code", result.value().status_code);
    }
    return result;
}

auto connection::send_stream_data(stream_id, data) -> VoidResult {
    NETWORK_TRACE_SPAN("quic.stream.send");
    _span.set_attribute("quic.stream_id", stream_id);
    _span.set_attribute("quic.data_length", data.size());
    
    return do_send_stream(stream_id, data);
}

struct tracing_config {
    enum class exporter_type {
        none,       // Disabled
        console,    // Console output
        otlp_grpc,  // OTLP gRPC
        otlp_http,  // OTLP HTTP
        jaeger,     // Jaeger
        zipkin,     // Zipkin
    };
    
    exporter_type exporter = exporter_type::none;
    std::string endpoint;  // Collector endpoint
    double sample_rate = 1.0;  // 0.0 to 1.0
    std::string service_name = "network_system";
    std::map<std::string, std::string> resource_attributes;
};

void configure_tracing(const tracing_config& config);
void shutdown_tracing();