// 使用RAII管理所有系統(tǒng)資源
class HTTPServer {
private:
    std::unique_ptr<Socket> listener_;
    std::unique_ptr<ThreadPool> thread_pool_;
    std::atomic<bool> running_{false};
    
public:
    HTTPServer(const std::string& address, uint16_t port)
        : listener_(std::make_unique<Socket>())
        , thread_pool_(std::make_unique<ThreadPool>()) {
        
        // RAII方式初始化：構(gòu)造函數(shù)獲取資源
        // 如果任何一步失敗，異常會(huì)阻止對(duì)象構(gòu)造，確保資源正確清理
        listener_->bind(address, port);
        listener_->listen(1024);
        
        std::cout << "HTTP服務(wù)器初始化完成，監(jiān)聽 " 
                  << address << ":" << port << std::endl;
    }
    
    ~HTTPServer() {
        // 析構(gòu)函數(shù)自動(dòng)釋放資源，無(wú)需手動(dòng)清理
        stop(); 
        std::cout << "HTTP服務(wù)器資源已釋放" << std::endl;
    }
    
    // 刪除拷貝操作，避免意外共享
    // 拷貝語(yǔ)義在資源管理類中通常是危險(xiǎn)的
    HTTPServer(const HTTPServer&) = delete;
    HTTPServer& operator=(const HTTPServer&) = delete;
    
    // 允許移動(dòng)語(yǔ)義，支持資源所有權(quán)的轉(zhuǎn)移
    HTTPServer(HTTPServer&&) = default;
    HTTPServer& operator=(HTTPServer&&) = default;
    
    void run() {
        running_.store(true, std::memory_order_release);
        std::cout << "啟動(dòng)HTTP服務(wù)器主循環(huán)..." << std::endl;
        
        // 主事件循環(huán)
        while (running_.load(std::memory_order_acquire)) {
            try {
                auto client_socket = listener_->accept();
                if (client_socket.is_valid()) {
                    handle_new_connection(std::move(client_socket));
                }
            } catch (const std::exception& e) {
                std::cerr << "接受連接時(shí)發(fā)生錯(cuò)誤: " << e.what() << std::endl;
            }
        }
    }
    
    void stop() {
        running_.store(false, std::memory_order_release);
    }
};

// 連接類繼承enable_shared_from_this，允許在回調(diào)中安全地延長(zhǎng)生命周期
class Connection : public std::enable_shared_from_this<Connection> {
private:
    std::unique_ptr<Socket> socket_;
    std::vector<char> buffer_;
    std::string request_data_;
    RequestParser parser_;
    
public:
    explicit Connection(std::unique_ptr<Socket> socket)
        : socket_(std::move(socket))  // 明確的所有權(quán)轉(zhuǎn)移
        , buffer_(8192) {             // 預(yù)分配讀緩沖區(qū)
        
        std::cout << "創(chuàng)建新連接，F(xiàn)D: " << socket_->fd() << std::endl;
    }
    
    ~Connection() {
        std::cout << "關(guān)閉連接，F(xiàn)D: " << socket_->fd() << std::endl;
    }
    
    void start() {
        // 使用shared_from_this()確保在異步操作期間對(duì)象不會(huì)被銷毀
        auto self = shared_from_this();  
        
        // 將連接注冊(cè)到事件循環(huán)中
        EventLoop::instance().add_socket(
            socket_->fd(), 
            EPOLLIN | EPOLLET,  // 邊緣觸發(fā)模式
            [self](uint32_t events) {
                if (events & EPOLLIN) {
                    self->do_read();
                }
                if (events & EPOLLOUT) {
                    self->do_write();
                }
                if (events & (EPOLLERR | EPOLLHUP)) {
                    self->handle_error();
                }
            }
        );
        
        do_read();
    }
    
    int fd() const { return socket_->fd(); }
    
private:
    void do_read() {
        auto self = shared_from_this();
        
        // 異步讀取數(shù)據(jù)
        socket_->async_read_some(buffer_, 
            [self](std::error_code ec, size_t bytes_transferred) {
                if (!ec && bytes_transferred > 0) {
                    self->on_data_received(bytes_transferred);
                } else {
                    self->handle_error();
                }
            });
    }
    
    void on_data_received(size_t bytes_read) {
        // 將數(shù)據(jù)追加到請(qǐng)求緩沖區(qū)
        request_data_.append(buffer_.data(), bytes_read);
        
        // 嘗試解析完整的HTTP請(qǐng)求
        auto result = parser_.parse(request_data_);
        if (result.has_value()) {
            handle_request(std::move(result.value()));
            request_data_.clear();  // 準(zhǔn)備處理下一個(gè)請(qǐng)求
        } else if (result.error() == ParseError::NeedMoreData) {
            // 需要更多數(shù)據(jù)，繼續(xù)讀取
            do_read();
        } else {
            // 解析錯(cuò)誤，返回400 Bad Request
            send_error_response(http::StatusCode::BadRequest);
        }
    }
    
    void do_write(std::string_view response) {
        auto self = shared_from_this();
        
        socket_->async_write(response,
            [self](std::error_code ec, size_t bytes_written) {
                if (!ec) {
                    // 寫入成功，檢查是否要保持連接
                    if (self->should_keep_alive()) {
                        self->do_read();  // 繼續(xù)讀取下一個(gè)請(qǐng)求
                    } else {
                        // 關(guān)閉連接
                        self->socket_->close();
                    }
                } else {
                    self->handle_error();
                }
            });
    }
    
    void handle_request(Request&& request);
    void send_error_response(http::StatusCode code);
    bool should_keep_alive() const;
};

// 工廠函數(shù)，使用make_shared確保單次內(nèi)存分配
auto create_connection(std::unique_ptr<Socket> socket) {
    return std::make_shared<Connection>(std::move(socket));
}

namespace http {
    // 強(qiáng)類型枚舉，避免隱式轉(zhuǎn)換
    enum class Method { 
        GET, 
        POST, 
        PUT, 
        DELETE, 
        HEAD, 
        OPTIONS, 
        PATCH 
    };
    
    enum class Version { 
        HTTP1_0, 
        HTTP1_1, 
        HTTP2_0 
    };
    
    // 枚舉底層類型指定，確保二進(jìn)制兼容性
    enum class StatusCode : uint16_t {
        // 2xx Success
        OK = 200,
        Created = 201,
        Accepted = 202,
        NoContent = 204,
        
        // 3xx Redirection
        MovedPermanently = 301,
        Found = 302,
        NotModified = 304,
        
        // 4xx Client Errors
        BadRequest = 400,
        Unauthorized = 401,
        Forbidden = 403,
        NotFound = 404,
        MethodNotAllowed = 405,
        
        // 5xx Server Errors
        InternalError = 500,
        NotImplemented = 501,
        BadGateway = 502,
        ServiceUnavailable = 503
    };
    
    // 大小寫不敏感的頭部映射
    class Headers {
    private:
        struct CaseInsensitiveHash {
            size_t operator()(const std::string& key) const {
                std::string lower_key;
                std::transform(key.begin(), key.end(), 
                             std::back_inserter(lower_key), ::tolower);
                return std::hash<std::string>{}(lower_key);
            }
        };
        
        struct CaseInsensitiveEqual {
            bool operator()(const std::string& lhs, 
                          const std::string& rhs) const {
                if (lhs.length() != rhs.length()) return false;
                return std::equal(lhs.begin(), lhs.end(), rhs.begin(),
                                [](char a, char b) {
                                    return ::tolower(a) == ::tolower(b);
                                });
            }
        };
        
        std::unordered_map<std::string, std::string, 
                          CaseInsensitiveHash, 
                          CaseInsensitiveEqual> headers_;
    public:
        void set(std::string_view key, std::string_view value) {
            headers_[std::string(key)] = std::string(value);
        }
        
        std::optional<std::string_view> get(std::string_view key) const {
            auto it = headers_.find(std::string(key));
            if (it != headers_.end()) {
                return std::string_view(it->second);
            }
            return std::nullopt;
        }
        
        bool contains(std::string_view key) const {
            return headers_.find(std::string(key)) != headers_.end();
        }
        
        auto begin() const { return headers_.begin(); }
        auto end() const { return headers_.end(); }
    };
    
    // HTTP請(qǐng)求類
    class Request {
    private:
        Method method_;
        std::string uri_;
        Version version_;
        Headers headers_;
        std::string body_;
        
    public:
        Request(Method method, std::string uri, Version version = Version::HTTP1_1)
            : method_(method), uri_(std::move(uri)), version_(version) {}
        
        // 訪問(wèn)器方法
        Method method() const { return method_; }
        const std::string& uri() const { return uri_; }
        Version version() const { return version_; }
        const Headers& headers() const { return headers_; }
        Headers& headers() { return headers_; }
        const std::string& body() const { return body_; }
        std::string& body() { return body_; }
        
        void set_method(Method method) { method_ = method; }
        void set_uri(std::string uri) { uri_ = std::move(uri); }
        void set_version(Version version) { version_ = version; }
        void set_body(std::string body) { body_ = std::move(body); }
    };
    
    // HTTP響應(yīng)類
    class Response {
    private:
        StatusCode status_code_;
        Headers headers_;
        std::string body_;
        
