use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer};
use futures_util::{SinkExt, StreamExt};
use std::net::TcpListener;
use tokio_tungstenite_wasm::{connect, Message};

async fn ws(req: HttpRequest, body: web::Payload) -> actix_web::Result<HttpResponse> {
    let (response, mut session, mut stream) = actix_ws::handle(&req, body)?;

    actix_web::rt::spawn(async move {
        while let Some(Ok(msg)) = stream.next().await {
            match msg {
                actix_ws::Message::Text(text) => {
                    let _ = session.text(text).await;
                }
                actix_ws::Message::Close(reason) => {
                    let _ = session.close(reason).await;
                    return;
                }
                _ => {}
            }
        }
    });

    Ok(response)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind(("127.0.0.1", 0))?;
    let addr = listener.local_addr()?;
    let server = HttpServer::new(|| App::new().route("/json_rpc", web::get().to(ws)))
        .listen(listener)?
        .run();

    actix_web::rt::spawn(server);

    let url = format!("ws://{addr}/json_rpc");
    let mut websocket = connect(&url)
        .await
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;

    websocket
        .send(Message::Text("ping".into()))
        .await
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;

    match websocket.next().await {
        Some(Ok(Message::Text(text))) if text == "ping" => Ok(()),
        other => Err(std::io::Error::new(
            std::io::ErrorKind::Other,
            format!("unexpected websocket response: {other:?}"),
        )),
    }
}