use std::cmp::Ordering;

use std::collections::VecDeque;

use std::fmt;

use std::hash::Hash;

use std::hash::Hasher;

use std::marker::PhantomData;

use std::sync::Arc;

use std::sync::Mutex;

use delegate::delegate;

use merc_sharedmutex::RecursiveLockReadGuard;

use merc_unsafety::ProtectionIndex;

use merc_unsafety::ProtectionSet;

use merc_unsafety::StablePointer;

use merc_utilities::MercError;

use merc_utilities::PhantomUnsend;

use crate::ATermIntRef;

use crate::ATermList;

use crate::Markable;

use crate::Symb;

use crate::SymbolRef;

use crate::Transmutable;

use crate::is_empty_list_term;

use crate::is_int_term;

use crate::is_list_term;

use crate::storage::GlobalTermPool;

use crate::storage::Marker;

use crate::storage::SharedTerm;

use crate::storage::THREAD_TERM_POOL;

/// The ATerm trait represents a first-order term in the ATerm library.

/// It provides methods to manipulate and access the term's properties.

///  

/// # Details

///

/// This trait is rather complicated with two lifetimes, but this is used

/// to support both the [ATerm], which has no lifetimes, and [ATermRef<'a>]

/// whose lifetime is bound by `'a`. Because now we can require that `'b: 'a`

/// for the implementation of [Term<'a, 'b>] for [ATerm], we can safely return

/// [ATermRef<'a>] from methods of [Term<'a, 'b>]. Further explanation can be

/// found on the website.

pub trait Term<'a, 'b> {

    /// Protects the term from garbage collection, returning an owned [ATerm].

    fn protect(&self) -> ATerm;

    /// Returns the indexed argument of the term as an [ATermRef].

    fn arg(&'b self, index: usize) -> ATermRef<'a>;

    /// Returns the list of arguments as an [ATermArgs] collection.

    fn arguments(&'b self) -> ATermArgs<'a>;

    /// Makes a copy of the term, returning an [ATermRef] with the same lifetime as itself.

    fn copy(&'b self) -> ATermRef<'a>;

    /// Returns the head symbol of the term as a [SymbolRef].

    fn get_head_symbol(&'b self) -> SymbolRef<'a>;

    /// Returns a [TermIterator] over all arguments of the term in pre-order traversal.

    fn iter(&'b self) -> TermIterator<'a>;

    /// Returns a unique index of the term in the term pool.

    fn index(&self) -> usize;

    /// Returns the [ATermIndex] of the term in the term pool.

    fn shared(&self) -> &ATermIndex;

}

/// Type alias for [ATerm] indices, representing a stable pointer to a [SharedTerm] in the term pool.

pub type ATermIndex = StablePointer<SharedTerm>;

/// This represents a lifetime bound reference to an existing [ATerm].

#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]

pub struct ATermRef<'a> {

    shared: ATermIndex,

    marker: PhantomData<&'a ()>,

}

// /// Check that the ATermRef is the same size as a usize.

// #[cfg(not(debug_assertions))]

// const _: () = assert!(std::mem::size_of::<ATermRef>() == std::mem::size_of::<usize>());

// /// Since we have NonZero we can use a niche value optimisation for option.

// #[cfg(not(debug_assertions))]

// const _: () = assert!(std::mem::size_of::<Option<ATermRef>>() == std::mem::size_of::<usize>());

/// These are safe because terms are immutable. Garbage collection is

/// always performed with exclusive access, and reference terms have no thread-local state.

unsafe impl Send for ATermRef<'_> {}

unsafe impl Sync for ATermRef<'_> {}

impl ATermRef<'_> {

    /// Creates a new term reference from the given [ATermIndex].

    ///

    /// # Safety

    ///

    /// This function is unsafe because it does not check if the index is valid for the given lifetime.

}

impl<'a, 'b> Term<'a, 'b> for ATermRef<'a> {

            "arg({index}) is not defined for term {self:?}"

        );

        // Safety: self is ATermRef<'a>, so the GC keeps all its arguments

        // protected for 'a. We copy the stable pointer rather than borrowing

        // through the short-lived slice reference.

        // SAFETY: `self` is an `ATermRef<'a>`, so the GC keeps the term alive

        // for `'a` and the pointee is valid to read.

}

impl Markable for ATermRef<'_> {

}

impl fmt::Display for ATermRef<'_> {

}

impl fmt::Debug for ATermRef<'_> {

        } else {

            // Format the term with its head symbol and arguments, avoiding trailing comma

            }

        }

}

/// The protected version of [ATermRef], mostly derived from it.

///

/// # Safety

///

/// Note that terms use thread-local state for their protection mechanism, so

/// [ATerm] is not [Send]. Moreover, this means that terms cannot be stored in

/// thread-local storage themselves, or at least must be destroyed before the

/// thread exists, because the order in which thread-local destructors are

/// called is undefined. For this purpose one can use `ManuallyDrop` to simply

/// never drop thread local terms, since exiting the thread will clean up the

/// protection sets anyway.

///

/// We do not mark term access as unsafe, since that would make their use

/// cumbersome. An alternative would be to require

/// THREAD_TERM_POOL.with(|tp| ...) around every access, but that would

/// be very verbose.

pub struct ATerm {

    term: ATermRef<'static>,

    /// The root of the term in the protection set

    root: ProtectionIndex,

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

    // mechanism. However, it can be Sync since terms are immutable, and unlike

    // `Rc` cloning results in a local protected copy.

    _marker: PhantomUnsend,

}

impl ATerm {

