use std::collections::HashMap;
use std::net::TcpListener;

mod messages;

#[derive(Debug)]
struct Player {
    name: String,
    xy: (f32, f32),
}

#[derive(Debug)]
struct State {
    players: HashMap<u16, Player>,
}

impl State {
    fn new() -> State {
        let players = HashMap::new();
        State { players }
    }

    fn handle_message(&mut self, msg: messages::Msg) {
        let nonce = msg.nonce;
        match msg.command {
            messages::Command::Hello(name) => {
                let player = Player { name, xy: (0.0, 0.0) };
                self.players.insert(nonce, player);
            }
            messages::Command::Goodbye => {
                self.players.remove(&nonce);
            }
            messages::Command::Update(x, y) => {
                if let Some(p) = self.players.get_mut(&nonce) {
                    p.xy = (x, y);
                }
            }
        }
    }
}

fn main() {
    let (send, recv) = std::sync::mpsc::channel();
    let udp_send = send.clone();
    std::thread::spawn(move || {
        let listener = TcpListener::bind("0.0.0.0:9991").unwrap();
        loop {
            match listener.accept() {
                Ok((sock, _addr)) => {
                    let msg = match messages::Msg::parse(sock) {
                        Some(m) => m,
                        None => continue,
                    };
                    send.send(msg).unwrap();
                },
                Err(e) => eprintln!("Problem! {:?}", e),
            }
        }
    });
    std::thread::spawn(move || {
        let socket = std::net::UdpSocket::bind("0.0.0.0:9992").unwrap();
        let mut buf = [0;1024];
        loop {
            let (amt, _) = socket.recv_from(&mut buf).unwrap();
            let msg = messages::Msg::from_slice(&buf[..amt]);
            udp_send.send(msg).unwrap();
        }
    });
    let mut state = State::new();
    while let Ok(msg) = recv.recv() {
        state.handle_message(msg);
        println!("State: {:?}", state);
    }
}