use std::sync::mpsc::SyncSender;
use std::sync::mpsc::Receiver;
use std::sync::mpsc::sync_channel;
use std::thread;
use std::io::{Read, Write};
use std::sync::{Arc, Mutex};
#[macro_use]
extern crate lazy_static;

use std::net::{TcpListener, TcpStream, Shutdown};
use std::collections::HashMap;

lazy_static! {
    static ref C_Senders: Mutex<HashMap<u32, SyncSender<String>>> = Mutex::new(HashMap::new());
}

fn main() {
    let listener = TcpListener::bind("0.0.0.0:3333").unwrap();
    let mut client_id = 0;

    for stream in listener.incoming() {
        match stream {
            Ok(mut stream) => {
                thread::spawn(move || {
                    // notify server about new connection
                    println!("New connection: {}", stream.peer_addr().unwrap());

                    // create channel
                    let (sender, receiver) = sync_channel(1024);

                    // take ownership of hashmap
                    let mut senders = C_Senders.lock().unwrap();

                    // insert new client to hashmap
                    senders.insert(client_id, sender);

                    // delete ownership of hashmap above
                    drop(senders);

                    // create clone of stream
                    let mut read_stream = stream.try_clone().unwrap();

                    // and move it to new thread
                    spawn_reading_thread(client_id, read_stream);

                    // receiving
                    loop {
                        // getting message from receiver
                        let msg = receiver.recv().unwrap();

                        // writing if msg found
                        stream.write(msg.as_bytes());
                    }
                });

                client_id = client_id + 1;
            },
            Err(_) => {
                println!("Close");
            },
        }
    }
}

fn spawn_reading_thread(client_id: u32, mut stream: TcpStream) {
    thread::spawn(move || {
        // get ownership of hashmap
        let mut senders    = C_Senders.lock().unwrap();

        // get ownership of client entry
        let mut sender_old = senders.get_mut(&client_id).unwrap();

        // get copy of sender
        let mut sender     = sender_old.clone();

        // delete ownership of hashmap and sender_old (will be autodroped cuz ts mut reference)
        drop(senders);

        // we have only sender, stream and client_id available

        // create buffer [u8]
        let mut buffer = [0 as u8; 1024];

        while match stream.read(&mut buffer) {
            Ok(size) => {
                // if empty
                if size == 0 {return};
                if buffer[size-1] == b'\n' {
                    buffer[size-1] = b'\0';
                }

                // [u8] -> String
                let message = String::from_utf8_lossy(&buffer).to_string();

                // send
                // get ownership of Senders HashMap
                let senders = C_Senders.lock().unwrap();

                // notify client, who wrote about his message
                sender.send(format!("You wrote: '{}'\n", message));

                // message for future sending
                let msg = format!("Client {} wrote: '{}'\n", client_id, message);

                // send to everybody
                for (k, sender) in senders.iter() {
                    sender.send(msg.clone());
                }

                true
            },
            Err(_) => {

                false
            }
        } {};
    });
}