/* Any copyright is dedicated to the Public Domain.
 * http://creativecommons.org/publicdomain/zero/1.0/ */

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

/// A countdown latch is like an [`std::sync::Barrier`] that lets M threads
/// wait on N operations to complete. Unlike a barrier, a countdown latch is
/// acyclic: once the latch has counted down to zero, it can't be reset.
pub struct CountDownLatch {
    count: Mutex<usize>,
    cvar: Condvar,
}

impl CountDownLatch {
    /// Creates a new latch that waits for N operations to complete.
    pub const fn new(count: usize) -> Self {
        Self {
            count: Mutex::new(count),
            cvar: Condvar::new(),
        }
    }

    /// Decrements the count of the latch, waking up any waiting threads
    /// if the count reaches zero. Returns without effect if the count is
    /// already zero.
    pub fn count_down(&self) {
        let mut count = self.count.lock().unwrap();
        if *count > 0 {
            *count -= 1;
            if *count == 0 {
                self.cvar.notify_all();
            }
        }
    }

    /// Waits for either the count of the latch to reach zero, or the `timeout`
    /// to elapse; whichever happens first. Returns `true` if the count is
    /// already zero, or reaches zero within the `timeout`.
    pub fn wait_timeout(&self, timeout: Duration) -> bool {
        let mut count = self.count.lock().unwrap();
        while *count > 0 {
            let (guard, result) = self.cvar.wait_timeout(count, timeout).unwrap();
            if result.timed_out() {
                return false;
            }
            count = guard;
        }
        true
    }
}