use std::{rc::Rc, sync::atomic::AtomicBool};
use monoio::{io::{AsyncReadRent, AsyncWriteRentExt}, net::{TcpListener, TcpStream}};

#[monoio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    let addr = listener.local_addr().unwrap();
    println!("Listening on {addr}");

    let (outgoing_res, incoming_res) = monoio::join!(TcpStream::connect_addr(addr), listener.accept());

    let mut outgoing = outgoing_res.unwrap();
    let (mut incoming, incoming_addr) = incoming_res.unwrap();

    println!("Connected to {addr} from {incoming_addr}");

    const TEXT: [&'static str; 0x10] = [
        "Meow 1",
        "Meow 2",
        "Meow 3",
        "Meow 4",
        "Meow 5",
        "Meow 6",
        "Meow 7",
        "Meow 8",
        "Meow 9",
        "Meow 10",
        "Meow 11",
        "Meow 12",
        "Meow 13",
        "Meow 14",
        "Meow 15",
        "Meow 16",
    ];

    let server_semaphore = Rc::new(AtomicBool::new(true));
    let client_semaphore = server_semaphore.clone();

    let client = monoio::spawn(async move {
        let mut recv_buf = Vec::<u8>::with_capacity(256);
        let mut r;
        let mut iter = 0;

        for text in TEXT {
            println!("Client writing");
            let written = outgoing.write_all(text).await.0.unwrap();
            println!("Client written {written} bytes\nClient reading");
            (r, recv_buf) = outgoing.read(recv_buf).await;
            println!("Client read {} bytes: {}", r.unwrap(), std::str::from_utf8(&recv_buf[..]).unwrap());
            recv_buf.clear();

            println!("Client finished iter {iter}");
            iter += 1;
        }
        client_semaphore.store(false, std::sync::atomic::Ordering::Relaxed);
    });

    let server = monoio::spawn(async move {
        let mut recv_buf = Vec::<u8>::with_capacity(256);
        let mut r;
        let mut iter = 0;

        while server_semaphore.load(std::sync::atomic::Ordering::Relaxed) {
            println!("Server reading");
            (r, recv_buf) = incoming.read(recv_buf).await;
            println!("Server read {}: {}\nServer echoing it back", r.unwrap(), std::str::from_utf8(&recv_buf[..]).unwrap());
            (r, recv_buf) = incoming.write_all(recv_buf).await;
            println!("Server wrote {} bytes", r.unwrap());
            recv_buf.clear();

            println!("Server finished iter {iter}");
            iter += 1;
        }
    });

    monoio::join!(server, client);
}