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

use std::cell::UnsafeCell;

use std::error::Error;

use std::fmt::Debug;

use std::ops::Deref;

use std::ops::DerefMut;

use std::sync::Arc;

use std::sync::Mutex;

use std::sync::MutexGuard;

use std::sync::atomic::AtomicBool;

use std::sync::atomic::Ordering;

use crossbeam_utils::CachePadded;

/// A shared mutex (readers-writer lock) implementation based on the so-called

/// busy-forbidden protocol.

///

/// # Details

///

/// Compared to a regular [std::sync::Mutex] this struct is Send but not Sync.

/// This means that every thread must acquire a clone of the shared mutex and

/// the cloned instances of the same shared mutex guarantee shared access

/// through the `read` operation and exclusive access for the `write` operation

/// of the given object.

pub struct BfSharedMutex<T> {

    /// The local control bits of each instance.

    ///

    /// TODO: Maybe use pin to share the control bits among shared mutexes.

    control: Arc<CachePadded<SharedMutexControl>>,

    /// Index into the `other` table.

    index: usize,

    /// Information shared between all clones.

    shared: Arc<CachePadded<SharedData<T>>>,

}

// Can only be send, but is not sync

unsafe impl<T> Send for BfSharedMutex<T> {}

/// The busy and forbidden flags used to implement the protocol.

#[derive(Default)]

struct SharedMutexControl {

    busy: AtomicBool,

    forbidden: AtomicBool,

}

/// The shared data between all instances of the shared mutex.

struct SharedData<T> {

    /// The object that is being protected.

    object: UnsafeCell<T>,

    /// The list of all the shared mutex instances.

    other: Mutex<Vec<Option<Arc<CachePadded<SharedMutexControl>>>>>,

}

impl<T> BfSharedMutex<T> {

    /// Constructs a new shared mutex for protecting access to the given object.

}

impl<T> Clone for BfSharedMutex<T> {

        // Register a new instance in the other list.

}

impl<T> Drop for BfSharedMutex<T> {

        // Remove ourselves from the table.

}

/// The guard object for exclusive access to the underlying object.

#[must_use = "Dropping the guard unlocks the shared mutex immediately"]

pub struct BfSharedMutexWriteGuard<'a, T> {

    mutex: &'a BfSharedMutex<T>,

    guard: MutexGuard<'a, Vec<Option<Arc<CachePadded<SharedMutexControl>>>>>,

}

/// Allow dereferencing the underlying object.

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

    type Target = T;

        // We are the only guard after `write()`, so we can provide immutable access to the underlying object. (No mutable references the guard can exist)

}

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

        // We are the only guard after `write()`, so we can provide mutable access to the underlying object.

}

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

        // Allow other threads to acquire access to the shared mutex.

        // The mutex guard is then dropped here.

}

pub struct BfSharedMutexReadGuard<'a, T> {

    mutex: &'a BfSharedMutex<T>,

}

/// Allow dereferences the underlying object.

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

    type Target = T;

        // There can only be shared guards, which only provide immutable access to the object.

}

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

            "Cannot unlock shared lock that was not acquired"

        );

}

impl<T> BfSharedMutex<T> {

    /// Provides read access to the underlying object, allowing multiple immutable references to it.

    #[inline]

            "Cannot acquire read access again inside a reader section"

        );

            // Wait for the mutex of the writer.

        }

        // We now have immutable access to the object due to the protocol.

    /// Creates a new `BfSharedMutexReadGuard` without checking if the lock is held.

    ///

    /// # Safety

    ///

    /// This method must only be called if the thread logically holds a read lock.

    ///

    /// This function does not increment the read count of the lock. Calling this function when a

    /// guard has already been produced is undefined behaviour unless the guard was forgotten

    /// with `mem::forget`.

    #[inline]

    /// Returns a raw pointer to the underlying data.

    ///

    /// This is useful when combined with `mem::forget` to hold a lock without

    /// the need to maintain a `RwLockReadGuard` or `RwLockWriteGuard` object

    /// alive, for example when dealing with FFI.

    ///

    /// # Safety

    ///

    /// You must ensure that there are no data races when dereferencing the

    /// returned pointer, for example if the current thread logically owns a

    /// `RwLockReadGuard` or `RwLockWriteGuard` but that guard has been discarded

    /// using `mem::forget`.

    #[inline]

    /// Provide write access to the underlying object, only a single mutable reference to the object exists.

    #[inline]

            "Can only exclusive lock outside of a shared lock, no upgrading!"

        );

            "Can not acquire exclusive lock inside of exclusive section"

        );

        // Make all instances wait due to forbidden access.

                "Other instance is already forbidden, this cannot happen"

            );

        }

        // Wait for the instances to exit their busy status.

        }

        // We now have exclusive access to the object according to the protocol

    /// Check if the shared mutex is locked shared, meaning no other thread has a read lock.

    /// Check if the shared mutex is locked exclusively, meaning no other thread has a lock.

    /// Obtain mutable access to the object without locking, is safe because we have mutable access.

}

impl<T: Debug> Debug for BfSharedMutex<T> {

        }

}

/// A global shared mutex that can be used to protect global data.

///

/// # Details

///

/// This is a wrapper around `BfSharedMutex` that provides a global instance

/// that can be used to protect global data. Must be cloned to obtain mutable

/// access.

pub struct GlobalBfSharedMutex<T> {

    /// The shared mutex that is used to protect the global data.

    pub shared_mutex: BfSharedMutex<T>,

}

impl<T> GlobalBfSharedMutex<T> {

    /// Constructs a new global shared mutex for protecting access to the given object.

    /// Returns a clone of the global shared mutex, which allows writing and reading.

}

// Can be Send and Sync, because it cannot be mutated anyway.

unsafe impl<T: Send> Send for GlobalBfSharedMutex<T> {}

unsafe impl<T: Send> Sync for GlobalBfSharedMutex<T> {}

#[cfg(test)]

mod tests {

    use crate::bf_sharedmutex::BfSharedMutex;

    use rand::prelude::*;

    use std::hint::black_box;

    use merc_utilities::random_test_threads;

    use merc_utilities::test_threads;

    // These are just simple tests.

    #[test]

    #[cfg_attr(miri, ignore)]

        );

    #[test]

    #[cfg_attr(miri, ignore)]

                    // Read a random index.

        );

}