#[cfg(debug_assertions)]

use std::cell::RefCell;

use std::fmt::Debug;

use std::hash::Hash;

use std::mem::transmute;

use std::ops::Deref;

use std::ops::DerefMut;

use std::sync::Arc;

use merc_collections::ProtectionIndex;

use merc_utilities::PhantomUnsend;

use crate::Markable;

use crate::Symb;

use crate::SymbolRef;

use crate::Term;

use crate::Transmutable;

use crate::aterm::ATermRef;

use crate::storage::GcMutex;

use crate::storage::GcMutexGuard;

use crate::storage::THREAD_TERM_POOL;

/// 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<GcMutex<C>>,

    root: ProtectionIndex,

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

    // mechanism.

    _unsend: PhantomUnsend,

}

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

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

    /// Provides mutable access to the underlying container.

        // The lifetime of ATermRef can be derived from self since it is protected by self, so transmute 'static into 'a.

    /// Provides immutable access to the underlying container.

}

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

}

impl<C: Clone + Markable + Send + Transmutable + '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> {

}

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

    reference: GcMutexGuard<'a, C>,

    /// Terms that have been protected during the lifetime of this guard.

    #[cfg(debug_assertions)]

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

    /// Symbols that have been protected during the lifetime of this guard.

    #[cfg(debug_assertions)]

    protected_symbols: RefCell<Vec<SymbolRef<'static>>>,

}

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

        #[cfg(debug_assertions)]

        #[cfg(not(debug_assertions))]

        return ProtectedWriteGuard { reference };

    /// Yields a term to insert into the container.

    ///

    /// # Safety

    ///

    /// The invariant to uphold is that the resulting term MUST be inserted into the container. This is checked in debug mode, but not in release mode. If this invariant is violated, undefined behaviour may occur during garbage collection.

    /// We do not mark this function unsafe since that would make its use cumbersome.

        unsafe {

            // Store terms that are marked as protected to check if they are

            // actually in the container when the protection is dropped.

            #[cfg(debug_assertions)]

        }

    /// Yields a symbol to insert into the container.

    ///

    /// The invariant to uphold is that the resulting symbol MUST be inserted into the container.

        unsafe {

            // Store symbols that are marked as protected to check if they are

            // actually in the container when the protection is dropped.

            #[cfg(debug_assertions)]

        }

}

#[cfg(debug_assertions)]

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

        {

                    "Term was protected but not actually inserted"

                );

            }

                    "Symbol was protected but not actually inserted"

                );

            }

        }

}

impl<'a, C: Markable + Transmutable + 'a> Deref for ProtectedWriteGuard<'a, C> {

    type Target = C::Target<'a>;

}

impl<C: Markable + Transmutable> DerefMut for ProtectedWriteGuard<'_, C> {

}

pub struct ProtectedReadGuard<'a, C> {

    reference: GcMutexGuard<'a, C>,

}

impl<'a, C> ProtectedReadGuard<'a, C> {

}

impl<'a, C: Transmutable> Deref for ProtectedReadGuard<'a, C> {

    type Target = C::Target<'a>;

}

#[cfg(test)]

mod tests {

    use crate::ATerm;

    use super::*;

    #[test]

        // First test the trait for a standard container.

}