non async code

i found out that async code would be better, so saved this code i might see this in future maybe :)

src/main.rs

@@ -1,46 +1,105 @@
-use std::{net::TcpListener, thread::spawn};
-
-use tungstenite::{accept, protocol::{frame::coding::CloseCode, CloseFrame}, Message};
+use std::{collections::HashMap, net::TcpListener, sync::{mpsc::{channel, Receiver, Sender}, Arc, Mutex}, thread::spawn};
+use tungstenite::{accept, Message};
 
 fn main() {
+    let mut connection_count: usize = 0;
+    let senders = Arc::new(Mutex::new(HashMap::<usize, Sender<Arc<Message>>>::new()));
+
     let server = TcpListener::bind("0.0.0.0:9001").unwrap();
     for stream in server.incoming() {
+
+        let t_senders = Arc::clone(&senders);
+        let (sender, receiver): (Sender<Arc<Message>>, Receiver<Arc<Message>>) = channel();
+        {
+            let mut sender_lock = t_senders.lock().unwrap();
+            connection_count += 1;
+            (*sender_lock).insert(connection_count, sender);
+        }
+        let websocket = Arc::new(Mutex::new(accept(stream.unwrap()).unwrap()));
+
+        let r_websocket = Arc::clone(&websocket);
         spawn(move || {
-            let mut websocket = accept(stream.unwrap()).unwrap();
-            println!("Connection Received");
+            let id = connection_count;
+            println!("Connection Received: {}", id);
             loop {
-                let res = websocket.read();
-
+                let res = {
+                    let mut wssocket_lock = r_websocket.lock().unwrap();
+                    (*wssocket_lock).read()
+                };
                 match res {
-                    Ok(Message::Text(txtmsg)) => {
-                        println!("received: {}", txtmsg);
-                        let strmsg = format!("i shall send this back to you {}", txtmsg.to_string());
-                        websocket.send(Message::text(strmsg)).unwrap();
-
-                    }
-                    Ok(Message::Close(_)) => {
-                        match websocket.send(Message::Close(Some(CloseFrame{
-                            code: CloseCode::Normal,
-                            reason: "Connection Closed :)".into()
-                        }))) {
-                            Ok(_) => println!("Close frame sent succesfully"),
-                            Err(e) => println!("Failed to send close frame (connection may already be closed): {}", e)
-                        };
-                        println!("closing connection");
-                        break;
+                    // Ok(Message::Close(_)) => {
+                    //     let mut t_sender_lock = t_senders.lock().unwrap();
+                    //     (*t_sender_lock).remove(&id);
+                    //     match (*wssocket_lock).send(Message::Close(Some(CloseFrame{
+                    //         code: CloseCode::Normal,
+                    //         reason: "Connection Closed :)".into()
+                    //     }))) {
+                    //         Ok(_) => println!("Close frame sent succesfully"),
+                    //         Err(e) => println!("Failed to send close frame (connection may already be closed): {}", e)
+                    //     };
+                    //     println!("closing connection");
+                    //     break;
+                    // }
+                    Ok(msg) => {
+                        let arc_msg = Arc::new(msg);
+                        if arc_msg.is_close() {
+                            let t_sender_lock = t_senders.lock().unwrap();
+                            let arc_msg_clone = Arc::clone(&arc_msg);
+                            match (*t_sender_lock).get(&id).unwrap().send(arc_msg_clone) {
+                                Ok(_) => println!("close message sent to thread no {}", id),
+                                Err(e) => println!("My Error: {}", e)
+                            }
+                            break;
+                        }
+                        else if arc_msg.is_text() || arc_msg.is_binary() {
+                            let t_sender_lock = t_senders.lock().unwrap();
+                            for (iter_id, sender) in (*t_sender_lock).iter() {
+                                let arc_msg_clone = Arc::clone(&arc_msg);
+                                if *iter_id != id {
+                                    match (*sender).send(arc_msg_clone) {
+                                        Ok(_) => println!("message sent to thread no {}", *iter_id),
+                                        Err(e) => println!("My Error: {}", e)
+                                    }
+                                }
+                            }
+                        }
                     }
                     Err(e) => {
+                        let mut t_sender_lock = t_senders.lock().unwrap();
+                        (*t_sender_lock).remove(&id);
                         println!("MyError Occured: {}", e);
+                        println!("Connection Closed");
                         break;
                     }
-                    _ => {
-                        println!("not handled");
-                    },
-                }
 
+                }
 
             }
 
         });
+
+        let s_websocket = Arc::clone(&websocket);
+        spawn(move || {
+            let id = connection_count;
+            loop {
+                match receiver.recv() {
+                    Ok(arc_msg) => {
+                        println!("Message received by thread {}", id);
+                        println!("The message is {}", arc_msg);
+                        let mut wssocket_lock = s_websocket.lock().unwrap();
+                        println!("Lock acquired");
+                        let msg = (*arc_msg).clone();
+                        //TODO add match for this
+                        let _ = (*wssocket_lock).send(msg);
+                        println!("message sent to client {}", id);
+                    }
+                    Err(e) => {
+                        println!("Error in receiving from other threads: {}", e);
+                        break;
+                    }
+                }
+            }
+        });
+
     }
 }