/*
    wearechat - generic multiplayer game with voip
    Copyright (C) 2025 metamuffin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, version 3 of the License only.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
use anyhow::Result;
use log::{debug, info, warn};
use std::{
    io::{BufReader, BufWriter, Write},
    net::TcpStream,
    sync::mpsc::{Receiver, Sender, channel},
    thread::spawn,
};
use weareshared::{helper::ReadWrite, packets::Packet};

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(())
}