use std::io::{self, Error};
use std::net::SocketAddr;

use crate::lobby::Lobby;
use crate::player::Player;

use anyhow::Result;
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
use tokio::net::{TcpListener, TcpStream};

mod card;
mod deck;
mod lobby;
mod player;

async fn handle_connection(mut stream: TcpStream, addr: SocketAddr) -> (Option<Player>, Option<Lobby>) {
    let (mut read, mut write) = stream.split();

    let mut buf = [0; 1024];

    let mut name = String::new();
    write.write_all(b"provide name\n").await.expect("failed to write to socket");

    let n = match read.read(&mut buf).await {
        Ok(0) => return (None, None),
        Ok(n) => n,
        Err(e) => {
            eprintln!("failed to read from socket; err: {:?}", e);
            return (None, None);
        },
    };

    name = String::from_utf8_lossy(&buf[0..n]).to_string();

//    if let Err(e) = write.write_all(&buf[0..n]).await {
//        eprintln!("failed to write to socket; err = {:?}", e);
//        return (None, None);
//    }

    let player = Player::new(addr, &name);

    write.write_all(b"your name is\n").await.expect("failed to write to socket");
    write.write_all(name.as_bytes()).await.expect("failed to write to socket");

    (Some(player), None)
}

#[tokio::main]
async fn main() -> io::Result<()> {
    let address = "127.0.0.1:8080".to_string();
    let listener = TcpListener::bind(&address).await?;

    let mut lobbies: Vec<Lobby> = Vec::new();

    loop {
        let (mut stream, addr) = listener.accept().await?;

        tokio::spawn(async move {
            println!("new connection from: {}", addr);
            let (player, lobby) = handle_connection(stream, addr).await;
        });
    }

    Ok(())
}