#![allow(unused)]

use sdlan_sn_rs::peer::Peer;

use dashmap::DashMap;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::time::{Duration, Instant};

use lazy_static::lazy_static;

lazy_static! {
    static ref DASH: DashMap<String, Arc<Peer>> = DashMap::new();
}

#[tokio::main]
async fn main() {
    let numbers = 1000000;
    let number_of_routine = 400;

    let start = Instant::now();
    for i in 0..numbers {
        let id = i.to_string();
        let peer = Arc::new(Peer::new(&id));
        DASH.insert(id, peer);
    }

    println!("insert {} record elapsed: {:?}", numbers, start.elapsed());

    let mut handlers = vec![];
    let start = Instant::now();
    for i in 0..number_of_routine {
        let handler = tokio::spawn(async move {
            for j in 0..numbers {
                // let info = DASH.get(&j.to_string()).unwrap().clone();
                let info = DASH.get(&j.to_string()).unwrap();
                info.last_seen.fetch_add(1, Ordering::Relaxed);
                // println!("{j}");
            }
        });
        handlers.push(handler);
    }

    for handler in handlers {
        let v = handler.await;
    }
    println!(
        "{}x{} times add elapsed: {:?}",
        number_of_routine,
        numbers,
        start.elapsed()
    );
    for i in 0..10 {
        println!(
            "{:?}",
            DASH.get(&i.to_string())
                .unwrap()
                .clone()
                .last_seen
                .load(Ordering::Relaxed)
        )
    }
}