zenith_http1/

parser.rs

//! HTTP/1.1 请求解析器
//!
//! 实现 RFC 7230/7231 严格解析，增量（流式）处理。

use crate::smuggling::SmugglingDetector;
use crate::types::{HeaderEntry, HeaderList, Http1Config, Http1Error, HttpRequest, HttpRequestLine};

/// HTTP/1.1 解析器状态
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ParserState {
    /// 等待请求
    WaitingRequest,
    /// 读取请求行
    ReadingRequest,
    /// 读取头部
    ReadingHeaders,
    /// 读取请求体（已知 Content-Length 字节流）
    ReadingBody,
    /// 读取 chunked 编码的 chunk-size 行（RFC 7230 §4.1）
    ReadingChunkSize,
    /// 读取 chunked 编码的 chunk-data 字节（含尾部 CRLF 消费）
    ReadingChunkData,
    /// 读取 chunked 编码的 trailer-part（最后一个 0-size chunk 之后）
    ReadingChunkTrailer,
    /// 头部+请求体 全部读取完成（可安全返回 HttpRequest）
    HeadersComplete,
    /// 错误
    Error,
}

/// 在 buf[start..] 中查找 CRLF
#[inline]
fn find_crlf_at(buf: &[u8], start: usize) -> Option<usize> {
    let mut i = start;
    while i + 1 < buf.len() {
        if buf[i] == b'\r' && buf[i + 1] == b'\n' {
            return Some(i);
        }
        i += 1;
    }
    None
}

/// RFC 7230 §3.5 容错拒绝：裸 LF（不紧随 CR）属于非法行分隔，
/// fail-closed 立即拒绝（禁止静默滞留直至 idle_timeout，阻塞 DoS）。
///
/// 判定区间仅自 `scanned` 起（已消费部分不再重复扫描，O(n) 单遍）。
///
/// HTTP-004：增量 feed 跨边界时，上一 feed 末尾若为 CR、本 feed 以 LF 开头，
/// 构成合法的 CRLF 而非裸 LF。为此函数引入 `init_prev_cr`（区间起始前一个字节
/// 是否为 CR），并返回区间末尾字节是否为 CR，供调用方保存跨 feed 状态。
#[inline]
fn scan_bare_lf(buf: &[u8], init_prev_cr: bool) -> (bool, bool) {
    let mut prev_cr = init_prev_cr;
    for &b in buf {
        if b == b'\n' && !prev_cr {
            return (true, false);
        }
        prev_cr = b == b'\r';
    }
    (false, prev_cr)
}

/// HTTP/1.1 请求解析器
#[derive(Debug, Clone)]
pub struct Http1Parser {
    config: Http1Config,
    state: ParserState,
    /// 头部列表
    headers: HeaderList,
    /// 统一缓冲区（累积数据）
    buf: Vec<u8>,
    /// 已扫描位置
    scanned: usize,
    /// 请求行解析
    request_line: Option<HttpRequestLine>,
    /// 走私检测器
    smuggler: SmugglingDetector,
    /// 首字节时间戳（毫秒），用于 Slowloris 空闲超时检测
    first_byte_ms: Option<u64>,
    /// 最近一次收到字节的时间戳（毫秒），body/chunked 阶段 Slowloris 防护（M-9）
    last_activity_ms: Option<u64>,
    /// 期望读取的请求体字节数（Some(cl) = Content-Length，None = 未知/无）
    body_expected: Option<u64>,
    /// 已累积的请求体字节（ReadingBody / ReadingChunkData 状态下使用）
    partial_body: Vec<u8>,
    /// chunked 编码当前 chunk 剩余待读字节数
    chunk_remaining: usize,
    /// HTTP-004：增量 feed 跨边界时，上一 feed 末尾字节是否为 CR，
    /// 用于裸 LF 检测的状态延续（避免 CRLF 被拆分成两次 feed 时误判为裸 LF）。
    last_byte_was_cr: bool,
}

impl Http1Parser {
    /// 创建解析器
    #[inline]
    pub fn new(config: Http1Config) -> Self {
        Self {
            config,
            state: ParserState::WaitingRequest,
            headers: HeaderList::new(),
            buf: Vec::with_capacity(256),
            scanned: 0,
            request_line: None,
            smuggler: SmugglingDetector::new(),
            first_byte_ms: None,
            last_activity_ms: None,
            body_expected: None,
            partial_body: Vec::new(),
            chunk_remaining: 0,
            last_byte_was_cr: false,
        }
    }

    /// 重置解析器
    pub fn reset(&mut self) {
        self.state = ParserState::WaitingRequest;
        self.headers.clear();
        self.buf.clear();
        self.scanned = 0;
        self.request_line = None;
        self.first_byte_ms = None;
        self.last_activity_ms = None;
        self.body_expected = None;
        self.partial_body.clear();
        self.chunk_remaining = 0;
        self.last_byte_was_cr = false;
    }

    /// 当前状态
    #[inline]
    pub fn state(&self) -> ParserState {
        self.state
    }

    /// 检查空闲超时（Slowloris 防护）
    ///
    /// 由连接管理层在每个事件循环周期调用。
    /// 计时基准为最近一次收到字节的时间（`last_activity_ms`，
    /// 未记录时回退首字节时间）：头部阶段自首字节起计时，
    /// body/chunked 阶段自最近一次活跃起计时——任何阶段超时一律
    /// fail-closed，杜绝 body 中途 Slowloris 盲区（M-9）。
    ///
    /// # 参数
    /// * `now_ms` - 当前时间戳（毫秒）
    pub fn check_idle_timeout(&mut self, now_ms: u64) -> Result<(), Http1Error> {
        // HeadersComplete（已交付上层）与 Error（已终结）不参与空闲计时
        if matches!(
            self.state,
            ParserState::HeadersComplete | ParserState::Error
        ) {
            return Ok(());
        }
        let deadline_base = self.last_activity_ms.or(self.first_byte_ms);
        if let Some(base) = deadline_base
            && now_ms.saturating_sub(base) > self.config.idle_timeout_ms
        {
            self.state = ParserState::Error;
            return Err(Http1Error::IdleTimeout);
        }
        Ok(())
    }

    /// 通知首字节到达（由连接层在收到首个数据时调用）
    ///
    /// 仅记录首字节时间；增量数据的活跃刷新请使用
    /// [`Self::note_activity`]（每次收到数据都应调用）。
    #[inline]
    pub fn note_first_byte(&mut self, now_ms: u64) {
        if self.first_byte_ms.is_none() {
            self.first_byte_ms = Some(now_ms);
        }
    }

    /// 通知活动时间（由连接层在**每次**收到数据时调用）
    ///
    /// 刷新最近一次活跃时间戳，并兼具首字节记录语义。
    /// body/chunked 阶段的 Slowloris 防护依赖本时间戳（M-9）。
    #[inline]
    pub fn note_activity(&mut self, now_ms: u64) {
        if self.first_byte_ms.is_none() {
            self.first_byte_ms = Some(now_ms);
        }
        self.last_activity_ms = Some(now_ms);
    }

