Organize code, begin database implementation

src/server.rs

@@ -0,0 +1,181 @@
+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);
+            },
+        }
+
+    }
+}