wae-https 0.0.1

#![doc = include_str!("readme.md")]
#![warn(missing_docs)]

pub mod error;
pub mod extract;
pub mod middleware;
pub mod response;
pub mod router;
pub mod template;
pub mod tls;

pub use wae_session as session;

use http::{Response, StatusCode, header};
use http_body_util::Full;
use hyper::body::Bytes;
use std::{net::SocketAddr, path::Path, time::Duration};
use tokio::net::TcpListener;
use tracing::info;

pub use wae_types::{WaeError, WaeResult};

/// HTTP 响应体类型
pub type Body = Full<Bytes>;

/// 创建空的 Body
pub fn empty_body() -> Body {
    Full::new(Bytes::new())
}

/// 创建带内容的 Body
pub fn full_body<B: Into<Bytes>>(data: B) -> Body {
    Full::new(data.into())
}

/// HTTPS 操作结果类型
pub type HttpsResult<T> = WaeResult<T>;

/// HTTPS 错误类型
pub type HttpsError = WaeError;

/// 自定义路由类型
#[derive(Clone, Default)]
pub struct Router {
    // 暂时为空，后续实现
}

impl Router {
    /// 创建新的空路由
    pub fn new() -> Self {
        Self::default()
    }

    /// 合并另一个路由（暂时实现）
    pub fn merge(self, _other: Self) -> Self {
        self
    }

    /// 嵌套服务（暂时实现）
    pub fn nest_service<S>(self, _prefix: &str, _service: S) -> Self {
        self
    }
}

/// HTTP 版本配置
///
/// 用于配置服务器支持的 HTTP 协议版本。
#[derive(Debug, Clone, Copy, Default)]
pub enum HttpVersion {
    /// 仅支持 HTTP/1.1
    Http1Only,
    /// 仅支持 HTTP/2
    Http2Only,
    /// 同时支持 HTTP/1.1 和 HTTP/2
    #[default]
    Both,
    /// HTTP/3 QUIC 支持
    Http3,
}

/// HTTP/2 配置
///
/// 用于配置 HTTP/2 协议的各项参数。
#[derive(Debug, Clone)]
pub struct Http2Config {
    /// 是否启用 HTTP/2
    pub enabled: bool,
    /// 是否启用服务器推送
    pub enable_push: bool,
    /// 最大并发流数量
    pub max_concurrent_streams: u32,
    /// 初始流窗口大小
    pub initial_stream_window_size: u32,
    /// 最大帧大小
    pub max_frame_size: u32,
    /// 是否启用 CONNECT 协议扩展
    pub enable_connect_protocol: bool,
    /// 流空闲超时时间
    pub stream_idle_timeout: Duration,
}

impl Default for Http2Config {
    fn default() -> Self {
        Self {
            enabled: true,
            enable_push: false,
            max_concurrent_streams: 256,
            initial_stream_window_size: 65535,
            max_frame_size: 16384,
            enable_connect_protocol: false,
            stream_idle_timeout: Duration::from_secs(60),
        }
    }
}

impl Http2Config {
    /// 创建默认的 HTTP/2 配置
    pub fn new() -> Self {
        Self::default()
    }

    /// 创建禁用 HTTP/2 的配置
    pub fn disabled() -> Self {
        Self { enabled: false, ..Self::default() }
    }

    /// 设置是否启用服务器推送
    pub fn with_enable_push(mut self, enable: bool) -> Self {
        self.enable_push = enable;
        self
    }

    /// 设置最大并发流数量
    pub fn with_max_concurrent_streams(mut self, max: u32) -> Self {
        self.max_concurrent_streams = max;
        self
    }

    /// 设置初始流窗口大小
    pub fn with_initial_stream_window_size(mut self, size: u32) -> Self {
        self.initial_stream_window_size = size;
        self
    }

    /// 设置最大帧大小
    pub fn with_max_frame_size(mut self, size: u32) -> Self {
        self.max_frame_size = size;
        self
    }

    /// 设置是否启用 CONNECT 协议扩展
    pub fn with_enable_connect_protocol(mut self, enable: bool) -> Self {
        self.enable_connect_protocol = enable;
        self
    }

    /// 设置流空闲超时时间
    pub fn with_stream_idle_timeout(mut self, timeout: Duration) -> Self {
        self.stream_idle_timeout = timeout;
        self
    }
}

/// TLS 配置
///
/// 用于配置 TLS 证书和密钥。
#[derive(Debug, Clone)]
pub struct TlsConfig {
    /// 证书文件路径
    pub cert_path: String,
    /// 私钥文件路径
    pub key_path: String,
}