    /// 解析输入数据
    pub fn feed(&mut self, input: &[u8]) -> Result<(Option<HttpRequest>, usize), Http1Error> {
        if input.is_empty() {
            // 空输入：若已有完整请求则返回
            if matches!(self.state, ParserState::HeadersComplete) {
                let req = self.build_request()?;
                return Ok((Some(req), 0));
            }
            // 无剩余字节可处理 → 需要更多数据
            if self.scanned >= self.buf.len() {
                return Ok((None, 0));
            }
            // 有剩余字节（pipelining / 跨 feed chunked）→ 继续到扫描循环
        }

        // 记录加入 buf 前的已处理位置
        let scanned_before = self.scanned;
        let old_buf_len = self.buf.len();

        // Slowloris 防护：缓冲区累积上限检查
        // checked 算术：输入长度由对端控制，溢出按缓冲区超限处理（fail-closed）
        let new_buf_len = match old_buf_len.checked_add(input.len()) {
            Some(n) => n,
            None => {
                self.state = ParserState::Error;
                return Err(Http1Error::BufferOverflow);
            }
        };
        if new_buf_len > self.config.max_buffer_size {
            self.state = ParserState::Error;
            return Err(Http1Error::BufferOverflow);
        }

        self.buf.extend_from_slice(input);
        let new_bytes = self.buf.len() - old_buf_len;

        // 扫描循环：在 self.buf[self.scanned..] 中解析
        while !matches!(self.state, ParserState::HeadersComplete | ParserState::Error) {
            match self.state {
                ParserState::WaitingRequest | ParserState::ReadingRequest => {
                    if let Some(cp) = find_crlf_at(&self.buf, self.scanned) {
                        // M-3：找到 CRLF 后同样约束请求行长度上限
                        // （此前仅约束未完成行，完整超长行可绕过防线）
                        if cp - self.scanned > self.config.max_request_line_size {
                            self.state = ParserState::Error;
                            return Err(Http1Error::RequestLineTooLong);
                        }
                        // §6.1.1：行切片直接借用 buf，零行级拷贝
                        self.request_line =
                            Some(parse_request_line(&self.buf[self.scanned..cp])?);
                        self.scanned = cp + 2;
                        self.state = ParserState::ReadingHeaders;
                    } else {
                        // RFC 7230 §3.5：裸 LF 非法行分隔，fail-closed 立即拒绝
                        // （禁止静默滞留至 idle_timeout，阻塞 DoS）
                        if self.check_bare_lf(self.scanned) {
                            self.state = ParserState::Error;
                            return Err(Http1Error::SyntaxError(
                                "bare LF in request line not allowed (RFC 7230 §3.5)".into(),
                            ));
                        }
                        // 未完成请求行（未找到 CRLF）超过上限 → 请求行过长
                        if self.buf.len() - self.scanned > self.config.max_request_line_size {
                            self.state = ParserState::Error;
                            return Err(Http1Error::RequestLineTooLong);
                        }
                        break;
                    }
                }
                ParserState::ReadingHeaders => {
                    let mut line_start = self.scanned;
                    let mut progressed = false;
                    let mut headers_done = false;
                    'lines: loop {
                        if line_start >= self.buf.len() {
                            break 'lines;
                        }
                        let rest = &self.buf[line_start..];
                        if let Some(cp) = find_crlf(rest) {
                            let line_end = line_start + cp;
                            // §6.1.1：行切片直接借用 buf，零行级拷贝
                            let line_slice = &self.buf[line_start..line_end];
                            line_start = line_end + 2;
                            progressed = true;
                            if line_slice.is_empty() {
                                self.scanned = line_start;
                                headers_done = true;
                                break 'lines;
                            }
                            if let Some(entry) = parse_header_line(line_slice, &self.config)? {
                                self.headers.push(entry);
                            }
                            if self.headers.len() > self.config.max_header_count {
                                self.state = ParserState::Error;
                                return Err(Http1Error::TooManyHeaders);
                            }
                            if self.current_header_size() > self.config.max_header_size {
                                self.state = ParserState::Error;
                                return Err(Http1Error::HeaderTooLarge);
                            }
                        } else {
                            // RFC 7230 §3.5：头部区块中的裸 LF 拒绝（见 request line 同款）
                            if self.check_bare_lf(line_start) {
                                self.state = ParserState::Error;
                                return Err(Http1Error::SyntaxError(
                                    "bare LF in header block not allowed (RFC 7230 §3.5)".into(),
                                ));
                            }
                            break 'lines;
                        }
                    }
                    if !progressed {
                        if self.buf.len() - self.scanned > self.config.max_header_size {
                            self.state = ParserState::Error;
                            return Err(Http1Error::HeaderTooLarge);
                        }
                        break;
                    }
                    self.scanned = line_start;

                    if headers_done {
                        // 头部读取完毕 → 先执行严格走私检测（必须在任何 body 分支决策前）
                        if let Err(e) = self.smuggler.detect_err_already_lowercased(self.headers.as_slice()) {
                            self.state = ParserState::Error;
                            return Err(e);
                        }
                        // 严格校验：HTTP/1.1 必须有 Host 头（必须在 body 决策前）
                        if !self.has_host() {
                            self.state = ParserState::Error;
                            return Err(Http1Error::MissingHost);
                        }
                        // RFC 7230 §5.4/§5.5：absolute-form 目标的 authority
                        // 必须与 Host 头一致（大小写不敏感）——若按不同来源
                        // 取主机是经典差异解析走私向量，不一致 fail-closed
                        self.check_absolute_form_host_consistency()?;

                        // 头部已全部读完，根据 Content-Length / Transfer-Encoding 决定下一步
                        // S-2：CL 头存在但数值不可解析（超 u64 等）一律 fail-closed，
                        // 禁止解析失败静默当作"无 body"
                        let content_length = match parse_content_length(self.headers.as_slice()) {
                            Ok(v) => v,
                            Err(e) => {
                                self.state = ParserState::Error;
                                return Err(e);
                            }
                        };
                        let te = analyze_transfer_encoding(self.headers.as_slice());

                        // RFC 7230 §3.3.1：Transfer-Encoding 仅由 HTTP/1.1 定义，
                        // HTTP/1.0 请求出现 TE 一律拒绝（fail-closed）
                        let is_http10 = self
                            .request_line
                            .as_ref()
                            .map(|l| l.version.as_ref() == "HTTP/1.0")
                            .unwrap_or(false);
                        if is_http10 && te != TransferEncodingKind::None {
                            self.state = ParserState::Error;
                            return Err(Http1Error::SmugglingDetected(
                                "Transfer-Encoding in HTTP/1.0 request".into(),
                            ));
                        }
                        // TE 存在但无 chunked 且非 identity → 按走私拒绝（fail-closed），
                        // 与 SmugglingDetector 语义统一
                        if te == TransferEncodingKind::Invalid {
                            self.state = ParserState::Error;
                            return Err(Http1Error::SmugglingDetected(
                                "Transfer-Encoding without 'chunked'".into(),
                            ));
                        }
                        // 仅当 TE 含 chunked 时才按 chunked 解析
                        let chunked = te == TransferEncodingKind::Chunked;

                        if chunked {
                            // 进入 chunked 请求体解析状态机（RFC 7230 §4.1）
                            // 后续状态：ReadingChunkSize → ReadingChunkData → ReadingChunkSize → ...
                            //           → ReadingChunkTrailer → HeadersComplete
                            self.body_expected = None;
                            self.partial_body.clear();
                            self.chunk_remaining = 0;
                            self.state = ParserState::ReadingChunkSize;
                        } else if let Some(cl) = content_length {
                            if cl == 0 {
                                // 显式声明 Content-Length: 0 → 空 body
                                self.body_expected = Some(0);
                                self.partial_body.clear();
                                self.state = ParserState::HeadersComplete;
                            } else {
                                // 需要读取固定长度 body：进入 ReadingBody 状态
                                self.body_expected = Some(cl);
                                self.partial_body.clear();
                                // checked 算术：u64 CL → usize 必须显式转换，
                                // 禁止 `as usize` 高位静默截断（§4.4 fail-closed）
                                let cl_usize = match usize::try_from(cl) {
                                    Ok(n) => n,
                                    Err(_) => {
                                        self.state = ParserState::Error;
                                        return Err(Http1Error::BodyTooLarge);
                                    }
                                };
                                if cl_usize > self.config.max_body_size {
                                    self.state = ParserState::Error;
                                    return Err(Http1Error::BodyTooLarge);
                                }
                                // 预分配一次，避免多次 realloc；
                                // 上限 64KB：攻击者声明巨大 CL 时不得触发等额预分配（OOM 防护），
                                // 超出部分由后续 extend 按需增长
                                self.partial_body.reserve(core::cmp::min(cl_usize, 64 * 1024));
                                self.state = ParserState::ReadingBody;
                                // 若当前 buf 中已有 body 字节，先拷贝一部分
                                let tail_avail = self.buf.len().saturating_sub(self.scanned);
                                if tail_avail > 0 {
                                    let copy_n =
                                        core::cmp::min(tail_avail, cl_usize);
                                    self.partial_body
                                        .extend_from_slice(&self.buf[self.scanned..self.scanned + copy_n]);
                                    self.scanned += copy_n;
                                }
                                // body 已读满 → 直接完成
                                if self.partial_body.len() as u64 >= cl {
                                    self.state = ParserState::HeadersComplete;
                                }
                            }
                        } else {
                            // 无 Content-Length 且非 chunked → 视为无 body（HTTP/1.1 默认）
                            self.body_expected = None;
                            self.partial_body.clear();
                            self.state = ParserState::HeadersComplete;
                        }
                    }
                }
                ParserState::ReadingBody => {
                    let cl = match self.body_expected {
                        Some(c) => c,
                        None => {
                            // 意外：ReadingBody 但未设置 body_expected，兜底直接完成
                            self.state = ParserState::HeadersComplete;
                            break;
                        }
                    };
                    // cl 进入本状态前已经 try_from(cl) <= max_body_size 校验，
                    // 在 u64 域内计算剩余量，禁止 `as usize` 截断（§4.4）
                    let remaining = cl.saturating_sub(self.partial_body.len() as u64);
                    if remaining == 0 {
                        self.state = ParserState::HeadersComplete;
                        break;
                    }
                    let tail_avail = self.buf.len().saturating_sub(self.scanned);
                    if tail_avail == 0 {
                        // buf 中无更多数据，等待下一次 feed
                        break;
                    }
                    let copy_n = core::cmp::min(remaining, tail_avail as u64) as usize;
                    self.partial_body
                        .extend_from_slice(&self.buf[self.scanned..self.scanned + copy_n]);
                    self.scanned += copy_n;
                    if self.partial_body.len() as u64 >= cl {
                        self.state = ParserState::HeadersComplete;
                    }
                }
                // ── chunked 请求体解析状态机（RFC 7230 §4.1） ───────────────────
                // chunk          = chunk-size [ chunk-ext ] CRLF chunk-data CRLF
                // last-chunk     = 1*("0") [ chunk-ext ] CRLF
                // chunked-body   = *chunk last-chunk trailer-part CRLF
                ParserState::ReadingChunkSize => {
                    // 读取 chunk-size 行（hex [; ext] CRLF）
                    if let Some(cp) = find_crlf_at(&self.buf, self.scanned) {
                        let chunk_size = parse_chunk_size(&self.buf[self.scanned..cp])?;
                        self.scanned = cp + 2;
                        if chunk_size == 0 {
                            // last-chunk → 进入 trailer-part 读取
                            self.state = ParserState::ReadingChunkTrailer;
                        } else {
                            // 累积 body 上限检查（防 OOM）
                            if self
                                .partial_body
                                .len()
                                .checked_add(chunk_size)
                                .map(|sum| sum > self.config.max_body_size)
                                .unwrap_or(true)
                            {
                                self.state = ParserState::Error;
                                return Err(Http1Error::BodyTooLarge);
                            }
                            self.chunk_remaining = chunk_size;
                            self.state = ParserState::ReadingChunkData;
                        }
                    } else {
                        // 需要更多数据
                        break;
                    }
                }
                ParserState::ReadingChunkData => {
                    if self.chunk_remaining > 0 {
                        // 读取 chunk-data 字节
                        let tail_avail = self.buf.len().saturating_sub(self.scanned);
                        if tail_avail == 0 {
                            break;
                        }
                        let copy_n = core::cmp::min(self.chunk_remaining, tail_avail);
                        self.partial_body
                            .extend_from_slice(&self.buf[self.scanned..self.scanned + copy_n]);
                        self.scanned += copy_n;
                        self.chunk_remaining -= copy_n;
                    }
                    if self.chunk_remaining == 0 {
                        // 消费 chunk-data 尾部的 CRLF（RFC 7230 §4.1 强制要求）
                        let tail_avail = self.buf.len().saturating_sub(self.scanned);
                        if tail_avail < 2 {
                            break;
                        }
                        if self.buf[self.scanned] != b'\r'
                            || self.buf[self.scanned + 1] != b'\n'
                        {
                            self.state = ParserState::Error;
                            return Err(Http1Error::ChunkedError(
                                "missing CRLF after chunk data".into(),
                            ));
                        }
                        self.scanned += 2;
                        self.state = ParserState::ReadingChunkSize;
                    }
                }
                ParserState::ReadingChunkTrailer => {
                    // 读取 trailer-part：连续的 header-field CRLF，直到空行 CRLF
                    if let Some(cp) = find_crlf_at(&self.buf, self.scanned) {
                        // §6.1.1：行切片直接借用 buf，零行级拷贝
                        let line_slice = &self.buf[self.scanned..cp];
                        let trailer_entry = if line_slice.is_empty() {
                            None
                        } else {
                            // §6.2.2 语义说明：trailer 头部与普通头部走同一严格校验函数
                            parse_header_line(line_slice, &self.config)?
                        };
                        self.scanned = cp + 2;
                        if line_slice.is_empty() {
                            // trailer-part 结束 → 请求完整
                            self.state = ParserState::HeadersComplete;
                        } else {
                            // 解析 trailer header（与普通 header 相同的严格校验）
                            if let Some(entry) = trailer_entry {
                                self.headers.push(entry);
                            }
                            if self.headers.len() > self.config.max_header_count {
                                self.state = ParserState::Error;
                                return Err(Http1Error::TooManyHeaders);
                            }
                            if self.current_header_size() > self.config.max_header_size {
                                self.state = ParserState::Error;
                                return Err(Http1Error::HeaderTooLarge);
                            }
                        }
                    } else {
                        break;
                    }
                }
                ParserState::HeadersComplete | ParserState::Error => break,
            }
        }