    public:
        Response(StatusCode status_code = StatusCode::OK) 
            : status_code_(status_code) {}
        
        StatusCode status_code() const { return status_code_; }
        const Headers& headers() const { return headers_; }
        Headers& headers() { return headers_; }
        const std::string& body() const { return body_; }
        std::string& body() { return body_; }
        
        void set_status_code(StatusCode code) { status_code_ = code; }
        void set_body(std::string body) { 
            body_ = std::move(body); 
            headers_.set("Content-Length", std::to_string(body_.size()));
        }
        
        // 便捷方法
        static Response text_response(std::string content) {
            Response resp(StatusCode::OK);
            resp.headers().set("Content-Type", "text/plain; charset=utf-8");
            resp.set_body(std::move(content));
            return resp;
        }
        
        static Response json_response(std::string json) {
            Response resp(StatusCode::OK);
            resp.headers().set("Content-Type", "application/json");
            resp.set_body(std::move(json));
            return resp;
        }
        
        static Response error_response(StatusCode code, std::string message) {
            Response resp(code);
            resp.headers().set("Content-Type", "text/plain; charset=utf-8");
            resp.set_body(std::move(message));
            return resp;
        }
    };
}

// 類型安全的請(qǐng)求解析器
class RequestParser {
public:
    std::expected<http::Request, ParseError> parse(std::string_view data);
    
private:
    std::expected<http::Method, ParseError> 
    parse_method(std::string_view method_str);
    
    std::expected<http::Version, ParseError> 
    parse_version(std::string_view version_str);
    
    std::expected<uint16_t, ParseError> 
    parse_status_code(std::string_view code_str);
};

enum class ParserError {
    InvalidMethod,
    MalformedRequestLine,
    InvalidVersion,
    MalformedHeaders,
    BodyTooLarge,
    InvalidEncoding,
    NeedMoreData
};

class RequestParser {
private:
    static constexpr size_t MAX_REQUEST_SIZE = 1024 * 1024; // 1MB
    static constexpr size_t MAX_HEADERS_SIZE = 8192;        // 8KB
    
public:
    std::expected<http::Request, ParserError> parse(std::string_view input) {
        if (input.empty()) {
            return std::unexpected(ParserError::NeedMoreData);
        }
        
        // 解析請(qǐng)求行
        auto request_line_end = input.find("\r\n");
        if (request_line_end == std::string_view::npos) {
            return std::unexpected(ParserError::NeedMoreData);
        }
        
        auto request_line = input.substr(0, request_line_end);
        auto method_result = parse_method(extract_method(request_line));
        if (!method_result) {
            return std::unexpected(method_result.error());
        }
        
        auto uri_result = extract_uri(request_line);
        if (!uri_result) {
            return std::unexpected(uri_result.error());
        }
        
        auto version_result = parse_version(extract_version(request_line));
        if (!version_result) {
            return std::unexpected(version_result.error());
        }
        
        http::Request request(*method_result, std::move(*uri_result), *version_result);
        
        // 解析頭部
        auto headers_start = request_line_end + 2;
        auto headers_end = input.find("\r\n\r\n", headers_start);
        if (headers_end == std::string_view::npos) {
            return std::unexpected(ParserError::NeedMoreData);
        }
        
        auto headers_result = parse_headers(input.substr(headers_start, 
                                                       headers_end - headers_start));
        if (!headers_result) {
            return std::unexpected(headers_result.error());
        }
        
        request.headers() = std::move(*headers_result);
        
        // 解析消息體
        auto body_start = headers_end + 4;
        if (body_start < input.length()) {
            auto body_result = parse_body(input.substr(body_start), request.headers());
            if (!body_result) {
                return std::unexpected(body_result.error());
            }
            request.body() = std::move(*body_result);
        }
        
        return request;
    }
    
private:
    std::expected<http::Method, ParserError> 
    parse_method(std::string_view method_str) {
        static const std::unordered_map<std::string_view, http::Method> method_map = {
            {"GET", http::Method::GET},
            {"POST", http::Method::POST},
            {"PUT", http::Method::PUT},
            {"DELETE", http::Method::DELETE},
            {"HEAD", http::Method::HEAD},
            {"OPTIONS", http::Method::OPTIONS},
            {"PATCH", http::Method::PATCH}
        };
        
        auto it = method_map.find(method_str);
        if (it != method_map.end()) {
            return it->second;
        }
        return std::unexpected(ParserError::InvalidMethod);
    }
    
    std::expected<std::string, ParserError> 
    extract_uri(std::string_view request_line) {
        auto method_end = request_line.find(' ');
        if (method_end == std::string_view::npos) {
            return std::unexpected(ParserError::MalformedRequestLine);
        }
        
        auto uri_start = method_end + 1;
        auto uri_end = request_line.find(' ', uri_start);
        if (uri_end == std::string_view::npos) {
            return std::unexpected(ParserError::MalformedRequestLine);
        }
        
        return std::string(request_line.substr(uri_start, uri_end - uri_start));
    }
    
    std::expected<http::Headers, ParserError> 
    parse_headers(std::string_view headers_data) {
        http::Headers headers;
        size_t start = 0;
        
        while (start < headers_data.length()) {
            auto line_end = headers_data.find("\r\n", start);
            if (line_end == std::string_view::npos) {
                break;
            }
            
            auto line = headers_data.substr(start, line_end - start);
            auto colon_pos = line.find(':');
            if (colon_pos != std::string_view::npos) {
                auto key = line.substr(0, colon_pos);
                auto value = line.substr(colon_pos + 1);
                
                // 去除value前后的空白字符
                value.remove_prefix(std::min(value.find_first_not_of(" \t"), value.size()));
                value.remove_suffix(value.size() - std::min(value.find_last_not_of(" \t") + 1, value.size()));
                
                headers.set(key, value);
            }
            
            start = line_end + 2;
        }
        
        return headers;
    }
    
    std::expected<std::string, ParserError>
    parse_body(std::string_view body_data, const http::Headers& headers) {
        // 檢查Content-Length
        if (auto content_length = headers.get("Content-Length")) {
            size_t expected_size = 0;
            try {
                expected_size = std::stoul(std::string(*content_length));
            } catch (const std::exception&) {
                return std::unexpected(ParserError::InvalidEncoding);
            }
            
            if (body_data.length() < expected_size) {
                return std::unexpected(ParserError::NeedMoreData);
            }
            
            if (expected_size > MAX_REQUEST_SIZE) {
                return std::unexpected(ParserError::BodyTooLarge);
            }
            
            return std::string(body_data.substr(0, expected_size));
        }
        
        // 檢查Transfer-Encoding: chunked
        if (auto transfer_encoding = headers.get("Transfer-Encoding")) {
            if (*transfer_encoding == "chunked") {
                return parse_chunked_body(body_data);
            }
        }
        
        // 沒(méi)有消息體
        return std::string();
    }
    
    std::expected<std::string, ParserError>
    parse_chunked_body(std::string_view chunked_data) {
        std::string body;
        size_t pos = 0;
        
        while (pos < chunked_data.length()) {
            // 解析塊大小
            auto line_end = chunked_data.find("\r\n", pos);
            if (line_end == std::string_view::npos) {
                return std::unexpected(ParserError::NeedMoreData);
            }
            
            auto size_line = chunked_data.substr(pos, line_end - pos);
            size_t chunk_size = 0;
            try {
                chunk_size = std::stoul(std::string(size_line), nullptr, 16);
            } catch (const std::exception&) {
                return std::unexpected(ParserError::InvalidEncoding);
            }
            
            if (chunk_size == 0) {
                // 最后一個(gè)塊
                break;
            }
            
            pos = line_end + 2;
            
            // 檢查是否有足夠的數(shù)據(jù)
            if (pos + chunk_size + 2 > chunked_data.length()) {
                return std::unexpected(ParserError::NeedMoreData);
            }
            
            // 添加塊數(shù)據(jù)到消息體
            body.append(chunked_data.data() + pos, chunk_size);
            pos += chunk_size + 2; // 跳過(guò)塊數(shù)據(jù)和\r\n
        }
        
        return body;
    }
};

#include <queue>
#include <thread>
#include <future>
#include <atomic>
#include <latch>
#include <barrier>

class ThreadPool {
private:
    std::vector<std::jthread> workers_;
    moodycamel::ConcurrentQueue<std::function<void()>> tasks_;
    std::atomic<bool> stop_{false};
    std::mutex queue_mutex_;
    std::condition_variable condition_;
    std::atomic<size_t> active_tasks_{0};
    std::latch shutdown_latch_;
    
public:
    explicit ThreadPool(size_t num_threads = std::thread::hardware_concurrency())
        : shutdown_latch_(num_threads) {
        
        std::cout << "初始化線程池，線程數(shù): " << num_threads << std::endl;
        workers_.reserve(num_threads);
        
        for (size_t i = 0; i < num_threads; ++i) {
            workers_.emplace_back([this, i] { 
                worker_loop(i); 
            });
        }
        
        // 等待所有線程啟動(dòng)完成
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::cout << "線程池初始化完成" << std::endl;
    }
    