impl TlsConfig {
    /// 创建新的 TLS 配置
    ///
    /// # 参数
    ///
    /// * `cert_path` - 证书文件路径
    /// * `key_path` - 私钥文件路径
    pub fn new(cert_path: impl Into<String>, key_path: impl Into<String>) -> Self {
        Self { cert_path: cert_path.into(), key_path: key_path.into() }
    }
}

/// HTTP/3 QUIC 配置
///
/// 用于配置 HTTP/3 QUIC 协议的设置。
#[derive(Debug, Clone, Default)]
pub struct Http3Config {
    /// 是否启用 HTTP/3 QUIC 支持
    pub enabled: bool,
}

impl Http3Config {
    /// 创建默认的 HTTP/3 配置
    pub fn new() -> Self {
        Self::default()
    }

    /// 创建启用 HTTP/3 的配置
    pub fn enabled() -> Self {
        Self { enabled: true }
    }
}

/// HTTPS 服务器配置
///
/// 用于配置 HTTPS 服务器的各项参数。
#[derive(Debug, Clone)]
pub struct HttpsServerConfig {
    /// 服务器监听地址
    pub addr: SocketAddr,
    /// 服务名称
    pub service_name: String,
    /// HTTP 版本配置
    pub http_version: HttpVersion,
    /// HTTP/2 配置
    pub http2_config: Http2Config,
    /// HTTP/3 配置
    pub http3_config: Http3Config,
    /// TLS 配置
    pub tls_config: Option<TlsConfig>,
}

impl Default for HttpsServerConfig {
    fn default() -> Self {
        Self {
            addr: "0.0.0.0:3000".parse().unwrap(),
            service_name: "wae-https-service".to_string(),
            http_version: HttpVersion::Both,
            http2_config: Http2Config::default(),
            http3_config: Http3Config::default(),
            tls_config: None,
        }
    }
}

/// HTTPS 服务器构建器
///
/// 用于构建和配置 HTTPS 服务器。
pub struct HttpsServerBuilder {
    config: HttpsServerConfig,
    router: Router,
}

impl HttpsServerBuilder {
    /// 创建新的 HTTPS 服务器构建器
    pub fn new() -> Self {
        Self { config: HttpsServerConfig::default(), router: Router::new() }
    }

    /// 设置服务器监听地址
    pub fn addr(mut self, addr: SocketAddr) -> Self {
        self.config.addr = addr;
        self
    }

    /// 设置服务名称
    pub fn service_name(mut self, name: impl Into<String>) -> Self {
        self.config.service_name = name.into();
        self
    }

    /// 设置路由
    pub fn router(mut self, router: Router) -> Self {
        self.router = router;
        self
    }

    /// 合并路由
    pub fn merge_router(mut self, router: Router) -> Self {
        self.router = self.router.merge(router);
        self
    }

    /// 设置 HTTP 版本配置
    pub fn http_version(mut self, version: HttpVersion) -> Self {
        self.config.http_version = version;
        self
    }

    /// 设置 HTTP/2 配置
    pub fn http2_config(mut self, config: Http2Config) -> Self {
        self.config.http2_config = config;
        self
    }

    /// 设置 HTTP/3 配置
    pub fn http3_config(mut self, config: Http3Config) -> Self {
        self.config.http3_config = config;
        self
    }

    /// 设置 TLS 证书和密钥
    ///
    /// # 参数
    ///
    /// * `cert_path` - 证书文件路径
    /// * `key_path` - 私钥文件路径
    pub fn tls(mut self, cert_path: impl Into<String>, key_path: impl Into<String>) -> Self {
        self.config.tls_config = Some(TlsConfig::new(cert_path, key_path));
        self
    }

    /// 设置 TLS 配置
    pub fn tls_config(mut self, config: TlsConfig) -> Self {
        self.config.tls_config = Some(config);
        self
    }

    /// 构建 HTTPS 服务器
    pub fn build(self) -> HttpsServer {
        HttpsServer { config: self.config, router: self.router }
    }
}

impl Default for HttpsServerBuilder {
    fn default() -> Self {
        Self::new()
    }
}

/// HTTPS 服务器
///
/// 提供 HTTP/HTTPS 服务的核心类型。
pub struct HttpsServer {
    config: HttpsServerConfig,
    router: Router,
}

