class ClientImpl;

class Client {
public:
    using RequestCallback = std::function<void(const Response&, const std::error_code&)>;
    using Ptr = std::unique_ptr<Client>;

    static Ptr create(boost::asio::any_io_executor& executor, const std::string& host, const std::string& port);
    
    virtual ~Client() = default;

    // Asynchronously send a request and receive a response
    virtual void sendRequest(const Request& request, RequestCallback callback) = 0;
    
    // Set connection timeout
    virtual void setConnectTimeout(std::chrono::milliseconds timeout) = 0;
    
    // Set activity timeout
    virtual void setActivityTimeout(std::chrono::milliseconds timeout) = 0;
};

class ServerImpl : public Server, public std::enable_shared_from_this<ServerImpl> {
    void doAccept() {
        acceptor_.async_accept(
            asio::make_strand(executor_),
            beast::bind_front_handler(
                &ServerImpl::onAccept,
                shared_from_this()));
    }

    void onAccept(beast::error_code ec, tcp::socket socket) {
        if (ec) {
            logging::Logger::debug("Accept failed: " + ec.message());
        } else {
            std::make_shared<Session>(
                std::move(socket),
                requestHandler_,
                activityTimeout_)
                ->start();
        }
        if (acceptor_.is_open()) {
            doAccept();
        }
    }

    asio::any_io_executor& executor_;
    tcp::acceptor acceptor_;

};

FetchContent_Declare(
  Boost
  URL ${BOOST_URL}
  URL_HASH SHA256=954a01219b....
)
set(FETCHCONTENT_QUIET OFF)
FetchContent_MakeAvailable(Boost)

FetchContent_GetProperties(Boost SOURCE_DIR BOOST_SOURCE_DIR)

set(Boost_INCLUDE_DIRS ${BOOST_SOURCE_DIR})

http::async_write(connection->stream, req,
    [this, connection, callback](...) {
        if (ec) {
            callback({}, ec);
            return;
        }
        onWrite(connection, callback);
    });

class ClientInstance;

class Client
{
 public:
	using RequestCallback = std::function<void(const Response&, const std::error_code&)>;

	Client(boost::asio::any_io_executor executor, const std::string& host, const std::string& port);
	~Client();

	void sendRequest(const Request& request, RequestCallback callback);
	void setConnectTimeout(std::chrono::milliseconds timeout);
	void setActivityTimeout(std::chrono::milliseconds timeout);

 private:
	std::unique_ptr<ClientInstance> instance_;
};

// Test server and client communication
TEST(ServerTest, ServerClientCommunication)
{
	boost::asio::io_context ioc;
	Server server(ioc.get_executor(), "127.0.0.1", 0);

	// ... preparations

	Client client(ioc.get_executor(), "127.0.0.1", std::to_string(serverPort));
	Request request(HttpMethod::POST, "/test/endpoint");
	request.setBody("Hello, Server!");
	client.sendRequest(request, [&](const Response& response, std::error_code ec) {
		// ... handling
	});

	ioc.run();

	// ... verification
	EXPECT_TRUE(...);
	EXPECT_EQ(...);
}

void ClientInstance::onConnect(...)
{
	http::request<http::string_body> req{...};
	http::async_write(req, ...);
}

-       void sendRequest(const Request& request, RequestCallback callback);
-       void setConnectTimeout(std::chrono::milliseconds timeout);
-       void setActivityTimeout(std::chrono::milliseconds timeout);
+       void sendRequest(const Request& request,
+                        RequestCallback callback,
+                        std::chrono::milliseconds timeout = std::chrono::seconds(30));

void ClientInstance::onResolve(...)
{
	connection->stream.expires_after(timeout);
	connect(...);
}

void ClientInstance::onConnect(...)
{
	connection->stream.expires_after(timeout);
	write(...);
}

void ClientInstance::onWrite(...)
{
	connection->stream.expires_after(timeout);
	read(...);
}

struct Connection : enable_shared_from_this<...>
{
	asio::strand<...> strand_;
	tcp::resolver resolver_;
	tcp::socket socket_;
	asio::steady_timer timer_;
	// ... other members
};

Connection::Connection(asio::any_io_executor executor)
	: strand_(executor)
	, resolver_(strand_)
	, socket_  (strand_)
	, timer_   (strand_)
{
	timer_.expires_after(timeout);
	// ... other work
}

