3 files changed, 31 insertions, 14 deletions

diff --git a/mumd/src/command.rs b/mumd/src/command.rs
index 8a5c715..0e5bdc7 100644
--- a/mumd/src/command.rs
+++ b/mumd/src/command.rs
@@ -27,7 +27,7 @@ pub enum CommandResponse {
         channels: HashMap<u32, Channel>,
     },
     Status {
-        username: String,
+        username: Option<String>,
         server_state: Server,
     }
 }
@@ -41,11 +41,12 @@ pub async fn handle(
     while let Some(command) = command_receiver.recv().await {
         debug!("Parsing command {:?}", command);
         let mut state = state.lock().unwrap();
-        let (wait_for_connected, _) = state.handle_command(command).await;
+        let (wait_for_connected, command_response) = state.handle_command(command).await;
         if wait_for_connected {
             let mut watcher = state.phase_receiver();
             drop(state);
             while !matches!(watcher.recv().await.unwrap(), StatePhase::Connected) {}
         }
+        command_response_sender.send(command_response).unwrap();
     }
 }
diff --git a/mumd/src/main.rs b/mumd/src/main.rs
index 93bb0d0..24c2567 100644
--- a/mumd/src/main.rs
+++ b/mumd/src/main.rs
@@ -76,9 +76,10 @@ async fn main() {
     let (command_response_sender, command_response_receiver) = mpsc::unbounded_channel::<Result<Option<CommandResponse>, ()>>();
     let (connection_info_sender, connection_info_receiver) = watch::channel::<Option<ConnectionInfo>>(None);
 
+    command_sender.send(Command::ChannelList).unwrap();
     command_sender.send(Command::ServerConnect{host: server_host, port: server_port, username: username.clone(), accept_invalid_cert});
-
     command_sender.send(Command::ChannelJoin{channel_id: 1}).unwrap();
+    command_sender.send(Command::ChannelList).unwrap();
     let state = State::new(packet_sender, command_sender.clone(), connection_info_sender, username);
     let state = Arc::new(Mutex::new(state));
 
@@ -100,16 +101,16 @@ async fn main() {
             command_receiver,
             command_response_sender,
         ),
-        send_commands(
-            command_sender,
+        receive_command_responses(
             command_response_receiver,
         ),
     );
 }
 
-async fn send_commands(
-    command_sender: mpsc::UnboundedSender<Command>,
-    command_response_receiver: mpsc::UnboundedReceiver<Result<Option<CommandResponse>, ()>>,
+async fn receive_command_responses(
+    mut command_response_receiver: mpsc::UnboundedReceiver<Result<Option<CommandResponse>, ()>>,
 ) {
-
+    while let Some(command_response) = command_response_receiver.recv().await {
+        debug!("{:#?}", command_response);
+    }
 }
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 84e78f0..ef1cd6d 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -50,11 +50,12 @@ impl State {
         }
     }
 
+    //TODO? move bool inside Result
     pub async fn handle_command(&mut self, command: Command) -> (bool, Result<Option<CommandResponse>, ()>) {
         match command {
             Command::ChannelJoin{channel_id} => {
-                if self.session_id.is_none() {
-                    warn!("Tried to join channel but we don't have a session id");
+                if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
+                    warn!("Not connected");
                     return (false, Err(()));
                 }
                 let mut msg = msgs::UserState::new();
@@ -64,6 +65,10 @@ impl State {
                 (false, Ok(None))
             }
             Command::ChannelList => {
+                if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
+                    warn!("Not connected");
+                    return (false, Err(()));
+                }
                 (false, Ok(Some(CommandResponse::ChannelList{channels: self.server.channels.clone()})))
             }
             Command::ServerConnect{host, port, username, accept_invalid_cert} => {
@@ -85,7 +90,17 @@ impl State {
                 )));
                 (true, Ok(None))
             }
-            _ => { (true, Ok(None)) }
+            Command::Status => {
+                if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
+                    warn!("Not connected");
+                    return (false, Err(()));
+                }
+                (false, Ok(Some(CommandResponse::Status{
+                    username: self.username.clone(),
+                    server_state: self.server.clone(),
+                })))
+            }
+            _ => { (false, Ok(None)) }
         }
     }
 
@@ -130,7 +145,7 @@ impl State {
     pub fn username(&self) -> Option<&String> { self.username.as_ref() }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Server {
     channels: HashMap<u32, Channel>,
     users: HashMap<u32, User>,
@@ -248,7 +263,7 @@ impl Channel {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct User {
     channel: u32,
     comment: Option<String>,