8. レスポンスの分解 — status-line、field-line、そして本文の長さをどう決めるか

// src/http.rs の分解の部分(HttpResponse::parse と decode_chunked)
pub fn parse(raw: &str) -> Result<HttpResponse, HttpError> {
    if raw.is_empty() {
        return Err(HttpError::EmptyResponse);
    }

    // ヘッダー部と本文の境目 = 最初の空行(CRLF CRLF、または LF LF)
    let (head, body) = split_head_body(raw);

    let mut lines = head.lines(); // lines() は "\r\n" も "\n" も行末として扱う
    let status_line = lines.next().unwrap_or("");

    // status-line = HTTP-version SP status-code SP [ reason-phrase ]
    let mut parts = status_line.splitn(3, ' ');
    let version = parts.next().unwrap_or("");
    let code = parts.next().unwrap_or("");
    let reason_phrase = parts.next().unwrap_or("").trim_end().to_string();
    if !version.starts_with("HTTP/") || code.len() != 3 {
        return Err(HttpError::InvalidStatusLine(status_line.to_string()));
    }
    let status_code = code
        .parse::<u16>()
        .map_err(|_| HttpError::InvalidStatusLine(status_line.to_string()))?;

    // field-line = field-name ":" OWS field-value OWS
    let mut headers = Vec::new();
    for line in lines {
        if line.trim().is_empty() {
            continue;
        }
        let (name, value) = line
            .split_once(':')
            .ok_or_else(|| HttpError::InvalidHeader(line.to_string()))?;
        headers.push(Header {
            name: name.trim().to_string(),
            value: value.trim().to_string(),
        });
    }

    let mut response = HttpResponse {
        version: version.to_string(),
        status_code,
        reason_phrase,
        headers,
        body: String::new(),
    };

    // 本文の長さの決め方(RFC 9112 §6.3 の順番): Transfer-Encoding が Content-Length より優先
    response.body = match response.header("Transfer-Encoding") {
        Some(te) if te.eq_ignore_ascii_case("chunked") => decode_chunked(body)?,
        Some(te) => return Err(HttpError::UnsupportedBody(format!("Transfer-Encoding: {te}"))),
        None => match response.header("Content-Length").and_then(|v| v.trim().parse::<usize>().ok()) {
            // Content-Length があればそのバイト数まで(文字の途中で切れるなら全部)
            Some(len) => body.get(..len).unwrap_or(body).to_string(),
            // どちらも無ければ「接続が閉じるまで」= 受け取った全部
            None => body.to_string(),
        },
    };
    Ok(response)
}

fn decode_chunked(body: &str) -> Result<String, HttpError> {
    let mut out = String::new();
    let mut rest = body;
    loop {
        let (size_line, after) = rest
            .split_once('\n')
            .ok_or_else(|| HttpError::UnsupportedBody("chunk-size の行がありません".into()))?;
        let size_hex = size_line.split(';').next().unwrap_or("").trim();
        let size = usize::from_str_radix(size_hex, 16)
            .map_err(|_| HttpError::UnsupportedBody(format!("chunk-size が 16 進でない: {size_hex:?}")))?;
        if size == 0 {
            break; // last-chunk。trailer は読まない
        }
        let data = after
            .get(..size)
            .ok_or_else(|| HttpError::UnsupportedBody("chunk-data が足りません".into()))?;
        out.push_str(data);
        // chunk-data の後ろの CRLF(または LF)を飛ばす
        rest = &after[size..];
        rest = rest.strip_prefix("\r\n").or_else(|| rest.strip_prefix('\n')).unwrap_or(rest);
    }
    Ok(out)
}