/*
 * @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/.
 */

mod types;
mod collect;

pub use types::*;

use alloc::vec::Vec;
use crate::types::{Ix, HasIx, Error, Root, Weak};
use crate::entry::{Spot, Entry};

impl <T> Region<T> {
    #[inline]
    #[allow(unused)]
    pub(crate) fn check_ix(&self, ix: Ix<T>) -> Result<(), Error> {
        #[cfg(feature = "debug-arena")]
        {
            if ix.nonce != self.nonce {
                Err(Error::IncorrectRegion)?;
            } else if ix.generation < self.generation {
                Err(Error::EntryExpired)?;
            } else if ix.generation > self.generation {
                Err(Error::UnexpectedInternalState)?;
            }
        }
        Ok(())
    }

    pub(crate) fn entry_raw_mut(&mut self, ix: Ix<T>) -> MutEntry<T> {
        MutEntry {
            ix,
            entry: self.data.get_mut(ix.ix()).unwrap().get_mut().unwrap(),
            roots: &self.roots,
        }
    }

    pub(crate) fn entry(&self, ix: Ix<T>) -> Result<&Entry<T>, Error> {
        Ok(self.data.get(ix.ix())
            .ok_or(Error::Indeterminable)?
            .get()
            .ok_or(Error::Indeterminable)?)
    }

    pub(crate) fn weak(&self, ix: Ix<T>) -> Result<Weak<T>, Error> {
        Ok(self.entry(ix)?.weak(ix))
    }

    pub(crate) fn root(&self, ix: Ix<T>) -> Result<Root<T>, Error> {
        let e = self.entry(ix)?;
        let r = e.root(ix);
        // there will be two copies of the roots,
        // there is a strong reference inside the entry
        // and one in this method.
        // The entry will handle clearing its version if there
        // are no weak references

        // This is one copy, so it's already in the vec
        // only this method considers it already rooted
        if !r.is_rooted() { // new root, push to list
            self.roots.borrow_mut().push(r.clone());
        }
        Ok(r)
    }

    pub(crate) fn try_get_mut(&mut self, ix: Ix<T>) -> Result<&mut T, Error> {
        self.check_ix(ix)?;
        Ok(self.data.get_mut(ix.ix())
            .ok_or(Error::Indeterminable)?
            .get_mut()
            .ok_or(Error::Indeterminable)?
            .get_mut())
    }

    pub(crate) fn try_get(&self, ix: Ix<T>) -> Result<&T, Error> {
        self.check_ix(ix)?;
        Ok(self.data.get(ix.ix())
            .ok_or(Error::Indeterminable)?
            .get()
            .ok_or(Error::Indeterminable)?
            .get())
    }
}

impl <T> Region<T> {
    /**
     * Return the current capacity of this region. A collection won't
     * be triggered by allocation unless the desired amount exceeds the capacity.
     */
    #[inline]
    pub fn capacity(&self) -> usize {
        self.data.capacity()
    }
    /**
     * Return the current number of entries in the region.
     */
    #[inline]
    pub fn len(&self) -> usize {
        self.data.len()
    }
    /**
     * Returns true if there are currently no entries in this region.
     */
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.data.is_empty()
    }
}

impl <T: 'static + HasIx<T>> Region<T> {

    /**
     * Ensure that the capacity supports new_elems more
     * elements, collecting garbage if necessary.
     */
    pub fn ensure(&mut self, additional: usize) {
        let len = self.data.len();
        let cap = self.data.capacity();
        if cap >= len + additional { return }
        let mut dst = Vec::with_capacity(len + core::cmp::max(len, additional));

        #[cfg(feature = "debug-arena")]
        let new_gen = (self.nonce, self.generation+1);

        let roots = self.roots.get_mut();
        Self::prim_gc_to(&mut self.data, &mut dst, roots,
            #[cfg(feature = "debug-arena")]
            (self.nonce, self.generation),
            #[cfg(feature = "debug-arena")]
            new_gen);
        *roots = roots.drain(..).filter(Root::is_rooted).collect();
        self.data = dst;

        #[cfg(feature = "debug-arena")]
        {
            self.generation = new_gen.1;
        }
    }

    /**
     * Allocate a new object, returning a temporary handle,
     * which can be used to mutate the object and to get
     * roots, weak pointers, and internal pointers to
     * the object.
     *
     * This may trigger a garbage collection and invalidate
     * raw indices.  As such, a function is used to
     * generate the new value, which
     * can query the state of the world post-collection.
     */
    pub fn alloc<F>(&mut self, make_t: F) -> MutEntry<T> where
        F: FnOnce(&Self) -> T
    {
        //else the index could be incorrect
        self.ensure(1);
        let n = self.data.len();
        self.data.push(Spot::new(make_t(&self)));
        self.entry_raw_mut(Ix::new(
            n,
            #[cfg(feature = "debug-arena")]
            self.nonce,
            #[cfg(feature = "debug-arena")]
            self.generation,
            ))
    }


    /**
     * Immediately trigger a standard garbage collection.
     *
     * This invalidates raw indices.
     *
     * ```rust
     * use moving_gc_arena as gc;
     * let mut r = gc::Region::new();
     *
     * r.alloc(|_|{()});
     * r.gc();
     * assert!(r.is_empty());
     * ```
     */
    pub fn gc(&mut self) {
        let mut dst = Vec::with_capacity(self.data.len());
        let roots = self.roots.get_mut();
        Self::prim_gc_to(&mut self.data, &mut dst, roots,
            #[cfg(feature = "debug-arena")]
            (self.nonce, self.generation),
            #[cfg(feature = "debug-arena")]
            (self.nonce, self.generation+1));
        let new_roots = self.take_valid_roots().collect();
        self.roots.replace(new_roots);
        self.data = dst;
        #[cfg(feature = "debug-arena")]
        {
            self.generation = self.generation+1;
        }
    }
    /**
     * Move the elements of this region onto the end of another Region.
     * This can trigger a collection in the other region if it
     * must be re-allocated.
     */
    pub fn gc_into(mut self, other: &mut Region<T>) {
        other.ensure(self.data.len());
        Self::prim_gc_to(&mut self.data, &mut other.data, self.roots.get_mut(),
            #[cfg(feature = "debug-arena")]
            (self.nonce, self.generation),
            #[cfg(feature = "debug-arena")]
            (other.nonce, other.generation));
        other.roots.get_mut().extend(self.take_valid_roots());
    }
    fn take_valid_roots(&mut self) -> impl Iterator<Item=Root<T>> + '_ {
        self.roots.get_mut().drain(..).filter(Root::is_rooted)
    }

    #[inline(always)]
    /**
     * Perform a depth-first search, applying a mutating function
     * to each of the values passed over. This traversal
     * uses the C stack, and so is subject to stack overflow,
     * but can use any state for the traversal.
     *
     * In order to ensure that this function performs well, the
     * HasIx implementation for T must be deterministic: it
     * should always return the same references. This is so
     * that we can correctly maintain marking information.
     *
     * There is currently no immutable variation on this function.
     */
    pub fn dfs_mut_cstack<'a, I, F>(&'a mut self, start: I, process: F)
    where
        T: HasIx<T>,
        F: FnMut(Ix<T>, &mut T),
        I: IntoIterator<Item=&'a Ix<T>>,
        I::IntoIter : Clone,
    {
        Self::prim_traverse_mut_cstack(&mut self.data, start.into_iter(), process)
    }
}