it is now possible to connect and create a player

src/main.rs

@@ -1,50 +1,65 @@
+use std::io::{self, Error};
+use std::net::SocketAddr;
+
+use crate::lobby::Lobby;
+use crate::player::Player;
+
 use anyhow::Result;
-use tokio::net::{TcpListener, TcpStream};
 use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use tokio::sync::broadcast;
+use tokio::net::{TcpListener, TcpStream};
 
 mod card;
 mod deck;
-mod player;
 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() -> Result<(), anyhow::Error> {
+async fn main() -> io::Result<()> {
     let address = "127.0.0.1:8080".to_string();
     let listener = TcpListener::bind(&address).await?;
 
-    let (tx, rx) = broadcast::channel::<String>(10);
+    let mut lobbies: Vec<Lobby> = Vec::new();
 
-    while let Ok((mut stream,_)) = listener.accept().await {
+    loop {
-        let tx = tx.clone();
+        let (mut stream, addr) = listener.accept().await?;
-        let mut rx = rx.resubscribe();
 
         tokio::spawn(async move {
-            let (read, mut write) = stream.split();
+            println!("new connection from: {}", addr);
-            let mut reader = BufReader::new(read);
+            let (player, lobby) = handle_connection(stream, addr).await;
-            let mut line = String::new();
-
-            loop {
-                tokio::select! {
-                    bytes_read = reader.read_line(&mut line) => {
-                        if bytes_read.unwrap() == 0 {
-                            println!("connection closed");
-                            return;
-                        }
-                        tx.send(line.clone()).unwrap();
-                    },
-                    msg = rx.recv() => {
-                        write.write_all(format!("> {}", msg.unwrap()).as_bytes()).await.expect("failed to write data");
-                        line.clear();
-                    }
-                }
-            }
         });
     }
 
     Ok(())
 }
-
-async fn spawn(mut stream: TcpStream) -> Result<(), anyhow::Error> {
-    todo!()
-}