// #[tokio::main] 宏标记了 `main` 函数，表明这是一个异步的`Tokio`应用程序。
#[tokio::main]
async fn main() {
    // 首先创建了一个 `TcpListener` 监听器，绑定到地址 "127.0.0.1:3000" 上
    // 然后，通过 `await` 等待监听器绑定完成
    // 如果绑定失败，会通过 `unwrap` 方法抛出错误。
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    println!("listening on {}", listener.local_addr().unwrap());
    // 使用 `axum::serve` 启动 Axum 框架的服务器，
    //    监听前面创建的 `TcpListener`。
    // `app()` 函数返回的是一个 `Router`
    //    它定义了一个简单的路由，将路径 "/a" 映射到处理函数 `a_handler`。
    axum::serve(listener, app()).await.unwrap();
}
// 返回一个 `Router`，它只有一个路由规则，
//    将 "/a" 路径映射到 `a_handler` 处理函数
fn app() -> Router {
    Router::new()
        .route("/a", get(a_handler))
}
// 一个WebSocket处理程序，它会回显收到的任何消息。
// 定义为一个WebSocket处理程序，
//   它接收一个 `WebSocketUpgrade` 参数，表示WebSocket升级。
async fn a_handler(ws: WebSocketUpgrade) -> Response {
    // 调用将WebSocket升级后的对象传递给 `a_handle_socket` 处理函数。
    ws.on_upgrade(a_handle_socket)
}
async fn a_handle_socket(mut socket: WebSocket) {
    // 使用 while let 循环，持续从 WebSocket 连接中接收消息。 
    // socket.recv().await 通过异步的方式接收消息，返回一个 Result，
    // 其中 Ok(msg) 表示成功接收到消息。
    while let Some(Ok(msg)) = socket.recv().await {
        //  使用 if let 匹配，判断接收到的消息是否为文本消息。
        //  WebSocket消息可以是不同类型的，这里我们只处理文本消息。
        if let Message::Text(msg) = msg {
            // 构造一个回显消息，将客户端发送的消息包含在回显消息中。
            // 然后，使用 socket.send 方法将回显消息发送回客户端。
            // await 等待发送操作完成。
            if socket
                .send(Message::Text(format!("You said: {msg}")))
                .await
                // 检查 send 操作是否返回错误。
                // 如果发送消息出现错误（例如，连接断开），
                // 就通过 break 跳出循环，结束处理函数。
                .is_err()
            {
                break;
            }
        }
    }
}

use actix::{Actor, StreamHandler};
use actix_web::{
  web, 
  App, 
  Error, 
  HttpRequest, 
  HttpResponse, 
  HttpServer
};
use actix_web_actors::ws;
/// 定义HTTP Actor
// 定义了一个名为 MyWs 的结构体，这将用作WebSocket的Actix Actor。
// Actors 是Actix框架中的并发单元，用于处理异步消息
struct MyWs;
// 为 MyWs 结构体实现了 Actor trait，指定了 WebsocketContext 作为上下文类型。
impl Actor for MyWs {
    type Context = ws::WebsocketContext<Self>;
}
/// 处理ws::Message消息的处理程序
// 为 MyWs 结构体实现了 StreamHandler trait，处理WebSocket连接中的消息。
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWs {
    // 对接收到的不同类型的消息进行处理。例如，对于 Ping 消息，发送 Pong 消息作为响应。
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        match msg {
            Ok(ws::Message::Ping(msg)) => ctx.pong(&msg),
            Ok(ws::Message::Text(text)) => ctx.text(text),
            Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
            _ => (),
        }
    }
}
// 定义了一个处理HTTP请求的异步函数。
async fn index(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    // 将WebSocket连接升级，并将请求委托给 MyWs Actor 处理。
    let resp = ws::start(MyWs {}, &req, stream);
    println!("{:?}", resp);
    resp
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    //  创建了一个 HttpServer 实例，通过 App::new() 创建一个应用，
    // 该应用只有一个路由，将路径 "/ws/" 映射到处理函数 index 上。
    HttpServer::new(|| App::new().route("/ws/", web::get().to(index)))
        // 绑定服务器到地址 "127.0.0.1" 和端口 8080。
        .bind(("127.0.0.1", 8080))?
        // 启动服务器并等待其完成运行。
        .run()
        .await
}

// 定义了一个名为 Password 的结构体，该结构体派生了 Debug 和 FromForm traits。
// FromForm trait 用于从表单数据中提取数据。
// 该结构体包含两个字段 first 和 second，分别表示密码的第一个和第二个部分。
#[derive(Debug, FromForm)]
struct Password<'v> {
    // 表示对字段的长度进行了验证，要求长度在6个字符以上
    #[field(validate = len(6..))]
    // 表示第一个字段必须等于第二个字段
    #[field(validate = eq(self.second))]
    first: &'v str,
    //  表示第二个字段必须等于第一个字段。
    #[field(validate = eq(self.first))]
    second: &'v str,
}
// 省略其他结构体和实现...
// 定义了一个处理GET请求的函数 index，返回一个 Template 对象。
// 这个函数用于渲染首页。
#[get("/")]
fn index() -> Template {
    Template::render("index", &Context::default())
}
// 定义了一个处理POST请求的函数 submit。
// 这个函数接受一个 Form 对象，其中包含了表单的数据
#[post("/", data = "<form>")]
fn submit(form: Form<Submit<'_>>) -> (Status, Template) {
    // 通过检查 form.value 是否包含 Some(ref submission) 来判断表单是否提交。
    let template = match form.value {
        // 如果提交了表单，打印提交的内容，并渲染 "success" 页面；
        Some(ref submission) => {
            println!("submission: {:#?}", submission);
            Template::render("success", &form.context)
        }
        // 否则，渲染 "index" 页面。
        None => Template::render("index", &form.context),
    };
    (form.context.status(), template)
}
// 定义了启动Rocket应用程序的函数。
#[launch]
fn rocket() -> _ {
    // 使用 rocket::build() 创建一个Rocket应用程序实例
    rocket::build()
        // 并通过 .mount() 方法挂载路由。
        // routes![index, submit] 定义了两个路由，
        // 分别映射到 index 和 submit 函数。
        .mount("/", routes![index, submit])
        // 添加了一个模板处理的Fairing（Rocket中的中间件）
        .attach(Template::fairing())
        // 将静态文件服务挂载到根路径。
        .mount("/", FileServer::from(relative!("/static")))
}