        // 计算本次输入的消耗数：若已达到 HeadersComplete / ReadingBody 消耗了全部新数据，则算消耗整个 input
        let processed_after = self.scanned;
        let processed_delta = processed_after.saturating_sub(scanned_before);

        // consumed 统一语义（L-3 pipelining 依赖精确记账）：
        // - 空输入仅处理既有缓冲，不消耗任何输入字节
        // - 处理量 >= 新增量 → 全部新字节已消耗
        // - 否则消耗实际处理量（多余字节属于下一个 pipelined 请求，
        //   由 parser 内部缓冲保留，调用方按 consumed 推进）
        let consumed = if new_bytes == 0 {
            0
        } else if processed_delta >= new_bytes {
            new_bytes
        } else {
            processed_delta
        };

        // HTTP-004：记录本 feed 末尾字节是否为 CR，供下一 feed 的裸 LF 检测
        // 延续状态（避免 CRLF 被拆分成两次 feed 时误判为裸 LF）。
        self.last_byte_was_cr = self.buf.last() == Some(&b'\r');

        // 清理：若未完成则移除已处理部分（ReadingBody 也需要清理已扫描的 body 前缀字节）
        if !matches!(self.state, ParserState::HeadersComplete) && self.scanned > 0 {
            self.buf.drain(..self.scanned);
            self.scanned = 0;
        }

        if matches!(self.state, ParserState::HeadersComplete) {
            let req = self.build_request()?;
            Ok((Some(req), consumed))
        } else {
            Ok((None, consumed))
        }
    }

    /// 检查 `buf[region_start..]` 内是否存在裸 LF（HTTP-004）。
    ///
    /// 跨 feed 状态延续：当 `region_start == 0`（区间覆盖缓冲起始，即本条数据
    /// 与上一 feed 的边界）时，以 `last_byte_was_cr`（上一 feed 末尾字节是否为
    /// CR）作为扫描的初始 `prev_cr`；否则取缓冲内紧邻区间前的字节。扫描后把
    /// 区间末尾字节的 CR 状态写回 `last_byte_was_cr`，供下一次 feed 使用。
    fn check_bare_lf(&mut self, region_start: usize) -> bool {
        let init_prev_cr = if region_start == 0 {
            self.last_byte_was_cr
        } else {
            self.buf[region_start - 1] == b'\r'
        };
        let (bare, last_cr) = scan_bare_lf(&self.buf[region_start..], init_prev_cr);
        self.last_byte_was_cr = last_cr;
        bare
    }

    /// 组装请求（假设 self.state == HeadersComplete）
    fn build_request(&mut self) -> Result<HttpRequest, Http1Error> {
        let line = self
            .request_line
            .take()
            .ok_or_else(|| Http1Error::Internal("missing request line".into()))?;

        self.smuggler.detect_err_already_lowercased(self.headers.as_slice())?;

        if !self.has_host() {
            return Err(Http1Error::MissingHost);
        }

        // S-2：与 feed 路径同一严格解析（CL 存在但非法一律 fail-closed）
        let content_length = parse_content_length(self.headers.as_slice())?;
        // 与 feed 路径语义统一：仅当 TE 含 chunked 时才视为 chunked
        let chunked =
            analyze_transfer_encoding(self.headers.as_slice()) == TransferEncodingKind::Chunked;
        // RFC 7230 §6.3 / RFC 1945 §1.3：
        // - HTTP/1.0 默认关闭连接，仅显式 `Connection: keep-alive` 才保持
        // - HTTP/1.1 默认保持，仅显式 `Connection: close` 才关闭
        // M-8：Connection 为逗号分隔 token 列表（如 "close, upgrade"），
        // 逐 token trim 后大小写不敏感比较，禁止整串精确匹配绕过
        let keep_alive = if line.version.as_ref() == "HTTP/1.0" {
            connection_has_token(self.headers.as_slice(), "keep-alive")
        } else {
            !connection_has_token(self.headers.as_slice(), "close")
        };

        // body 取自 ReadingBody 阶段累积的 partial_body
        let body: Vec<u8> = std::mem::take(&mut self.partial_body);

        // 严格校验：若声明了 Content-Length 且非 chunked，实际 body 长度必须匹配
        if let Some(cl) = content_length
            && !chunked
            && (body.len() as u64) != cl
        {
            self.state = ParserState::Error;
            return Err(Http1Error::SyntaxError(format!(
                "request body length mismatch: declared Content-Length={cl}, actual bytes={}",
                body.len()
            )));
        }

        let req = HttpRequest {
            line,
            headers: std::mem::take(&mut self.headers),
            body,
            content_length,
            chunked,
            keep_alive,
        };

        // 重置解析器状态以接受下一个请求（keep-alive / pipelining）
        // 关键：仅丢弃已扫描的字节，保留 buf 中剩余字节（属于下一个请求）
        self.state = ParserState::WaitingRequest;
        if self.scanned > 0 && self.scanned <= self.buf.len() {
            self.buf.drain(..self.scanned);
        }
        self.scanned = 0;
        self.body_expected = None;
        self.chunk_remaining = 0;
        // HTTP-004：新请求重新计时交叉 feed 的 CR 状态
        self.last_byte_was_cr = false;
        // 计时字段重置：下一个请求（keep-alive / pipelining）重新计时
        self.first_byte_ms = None;
        self.last_activity_ms = None;
        // partial_body 已通过 std::mem::take 移交给 req，此处无需再次 clear

        Ok(req)
    }

}

