use std::sync::{Arc, Condvar, Mutex};
use std::{thread};
use std::time::Duration;

fn main() {
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let pair2 = pair.clone();

    thread::spawn(move || {
        thread::sleep(Duration::from_millis(100));
        let (lock, cvar) = &*pair2;
        thread::sleep(Duration::from_millis(500));
        cvar.notify_one();
        println!("notify first");

        let mut started = lock.lock().unwrap();
        thread::sleep(Duration::from_millis(500));
        *started = true;
        cvar.notify_one();
        println!("notify second");
    });

    // thread::sleep(Duration::from_millis(800));
    let (lock, cvar) = &*pair;
    let mut started = lock.lock().unwrap();
    // mutex 鎖的是資源查坪，可以用CondVar進(jìn)行資源狀態(tài)變化的判斷
    // 因此林螃，CondVar的用法是先判斷資源狀態(tài)是否符合當(dāng)前要求邮绿，如果不符合，則調(diào)用wait（釋放鎖）娜遵，并等待被通知
    // 使用while的原因在于資源的狀態(tài)可能未變更為預(yù)期的狀態(tài)，還需要再等待；或者可能有多個(gè)ConVar在等待揽趾，但只觸發(fā)了一次通知
    println!("before: {:?}", started);
    while !*started {
        started = cvar.wait(started).unwrap();  // 這里會(huì)釋放鎖，并監(jiān)控鎖被再次釋放的時(shí)機(jī)
    }
    println!("after: {:?}", started);

    // {
    //     let first = S{a: 10};
    //     let mut second: [MaybeUninit<S>; 10] = unsafe {
    //         MaybeUninit::uninit().assume_init()
    //     };
    //
    //     for (i, elem) in second[..5].iter_mut().enumerate() {
    //         elem.write(S{ a: i });
    //     }
    //     for elem in second[..5].iter_mut() {
    //         unsafe {
    //             ptr::drop_in_place(elem as *mut _ as *mut S);
    //         }
    //     }
    //     // let mut second = ManuallyDrop::new(S{a: 20});
    //
    //     // unsafe {
    //     //     ptr::drop_in_place(second.as_mut_ptr());
    //     // }
    // }

    println!("done");
}

#[derive(Debug)]
struct S {
    a: usize,
}

impl Drop for S {
    fn drop(&mut self) {
        println!("drop {:?}", self);
    }
}

struct Semaphore {
    condvar: Condvar,
    counter: Mutex<i32>,
}

impl Semaphore {
    pub fn new(max: i32) -> Self {
        Semaphore {
            condvar: Condvar::new(),
            counter: Mutex::new(max),
        }
    }

    pub fn acquire(&mut self) {
        let mut count = self.counter.lock().unwrap();

        while *count <= 0 {
            count = self.condvar.wait(count).unwrap();  // 這里會(huì)釋放鎖苛骨，保證其它線程獲取到鎖篱瞎；直到被notify
        }

        *count -= 1;
    }

    pub fn release(&mut self) {
        let mut count = self.counter.lock().unwrap();
        *count += 1;

        self.condvar.notify_one();
    }
}