    ~ThreadPool() {
        shutdown();
    }
    
    void shutdown() {
        if (stop_.exchange(true)) {
            return; // 已經(jīng)在關(guān)閉過(guò)程中
        }
        
        std::cout << "開始關(guān)閉線程池..." << std::endl;
        
        // 喚醒所有等待的線程
        condition_.notify_all();
        
        // 等待所有線程完成
        shutdown_latch_.wait();
        
        std::cout << "線程池關(guān)閉完成" << std::endl;
    }
    
    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...>;
        
        if (stop_.load()) {
            throw std::runtime_error("向已停止的線程池提交任務(wù)");
        }
        
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            [f = std::forward<F>(f), args = std::make_tuple(std::forward<Args>(args)...)]() mutable {
                return std::apply(f, std::move(args));
            }
        );
        
        std::future<return_type> result = task->get_future();
        
        // 使用無(wú)鎖隊(duì)列提交任務(wù)
        tasks_.enqueue([task]() { (*task)(); });
        
        // 通知一個(gè)等待的線程
        condition_.notify_one();
        
        return result;
    }
    
    size_t pending_tasks() const {
        return tasks_.size_approx();
    }
    
    size_t active_tasks() const {
        return active_tasks_.load();
    }
    
    size_t total_threads() const {
        return workers_.size();
    }

private:
    void worker_loop(size_t thread_id) {
        std::cout << "工作線程 " << thread_id << " 啟動(dòng)" << std::endl;
        
        // 設(shè)置線程名稱（平臺(tái)相關(guān)）
        #ifdef __linux__
        std::string thread_name = "worker_" + std::to_string(thread_id);
        pthread_setname_np(pthread_self(), thread_name.c_str());
        #endif
        
        while (!stop_.load(std::memory_order_acquire)) {
            std::function<void()> task;
            
            // 優(yōu)先從無(wú)鎖隊(duì)列獲取任務(wù)
            if (tasks_.try_dequeue(task)) {
                active_tasks_.fetch_add(1, std::memory_order_relaxed);
                
                try {
                    task();
                } catch (const std::exception& e) {
                    std::cerr << "工作線程 " << thread_id 
                              << " 執(zhí)行任務(wù)時(shí)發(fā)生異常: " << e.what() << std::endl;
                }
                
                active_tasks_.fetch_sub(1, std::memory_order_relaxed);
                continue;
            }
            
            // 無(wú)鎖隊(duì)列為空，使用條件變量等待
            std::unique_lock lock(queue_mutex_);
            condition_.wait_for(lock, std::chrono::milliseconds(100), [this] {
                return stop_.load() || !tasks_.empty();
            });
        }
        
        std::cout << "工作線程 " << thread_id << " 關(guān)閉" << std::endl;
        shutdown_latch_.count_down();
    }
};

// 專用的I/O線程池，用于處理網(wǎng)絡(luò)I/O密集型任務(wù)
class IOThreadPool {
private:
    std::vector<std::jthread> io_workers_;
    moodycamel::ConcurrentQueue<std::function<void()>> io_tasks_;
    std::atomic<bool> io_stop_{false};
    
public:
    IOThreadPool(size_t num_threads = std::max(1u, std::thread::hardware_concurrency() / 2))
        : io_workers_(num_threads) {
        
        for (size_t i = 0; i < num_threads; ++i) {
            io_workers_[i] = std::jthread([this, i] {
                io_worker_loop(i);
            });
        }
    }
    
    ~IOThreadPool() {
        io_stop_.store(true);
        // jthread 會(huì)自動(dòng) join
    }
    
    template<typename F>
    void submit_io_task(F&& task) {
        io_tasks_.enqueue(std::forward<F>(task));
    }

private:
    void io_worker_loop(size_t thread_id) {
        #ifdef __linux__
        std::string thread_name = "io_worker_" + std::to_string(thread_id);
        pthread_setname_np(pthread_self(), thread_name.c_str());
        #endif
        
        while (!io_stop_.load()) {
            std::function<void()> task;
            if (io_tasks_.try_dequeue(task)) {
                try {
                    task();
                } catch (const std::exception& e) {
                    std::cerr << "I/O工作線程 " << thread_id 
                              << " 執(zhí)行任務(wù)時(shí)發(fā)生異常: " << e.what() << std::endl;
                }
            } else {
                std::this_thread::yield();
            }
        }
    }
};

#include <sys/epoll.h>
#include <unistd.h>

class Epoll {
private:
    int epoll_fd_;
    std::vector<epoll_event> events_;
    std::unordered_map<int, std::function<void(uint32_t)>> callbacks_;
    std::mutex callback_mutex_;
    
public:
    Epoll(size_t max_events = 1024) 
        : epoll_fd_(epoll_create1(0))
        , events_(max_events) {
        
        if (epoll_fd_ == -1) {
            throw std::system_error(errno, std::system_category(), "epoll_create1失敗");
        }
        
        std::cout << "Epoll初始化完成，最大事件數(shù): " << max_events << std::endl;
    }
    
    ~Epoll() {
        if (epoll_fd_ != -1) {
            close(epoll_fd_);
        }
    }
    
    // 刪除拷貝操作
    Epoll(const Epoll&) = delete;
    Epoll& operator=(const Epoll&) = delete;
    
    // 允許移動(dòng)
    Epoll(Epoll&& other) noexcept 
        : epoll_fd_(std::exchange(other.epoll_fd_, -1))
        , events_(std::move(other.events_))
        , callbacks_(std::move(other.callbacks_)) {}
    
    Epoll& operator=(Epoll&& other) noexcept {
        if (this != &other) {
            if (epoll_fd_ != -1) {
                close(epoll_fd_);
            }
            epoll_fd_ = std::exchange(other.epoll_fd_, -1);
            events_ = std::move(other.events_);
            callbacks_ = std::move(other.callbacks_);
        }
        return *this;
    }
    
    void add(int fd, uint32_t events, std::function<void(uint32_t)> callback) {
        epoll_event ev;
        ev.events = events;
        ev.data.fd = fd;
        
        if (epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &ev) == -1) {
            throw std::system_error(errno, std::system_category(), 
                                  "epoll_ctl ADD失敗");
        }
        
        std::lock_guard lock(callback_mutex_);
        callbacks_[fd] = std::move(callback);
        
        std::cout << "添加FD到epoll: " << fd << ", 事件: " << events << std::endl;
    }
    
    void modify(int fd, uint32_t events) {
        epoll_event ev;
        ev.events = events;
        ev.data.fd = fd;
        
        if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &ev) == -1) {
            throw std::system_error(errno, std::system_category(), 
                                  "epoll_ctl MOD失敗");
        }
        
        std::cout << "修改epoll事件: FD=" << fd << ", 新事件=" << events << std::endl;
    }
    
    void remove(int fd) {
        if (epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, nullptr) == -1) {
            // 如果fd已經(jīng)關(guān)閉，忽略錯(cuò)誤
            if (errno != EBADF) {
                std::cerr << "epoll_ctl DEL失敗，F(xiàn)D: " << fd 
                          << ", 錯(cuò)誤: " << strerror(errno) << std::endl;
            }
        }
        
        std::lock_guard lock(callback_mutex_);
        callbacks_.erase(fd);
        
        std::cout << "從epoll移除FD: " << fd << std::endl;
    }
    
    int wait(int timeout_ms = -1) {
        int num_events = epoll_wait(epoll_fd_, events_.data(), 
                                  static_cast<int>(events_.size()), timeout_ms);
        
        if (num_events == -1) {
            if (errno != EINTR) {
                throw std::system_error(errno, std::system_category(), 
                                      "epoll_wait失敗");
            }
            return 0; // 被信號(hào)中斷
        }
        
        // 處理就緒的事件
        for (int i = 0; i < num_events; ++i) {
            int fd = events_[i].data.fd;
            uint32_t events = events_[i].events;
            
            std::function<void(uint32_t)> callback;
            {
                std::lock_guard lock(callback_mutex_);
                auto it = callbacks_.find(fd);
                if (it != callbacks_.end()) {
                    callback = it->second;
                }
            }
            
            if (callback) {
                try {
                    callback(events);
                } catch (const std::exception& e) {
                    std::cerr << "處理epoll事件時(shí)發(fā)生異常，F(xiàn)D: " << fd 
                              << ", 錯(cuò)誤: " << e.what() << std::endl;
                }
            }
        }
        
        return num_events;
    }
};

class EventLoop {
private:
    std::unique_ptr<Epoll> epoll_;
    std::atomic<bool> running_{false};
    std::jthread event_thread_;
    std::chrono::steady_clock::time_point last_stats_time_;
    std::atomic<uint64_t> total_events_processed_{0};
    
    // 定時(shí)器支持
    struct Timer {
        std::chrono::steady_clock::time_point expiry;
        std::function<void()> callback;
        bool repeated;
        std::chrono::milliseconds interval;
        
        bool operator<(const Timer& other) const {
            return expiry > other.expiry; // 最小堆
        }
    };
    
    std::priority_queue<Timer> timers_;
    std::mutex timer_mutex_;
    
public:
    EventLoop() 
        : epoll_(std::make_unique<Epoll>())
        , last_stats_time_(std::chrono::steady_clock::now()) {}
    