/// 严格解析 Content-Length（S-2 fail-closed）
///
/// - 头不存在 → `Ok(None)`
/// - 头存在且为合法 u64 → `Ok(Some(n))`
/// - 头存在但数值不可解析（全数字但超 u64 等）→ `Err`
///
/// 与"头不存在"严格区分：禁止把解析失败静默当作"无 body"
/// （等价 400 语义，fail-closed）。
fn parse_content_length(headers: &[HeaderEntry]) -> Result<Option<u64>, Http1Error> {
    match headers.iter().find(|(k, _)| k.as_ref() == "content-length") {
        None => Ok(None),
        Some((_, v)) => {
            let cl = v.parse::<u64>().map_err(|_| {
                Http1Error::SmugglingDetected(format!(
                    "Content-Length value not parseable as u64: '{}'",
                    v.as_ref()
                ))
            })?;
            Ok(Some(cl))
        }
    }
}

/// 判定 Connection 头部 token 列表中是否含指定 token（M-8）
///
/// RFC 7230 §6.1：Connection = 逗号分隔 token 列表；
/// 逐 token trim 后大小写不敏感比较（如 "close, upgrade" 含 close 语义）。
fn connection_has_token(headers: &[HeaderEntry], token: &str) -> bool {
    headers
        .iter()
        .filter(|(k, _)| k.as_ref() == "connection")
        .flat_map(|(_, v)| v.split(','))
        .map(str::trim)
        .any(|t| t.eq_ignore_ascii_case(token))
}

/// 提取 absolute-form 目标的 authority 部分（RFC 7230 §5.3.2）
///
/// - 以 `http://` / `https://` 开头（scheme 大小写不敏感）→ 返回 authority
///   （到首个 `/`、`?`、`#` 或字符串结尾为止）
/// - 其余形态（origin-form / authority-form / asterisk-form）→ `None`
fn absolute_form_authority(target: &str) -> Option<&str> {
    let after_scheme = if target.len() >= 7 && target[..7].eq_ignore_ascii_case("http://") {
        &target[7..]
    } else if target.len() >= 8 && target[..8].eq_ignore_ascii_case("https://") {
        &target[8..]
    } else {
        return None;
    };
    let end = after_scheme
        .find(['/', '?', '#'])
        .unwrap_or(after_scheme.len());
    Some(&after_scheme[..end])
}

/// 解析请求行（自由函数：零行级拷贝，输入为 buf 借用切片）
///
/// 产出 `HttpRequestLine`（`Box<str>` 三段物化，§6.1.1）。
fn parse_request_line(line: &[u8]) -> Result<HttpRequestLine, Http1Error> {
    let s = std::str::from_utf8(line)
        .map_err(|_| Http1Error::SyntaxError("request line not UTF-8".into()))?;
    let s = s.trim_end_matches('\r');

    let mut parts = s.splitn(3, ' ');
    let method = parts
        .next()
        .ok_or_else(|| Http1Error::SyntaxError("missing method".into()))?;
    let target = parts
        .next()
        .ok_or_else(|| Http1Error::SyntaxError("missing target".into()))?;
    let version = parts
        .next()
        .ok_or_else(|| Http1Error::SyntaxError("missing version".into()))?;

    if !is_valid_method(method) {
        return Err(Http1Error::UnsupportedMethod(method.to_string()));
    }
    if version != "HTTP/1.0" && version != "HTTP/1.1" {
        return Err(Http1Error::UnsupportedVersion(version.to_string()));
    }
    if target.chars().any(|c| (c as u32) < 0x20) {
        return Err(Http1Error::SyntaxError(
            "target contains control chars".into(),
        ));
    }

    Ok(HttpRequestLine {
        method: method.into(),
        target: target.into(),
        version: version.into(),
    })
}

/// 解析单条头部（自由函数：零行级拷贝，输入为 buf 借用切片）
///
/// 空行返回 `Ok(None)`（头部区结束标记）；否则返回 `(小写名, 值)`。
/// 名称经 `to_ascii_lowercase().into_boxed_str()` 一次分配完成
/// 小写化与物化，值为 `Box<str>`（§6.1.1）。
fn parse_header_line(line: &[u8], config: &Http1Config) -> Result<Option<HeaderEntry>, Http1Error> {
    if line.is_empty() {
        return Ok(None);
    }
    if line.iter().any(|&b| b == b'\r' || b == b'\n') {
        return Err(Http1Error::SyntaxError(
            "header line contains CR/LF".into(),
        ));
    }
    // 拒绝 line folding（RFC 7230 已废弃）
    if line.first() == Some(&b' ') || line.first() == Some(&b'\t') {
        return Err(Http1Error::SyntaxError(
            "header line folding is forbidden".into(),
        ));
    }

    let colon = line
        .iter()
        .position(|&b| b == b':')
        .ok_or_else(|| Http1Error::SyntaxError("missing colon in header".into()))?;

    let name = std::str::from_utf8(&line[..colon])
        .map_err(|_| Http1Error::SyntaxError("header name not UTF-8".into()))?;
    // checked 算术：colon+1 不超 line.len()（colon 来自 position，严格小于 len）
    let value = std::str::from_utf8(&line[colon + 1..])
        .map_err(|_| Http1Error::SyntaxError("header value not UTF-8".into()))?;

    if !is_valid_header_name(name) {
        return Err(Http1Error::SyntaxError(format!(
            "invalid header name: {name}"
        )));
    }
    if name.len() > config.max_header_name_len {
        return Err(Http1Error::HeaderTooLarge);
    }

    // L-7：RFC 7230 §3.2.4 头部值首尾可选空白（OWS = SP/HTAB）两侧均裁剪，
    // 与客户端 parse_head 的 OWS 处理语义一致
    let val_trim = value.trim_matches(|c| c == ' ' || c == '\t');
    if val_trim.len() > config.max_header_value_len {
        return Err(Http1Error::HeaderTooLarge);
    }
    if val_trim.contains('\r') || val_trim.contains('\n') {
        return Err(Http1Error::SyntaxError(
            "header value contains CR/LF".into(),
        ));
    }

    let name = name.to_ascii_lowercase();
    Ok(Some((name.into_boxed_str(), val_trim.into())))
}

impl Http1Parser {
    /// 累积头部大小
    fn current_header_size(&self) -> usize {
        self.headers
            .iter()
            .map(|(k, v)| k.len() + v.len() + 2)
            .sum()
    }

    /// 是否包含 Host 头
    #[inline]
    fn has_host(&self) -> bool {
        self.headers.iter().any(|(k, _)| k.as_ref() == "host")
    }

    /// Host 头值（单 Host 已由走私检测器保证）
    #[inline]
    fn host_value(&self) -> Option<&str> {
        self.headers
            .iter()
            .find(|(k, _)| k.as_ref() == "host")
            .map(|(_, v)| v.as_ref())
    }

    /// RFC 7230 §5.4/§5.5：absolute-form 目标的 authority 必须与 Host 头一致
    ///
    /// 大小写不敏感比较；端口不做归一化（authority 与 Host 字符串一致即可，
    /// 如 `example.com` vs `example.com:80` 视为不一致——宁可拒绝也不放行歧义）。
    /// 非 absolute-form 目标（origin/authority/asterisk-form）直接通过。
    fn check_absolute_form_host_consistency(&mut self) -> Result<(), Http1Error> {
        let target = match self.request_line.as_ref() {
            Some(line) => line.target.as_ref(),
            None => return Ok(()),
        };
        let authority = match absolute_form_authority(target) {
            Some(a) => a,
            None => return Ok(()),
        };
        // Host 存在性已由调用方先行校验（has_host），缺省值仅为兜底
        let host = self.host_value().unwrap_or("");
        if authority.is_empty() || !authority.eq_ignore_ascii_case(host) {
            self.state = ParserState::Error;
            return Err(Http1Error::ProtocolInconsistency(
                "absolute-form authority does not match Host header".into(),
            ));
        }
        Ok(())
    }
}

