player gets added to lobby upon lobby creation

src/client.rs

@@ -1,13 +1,12 @@
 use anyhow::Result;
-use ratatui::DefaultTerminal;
+use ratatui::{widgets::ListState, DefaultTerminal};
 
-use crate::{message::{Message, MessageKind}, player::Player, ui::{ui, CurrentScreen}};
+use crate::{lobby::Lobby, message::{Message, MessageKind}, player::Player, ui::{ui, CurrentScreen}};
 
 #[derive(Debug, Default)]
 pub struct Client {
     pub addr: String,
     pub client: reqwest::Client,
-    pub current_screen: CurrentScreen,
     pub user: Option<String>,
     pub user_name: String,
     pub exit: bool,

src/lobby.rs

@@ -23,7 +23,7 @@ impl Lobby {
         }
     }
 
-    pub fn join_lobby(mut self, player: Player) {
+    pub fn join_lobby(&mut self, player: Player) {
         self.players.push(player);
     }
 

src/message.rs

@@ -19,6 +19,7 @@ pub enum MessageKind {
     DeleteLobby,
     JoinLobby,
     QuitLobby,
+    GetLobbies,
 }
 
 impl Message {

src/router.rs

@@ -34,7 +34,7 @@ impl App {
     pub async fn create_player(
         State(db): State<AppState>,
         json_body: Result<Json<Message>, JsonRejection>,
-    ) -> Result<axum::Json<Message>, StatusCode> {
+    ) -> Result<axum::Json<Message>, String> {
         match json_body {
             Ok(Json(message)) => {
                 println!("{:?}", message);
@@ -44,7 +44,7 @@ impl App {
                     .lock().expect("ciao");
 
                 if players.contains_key(&player.name) {
-                    return Err(StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS)
+                    return Err(String::from("player already in db"))
                 }
 
                 players.insert(
@@ -55,42 +55,57 @@ impl App {
 
                 Ok(Json(Message::new("server", MessageKind::CreatePlayer, &player.name).expect("failed creating message")))
             }
-            Err(_) => Err(StatusCode::UNPROCESSABLE_ENTITY)
+            Err(_) => Err(String::from("failed parsing json message"))
         }
     }
 
     pub async fn create_lobby(
         State(db): State<AppState>,
         json_body: Result<Json<Message>, JsonRejection>,
-    ) -> Result<axum::Json<Message>, StatusCode> {
+    ) -> Result<axum::Json<Message>, String> {
         match json_body {
             Ok(Json(message)) => {
                 println!("{:?}", message);
-                let lobby: Lobby = Lobby::new();
+                let mut lobby: Lobby = Lobby::new();
                 
                 let mut lobbies = db.lobbies
-                    .lock().expect("ciao");
+                    .lock()
+                    .expect("failed to lock lobbies db");
 
                 if lobbies.contains_key(&lobby.id) {
-                    return Err(StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS)
+                    return Err(String::from("lobby already in db"))
                 }
 
+                let players = db.players
+                    .lock()
+                    .expect("failed to lock player db");
+
+                let player_bytes = players.get(&message.content);
+
+                let player: Player = if let None = player_bytes {
+                    return Err(String::from("player not found or not yet created"));
+                } else {
+                    Player::from(serde_json::from_slice(player_bytes.unwrap()).expect("failed"))
+                };
+
+                lobby.join_lobby(player);
+
                 lobbies.insert(
                     lobby.get_id(),
-                    Bytes::copy_from_slice(lobby.encode().expect(&StatusCode::EXPECTATION_FAILED.to_string()).as_ref())
+                    Bytes::copy_from_slice(lobby.encode().expect("failed copying lobby from bytes slice").as_ref())
                 );
                 println!("{:?}", lobbies);
 
                 Ok(Json(Message::new("server", MessageKind::CreateLobby, &lobby.id).expect("failed creating message")))
             },
-            Err(_) => Err(StatusCode::UNPROCESSABLE_ENTITY),
+            Err(_) => Err(String::from("failed to parse json message")),
         }
     }
 
     pub async fn delete_player(
         State(db): State<AppState>,
         Path(player_id): Path<String>
-    ) -> Result<axum::response::Json<Message>, StatusCode> {
+    ) -> Result<axum::response::Json<Message>, String> {
         {
             let mut players = db.players
                 .lock().expect("ciao");
@@ -101,7 +116,7 @@ impl App {
                     println!("{:?}", players);
                     Ok(Json(Message::new("server", MessageKind::DeletePlayer, "user deleted").expect("a")))
                 },
-                false => Err(StatusCode::NOT_FOUND),
+                false => Err(String::from("player not found")),
             }
         }
       
@@ -110,7 +125,7 @@ impl App {
     pub async fn delete_lobby(
         State(db): State<AppState>,
         Path(lobby_id): Path<String>
-    ) -> Result<axum::response::Json<Message>, StatusCode> {
+    ) -> Result<axum::response::Json<Message>, String> {
         {
             let mut lobbies = db.lobbies
                 .lock().expect("ciao");
@@ -121,7 +136,7 @@ impl App {
                     println!("{:?}", lobbies);
                     Ok(Json(Message::new("server", MessageKind::DeleteLobby, "lobby deleted").expect("a")))
                 },
-                false => Err(StatusCode::NOT_FOUND),
+                false => Err(String::from("lobby not found in db")),
             }
         }
       
@@ -130,7 +145,8 @@ impl App {
     pub async fn join_lobby(
         State(db): State<AppState>,
         Path(lobby_id): Path<String>
-    ) -> Result<axum::response::Json<Message>, StatusCode> {
+    ) -> Result<axum::response::Json<Message>, String> {
         todo!()
     }
+
 }

src/ui.rs

@@ -8,7 +8,7 @@ use ratatui::{
     },
     style::{Color, Style, Stylize},
     text::{Line, Span, Text},
-    widgets::{Block, Borders, Clear, List, ListItem, Paragraph, Widget, Wrap},
+    widgets::{Block, Borders, Clear, List, ListItem, ListState, Paragraph, Widget, Wrap},
     Frame,
 };
 use ratatui::crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind};
@@ -57,14 +57,12 @@ impl Widget for Popup<'_> {
 #[derive(Debug, Default)]
 pub enum CurrentScreen {
     #[default] Menu,
-    LobbyList,
+    Lobbies,
 }
 
 async fn handle_key_event(mut client: &mut Client, key_event: KeyEvent) {
     match &client.popup {
         false => {
-            match client.current_screen {
-                CurrentScreen::Menu => {
             match key_event.code {
                 KeyCode::Char('q') => Client::exit(client),
                 KeyCode::Char('h') => {
@@ -91,9 +89,9 @@ async fn handle_key_event(mut client: &mut Client, key_event: KeyEvent) {
                     }
                 },
                 KeyCode::Char('2') => {
-                            if client.lobby != None {
+                    if client.lobby != None || client.user == None {
                         client.popup_title = "Error".to_string();
-                                client.popup_content = "lobby already_created".to_string();
+                        client.popup_content = "lobby already_created or player not yet created".to_string();
                         client.popup = true;
                     } else {
                         let addr = client.addr.clone();
@@ -101,7 +99,7 @@ async fn handle_key_event(mut client: &mut Client, key_event: KeyEvent) {
                         let message = Message::new(
                             "",
                             MessageKind::CreateLobby,
-                                    ""
+                            &client.user_name,
                         ).unwrap();
 
                         Client::send(&mut client, message, &addr, &path).await.unwrap();
@@ -111,9 +109,6 @@ async fn handle_key_event(mut client: &mut Client, key_event: KeyEvent) {
                 _ => (),
             }
         }
-                CurrentScreen::LobbyList => todo!(),
-            }
-        }
         true => {
             match key_event.code {
                 _ => client.popup = false,
@@ -134,9 +129,6 @@ pub async fn handle_events(client: &mut Client) -> anyhow::Result<()> {
 }
 
 pub fn ui(frame: &mut Frame, app: &Client) {
-    match app.current_screen {
-        CurrentScreen::Menu => {
-            
     let chunks = Layout::default()
         .direction(Direction::Vertical)
         .constraints([
@@ -195,9 +187,6 @@ pub fn ui(frame: &mut Frame, app: &Client) {
             .block(btm_block),
         chunks[1],
     );
-        }
-        CurrentScreen::LobbyList => todo!(),
-    }
 
     let popup_area = Rect {
         x: frame.area().width / 4,