use std::{collections::HashMap, net::TcpListener, sync::{mpsc::{channel, Receiver, Sender}, Arc, Mutex}, thread::spawn};
use tungstenite::{accept, Message};

fn main() {
    let mut connection_count: usize = 0;
    let senders = Arc::new(Mutex::new(HashMap::<usize, Sender<Arc<Message>>>::new()));

    let server = TcpListener::bind("0.0.0.0:9001").unwrap();
    for stream in server.incoming() {

        let t_senders = Arc::clone(&senders);
        let (sender, receiver): (Sender<Arc<Message>>, Receiver<Arc<Message>>) = channel();
        {
            let mut sender_lock = t_senders.lock().unwrap();
            connection_count += 1;
            (*sender_lock).insert(connection_count, sender);
        }
        let websocket = Arc::new(Mutex::new(accept(stream.unwrap()).unwrap()));

        let r_websocket = Arc::clone(&websocket);
        spawn(move || {
            let id = connection_count;
            println!("Connection Received: {}", id);
            loop {
                let res = {
                    let mut wssocket_lock = r_websocket.lock().unwrap();
                    (*wssocket_lock).read()
                };
                match res {
                    // Ok(Message::Close(_)) => {
                    //     let mut t_sender_lock = t_senders.lock().unwrap();
                    //     (*t_sender_lock).remove(&id);
                    //     match (*wssocket_lock).send(Message::Close(Some(CloseFrame{
                    //         code: CloseCode::Normal,
                    //         reason: "Connection Closed :)".into()
                    //     }))) {
                    //         Ok(_) => println!("Close frame sent succesfully"),
                    //         Err(e) => println!("Failed to send close frame (connection may already be closed): {}", e)
                    //     };
                    //     println!("closing connection");
                    //     break;
                    // }
                    Ok(msg) => {
                        let arc_msg = Arc::new(msg);
                        if arc_msg.is_close() {
                            let t_sender_lock = t_senders.lock().unwrap();
                            let arc_msg_clone = Arc::clone(&arc_msg);
                            match (*t_sender_lock).get(&id).unwrap().send(arc_msg_clone) {
                                Ok(_) => println!("close message sent to thread no {}", id),
                                Err(e) => println!("My Error: {}", e)
                            }
                            break;
                        }
                        else if arc_msg.is_text() || arc_msg.is_binary() {
                            let t_sender_lock = t_senders.lock().unwrap();
                            for (iter_id, sender) in (*t_sender_lock).iter() {
                                let arc_msg_clone = Arc::clone(&arc_msg);
                                if *iter_id != id {
                                    match (*sender).send(arc_msg_clone) {
                                        Ok(_) => println!("message sent to thread no {}", *iter_id),
                                        Err(e) => println!("My Error: {}", e)
                                    }
                                }
                            }
                        }
                    }
                    Err(e) => {
                        let mut t_sender_lock = t_senders.lock().unwrap();
                        (*t_sender_lock).remove(&id);
                        println!("MyError Occured: {}", e);
                        println!("Connection Closed");
                        break;
                    }

                }

            }

        });

        let s_websocket = Arc::clone(&websocket);
        spawn(move || {
            let id = connection_count;
            loop {
                match receiver.recv() {
                    Ok(arc_msg) => {
                        println!("Message received by thread {}", id);
                        println!("The message is {}", arc_msg);
                        let mut wssocket_lock = s_websocket.lock().unwrap();
                        println!("Lock acquired");
                        let msg = (*arc_msg).clone();
                        //TODO add match for this
                        let _ = (*wssocket_lock).send(msg);
                        println!("message sent to client {}", id);
                    }
                    Err(e) => {
                        println!("Error in receiving from other threads: {}", e);
                        break;
                    }
                }
            }
        });

    }
}