use async_trait::async_trait;
use distant_auth::{DummyAuthHandler, Verifier};
use distant_net::client::Client;
use distant_net::common::{InmemoryTransport, OneshotListener};
use distant_net::server::{RequestCtx, Server, ServerHandler};
use log::*;
use test_log::test;

struct TestServerHandler;

#[async_trait]
impl ServerHandler for TestServerHandler {
    type Request = (u8, String);
    type Response = String;

    async fn on_request(&self, ctx: RequestCtx<Self::Request, Self::Response>) {
        let (cnt, msg) = ctx.request.payload;

        for i in 0..cnt {
            ctx.reply
                .send(format!("echo {i} {msg}"))
                .expect("Failed to send response");
        }
    }
}

#[test(tokio::test)]
async fn should_be_able_to_send_and_receive_typed_payloads_between_client_and_server() {
    let (t1, t2) = InmemoryTransport::pair(100);

    let _server = Server::new()
        .handler(TestServerHandler)
        .verifier(Verifier::none())
        .start(OneshotListener::from_value(t2))
        .expect("Failed to start server");

    let mut client: Client<(u8, String), String> = Client::build()
        .auth_handler(DummyAuthHandler)
        .connector(t1)
        .connect()
        .await
        .expect("Failed to connect to server");

    info!("Mailing a message from the client, and waiting for 3 responses");
    let mut mailbox = client
        .mail((3, "hello".to_string()))
        .await
        .expect("Failed to mail message");

    assert_eq!(mailbox.next().await.unwrap().payload, "echo 0 hello");
    assert_eq!(mailbox.next().await.unwrap().payload, "echo 1 hello");
    assert_eq!(mailbox.next().await.unwrap().payload, "echo 2 hello");

    info!("Sending a message from the client, and waiting for a response");
    let response = client
        .send((1, "hello".to_string()))
        .await
        .expect("Failed to send message");

    assert_eq!(response.payload, "echo 0 hello");

    info!("Firing off a message from the client");
    client
        .fire((1, "hello".to_string()))
        .await
        .expect("Failed to fire message");
}