    void run() {
        running_.store(true, std::memory_order_release);
        
        event_thread_ = std::jthread([this](std::stop_token st) {
            event_loop(st);
        });
        
        std::cout << "事件循環(huán)啟動(dòng)" << std::endl;
    }
    
    void stop() {
        running_.store(false, std::memory_order_release);
        if (event_thread_.joinable()) {
            event_thread_.request_stop();
        }
    }
    
    void add_socket(int fd, uint32_t events, std::function<void(uint32_t)> callback) {
        epoll_->add(fd, events, std::move(callback));
    }
    
    void modify_socket(int fd, uint32_t events) {
        epoll_->modify(fd, events);
    }
    
    void remove_socket(int fd) {
        epoll_->remove(fd);
    }
    
    // 添加定時(shí)器
    void add_timer(std::chrono::milliseconds delay, 
                   std::function<void()> callback,
                   bool repeated = false) {
        auto expiry = std::chrono::steady_clock::now() + delay;
        
        std::lock_guard lock(timer_mutex_);
        timers_.push(Timer{expiry, std::move(callback), repeated, delay});
    }
    
    uint64_t events_processed() const {
        return total_events_processed_.load();
    }

private:
    void event_loop(std::stop_token st) {
        #ifdef __linux__
        pthread_setname_np(pthread_self(), "event_loop");
        #endif
        
        std::cout << "事件循環(huán)線程啟動(dòng)" << std::endl;
        
        while (!st.stop_requested() && running_.load(std::memory_order_acquire)) {
            // 計(jì)算下一個(gè)定時(shí)器到期時(shí)間
            int timeout_ms = calculate_timeout();
            
            // 等待事件
            int num_events = epoll_->wait(timeout_ms);
            total_events_processed_.fetch_add(num_events, std::memory_order_relaxed);
            
            // 處理到期定時(shí)器
            process_timers();
            
            // 定期輸出統(tǒng)計(jì)信息
            output_stats();
        }
        
        std::cout << "事件循環(huán)線程結(jié)束" << std::endl;
    }
    
    int calculate_timeout() {
        std::lock_guard lock(timer_mutex_);
        if (timers_.empty()) {
            return 100; // 100ms超時(shí)，避免忙等待
        }
        
        auto now = std::chrono::steady_clock::now();
        auto next_timer = timers_.top().expiry;
        
        if (next_timer <= now) {
            return 0; // 立即返回，處理到期定時(shí)器
        }
        
        auto timeout = std::chrono::duration_cast<std::chrono::milliseconds>(
            next_timer - now);
        return static_cast<int>(timeout.count());
    }
    
    void process_timers() {
        auto now = std::chrono::steady_clock::now();
        std::vector<Timer> expired_timers;
        
        {
            std::lock_guard lock(timer_mutex_);
            while (!timers_.empty() && timers_.top().expiry <= now) {
                expired_timers.push_back(std::move(const_cast<Timer&>(timers_.top())));
                timers_.pop();
            }
        }
        
        // 執(zhí)行定時(shí)器回調(diào)
        for (auto& timer : expired_timers) {
            try {
                timer.callback();
            } catch (const std::exception& e) {
                std::cerr << "定時(shí)器回調(diào)異常: " << e.what() << std::endl;
            }
            
            // 如果是重復(fù)定時(shí)器，重新添加
            if (timer.repeated) {
                add_timer(timer.interval, std::move(timer.callback), true);
            }
        }
    }
    
    void output_stats() {
        auto now = std::chrono::steady_clock::now();
        if (now - last_stats_time_ > std::chrono::seconds(10)) {
            std::cout << "事件循環(huán)統(tǒng)計(jì) - 處理事件總數(shù): " 
                      << total_events_processed_.load() << std::endl;
            last_stats_time_ = now;
        }
    }
};

// 全局事件循環(huán)實(shí)例
class GlobalEventLoop {
private:
    static std::unique_ptr<EventLoop> instance_;
    static std::once_flag init_flag_;
    
public:
    static EventLoop& instance() {
        std::call_once(init_flag_, []() {
            instance_ = std::make_unique<EventLoop>();
            instance_->run();
        });
        return *instance_;
    }
    
    static void shutdown() {
        if (instance_) {
            instance_->stop();
            instance_.reset();
        }
    }
};

std::unique_ptr<EventLoop> GlobalEventLoop::instance_ = nullptr;
std::once_flag GlobalEventLoop::init_flag_;

class RequestParser {
private:
    enum class State {
        Start,
        Headers,
        Body,
        Complete,
        Error
    };
    
    State state_ = State::Start;
    size_t content_length_ = 0;
    bool chunked_encoding_ = false;
    std::string current_chunk_size_;
    
public:
    std::expected<http::Request, ParseError> parse(std::string_view data) {
        if (state_ == State::Error) {
            return std::unexpected(ParseError::InvalidFormat);
        }
        
        http::Request request;
        size_t bytes_consumed = 0;
        
        try {
            if (state_ == State::Start) {
                auto result = parse_request_line(data, request);
                if (!result) {
                    state_ = State::Error;
                    return std::unexpected(result.error());
                }
                bytes_consumed += result.value();
            }
            
            if (state_ == State::Start || state_ == State::Headers) {
                auto headers_data = data.substr(bytes_consumed);
                auto result = parse_headers(headers_data, request);
                if (result.has_value()) {
                    bytes_consumed += result.value();
                    state_ = State::Body;
                    
                    // 檢查是否需要解析消息體
                    auto content_length = request.headers().get("Content-Length");
                    if (content_length) {
                        content_length_ = std::stoul(std::string(*content_length));
                    }
                    
                    auto transfer_encoding = request.headers().get("Transfer-Encoding");
                    if (transfer_encoding && *transfer_encoding == "chunked") {
                        chunked_encoding_ = true;
                    }
                } else if (result.error() == ParseError::NeedMoreData) {
                    return std::unexpected(ParseError::NeedMoreData);
                } else {
                    state_ = State::Error;
                    return std::unexpected(result.error());
                }
            }
            
            if (state_ == State::Body) {
                auto body_data = data.substr(bytes_consumed);
                auto result = parse_body(body_data, request);
                if (result.has_value()) {
                    bytes_consumed += result.value();
                    state_ = State::Complete;
                } else if (result.error() == ParseError::NeedMoreData) {
                    return std::unexpected(ParseError::NeedMoreData);
                } else {
                    state_ = State::Error;
                    return std::unexpected(result.error());
                }
            }
            
        } catch (const std::exception& e) {
            state_ = State::Error;
            return std::unexpected(ParseError::InvalidFormat);
        }
        
        if (state_ == State::Complete) {
            state_ = State::Start; // 重置狀態(tài)以解析下一個(gè)請(qǐng)求
            return request;
        }
        
        return std::unexpected(ParseError::NeedMoreData);
    }
    
    void reset() {
        state_ = State::Start;
        content_length_ = 0;
        chunked_encoding_ = false;
        current_chunk_size_.clear();
    }

private:
    std::expected<size_t, ParseError> 
    parse_request_line(std::string_view data, http::Request& request) {
        auto line_end = data.find("\r\n");
        if (line_end == std::string_view::npos) {
            return std::unexpected(ParseError::NeedMoreData);
        }
        
        auto request_line = data.substr(0, line_end);
        
        // 解析方法
        auto method_end = request_line.find(' ');
        if (method_end == std::string_view::npos) {
            return std::unexpected(ParseError::MalformedRequestLine);
        }
        
        auto method_str = request_line.substr(0, method_end);
        auto method = parse_method(method_str);
        if (!method) {
            return std::unexpected(method.error());
        }
        
        // 解析URI
        auto uri_start = method_end + 1;
        auto uri_end = request_line.find(' ', uri_start);
        if (uri_end == std::string_view::npos) {
            return std::unexpected(ParseError::MalformedRequestLine);
        }
        
        auto uri = request_line.substr(uri_start, uri_end - uri_start);
        
        // 解析版本
        auto version_start = uri_end + 1;
        auto version_str = request_line.substr(version_start);
        auto version = parse_version(version_str);
        if (!version) {
            return std::unexpected(version.error());
        }
        
        request.set_method(*method);
        request.set_uri(std::string(uri));
        request.set_version(*version);
        
        return line_end + 2; // 返回消耗的字節(jié)數(shù)
    }
    
    std::expected<size_t, ParseError>
    parse_headers(std::string_view data, http::Request& request) {
        size_t bytes_consumed = 0;
        
        while (bytes_consumed < data.length()) {
            auto line_end = data.find("\r\n", bytes_consumed);
            if (line_end == std::string_view::npos) {
                return std::unexpected(ParseError::NeedMoreData);
            }
            
            // 空行表示頭部結(jié)束
            if (line_end == bytes_consumed) {
                return bytes_consumed + 2; // 消耗空行
            }
            
            auto line = data.substr(bytes_consumed, line_end - bytes_consumed);
            
            auto colon_pos = line.find(':');
            if (colon_pos == std::string_view::npos) {
                return std::unexpected(ParseError::MalformedHeaders);
            }
            
            auto key = line.substr(0, colon_pos);
            auto value = line.substr(colon_pos + 1);
            
            // 去除value前后的空白字符
            value.remove_prefix(std::min(value.find_first_not_of(" \t"), value.size()));
            value.remove_suffix(value.size() - std::min(value.find_last_not_of(" \t") + 1, value.size()));
            
            request.headers().set(key, value);
            
            bytes_consumed = line_end + 2;
        }
        
        return std::unexpected(ParseError::NeedMoreData);
    }
    
