// #[tokio::main] 宏標(biāo)記了 `main` 函數(shù)，表明這是一個(gè)異步的`Tokio`應(yīng)用程序。
#[tokio::main]
async fn main() {
    // 首先創(chuàng)建了一個(gè) `TcpListener` 監(jiān)聽器，綁定到地址 "127.0.0.1:3000" 上
    // 然后，通過 `await` 等待監(jiān)聽器綁定完成
    // 如果綁定失敗，會(huì)通過 `unwrap` 方法拋出錯(cuò)誤。
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    println!("listening on {}", listener.local_addr().unwrap());
    // 使用 `axum::serve` 啟動(dòng) Axum 框架的服務(wù)器，
    //    監(jiān)聽前面創(chuàng)建的 `TcpListener`。
    // `app()` 函數(shù)返回的是一個(gè) `Router`
    //    它定義了一個(gè)簡(jiǎn)單的路由，將路徑 "/a" 映射到處理函數(shù) `a_handler`。
    axum::serve(listener, app()).await.unwrap();
}

// 返回一個(gè) `Router`，它只有一個(gè)路由規(guī)則，
//    將 "/a" 路徑映射到 `a_handler` 處理函數(shù)
fn app() -> Router {
    Router::new()
        .route("/a", get(a_handler))
}

// 一個(gè)WebSocket處理程序，它會(huì)回顯收到的任何消息。
// 定義為一個(gè)WebSocket處理程序，
//   它接收一個(gè) `WebSocketUpgrade` 參數(shù)，表示W(wǎng)ebSocket升級(jí)。
async fn a_handler(ws: WebSocketUpgrade) -> Response {
    // 調(diào)用將WebSocket升級(jí)后的對(duì)象傳遞給 `a_handle_socket` 處理函數(shù)。
    ws.on_upgrade(a_handle_socket)
}

async fn a_handle_socket(mut socket: WebSocket) {
    // 使用 while let 循環(huán)，持續(xù)從 WebSocket 連接中接收消息。 
    // socket.recv().await 通過異步的方式接收消息，返回一個(gè) Result，
    // 其中 Ok(msg) 表示成功接收到消息。
    while let Some(Ok(msg)) = socket.recv().await {
        //  使用 if let 匹配，判斷接收到的消息是否為文本消息。
        //  WebSocket消息可以是不同類型的，這里我們只處理文本消息。
        if let Message::Text(msg) = msg {
            // 構(gòu)造一個(gè)回顯消息，將客戶端發(fā)送的消息包含在回顯消息中。
            // 然后，使用 socket.send 方法將回顯消息發(fā)送回客戶端。
            // await 等待發(fā)送操作完成。
            if socket
                .send(Message::Text(format!("You said: {msg}")))
                .await
                // 檢查 send 操作是否返回錯(cuò)誤。
                // 如果發(fā)送消息出現(xiàn)錯(cuò)誤（例如，連接斷開），
                // 就通過 break 跳出循環(huán)，結(jié)束處理函數(shù)。
                .is_err()
            {
                break;
            }
        }
    }
}

use actix::{Actor, StreamHandler};
use actix_web::{
  web, 
  App, 
  Error, 
  HttpRequest, 
  HttpResponse, 
  HttpServer
};
use actix_web_actors::ws;

/// 定義HTTP Actor
// 定義了一個(gè)名為 MyWs 的結(jié)構(gòu)體，這將用作WebSocket的Actix Actor。
// Actors 是Actix框架中的并發(fā)單元，用于處理異步消息
struct MyWs;

// 為 MyWs 結(jié)構(gòu)體實(shí)現(xiàn)了 Actor trait，指定了 WebsocketContext 作為上下文類型。
impl Actor for MyWs {
    type Context = ws::WebsocketContext<Self>;
}

/// 處理ws::Message消息的處理程序
// 為 MyWs 結(jié)構(gòu)體實(shí)現(xiàn)了 StreamHandler trait，處理WebSocket連接中的消息。
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWs {
    // 對(duì)接收到的不同類型的消息進(jìn)行處理。例如，對(duì)于 Ping 消息，發(fā)送 Pong 消息作為響應(yīng)。
    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),
            _ => (),
        }
    }
}

// 定義了一個(gè)處理HTTP請(qǐng)求的異步函數(shù)。
async fn index(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    // 將WebSocket連接升級(jí)，并將請(qǐng)求委托給 MyWs Actor 處理。
    let resp = ws::start(MyWs {}, &req, stream);
    println!("{:?}", resp);
    resp
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    //  創(chuàng)建了一個(gè) HttpServer 實(shí)例，通過 App::new() 創(chuàng)建一個(gè)應(yīng)用，
    // 該應(yīng)用只有一個(gè)路由，將路徑 "/ws/" 映射到處理函數(shù) index 上。
    HttpServer::new(|| App::new().route("/ws/", web::get().to(index)))
        // 綁定服務(wù)器到地址 "127.0.0.1" 和端口 8080。
        .bind(("127.0.0.1", 8080))?
        // 啟動(dòng)服務(wù)器并等待其完成運(yùn)行。
        .run()
        .await
}

