shiritori/src/server.rs

use crate::dictionary::lookup;

use simple_websockets::{Event, Responder, Message, EventHub};
use std::collections::HashMap;
use serde::Serialize;
use wana_kana::{ConvertJapanese, IsJapaneseStr};

#[derive(Serialize)]
struct MessageResponse {
    event: String,
    data: MessageResponseData,
}

impl MessageResponse {
    fn to_message(&self) -> Message {
        Message::Text(serde_json::to_string(&self).unwrap())
    }
}

#[derive(Serialize)]
#[serde(untagged)]
enum MessageResponseData {
    Greeting {
        id: u64,
    },
    Word {
        author: u64,
        word: String,
        reading: Option<String>,
        next_char: char,
    },
    PlayerCount {
        players: u64,
    },
    Error {
        message: String,
    },
}

impl MessageResponseData {
    fn get_name(&self) -> String {
        String::from(match self {
            Self::Greeting { .. } => "greeting",
            Self::Word { .. } => "word",
            Self::PlayerCount { .. } => "playerCount",
            Self::Error { .. } => "error",
        })
    }

    fn to_response(self) -> MessageResponse {
        MessageResponse {
            event: self.get_name(),
            data: self,
        }
    }

    fn to_message(self) -> Message {
        self.to_response().to_message()
    }
}

pub struct Server {
    event_hub: EventHub,
    clients: HashMap<u64, Responder>,
    next_char: Option<char>,
    last_response: Option<MessageResponse>,
    last_client_id: Option<u64>,
}

impl Server {
    pub fn new(port: u16) -> Result<Self, simple_websockets::Error> {
        Ok(Server {
            event_hub: simple_websockets::launch(port)?,
            clients: HashMap::new(),
            next_char: None,
            last_response: None,
            last_client_id: None,
        })
    }

    pub fn run(&mut self) {
        loop {
            match self.event_hub.poll_event() {
                Event::Connect(client_id, responder) => self.handle_connection(client_id, responder),
                Event::Disconnect(client_id) => self.handle_disconnection(client_id),
                Event::Message(client_id, message) => self.handle_message(client_id, message),
            }
        }
    }

    fn broadcast_player_count(&self) {
        let response = MessageResponseData::PlayerCount { players: self.clients.len() as u64 }.to_response();
        for (_client, responder) in self.clients.iter() {
            responder.send(response.to_message());
        }
    }

    fn handle_connection(&mut self, client_id: u64, responder: Responder) {
        println!("A client connected with id #{}", client_id);
        responder.send(MessageResponseData::Greeting { id: client_id }.to_message());
        if let Some(ref last_response) = self.last_response {
            responder.send(last_response.to_message());
        }
        self.clients.insert(client_id, responder);
        self.broadcast_player_count();
    }

    fn handle_disconnection(&mut self, client_id: u64) {
        println!("Client #{} disconnected.", client_id);
        self.clients.remove(&client_id);
        self.broadcast_player_count();
    }

    fn handle_message(&mut self, client_id: u64, message: Message) {
        // Ignore binary messages
        let message = match message {
            Message::Text(message) => message,
            Message::Binary(_) => return,
        };

        // Debug
        println!("Received a message from client #{}: {:?}", client_id, message);

        let response = if Some(client_id) == self.last_client_id {
            MessageResponseData::Error {
                message: String::from("It's not your turn!"),
            }
        } else {
            match lookup(&message) {
                Some(entry) => {
                    if entry.reading.chars().last().unwrap().to_string().to_hiragana() == "ん" {
                        MessageResponseData::Error {
                            message: String::from("Can't end with ん!"),
                        }
                    } else if self.next_char.is_none() || entry.reading.chars().next().unwrap().to_string().to_hiragana().chars().next().unwrap() == self.next_char.unwrap() {
                        self.next_char = {
                            // If final character is lengthener or not kana
                            // Use semifinal
                            let mut final_chars = entry.reading.chars().rev();
                            let final_char = final_chars.next().unwrap();
                            Some(if final_char == 'ー' || !final_char.to_string().is_kana() {
                                final_chars.next().unwrap()
                            } else {
                                final_char
                            }.to_string().to_hiragana().chars().next().unwrap())
                        };
                        MessageResponseData::Word {
                            author: client_id,
                            word: entry.kanji.to_owned(),
                            reading: Some(entry.reading.to_owned()),
                            next_char: self.next_char.unwrap(),
                        }
                    } else {
                        MessageResponseData::Error {
                            message: String::from("Wrong starting kana!"),
                        }
                    }
                }
                None => MessageResponseData::Error {
                    message: String::from("Not in dictionary!"),
                },
            }
        }.to_response();

        match response.data {
            // Send errors to only this client
            MessageResponseData::Error { .. } => {
                self.clients.get(&client_id).unwrap().send(response.to_message());
            },
            // Broadcast everything else to all clients
            _ => {
                for (_client, responder) in self.clients.iter() {
                    responder.send(response.to_message());
                }
                self.last_response = Some(response);
                self.last_client_id = Some(client_id);
            },
        }

    }
}