let data = r#"
        {
            "name": "John Doe",
            "age": 43,
            "phones": [
                "+44 1234567",
                "+44 2345678"
            ]
        }"#;

use std::thread;
use std::os::unix::net::{UnixStream, UnixListener};
use std::println;
use std::io::prelude::*;
use std::time::Duration;
use std::io::{BufWriter, BufReader, Read};

fn handle_client(stream:  UnixStream) {
    let mut read_stream = BufReader::new(&stream);
    let mut res = String::new();
    // for line in read_stream.lines() {
    //     println!("Server: {}", line.unwrap());
    // }
    // read_lines is not recommended: as a new line ch is required.
    read_stream.read_to_string(&mut res).unwrap();
    println!("Server: {res:?}");

}

fn main() -> std::io::Result<()> {
    let socket = std::path::Path::new("/tmp/dbs.socks");
    if socket.exists() {
        std::fs::remove_file(socket).unwrap();
    }

    // server
    let t1 = thread::spawn(|| {
        let listener = UnixListener::bind("/tmp/dbs.socks").unwrap();
        for mut stream in listener.incoming() {
            match stream {
                Ok(stream ) => {
                    /* connection succeeded */
                    thread::spawn(|| handle_client(stream));
                    println!("bingo");
                }
                Err(err) => {
                    /* connection failed */
                    println!("{:?}", err);
                    break;
                }
            }
        }

    });

    thread::sleep(Duration::from_millis(2000));

    // client
    let t2 =thread::spawn(|| {
        // println!("{}", soc.)
        for i in 1..10 {

            // each request for one connection (Otherwise, the streaming is recognized as one transfer process)
            let mut soc = UnixStream::connect("/tmp/dbs.socks").unwrap();
            soc.write_all(b"Hello! dsa\n").unwrap();
            // let mut reader = BufReader::new(&soc);
            println!("send");
            thread::sleep(Duration::from_millis(200));
        }

    });

    t1.join().unwrap();
    t2.join().unwrap();


    Ok(())
}

use std::io::ErrorKind;

fn test() -> Result<(), std::io::Error> {
    let res = do(A().ok_or(ErrorKin::AddrInUse)?)?;
    res
}