feat: add missing message handlers

src/server.rs

@@ -1,20 +1,27 @@
+use crate::client::ClientOperation;
 use crate::dispatcher::MessageDispatcher;
-use crate::message::factory::{build_init_message, build_login_message};
-use crate::message::{Message, MessageReader};
+use crate::message::server::MessageFactory;
+use crate::message::Handlers;
+use crate::message::Message;
+use crate::message::MessageReader;
+use crate::peer::listen::Listen;
+use crate::peer::peer::Peer;
+
 use std::io::{self, Write};
 use std::net::{TcpStream, ToSocketAddrs};
 use std::sync::mpsc;
 use std::sync::mpsc::{Receiver, Sender};
 use std::sync::{Arc, Barrier, Mutex};
 use std::thread::{self};
-use std::time::Duration;
+use std::time::{Duration, Instant};
+
 #[derive(Debug, Clone)]
-pub struct ServerAddress {
+pub struct PeerAddress {
     host: String,
     port: u16,
 }
 
-impl ServerAddress {
+impl PeerAddress {
     pub fn new(host: String, port: u16) -> Self {
         Self { host, port }
     }
@@ -30,26 +37,61 @@ impl ServerAddress {
 
 #[derive(Debug)]
 pub struct Context {
-    message_sender: Arc<Mutex<Sender<Message>>>,
+    pub logged_in: Option<bool>,
+    #[allow(dead_code)]
     rooms: Rooms,
 }
 
 impl Context {
-    pub fn new(message_sender: Arc<Mutex<Sender<Message>>>) -> Self {
+    pub fn new() -> Self {
         Self {
-            message_sender,
+            #[allow(dead_code)]
             rooms: Rooms::new(),
+            logged_in: Option::None,
         }
     }
-    pub fn get_rooms(&mut self) -> &mut Rooms {
-        &mut self.rooms
-    }
 
-    pub fn queue_message(&self, message: Message) {
-        self.message_sender.lock().unwrap().send(message).unwrap();
+    // pub fn get_messages_for_user(&self, username: String) -> Option<&UserMessage> {
+    //     self.user_messages.get(&username)
+    // }
+    //
+    // pub fn get_rooms(&mut self) -> &mut Rooms {
+    //     &mut self.rooms
+    // }
+}
+#[derive(Debug, Clone)]
+pub struct UserMessage {
+    id: i32,
+    timestamp: i32,
+    username: String,
+    message: String,
+    new_message: bool,
+}
+impl UserMessage {
+    pub fn new(
+        id: i32,
+        timestamp: i32,
+        username: String,
+        message: String,
+        new_message: bool,
+    ) -> Self {
+        Self {
+            id,
+            timestamp,
+            username,
+            message,
+            new_message,
+        }
+    }
+    pub fn print(&self) {
+        println!(
+            "Timestamp: {}. User: {}, Id: #{}, New message: {} Message: {}",
+            self.timestamp, self.username, self.id, self.new_message, self.message
+        );
     }
 }
 
+#[allow(dead_code)]
 #[derive(Debug)]
 pub struct Rooms {
     pub public_rooms: Vec<Room>,
@@ -66,6 +108,8 @@ impl Rooms {
             operated_private_rooms: Vec::new(),
         }
     }
+
+    #[allow(dead_code)]
     pub fn print(&self) {
         println!("Public rooms ({}):", self.public_rooms.len());
         for room in &self.public_rooms {
@@ -94,12 +138,14 @@ pub struct Room {
     number_of_users: i32,
 }
 impl Room {
+    #[allow(dead_code)]
     pub fn new(name: String, number_of_users: i32) -> Self {
         Self {
             name,
             number_of_users,
         }
     }
+    #[allow(dead_code)]
     pub fn set_number_of_users(&mut self, number_of_users: i32) {
         self.number_of_users = number_of_users;
     }
@@ -109,42 +155,52 @@ impl Room {
             self.name, self.number_of_users
         );
     }
-
-    // pub fn get_name(&self) -> &str {
-    //     &self.name
-    // }
-    // pub fn get_number_of_users(&self) -> i32 {
-    //     self.number_of_users
-    // }
 }
 
+pub enum ServerOperation {
+    LoginStatus(bool),
+    SendMessage(Message),
+    #[allow(dead_code)]
+    ConnectToPeer(Peer),
+}
+
+#[derive(Debug)]
 pub struct Server {
-    address: ServerAddress,
+    address: PeerAddress,
+    sender: Sender<ServerOperation>,
     context: Arc<Mutex<Context>>,
 }
 impl Server {
     /// Create a new instance of Server, returning a Result
-    pub fn new(address: ServerAddress) -> Result<Self, io::Error> {
-        let (message_sender, message_reader): (Sender<Message>, Receiver<Message>) =
+    pub fn new(
+        address: PeerAddress,
+        client_channel: Sender<ClientOperation>,
+    ) -> Result<Self, io::Error> {
+        let (sender, server_channel): (Sender<ServerOperation>, Receiver<ServerOperation>) =
             mpsc::channel();
 
-        let context = Arc::new(Mutex::new(Context::new(Arc::new(Mutex::new(
-            message_sender,
-        )))));
+        let context = Arc::new(Mutex::new(Context::new()));
 
-        let server = Self { address, context };
-
-        server.start_read_write_loops(message_reader)?;
+        let mut server = Self {
+            address,
+            context,
+            sender,
+        };
 
+        server.start_read_write_loops(server_channel, client_channel)?;
         Ok(server)
     }
 
-    pub fn get_address(&self) -> &ServerAddress {
+    pub fn get_address(&self) -> &PeerAddress {
         &self.address
     }
 
     /// Start reading and writing loops in separate threads
-    fn start_read_write_loops(&self, message_reader: Receiver<Message>) -> Result<(), io::Error> {
+    fn start_read_write_loops(
+        &mut self,
+        server_channel: Receiver<ServerOperation>,
+        client_channel: Sender<ClientOperation>,
+    ) -> Result<(), io::Error> {
         let socket_address = format!("{}:{}", self.address.host, self.address.port)
             .to_socket_addrs()?
             .next()
@@ -163,15 +219,16 @@ impl Server {
         let mut read_stream = stream.try_clone()?;
         let mut write_stream = stream.try_clone()?;
 
-        let barrier = Arc::new(Barrier::new(2));
+        let barrier = Arc::new(Barrier::new(3));
         let read_barrier = barrier.clone();
         let write_barrier = barrier.clone();
-
-        let dispatcher = MessageDispatcher::new(Arc::clone(&self.context));
+        let done_barrier = barrier.clone();
+        let sender = self.sender.clone();
 
         thread::spawn(move || {
             read_barrier.wait();
-
+            let message_handlers = Handlers::new_with_server_handlers();
+            let dispatcher = MessageDispatcher::new(sender, message_handlers);
             let mut buffered_reader = MessageReader::new();
             loop {
                 match buffered_reader.read_from_socket(&mut read_stream) {
@@ -190,7 +247,9 @@ impl Server {
 
                 match buffered_reader.extract_message() {
                     Ok(Some(mut message)) => {
-                        println!("Received message: {:?}", message.get_data());
+                        // println!("Received message: {:?}", message.get_message_code_u32());
+                        // message.print_hex();
+
                         dispatcher.dispatch(&mut message)
                     }
                     Err(e) => {
@@ -201,31 +260,96 @@ impl Server {
             }
         });
 
+        // let monitor_handle = thread::spawn(move || loop {
+        //     thread::sleep(Duration::from_secs(1));
+        //     println!("Stream state: connected={}", stream.peer_addr().is_ok());
+        // });
+        let context = self.context.clone();
         thread::spawn(move || {
             write_barrier.wait();
-
             loop {
-                let message = message_reader.recv().unwrap();
-                println!("Sending message from queue: {:?}", message); // Debug log when sending
-                match write_stream.write_all(&message.get_data()) {
-                    Ok(_) => println!("Sent buffered message: {:?}", message),
-                    Err(e) => {
-                        eprintln!("Failed to send buffered message: {}", e);
-                        break;
+                if let Ok(operation) = server_channel.recv() {
+                    match operation {
+                        ServerOperation::ConnectToPeer(peer) => {
+                            match client_channel.send(ClientOperation::ConnectToPeer(peer)) {
+                                Ok(_) => {}
+                                Err(e) => {
+                                    println!("Error sending message: {}", e);
+                                }
+                            }
+                        }
+                        ServerOperation::LoginStatus(message) => {
+                            context.lock().unwrap().logged_in = Some(message);
+                        }
+                        ServerOperation::SendMessage(message) => {
+                            // message.decode();
+                            // message.print_hex2();
+                            match write_stream.write_all(&message.get_buffer()) {
+                                Ok(_) => {}
+                                Err(e) => {
+                                    eprintln!("Error writing message to stream : {}", e);
+                                    break;
+                                }
+                            }
+                        }
                     }
                 }
             }
         });
+        done_barrier.wait();
         Ok(())
     }
 
     fn queue_message(&self, message: Message) {
-        self.context.lock().unwrap().queue_message(message);
+        match self.sender.send(ServerOperation::SendMessage(message)) {
+            Ok(_) => {}
+            Err(e) => println!("Failed to send: {}", e),
+        }
+    }
+    fn start_listener(&self) {
+        thread::spawn(move || Listen::new(2234));
     }
 
-    pub fn login(&mut self, username: &str, password: &str) -> Result<(), std::io::Error> {
-        self.queue_message(build_init_message());
-        self.queue_message(build_login_message(username, password));
-        Ok(())
+    pub fn login(&self, username: &str, password: &str) -> Result<bool, std::io::Error> {
+        self.start_listener();
+        // Send the login message
+        self.queue_message(MessageFactory::build_login_message(username, password));
+        let context = self.context.clone();
+        let mut logged_in;
+        let timeout = Duration::from_secs(5);
+        let start = Instant::now();
+
+        // wait till server says your logged in or not
+        loop {
+            if start.elapsed() > timeout {
+                println!("Timeout waiting for login response");
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::TimedOut,
+                    "Timeout waiting for login response",
+                ));
+            }
+
+            {
+                logged_in = context.lock().unwrap().logged_in.clone()
+            }
+
+            if !logged_in.is_none() {
+                break;
+            }
+        }
+
+        if logged_in.unwrap() {
+            println!("Logged in as {}", username);
+            self.queue_message(MessageFactory::build_set_wait_port_message());
+            self.queue_message(MessageFactory::build_shared_folders_message(1, 1));
+            self.queue_message(MessageFactory::build_no_parent_message());
+            self.queue_message(MessageFactory::build_set_status_message(2));
+        }
+
+        Ok(logged_in.unwrap())
+    }
+
+    pub fn file_search(&self, token: i32, query: &str) {
+        self.queue_message(MessageFactory::build_file_search_message(token, query));
     }
 }