// 定義了一個(gè)名為 Password 的結(jié)構(gòu)體，該結(jié)構(gòu)體派生了 Debug 和 FromForm traits。
// FromForm trait 用于從表單數(shù)據(jù)中提取數(shù)據(jù)。
// 該結(jié)構(gòu)體包含兩個(gè)字段 first 和 second，分別表示密碼的第一個(gè)和第二個(gè)部分。
#[derive(Debug, FromForm)]
struct Password<'v> {
    // 表示對(duì)字段的長(zhǎng)度進(jìn)行了驗(yàn)證，要求長(zhǎng)度在6個(gè)字符以上
    #[field(validate = len(6..))]
    // 表示第一個(gè)字段必須等于第二個(gè)字段
    #[field(validate = eq(self.second))]
    first: &'v str,
    //  表示第二個(gè)字段必須等于第一個(gè)字段。
    #[field(validate = eq(self.first))]
    second: &'v str,
}

// 省略其他結(jié)構(gòu)體和實(shí)現(xiàn)...

// 定義了一個(gè)處理GET請(qǐng)求的函數(shù) index，返回一個(gè) Template 對(duì)象。
// 這個(gè)函數(shù)用于渲染首頁(yè)。
#[get("/")]
fn index() -> Template {
    Template::render("index", &Context::default())
}

// 定義了一個(gè)處理POST請(qǐng)求的函數(shù) submit。
// 這個(gè)函數(shù)接受一個(gè) Form 對(duì)象，其中包含了表單的數(shù)據(jù)
#[post("/", data = "<form>")]
fn submit(form: Form<Submit<'_>>) -> (Status, Template) {
    // 通過檢查 form.value 是否包含 Some(ref submission) 來判斷表單是否提交。
    let template = match form.value {
        // 如果提交了表單，打印提交的內(nèi)容，并渲染 "success" 頁(yè)面；
        Some(ref submission) => {
            println!("submission: {:#?}", submission);
            Template::render("success", &form.context)
        }
        // 否則，渲染 "index" 頁(yè)面。
        None => Template::render("index", &form.context),
    };

    (form.context.status(), template)
}

// 定義了啟動(dòng)Rocket應(yīng)用程序的函數(shù)。
#[launch]
fn rocket() -> _ {
    // 使用 rocket::build() 創(chuàng)建一個(gè)Rocket應(yīng)用程序?qū)嵗?    rocket::build()
        // 并通過 .mount() 方法掛載路由。
        // routes![index, submit] 定義了兩個(gè)路由，
        // 分別映射到 index 和 submit 函數(shù)。
        .mount("/", routes![index, submit])
        // 添加了一個(gè)模板處理的Fairing（Rocket中的中間件）
        .attach(Template::fairing())
        // 將靜態(tài)文件服務(wù)掛載到根路徑。
        .mount("/", FileServer::from(relative!("/static")))
}

// 定義了一個(gè)靜態(tài)的原子 usize 計(jì)數(shù)器，用于為每個(gè)連接的用戶分配唯一的用戶ID。
static NEXT_USER_ID: AtomicUsize = AtomicUsize::new(1);

// 當(dāng)前連接用戶的狀態(tài)。
//  定義了一個(gè)類型別名 Users，它是一個(gè)原子引用計(jì)數(shù)的可讀寫鎖的 HashMap，將用戶ID映射到消息的發(fā)送器。
// Arc 是原子引用計(jì)數(shù)的智能指針，RwLock 是讀寫鎖。
// - 鍵是其id
// - 值是`warp::ws::Message`的發(fā)送器
type Users = Arc<RwLock<HashMap<usize, mpsc::UnboundedSender<Message>>>>;

#[tokio::main]
async fn main() {
    // 創(chuàng)建了一個(gè) users 變量，用于存儲(chǔ)連接的用戶信息
    let users = Users::default();
    // 將其包裝成 Warp 過濾器，以便在不同的路由中共享用戶狀態(tài)。
    let users = warp::any().map(move || users.clone());

    // chat 路由處理 WebSocket 握手
    let chat = warp::path("chat")
        // `ws()`過濾器將準(zhǔn)備WebSocket握手...
        .and(warp::ws())
        .and(users)
        // 調(diào)用 user_connected 函數(shù)處理 WebSocket 連接。
        .map(|ws: warp::ws::Ws, users| {
            // 如果握手成功，將調(diào)用我們的函數(shù)。
            ws.on_upgrade(move |socket| user_connected(socket, users))
        });

    // 處理 HTTP GET 請(qǐng)求，返回一個(gè)包含聊天室鏈接的 HTML 頁(yè)面
    let index = warp::path::end().map(|| warp::reply::html(INDEX_HTML));

    let routes = index.or(chat);

    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
}


