use futures::stream::{self, StreamExt};
use tokio::io;
use tokio::net;
use tokio::sync::mpsc;

use solstice_client::proto::server::{
  Client, ClientOptions, Credentials, ServerRequest, ServerResponse,
  UserStatusRequest, Version,
};

// 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 client_options(user_name: String) -> ClientOptions {
  let password = "abcdefgh".to_string();
  let credentials = Credentials::new(user_name, password).unwrap();

  ClientOptions {
    credentials,
    version: Version::default(),
  }
}

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

  let stream = connect().await.unwrap();

  let options = client_options(make_user_name("connect"));
  let client = Client::login(stream, options).await.unwrap();

  let mut inbound = client.run(stream::pending());

  assert!(inbound.next().await.is_some());
}

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

  let stream = connect().await.unwrap();

  let user_name = make_user_name("check_user_status");
  let options = client_options(user_name.clone());
  let client = Client::login(stream, options).await.unwrap();

  let (request_tx, mut request_rx) = mpsc::channel(1);

  let outbound = Box::pin(async_stream::stream! {
    while let Some(request) = request_rx.recv().await {
      yield request;
    }
  });

  let mut inbound = client.run(outbound);

  request_tx
    .send(
      UserStatusRequest {
        user_name: user_name.clone(),
      }
      .into(),
    )
    .await
    .unwrap();

  while let Some(result) = inbound.next().await {
    let response = result.unwrap();
    if let ServerResponse::UserStatusResponse(response) = response {
      assert_eq!(response.user_name, user_name);
      return;
    }
  }

  unreachable!();
}