//! Authors: Maurice Laveaux, Flip van Spaendonck and Jan Friso Groote

use std::cell::Cell;

use std::error::Error;

use std::ops::Deref;

use std::ops::DerefMut;

use crate::BfSharedMutex;

use crate::BfSharedMutexReadGuard;

use crate::BfSharedMutexWriteGuard;

/// An extension of the [BfSharedMutex] that allows recursive read locking without deadlocks.

///

/// The recursion depth and call counters are stored in [`Cell`]s, so a `RecursiveLock` is

/// `!Sync` and has no `Clone`. To share the underlying data across threads, give each thread

/// its own `RecursiveLock` over a clone of the same mutex via

/// [`RecursiveLock::from_mutex`]`(shared.clone())`; the depth tracking is then per thread, as

/// the protocol requires. The call counters are likewise per instance, not global.

pub struct RecursiveLock<T> {

    inner: BfSharedMutex<T>,

    /// The number of times the current thread has read locked the mutex.

    recursive_depth: Cell<usize>,

    /// The number of calls to the write() method.

    write_calls: Cell<usize>,

    /// The number of calls to the read_recursive() method.

    read_recursive_calls: Cell<usize>,

}

impl<T> RecursiveLock<T> {

    /// Creates a new `RecursiveLock` with the given data.

    /// Creates a new `RecursiveLock` from an existing `BfSharedMutex`.

    delegate::delegate! {

        to self.inner {

            #[cfg(not(loom))]

            #[cfg(loom)]

            pub fn data_ptr(&self) -> loom::cell::ConstPtr<T>;

        }

    }

    /// Acquires a write lock on the mutex.

    ///

    /// # Panics

    ///

    /// Panics when called inside a read or write section. In that case the underlying mutex

    /// would not wait for this thread's own lock, handing out `&mut T` while a `&T` or another

    /// `&mut T` is live.

            "Cannot call write() inside an existing read or write section"

        );

        // Acquire the underlying lock before touching any bookkeeping, so a

        // failed acquisition leaves the recursive state untouched.

    /// Acquires a write lock on the mutex without blocking.

    ///

    /// # Panics

    ///

    /// Panics when called inside a read or write section. In that case the underlying mutex

    /// would not wait for this thread's own lock, handing out `&mut T` while a `&T` or another

    /// `&mut T` is live.

            "Cannot call try_write() inside an existing read or write section"

        );

        // Acquire the underlying lock before touching any bookkeeping, so a

        // failed acquisition leaves the recursive state untouched.

        } else {

        }

    /// Acquires a read lock on the mutex.

    ///

    /// # Panics

    ///

    /// Panics when called inside a read or write section; the raw read lock is not reentrant.

    /// Use [`RecursiveLock::read_recursive`] instead.

            "Cannot call read() inside an existing read or write section"

        );

    /// Acquires a read lock on the mutex, allowing for recursive read locking.

    ///

    /// May also be called inside a write section: the returned guard then borrows the write

    /// lock instead of acquiring the underlying mutex. While such a guard is alive, mutating

    /// through the [`RecursiveLockWriteGuard`] panics.

            // Not yet holding a read lock: acquire the shared protocol lock without

            // materialising a guard, so the busy flag stays set until our own guard

            // releases it (via `create_read_guard_unchecked` on drop). The acquisition

            // happens before the bookkeeping is updated, so a failed acquisition leaves

            // the recursive state untouched.

    /// Returns the number of times `write()` has been called.

    /// Returns the number of times `read_recursive()` has been called.

}

#[must_use = "Dropping the guard unlocks the recursive lock immediately"]

pub struct RecursiveLockReadGuard<'a, T> {

    mutex: &'a RecursiveLock<T>,

    #[cfg(loom)]

    ptr: loom::cell::ConstPtr<T>,

}

impl<T> RecursiveLockReadGuard<'_, T> {

    /// Returns the read depth of the recursive lock.

}

/// Allow dereferences the underlying object.

impl<T> Deref for RecursiveLockReadGuard<'_, T> {

    type Target = T;

        // SAFETY: This guard keeps the read lock (or the enclosing write lock) held, so only

        // shared access is handed out and the data pointer (an `UnsafeCell::get`) is non-null.

        #[cfg(not(loom))]

        unsafe {

        }

        #[cfg(loom)]

        unsafe {

            self.ptr.deref()

        }

}