    /// Creates a new term with the given symbol and arguments.

    /// Creates a new term with the given symbol and an iterator over the arguments.

    {

    /// Creates a new term with the given symbol and an iterator over the arguments.

    {

    /// Creates a new term with the given symbol and a head term, along with a list of arguments.

    {

    /// Creates a new constant term (arity 0) for the given symbol.

    /// Constructs a term from the given string.

    /// Returns the term as a borrowed [ATermRef].

    /// Returns the root of the term

    /// Replace this term by the given term in place.

    {

        // Replace the current term in the protection set by the value.

        // SAFETY: `value` still holds the recursive read guard, so no garbage

        // collection can run before `tp.replace` registers this index under

        // `self.root`; from then on the protection set keeps the term alive

        // until this `ATerm` unprotects it.

        // Set the term itself.

    /// Creates a new term from the given reference and protection set root

    /// entry.

        unsafe {

        }

}

impl<'a, 'b> Term<'a, 'b> for ATerm

where

    'b: 'a,

{

    delegate! {

        to self.term {

        }

    }

}

impl Markable for ATerm {

}

impl Drop for ATerm {

}

impl Clone for ATerm {

}

impl fmt::Display for ATerm {

}

impl fmt::Debug for ATerm {

}

impl Hash for ATerm {

}

impl PartialEq for ATerm {

}

impl PartialOrd for ATerm {

}

impl Ord for ATerm {

}

impl Eq for ATerm {}

/// A sendable variant of an `ATerm`.

///

/// # Details

///

/// Keeps track of an internal reference to the protection set it was protected from to ensure proper cleanup.

pub struct ATermSend {

    term: ATermRef<'static>,

    /// The root of the term in the protection set

    root: ProtectionIndex,

    /// A shared reference to the protection set that this term was created in.

    protection_set: Arc<Mutex<ProtectionSet<ATermIndex>>>,

}

unsafe impl Send for ATermSend {}

unsafe impl Sync for ATermSend {}

impl ATermSend {

    /// Takes ownership of an `ATerm` and makes it send.

        // We need to insert the term into the protection set of the current

        // thread, and keep track of the root index to properly unprotect it on

        // drop.

        // SAFETY: `term` keeps the index alive during this call, and inserting

        // the copy into the send-term protection set makes it a GC root until

        // the `ATermSend` is dropped.

}

impl Drop for ATermSend {

        };

        // SAFETY: `self.root` was protected when this `ATermSend` was created and

        // `Drop` runs exactly once, so the root is unprotected exactly once.

}

impl<'a, 'b> Term<'a, 'b> for ATermSend

where

    'b: 'a,

{

    delegate! {

        to self.term {

        }

    }

}

/// This is a wrapper around a term that indicates it is being returned from a

/// function.

///

/// The resulting term can have a lifetime tied to the thread-local term pool.

pub struct Return<T> {

    term: T,

    guard: RecursiveLockReadGuard<'static, GlobalTermPool>,

}

impl<T> Return<T> {

    /// Creates a new return value wrapping the given term.

    /// Casts the inner term to another type, while keeping the same guard.

    {

}

impl<T: Transmutable> Return<T> {

    /// Maps the inner term to another type, while keeping the same guard.

        // SAFETY: The returned lifetime is bound to the borrow of `self` by the signature.

}

impl<'a, 'b, T: Term<'a, 'b>> Term<'a, 'b> for Return<T>

where

    'b: 'a,

{

    delegate! {

        to self.term {

        }

    }

}

/// An iterator over the arguments of a term.

pub struct ATermArgs<'a> {

    term: Option<ATermRef<'a>>,

    arity: usize,

    index: usize,

}

impl<'a> ATermArgs<'a> {

}

impl<'a> Iterator for ATermArgs<'a> {

    type Item = ATermRef<'a>;

        } else {

        }

        // Report the exact remaining length so adapters such as `Skip` and `Map` keep

        // satisfying the `ExactSizeIterator` invariant (upper bound == lower bound).

}

impl DoubleEndedIterator for ATermArgs<'_> {

        } else {

        }

}

impl ExactSizeIterator for ATermArgs<'_> {

}

/// An iterator over all subterms of the given [ATerm] in preorder traversal, i.e.,

/// for f(g(a), b) we visit f(g(a), b), g(a), a, b.

pub struct TermIterator<'a> {

    queue: VecDeque<ATermRef<'a>>,

}

impl TermIterator<'_> {

}

impl<'a> Iterator for TermIterator<'a> {

    type Item = ATermRef<'a>;

                // Put subterms in the queue

            }

        }

}

/// Blanket implementation allowing passing borrowed terms as references.

/// TODO: Why is this necessary.

impl<'a, 'b, T: Term<'a, 'b>> Term<'a, 'b> for &'b T {

}

#[cfg(test)]

mod tests {

    use std::sync::Arc;

    use parking_lot::Mutex;

    use crate::ATerm;

    use crate::ATermSend;

    use crate::Symbol;

    use crate::Term;

    use crate::storage::THREAD_TERM_POOL;

    #[test]

        // An ATermSend created on a thread must keep its term alive after that thread exits,

        // even across garbage collection. This pins the invariant relied upon when GC reclaims

        // the send-term protection set slots of exited threads: a slot must not be released while

        // a live ATermSend still references it.

        // The creating thread has exited; force collections from this thread.

        // The term must still be alive and structurally intact.

    #[test]

    #[cfg_attr(miri, ignore)] // This test runs too slow under miri.

        // Run two threads that create and drop sendable terms, and check that the protection set is properly cleaned up.

        };

}