cards/server/src/game_handler.rs

use crate::user_handler::*;
use crate::AppState;
use crate::Game;
use crate::NewGameManifest;
use crate::NewGameRequest;
use crate::User;
use lib::*;
use std::net::SocketAddr;
use std::sync::{Arc, RwLock};

// This file is disgusting, don't look at it

pub enum GameHandlerMessage {
    NewGame {
        addr: SocketAddr,
        new_game: NewGameRequest,
    },
    JoinGame {
        user: Arc<User>,
        game_name: String,
    },
}
pub struct GameHandler {
    state: Arc<AppState>,
}

impl GameHandler {
    pub fn new(state: Arc<AppState>) -> Self {
        GameHandler { state }
    }

    pub async fn handle(&self, message: GameHandlerMessage) {
        match message {
            GameHandlerMessage::NewGame { addr, new_game } => self.new_game(addr, new_game).await,
            _ => {
                tracing::debug!("Unhandled at game handler");
            }
        }
    }

    async fn new_game(&self, addr: SocketAddr, new_game: NewGameRequest) {
        if new_game.packs.is_empty() {
            tracing::debug!("Cards are empty");
            return;
        } else if new_game.name.is_empty() {
            tracing::debug!("Name are empty");
            return;
        }

        let manifest = NewGameManifest {
            name: new_game.name,
            host: self
                .state
                .online_users
                .read()
                .unwrap()
                .get(&addr)
                .unwrap()
                .clone(),
        };
        tracing::debug!("Game Packs {:?}", new_game.packs);

        // create game
        if let Ok(new_game_object) = Game::new(manifest) {
            let tx = self
                .state
                .online_users
                .read()
                .unwrap()
                .get(&addr)
                .unwrap()
                .read()
                .unwrap()
                .tx
                .clone();

            tracing::debug!("{:#?}", &new_game_object);

            let mut black_text = "Error".to_string();
            if let Some(ref current_black) = new_game_object.current_black {
                black_text = current_black.text.to_owned()
            }

            tracing::debug!("{:#?}", &new_game_object.white);

            let meta = GameMeta {
                name: new_game_object.name.clone(),
                host: new_game_object.host.read().unwrap().name.clone(),
                players: new_game_object
                    .players
                    .iter()
                    .map(|player| {
                        self.state
                            .user_uuid
                            .read()
                            .unwrap()
                            .get(&player.0)
                            .unwrap()
                            .read()
                            .unwrap()
                            .name
                            .clone()
                    })
                    .collect(),
                czar: new_game_object.host.read().unwrap().name.clone(),
                black: black_text,
                white: new_game_object
                    .players
                    .get(&new_game_object.host.read().unwrap().uuid)
                    .unwrap()
                    .white
                    .iter()
                    .map(|card| card.text.clone())
                    .collect(),
            };

            tracing::debug!("{:#?}", &meta);
            tx.send(serde_json::to_string(&meta).unwrap())
                .await
                .unwrap();
            self.state.games.write().unwrap().insert(
                new_game_object.name.clone(),
                Arc::new(RwLock::new(new_game_object)),
            );
            self.state
                .broadcast_tx
                .send(meta_games_browser_update(&self.state))
                .unwrap();
            self.state
                .broadcast_tx
                .send(meta_server_summary_update(&self.state))
                .unwrap();
        }
    }
}