JESKOserver 0.1.0

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};

pub use JESKOderive::{Decode, Encode};
pub use serde::{Serialize, de::DeserializeOwned};

/// Encode trait (wraps serde::Serialize + bincode)
pub trait Encode: Serialize {
    fn encode(&self) -> bincode::Result<Vec<u8>> {
        bincode::serialize(self)
    }
}

//cioPqIAtVV68Fs0qwJacct6rvdxpYXTYbMf

/// Decode trait (wraps serde::Deserialize + bincode)
pub trait Decode: DeserializeOwned {
    fn decode(data: &[u8]) -> bincode::Result<Self>
    where
        Self: Sized,
    {
        bincode::deserialize(data)
    }
}

impl<T> Encode for T where T: Serialize {}
impl<T> Decode for T where T: DeserializeOwned {}

/// Server struct
pub struct Server {
    stream: TcpStream,
}

/// Client struct
pub struct Client {
    stream: TcpStream,
}

impl Server {
    /// Start a server and wait for 1 client
    pub fn host(addr: &str) -> std::io::Result<Self> {
        let listener = TcpListener::bind(addr)?;
        println!("Server listening on {}", addr);
        let (stream, addr) = listener.accept()?;
        println!("Client connected: {}", addr);
        Ok(Server { stream })
    }

    pub fn send<T: Encode>(&mut self, value: &T) -> bincode::Result<()> {
        let data = value.encode()?;
        let len = (data.len() as u32).to_be_bytes();
        self.stream.write_all(&len)?;
        self.stream.write_all(&data)?;
        Ok(())
    }

    pub fn receive<T: Decode>(&mut self) -> bincode::Result<T> {
        let mut len_buf = [0u8; 4];
        self.stream.read_exact(&mut len_buf)?;
        let len = u32::from_be_bytes(len_buf) as usize;

        let mut buf = vec![0u8; len];
        self.stream.read_exact(&mut buf)?;
        T::decode(&buf)
    }
}

impl Client {
    pub fn connect(addr: &str) -> std::io::Result<Self> {
        let stream = TcpStream::connect(addr)?;
        println!("Connected to server {}", addr);
        Ok(Client { stream })
    }

    pub fn send<T: Encode>(&mut self, value: &T) -> bincode::Result<()> {
        let data = value.encode()?;
        let len = (data.len() as u32).to_be_bytes();
        self.stream.write_all(&len)?;
        self.stream.write_all(&data)?;
        Ok(())
    }

    pub fn receive<T: Decode>(&mut self) -> bincode::Result<T> {
        let mut len_buf = [0u8; 4];
        self.stream.read_exact(&mut len_buf)?;
        let len = u32::from_be_bytes(len_buf) as usize;

        let mut buf = vec![0u8; len];
        self.stream.read_exact(&mut buf)?;
        T::decode(&buf)
    }
}