    std::expected<size_t, ParseError>
    parse_body(std::string_view data, http::Request& request) {
        if (chunked_encoding_) {
            return parse_chunked_body(data, request);
        } else if (content_length_ > 0) {
            return parse_content_length_body(data, request);
        } else {
            // 沒(méi)有消息體
            request.set_body("");
            return 0;
        }
    }
    
    std::expected<size_t, ParseError>
    parse_content_length_body(std::string_view data, http::Request& request) {
        if (data.length() < content_length_) {
            return std::unexpected(ParseError::NeedMoreData);
        }
        
        request.set_body(std::string(data.substr(0, content_length_)));
        return content_length_;
    }
    
    std::expected<size_t, ParseError>
    parse_chunked_body(std::string_view data, http::Request& request) {
        std::string body;
        size_t pos = 0;
        
        while (pos < data.length()) {
            // 如果正在解析塊大小
            if (current_chunk_size_.empty()) {
                auto line_end = data.find("\r\n", pos);
                if (line_end == std::string_view::npos) {
                    return std::unexpected(ParseError::NeedMoreData);
                }
                
                auto size_line = data.substr(pos, line_end - pos);
                current_chunk_size_ = std::string(size_line);
                
                pos = line_end + 2;
            }
            
            // 解析當(dāng)前塊的大小
            size_t chunk_size = 0;
            try {
                chunk_size = std::stoul(current_chunk_size_, nullptr, 16);
            } catch (const std::exception&) {
                return std::unexpected(ParseError::InvalidEncoding);
            }
            
            if (chunk_size == 0) {
                // 最后一個(gè)塊，跳過(guò)尾部頭部
                auto trailer_end = data.find("\r\n\r\n", pos);
                if (trailer_end == std::string_view::npos) {
                    return std::unexpected(ParseError::NeedMoreData);
                }
                
                request.set_body(std::move(body));
                return trailer_end + 4;
            }
            
            // 檢查是否有足夠的塊數(shù)據(jù)
            if (pos + chunk_size + 2 > data.length()) {
                return std::unexpected(ParseError::NeedMoreData);
            }
            
            // 添加塊數(shù)據(jù)
            body.append(data.data() + pos, chunk_size);
            pos += chunk_size + 2; // 跳過(guò)塊數(shù)據(jù)和\r\n
            current_chunk_size_.clear();
        }
        
        return std::unexpected(ParseError::NeedMoreData);
    }
    
    // 輔助方法
    std::expected<http::Method, ParseError> parse_method(std::string_view method_str) {
        static const std::unordered_map<std::string_view, http::Method> methods = {
            {"GET", http::Method::GET}, {"POST", http::Method::POST},
            {"PUT", http::Method::PUT}, {"DELETE", http::Method::DELETE},
            {"HEAD", http::Method::HEAD}, {"OPTIONS", http::Method::OPTIONS},
            {"PATCH", http::Method::PATCH}
        };
        
        auto it = methods.find(method_str);
        if (it != methods.end()) {
            return it->second;
        }
        return std::unexpected(ParseError::InvalidMethod);
    }
    
    std::expected<http::Version, ParseError> parse_version(std::string_view version_str) {
        if (version_str == "HTTP/1.0") return http::Version::HTTP1_0;
        if (version_str == "HTTP/1.1") return http::Version::HTTP1_1;
        if (version_str == "HTTP/2.0") return http::Version::HTTP2_0;
        return std::unexpected(ParseError::InvalidVersion);
    }
};

class Router {
private:
    using Handler = std::function<http::Response(const http::Request&)>;
    using Middleware = std::function<void(const http::Request&, http::Response&)>;
    
    struct Route {
        std::regex pattern;
        Handler handler;
        http::Method method;
        std::string description;
    };
    
    std::vector<Route> routes_;
    std::vector<Middleware> middlewares_;
    std::unordered_map<std::string, std::string> static_files_;
    
public:
    Router() {
        setup_default_routes();
    }
    
    void add_middleware(Middleware middleware) {
        middlewares_.push_back(std::move(middleware));
    }
    
    template<typename Handler>
    void add_route(http::Method method, std::string pattern, 
                   Handler&& handler, std::string description = "") {
        routes_.push_back({
            std::regex(std::move(pattern)),
            std::forward<Handler>(handler),
            method,
            std::move(description)
        });
        
        std::cout << "注冊(cè)路由: " << to_string(method) << " " 
                  << pattern << " - " << description << std::endl;
    }
    
    void add_static_file(std::string url_path, std::string file_path) {
        static_files_[std::move(url_path)] = std::move(file_path);
    }
    
    std::optional<http::Response> route(const http::Request& request) {
        // 首先檢查靜態(tài)文件
        if (request.method() == http::Method::GET) {
            auto static_response = try_serve_static(request);
            if (static_response) {
                return apply_middlewares(request, std::move(*static_response));
            }
        }
        
        // 然后檢查動(dòng)態(tài)路由
        for (const auto& route : routes_) {
            if (route.method != request.method()) {
                continue;
            }
            
            std::smatch match;
            if (std::regex_match(request.uri(), match, route.pattern)) {
                auto response = route.handler(request);
                return apply_middlewares(request, std::move(response));
            }
        }
        
        // 沒(méi)有匹配的路由
        return std::nullopt;
    }
    
    void print_routes() const {
        std::cout << "\n=== 注冊(cè)的路由 ===" << std::endl;
        for (const auto& route : routes_) {
            std::cout << to_string(route.method) << " " 
                      << route.pattern.str() << " - " 
                      << route.description << std::endl;
        }
        std::cout << "==================\n" << std::endl;
    }

private:
    void setup_default_routes() {
        // 健康檢查端點(diǎn)
        add_route(http::Method::GET, "/health", 
            [](const http::Request&) {
                return http::Response::text_response("OK");
            }, "健康檢查");
        
        // 接口信息端點(diǎn)
        add_route(http::Method::GET, "/api/info", 
            [this](const http::Request&) {
                nlohmann::json info = {
                    {"server", "Modern C++ HTTP Server"},
                    {"version", "1.0.0"},
                    {"routes", routes_.size()},
                    {"timestamp", std::time(nullptr)}
                };
                return http::Response::json_response(info.dump());
            }, "服務(wù)器信息");
        
        // 404處理
        add_route(http::Method::GET, ".*", 
            [](const http::Request& req) {
                return http::Response::error_response(
                    http::StatusCode::NotFound,
                    "未找到路徑: " + req.uri()
                );
            }, "默認(rèn)404處理");
    }
    
    std::optional<http::Response> try_serve_static(const http::Request& request) {
        auto it = static_files_.find(request.uri());
        if (it != static_files_.end()) {
            return serve_file(it->second);
        }
        
        // 檢查靜態(tài)文件目錄
        if (request.uri().starts_with("/static/")) {
            std::string file_path = "static" + request.uri().substr(7);
            return serve_file(file_path);
        }
        
        return std::nullopt;
    }
    
    http::Response serve_file(const std::string& file_path) {
        std::ifstream file(file_path, std::ios::binary);
        if (!file) {
            return http::Response::error_response(
                http::StatusCode::NotFound,
                "文件未找到: " + file_path
            );
        }
        
        std::string content((std::istreambuf_iterator<char>(file)),
                           std::istreambuf_iterator<char>());
        
        http::Response response(http::StatusCode::OK);
        response.set_body(std::move(content));
        
        // 設(shè)置Content-Type
        auto ext_pos = file_path.find_last_of('.');
        if (ext_pos != std::string::npos) {
            auto ext = file_path.substr(ext_pos + 1);
            response.headers().set("Content-Type", get_mime_type(ext));
        }
        
        return response;
    }
    
    std::string get_mime_type(const std::string& extension) {
        static const std::unordered_map<std::string, std::string> mime_types = {
            {"html", "text/html"},
            {"css", "text/css"},
            {"js", "application/javascript"},
            {"json", "application/json"},
            {"png", "image/png"},
            {"jpg", "image/jpeg"},
            {"jpeg", "image/jpeg"},
            {"gif", "image/gif"},
            {"txt", "text/plain"}
        };
        
        auto it = mime_types.find(extension);
        return it != mime_types.end() ? it->second : "application/octet-stream";
    }
    
    http::Response apply_middlewares(const http::Request& request, 
                                   http::Response response) {
        for (const auto& middleware : middlewares_) {
            middleware(request, response);
        }
        return response;
    }
    
    std::string to_string(http::Method method) const {
        switch (method) {
            case http::Method::GET: return "GET";
            case http::Method::POST: return "POST";
            case http::Method::PUT: return "PUT";
            case http::Method::DELETE: return "DELETE";
            case http::Method::HEAD: return "HEAD";
            case http::Method::OPTIONS: return "OPTIONS";
            case http::Method::PATCH: return "PATCH";
            default: return "UNKNOWN";
        }
    }
};