/// 查找 CRLF 位置
#[inline]
fn find_crlf(buf: &[u8]) -> Option<usize> {
    find_crlf_at(buf, 0)
}

/// 解析 chunk-size 行（RFC 7230 §4.1）
///
/// 格式：`1*HEXDIG [ ";" chunk-ext ]`（CRLF 已被调用方剥离）
///
/// # 参数
/// * `line` - chunk-size 行的字节切片（不含尾部 CRLF）
///
/// # 返回
/// chunk-data 的字节数
///
/// 全 crate 唯一实现：服务端 feed 状态机与客户端
/// [`crate::chunked::ChunkedDecoder`] 共用，禁止第二份 hex/ext 解析副本。
///
/// # 错误
/// - `ChunkedError`：空行、非十六进制字符、数值溢出
pub(crate) fn parse_chunk_size(line: &[u8]) -> Result<usize, Http1Error> {
    let line_str = std::str::from_utf8(line)
        .map_err(|_| Http1Error::ChunkedError("chunk size line not UTF-8".into()))?;
    // 分离 chunk-ext（分号之后的内容），仅校验 hex 前缀
    let size_part = line_str.split(';').next().unwrap_or("");
    let size_part = size_part.trim();
    if size_part.is_empty() {
        return Err(Http1Error::ChunkedError("empty chunk size".into()));
    }
    if !size_part.chars().all(|c| c.is_ascii_hexdigit()) {
        return Err(Http1Error::ChunkedError(format!(
            "invalid chunk size: non-hex digit in '{size_part}'"
        )));
    }
    usize::from_str_radix(size_part, 16)
        .map_err(|_| Http1Error::ChunkedError(format!("chunk size overflow: {size_part}")))
}

/// Transfer-Encoding 分析结果（与 SmugglingDetector 语义统一）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum TransferEncodingKind {
    /// 无 Transfer-Encoding 头
    None,
    /// 含 chunked（可能同时含其他编码，chunked 为最后编码由 detector 校验）
    Chunked,
    /// 存在 TE 但无 chunked → 走私嫌疑（fail-closed）
    Invalid,
}

/// 分析 Transfer-Encoding 头部（可多次出现、逗号分隔多值，大小写不敏感）
///
/// HTTP-002：RFC 7230 已废弃 `identity` 作为 TE 值，不再作为合法编码处理，
/// 因此不含 chunked 的 TE（含 identity）一律归为 `Invalid`（fail-closed）。
/// 含 `identity` 的 TE 会先被走私检测器拒绝（feed/build_request 均先调用
/// detect），此处语义与检测器保持一致。
fn analyze_transfer_encoding(headers: &[HeaderEntry]) -> TransferEncodingKind {
    let mut saw_te = false;
    let mut saw_chunked = false;
    for (k, v) in headers {
        if k.as_ref() != "transfer-encoding" {
            continue;
        }
        saw_te = true;
        for tok in v.split(',') {
            let tok = tok.trim();
            if tok.is_empty() {
                continue;
            }
            if tok.eq_ignore_ascii_case("chunked") {
                saw_chunked = true;
            }
        }
    }
    if !saw_te {
        TransferEncodingKind::None
    } else if saw_chunked {
        TransferEncodingKind::Chunked
    } else {
        TransferEncodingKind::Invalid
    }
}

/// 合法方法
///
/// RFC 7230 §3.1.1：方法区分大小写，仅接受标准大写方法。
/// 委托 [`zenith_api::Method::from_str`]（全库唯一方法解析入口），
/// 与 normalize 层语义严格一致（拒绝 "get" 等小写变体，消除协议差分）。
#[inline]
fn is_valid_method(m: &str) -> bool {
    m.parse::<zenith_api::Method>().is_ok()
}

