feat: add server message loop

src/network/server.rs

@@ -1,5 +1,8 @@
 use log::{error, info};
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::{
+    collections::HashMap,
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+};
 use tokio::{
     net::{TcpListener, TcpStream},
     sync::mpsc::{Receiver, Sender},
@@ -9,7 +12,10 @@ use crate::{
     logic::game_master::GameMaster,
     network::{
         connection::{Connection, ConnectionType},
-        message::{ClientMessage, Message, ServerMessage},
+        message::{
+            ClientMessage::{self, AnswerHandshake, RequestCapture, RequestMove},
+            Message, ServerMessage,
+        },
     },
 };
 
@@ -22,9 +28,9 @@ pub struct ServerSettings {
 
 pub struct Server {
     listener: TcpListener,
-    connections: Vec<Connection<ClientMessage, ServerMessage>>,
-    reciever: Receiver<Message<ClientMessage>>,
-    sender: Sender<Message<ClientMessage>>,
+    connections: HashMap<SocketAddr, Sender<Message<ServerMessage>>>,
+    reciever: Receiver<(SocketAddr, Message<ClientMessage>)>,
+    sender: Sender<(SocketAddr, Message<ClientMessage>)>,
     game_master: Option<GameMaster>,
     settings: ServerSettings,
 }
@@ -38,7 +44,8 @@ impl Server {
             allow_spectators: false,
         };
 
-        let (sender, mut reciever) = tokio::sync::mpsc::channel::<Message<ClientMessage>>(1024); // random
+        let (sender, mut reciever) =
+            tokio::sync::mpsc::channel::<(SocketAddr, Message<ClientMessage>)>(1024); // random
         // number
 
         Server {
@@ -46,7 +53,7 @@ impl Server {
                 .await
                 .expect("Could not start the server"), // TODO! Handle this nicely, as this will
             // crash gui app
-            connections: vec![],
+            connections: HashMap::new(),
             sender,
             reciever,
             game_master: None,
@@ -80,13 +87,77 @@ impl Server {
             Connection::new(ConnectionType::Client, self.sender.clone());
 
         conn.delegate(socket, addr);
-        self.connections.push(conn);
+        let sender = conn.get_sender();
+
+        self.connections.insert(addr, sender);
+
+        self.listen_client(conn);
     }
 
-    fn request_handshake(&self) {
-        let conn = self.connections.last().unwrap();
-        info!("Requesting handshake from: {:?}", conn);
+    fn listen_client(&mut self, mut conn: Connection<ClientMessage, ServerMessage>) {
+        tokio::spawn(async move {
+            conn.start_listening().await;
+        });
+    }
 
+    /// Process incoming messages
+    pub async fn update(&mut self) {
+        let Some(oldest_message) = self.reciever.recv().await else {
+            return;
+        };
+
+        let (addr, msg) = oldest_message;
+
+        match msg.content {
+            ClientMessage::AnswerHandshake { player_name } => {
+                self.process_handshake();
+            }
+            ClientMessage::RequestCapture { capture_path } => {
+                self.process_capture();
+            }
+            ClientMessage::RequestMove { from, to } => {
+                self.process_move();
+            }
+        }
+    }
+
+    /* ======= Processing messages :D helper functions ======== */
+
+    fn process_handshake(&self) {
         todo!();
     }
+
+    fn process_capture(&self) {
+        todo!();
+    }
+
+    fn process_move(&self) {
+        todo!();
+    }
+
+    async fn request_handshake(&mut self, addr: SocketAddr) {
+        let msg = Message::new(ServerMessage::RequestHandshake);
+        self.send_message(addr, msg).await;
+    }
+
+    async fn send_message(
+        &mut self,
+        addr: SocketAddr,
+        msg: Result<Message<ServerMessage>, postcard::Error>,
+    ) {
+        let conn_opt = self.connections.get_mut(&addr);
+
+        let Some(conn) = conn_opt else {
+            error!("Could not get connection from connections list");
+            return;
+        };
+
+        let _ = match msg {
+            Err(e) => {
+                error!("There was an error while creating message: {}", e);
+                return;
+            }
+            Ok(msg) => conn.send(msg).await,
+        };
+    }
 }