use std::sync::{LockResult, Mutex, MutexGuard, PoisonError, TryLockError};

pub enum TryLockGuard<'a, T> {
    Lock(MutexGuard<'a, T>),
    WouldBlock(&'a Mutex<T>),
}

impl<'a, T> TryLockGuard<'a, T> {
    pub fn try_lock(
        d: &'a Mutex<T>,
    ) -> Result<TryLockGuard<'a, T>, PoisonError<MutexGuard<'a, T>>> {
        match d.try_lock() {
            Ok(lock) => Ok(TryLockGuard::Lock(lock)),
            Err(try_lock_error) => match try_lock_error {
                TryLockError::Poisoned(poison_error) => Err(poison_error),
                TryLockError::WouldBlock => Ok(TryLockGuard::WouldBlock(d)),
            },
        }
    }

    pub fn would_block(&self) -> bool {
        match self {
            Self::Lock(_) => false,
            Self::WouldBlock(_) => true,
        }
    }

    pub fn guard(self) -> Option<MutexGuard<'a, T>> {
        match self {
            Self::Lock(guard) => Some(guard),
            Self::WouldBlock(_) => None,
        }
    }

    pub fn lock(self) -> LockResult<MutexGuard<'a, T>> {
        match self {
            Self::Lock(guard) => Ok(guard),
            Self::WouldBlock(mutex) => Ok(mutex.lock()?),
        }
    }
}