Network Chat Application

// server/Session.hpp
#pragma once
#include <asio.hpp>
#include <asio/ssl.hpp>
#include <memory>
#include <queue>
#include <mutex>
#include "Protocol.hpp"

namespace chat {

class ChatServer;

class Session : public std::enable_shared_from_this<Session> {
public:
    using ssl_socket = asio::ssl::stream<asio::ip::tcp::socket>;
    
    Session(asio::io_context& io_context,
            asio::ssl::context& ssl_context,
            ChatServer& server);
    
    ssl_socket::lowest_layer_type& socket() { return socket_.lowest_layer(); }
    
    void start();
    void stop();
    void send(const Message& msg);
    
    const std::string& username() const { return username_; }
    void setUsername(const std::string& name) { username_ = name; }
    bool isAuthenticated() const { return authenticated_; }

private:
    void doHandshake();
    void doRead();
    void doWrite();
    void processMessage(const Message& msg);
    
    // Message handlers
    void handleAuth(const Message& msg);
    void handleChat(const Message& msg);
    void handleJoin(const Message& msg);
    void handleLeave(const Message& msg);

    ssl_socket socket_;
    ChatServer& server_;
    
    std::string username_;
    bool authenticated_ = false;
    
    std::array<uint8_t, 65536> read_buffer_;
    std::vector<uint8_t> message_buffer_;
    
    std::mutex write_mutex_;
    std::queue<std::vector<uint8_t>> write_queue_;
    bool writing_ = false;
};

} // namespace chat

// client/ChatClient.hpp
#pragma once
#include <asio.hpp>
#include <asio/ssl.hpp>
#include <functional>
#include <queue>
#include <thread>
#include "Protocol.hpp"

namespace chat {

class ChatClient {
public:
    using MessageCallback = std::function<void(const Message&)>;
    using ErrorCallback = std::function<void(const std::string&)>;
    
    ChatClient();
    ~ChatClient();
    
    // Connection
    bool connect(const std::string& host, uint16_t port);
    void disconnect();
    bool isConnected() const { return connected_; }
    
    // Authentication
    bool authenticate(const std::string& username, const std::string& password);
    
    // Messaging
    void sendMessage(const std::string& room, const std::string& content);
    void sendPrivateMessage(const std::string& recipient, const std::string& content);
    
    // Room operations
    void joinRoom(const std::string& room);
    void leaveRoom(const std::string& room);
    void listRooms();
    
    // Callbacks
    void onMessage(MessageCallback callback) { message_callback_ = callback; }
    void onError(ErrorCallback callback) { error_callback_ = callback; }

private:
    void ioThread();
    void doRead();
    void doWrite();
    void send(const Message& msg);
    
    asio::io_context io_context_;
    asio::ssl::context ssl_context_;
    std::unique_ptr<asio::ssl::stream<asio::ip::tcp::socket>> socket_;
    std::thread io_thread_;
    
    bool connected_ = false;
    bool authenticated_ = false;
    
    MessageCallback message_callback_;
    ErrorCallback error_callback_;
};

} // namespace chat

// common/ThreadPool.hpp
#pragma once
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>

namespace chat {

class ThreadPool {
public:
    explicit ThreadPool(size_t num_threads = std::thread::hardware_concurrency());
    ~ThreadPool();
    
    // Submit a task and get a future for the result
    template<typename F, typename... Args>
    auto submit(F&& f, Args&&... args) 
        -> std::future<std::invoke_result_t<F, Args...>> 
    {
        using return_type = std::invoke_result_t<F, Args...>;
        
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        
        std::future<return_type> result = task->get_future();
        
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            if (stop_) throw std::runtime_error("ThreadPool stopped");
            tasks_.emplace([task]() { (*task)(); });
        }
        
        condition_.notify_one();
        return result;
    }
    
    size_t pendingTasks() const;
    size_t size() const { return workers_.size(); }

private:
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
    
    mutable std::mutex queue_mutex_;
    std::condition_variable condition_;
    bool stop_ = false;
};

} // namespace chat