/*
 * @Copyright 2020 Jason Carr
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

use alloc::{
    rc,
    rc::Rc,
    boxed::Box,
    vec::Vec
};
use core::cell::Cell;
use core::fmt;
use core::marker::PhantomData;


/**
 * A raw index for a region, that should be used for internal edges.
 * 
 * This index is invalidated by many operations. but locations which
 * have always been exposed exactly once by foreach_ix for each collection are
 * guaranteed to have an index which is valid.
 *
 * Furthermore, indices received from a MutEntry or Root/Weak are
 * valid when retrieved.
 *
 * An Ix is valid so long as no invalidating methods have been called.
 * Borrowing rules ensure several situations in which no invalidating method can be called:
 *  - An immutable reference to the region exists
 *  - A mutable or immutable reference to any element of this region exists, such as those
 *    acquired via Ix::get.
 *  - A MutEntry for this region exists.
 *
 * If an Ix is not valid for the given region, behavior is unspecified but safe,
 * A valid instance of T may be returned. Panics may occur with get and get_mut.
 * If the index is valid, then it still points to the expected object.
 */
#[repr(C)]
// repr(C) Needed for unsafe header
// Note that Ix<T> can pack any set of
// bits whatsoever
pub struct Ix<T> {
    ix: usize,
    _t: PhantomData<*mut T>,
    #[cfg(feature = "debug-arena")]
    pub(crate) nonce: u64,
    #[cfg(feature = "debug-arena")]
    pub(crate) generation: u64,
}
impl <T> fmt::Debug for Ix<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("Ix(")?;
        self.ix.fmt(f)?;
        #[cfg(feature = "debug-arena")]
        {
            f.write_str("; ")?;
            self.nonce.fmt(f)?;
            f.write_str(", ")?;
            self.generation.fmt(f)?;
        }
        f.write_str(")")?;
        Ok(())
    }
}
impl <T> Clone for Ix<T> {
    fn clone(&self) -> Self {
        Ix {
            ix: self.ix,
            _t: PhantomData,
            #[cfg(feature = "debug-arena")]
            nonce: self.nonce,
            #[cfg(feature = "debug-arena")]
            generation: self.generation,
        }
    }
}
impl <T> Copy for Ix<T> {}
unsafe impl <T> Send for Ix<T> {}
unsafe impl <T> Sync for Ix<T> {}
impl <T> PartialEq for Ix<T> {
    fn eq(&self, other: &Ix<T>) -> bool {
        #[cfg(feature = "debug-arena")]
        {
            if self.nonce != other.nonce {
                panic!("Tested equality for indices into two different regions");
            }
            if self.generation != other.generation {
                panic!("Tested equality for indices in two different generations");
            }
        }

        self.ix == other.ix
    }
}
/**
 * If indices are in different regions or different generations,
 * then behavior is unspecified: this may return true, false,
 * or panic, obeying symmetry and transitivity.
 *
 * In practice, it will panic if and only if
 * the "debug-arena" feature is active.
 */
impl <T> Eq for Ix<T> { }


impl <T> Ix<T> {
    pub(crate) fn new(ix: usize,
                      #[cfg(feature = "debug-arena")]
                      nonce: u64,
                      #[cfg(feature = "debug-arena")]
                      generation: u64,
    ) -> Self {
        Ix { ix, _t: PhantomData,
            #[cfg(feature = "debug-arena")]
            nonce,
            #[cfg(feature = "debug-arena")]
            generation, }
    }

    #[inline(always)]
    pub(crate) fn ix(self) -> usize {self.ix}

    /**
     * Get an identifier for this index.
     * It is unique amongst indices in this region,
     * so long as they have not been invalidated.
     *
     * Like the index itself, uniqueness is only
     * guaranteed as long as the index has not been
     * invalidated.
     */
    #[inline(always)]
    pub fn identifier(self) -> usize {self.ix}
}
pub(crate) type IxCell<T> = Cell<Ix<T>>;

pub enum SpotVariant<'a, E, T> {
    Present(&'a mut E),
    BrokenHeart(Ix<T>),
}

