use crate::types::*;
use std::{
    sync::Arc,
    net::SocketAddr,
};
use tokio::sync::RwLock;
use futures::{SinkExt, StreamExt, TryStreamExt, stream::SplitStream};
use warp::ws::{ WebSocket, Message };
use ammonia;

const MAX_IN: usize = 2048;

pub async fn lobby(socket: WebSocket, addr: SocketAddr, rinfo: (RoomId,Arc<RwLock<Room>>)) {
    let (room_id, room) = rinfo;
    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();

    // server <-> client comms
    let (mut outgoing, incoming) = socket.split();

    println!("{room_id} I: Incoming TCP connection from: {}", addr);

    let full = {
        let rl = room.read().await;
        let pcap = rl.conf.player_cap;
        let pl = rl.players.read().await;
        pl.len() >= pcap
    };
    if full { return }
    let drive_game = handle_room((incoming,tx), addr, (room_id.clone(),room.clone()));
    let send_to_client = {
        let room_id = room_id.clone();
        async move {
            while let Some(m) = rx.recv().await {
                if let Err(e) = outgoing.send(m).await {
                    println!("{room_id} E: something went bad lol: {e}");
                }
            }
        }
    };

    tokio::select! {
        _ = drive_game => (),
        _ = send_to_client => { println!("{room_id} E: anomalous close for {addr}"); }
    };

    let room_lock = room.read().await;
    let mut players = room_lock.players.write().await;
    if let Some(disconn_p) = players.remove(&addr) {
        for p in players.values() {
            if let Err(e) = p.conn.tx.send(Message::text(format!("logoff {}", disconn_p.uid))) {
                println!("{room_id} E: couldn't deliver logoff info to {}: {}", p, e);
            }
        }
        println!("{room_id} I: {disconn_p} disconnected");
    } else {
        println!("{room_id} I: {addr} disconnected");
    }
}

pub async fn handle_room(streams: (SplitStream<WebSocket>,tokio::sync::mpsc::UnboundedSender<Message>), addr: SocketAddr, rinfo: (RoomId, Arc<RwLock<Room>>)) {
    let (mut incoming, tx) = streams;
    let (room_id, room) = rinfo;
    let (players, cmd_tx, room_conf) = {
        let room = room.read().await;
        (room.players.clone(), room.cmd_stream.clone(), room.conf.clone())
    };
    while let Ok(cmd) = incoming.try_next().await {
        if let Some(cmd) = cmd {
            // if it ain't text we can't handle it
            let cmd = match cmd.to_str() {
                Ok(cmd) => { if cmd.len() > MAX_IN {
                    println!("{room_id} E: string too big: {cmd}");
                    return
                } else { cmd.to_owned() } },
                Err(_) => return
            };

            let mut fields = cmd.split(" ");
            let parse_pos = |mut fields: std::str::Split<&str>| -> Option<(usize, usize)> {
                let x = fields.next().and_then(|xstr| xstr.parse::<usize>().ok());
                let y = fields.next().and_then(|ystr| ystr.parse::<usize>().ok());
                x.zip(y)
            };
            if let Some(cmd_name) = fields.next() {
                use crate::minesweeper::{Move,MoveType};
                let mut players_lock = players.write().await;
                match players_lock.get_mut(&addr) {
                    Some(me) => match cmd_name {
                        "pos" => {
                            match parse_pos(fields) {
                                Some(pos) => {
                                    me.position = pos.clone();
                                    let sanitized_name = me.name.replace(" ", "&nbsp").to_string();
                                    let msg = format!("pos {} {sanitized_name} {} {} {}", me.uid, me.clr, pos.0, pos.1);
                                    for peer_tx in players_lock.iter().filter(|(s, _)| **s != addr).map(|(_,p)| &p.conn.tx) {
                                        let r = peer_tx.send(Message::text(&msg));
                                        if let Err(e) = r {
                                            println!("{room_id} E: error sending pos update: {e}");
                                        }
                                    }
                                },
                                None => {
                                    println!("{room_id} E: bad position update from {me}");
                                },
                            }
                        },
                        "reveal" => {
                            match parse_pos(fields) {
                                Some(pos) => {
                                    if let Err(e) = cmd_tx.send(MetaMove::Move(Move { t: MoveType::Reveal, pos }, addr)) {
                                        println!("{room_id} E: couldn't process {me}'s reveal command: {e}");
                                    };
                                },
                                None => {
                                    println!("{room_id} E: bad reveal from {me}");
                                }
                            }
                        },
                        "flag" => {
                            match parse_pos(fields) {
                                Some(pos) => {
                                    if let Err(e) = cmd_tx.send(MetaMove::Move(Move { t: MoveType::ToggleFlag, pos }, addr)) {
                                        println!("{room_id} E: couldn't process {me}'s flag command: {e}");
                                    };
                                },
                                None => {
                                    println!("{room_id} E: bad flag from {me}");
                                }
                            }
                        },
                        "reset" => {
                            if let Err(e) = cmd_tx.send(MetaMove::Reset) {
                                println!("{room_id} E: couldn't request game dump in behalf of {me}: {e}");
                            }
                        },
                        e => println!("{room_id} E: unknown command {e:?} from {me}: \"{cmd}\""),
                    },
                    None => {
                        if cmd_name == "register" {
                            let mut all_fields = fields.collect::<Vec<&str>>();
                            let clr = all_fields.pop().expect("register without color").chars().filter(|c| c.is_digit(16) || *c == '#').collect::<String>();
                            let name = {
                                let def = "anon".to_string();
                                if all_fields.is_empty() { def }
                                else {
                                    let n = ammonia::clean(&all_fields.join(" "));
                                    if n.is_empty() { def } else { n }
                                }
                            };
                            println!("{room_id} I: registered \"{name}@{addr}\"");
                            drop(players_lock);
                            let uid = {
                                // new scope cuz paranoid bout deadlocks
                                let conn = Conn { addr, tx: tx.clone() };
                                room.write().await.players.insert_conn(conn, name.clone(), clr).await
                            };
                            tx.send(Message::text(format!("regack {} {} {} {}",
                                    room_conf.name.replace(" ", "&nbsp;"), name.replace(" ", "&nbsp;"), uid, room_conf.board_conf))
                            ).expect("couldn't send register ack");
                            if let Err(e) = room.read().await.cmd_stream.send(MetaMove::Dump) {
                                println!("{room_id} E: couldn't request game dump in behalf of {addr}: {e}");
                            }
                        }
                    }
                }
            }
        } else {
            println!("{room_id} E: reached end of stream for {addr}");
            break;
        }
    }
}