#[cfg(test)]
mod tests;

use crate::fmt;
use crate::sync::{mutex, poison, LockResult, MutexGuard, PoisonError};
use crate::sys::locks as sys;
use crate::time::{Duration, Instant};

/// 指示是否因超时而返回的条件变量的定时等待的类型。
///
///
/// 它由 [`wait_timeout`] 方法返回。
///
/// [`wait_timeout`]: Condvar::wait_timeout
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
#[stable(feature = "wait_timeout", since = "1.5.0")]
pub struct WaitTimeoutResult(bool);

impl WaitTimeoutResult {
    /// 如果已知等待超时，则返回 `true`。
    ///
    /// # Examples
    ///
    /// 本示例生成一个线程，该线程将更新布尔值，然后等待 100 毫秒再通知 condvar。
    ///
    ///
    /// 主线程将在 condvar 上等待超时，然后在布尔值已更新并通知后离开。
    ///
    /// ```
    /// use std::sync::{Arc, Condvar, Mutex};
    /// use std::thread;
    /// use std::time::Duration;
    ///
    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
    /// let pair2 = Arc::clone(&pair);
    ///
    /// thread::spawn(move || {
    ///     let (lock, cvar) = &*pair2;
    ///
    ///     // 让我们等待 20 毫秒，然后再通知 condvar。
    ///     thread::sleep(Duration::from_millis(20));
    ///
    ///     let mut started = lock.lock().unwrap();
    ///     // 我们更新布尔值。
    ///     *started = true;
    ///     cvar.notify_one();
    /// });
    ///
    /// // 等待线程启动。
    /// let (lock, cvar) = &*pair;
    /// let mut started = lock.lock().unwrap();
    /// loop {
    ///     // 让我们在 condvar 的等待上设置超时。
    ///     let result = cvar.wait_timeout(started, Duration::from_millis(10)).unwrap();
    ///     // 10 毫秒已过去，或者值已更改！
    ///     started = result.0;
    ///     if *started == true {
    ///         // 我们已收到通知，并且值已更新，我们可以离开。
    ///         break
    ///     }
    /// }
    /// ```
    ///
    #[must_use]
    #[stable(feature = "wait_timeout", since = "1.5.0")]
    pub fn timed_out(&self) -> bool {
        self.0
    }
}

/// 条件变量
///
/// 条件变量表示阻塞线程的能力，以使线程在等待事件发生时不占用任何 CPU 时间。
/// 条件变量通常与布尔谓词 (条件) 和互斥锁相关联。
/// 在确定线程必须阻塞之前，始终在互斥锁内部验证该谓词。
///
/// 此模块中的函数将阻止当前的执行线程。
/// 请注意，对同一条件变量使用多个互斥锁的任何尝试都可能导致运行时 panic。
///
/// # Examples
///
/// ```
/// use std::sync::{Arc, Mutex, Condvar};
/// use std::thread;
///
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
/// let pair2 = Arc::clone(&pair);
///
/// // 在我们的锁内部，spawn 有一个新线程，然后等待它启动。
/// thread::spawn(move|| {
///     let (lock, cvar) = &*pair2;
///     let mut started = lock.lock().unwrap();
///     *started = true;
///     // 我们通知 condvar 值已更改。
///     cvar.notify_one();
/// });
///
/// // 等待线程启动。
/// let (lock, cvar) = &*pair;
/// let mut started = lock.lock().unwrap();
/// while !*started {
///     started = cvar.wait(started).unwrap();
/// }
/// ```
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Condvar {
    inner: sys::Condvar,
}

