use crate::handle_packet;
use karlcommon::{version, ClientboundPacket, ProtoError, ServerboundPacket};
use log::{debug, error, warn};
use std::{
    io::{self, BufRead, BufReader, ErrorKind, Read, Write},
    thread,
};

pub fn generic_handle_connection<ReadStream: Read, WriteStream: Write + Send + 'static>(
    id: u32,
    rstream: ReadStream,
    wstream: WriteStream,
) -> io::Result<()> {
    let mut reader = BufReader::new(rstream);
    let (responder, responses) = crossbeam_channel::unbounded();
    responder
        .send(ClientboundPacket::Handshake {
            version: version!(),
        })
        .unwrap();

    thread::spawn(move || {
        let mut wstream = wstream;
        for m in responses {
            debug!("{id} -> {m:?}");
            match wstream
                .write_fmt(format_args!("{}\n", serde_json::to_string(&m).unwrap()))
                .map_err(|e| e.kind())
            {
                Ok(_) => (),
                Err(ErrorKind::BrokenPipe) => break,
                Err(e) => error!("network error: {:?}", e),
            }
        }
    });
    {
        let mut buf = String::new();
        loop {
            if reader.read_line(&mut buf)? == 0 {
                break Ok(());
            };
            match serde_json::from_str::<ServerboundPacket>(buf.as_str()) {
                Ok(packet) => {
                    debug!("{id} <- {packet:?}");
                    handle_packet(id, packet, responder.clone());
                }
                Err(err) => {
                    warn!("client error: {:?}", &err);
                    responder
                        .send(ClientboundPacket::Error(ProtoError::FormatError(format!(
                            "{}",
                            &err
                        ))))
                        .map_err(|_| io::Error::from(ErrorKind::InvalidInput))?
                }
            }

            buf.clear();
        }
    }
}