impl HttpsServer {
    /// 启动服务器
    pub async fn serve(self) -> HttpsResult<()> {
        let addr = self.config.addr;
        let service_name = self.config.service_name.clone();
        let protocol_info = self.get_protocol_info();
        let tls_config = self.config.tls_config.clone();

        let listener =
            TcpListener::bind(addr).await.map_err(|e| WaeError::internal(format!("Failed to bind address: {}", e)))?;

        info!("{} {} server starting on {}", service_name, protocol_info, addr);

        match tls_config {
            Some(tls_config) => self.serve_tls(listener, &tls_config).await,
            None => self.serve_plain(listener).await,
        }
    }

    async fn serve_plain(self, _listener: TcpListener) -> HttpsResult<()> {
        // TODO: 使用 hyper::server 实现
        // 暂时挂起，等待 Router 实现
        loop {
            tokio::time::sleep(Duration::from_secs(3600)).await;
        }
    }

    async fn serve_tls(self, _listener: TcpListener, _tls_config: &TlsConfig) -> HttpsResult<()> {
        // TODO: 使用 hyper::server 实现
        // 暂时挂起，等待 Router 实现
        loop {
            tokio::time::sleep(Duration::from_secs(3600)).await;
        }
    }

    fn get_protocol_info(&self) -> String {
        let tls_info = if self.config.tls_config.is_some() { "S" } else { "" };
        let version_info = match self.config.http_version {
            HttpVersion::Http1Only => "HTTP/1.1",
            HttpVersion::Http2Only => "HTTP/2",
            HttpVersion::Both => "HTTP/1.1+HTTP/2",
            HttpVersion::Http3 => "HTTP/3",
        };
        format!("{}{}", version_info, tls_info)
    }
}

/// API 响应结构
///
/// 用于标准化 API 响应格式。
#[derive(Debug, serde::Serialize)]
pub struct ApiResponse<T> {
    /// 是否成功
    pub success: bool,
    /// 响应数据
    pub data: Option<T>,
    /// 错误信息
    pub error: Option<ApiErrorBody>,
    /// 追踪 ID
    pub trace_id: Option<String>,
}

/// API 错误响应结构
///
/// 用于标准化 API 错误响应格式。
#[derive(Debug, serde::Serialize)]
pub struct ApiErrorBody {
    /// 错误代码
    pub code: String,
    /// 错误消息
    pub message: String,
}

impl<T: serde::Serialize> ApiResponse<T> {
    /// 将 API 响应转换为 HTTP 响应
    pub fn into_response(self) -> Response<Body> {
        let status = if self.success { StatusCode::OK } else { StatusCode::BAD_REQUEST };
        let body = serde_json::to_string(&self).unwrap_or_default();
        Response::builder()
            .status(status)
            .header(header::CONTENT_TYPE, "application/json")
            .body(Full::new(Bytes::from(body)))
            .unwrap()
    }
}

/// 创建静态文件服务路由
///
/// 用于提供静态资源文件服务。
///
/// # 参数
///
/// * `path` - 静态文件所在的目录路径
/// * `prefix` - 路由前缀，例如 "/static"
pub fn static_files_router(_path: impl AsRef<Path>, _prefix: &str) -> Router {
    // TODO: 实现静态文件路由
    Router::new()
}

impl<T> ApiResponse<T>
where
    T: serde::Serialize,
{
    /// 创建成功的 API 响应
    ///
    /// # 参数
    ///
    /// * `data` - 响应数据
    pub fn success(data: T) -> Self {
        Self { success: true, data: Some(data), error: None, trace_id: None }
    }

    /// 创建带追踪 ID 的成功 API 响应
    ///
    /// # 参数
    ///
    /// * `data` - 响应数据
    /// * `trace_id` - 追踪 ID
    pub fn success_with_trace(data: T, trace_id: impl Into<String>) -> Self {
        Self { success: true, data: Some(data), error: None, trace_id: Some(trace_id.into()) }
    }

    /// 创建错误的 API 响应
    ///
    /// # 参数
    ///
    /// * `code` - 错误代码
    /// * `message` - 错误消息
    pub fn error(code: impl Into<String>, message: impl Into<String>) -> Self {
        Self {
            success: false,
            data: None,
            error: Some(ApiErrorBody { code: code.into(), message: message.into() }),
            trace_id: None,
        }
    }

    /// 创建带追踪 ID 的错误 API 响应
    ///
    /// # 参数
    ///
    /// * `code` - 错误代码
    /// * `message` - 错误消息
    /// * `trace_id` - 追踪 ID
    pub fn error_with_trace(code: impl Into<String>, message: impl Into<String>, trace_id: impl Into<String>) -> Self {
        Self {
            success: false,
            data: None,
            error: Some(ApiErrorBody { code: code.into(), message: message.into() }),
            trace_id: Some(trace_id.into()),
        }
    }
}