use clap::Parser;
use tokio::net::UdpSocket;

/// Simple program to greet a person
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// The address and port to listen and accept cleartext UDP datagrams from
    #[arg(short, long)]
    bind: String,

    /// The local endpoint to read cleartext datagrams from & write to
    #[arg(short, long)]
    local: String,

    /// The destination to send obfuscated UDP datagrams to
    #[arg(short, long)]
    sendto: String,

    /// The hex representation of XOR key to use
    #[arg(short, long)]
    key: String,
}

#[tokio::main]
async fn main() {
    let args = Args::parse();
    let key = hex::decode(args.key)
        .expect("failed to decode key hex string");
    let sock = UdpSocket::bind(&args.bind).await
        .expect("failed to bind UDP endpoint");
    let mut buf = [0; 65536];
    let local = args.local.parse().expect("failed to parse local address");
    loop {
        if let Ok((len, addr)) = sock.recv_from(&mut buf).await {
            let mut i = 0;
            let n = key.len();
            for j in 0..len {
                buf[j] ^= key[i];
                i += 1;
                if i == n {
                    i = 0;
                }
            }
            let target = if addr == local {
                // packet comes from local endpoint
                // send to target
                &args.sendto
            } else {
                // packets coming from target
                // send to local
                &args.local
            };
            let _ = sock.send_to(&buf[..len], target).await;
        }
    }
}