zlsrs 0.1.6

//! HTTP 客户端实现
//!
//! 这个模块提供了一个简单但功能完整的 HTTP 客户端实现。支持：
//! - 所有标准 HTTP 方法（GET、POST、PUT、DELETE 等）
//! - 自动处理重定向
//! - 超时控制
//! - SSL/TLS 支持
//! - 自定义请求头和请求体
//!
//! # 示例
//!
//! ```rust
//! use zlsrs::zhttp::Client;
//! use std::time::Duration;
//!
//! async fn example(){
//!     // 创建客户端
//!     let client = Client::new();
//!     
//!     // 发送 GET 请求
//!     let response = client.get("https://api.example.com")
//!         .timeout(Duration::from_secs(30))
//!         .send().unwrap();
//!     
//!     println!("Status: {}", response.status);
//!     println!("Body: {}", response.text()?);
//!     
//!     // 发送 POST 请求
//!     let response = client.post("https://api.example.com/data")
//!         .header("Content-Type", "application/json")
//!         .body(r#"{"key": "value"}"#.as_bytes())
//!         .send()
//!         .unwrap();
//!     
//!     Ok(())
//! }
//! ```

use std::collections::HashMap;
use std::io::{Read, Write};
use std::net::TcpStream;

use crate::zhttp::builder::RequestBuilder;
use crate::zhttp::types::{ClientConfig, Error, Method, Response};

/// HTTP 客户端
///
/// 提供了一个简单但功能完整的 HTTP 客户端实现，支持常见的 HTTP 操作。
/// 可以通过 `default()` 创建使用默认配置的客户端，或通过 `new(config)` 创建自定义配置的客户端。
///
/// # 示例
///
/// ```rust
/// use zlsrs::zhttp;
/// use std::time::Duration;
///
/// // 使用默认配置创建客户端
/// let client = zhttp::default();
///
/// // 使用自定义配置创建客户端
/// let config = zhttp::ClientConfig {
///     timeout: Duration::from_secs(60),
///     max_retries: 3,
///     ..Default::default()
/// };
/// let client = zhttp::new(config);
/// ```
#[derive(Debug, Clone)]
pub struct Client {
    pub(crate) config: ClientConfig,
}

impl Client {
    /// 创建一个使用默认配置的 HTTP 客户端
    ///
    /// 默认配置包括：
    /// - 30 秒超时
    /// - 3 次重试
    /// - 允许重定向（最多 10 次）
    /// - 启用 SSL 证书验证
    ///
    /// # 示例
    ///
    /// ```rust
    /// use zlsrs::zhttp::Client;
    ///
    /// let client = Client::default();
    /// ```
    pub(crate) fn default() -> Self {
        Self {
            config: ClientConfig::default(),
        }
    }

    /// 创建一个使用自定义配置的 HTTP 客户端
    ///
    /// # 参数
    ///
    /// * `config` - 客户端配置，包含超时、重试等设置
    ///
    /// # 示例
    ///
    /// ```rust
    /// use zlsrs::zhttp::{Client, ClientConfig};
    /// use std::time::Duration;
    ///
    /// let config = ClientConfig {
    ///     timeout: Duration::from_secs(60),
    ///     max_retries: 5,
    ///     ..Default::default()
    /// };
    /// let client = Client::new(config);
    /// ```
    pub(crate) fn new(config: ClientConfig) -> Self {
        Self { config }
    }

    /// 创建一个 GET 请求
    ///
    /// # 参数
    ///
    /// * `url` - 请求的 URL
    ///
    /// # 返回值
    ///
    /// 返回一个 `RequestBuilder` 实例，可以进一步配置请求参数
    ///
    /// # 示例
    ///
    /// ```rust
    /// # use zlsrs::zhttp::Client;
    /// let client = Client::new();
    /// let builder = client.get("https://api.example.com")
    ///     .header("Authorization", "Bearer token");
    /// ```
    pub fn get(&self, url: impl Into<String>) -> RequestBuilder {
        self.create_request(Method::GET, url)
    }