/**
 * A weak index into a region.
 *
 * This index will never prevent an
 * object from being collected, but
 * can be used to test if an object
 * has been collected, or access
 * it as normal.
 */
pub struct Weak<T> {
    pub(crate) cell: rc::Weak<IxCell<T>>
}

impl <T> Weak<T> {
    // NOTE: change for 0.3.0
    /**
     * Get the raw index pointed to this by external index.
     * All validity caveats of indices apply, so this should
     * most likely be used only to move into a location
     * that is owned by an element of the Region
     */
    #[inline(always)]
    pub fn ix(&self) -> Option<Ix<T>> {
        Some(self.cell.upgrade()?.get())
    }
    #[inline(always)]
    pub fn try_ix(&self) -> Result<Ix<T>, Error> {
        Ok(self.cell.upgrade().ok_or(Error::EntryExpired)?.get())
    }
}
impl <T> Clone for Weak<T> {
    fn clone(&self) -> Self {
        Weak {cell: self.cell.clone()}
    }
}
impl <T> fmt::Debug for Weak<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Weak(")?;
        self.cell.upgrade().map(|c| c.get()).fmt(f)?;
        f.write_str(")")?;
        Ok(())
    }
}
impl <T> PartialEq for Weak<T> {
    fn eq(&self, other: &Weak<T>) -> bool {
        alloc::rc::Weak::ptr_eq(&self.cell, &other.cell)
    }
}
impl <T> Eq for Weak<T> { }

/**
 * An external rooted index into a region.
 *
 * Roots will always keep the objects they
 * point to live in the appropriate region.
 *
 * Roots should generally not be used within a region,
 * instead use [`Ix`](struct.Ix.html).
 * A root that is inside its own region will never
 * be collected and is vulnerable to the same issues
 * as Rc. Similarly, roots between two different regions
 * may cause uncollectable reference cycles.
 */
pub struct Root<T> {
    pub(crate) cell: Rc<IxCell<T>>
}
impl <T> Clone for Root<T> {
    fn clone(&self) -> Self {
        Root {cell: self.cell.clone()}
    }
}
impl <T> fmt::Debug for Root<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Root(")?;
        self.cell.get().fmt(f)?;
        f.write_str(")")?;
        Ok(())
    }
}
impl <T> PartialEq for Root<T> {
    fn eq(&self, other: &Root<T>) -> bool {
        alloc::rc::Rc::ptr_eq(&self.cell, &other.cell)
    }
}
impl <T> Eq for Root<T> { }


/**
 * A root is always a valid pointer into its corresponding region, regardless of
 * the presence of any garbage collections.
 */
impl <T> Root<T> {

    /**
     * Get the raw index pointed to this by external index.
     * All validity caveats of indices apply, so this should
     * most likely be used only to move into a location
     * that is owned by an element of the Region
     */
    #[inline(always)]
    pub fn ix(&self) -> Ix<T> {
        self.cell.get()
    }

    pub fn weak(&self) -> Weak<T> {
        Weak {
            cell: rc::Rc::downgrade(&self.cell)
        }
    }

    // returns true if there are enough roots
    // for this to certainly be rooted already,
    // assuming that it's used twice, once for
    // the entry and once for the roots vec
    pub(crate) fn is_rooted(&self) -> bool {
        // 3 because:
        // If we're rooted then we have
        // 1 inside the entry
        // 1 inside the roots list
        // at least 1 outside the region
        Rc::strong_count(&self.cell) >= 3
    }

    pub(crate) fn is_weaked(&self) -> bool {
        Rc::weak_count(&self.cell) >= 1
    }
}


#[derive(Debug, PartialEq, Eq)]
#[allow(unused)]
/**
 * Type of region access errors.
 */
