// file: crates/common/game-realtime-websocket-lib/tests/loopback.rs
// version: 1

//! Deterministic localhost proof for the Tokio/tokio-tungstenite backend.

use game_realtime_transport_lib::RealtimeConnection; // rust-rules: trait-import
use game_realtime_transport_lib::RealtimeReceiver; // rust-rules: trait-import
use game_realtime_transport_lib::RealtimeSender; // rust-rules: trait-import

const TEST_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(3);

#[tokio::test(flavor = "current_thread")]
async fn binary_round_trip_and_clean_close_work_on_loopback() {
    let bind_address = std::net::SocketAddr::from(([127, 0, 0, 1], 0));
    let listener = match game_realtime_websocket_lib::WebSocketListener::bind(bind_address).await {
        Ok(value) => value,
        Err(error) => panic!("loopback listener bind failed: {error}"),
    };
    let endpoint = format!("ws://{}/", listener.local_addr());
    let pair = tokio::time::timeout(TEST_TIMEOUT, async {
        return tokio::join!(listener.accept(), game_realtime_websocket_lib::connect(endpoint.as_str()));
    })
    .await;
    let (server_connection, client_connection) = match pair {
        Ok((Ok(server), Ok(client))) => (server, client),
        Ok((_server, _client)) => panic!("loopback connection establishment failed"),
        Err(_) => panic!("loopback connection establishment timed out"),
    };
    let (mut server_sender, mut server_receiver) = server_connection.split();
    let (mut client_sender, mut client_receiver) = client_connection.split();
    let client_payload = game_realtime_transport_lib::TransportMessage::new(vec![0, 1, 2, 3, 255]);
    let client_send = tokio::time::timeout(TEST_TIMEOUT, client_sender.send(client_payload)).await;
    assert!(matches!(client_send, Ok(Ok(()))));
    let server_receive = tokio::time::timeout(TEST_TIMEOUT, server_receiver.receive()).await;
    match server_receive {
        Ok(Ok(received)) => assert_eq!(
            received,
            game_realtime_transport_lib::TransportReceive::Message(game_realtime_transport_lib::TransportMessage::new(vec![0, 1, 2, 3, 255]))
        ),
        Ok(Err(error)) => panic!("server receive failed: {error}"),
        Err(_) => panic!("server receive timed out"),
    }
    let server_payload = game_realtime_transport_lib::TransportMessage::new(vec![9, 8, 7, 6]);
    let server_send = tokio::time::timeout(TEST_TIMEOUT, server_sender.send(server_payload)).await;
    assert!(matches!(server_send, Ok(Ok(()))));
    let client_receive = tokio::time::timeout(TEST_TIMEOUT, client_receiver.receive()).await;
    match client_receive {
        Ok(Ok(received)) => {
            assert_eq!(received, game_realtime_transport_lib::TransportReceive::Message(game_realtime_transport_lib::TransportMessage::new(vec![9, 8, 7, 6])))
        },
        Ok(Err(error)) => panic!("client receive failed: {error}"),
        Err(_) => panic!("client receive timed out"),
    }
    let client_close = tokio::time::timeout(TEST_TIMEOUT, client_sender.close()).await;
    assert!(matches!(client_close, Ok(Ok(()))));
    let server_close_observation = tokio::time::timeout(TEST_TIMEOUT, server_receiver.receive()).await;
    match server_close_observation {
        Ok(Ok(received)) => assert_eq!(received, game_realtime_transport_lib::TransportReceive::Closed),
        Ok(Err(error)) => panic!("server close observation failed: {error}"),
        Err(_) => panic!("server close observation timed out"),
    };
}