use futures::stream::{self, StreamExt};
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.unwrap();

  let credentials = make_credentials(make_user_name("connect"));
  let channel = Client::new(stream).login(credentials).await.unwrap();

  let inbound = channel.run(stream::pending());
  tokio::pin!(inbound);

  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 credentials = make_credentials(user_name.clone());
  let channel = Client::new(stream).login(credentials).await.unwrap();

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

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

  let inbound = channel.run(outbound);
  tokio::pin!(inbound);

  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!();
}