use std::{
    io::{BufReader, BufWriter, Write},
    net::TcpStream,
    sync::mpsc::{Receiver, Sender, channel},
    thread::spawn,
};

use anyhow::Result;
use log::{debug, info, warn};
use weareshared::packets::{Packet, ReadWrite};

pub struct Network {
    pub packet_recv: Receiver<Packet>,
    pub packet_send: Sender<Packet>,
}
impl Network {
    pub fn new(sock: TcpStream) -> Self {
        info!("starting network threads");
        let (packet_send, rx) = channel();
        let (tx, packet_recv) = channel();

        let sock2 = sock.try_clone().unwrap();
        spawn(move || {
            if let Err(e) = handle_conn_read(sock, tx) {
                warn!("read thread: {e:?}")
            }
        });
        spawn(move || {
            if let Err(e) = handle_conn_write(sock2, rx) {
                warn!("write thread: {e:?}")
            }
        });
        Self {
            packet_recv,
            packet_send,
        }
    }
}

fn handle_conn_read(sock: TcpStream, tx: Sender<Packet>) -> Result<()> {
    let mut sock = BufReader::new(sock);
    loop {
        let packet = Packet::read(&mut sock)?;
        debug!("<- {packet:?}");
        tx.send(packet)?;
    }
}
fn handle_conn_write(sock: TcpStream, rx: Receiver<Packet>) -> Result<()> {
    let mut sock = BufWriter::new(sock);
    for packet in rx {
        debug!("-> {packet:?}");
        packet.write(&mut sock)?;
        sock.flush()?;
    }
    Ok(())
}