impl<T> Drop for RecursiveLockReadGuard<'_, T> {

            // SAFETY: The depth reached zero, so the outermost `read_recursive` forgot a real read

            // guard that still holds this thread's `busy` flag. Reconstructing and immediately

            // dropping a guard releases that flag exactly once, matching the forgotten guard.

}

#[must_use = "Dropping the guard unlocks the recursive lock immediately"]

pub struct RecursiveLockWriteGuard<'a, T> {

    mutex: &'a RecursiveLock<T>,

    guard: BfSharedMutexWriteGuard<'a, T>,

}

/// Allow dereferences the underlying object.

impl<T> Deref for RecursiveLockWriteGuard<'_, T> {

    type Target = T;

        // We hold the write guard, so immutable access is safe; defer to it rather than taking a

        // second loom borrow of the cell, which would conflict with the guard's mutable borrow.

}

/// Allow dereferences the underlying object.

impl<T> DerefMut for RecursiveLockWriteGuard<'_, T> {

    /// # Panics

    ///

    /// Panics while a recursive read guard taken inside this write section is alive. Such a

    /// guard hands out `&T` derived from the data pointer, invisible to the borrow checker,

    /// so a `&mut T` would alias it.

            "Cannot mutate through RecursiveLockWriteGuard while recursive read guards from its write section are alive"

        );

        // We hold the write guard exclusively and no recursive read guards exist, so mutable

        // access is safe.

}

impl<T> Drop for RecursiveLockWriteGuard<'_, T> {

        // Read guards taken with `read_recursive()` inside this write section borrow the write

        // lock: once this guard drops, the underlying mutex is released and their `&T` would be

        // unprotected. Panic instead of silently allowing that use-after-unlock.

            "RecursiveLockWriteGuard dropped while recursive read guards from its write section are still alive"

        );

}

#[cfg(test)]

mod tests {

    use crate::BfSharedMutex;

    use crate::RecursiveLock;

    #[test]

    #[test]

    #[test]

    #[test]

        // Piggybacks on the write lock instead of acquiring the underlying mutex.

        // Mutation is allowed again once the read guard is gone.

    #[test]

        // Initially, the counter should be 0

        // After one write call, counter should be 1

        {

        }

        // After another write call, counter should be 2

        {

        }

        // Counter should remain 2

    #[test]

        // Initially, the counter should be 0

        // After one read_recursive call, counter should be 1

        {

        }

        // After another read_recursive call, counter should be 2

        {

        }

        // Test nested recursive reads increment the counter

        {

        }

        // Counter should remain 4

    #[test]

    #[cfg(loom)]

    fn test_loom_recursive_lock() {

        let mut builder = loom::model::Builder::new();

        // Mirrors the bound used for the underlying busy-forbidden mutex.

        builder.preemption_bound = Some(2);

        builder.check(|| {

            let mutex = BfSharedMutex::new(0usize);

            let threads: Vec<_> = (0..2)

                .map(|_| {

                    let mutex = mutex.clone();

                    loom::thread::spawn(move || {

                        // `RecursiveLock` is !Sync, so each thread wraps its own clone of the

                        // shared mutex; the recursion depth is then tracked per thread.

                        let lock = RecursiveLock::from_mutex(mutex);

                        // Nested recursive reads must observe a single consistent value and

                        // release the underlying read lock exactly once when the outermost

                        // guard drops.

                        {

                            let outer = lock.read_recursive().unwrap();

                            let inner = lock.read_recursive().unwrap();

                            assert_eq!(*outer, *inner);

                            assert_eq!(inner.read_depth(), 2);

                        }

                        // Exclusive access through the recursive write path.

                        *lock.write().unwrap() += 1;

                    })

                })

                .collect();

            for th in threads {

                th.join().unwrap();

            }

        });

    }

    #[test]

        // Initially, both counters should be 0

        // Call write and check counters

        {

        }

        // Call read_recursive and check counters

        {

        }

        // Call write again

        {

        }

        // Call read_recursive multiple times

        {

        }

}