impl Condvar {
    /// 创建一个新的条件变量，可以随时等待它并通知它。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::sync::Condvar;
    ///
    /// let condvar = Condvar::new();
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_stable(feature = "const_locks", since = "1.63.0")]
    #[must_use]
    #[inline]
    pub const fn new() -> Condvar {
        Condvar { inner: sys::Condvar::new() }
    }

    /// 阻塞当前线程，直到此条件变量收到通知为止。
    ///
    /// 该函数将自动解锁指定的互斥锁 (由 `guard` 表示) 并阻塞当前线程。
    /// 这意味着在互斥锁解锁后逻辑上发生的任何对 [`notify_one`] 或 [`notify_all`] 的调用都可以唤醒该线程。
    /// 当此函数调用返回时，将重新获得指定的锁。
    ///
    /// 请注意，此函数易受虚假唤醒的影响。
    /// 条件变量通常具有与之关联的布尔谓词，并且每次此函数返回时都必须始终检查谓词，以防止虚假唤醒。
    ///
    ///
    /// # Errors
    ///
    /// 如果正在等待的互斥锁在此线程重新获取锁时中毒，则此函数将返回错误。
    /// 有关更多信息，请参见有关 [`Mutex`] 类型的 [中毒][poisoning] 的信息。
    ///
    /// # Panics
    ///
    /// 如果长时间使用此函数与多个互斥锁，则该函数可能为 [`panic!`]。
    ///
    /// [`notify_one`]: Self::notify_one
    /// [`notify_all`]: Self::notify_all
    /// [poisoning]: super::Mutex#poisoning
    /// [`Mutex`]: super::Mutex
    ///
    /// # Examples
    ///
    /// ```
    /// use std::sync::{Arc, Mutex, Condvar};
    /// use std::thread;
    ///
    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
    /// let pair2 = Arc::clone(&pair);
    ///
    /// thread::spawn(move|| {
    ///     let (lock, cvar) = &*pair2;
    ///     let mut started = lock.lock().unwrap();
    ///     *started = true;
    ///     // 我们通知 condvar 值已更改。
    ///     cvar.notify_one();
    /// });
    ///
    /// // 等待线程启动。
    /// let (lock, cvar) = &*pair;
    /// let mut started = lock.lock().unwrap();
    /// // 只要 `Mutex<bool>` 内部的值为 `false`，我们就等待。
    /// while !*started {
    ///     started = cvar.wait(started).unwrap();
    /// }
    /// ```
    ///
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> LockResult<MutexGuard<'a, T>> {
        let poisoned = unsafe {
            let lock = mutex::guard_lock(&guard);
            self.inner.wait(lock);
            mutex::guard_poison(&guard).get()
        };
        if poisoned { Err(PoisonError::new(guard)) } else { Ok(guard) }
    }

    /// 阻止当前线程，直到此条件变量接收到通知并且所提供的条件为 false 为止。
    ///
    /// 该函数将自动解锁指定的互斥锁 (由 `guard` 表示) 并阻塞当前线程。
    /// 这意味着在互斥锁解锁后逻辑上发生的任何对 [`notify_one`] 或 [`notify_all`] 的调用都可以唤醒该线程。
    ///
    /// 当此函数调用返回时，将重新获得指定的锁。
    ///
    /// # Errors
    ///
    /// 如果正在等待的互斥锁在此线程重新获取锁时中毒，则此函数将返回错误。
    /// 有关更多信息，请参见有关 [`Mutex`] 类型的 [中毒][poisoning] 的信息。
    ///
    /// [`notify_one`]: Self::notify_one
    /// [`notify_all`]: Self::notify_all
    /// [poisoning]: super::Mutex#poisoning
    /// [`Mutex`]: super::Mutex
    ///
    /// # Examples
    ///
    /// ```
    /// use std::sync::{Arc, Mutex, Condvar};
    /// use std::thread;
    ///
    /// let pair = Arc::new((Mutex::new(true), Condvar::new()));
    /// let pair2 = Arc::clone(&pair);
    ///
    /// thread::spawn(move|| {
    ///     let (lock, cvar) = &*pair2;
    ///     let mut pending = lock.lock().unwrap();
    ///     *pending = false;
    ///     // 我们通知 condvar 值已更改。
    ///     cvar.notify_one();
    /// });
    ///
    /// // 等待线程启动。
    /// let (lock, cvar) = &*pair;
    /// // 只要 `Mutex<bool>` 内部的值为 `true`，我们就等待。
    /// let _guard = cvar.wait_while(lock.lock().unwrap(), |pending| { *pending }).unwrap();
    /// ```
    ///
    ///
    ///
    #[stable(feature = "wait_until", since = "1.42.0")]
    pub fn wait_while<'a, T, F>(
        &self,
        mut guard: MutexGuard<'a, T>,
        mut condition: F,
    ) -> LockResult<MutexGuard<'a, T>>
    where
        F: FnMut(&mut T) -> bool,
    {
        while condition(&mut *guard) {
            guard = self.wait(guard)?;
        }
        Ok(guard)
    }

    /// 等待此条件变量以获取通知，并在指定的持续时间后超时。
    ///
    /// 该函数的语义与 [`wait`] 等效，除了线程被阻塞的时间大约不超过 `ms` 毫秒。
    /// 由于抢占或平台差异等异常情况可能不会导致最大等待时间精确到 `ms`，因此不应将此方法用于精确计时。
    ///
    ///
    /// 请注意，已尽最大努力确保使用单调时钟来测量等待的时间，并且不受系统时间更改的影响。
    ///
    /// 仅当已知超时已经过去时，返回的布尔值为 `false`。
    ///
    /// 与 [`wait`] 一样，无论是否经过超时，都将在此函数返回时重新获取指定的锁。
    ///
    /// [`wait`]: Self::wait
    ///
    /// # Examples
    ///
    /// ```
    /// use std::sync::{Arc, Mutex, Condvar};
    /// use std::thread;
    ///
    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
    /// let pair2 = Arc::clone(&pair);
    ///
    /// thread::spawn(move|| {
    ///     let (lock, cvar) = &*pair2;
    ///     let mut started = lock.lock().unwrap();
    ///     *started = true;
    ///     // 我们通知 condvar 值已更改。
    ///     cvar.notify_one();
    /// });
    ///
    /// // 等待线程启动。
    /// let (lock, cvar) = &*pair;
    /// let mut started = lock.lock().unwrap();
    /// // 只要 `Mutex<bool>` 内部的值为 `false`，我们就等待。
    /// loop {
    ///     let result = cvar.wait_timeout_ms(started, 10).unwrap();
    ///     // 10 毫秒已过去，或者值已更改！
    ///     started = result.0;
    ///     if *started == true {
    ///         // 我们已收到通知，并且值已更新，我们可以离开。
    ///         break
    ///     }
    /// }
    /// ```
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    #[deprecated(since = "1.6.0", note = "replaced by `std::sync::Condvar::wait_timeout`")]
    pub fn wait_timeout_ms<'a, T>(
        &self,
        guard: MutexGuard<'a, T>,
        ms: u32,
    ) -> LockResult<(MutexGuard<'a, T>, bool)> {
        let res = self.wait_timeout(guard, Duration::from_millis(ms as u64));
        poison::map_result(res, |(a, b)| (a, !b.timed_out()))
    }

    /// 等待此条件变量以获取通知，并在指定的持续时间后超时。
    ///
    /// 该函数的语义与 [`wait`] 等效，除了线程被阻塞的时间不超过 `dur`。
    /// 由于抢占或平台差异等异常情况可能不会导致最大等待时间精确到 `dur`，因此不应将此方法用于精确计时。
    ///
    ///
    /// 请注意，已尽最大努力确保使用单调时钟来测量等待的时间，并且不受系统时间更改的影响。
    /// 此函数易受虚假唤醒的影响。
    /// 条件变量通常具有与之关联的布尔谓词，并且每次此函数返回时都必须始终检查谓词，以防止虚假唤醒。
    /// 另外，尽管有虚假的唤醒，但通常还是希望超时不超过某个持续时间，因此睡眠时间会减少睡眠量。
    /// 或者，在谓词为 true 时，使用 `wait_timeout_while` 方法等待超时。
    ///
    /// 返回的 [`WaitTimeoutResult`] 值指示是否已知超时。
    ///
    /// 与 [`wait`] 一样，无论是否经过超时，都将在此函数返回时重新获取指定的锁。
    ///
    /// [`wait`]: Self::wait
    /// [`wait_timeout_while`]: Self::wait_timeout_while
    ///
    /// # Examples
    ///
    /// ```
    /// use std::sync::{Arc, Mutex, Condvar};
    /// use std::thread;
    /// use std::time::Duration;
    ///
    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
    /// let pair2 = Arc::clone(&pair);
    ///
    /// thread::spawn(move|| {
    ///     let (lock, cvar) = &*pair2;
    ///     let mut started = lock.lock().unwrap();
    ///     *started = true;
    ///     // 我们通知 condvar 值已更改。
    ///     cvar.notify_one();
    /// });
    ///
    /// // 等待线程启动
    /// let (lock, cvar) = &*pair;
    /// let mut started = lock.lock().unwrap();
    /// // 只要 `Mutex<bool>` 内的值为 `false`，我们就等待
    /// loop {
    ///     let result = cvar.wait_timeout(started, Duration::from_millis(10)).unwrap();
    ///     // 10 毫秒已过去，或者值已更改！
    ///     started = result.0;
    ///     if *started == true {
    ///         // 我们已收到通知，并且值已更新，我们可以离开。
    ///         break
    ///     }
    /// }
    /// ```
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "wait_timeout", since = "1.5.0")]
    pub fn wait_timeout<'a, T>(
        &self,
        guard: MutexGuard<'a, T>,
        dur: Duration,
    ) -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)> {
        let (poisoned, result) = unsafe {
            let lock = mutex::guard_lock(&guard);
            let success = self.inner.wait_timeout(lock, dur);
            (mutex::guard_poison(&guard).get(), WaitTimeoutResult(!success))
        };
        if poisoned { Err(PoisonError::new((guard, result))) } else { Ok((guard, result)) }
    }

    /// 等待此条件变量以获取通知，并在指定的持续时间后超时。
    ///
    /// 该函数的语义与 [`wait_while`] 等效，除了线程被阻塞的时间不超过 `dur`。
    /// 由于抢占或平台差异等异常情况可能不会导致最大等待时间精确到 `dur`，因此不应将此方法用于精确计时。
    ///
    ///
    /// 请注意，已尽最大努力确保使用单调时钟来测量等待的时间，并且不受系统时间更改的影响。
    ///
    /// 返回的 [`WaitTimeoutResult`] 值指示是否已知超时已经过去，而没有满足条件。
    ///
    /// 与 [`wait_while`] 一样，无论是否经过超时，都将在此函数返回时重新获取指定的锁。
    ///
    /// [`wait_while`]: Self::wait_while
    /// [`wait_timeout`]: Self::wait_timeout
    ///
    /// # Examples
    ///
    /// ```
    /// use std::sync::{Arc, Mutex, Condvar};
    /// use std::thread;
    /// use std::time::Duration;
    ///
    /// let pair = Arc::new((Mutex::new(true), Condvar::new()));
    /// let pair2 = Arc::clone(&pair);
    ///
    /// thread::spawn(move|| {
    ///     let (lock, cvar) = &*pair2;
    ///     let mut pending = lock.lock().unwrap();
    ///     *pending = false;
    ///     // 我们通知 condvar 值已更改。
    ///     cvar.notify_one();
    /// });
    ///
    /// // 等待线程启动
    /// let (lock, cvar) = &*pair;
    /// let result = cvar.wait_timeout_while(
    ///     lock.lock().unwrap(),
    ///     Duration::from_millis(100),
    ///     |&mut pending| pending,
    /// ).unwrap();
    /// if result.1.timed_out() {
    ///     // 超时，条件永远不会为 false。
    /// }
    /// // 通过 result.0 访问锁定的互斥锁
    /// ```
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "wait_timeout_until", since = "1.42.0")]
    pub fn wait_timeout_while<'a, T, F>(
        &self,
        mut guard: MutexGuard<'a, T>,
        dur: Duration,
        mut condition: F,
    ) -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)>
    where
        F: FnMut(&mut T) -> bool,
    {
        let start = Instant::now();
        loop {
            if !condition(&mut *guard) {
                return Ok((guard, WaitTimeoutResult(false)));
            }
            let timeout = match dur.checked_sub(start.elapsed()) {
                Some(timeout) => timeout,
                None => return Ok((guard, WaitTimeoutResult(true))),
            };
            guard = self.wait_timeout(guard, timeout)?.0;
        }
    }

    /// 在此 condvar 上唤醒一个阻塞的线程。
    ///
    /// 如果此条件变量上有阻塞的线程，则它将从其调用中唤醒到 [`wait`] 或 [`wait_timeout`]。
    /// 不会以任何方式缓冲对 `notify_one` 的调用。
    ///
    /// 要唤醒所有线程，请参见 [`notify_all`]。
    ///
    /// [`wait`]: Self::wait
    /// [`wait_timeout`]: Self::wait_timeout
    /// [`notify_all`]: Self::notify_all
    ///
    /// # Examples
    ///
    /// ```
    /// use std::sync::{Arc, Mutex, Condvar};
    /// use std::thread;
    ///
    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
    /// let pair2 = Arc::clone(&pair);
    ///
    /// thread::spawn(move|| {
    ///     let (lock, cvar) = &*pair2;
    ///     let mut started = lock.lock().unwrap();
    ///     *started = true;
    ///     // 我们通知 condvar 值已更改。
    ///     cvar.notify_one();
    /// });
    ///
    /// // 等待线程启动。
    /// let (lock, cvar) = &*pair;
    /// let mut started = lock.lock().unwrap();
    /// // 只要 `Mutex<bool>` 内部的值为 `false`，我们就等待。
    /// while !*started {
    ///     started = cvar.wait(started).unwrap();
    /// }
    /// ```
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn notify_one(&self) {
        self.inner.notify_one()
    }

    /// 唤醒此 condvar 上的所有阻塞线程。
    ///
    /// 此方法将确保唤醒条件变量上的所有当前侍者。
    /// 不会以任何方式缓冲对 `notify_all()` 的调用。
    ///
    /// 要仅唤醒一个线程，请参见 [`notify_one`]。
    ///
    /// [`notify_one`]: Self::notify_one
    ///
    /// # Examples
    ///
    /// ```
    /// use std::sync::{Arc, Mutex, Condvar};
    /// use std::thread;
    ///
    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
    /// let pair2 = Arc::clone(&pair);
    ///
    /// thread::spawn(move|| {
    ///     let (lock, cvar) = &*pair2;
    ///     let mut started = lock.lock().unwrap();
    ///     *started = true;
    ///     // 我们通知 condvar 值已更改。
    ///     cvar.notify_all();
    /// });
    ///
    /// // 等待线程启动。
    /// let (lock, cvar) = &*pair;
    /// let mut started = lock.lock().unwrap();
    /// // 只要 `Mutex<bool>` 内部的值为 `false`，我们就等待。
    /// while !*started {
    ///     started = cvar.wait(started).unwrap();
    /// }
    /// ```
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn notify_all(&self) {
        self.inner.notify_all()
    }
}

#[stable(feature = "std_debug", since = "1.16.0")]
impl fmt::Debug for Condvar {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Condvar").finish_non_exhaustive()
    }
}

#[stable(feature = "condvar_default", since = "1.10.0")]
impl Default for Condvar {
    /// 创建一个 `Condvar`，可以等待它并通知它。
    fn default() -> Condvar {
        Condvar::new()
    }
}