use super::protocol::{ClientboundPacket, ServerboundPacket};
use crate::handle_packet;
use log::{debug, error, info, warn};
use std::io;
use std::io::{BufRead, BufReader, ErrorKind, Write};
use std::os::unix::net::{UnixListener, UnixStream};
use std::thread;

pub fn network_loop() {
    let listener = UnixListener::bind("/run/user/1000/calendar").unwrap();
    let mut id_counter = 0;

    loop {
        let (stream, addr) = listener.accept().unwrap();
        let id = id_counter;
        id_counter += 1;
        thread::spawn(move || {
            info!("client connected: {:?}", addr);
            if let Err(err) = handle_connection(id, stream.try_clone().unwrap()) {
                warn!("client dropped: {:?} ({})", addr, err);
            } else {
                info!("client dropped: {:?}", addr);
            }
        });
    }
}

fn handle_connection(id: u32, mut stream: UnixStream) -> io::Result<()> {
    let mut reader = BufReader::new(stream.try_clone()?);
    let (responder, responses) = crossbeam_channel::unbounded();
    responder
        .send(ClientboundPacket::Handshake {
            version: env!("CARGO_PKG_VERSION").to_string(),
        })
        .unwrap();
    thread::spawn(move || {
        for m in responses {
            debug!("{id} -> {m:?}");
            match stream
                .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) => responder
                    .send(ClientboundPacket::Error(format!("{}", &err)))
                    .map_err(|_| io::Error::from(ErrorKind::InvalidInput))?,
            }

            buf.clear();
        }
    }
}