    /// 创建一个 POST 请求
    ///
    /// # 参数
    ///
    /// * `url` - 请求的 URL
    ///
    /// # 返回值
    ///
    /// 返回一个 `RequestBuilder` 实例，可以进一步配置请求参数
    ///
    /// # 示例
    ///
    /// ```rust
    /// # use zlsrs::zhttp::Client;
    /// let client = Client::new();
    /// let builder = client.post("https://api.example.com")
    ///     .header("Content-Type", "application/json")
    ///     .body(r#"{"key": "value"}"#.as_bytes());
    /// ```
    pub fn post(&self, url: impl Into<String>) -> RequestBuilder {
        self.create_request(Method::POST, url)
    }

    /// 创建一个 PUT 请求
    ///
    /// # 参数
    ///
    /// * `url` - 请求的 URL
    ///
    /// # 返回值
    ///
    /// 返回一个 `RequestBuilder` 实例，可以进一步配置请求参数
    pub fn put(&self, url: impl Into<String>) -> RequestBuilder {
        self.create_request(Method::PUT, url)
    }

    /// 创建一个 DELETE 请求
    ///
    /// # 参数
    ///
    /// * `url` - 请求的 URL
    ///
    /// # 返回值
    ///
    /// 返回一个 `RequestBuilder` 实例，可以进一步配置请求参数
    pub fn delete(&self, url: impl Into<String>) -> RequestBuilder {
        self.create_request(Method::DELETE, url)
    }

    /// 创建一个 HEAD 请求
    ///
    /// # 参数
    ///
    /// * `url` - 请求的 URL
    ///
    /// # 返回值
    ///
    /// 返回一个 `RequestBuilder` 实例，可以进一步配置请求参数
    pub fn head(&self, url: impl Into<String>) -> RequestBuilder {
        self.create_request(Method::HEAD, url)
    }

    /// 创建一个 OPTIONS 请求
    ///
    /// # 参数
    ///
    /// * `url` - 请求的 URL
    ///
    /// # 返回值
    ///
    /// 返回一个 `RequestBuilder` 实例，可以进一步配置请求参数
    pub fn options(&self, url: impl Into<String>) -> RequestBuilder {
        self.create_request(Method::OPTIONS, url)
    }

    /// 创建一个 PATCH 请求
    ///
    /// # 参数
    ///
    /// * `url` - 请求的 URL
    ///
    /// # 返回值
    ///
    /// 返回一个 `RequestBuilder` 实例，可以进一步配置请求参数
    pub fn patch(&self, url: impl Into<String>) -> RequestBuilder {
        self.create_request(Method::PATCH, url)
    }

    /// 创建一个新的请求构建器
    ///
    /// 这是一个内部方法，用于创建各种 HTTP 方法的请求构建器。
    ///
    /// # 参数
    ///
    /// * `method` - HTTP 请求方法
    /// * `url` - 请求的 URL
    fn create_request(&self, method: Method, url: impl Into<String>) -> RequestBuilder {
        RequestBuilder {
            method,
            url: url.into(),
            headers: Default::default(),
            body: None,
            body_format: None,
            client: self.clone(),
            timeout: None,
            retries: None,
            follow_redirects: None,
            verify_ssl: None,
        }
    }

    /// 发送 HTTP 请求
    ///
    /// 这是一个内部方法，处理请求的发送和重定向逻辑。
    ///
    /// # 参数
    ///
    /// * `builder` - 请求构建器实例
    ///
    /// # 返回值
    ///
    /// 返回请求的响应结果
    pub(crate) fn send_request(
        &self,
        builder: RequestBuilder,
    ) -> std::result::Result<Response, Error> {
        let mut redirects = 0;
        let mut current_url = url::Url::parse(&builder.url).map_err(Error::UrlParse)?;
        let follow_redirects = builder
            .follow_redirects
            .unwrap_or(self.config.allow_redirects);
        let max_redirects = self.config.max_redirects;

        loop {
            let response = self.try_request(&builder, current_url.as_str())?;

            // 处理重定向
            if follow_redirects && (300..400).contains(&response.status) {
                if let Some(location) = response.header("Location") {
                    redirects += 1;
                    if redirects > max_redirects {
                        return Err(Error::TooManyRedirects);
                    }
                    // 处理相对路径的重定向
                    current_url = match url::Url::parse(location) {
                        Ok(absolute_url) => absolute_url,
                        Err(url::ParseError::RelativeUrlWithoutBase) => {
                            current_url.join(location).map_err(Error::UrlParse)?
                        }
                        Err(e) => return Err(Error::UrlParse(e)),
                    };
                    continue;
                }
            }

            return Ok(response);
        }
    }