void Connection::onTimeout()
{
	if (cancelled_)
	{
		return;
	}
	doCancel();
	callback_({}, asio::error::operation_aborted);
}

 #include <string>
 #include <string_view>
 #include <boost/asio/any_io_executor.hpp>
-#include <vibeserver/request.hpp>
-#include <vibeserver/response.hpp>
+
+#include "vibeserver/request.hpp"
+#include "vibeserver/response.hpp"

namespace vibe
{

enum class LogLevel
{
	Debug,
	Info,
	Off
};

void setLogLevel(LogLevel level);
LogLevel getLogLevel();

void logDebug(const std::string& message);
void logInfo(const std::string& message);

}  // namespace vibe

class ServerInstance
{
	asio::strand<asio::any_io_executor> strand_;
	asio::any_io_executor executor_;
	tcp::acceptor acceptor_;
	// ... other members
};

ServerInstance::ServerInstance(...)
	: strand_(asio::make_strand(executor)),
	, executor_(executor)
	, acceptor_(strand_)
{
	// ... some work
}

class Session : enable_shared_from_this<...>
{
	asio::strand<...> strand_;
	tcp::socket socket_;
	asio::steady_timer timer_;
	// ... other members
};

Session::Session(...)
	: strand_(asio::make_strand(executor))
	, socket_(std::move(socket))
	, timer_(strand_)
{
	// ... some work
}

TEST(ServerTest, MultithreadingStressTest)
{
	// .. some declarations

	Server server(...);
	std::vector<std::unique_ptr<Client>> clients(NUM_CLIENTS);

	std::function<void()> sendClientRequests = [&](size_t clientIdx, size_t requestsRemaining) {
		if (requestsRemaining == 0)
			return;
		clients[clientIdx]->sendRequest(
		    request, [...](const Response& response, const std::error_code& ec) {
			    completedRequests++;
			    sendClientRequests(clientIdx, requestsRemaining - 1);
		    });
	};

	std::vector<std::thread> ioThreads;
	for (size_t i = 0; i < IO_THREADS; ++i)
		ioThreads.push_back(std::thread([&ioc]() { ioc.run(); }));

	for (size_t i = 0; i < NUM_CLIENTS; ++i)
		sendClientRequests(i, REQUESTS_PER_CLIENT);

	while (completedRequests < TOTAL_REQUESTS && !testFailed) { /* ... wait */ }

	ioc.stop();
	for (auto& thread : ioThreads)
			thread.join();

	// ... print some info
}

TEST(ServerTest, TimeoutWithDelayedHandler)
{
	ServerParams params;
	params.activityTimeout = std::chrono::milliseconds(50);
	params.requestHandler = [](const Request& /*req*/, Response& res) {
		// Create a 10MB response
		res.setBody(std::string(10 * 1024 * 1024, 'X'));
	};

	Server server(params, ...);

	boost::asio::io_context client_io_context;
	boost::asio::ip::tcp::socket socket(client_io_context);
	boost::asio::ip::tcp::endpoint endpoint(server_port);
	socket.connect(endpoint);
	boost::asio::write(socket, boost::asio::buffer(request_str));

	// Sleep for twice the server's timeout period to ensure the server has time
	// to detect inactivity
	std::this_thread::sleep_for(params.activityTimeout * 2);

	// Consume the data to notice EOF.
	while (!connection_closed)
	{
		socket.read_some(boost::asio::buffer(buffer, sizeof(buffer)));
		if (ec == boost::asio::error::eof)
			connection_closed = true;
		else if (...)
			; // ... other checks.
	}
	EXPECT_TRUE(connection_closed);
}

-void ClientInstance::setConnectTimeout(...)
-{
-       connectTimeout_ = timeout;
-}
-
-void ClientInstance::setActivityTimeout(...)
-{
-       activityTimeout_ = timeout;
-}
+// Timeout setter methods removed as timeout is
+// now passed with each request

// Test with request timeout
TEST_F(ClientTest, RequestWithTimeout)
{
	// Create a sample request
	Request request(HttpMethod::GET, "/test");

	// We can now use the timeout parameter
    // with each request
	std::chrono::milliseconds timeout{2000};

	// This test doesn't actually send the request,
    // it just verifies compilation
	SUCCEED();
}