/// 合法头部名称（RFC 7230 §3.2.6 token，非空）
///
/// 委托 [`zenith_api::normalize::is_valid_header_name`]（全库唯一 tchar 校验实现）。
#[inline]
fn is_valid_header_name(s: &str) -> bool {
    zenith_api::normalize::is_valid_header_name(s)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn make_config() -> Http1Config {
        Http1Config::new()
    }

    #[test]
    fn test_parse_get_request() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.line.method.as_ref(), "GET");
        assert_eq!(req.line.target.as_ref(), "/");
        assert_eq!(req.line.version.as_ref(), "HTTP/1.1");
        assert_eq!(req.get_header("host"), Some("example.com"));
        assert!(req.keep_alive);
    }

    #[test]
    fn test_parse_post_with_content_length() {
        let mut p = Http1Parser::new(make_config());
        // 发送 headers（Content-Length: 13）+ 真实 13 字节 body，保证 parser 到达 HeadersComplete
        let input =
            b"POST /api HTTP/1.1\r\nHost: example.com\r\nContent-Length: 13\r\n\r\nHello, World!";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.content_length, Some(13));
        assert_eq!(req.body, b"Hello, World!");
        assert!(!req.chunked);
    }

    #[test]
    fn test_parse_chunked_request() {
        let mut p = Http1Parser::new(make_config());
        // RFC 7230 §4.1 完整 chunked 请求：
        // headers + "5\r\nHello\r\n6\r\n World\r\n0\r\n\r\n"
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n6\r\n World\r\n0\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(req.chunked);
        assert_eq!(req.content_length, None);
        assert_eq!(req.body, b"Hello World");
    }

    #[test]
    fn test_parse_chunked_empty_body() {
        let mut p = Http1Parser::new(make_config());
        // 仅 last-chunk，body 为空
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n0\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(req.chunked);
        assert!(req.body.is_empty());
    }

    #[test]
    fn test_parse_chunked_with_chunk_ext() {
        let mut p = Http1Parser::new(make_config());
        // chunk-ext（分号后内容）应被忽略，不影响 body
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5;name=value\r\nHello\r\n0\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.body, b"Hello");
    }

    #[test]
    fn test_parse_chunked_with_trailer() {
        let mut p = Http1Parser::new(make_config());
        // last-chunk 后有 trailer header，应被解析并追加到 headers
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n0\r\nX-Checksum: abc123\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.body, b"Hello");
        assert_eq!(req.get_header("x-checksum"), Some("abc123"));
    }

    #[test]
    fn test_parse_chunked_multiple_chunks() {
        let mut p = Http1Parser::new(make_config());
        // 多个 chunk，验证累积拼接正确
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n3\r\nabc\r\n3\r\ndef\r\n3\r\nghi\r\n0\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.body, b"abcdefghi");
    }

    #[test]
    fn test_parse_chunked_incremental_byte_by_byte() {
        // 逐字节喂入，验证状态机在任意切分点都能正确恢复
        let mut p = Http1Parser::new(make_config());
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n0\r\n\r\n";
        let mut req_opt: Option<HttpRequest> = None;
        for i in 0..input.len() {
            let (r, _) = p.feed(&input[i..i + 1]).unwrap();
            if r.is_some() {
                req_opt = r;
            }
        }
        let req = req_opt.expect("should parse complete request after byte-by-byte feed");
        assert!(req.chunked);
        assert_eq!(req.body, b"Hello");
    }

    #[test]
    fn test_parse_chunked_incremental_split_at_chunks() {
        // 在 chunk 边界切分，验证跨 feed 拼接
        let mut p = Http1Parser::new(make_config());
        let part1 = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHel";
        let part2 = b"lo\r\n0\r\n\r\n";

        let (r1, _) = p.feed(part1).unwrap();
        assert!(r1.is_none(), "first part should not complete");
        let (r2, _) = p.feed(part2).unwrap();
        let req = r2.expect("second part should complete");
        assert_eq!(req.body, b"Hello");
    }

    #[test]
    fn test_parse_chunked_invalid_hex_size() {
        let mut p = Http1Parser::new(make_config());
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\nXY\r\nHello\r\n0\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::ChunkedError(_))));
    }

    #[test]
    fn test_parse_chunked_empty_size_line() {
        let mut p = Http1Parser::new(make_config());
        // chunk-size 行为空（仅有 CRLF）
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n\r\nHello\r\n0\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::ChunkedError(_))));
    }

    #[test]
    fn test_parse_chunked_missing_crlf_after_data() {
        let mut p = Http1Parser::new(make_config());
        // chunk-data 后缺少 CRLF（直接是下一个 chunk-size）
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHelloXX\r\n0\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::ChunkedError(_))));
    }

    #[test]
    fn test_parse_chunked_body_too_large() {
        let config = Http1Config::new().with_max_body_size(10);
        let mut p = Http1Parser::new(config);
        // 单个 chunk 超过 max_body_size
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\nB\r\nHello World\r\n0\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::BodyTooLarge)));
    }

    #[test]
    fn test_parse_chunked_large_hex_size() {
        let mut p = Http1Parser::new(make_config());
        // 使用大写十六进制 + 较大的 chunk size
        let input = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\nA\r\n0123456789\r\n0\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.body, b"0123456789");
    }

    #[test]
    fn test_parse_chunked_partial_last_chunk_crlf() {
        // 验证 "0\r\n" 和 "\r\n" 分两次 feed 的场景
        let mut p = Http1Parser::new(make_config());
        let part1 = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n0\r\n";
        let part2 = b"\r\n";

        let (r1, _) = p.feed(part1).unwrap();
        assert!(r1.is_none(), "should not complete before trailer CRLF");
        let (r2, _) = p.feed(part2).unwrap();
        assert!(r2.is_some(), "should complete after trailer CRLF");
    }

    #[test]
    fn test_parse_chunked_split_at_chunk_data_crlf() {
        // 验证 chunk-data 完整但 CRLF 未到达时的暂停/恢复
        let mut p = Http1Parser::new(make_config());
        let part1 = b"POST /upload HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello";
        let part2 = b"\r\n0\r\n\r\n";

        let (r1, _) = p.feed(part1).unwrap();
        assert!(r1.is_none());
        let (r2, _) = p.feed(part2).unwrap();
        let req = r2.unwrap();
        assert_eq!(req.body, b"Hello");
    }

    #[test]
    fn test_bare_lf_rejected_in_request_line() {
        // RFC 7230 §3.5：裸 LF（不紧随 CR）非法行分隔 fail-closed，禁止静默滞留
        let mut p = Http1Parser::new(Http1Config::new());
        let result = p.feed(b"GET /status HTTP/1.1\nHost: example.com\n\n");
        assert!(matches!(result, Err(Http1Error::SyntaxError(_))), "bare LF 必须拒绝: {:?}", result);
    }

    #[test]
    fn test_bare_lf_rejected_in_headers() {
        let mut p = Http1Parser::new(Http1Config::new());
        let result = p.feed(b"GET /status HTTP/1.1\r\nHost: example.com\nX-Other: yes\r\n\r\n");
        assert!(matches!(result, Err(Http1Error::SyntaxError(_))), "header 区块裸 LF 必须拒绝: {:?}", result);
    }

    #[test]
    fn test_crlf_lf_only_edge_accept() {
        // CRLF 行分隔不受影响（控制对照）
        let mut p = Http1Parser::new(Http1Config::new());
        let result = p.feed(b"GET /status HTTP/1.1\r\nHost: example.com\r\n\r\n");
        assert!(result.is_ok(), "合法 CRLF 请求不得被拒绝: {:?}", result);
    }

    // ─── HTTP-004：跨 feed 的 CR 状态延续（增量拆分 CRLF）───────────────

    #[test]
    fn test_crlf_split_across_feeds_accepted() {
        // HTTP-004：CRLF 被拆成两次 feed（上一 feed 以 CR 结尾、下一 feed 以 LF 开头），
        // 必须识别为合法 CRLF 而非裸 LF（状态延续）。
        let mut p = Http1Parser::new(Http1Config::new());
        // 第一段以 CR 结尾（请求行 CRLF 的 CR 部分）
        let r1 = p.feed(b"GET /status HTTP/1.1\r");
        assert!(r1.is_ok(), "以 CR 结尾的分段不得报错: {:?}", r1);
        // 第二段以 LF 开头补全 CRLF，随后完整请求
        let (req, _) = p
            .feed(b"\nHost: example.com\r\n\r\n")
            .expect("补全 CRLF 后应解析成功");
        assert!(req.is_some(), "跨 feed 拆分的 CRLF 必须被接受");
    }

    #[test]
    fn test_bare_lf_split_across_feeds_rejected() {
        // HTTP-004：上一 feed 不以 CR 结尾、下一 feed 以 LF 开头 → 跨 feed 裸 LF 必须拒绝。
        // 单独 feed 一个 LF（缓冲内无其他 CRLF 干扰），确保命中裸 LF 检测而非版本解析。
        let mut p = Http1Parser::new(Http1Config::new());
        let r1 = p.feed(b"GET /status HTTP/1.1");
        assert!(r1.is_ok());
        let r2 = p.feed(b"\n");
        assert!(
            matches!(r2, Err(Http1Error::SyntaxError(_))),
            "跨 feed 裸 LF 必须拒绝，实际 {r2:?}"
        );
    }

    #[test]
    fn test_bare_lf_split_across_feeds_rejected_full() {
        // HTTP-004 对照：跨 feed 裸 LF 出现在请求行内（后续 CRLF 存在）时，
        // 请求行无法解析（含 LF）→ 同样 fail-closed 拒绝（本测试验证非误放行）。
        let mut p = Http1Parser::new(Http1Config::new());
        let r1 = p.feed(b"GET /status HTTP/1.1");
        assert!(r1.is_ok());
        let r2 = p.feed(b"\nHost: x\r\n\r\n");
        assert!(
            r2.is_err(),
            "请求行内跨 feed 裸 LF 必须拒绝，实际 {r2:?}"
        );
    }

    #[test]
    fn test_crlf_split_across_feeds_in_headers_accepted() {
        // HTTP-004：头部区块内 CRLF 被拆成两次 feed（footer 行结束的 CR + LF）
        let mut p = Http1Parser::new(Http1Config::new());
        let r1 = p.feed(b"GET / HTTP/1.1\r\nHost: example.com\r");
        assert!(r1.is_ok());
        let (req, _) = p
            .feed(b"\nX-Test: v\r\n\r\n")
            .expect("头部 CRLF 跨 feed 拆分应解析成功");
        assert!(req.is_some());
    }

    #[test]
    fn test_missing_host() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::MissingHost)));
    }

    #[test]
    fn test_invalid_method() {
        let mut p = Http1Parser::new(make_config());
        let input = b"FOOBAR / HTTP/1.1\r\nHost: x\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::UnsupportedMethod(_))));
    }

    #[test]
    fn test_invalid_version() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/2.0\r\nHost: x\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::UnsupportedVersion(_))));
    }

    #[test]
    fn test_cl_te_smuggling_rejected() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: x\r\nContent-Length: 0\r\nTransfer-Encoding: chunked\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::SmugglingDetected(_))));
    }

    #[test]
    fn test_incremental_parsing() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let (req1, consumed1) = p.feed(&input[..10]).unwrap();
        assert!(req1.is_none());
        assert_eq!(consumed1, 0, "partial input should not be fully consumed");
        let (req2, consumed2) = p.feed(&input[10..]).unwrap();
        assert!(req2.is_some(), "should parse full request on second call");
        assert_eq!(consumed2, input.len() - 10);
    }

    #[test]
    fn test_reset() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n";
        p.feed(input).unwrap();
        p.reset();
        assert_eq!(p.state(), ParserState::WaitingRequest);
    }

    #[test]
    fn test_invalid_header_name_rejected() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: x\r\nBad\x00: value\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err());
    }

    #[test]
    fn test_smuggling_detected_by_parser() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: x\r\nContent-Length: 0\r\nTransfer-Encoding: chunked\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err(), "expected CL.TE smuggling error, got {r:?}");
    }

    #[test]
    fn test_double_content_length_rejected() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: x\r\nContent-Length: 10\r\nContent-Length: 20\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err(), "expected double CL error, got {r:?}");
    }

    #[test]
    fn test_parser_state_variants() {
        let states = [
            ParserState::WaitingRequest,
            ParserState::ReadingRequest,
            ParserState::ReadingHeaders,
            ParserState::ReadingBody,
            ParserState::ReadingChunkSize,
            ParserState::ReadingChunkData,
            ParserState::ReadingChunkTrailer,
            ParserState::HeadersComplete,
            ParserState::Error,
        ];
        for (i, s) in states.iter().enumerate() {
            assert_eq!(*s, states[i]);
        }
        assert_ne!(ParserState::WaitingRequest, ParserState::Error);
    }

    #[test]
    fn test_parse_http10_request() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.0\r\nHost: example.com\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.line.version.as_ref(), "HTTP/1.0");
    }

    #[test]
    fn test_header_name_lowercase_normalization() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\nContent-Type: text/plain\r\nX-Custom-Header: value\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.get_header("host"), Some("example.com"));
        assert_eq!(req.get_header("content-type"), Some("text/plain"));
        assert_eq!(req.get_header("x-custom-header"), Some("value"));
    }

    #[test]
    fn test_header_value_leading_whitespace_trimmed() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost:   example.com\r\nX-Test:\tvalue\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.get_header("host"), Some("example.com"));
        assert_eq!(req.get_header("x-test"), Some("value"));
    }

    #[test]
    fn test_missing_method_in_request_line() {
        let mut p = Http1Parser::new(make_config());
        let input = b" / HTTP/1.1\r\nHost: x\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err());
    }

    #[test]
    fn test_missing_version_in_request_line() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET /\r\nHost: x\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err());
    }

    #[test]
    fn test_only_method_in_request_line() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET\r\nHost: x\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err());
    }

    #[test]
    fn test_header_line_folding_rejected() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\n continued\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err());
    }

    #[test]
    fn test_header_line_folding_tab_rejected() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\n\tcontinued\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err());
    }

    #[test]
    fn test_header_missing_colon() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost example.com\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err());
    }

    #[test]
    fn test_empty_input() {
        let mut p = Http1Parser::new(make_config());
        let (req, consumed) = p.feed(b"").unwrap();
        assert!(req.is_none());
        assert_eq!(consumed, 0);
    }

    #[test]
    fn test_multiple_headers_same_name() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\nX-Test: first\r\nX-Test: second\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        let test_headers: Vec<_> = req.headers.iter().filter(|(k, _)| k.as_ref() == "x-test").collect();
        assert_eq!(test_headers.len(), 2);
    }

    #[test]
    fn test_request_line_with_query_string() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET /path?query=value&foo=bar HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.line.target.as_ref(), "/path?query=value&foo=bar");
    }

    #[test]
    fn test_all_valid_methods() {
        let methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
        for method in methods.iter() {
            let mut p = Http1Parser::new(make_config());
            let input = format!("{} / HTTP/1.1\r\nHost: example.com\r\n\r\n", method);
            let (req, _) = p.feed(input.as_bytes()).unwrap();
            let req = req.unwrap();
            assert_eq!(req.line.method.as_ref(), *method);
        }
    }

    #[test]
    fn test_lowercase_method_rejected() {
        // RFC 7230 §3.1.1：方法区分大小写，"get" 必须拒绝（与 normalize 层一致）
        let mut p = Http1Parser::new(make_config());
        let input = b"get / HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let r = p.feed(input);
        assert!(
            matches!(r, Err(Http1Error::UnsupportedMethod(_))),
            "小写方法必须拒绝，实际 {r:?}"
        );
        // 混合大小写同样拒绝
        let mut p = Http1Parser::new(make_config());
        let input = b"Get / HTTP/1.1\r\nHost: example.com\r\n\r\n";
        assert!(matches!(p.feed(input), Err(Http1Error::UnsupportedMethod(_))));
    }

    #[test]
    fn test_http10_default_connection_close() {
        // RFC 1945：HTTP/1.0 默认关闭连接
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.0\r\nHost: example.com\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(!req.keep_alive, "HTTP/1.0 无 Connection 头应默认关闭");
    }

    #[test]
    fn test_http10_explicit_keep_alive() {
        // HTTP/1.0 仅显式 Connection: keep-alive 才保持
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.0\r\nHost: example.com\r\nConnection: keep-alive\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(req.keep_alive);
    }

    #[test]
    fn test_http11_default_keep_alive() {
        // HTTP/1.1 默认保持；显式 close 才关闭
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        assert!(req.unwrap().keep_alive);
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        assert!(!req.unwrap().keep_alive);
    }

    #[test]
    fn test_http10_transfer_encoding_rejected() {
        // HTTP/1.0 请求出现 Transfer-Encoding 一律拒绝（fail-closed）
        let mut p = Http1Parser::new(make_config());
        let input = b"POST / HTTP/1.0\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n0\r\n\r\n";
        let r = p.feed(input);
        assert!(
            matches!(r, Err(Http1Error::SmugglingDetected(_))),
            "HTTP/1.0 + TE 必须拒绝，实际 {r:?}"
        );
    }

    #[test]
    fn test_transfer_encoding_without_chunked_rejected() {
        // TE 存在但无 chunked 且非 identity → 走私拒绝（fail-closed）
        let mut p = Http1Parser::new(make_config());
        let input = b"POST / HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: gzip\r\n\r\n";
        let r = p.feed(input);
        assert!(
            matches!(r, Err(Http1Error::SmugglingDetected(_))),
            "TE 无 chunked 必须拒绝，实际 {r:?}"
        );
    }

    #[test]
    fn test_transfer_encoding_identity_rejected() {
        // HTTP-002：TE: identity 已被 RFC 7230 废弃，必须拒绝（fail-closed）
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: identity\r\n\r\n";
        let r = p.feed(input);
        assert!(
            matches!(r, Err(Http1Error::SmugglingDetected(_))),
            "TE: identity 必须走私拒绝，实际 {r:?}"
        );
    }

    #[test]
    fn test_transfer_encoding_gzip_chunked_parsed() {
        // 含 chunked 才按 chunked 解析（gzip, chunked 中 chunked 在最后，合法）
        let mut p = Http1Parser::new(make_config());
        let input = b"POST / HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: gzip, chunked\r\n\r\n5\r\nHello\r\n0\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(req.chunked);
        assert_eq!(req.body, b"Hello");
    }

    #[test]
    fn test_header_name_too_long() {
        let config = Http1Config::new().with_max_header_size(1024);
        let mut p = Http1Parser::new(config);
        let long_name = "X-".to_string() + &"A".repeat(100);
        let input = format!("GET / HTTP/1.1\r\nHost: x\r\n{}: value\r\n\r\n", long_name);
        let r = p.feed(input.as_bytes());
        let _ = r;
    }

    #[test]
    fn test_control_char_in_target_rejected() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET /path\x01 HTTP/1.1\r\nHost: x\r\n\r\n";
        let r = p.feed(input);
        assert!(r.is_err());
    }

    #[test]
    fn test_parser_clone() {
        let p = Http1Parser::new(make_config());
        let p2 = p.clone();
        assert_eq!(p.state(), p2.state());
    }

    #[test]
    fn test_parser_debug_format() {
        let p = Http1Parser::new(make_config());
        let s = format!("{:?}", p);
        assert!(!s.is_empty());
    }

    #[test]
    fn test_connection_close_header() {
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(!req.keep_alive);
    }

    // ───────── S-2：Content-Length 解析 fail-closed ─────────

    #[test]
    fn test_content_length_overflow_u64_rejected() {
        // S-2：超 u64 的全数字 CL（23 位 9）必须拒绝，禁止当"无 body"放行
        let mut p = Http1Parser::new(make_config());
        let input = b"POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 99999999999999999999999\r\n\r\n";
        let r = p.feed(input);
        assert!(
            matches!(r, Err(Http1Error::SmugglingDetected(_))),
            "超 u64 的 CL 必须 fail-closed 拒绝，实际 {r:?}"
        );
    }

    #[test]
    fn test_content_length_valid_still_accepted() {
        // 对照组：合法 CL 不受影响
        let mut p = Http1Parser::new(make_config());
        let input = b"POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 5\r\n\r\nhello";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.content_length, Some(5));
        assert_eq!(req.body, b"hello");
    }

    // ───────── M-3：完整请求行长度上限 enforcement ─────────

    #[test]
    fn test_complete_request_line_too_long_rejected() {
        // M-3：已找到 CRLF 的完整请求行超长同样拒绝
        let config = Http1Config::new();
        let line_limit = config.max_request_line_size;
        let mut p = Http1Parser::new(config);
        let long_path = "a".repeat(line_limit + 1);
        let input = format!("GET /{long_path} HTTP/1.1\r\nHost: x\r\n\r\n");
        let r = p.feed(input.as_bytes());
        assert!(
            matches!(r, Err(Http1Error::RequestLineTooLong)),
            "完整超长请求行必须拒绝，实际 {r:?}"
        );
        assert_eq!(p.state(), ParserState::Error);
    }

    #[test]
    fn test_incomplete_request_line_too_long_rejected() {
        // 对照：未完成请求行（无 CRLF）超长同样拒绝
        let config = Http1Config::new();
        let line_limit = config.max_request_line_size;
        let mut p = Http1Parser::new(config);
        let junk = "a".repeat(line_limit + 1);
        let r = p.feed(junk.as_bytes());
        assert!(matches!(r, Err(Http1Error::RequestLineTooLong)), "实际 {r:?}");
    }

    #[test]
    fn test_request_line_at_limit_accepted() {
        // 边界：请求行长度恰好等于 max_request_line_size 放行
        let config = Http1Config::new();
        let line_limit = config.max_request_line_size;
        // "GET /" + pad + " HTTP/1.1" 恰好 line_limit 字节
        let pad = line_limit - "GET /".len() - " HTTP/1.1".len();
        let mut p = Http1Parser::new(config);
        let input = format!("GET /{} HTTP/1.1\r\nHost: x\r\n\r\n", "a".repeat(pad));
        let (req, _) = p.feed(input.as_bytes()).unwrap();
        assert!(req.is_some(), "恰在上限内的请求行必须放行");
    }

    // ───────── S-1：absolute-form 与 Host 一致性 ─────────

    #[test]
    fn test_absolute_form_matching_host_accepted() {
        // S-1 正向：absolute-form authority 与 Host 一致放行（大小写不敏感）
        let mut p = Http1Parser::new(make_config());
        let input = b"GET http://example.com/path?q=1 HTTP/1.1\r\nHost: EXAMPLE.com\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.line.target.as_ref(), "http://example.com/path?q=1");
    }

    #[test]
    fn test_absolute_form_with_port_matching_host_accepted() {
        // S-1 正向：authority 与 Host 均含端口且一致放行
        let mut p = Http1Parser::new(make_config());
        let input = b"GET https://example.com:8443/x HTTP/1.1\r\nHost: example.com:8443\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        assert!(req.is_some());
    }

    #[test]
    fn test_absolute_form_host_mismatch_rejected() {
        // S-1 反向：absolute-form authority 与 Host 不一致 → 协议不一致拒绝
        let mut p = Http1Parser::new(make_config());
        let input = b"GET http://evil.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let r = p.feed(input);
        assert!(
            matches!(r, Err(Http1Error::ProtocolInconsistency(_))),
            "authority 与 Host 不一致必须拒绝，实际 {r:?}"
        );
    }

    #[test]
    fn test_absolute_form_port_mismatch_rejected() {
        // S-1 反向：authority 含端口、Host 不含（不做归一化放行歧义）
        let mut p = Http1Parser::new(make_config());
        let input = b"GET http://example.com:8080/ HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let r = p.feed(input);
        assert!(matches!(r, Err(Http1Error::ProtocolInconsistency(_))), "实际 {r:?}");
    }

    #[test]
    fn test_origin_form_unaffected_by_host_check() {
        // 对照：origin-form 目标不受 absolute-form 校验影响
        let mut p = Http1Parser::new(make_config());
        let input = b"GET /path HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        assert!(req.is_some());
    }

    // ───────── M-8：Connection 头 token 列表解析 ─────────

    #[test]
    fn test_connection_close_among_tokens() {
        // "close, upgrade" 必须识别为 close 语义（整串精确比较会漏判）
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close, upgrade\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(!req.keep_alive, "token 列表中的 close 必须生效");
    }

    #[test]
    fn test_connection_keep_alive_among_tokens_http10() {
        // HTTP/1.0 "keep-alive, timeout=5" 必须识别为 keep-alive 语义
        let mut p = Http1Parser::new(make_config());
        let input =
            b"GET / HTTP/1.0\r\nHost: example.com\r\nConnection: keep-alive, timeout=5\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(req.keep_alive, "token 列表中的 keep-alive 必须生效");
    }

    #[test]
    fn test_connection_prefixed_token_not_close() {
        // "x-close" 不得误判为 close（逐 token 精确比较，非子串）
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: x-close\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert!(req.keep_alive);
    }

    // ───────── L-7：头部值尾部 OWS 裁剪 ─────────

    #[test]
    fn test_header_value_trailing_ows_trimmed() {
        // L-7：尾部 SP/HTAB 同样裁剪（与客户端 OWS 语义一致）
        let mut p = Http1Parser::new(make_config());
        let input = b"GET / HTTP/1.1\r\nHost: example.com\r\nX-Test: value  \t\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        let req = req.unwrap();
        assert_eq!(req.get_header("x-test"), Some("value"));
    }

    // ───────── M-9：body 阶段 Slowloris 空闲超时 ─────────

    #[test]
    fn test_idle_timeout_during_body_read() {
        // M-9：ReadingBody 阶段超过 idle_timeout 必须返回 IdleTimeout
        let config = Http1Config::new().with_idle_timeout_ms(30_000);
        let mut p = Http1Parser::new(config);
        p.note_activity(1_000);
        // 仅头部（CL=10 但 body 未到达）→ 进入 ReadingBody
        let input = b"POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 10\r\n\r\n";
        let (req, _) = p.feed(input).unwrap();
        assert!(req.is_none());
        assert_eq!(p.state(), ParserState::ReadingBody);
        // 超时未再收到 body 字节 → IdleTimeout
        let r = p.check_idle_timeout(1_000 + 30_001);
        assert!(matches!(r, Err(Http1Error::IdleTimeout)), "实际 {r:?}");
        assert_eq!(p.state(), ParserState::Error);
    }

    #[test]
    fn test_idle_timeout_refreshed_by_activity() {
        // M-9：活跃刷新后重新计时，未超时放行；持续静默才超时
        let config = Http1Config::new().with_idle_timeout_ms(30_000);
        let mut p = Http1Parser::new(config);
        p.note_activity(0);
        let part1 = b"POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 10\r\n\r\nhe";
        let (r1, _) = p.feed(part1).unwrap();
        assert!(r1.is_none());
        assert_eq!(p.state(), ParserState::ReadingBody);
        // 20s 后又有数据到达（活跃刷新）
        p.note_activity(20_000);
        assert!(p.check_idle_timeout(45_000).is_ok(), "活跃后 25s 不得超时");
        // 但自 20s 后再静默超过 30s → 超时
        let r = p.check_idle_timeout(20_000 + 30_001);
        assert!(matches!(r, Err(Http1Error::IdleTimeout)));
    }

    #[test]
    fn test_idle_timeout_chunked_phase() {
        // M-9：chunked 阶段同样适用 idle 超时
        let config = Http1Config::new().with_idle_timeout_ms(30_000);
        let mut p = Http1Parser::new(config);
        p.note_activity(500);
        let input = b"POST / HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHel";
        let (r1, _) = p.feed(input).unwrap();
        assert!(r1.is_none());
        assert_eq!(p.state(), ParserState::ReadingChunkData);
        let r = p.check_idle_timeout(500 + 30_001);
        assert!(matches!(r, Err(Http1Error::IdleTimeout)));
    }

    // ───────── L-3：pipelining consumed 记账 ─────────

    #[test]
    fn test_pipelining_two_requests_single_feed() {
        // L-3：一次 feed 两个完整请求 → 第一个请求 + consumed 恰好为其字节数
        let mut p = Http1Parser::new(make_config());
        let req1 = b"GET /a HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let req2 = b"GET /b HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let mut input = Vec::with_capacity(req1.len() + req2.len());
        input.extend_from_slice(req1);
        input.extend_from_slice(req2);

        let (r1, c1) = p.feed(&input).unwrap();
        let r1 = r1.expect("first request must complete");
        assert_eq!(r1.line.target.as_ref(), "/a");
        assert_eq!(c1, req1.len(), "consumed 必须恰好等于第一个请求字节数");

        // 第二个请求已在 parser 内部缓冲，空 feed 取出
        let (r2, c2) = p.feed(&[]).unwrap();
        let r2 = r2.expect("second request must be buffered internally");
        assert_eq!(r2.line.target.as_ref(), "/b");
        assert_eq!(c2, 0, "空输入不消耗字节");
    }

    #[test]
    fn test_pipelining_body_then_next_request() {
        // L-3：带 body 的请求后接 pipelined 请求，consumed 含 body 字节
        let mut p = Http1Parser::new(make_config());
        let req1 = b"POST /x HTTP/1.1\r\nHost: example.com\r\nContent-Length: 5\r\n\r\nhello";
        let req2 = b"GET /y HTTP/1.1\r\nHost: example.com\r\n\r\n";
        let mut input = Vec::with_capacity(req1.len() + req2.len());
        input.extend_from_slice(req1);
        input.extend_from_slice(req2);

        let (r1, c1) = p.feed(&input).unwrap();
        let r1 = r1.expect("first request must complete");
        assert_eq!(r1.body, b"hello");
        assert_eq!(c1, req1.len());

        let (r2, _) = p.feed(&[]).unwrap();
        let r2 = r2.expect("second request must follow");
        assert_eq!(r2.line.target.as_ref(), "/y");
    }
}