    /// 尝试发送一次请求
    ///
    /// 这是一个内部方法，处理单次请求的发送逻辑。
    ///
    /// # 参数
    ///
    /// * `builder` - 请求构建器实例
    /// * `url` - 请求的 URL
    ///
    /// # 返回值
    ///
    /// 返回请求的响应结果
    fn try_request(
        &self,
        builder: &RequestBuilder,
        url: &str,
    ) -> std::result::Result<Response, Error> {
        let retries = builder.retries.unwrap_or(self.config.max_retries);
        let mut last_error = None;

        for attempt in 0..=retries {
            if attempt > 0 {
                if self.config.debug {
                    eprintln!(">>> Retry attempt {} of {}", attempt, retries);
                }
                std::thread::sleep(self.config.retry_interval);
            }

            match self.execute_request(builder, url) {
                Ok(response) => {
                    // 对于某些状态码，我们可能需要重试
                    if response.status == 429 || response.status >= 500 {
                        if attempt < retries {
                            if self.config.debug {
                                eprintln!(">>> Got status {}, will retry", response.status);
                            }
                            if let Some(retry_after) = response.header("Retry-After") {
                                if let Ok(secs) = retry_after.parse::<u64>() {
                                    std::thread::sleep(std::time::Duration::from_secs(secs));
                                }
                            }
                            continue;
                        }
                    }
                    return Ok(response);
                }
                Err(e) => {
                    last_error = Some(e);
                    if attempt < retries {
                        continue;
                    }
                }
            }
        }

        Err(last_error.unwrap_or_else(|| Error::Custom("Unknown error".into())))
    }

    fn execute_request(
        &self,
        builder: &RequestBuilder,
        url: &str,
    ) -> std::result::Result<Response, Error> {
        // 解析 URL
        let url = url::Url::parse(url).map_err(Error::UrlParse)?;
        let host = url
            .host_str()
            .ok_or_else(|| Error::Custom("Invalid host".into()))?;
        let port = url
            .port()
            .unwrap_or(if url.scheme() == "https" { 443 } else { 80 });

        if self.config.debug {
            eprintln!(">>> Request URL: {}", url);
            eprintln!(">>> Method: {}", builder.method.as_str());
        }

        // 构建请求路径
        let path = self.build_request_path(&url);

        // 建立 TCP 连接
        let addr = format!("{}:{}", host, port);
        if self.config.debug {
            eprintln!(">>> Connecting to: {}", addr);
        }

        let mut stream = self.create_connection(&addr, builder)?;

        // 构建并发送请求
        let request = self.build_request(builder, &path, host)?;
        self.send_request_data(&mut stream, &request, builder)?;

        // 读取响应
        let response = self.read_response(&mut stream)?;
        self.parse_response(&response)
    }

    fn build_request_path(&self, url: &url::Url) -> String {
        let mut path = if url.path().is_empty() {
            String::from("/")
        } else {
            String::from(url.path())
        };
        if let Some(query) = url.query() {
            path = format!("{}?{}", path, query);
        }
        path
    }

    fn create_connection(
        &self,
        addr: &str,
        builder: &RequestBuilder,
    ) -> std::result::Result<TcpStream, Error> {
        let stream = TcpStream::connect(addr).map_err(Error::Network)?;
        let timeout = builder.timeout.unwrap_or(self.config.timeout);
        stream
            .set_read_timeout(Some(timeout))
            .map_err(Error::Network)?;
        stream
            .set_write_timeout(Some(timeout))
            .map_err(Error::Network)?;
        Ok(stream)
    }

