use ewebsock::WsEvent;
use macroquad::prelude::{error, info};

use crate::model::{ClientMessage, ClientRequest, GameResponse};

pub struct Context {
    pub sender: ewebsock::WsSender,
    pub reciever: ewebsock::WsReceiver,
    pub token: String,
    pub username: String,
}

impl Context {
    pub fn new(url: &str) -> Context {
        let (sender, reciever) = ewebsock::connect(url, ewebsock::Options::default()).unwrap();

        Self {
            sender,
            reciever,
            token: String::new(),
            username: String::new(),
        }
    }

    pub fn send_msg(&mut self, msg: &ClientMessage) {
        let request = ClientRequest {
            token: self.token.clone(),
            msg: msg.clone(),
        };
        let msg = serde_json::to_string(&request).unwrap();
        self.sender.send(ewebsock::WsMessage::Text(msg));
    }

    pub fn recv_msg(&mut self) -> Option<GameResponse> {
        if let Some(msg) = self.reciever.try_recv() {
            match msg {
                WsEvent::Opened => {
                    info!("Web socket opened!");
                    None
                }
                WsEvent::Message(ws_message) => match ws_message {
                    ewebsock::WsMessage::Text(msg) => {
                        let game_resp: GameResponse = serde_json::from_str(&msg).unwrap();

                        if let GameResponse::JoinResponse { username, token } = &game_resp {
                            self.username = username.clone();
                            self.token = token.clone();
                        }

                        Some(game_resp)
                    }
                    _ => None,
                },
                WsEvent::Error(err) => {
                    error!("Something hecky going on: {}", err);
                    None
                }
                WsEvent::Closed => {
                    panic!("Socket closed, something up...");
                }
            }
        } else {
            None
        }
    }
}