pub enum Error {
    /**
     * Incorrect usage resulted in an error,
     * but the system does not have enough data
     * to determine exactly what the error was.
     *
     * Enabling the feature "debug-arena" will
     * allow the library to have appropriate data
     * in most cases, with high costs to space usage.
     */
    Indeterminable,
    /**
     * This index has been used with a region for
     * which it was not created.
     */
    IncorrectRegion,
    /**
     * This index has been invalidated by a garbage
     * collection.
     */
    EntryExpired,
    /**
     * This library is in an unexpected internal state.
     * It is not expected that any valid rust code
     * will be able receive this error, so encountering
     * it is likely a bug in the library.
     */
    // It can also occur if e.g. 2^64 collections occur
    // with debug-arena. That is of course still unexpected
    // and still requires an error to occur.
    UnexpectedInternalState,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        match self {
            Error::Indeterminable => write!(f, "Invalid index"),
            Error::IncorrectRegion => write!(f, "Incorrect region for index"),
            Error::EntryExpired => write!(f, "Index expired"),
            Error::UnexpectedInternalState => write!(f, "Correct region has invalid internal state"),
        }
    }

}

/**
 * Trait to expose contained indices to the garbage collector.
 */
pub trait HasIx<T : 'static> {
    /**
     * Expose a mutable reference to every Ix owned
     * by this datastructure. Any Ix which is not
     * exposed by this function will be invalidated
     * by a garbage collection. The object which
     * was pointed to may also have been collected.
     *
     * If some Ix is owned by two or more instances of
     * this type (such as via Rc<Cell<...>>),
     * then the situation is tricker. Because
     * this is an uncommon use case, and because
     * enforcing uniqueness in the collector would
     * create additional space and time overheads,
     * ensuring uniqueness is a requirement of the implementer.
     *
     * Avoid panicking in this method. A panic may
     * cause some elements to never be dropped, leaking
     * any owned memory outside the region.
     */
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, f: F) where
        F: FnMut(&'b mut Ix<T>);
}
impl <T : 'static, S: HasIx<T>> HasIx<T> for Vec<S> {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut f: F) where
        F: FnMut(&'b mut Ix<T>)
    {
        self.iter_mut().for_each(|o| {o.foreach_ix(&mut f)});
    }
}
impl <T : 'static> HasIx<T> for () {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut _f: F) where
        F: FnMut(&'b mut Ix<T>)
    { }
}
impl <T : 'static, S1: HasIx<T>, S2: HasIx<T>> HasIx<T> for (S1, S2) {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut f: F) where
        F: FnMut(&'b mut Ix<T>)
    {
        self.0.foreach_ix(&mut f);
        self.1.foreach_ix(&mut f);
    }
}
impl <T : 'static, S1: HasIx<T>, S2: HasIx<T>, S3: HasIx<T>> HasIx<T> for (S1, S2, S3) {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut f: F) where
        F: FnMut(&'b mut Ix<T>)
    {
        self.0.foreach_ix(&mut f);
        self.1.foreach_ix(&mut f);
        self.2.foreach_ix(&mut f);
    }
}
impl <T : 'static, S1: HasIx<T>, S2: HasIx<T>, S3: HasIx<T>, S4: HasIx<T>> HasIx<T> for (S1, S2, S3, S4) {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut f: F) where
        F: FnMut(&'b mut Ix<T>)
    {
        self.0.foreach_ix(&mut f);
        self.1.foreach_ix(&mut f);
        self.2.foreach_ix(&mut f);
        self.3.foreach_ix(&mut f);
    }
}
impl <T : 'static, S: HasIx<T>> HasIx<T> for Option<S> {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut f: F) where
        F: FnMut(&'b mut Ix<T>)
    {
        self.iter_mut().for_each(|o|{o.foreach_ix(&mut f)})
    }
}
impl <T : 'static, S: HasIx<T>> HasIx<T> for Box<S> {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut f: F) where
        F: FnMut(&'b mut Ix<T>)
    {
        self.as_mut().foreach_ix(&mut f);
    }
}
impl <T : 'static, S: HasIx<T>> HasIx<T> for &mut S {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut f: F) where
        F: FnMut(&'b mut Ix<T>)
    {
        (*self).foreach_ix(&mut f);
    }
}
impl <T : 'static> HasIx<T> for Ix<T> {
    fn foreach_ix<'b, 'a : 'b, F>(&'a mut self, mut f: F) where
        F: FnMut(&'b mut Ix<T>)
    {
        f(self);
    }
}