use std::fmt::Debug;

use std::hash::Hash;

use std::mem::transmute;

use std::ops::Deref;

use std::ops::DerefMut;

use std::pin::Pin;

use std::sync::Arc;

use mcrl2_sys::atermpp::ffi;

use utilities::PhantomUnsend;

use crate::aterm::ATermRef;

use crate::aterm::BfTermPool;

use crate::aterm::THREAD_TERM_POOL;

use super::BfTermPoolThreadWrite;

#[cfg(debug_assertions)]

use std::cell::RefCell;

/// A container of objects, typically either terms or objects containing terms,

/// that are of trait Markable. These store ATermRef<'static> that are protected

/// during garbage collection by being in the container itself.

pub struct Protected<C> {

    container: Arc<BfTermPool<C>>,

    root: usize,

    // Protected is not Send because it uses thread-local state for its protection

    // mechanism.

    _unsend: PhantomUnsend,

}

impl<C: Markable + Send + 'static> Protected<C> {

    /// Creates a new Protected container from a given container.

    /// Provides mutable access to the underlying container. Use [Protector::protect] of

    /// the resulting guard to be able to insert terms into the container.

    /// Otherwise the borrow checker will note that the [ATermRef] do not

    /// outlive the guard, see [Protector].

    /// Provides immutable access to the underlying container.

}

impl<C: Default + Markable + Send + 'static> Default for Protected<C> {

}

impl<C: Clone + Markable + Send + 'static> Clone for Protected<C> {

}

impl<C: Hash + Markable> Hash for Protected<C> {

}

impl<C: PartialEq + Markable> PartialEq for Protected<C> {

}

impl<C: PartialOrd + Markable> PartialOrd for Protected<C> {

}

impl<C: Debug + Markable> Debug for Protected<C> {

}

impl<C: Eq + PartialEq + Markable> Eq for Protected<C> {}

impl<C: Ord + PartialEq + PartialOrd + Markable> Ord for Protected<C> {

}

impl<C> Drop for Protected<C> {

}

/// A type for the todo queue.

pub type Todo<'a> = Pin<&'a mut ffi::term_mark_stack>;

/// This trait should be used on all objects and containers related to storing unprotected terms.

pub trait Markable {

    /// Marks all the ATermRefs to prevent them from being garbage collected.

    fn mark(&self, todo: Todo);

    /// Should return true iff the given term is contained in the object. Used for runtime checks.

    fn contains_term(&self, term: &ATermRef<'_>) -> bool;

    /// Returns the number of terms in the instance, used to delay garbage collection.

    fn len(&self) -> usize;

    /// Returns true iff the container is empty.

}

impl Markable for ATermRef<'_> {

}

impl<T: Markable> Markable for Vec<T> {

}

impl<T: Markable + ?Sized> Markable for BfTermPool<T> {

}

/// This is a helper struct used by TermContainer to protected terms that are

/// inserted into the container before the guard is dropped.

///

/// The reason is that the ATermRef derive their lifetime from the

/// TermContainer. However, when inserting terms with shorter lifetimes we know

/// that their lifetime is extended by being in the container. This is enforced

/// by runtime checks during debug for containers that implement IntoIterator.

pub struct Protector<'a, C: Markable> {

    reference: BfTermPoolThreadWrite<'a, C>,

    #[cfg(debug_assertions)]

    protected: RefCell<Vec<ATermRef<'static>>>,

}

impl<'a, C: Markable> Protector<'a, C> {

}

impl<C: Markable> Deref for Protector<'_, C> {

    type Target = C;

}

impl<C: Markable> DerefMut for Protector<'_, C> {

}

impl<C: Markable> Drop for Protector<'_, C> {

        #[cfg(debug_assertions)]

        {

                );

            }

        }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::aterm::TermPool;

    #[test]

}