use rand::{distributions::Alphanumeric, seq::IteratorRandom, Rng};
use reqwest::{Client, StatusCode};
use serde_json::json;
use std::collections::HashSet;
use tokio;
use tokio::time::{Duration, Instant};

async fn send_key_value(
    client: &Client,
    submit_url: &str,
    lookup_url: &str,
    key: &str,
    value: &str,
    times: &mut Vec<Duration>,
) -> Result<(), reqwest::Error> {
    let body = json!({ "key": key, "value": value });

    // Measure time for submission
    let start = Instant::now();
    client
        .post(submit_url)
        .json(&body)
        .send()
        .await?
        .error_for_status()?; // Ensure the response status is checked
    let elapsed = start.elapsed();
    times.push(elapsed);
    //println!("Time to submit '{}': {:?}", key, elapsed);

    // Measure time for lookup
    let start = Instant::now();
    let response = client
        .get(format!("{}?key={}", lookup_url, key))
        .send()
        .await?
        .error_for_status()?;
    let elapsed = start.elapsed();
    times.push(elapsed);
    //println!("Time to lookup '{}': {:?}", key, elapsed);

    // Print the value if the lookup was successful
    if response.status() == StatusCode::OK {
        let r_value: String = response
            .json::<serde_json::Value>()
            .await?
            .get("value")
            .unwrap()
            .as_str() // This returns an Option<&str>
            .unwrap() // Unwrap the Option<&str> to &str
            .to_string(); // Convert &str to String
        assert_eq!(value, r_value.as_str(), "we got back what we sent in");
        //println!("Lookup value for '{}': {}", key, value);
    }

    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let submit_url = "http://localhost:6000/submit";
    let lookup_url = "http://localhost:6000/lookup";
    let mut rng = rand::thread_rng();
    let mut keys: HashSet<String> = HashSet::new();
    let mut times: Vec<Duration> = Vec::new();

    for _ in 0..100 {
        // sometimes edit, sometimes create
        let key = if rng.gen_bool(0.05) && !keys.is_empty() {
            keys.iter().choose(&mut rng).unwrap().to_string()
        } else {
            let new_key: String = std::iter::repeat(())
                .map(|()| rng.sample(Alphanumeric))
                .map(char::from)
                .take(10)
                .collect();
            keys.insert(new_key.clone());
            new_key
        };

        let value: String = std::iter::repeat(())
            .map(|()| rng.sample(Alphanumeric))
            .map(char::from)
            .take(20)
            .collect();

        if let Err(e) =
            send_key_value(&client, submit_url, lookup_url, &key, &value, &mut times).await
        {
            eprintln!("Error sending or looking up key-value: {}", e);
        }
    }

    // Calculate and print the average times
    let average_time = times.iter().sum::<Duration>() / times.len() as u32;
    println!("Average time for operations: {:?}", average_time);

    Ok(())
}