use tokio::io;
use tokio::net;
use tokio::sync::mpsc;

use solstice_proto::server::{
  Client, Credentials, ServerResponse, UserStatusRequest,
};

// Enable capturing logs in tests.
fn init() {
  let _ = env_logger::builder().is_test(true).try_init();
}

async fn connect() -> io::Result<net::TcpStream> {
  net::TcpStream::connect("server.slsknet.org:2242").await
}

fn make_user_name(test_name: &str) -> String {
  format!("st_{}", test_name)
}

fn make_credentials(user_name: String) -> Credentials {
  let password = "abcdefgh".to_string();
  Credentials::new(user_name, password).unwrap()
}

#[tokio::test]
async fn integration_connect() {
  init();

  let stream = connect().await.expect("connecting");

  let credentials = make_credentials(make_user_name("connect"));
  let (_info, mut worker) = Client::new(stream)
    .login(credentials)
    .await
    .expect("logging in");

  let (request_tx, request_rx) = mpsc::channel(100);
  let (response_tx, _response_rx) = mpsc::channel(100);

  let worker_task =
    tokio::spawn(async move { worker.run(response_tx, request_rx).await });

  drop(request_tx);
  worker_task
    .await
    .expect("joining worker")
    .expect("running worker");
}

#[tokio::test]
async fn integration_check_user_status() {
  init();

  let stream = connect().await.expect("connecting");

  let user_name = make_user_name("check_user_status");
  let credentials = make_credentials(user_name.clone());
  let (_, mut worker) = Client::new(stream)
    .login(credentials)
    .await
    .expect("logging in");

  let (request_tx, request_rx) = mpsc::channel(100);
  let (response_tx, mut response_rx) = mpsc::channel(100);

  request_tx
    .send(
      UserStatusRequest {
        user_name: user_name.clone(),
      }
      .into(),
    )
    .await
    .expect("sending request");

  let worker_task =
    tokio::spawn(async move { worker.run(response_tx, request_rx).await });

  log::info!("Waiting for responses.");
  while let Some(response) = response_rx.recv().await {
    if let ServerResponse::UserStatusResponse(response) = response {
      assert_eq!(response.user_name, user_name);
      return;
    }
  }

  worker_task
    .await
    .expect("joining worker")
    .expect("running worker");

  unreachable!();
}