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};

/// Handle incoming messages over the WebSocket

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) {
            tracing::debug!("{:#?}", &new_game_object);
            let tx = self
                .state
                .online_users
                .read()
                .unwrap()
                .get(&addr)
                .unwrap()
                .read()
                .unwrap()
                .tx
                .clone();

            tx.send(
                serde_json::to_string(&GameMeta {
                    name: new_game_object.name.clone(),
                    // host: new_game_object.host.read().unwrap().name.clone(),
                    // players: new_game_object
                    //     .players
                    //     .iter()
                    //     .map(|player| player.user.read().unwrap().name)
                    //     .collect(),
                    // czar: new_game_object.host.read().unwrap().name.clone(),
                    // black: new_game_object
                    //     .current_black
                    //     .clone()
                    //     .unwrap()
                    //     .text
                    //     .clone()
                    //     .to_string()
                    //     .clone(),
                    // white: new_game_object.white.iter().map(|card| card.text).collect(),
                })
                .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();
        }
    }
}