extern crate parking_lot; // 0.7.1

use std::sync::{Arc, Mutex, RwLock};
use std::cell::RefCell;
use std::thread;
use std::time::Duration;
use parking_lot::ReentrantMutex;

struct MyCtrl {
    x: usize,
    lock: Arc<Mutex<usize>>,
    data: Arc<ReentrantMutex<RefCell<Vec<usize>>>>
}

struct S<T: Calc> {
    calc: T,
    ctrl: MyCtrl
}

impl<T: Calc> S<T> {
    pub fn process(&mut self, data: &[usize]) {
        let lock = self.ctrl.data.clone();
        for x in data {
            // trying to lock with change in thread::spawn
            let _lock = lock.lock();

            self.ctrl.x = *x;
            self.calc.calc(&mut self.ctrl)
        }

        thread::sleep(Duration::from_millis(100));

        let data = self.ctrl.data.lock();
        let res = data.borrow();
        dbg!(res.len());
    }
}

trait Ctrl {
    fn get(&self) -> usize;
    fn set(&mut self, v: usize);
}

impl Ctrl for MyCtrl {
    fn get(&self) -> usize {
        self.x + self.data.lock().borrow().len()
    }

    fn set(&mut self, v: usize) {
        let data = self.data.clone();
        let mutex = self.lock.clone();
        thread::spawn(move || {
            let guard = mutex.try_lock();
            if let Ok(_v) = guard {
                thread::sleep(Duration::from_millis(1));

                // trying to lock with main thread
                let data = data.lock();
                let mut data = data.borrow_mut();
                data.push(v);
            }
        });
    }
}

trait Calc {
    fn calc(&mut self, ctrl: &mut impl Ctrl); // cannot change
}

struct MyCalc {
    counter: usize
}

impl Calc for MyCalc {
    fn calc(&mut self, ctrl: &mut impl Ctrl) {
        ctrl.set(ctrl.get());
        self.counter += 1;
    }
}

fn main() {
    let calc = MyCalc{counter: 0};
    let ctrl = MyCtrl{
        x: 0,
        lock: Arc::new(Mutex::new(0)),
        data: Arc::new(ReentrantMutex::new(RefCell::new(vec![])))
    };
    let mut s = S{calc, ctrl};

    s.process(&(0..2000).collect::<Vec<_>>());
}