use std::thread;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use std::sync::{Arc, Mutex};
use std::io::{self, Write};

struct Runner1 {
    number: Arc<Mutex<f64>>,
}

impl Runner1 {
    fn new(number: f64) -> Runner1 {
        Runner1 {
            number: Arc::new(Mutex::new(number)),
        }
    }

    fn run(&self) -> io::Result<()> {
        let mut stdout = io::stdout();
        loop {
            let number = *self.number.lock().unwrap();
            writeln!(stdout, "Current number: {}", number)?;
            thread::sleep(Duration::from_millis(100));
        }
    }

    fn update_number(&self) -> Box<dyn Fn(f64) + Send + Sync> {
        let number = Arc::clone(&self.number);
        Box::new(move |new_number: f64| {
            let mut num = number.lock().unwrap();
            *num = new_number;
        })
    }
}

struct Runner2 {
    update_hook: Box<dyn Fn(f64) + Send + Sync>,
}

impl Runner2 {
    fn new(update_hook: Box<dyn Fn(f64) + Send + Sync>) -> Runner2 {
        Runner2 {
            update_hook,
        }
    }

    fn run(&self) -> io::Result<()> {
        let mut stdout = io::stdout();
        loop {
            let now = SystemTime::now();
            let since_the_epoch = now.duration_since(UNIX_EPOCH).unwrap();
            let secs = since_the_epoch.as_secs();
            let new_number = secs as f64;
            (self.update_hook)(new_number);
            writeln!(stdout, "Number after run2: {}", new_number)?;
            thread::sleep(Duration::from_millis(100));
        }
    }
}

#[tokio::test]
async fn test_thread() {
    let runner1 = Arc::new(Runner1::new(1.0));
    let runner2 = Runner2::new(runner1.update_number());

    let handle1 = thread::spawn(move || {
        let _ = runner1.run();
    });

    let handle2 = thread::spawn(move || {
        let _ = runner2.run();
    });

    let _ = handle1.join();
    let _ = handle2.join();
}