async fn user_connected(ws: WebSocket, users: Users) {
    // 使用計(jì)數(shù)器為此用戶分配新的唯一ID。
    let my_id = NEXT_USER_ID.fetch_add(1, Ordering::Relaxed);

    eprintln!("new chat user: {}", my_id);

    // 將套接字拆分為消息的發(fā)送器和接收器。
    let (mut user_ws_tx, mut user_ws_rx) = ws.split();
    // 創(chuàng)建一個(gè)新的消息通道 (mpsc::unbounded_channel) 用于將用戶的消息廣播給其他用戶
    let (tx, rx) = mpsc::unbounded_channel();
    let mut rx = UnboundedReceiverStream::new(rx);

    tokio::task::spawn(async move {
        // 不斷接收用戶的消息。一旦用戶斷開連接，就會(huì)退出這個(gè)循環(huán)。
        while let Some(message) = rx.next().await {
            user_ws_tx
                .send(message)
                .unwrap_or_else(|e| {
                    eprintln!("websocket send error: {}", e);
                })
                .await;
        }
    });

    //將發(fā)送器保存在我們的已連接用戶列表中。
    users.write().await.insert(my_id, tx);

    // 返回一個(gè)基本上是管理此特定用戶連接的狀態(tài)機(jī)的“Future”。

    // 每當(dāng)用戶發(fā)送消息時(shí)，將其廣播給
    // 所有其他用戶...
    while let Some(result) = user_ws_rx.next().await {
        let msg = match result {
            Ok(msg) => msg,
            Err(e) => {
                eprintln!("websocket error(uid={}): {}", my_id, e);
                break;
            }
        };
        user_message(my_id, msg, &users).await;
    }

    // 只要用戶保持連接，user_ws_rx流就會(huì)繼續(xù)處理。一旦他們斷開連接，那么...
    user_disconnected(my_id, &users).await;
}

// 處理用戶發(fā)送的消息。它跳過非文本消息，將文本消息格式化為 <User#ID>: Message，然后將其廣播給所有其他用戶。
async fn user_message(my_id: usize, msg: Message, users: &Users) {
    // 跳過任何非文本消息...
    let msg = if let Ok(s) = msg.to_str() {
        s
    } else {
        return;
    };

    let new_msg = format!("<User#{}>: {}", my_id, msg);

    // 來自此用戶的新消息，將其發(fā)送給所有其他用戶（除了相同的uid）...
    for (&uid, tx) in users.read().await.iter() {
        if my_id != uid {
            if let Err(_disconnected) = tx.send(Message::text(new_msg.clone())) {
                // 發(fā)送器已斷開連接，我們的`user_disconnected`代碼
                // 應(yīng)該在另一個(gè)任務(wù)中執(zhí)行，這里沒有更多的事情要做。
            }
        }
    }
}

async fn user_disconnected(my_id: usize, users: &Users) {
    eprintln!("good bye user: {}", my_id);

    // 流關(guān)閉，因此從用戶列表中刪除
    users.write().await.remove(&my_id);
}