    fn build_request(
        &self,
        builder: &RequestBuilder,
        path: &str,
        host: &str,
    ) -> std::result::Result<String, Error> {
        let mut request = format!(
            "{} {} HTTP/1.1\r\nHost: {}\r\nUser-Agent: {}\r\n",
            builder.method.as_str(),
            path,
            host,
            self.config.user_agent
        );

        // 添加请求头
        for (key, value) in &builder.headers {
            request.push_str(&format!("{}: {}\r\n", key, value));
        }

        // 处理请求体
        if let Some(body) = &builder.body {
            if !builder.headers.contains_key("Content-Length") {
                request.push_str(&format!("Content-Length: {}\r\n", body.len()));
            }
            if !builder.headers.contains_key("Content-Type") {
                let content_type = builder
                    .body_format
                    .as_ref()
                    .map(|f| f.content_type())
                    .unwrap_or_else(|| "application/x-www-form-urlencoded".into());
                request.push_str(&format!("Content-Type: {}\r\n", content_type));
            }
        }

        // 添加默认请求头
        if !builder.headers.contains_key("Accept") {
            request.push_str("Accept: */*\r\n");
        }
        request.push_str("Connection: close\r\n\r\n");

        Ok(request)
    }

    fn send_request_data(
        &self,
        stream: &mut TcpStream,
        request: &str,
        builder: &RequestBuilder,
    ) -> std::result::Result<(), Error> {
        if self.config.debug {
            eprintln!(">>> Request Headers:");
            for line in request.lines() {
                eprintln!(">>> {}", line);
            }
        }

        // 发送请求头
        stream
            .write_all(request.as_bytes())
            .map_err(Error::Network)?;

        // 发送请求体
        if let Some(body) = &builder.body {
            if self.config.debug {
                eprintln!(">>> Request Body: {} bytes", body.len());
                if let Ok(body_str) = String::from_utf8(body.clone()) {
                    eprintln!(">>> {}", body_str);
                }
            }
            stream.write_all(body).map_err(Error::Network)?;
        }

        Ok(())
    }

    fn read_response(&self, stream: &mut TcpStream) -> std::result::Result<Vec<u8>, Error> {
        if self.config.debug {
            eprintln!(">>> Reading response...");
        }

        let mut response = Vec::new();
        let mut buffer = [0; 4096];

        loop {
            match stream.read(&mut buffer) {
                Ok(0) => break,
                Ok(n) => response.extend_from_slice(&buffer[..n]),
                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                    return Err(Error::Timeout);
                }
                Err(e) => return Err(Error::Network(e)),
            }
        }

        if response.is_empty() {
            return Err(Error::ResponseParse("Empty response from server".into()));
        }

        if self.config.debug {
            eprintln!(">>> Response received: {} bytes", response.len());
        }

        Ok(response)
    }

    /// 解析 HTTP 响应
    ///
    /// 这是一个内部方法，用于解析 HTTP 响应数据。
    ///
    /// # 参数
    ///
    /// * `response` - 原始响应数据
    ///
    /// # 返回值
    ///
    /// 返回解析后的 `Response` 对象
    fn parse_response(&self, response: &[u8]) -> std::result::Result<Response, Error> {
        let response_str = String::from_utf8_lossy(response);
        let mut headers = HashMap::new();

        // 分割响应头和响应体
        let separator_pos = response_str.find("\r\n\r\n").ok_or_else(|| {
            Error::ResponseParse("Invalid response format: missing header separator".into())
        })?;

        let headers_part = &response_str[..separator_pos];
        let mut lines = headers_part.lines();

        // 解析状态行
        let status = lines
            .next()
            .ok_or_else(|| Error::ResponseParse("Empty response headers".into()))
            .and_then(|status_line| {
                let parts: Vec<&str> = status_line.split_whitespace().collect();
                if parts.len() >= 2 {
                    parts[1].parse().map_err(|_| Error::InvalidStatus)
                } else {
                    Err(Error::ResponseParse("Invalid status line".into()))
                }
            })?;

        // 解析头部
        for line in lines {
            if let Some((key, value)) = line.split_once(':') {
                headers.insert(key.trim().to_string(), value.trim().to_string());
            }
        }

        // 提取响应体（跳过分隔符 \r\n\r\n）
        let body = response[separator_pos + 4..].to_vec();

        Ok(Response {
            status,
            headers,
            body,
        })
    }
}