use std::net::TcpListener;
use std::thread;
use std::sync::{Arc, Mutex};
use std::collections::HashMap;

mod message;
use message::Message;

mod code_generator;
use code_generator::CodeGenerator;

use tungstenite::protocol::Message as WsMessage;

fn main() {
    let code_generator = Arc::new(Mutex::new(CodeGenerator::default()));
    let server = TcpListener::bind("127.0.0.1:8080").unwrap();

    let rooms = Arc::new(Mutex::new(HashMap::new()));
    
    for stream in server.incoming() {
        let code_generator = Arc::clone(&code_generator);
        let rooms = Arc::clone(&rooms);
        thread::spawn (move || {
            let mut ws = tungstenite::accept(stream.unwrap()).unwrap();
            println!("New client!");
            ws.write_message(WsMessage::Text("HOSTJOIN:".to_string())).unwrap();
            loop {
                let message = ws.read_message();
                println!("{:?}", message);
                match message {
                    Err(_) => break,
                    Ok(WsMessage::Close(_)) => break,
                    Ok(WsMessage::Text(msg)) => {
                        let msg = Message::parse(msg.as_str().trim());
                        match msg {
                            Ok(msg) =>
                                match msg.command {
                                    "HOST" => {
                                        let code = code_generator.lock().unwrap().generate();
                                        let mut room = Room::default();
                                        let player = Player { name: "Guest".to_string() };
                                        room.players.push(player);
                                        rooms.lock().unwrap().insert(code.clone(), room);
                                        ws.write_message(WsMessage::Text(code)).unwrap();
                                    }
                                    _ => todo!(),
                                }
                            Err(_) => todo!(),
                        }                       
                    }
                    _ => unimplemented!(),
                }
            }
        });
    }
}
#[derive(Default)]
struct Room {
    players: Vec<Player>,
}

struct Player {
    name: String,
}