// async-std crate 提供的異步 main 函數(shù)。它返回一個(gè) Result，表示可能的錯(cuò)誤。
#[async_std::main]
async fn main() -> Result<(), std::io::Error> {
    // 使用 femme crate 啟用顏色日志。這是一個(gè)美觀的日志記錄庫(kù)，可以使日志輸出更易讀。
    femme::start();
    // 創(chuàng)建一個(gè) Tide 應(yīng)用程序?qū)嵗?    let mut app = tide::new();
    // 添加一個(gè)日志中間件，用于記錄請(qǐng)求和響應(yīng)的日志信息。
    app.with(tide::log::LogMiddleware::new());
    // 添加一個(gè)會(huì)話中間件，用于處理會(huì)話數(shù)據(jù)。這里使用內(nèi)存存儲(chǔ)，并提供一個(gè)密鑰（TIDE_SECRET），用于加密和驗(yàn)證會(huì)話數(shù)據(jù)。
    app.with(tide::sessions::SessionMiddleware::new(
        tide::sessions::MemoryStore::new(),
        std::env::var("TIDE_SECRET")
            .expect(
                "Please provide a TIDE_SECRET value of at \
                      least 32 bytes in order to run this example",
            )
            .as_bytes(),
    ));
    // 添加一個(gè) Before 中間件，它在處理請(qǐng)求之前執(zhí)行。在這里，它用于增加訪問計(jì)數(shù)，存儲(chǔ)在會(huì)話中。
    app.with(tide::utils::Before(
        |mut request: tide::Request<()>| async move {
            let session = request.session_mut();
            let visits: usize = session.get("visits").unwrap_or_default();
            session.insert("visits", visits + 1).unwrap();
            request
        },
    ));
    // 定義了一個(gè)處理根路徑的GET請(qǐng)求的路由。這個(gè)路由通過 async move 來處理請(qǐng)求，獲取會(huì)話中的訪問計(jì)數(shù)，并返回一個(gè)包含訪問次數(shù)的字符串。
    app.at("/").get(|req: tide::Request<()>| async move {
        let visits: usize = req.session().get("visits").unwrap();
        Ok(format!("you have visited this website {} times", visits))
    });
    // 定義了一個(gè)處理 "/reset" 路徑的GET請(qǐng)求的路由。這個(gè)路由通過 async move 處理請(qǐng)求，將會(huì)話數(shù)據(jù)清除，然后重定向到根路徑
    app.at("/reset")
        .get(|mut req: tide::Request<()>| async move {
            req.session_mut().destroy();
            Ok(tide::Redirect::new("/"))
        });
    // 啟動(dòng)應(yīng)用程序并監(jiān)聽在 "127.0.0.1:8080" 地址上。使用 await? 處理可能的啟動(dòng)錯(cuò)誤。
    app.listen("127.0.0.1:8080").await?;

    Ok(())
}

// 注解表示這是一個(gè)處理器函數(shù)，用于處理 WebSocket 請(qǐng)求
#[handler]
fn ws(
    // 提取了 WebSocket 路徑中的名字參數(shù)
    Path(name): Path<String>,
    // WebSocket 對(duì)象，表示與客戶端的連接
    ws: WebSocket,
    // 是一個(gè)數(shù)據(jù)提取器，用于獲取廣播通道的發(fā)送器。
    sender: Data<&tokio::sync::broadcast::Sender<String>>,
) -> impl IntoResponse {
    // 克隆了廣播通道的發(fā)送器 sender。
    let sender = sender.clone();
    // 它訂閱了廣播通道，創(chuàng)建了一個(gè)接收器 receiver
    let mut receiver = sender.subscribe();
    //  處理 WebSocket 連接升級(jí)
    ws.on_upgrade(move |socket| async move {
        // 將連接的讀寫部分拆分為 sink 和 stream
        let (mut sink, mut stream) = socket.split();
        
        // 從 WebSocket 客戶端接收消息
        // 如果是文本消息，則將其格式化為 {name}: {text} 的形式，并通過廣播通道發(fā)送。
        // 如果發(fā)送失敗（例如，通道關(guān)閉），則任務(wù)終止。

        tokio::spawn(async move {
            while let Some(Ok(msg)) = stream.next().await {
                if let Message::Text(text) = msg {
                    if sender.send(format!("{name}: {text}")).is_err() {
                        break;
                    }
                }
            }
        });
        // 從廣播通道接收消息，并將其發(fā)送到 WebSocket 客戶端
        tokio::spawn(async move {
            while let Ok(msg) = receiver.recv().await {
                if sink.send(Message::Text(msg)).await.is_err() {
                    break;
                }
            }
        });
    })
}

#[tokio::main]
async fn main() -> Result<(), std::io::Error> {
    // 使用 tide::Route 創(chuàng)建了一個(gè)路由，其中包括兩個(gè)路徑：
    // - / 路徑處理 HTTP GET 請(qǐng)求，調(diào)用 index 函數(shù)。
    // - /ws/:name 路徑處理 WebSocket 請(qǐng)求，調(diào)用 ws 函數(shù)。
    let app = Route::new().at("/", get(index)).at(
        "/ws/:name",
        // 通過 tokio::sync::broadcast::channel 創(chuàng)建一個(gè)廣播通道；
        // 并通過 tokio::sync::broadcast::channel::<String>(32).0 
        //   獲取其發(fā)送器，將其作為數(shù)據(jù)傳遞給 ws 處理函數(shù)
        get(ws.data(tokio::sync::broadcast::channel::<String>(32).0)),
    );
    // 創(chuàng)建了一個(gè)服務(wù)器實(shí)例
    Server::new(TcpListener::bind("127.0.0.1:3000"))
         // 啟動(dòng)服務(wù)器，并等待其完成運(yùn)行。
        .run(app)
        .await
}