// Danh sách các lệnh có thể gửi tới Actor.
pub enum SharedStateCommand {
    Increment,
    Get(tokio::sync::oneshot::Sender<u64>), // oneshot là chìa khóa vì đây là cách thông tin được gửi lại - thông qua kênh này
}

// Hàm khởi động Actor. Actor này duy trì trạng thái `counter`. Cách nó xử lý các lệnh là thông qua `Sender` mà nó trả về.
pub async fn start() -> tokio::sync::mpsc::Sender<SharedStateCommand> {

    // Tạo các kênh tx và rx với dung lượng bộ đệm 32 tin nhắn
    let (tx, mut rx) = tokio::sync::mpsc::channel(32);

    // Khởi tạo biến đếm
    let mut counter: u64 = 0;

    // Tạo Actor và di chuyển mọi thứ vào bên trong nó
    tokio::spawn(async move {

        // Xử lý các lệnh được gửi tới nó
        while let Some(cmd) = rx.recv().await {
            match cmd {
                SharedStateCommand::Increment => {
                    counter += 1;
                },
                SharedStateCommand::Get(resp_tx) => {
                    let _ = resp_tx.send(counter);
                }
            }
        }
    });

    tx
}

// Hàm lấy giá trị biến đếm hiện tại bằng cách sử dụng `oneshot` để gửi một lệnh và chờ nhận kết quả qua cùng một kênh
pub async fn get_counter(sender: &tokio::sync::mpsc::Sender<SharedStateCommand>) -> u64 {
    let (resp_tx, resp_rx) = tokio::sync::oneshot::channel();
    let cmd = SharedStateCommand::Get(resp_tx);
    if sender.send(cmd).await.is_err() {
        return 0;
    }
    resp_rx.await.unwrap_or(0)
}

// Hàm này chỉ đơn giản gửi lệnh tới Actor để tăng biến đếm mà không cần chờ kết quả
pub async fn increment(sender: &tokio::sync::mpsc::Sender<SharedStateCommand>) {
    let cmd = SharedStateCommand::Increment;
    let _ = sender.send(cmd).await; // chúng ta không thực sự quan tâm ở đây
}

use axum::{http::StatusCode, Extension, Json, Router};
use shared_state_actor::SharedStateCommand;
use tokio::sync::mpsc::Sender;

#[tokio::main]
async fn main() {
    // Khởi động Actor và nhận handle của nó - Tôi đã nhập thư viện này trong Cargo.toml
    let my_actor = shared_state_actor::start().await;

    // Một số boilerplate của Axum cũng như các route
    let app = Router::new()
        .route("/", axum::routing::get(|| async { "Hello, World!" }))
        .route("/json", axum::routing::get(hello_json))
        .layer(Extension(my_actor)); // ĐIỀU NÀY RẤT QUAN TRỌNG - Thêm Actor ở đây, để nó có sẵn cho tất cả các route

    // Khởi động server axum
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3001")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

#[derive(serde::Serialize, serde::Deserialize, Debug)]
struct HelloJson {
    message: String,
}

async fn hello_json(
    Extension(my_actor): Extension<Sender<SharedStateCommand>>, // Trích xuất layer ở đây bằng extractor của Axum
) -> axum::Json<HelloJson> {
    // Tăng biến đếm trong actor
    shared_state_actor::increment(&my_actor).await;

    // Lấy giá trị biến đếm hiện tại
    let new_total = shared_state_actor::get_counter(&my_actor).await;

    // Phản hồi lại
    let reply = HelloJson {
        message: format!("Counter: {}", new_total),
    };
    axum::Json(reply)
}