use std::thread;
use std::time::Duration;

use std::sync::Arc;
use crossbeam_arccell::ArcCell;

#[derive(Debug, Default)]
struct Mine {
    val: i32,
}

fn test_atomic_ptr() {


    let smalldur = Arc::new(Duration::from_millis(231));
    let twosec = Arc::new(Duration::from_secs(2));


    let some_ptr = Arc::new(ArcCell::new(Mine::default()));


    let prod_dur = Arc::clone(&smalldur);

    let prod_ptr = Arc::clone(&some_ptr);
    let producer = thread::spawn(move || {
        for i in 1..50 {
            let tmp = i + 1;

            let new_val = Mine {
                val: tmp,
            };
            println!("Updating value to {:?}", new_val);
            prod_ptr.set(new_val);
            println!("Value updated, sleeping producer");
            thread::sleep(*prod_dur);
        }
    });

    let cons_dur = Arc::clone(&twosec);
    let cons_ptr = Arc::clone(&some_ptr);
    let consumer = thread::spawn( move || {
        let dur = Arc::clone(&twosec);
        for _ in 1..8 {
            let value = cons_ptr.load();
            thread::sleep(*cons_dur);
            println!("{:?}", value.val);
        }
    });

    producer.join().unwrap();
    consumer.join().unwrap();
}

fn main () {
    test_atomic_ptr();
}