bytezy 0.0.1

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

// inside bytezy we will suppport (tag, check, bytes)
#[proc_macro_derive(Packet, attributes(bytezy))]
pub fn packet_derive(input: TokenStream) -> TokenStream {
    let _ast = parse_macro_input!(input as DeriveInput);

    //println!("{:?}", ast);

    quote! {}.into()
}

#[cfg(test)]
mod test {
    use std::{
        io::{Read, Write},
        net::{TcpListener, TcpStream},
        thread::{self, Thread},
    };

    #[test]
    fn test_client_server() {
        const ADDRESS: &str = "127.0.0.1:18018";

        let server = TcpListener::bind(ADDRESS).unwrap();
        let server_thread = thread::spawn(move || {
            let (mut server_stream, _) = server.accept().unwrap();
            let mut message = [0u8; 4];

            while let Ok(_) = server_stream.read(&mut message) {
                let mut num_message = u32::from_be_bytes(message);

                // u32 MAX closes the connection
                if num_message == u32::MAX {
                    break;
                }

                server_stream.write(&(num_message + 1).to_be_bytes());
            }
        });

        let mut client_stream = TcpStream::connect(ADDRESS).unwrap();
        let client_thread = thread::spawn(move || {
            let mut message = [0u8; 4];
            let mut num = 0u32;

            for _i in 0..10 {
                client_stream.write(&num.to_be_bytes());
                client_stream.read(&mut message);
                num = u32::from_be_bytes(message);
                println!("Response num {:?}", num);
            }

            // u32 MAX closes the connection
            client_stream.write(&u32::MAX.to_be_bytes());
        });

        server_thread.join().unwrap();
        client_thread.join().unwrap();
    }
}