// use std::io::{BufReader, Write, Result, stdin, BufRead};
// use std::net::{ToSocketAddrs};
// use reqwest::Client;
// use tokio::io::{AsyncReadExt, AsyncWriteExt};
// use tokio::net::TcpStream;
// use crate::lavina_clients;

#[cfg(feature = "ssr")]
struct TestScope<'a> {
    reader: tokio::io::BufReader<tokio::net::tcp::ReadHalf<'a>>,
    writer: tokio::net::tcp::WriteHalf<'a>,
    buffer: Vec<u8>,
}
#[cfg(feature = "ssr")]
impl<'a> TestScope<'a> {
    // fn new(stream: &mut TcpStream) -> TestScope<'_> {
    //     let (reader, writer) = stream.split();
    //     let reader = tokio::io::BufReader::new(reader);
    //     let buffer = vec![];
    //     TestScope {
    //         reader,
    //         writer,
    //         buffer,
    //     }
    // }
    //
    // async fn send_request() -> Result<()> {
    //     let resp = match reqwest::blocking::get("https://httpbin.org/ip") {
    //         Ok(resp) => resp.text().unwrap(),
    //         Err(err) => panic!("Error: {}", err)
    //     };
    //     println!("{}", resp);
    //     Ok(())
    // }
    //
    // async fn send(&mut self, str: &(impl AsRef<str> + ?Sized)) -> Result<()> {
    //     self.writer.write_all(str.as_ref().as_bytes()).await?;
    //     self.writer.write_all(b"\r\n").await?;
    //     self.writer.flush().await?;
    //     Ok(())
    // }

}
#[cfg(feature = "ssr")]
pub struct LavinaClient {
}
#[cfg(feature = "ssr")]
impl LavinaClient {
    // async fn connect(addr: &str, nickname: &str, password: &str, channel: &str) -> Result<()> {
    //     let mut stream = TcpStream::connect(addr).await?;
    //     let mut client: TestScope = TestScope::new(& mut stream);
    //
    //     client.send("PASS pwd").await?;
    //     client.send("NICK hello").await?;
    //     client.send("USER UserName 0 * :Real Name").await?;
    //     // client.send("JOIN #kek").await?;
    //
    //     Ok(())
    // }
    // // PASS pwd
    // // NICK hello
    // // USER UserName 0 * :Real Name
    // pub async fn connect_dummy() -> Result<()> {
    //     let server = "127.0.0.1:6667";
    //     let password = "parolchik1";
    //     let nickname = "kek";
    //     let channel = "kek";
    //
    //     let client = LavinaClient::connect(server, nickname, password, channel).await?;
    //
    //     Ok(())
    //     // let stdin = stdin();
    //     // let mut reader = BufReader::new(stdin);
    //     //
    //     // let mut input = String::new();
    //     //
    //     // loop {
    //     //     input.clear();
    //     //     reader.read_line(&mut input)?;
    //     //     client.send("PRIVMSG", &format!("#kek :{}", input.trim()))?;
    //     // }
    // }

    pub async fn new_player(name: &str, password: &str) -> () {
        let client = reqwest::Client::new();


        let mut create_query = std::collections::HashMap::new();
        create_query.insert("name", name);

        let crete_user = client.post("http://127.0.0.1:8080/mgmt/create_player")
            .json(&create_query).send().await;

        let mut create_query = std::collections::HashMap::new();
        create_query.insert("player_name", name);
        create_query.insert("password", password);

        let set_password = client.post("http://127.0.0.1:8080/mgmt/set_password")
            .json(&create_query).send().await;
    }


}