// 便捷的路由構(gòu)建器
class RouteBuilder {
private:
    Router& router_;
    
public:
    explicit RouteBuilder(Router& router) : router_(router) {}
    
    RouteBuilder& get(std::string pattern, Router::Handler handler, 
                     std::string description = "") {
        router_.add_route(http::Method::GET, std::move(pattern), 
                         std::move(handler), std::move(description));
        return *this;
    }
    
    RouteBuilder& post(std::string pattern, Router::Handler handler,
                      std::string description = "") {
        router_.add_route(http::Method::POST, std::move(pattern), 
                         std::move(handler), std::move(description));
        return *this;
    }
    
    RouteBuilder& put(std::string pattern, Router::Handler handler,
                     std::string description = "") {
        router_.add_route(http::Method::PUT, std::move(pattern), 
                         std::move(handler), std::move(description));
        return *this;
    }
    
    RouteBuilder& del(std::string pattern, Router::Handler handler,
                     std::string description = "") {
        router_.add_route(http::Method::DELETE, std::move(pattern), 
                         std::move(handler), std::move(description));
        return *this;
    }
};

// 使用示例
void setup_advanced_routes(Router& router) {
    RouteBuilder builder(router);
    
    // RESTful API 示例
    builder.get("/api/users", 
        [](const http::Request& req) {
        // 獲取用戶列表
nlohmann::json users = {
{"users", {
{{"id", 1}, {"name", "Alice"}, {"email", "alice@example.com"}},
{{"id", 2}, {"name", "Bob"}, {"email", "bob@example.com"}},
{{"id", 3}, {"name", "Charlie"}, {"email", "charlie@example.com"}}
}},
{"total", 3},
{"page", 1}
};
return http::Response::json_response(users.dump());
}, "獲取用戶列表")
 .get("/api/users/(\\d+)", 
    [](const http::Request& req) {
        // 提取用戶ID
        std::smatch match;
        if (std::regex_match(req.uri(), match, std::regex("/api/users/(\\d+)"))) {
            int user_id = std::stoi(match[1]);
            nlohmann::json user = {
                {"id", user_id},
                {"name", "User " + std::to_string(user_id)},
                {"email", "user" + std::to_string(user_id) + "@example.com"}
            };
            return http::Response::json_response(user.dump());
        }
        return http::Response::error_response(http::StatusCode::BadRequest, "無(wú)效的用戶ID");
    }, "獲取用戶詳情")
    
 .post("/api/users", 
    [](const http::Request& req) {
        try {
            auto body = nlohmann::json::parse(req.body());
            std::string name = body.value("name", "");
            std::string email = body.value("email", "");
            
            if (name.empty() || email.empty()) {
                return http::Response::error_response(
                    http::StatusCode::BadRequest, 
                    "姓名和郵箱不能為空"
                );
            }
            
            nlohmann::json response = {
                {"id", 100}, // 模擬新用戶ID
                {"name", name},
                {"email", email},
                {"message", "用戶創(chuàng)建成功"}
            };
            
            auto resp = http::Response::json_response(response.dump());
            resp.set_status_code(http::StatusCode::Created);
            return resp;
            
        } catch (const nlohmann::json::exception& e) {
            return http::Response::error_response(
                http::StatusCode::BadRequest,
                "無(wú)效的JSON格式: " + std::string(e.what())
            );
        }
    }, "創(chuàng)建用戶")
    
 .put("/api/users/(\\d+)", 
    [](const http::Request& req) {
        std::smatch match;
        if (std::regex_match(req.uri(), match, std::regex("/api/users/(\\d+)"))) {
            int user_id = std::stoi(match[1]);
            
            try {
                auto body = nlohmann::json::parse(req.body());
                nlohmann::json response = {
                    {"id", user_id},
                    {"name", body.value("name", "Updated User")},
                    {"email", body.value("email", "updated@example.com")},
                    {"message", "用戶更新成功"}
                };
                return http::Response::json_response(response.dump());
                
            } catch (const nlohmann::json::exception& e) {
                return http::Response::error_response(
                    http::StatusCode::BadRequest,
                    "無(wú)效的JSON格式"
                );
            }
        }
        return http::Response::error_response(http::StatusCode::BadRequest, "無(wú)效的用戶ID");
    }, "更新用戶")
    
 .del("/api/users/(\\d+)", 
    [](const http::Request& req) {
        std::smatch match;
        if (std::regex_match(req.uri(), match, std::regex("/api/users/(\\d+)"))) {
            int user_id = std::stoi(match[1]);
            nlohmann::json response = {
                {"message", "用戶 " + std::to_string(user_id) + " 已刪除"}
            };
            return http::Response::json_response(response.dump());
        }
        return http::Response::error_response(http::StatusCode::BadRequest, "無(wú)效的用戶ID");
    }, "刪除用戶");
    // 中間件示例
void setup_middlewares(Router& router) {
// 日志中間件
router.add_middleware([](const http::Request& req, http::Response& resp) {
auto timestamp = std::chrono::system_clock::now();
std::time_t time = std::chrono::system_clock::to_time_t(timestamp);


    std::cout << "[" << std::ctime(&time) 
              << "] " << to_string(req.method()) << " " << req.uri()
              << " -> " << static_cast<int>(resp.status_code()) 
              << " " << resp.body().size() << " bytes" << std::endl;
});

// CORS 中間件
router.add_middleware([](const http::Request& req, http::Response& resp) {
    resp.headers().set("Access-Control-Allow-Origin", "*");
    resp.headers().set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
    resp.headers().set("Access-Control-Allow-Headers", "Content-Type, Authorization");
});

// 安全頭部中間件
router.add_middleware([](const http::Request& req, http::Response& resp) {
    resp.headers().set("X-Content-Type-Options", "nosniff");
    resp.headers().set("X-Frame-Options", "DENY");
    resp.headers().set("X-XSS-Protection", "1; mode=block");
});
}

// 編譯時(shí)路由檢查概念
template<typename T>
concept RequestHandler = requires(T handler, const http::Request& req) {
    { handler(req) } -> std::convertible_to<http::Response>;
    requires std::is_nothrow_move_constructible_v<T>;
};

// 編譯時(shí)路由表
template<size_t MaxRoutes = 64>
class CompileTimeRouter {
private:
    struct Route {
        std::string_view pattern;
        http::Method method;
        std::function<http::Response(const http::Request&)> handler;
        std::string_view description;
    };
    
    std::array<Route, MaxRoutes> routes_{};
    size_t route_count_{0};
    
public:
    // 編譯時(shí)路由注冊(cè)
    template<RequestHandler Handler>
    consteval void add_route(std::string_view pattern, 
                           http::Method method, 
                           Handler&& handler,
                           std::string_view description = "") {
        static_assert(route_count_ < MaxRoutes, "路由數(shù)量超過(guò)限制");
        
        routes_[route_count_] = Route{
            pattern,
            method,
            std::function<http::Response(const http::Request&)>(std::forward<Handler>(handler)),
            description
        };
        route_count_++;
    }
    
    // 運(yùn)行時(shí)路由查找
    auto find_handler(const http::Request& request) const 
        -> std::optional<std::function<http::Response(const http::Request&)>> {
        
        for (size_t i = 0; i < route_count_; ++i) {
            const auto& route = routes_[i];
            if (route.method == request.method()) {
                std::regex pattern(route.pattern.data(), route.pattern.length());
                if (std::regex_match(request.uri(), pattern)) {
                    return route.handler;
                }
            }
        }
        return std::nullopt;
    }
    
    constexpr size_t size() const { return route_count_; }
    
    // 編譯時(shí)路由信息輸出
    constexpr void print_routes() const {
        std::cout << "\n=== 編譯時(shí)路由表 ===" << std::endl;
        for (size_t i = 0; i < route_count_; ++i) {
            const auto& route = routes_[i];
            std::cout << to_string(route.method) << " " 
                      << route.pattern << " - " 
                      << route.description << std::endl;
        }
        std::cout << "====================\n" << std::endl;
    }
};

// 編譯時(shí)路由構(gòu)建器
template<size_t N>
consteval auto create_router() {
    CompileTimeRouter<N> router;
    
    // 編譯時(shí)注冊(cè)路由
    router.add_route("/api/health", http::Method::GET,
        [](const http::Request&) -> http::Response {
            return http::Response::text_response("OK");
        }, "健康檢查");
    
    router.add_route("/api/version", http::Method::GET,
        [](const http::Request&) -> http::Response {
            nlohmann::json version_info = {
                {"name", "Modern C++ HTTP Server"},
                {"version", "2.0.0"},
                {"compiler", __VERSION__},
                {"standard", __cplusplus}
            };
            return http::Response::json_response(version_info.dump());
        }, "版本信息");
    
    return router;
}

// 使用編譯時(shí)常量路由表
constexpr auto global_router = create_router<32>();

// 線程安全的對(duì)象池
template<typename T, size_t GrowthSize = 64>
class ObjectPool {
private:
    struct PooledObject {
        T object;
        bool in_use = false;
    };
    
    std::vector<std::unique_ptr<PooledObject>> pool_;
    std::stack<PooledObject*> available_;
    std::mutex mutex_;
    std::atomic<size_t> total_objects_{0};
    std::atomic<size_t> active_objects_{0};
    
public:
    template<typename... Args>
    ObjectPool(size_t initial_size = 32, Args&&... args) {
        expand(initial_size, std::forward<Args>(args)...);
        std::cout << "對(duì)象池初始化: " << initial_size << " 個(gè)對(duì)象" << std::endl;
    }
    
    ~ObjectPool() {
        std::lock_guard lock(mutex_);
        std::cout << "對(duì)象池銷毀 - 總對(duì)象: " << total_objects_
                  << ", 活躍對(duì)象: " << active_objects_ << std::endl;
    }
    
    // 獲取對(duì)象
    template<typename... Args>
    auto acquire(Args&&... args) -> std::unique_ptr<T, std::function<void(T*)>> {
        std::lock_guard lock(mutex_);
        
        if (available_.empty()) {
            expand(GrowthSize, std::forward<Args>(args)...);
        }
        
        auto* pooled_obj = available_.top();
        available_.pop();
        
        pooled_obj->in_use = true;
        active_objects_.fetch_add(1, std::memory_order_relaxed);
        
        // 自定義刪除器，將對(duì)象返回到池中
        auto deleter = [this](T* obj) {
            this->release(obj);
        };
        
        return std::unique_ptr<T, std::function<void(T*)>>(
            &pooled_obj->object, std::move(deleter));
    }
    
    size_t total_objects() const { return total_objects_.load(); }
    size_t active_objects() const { return active_objects_.load(); }
    size_t available_objects() const { 
        std::lock_guard lock(mutex_);
        return available_.size(); 
    }

private:
    template<typename... Args>
    void expand(size_t count, Args&&... args) {
        for (size_t i = 0; i < count; ++i) {
            auto pooled_obj = std::make_unique<PooledObject>();
            // 原位構(gòu)造對(duì)象
            new (&pooled_obj->object) T(std::forward<Args>(args)...);
            
            available_.push(pooled_obj.get());
            pool_.push_back(std::move(pooled_obj));
        }
        total_objects_.fetch_add(count, std::memory_order_relaxed);
        
        std::cout << "對(duì)象池?cái)U(kuò)容: +" << count 
                  << " 對(duì)象，總計(jì): " << total_objects_ << std::endl;
    }
    
    void release(T* obj) {
        std::lock_guard lock(mutex_);
        
        // 找到對(duì)應(yīng)的PooledObject
        for (auto& pooled_obj : pool_) {
            if (&pooled_obj->object == obj) {
                pooled_obj->in_use = false;
                available_.push(pooled_obj.get());
                active_objects_.fetch_sub(1, std::memory_order_relaxed);
                break;
            }
        }
    }
};

// 連接專用的對(duì)象池
class ConnectionPool {
private:
    ObjectPool<Connection> pool_;
    
public:
    ConnectionPool(size_t initial_size = 1000)
        : pool_(initial_size) {}
    
    auto create_connection(std::unique_ptr<Socket> socket) {
        return pool_.acquire(std::move(socket));
    }
    
    void print_stats() const {
        std::cout << "連接池統(tǒng)計(jì) - 總數(shù): " << pool_.total_objects()
                  << ", 活躍: " << pool_.active_objects()
                  << ", 可用: " << pool_.available_objects() << std::endl;
    }
};

// 緩沖池，用于管理讀/寫緩沖區(qū)
class BufferPool {
private:
    static constexpr size_t BUFFER_SIZE = 8192;
    ObjectPool<std::array<char, BUFFER_SIZE>> pool_;
    
public:
    BufferPool(size_t initial_size = 500) : pool_(initial_size) {}
    
    auto acquire_buffer() {
        return pool_.acquire();
    }
    
    size_t buffer_size() const { return BUFFER_SIZE; }
};

// 在HTTP服務(wù)器中使用對(duì)象池
class HighPerformanceHTTPServer {
private:
    ConnectionPool connection_pool_;
    BufferPool buffer_pool_;
    ThreadPool thread_pool_;
    Router router_;
    
    // 統(tǒng)計(jì)信息
    std::atomic<uint64_t> total_requests_{0};
    std::atomic<uint64_t> active_connections_{0};
    std::chrono::steady_clock::time_point start_time_;
    
public:
    HighPerformanceHTTPServer()
        : connection_pool_(1000)
        , buffer_pool_(500)
        , thread_pool_()
        , start_time_(std::chrono::steady_clock::now()) {
        
        setup_routes();
        setup_middlewares(router_);
        
        std::cout << "高性能HTTP服務(wù)器初始化完成" << std::endl;
        print_stats(); // 初始統(tǒng)計(jì)
    }
    
    void handle_new_connection(std::unique_ptr<Socket> socket) {
        auto connection = connection_pool_.create_connection(std::move(socket));
        auto buffer = buffer_pool_.acquire_buffer();
        
        active_connections_.fetch_add(1, std::memory_order_relaxed);
        
        // 在線程池中處理連接
        thread_pool_.submit([this, conn = std::move(connection), 
                            buf = std::move(buffer)]() mutable {
            process_connection(std::move(conn), std::move(buf));
        });
    }
    
    void print_stats() const {
        auto now = std::chrono::steady_clock::now();
        auto uptime = std::chrono::duration_cast<std::chrono::seconds>(now - start_time_);
        
        std::cout << "\n=== 服務(wù)器統(tǒng)計(jì) ===" << std::endl;
        std::cout << "運(yùn)行時(shí)間: " << uptime.count() << " 秒" << std::endl;
        std::cout << "總請(qǐng)求數(shù): " << total_requests_.load() << std::endl;
        std::cout << "活躍連接: " << active_connections_.load() << std::endl;
        std::cout << "請(qǐng)求速率: " << (total_requests_.load() / std::max(uptime.count(), 1LL)) 
                  << " 請(qǐng)求/秒" << std::endl;
        
        connection_pool_.print_stats();
        std::cout << "==================\n" << std::endl;
    }

private:
    void setup_routes() {
        setup_advanced_routes(router_);
        
        // 性能監(jiān)控端點(diǎn)
        router_.add_route(http::Method::GET, "/api/stats", 
            [this](const http::Request&) {
                auto now = std::chrono::steady_clock::now();
                auto uptime = std::chrono::duration_cast<std::chrono::seconds>(now - start_time_);
                
                nlohmann::json stats = {
                    {"uptime", uptime.count()},
                    {"total_requests", total_requests_.load()},
                    {"active_connections", active_connections_.load()},
                    {"request_rate", total_requests_.load() / std::max(uptime.count(), 1LL)},
                    {"connection_pool", {
                        {"total", connection_pool_.total_objects()},
                        {"active", connection_pool_.active_objects()},
                        {"available", connection_pool_.available_objects()}
                    }},
                    {"thread_pool", {
                        {"threads", thread_pool_.total_threads()},
                        {"active_tasks", thread_pool_.active_tasks()},
                        {"pending_tasks", thread_pool_.pending_tasks()}
                    }}
                };
                return http::Response::json_response(stats.dump());
            }, "服務(wù)器統(tǒng)計(jì)信息");
    }
    
    void process_connection(std::unique_ptr<Connection, 
                          std::function<void(Connection*)>> conn,
                          std::unique_ptr<std::array<char, 8192>, 
                          std::function<void(std::array<char, 8192>*)>> buffer) {
        
        // 連接處理邏輯
        try {
            conn->start();
            total_requests_.fetch_add(1, std::memory_order_relaxed);
        } catch (const std::exception& e) {
            std::cerr << "處理連接時(shí)發(fā)生錯(cuò)誤: " << e.what() << std::endl;
        }
        
        active_connections_.fetch_sub(1, std::memory_order_relaxed);
        
        // 定期打印統(tǒng)計(jì)信息
        if (total_requests_.load() % 1000 == 0) {
            print_stats();
        }
    }
};

// 測(cè)試配置文件
struct TestConfig {
    std::string host = "127.0.0.1";
    uint16_t port = 8080;
    int test_duration_seconds = 30;
    int concurrent_clients = 100;
    size_t request_size = 1024;
};

// 基礎(chǔ)測(cè)試夾具
class HTTPServerTest : public ::testing::Test {
protected:
    void SetUp() override {
        server_thread_ = std::jthread([this] {
            server_ = std::make_unique<HighPerformanceHTTPServer>();
            server_->run("127.0.0.1", 8080);
        });
        
        // 等待服務(wù)器啟動(dòng)
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    
    void TearDown() override {
        if (server_) {
            server_->stop();
        }
    }
    
    std::unique_ptr<HighPerformanceHTTPServer> server_;
    std::jthread server_thread_;
};

// 單元測(cè)試
TEST_F(HTTPServerTest, RequestParserValidRequest) {
    RequestParser parser;
    std::string request = 
        "GET /api/users/123 HTTP/1.1\r\n"
        "Host: localhost:8080\r\n"
        "User-Agent: TestClient/1.0\r\n"
        "Accept: application/json\r\n"
        "\r\n";
    
    auto result = parser.parse(request);
    ASSERT_TRUE(result.has_value());
    EXPECT_EQ(result->method(), http::Method::GET);
    EXPECT_EQ(result->uri(), "/api/users/123");
    EXPECT_EQ(result->version(), http::Version::HTTP1_1);
}

TEST_F(HTTPServerTest, RequestParserChunkedEncoding) {
    RequestParser parser;
    std::string request = 
        "POST /api/data HTTP/1.1\r\n"
        "Host: localhost:8080\r\n"
        "Transfer-Encoding: chunked\r\n"
        "\r\n"
        "5\r\n"
        "Hello\r\n"
        "6\r\n"
        " World\r\n"
        "0\r\n"
        "\r\n";
    
    auto result = parser.parse(request);
    ASSERT_TRUE(result.has_value());
    EXPECT_EQ(result->method(), http::Method::POST);
    EXPECT_EQ(result->body(), "Hello World");
}

TEST_F(HTTPServerTest, RouterBasicRouting) {
    Router router;
    router.add_route(http::Method::GET, "/api/test", 
        [](const http::Request&) {
            return http::Response::text_response("OK");
        });
    
    http::Request request(http::Method::GET, "/api/test");
    auto response = router.route(request);
    
    ASSERT_TRUE(response.has_value());
    EXPECT_EQ(response->status_code(), http::StatusCode::OK);
    EXPECT_EQ(response->body(), "OK");
}

// 性能基準(zhǔn)測(cè)試
class HTTPServerBenchmark : public ::benchmark::Fixture {
protected:
    void SetUp(const ::benchmark::State& state) override {
        server_ = std::make_unique<HighPerformanceHTTPServer>();
        server_thread_ = std::jthread([this] {
            server_->run("127.0.0.1", 8080);
        });
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
    
    void TearDown(const ::benchmark::State& state) override {
        server_->stop();
    }
    
    std::unique_ptr<HighPerformanceHTTPServer> server_;
    std::jthread server_thread_;
};

BENCHMARK_DEFINE_F(HTTPServerBenchmark, RequestParsing)(benchmark::State& state) {
    RequestParser parser;
    std::string request = 
        "GET /api/users/123 HTTP/1.1\r\n"
        "Host: localhost:8080\r\n"
        "User-Agent: Benchmark/1.0\r\n"
        "\r\n";
    
    for (auto _ : state) {
        auto result = parser.parse(request);
        benchmark::DoNotOptimize(result);
    }
    
    state.SetItemsProcessed(state.iterations());
}
BENCHMARK_REGISTER_F(HTTPServerBenchmark, RequestParsing);

BENCHMARK_DEFINE_F(HTTPServerBenchmark, RouterMatching)(benchmark::State& state) {
    Router router;
    for (int i = 0; i < 100; ++i) {
        router.add_route(http::Method::GET, "/api/endpoint" + std::to_string(i),
            [](const http::Request&) {
                return http::Response::text_response("OK");
            });
    }
    
    http::Request request(http::Method::GET, "/api/endpoint50");
    
    for (auto _ : state) {
        auto response = router.route(request);
        benchmark::DoNotOptimize(response);
    }
    
    state.SetItemsProcessed(state.iterations());
}
BENCHMARK_REGISTER_F(HTTPServerBenchmark, RouterMatching);

// 集成測(cè)試
class HTTPServerIntegrationTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 啟動(dòng)測(cè)試服務(wù)器
        server_ = std::make_unique<HighPerformanceHTTPServer>();
        server_thread_ = std::jthread([this] {
            server_->run("127.0.0.1", 8080);
        });
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
    
    void TearDown() override {
        server_->stop();
    }
    
    std::unique_ptr<HighPerformanceHTTPServer> server_;
    std::jthread server_thread_;
};

TEST_F(HTTPServerIntegrationTest, HealthCheck) {
    HttpClient client("127.0.0.1", 8080);
    auto response = client.get("/health");
    
    EXPECT_EQ(response.status_code, 200);
    EXPECT_EQ(response.body, "OK");
}

TEST_F(HTTPServerIntegrationTest, ConcurrentRequests) {
    constexpr int num_clients = 50;
    constexpr int requests_per_client = 100;
    
    std::vector<std::future<int>> futures;
    std::atomic<int> successful_requests{0};
    
    for (int i = 0; i < num_clients; ++i) {
        futures.push_back(std::async(std::launch::async, [i, &successful_requests] {
            HttpClient client("127.0.0.1", 8080);
            int success_count = 0;
            
            for (int j = 0; j < requests_per_client; ++j) {
                try {
                    auto response = client.get("/api/health");
                    if (response.status_code == 200) {
                        success_count++;
                    }
                } catch (const std::exception& e) {
                    // 請(qǐng)求失敗
                }
            }
            
            successful_requests.fetch_add(success_count);
            return success_count;
        }));
    }
    
    // 等待所有客戶端完成
    int total_success = 0;
    for (auto& future : futures) {
        total_success += future.get();
    }
    
    EXPECT_GE(total_success, num_clients * requests_per_client * 0.95); // 95% 成功率
    EXPECT_EQ(total_success, successful_requests.load());
}

// 壓力測(cè)試工具
class StressTester {
private:
    TestConfig config_;
    std::atomic<uint64_t> total_requests_{0};
    std::atomic<uint64_t> successful_requests_{0};
    std::atomic<uint64_t> failed_requests_{0};
    
public:
    explicit StressTester(TestConfig config = {}) : config_(std::move(config)) {}
    
    struct TestResults {
        uint64_t total_requests;
        uint64_t successful_requests;
        uint64_t failed_requests;
        double requests_per_second;
        double success_rate;
        std::chrono::duration<double> duration;
    };
    
    TestResults run_stress_test() {
        auto start_time = std::chrono::steady_clock::now();
        
        std::vector<std::jthread> clients;
        clients.reserve(config_.concurrent_clients);
        
        // 啟動(dòng)并發(fā)客戶端
        for (int i = 0; i < config_.concurrent_clients; ++i) {
            clients.emplace_back([this] { client_worker(); });
        }
        
        // 運(yùn)行指定時(shí)間
        std::this_thread::sleep_for(std::chrono::seconds(config_.test_duration_seconds));
        
        // 停止測(cè)試
        stop_test_ = true;
        
        auto end_time = std::chrono::steady_clock::now();
        auto duration = end_time - start_time;
        
        // 等待所有客戶端結(jié)束
        for (auto& client : clients) {
            if (client.joinable()) {
                client.join();
            }
        }
        
        return calculate_results(duration);
    }
    
    void print_results(const TestResults& results) const {
        std::cout << "\n=== 壓力測(cè)試結(jié)果 ===" << std::endl;
        std::cout << "持續(xù)時(shí)間: " << results.duration.count() << " 秒" << std::endl;
        std::cout << "總請(qǐng)求數(shù): " << results.total_requests << std::endl;
        std::cout << "成功請(qǐng)求: " << results.successful_requests << std::endl;
        std::cout << "失敗請(qǐng)求: " << results.failed_requests << std::endl;
        std::cout << "請(qǐng)求速率: " << results.requests_per_second << " 請(qǐng)求/秒" << std::endl;
        std::cout << "成功率: " << (results.success_rate * 100) << "%" << std::endl;
        std::cout << "====================\n" << std::endl;
    }

private:
    std::atomic<bool> stop_test_{false};
    
    void client_worker() {
        HttpClient client(config_.host, config_.port);
        
        while (!stop_test_.load()) {
            try {
                auto response = client.get("/api/health");
                total_requests_.fetch_add(1);
                
                if (response.status_code == 200) {
                    successful_requests_.fetch_add(1);
                } else {
                    failed_requests_.fetch_add(1);
                }
            } catch (const std::exception&) {
                total_requests_.fetch_add(1);
                failed_requests_.fetch_add(1);
            }
            
            // 短暫休息，避免過(guò)度占用CPU
            std::this_thread::sleep_for(std::chrono::microseconds(100));
        }
    }
    
    TestResults calculate_results(std::chrono::duration<double> duration) const {
        auto total = total_requests_.load();
        auto success = successful_requests_.load();
        auto failed = failed_requests_.load();
        
        return TestResults{
            total,
            success,
            failed,
            total / duration.count(),
            static_cast<double>(success) / total,
            duration
        };
    }
};

// 示例測(cè)試運(yùn)行器
void run_comprehensive_tests() {
    std::cout << "開始全面測(cè)試..." << std::endl;
    
    // 單元測(cè)試
    ::testing::GTEST_FLAG(output) = "xml:unit_test_results.xml";
    ::testing::InitGoogleTest();
    auto unit_test_result = RUN_ALL_TESTS();
    
    // 性能測(cè)試
    ::benchmark::Initialize(nullptr, nullptr);
    ::benchmark::RunSpecifiedBenchmarks();
    
    // 壓力測(cè)試
    TestConfig stress_config;
    stress_config.concurrent_clients = 200;
    stress_config.test_duration_seconds = 60;
    
    StressTester tester(stress_config);
    auto results = tester.run_stress_test();
    tester.print_results(results);
    
    std::cout << "全面測(cè)試完成" << std::endl;
}