class http2_server : public std::enable_shared_from_this<http2_server> {
public:
    using request_handler_t = std::function<void(
        http2_server_stream& stream,
        const http2_request& request)>;
    
    explicit http2_server(std::string_view server_id);
    ~http2_server();
    
    // Server lifecycle
    auto start(unsigned short port) -> VoidResult;
    auto start_tls(unsigned short port, 
                   const tls_config& config) -> VoidResult;
    auto stop() -> VoidResult;
    [[nodiscard]] auto is_running() const -> bool;
    
    // Request handling
    void set_request_handler(request_handler_t handler);
    void set_error_handler(error_handler_t handler);
    
    // Configuration
    auto set_settings(const http2_settings& settings) -> void;
    [[nodiscard]] auto get_settings() const -> http2_settings;
    
    // Statistics
    [[nodiscard]] auto active_connections() const -> size_t;
    [[nodiscard]] auto active_streams() const -> size_t;

private:
    // Connection management
    void accept_connection(tcp_socket socket);
    void handle_connection(std::shared_ptr<http2_connection> conn);
    
    // Members
    std::string server_id_;
    std::unique_ptr<asio::io_context> io_context_;
    std::unique_ptr<asio::ip::tcp::acceptor> acceptor_;
    std::optional<asio::ssl::context> ssl_context_;
    request_handler_t request_handler_;
    http2_settings settings_;
    std::map<uint64_t, std::shared_ptr<http2_connection>> connections_;
    std::mutex connections_mutex_;
};

class http2_server_stream {
public:
    // Response methods
    auto send_headers(int status_code, 
                      const std::vector<http_header>& headers,
                      bool end_stream = false) -> VoidResult;
    
    auto send_data(const std::vector<uint8_t>& data,
                   bool end_stream = false) -> VoidResult;
    
    auto send_data(std::string_view data,
                   bool end_stream = false) -> VoidResult;
    
    // Streaming response
    auto start_response(int status_code,
                        const std::vector<http_header>& headers) -> VoidResult;
    auto write(const std::vector<uint8_t>& chunk) -> VoidResult;
    auto end_response() -> VoidResult;
    
    // Stream control
    auto reset(uint32_t error_code) -> VoidResult;
    
    // Request info
    [[nodiscard]] auto stream_id() const -> uint32_t;
    [[nodiscard]] auto method() const -> std::string_view;
    [[nodiscard]] auto path() const -> std::string_view;
    [[nodiscard]] auto headers() const -> const std::vector<http_header>&;
    
private:
    uint32_t stream_id_;
    std::weak_ptr<http2_connection> connection_;
    std::vector<http_header> request_headers_;
    stream_state state_{stream_state::open};
};

struct http2_request {
    std::string method;
    std::string path;
    std::string authority;  // :authority pseudo-header
    std::string scheme;     // :scheme pseudo-header
    std::vector<http_header> headers;
    std::vector<uint8_t> body;
    
    // Helpers
    [[nodiscard]] auto get_header(std::string_view name) const 
        -> std::optional<std::string>;
    [[nodiscard]] auto content_type() const -> std::optional<std::string>;
    [[nodiscard]] auto content_length() const -> std::optional<size_t>;
};

auto server = std::make_shared<http2_server>("my-server");

server->set_request_handler([](http2_server_stream& stream,
                               const http2_request& request) {
    if (request.method == "GET" && request.path == "/api/health") {
        stream.send_headers(200, {{"content-type", "application/json"}});
        stream.send_data(R"({"status": "ok"})", true);
    } else if (request.method == "POST" && request.path == "/api/echo") {
        stream.send_headers(200, {{"content-type", "application/octet-stream"}});
        stream.send_data(request.body, true);
    } else {
        stream.send_headers(404, {});
        stream.send_data("Not Found", true);
    }
});

server->start_tls(8443, tls_config);

// Server-initiated push
auto push_stream = stream.push_promise("/static/style.css", 
    {{"content-type", "text/css"}});
push_stream.send_data(css_content, true);