#![doc(html_root_url = "https://docs.rs/high_mem_utils/0.2.1/")]
#![feature(vec_leak, untagged_unions, const_fn)]
#![allow(unused_unsafe)]

/*!
This crate provides high-level memory abstractions used for ensure memory and exception safety in some
patterns.

High-level signifies that it only brings safe abstractions for some cases of transmute and others unsafe
functions in the mem or ptr module,does not provide a custom allocator or garbage collector neither depends
on the [core::alloc] unstable lib.

At the moment this crate is nightly only,this will change if the features [`vec_leak`], [`const_fn`] and
[`untagged_unions`] get stabilished.

# Examples

```
use high_mem_utils::{CatchStr, DontDrop, DropBy};

let mut string = String::from("Hello world!");
let catch = CatchStr::new(string.clone());

assert_eq!(catch.leaked().to_string(), string); // leaked returns &&mut str,not use to_string
                                                // it's a bit difficult cast rigth now

assert_eq!(catch.seal(), string); // catch consumed
let mut a = [1, 2, 3];

{
    let elem = DropBy::new([2, 3, 4], |e: [u32; 3]| { a = e.clone(); });

    assert_eq!(*elem, Some([2, 3, 4]));
}

assert_eq!(a, [2, 3, 4]);

unsafe {
    let b = DontDrop([1, 2, 3]); // we're not dropping here because we will have two variables
                                 // pointing to the same memory and "b" lives for shorter
    a = [0; 3];
    b.as_ptr().copy_to(a.as_mut_ptr(), 3);
}

assert_eq!(a, [1, 2, 3]);
```

[`vec_leak`]: https://github.com/rust-lang/rust/issues/62195
[`untagged_unions`]: https://github.com/rust-lang/rust/issues/32836
[`const_fn`]: https://github.com/rust-lang/rust/issues/57563
[core::alloc]: https://doc.rust-lang.org/core/alloc/index.html
*/

use std::mem::{take, ManuallyDrop, MaybeUninit, forget};
use std::ops::{Deref, DerefMut};
use std::collections::BTreeMap;

/// This macro panics with the given message with debug_assertions on or call (unreachable_unchecked)[https://doc.rust-lang.org/std/hint/fn.unreachable_unchecked.html] when off.
/// 
/// # Safety
/// 
/// You should use this macro for code that must not reach.but all the cases where can are not handled and
/// will be handled on release or otherwise the responsability of do it passed to another caller,via unsafe
/// interfaces. 
#[macro_export]
macro_rules! unreachable_debug {
    () => { unreachable!("entered unreachable code") };
    ($e:expr) => {
        if cfg!(not(debug_assertions)) {
            unsafe { std::hint::unreachable_unchecked() };
        } else {
            panic!($e);
        }
    }
}

/// An union type that can be leaked or sealed(owned),useful when you want to give temporal global access to a particular value.
pub union Catch<'a, T> {
    leaked: &'a mut T,
    sealed: ManuallyDrop<Box<T>>,
}

impl<'a, T> Catch<'a, T> {
    /// Creates a new Catch with a leak, you can lately get the underlying value and consume the Catch
    /// with the [`seal`](#method.seal) method.
    pub fn new(a: Box<T>) -> Self {
        Catch {
            leaked: Box::leak(a),
        }
    }

    /// Returns a a reference to the leaked field,'cause the only ways for construct this union returns
    /// a leaked one,for warranty never transmute stack to heap data,this method does not use transmute
    /// implicitly.
    pub fn leaked(&self) -> &&'a mut T {
        unsafe { &self.leaked }
    }

    /// Consumes the Catch and gets the inner Box\<T\>,preventing the memory leak.
    ///
    /// This does a call to transmute but,as the only ways to construct this union gives you a leaked one
    /// this never trigger undefined behavior by itself.
    pub fn seal(self) -> Box<T> {
        unsafe { ManuallyDrop::into_inner(self.sealed) }
    }

    /// Consumes the Catch and returns a mutable reference pointing to leaked data.
    pub fn leak(self) -> &'a mut T {
        unsafe { self.leaked }
    }

    /// Creates a new Catch from a mutable reference to T,without checking if T is in the heap.
    ///
    /// # Safety
    ///
    /// This function should only be used with data returned by leak from a safely construct Catch or with
    /// data returned by Box::leak otherwise will trigger undefined behavior if seal is called.
    pub unsafe fn from_leaked(leaked: &'a mut T) -> Self {
        Catch { leaked }
    }
}

// impl<'a, T> Drop for Catch<'a, T> {
//     fn drop(&mut self) {
//        unsafe { ManuallyDrop::drop(&mut self.sealed) };
//     }
// }

/// An union slice that can be leaked or sealed(owned),useful when you want to give temporal global access
/// to a particular sequence.
pub union CatchSeq<'a, T> {
    leaked: &'a mut [T],
    sealed: ManuallyDrop<Box<[T]>>,
}

impl<'a, T> CatchSeq<'a, T> {
    /// Creates a new CatchSeq with a leak, you can lately get the underlying sequence and consume the CatchSeq
    /// with the [`seal`](#method.seal) method.
    pub fn new(a: Vec<T>) -> Self {
        CatchSeq {
            leaked: Vec::leak(a),
        }
    }

    /// Returns a a reference to the leaked field,as the only safe ways for construct this union returns a leaked
    /// one,for warranty never transmute stack to heap data,this method does not use transmute implicitly.
    pub fn leaked(&self) -> &&'a mut [T] {
        unsafe { &self.leaked }
    }

    /// Consumes the Catch and gets the inner Vec<T>, preventing the memory leak.
    ///
    /// This does a call to transmute but,as the only safe ways for construct this union returns a leaked
    /// one,this never trigger undefined behavior by itself.
    pub fn seal(self) -> Vec<T> {
        unsafe { ManuallyDrop::into_inner(self.sealed).into_vec() }
    }

    /// Consumes the CatchSeq and returns a mutable reference pointing to leaked data.
    pub fn leak(self) -> &'a mut [T] {
        unsafe { self.leaked }
    }

    /// Creates a new CatchSeq from a `&mut [T]`,without checking if the referent is in the heap.
    ///
    /// # Safety
    ///
    /// This function should only be used with data returned by leak from a safely constructed CatchSeq or
    /// with data returned by Vec::leak otherwise this will trigger undefined behavior if[`seal`](#method.seal)
    /// is called.
    pub unsafe fn from_leaked(leaked: &'a mut [T]) -> Self {
        CatchSeq { leaked }
    }
}

/// An union string that can be leaked or sealed(owned),useful when you want to give temporal global access
/// to a particular string.
pub union CatchStr<'a> {
    leaked: &'a mut str,
    sealed: ManuallyDrop<Box<str>>,
}

impl<'a> CatchStr<'a> {
    /// Creates a new CatchStr with a leak, you can lately get the underlying string and consume the CatchStr
    /// with the [`seal`](#method.seal) method.
    pub fn new(a: String) -> Self {
        CatchStr {
            leaked: Box::leak(a.into_boxed_str()),
        }
    }

    /// Returns a a reference to the leaked field,as the only safe ways for construct this union returns a leaked
    /// one,for warranty never transmute stack to heap data,this method does not use transmute implicitly.
    pub fn leaked(&self) -> &&'a mut str {
        unsafe { &self.leaked }
    }

    /// Consumes the Catch and gets the inner String, preventing the memory leak.
    ///
    /// This does a call to transmute but,as the only safe ways for construct this union return a leaked
    /// one,this never trigger undefined behavior by itself.
    pub fn seal(self) -> String {
        unsafe { ManuallyDrop::into_inner(self.sealed).into_string() }
    }

    /// Consumes the CatchStr and returns a mutable reference pointing to leaked data.
    pub fn leak(self) -> &'a mut str {
        unsafe { self.leaked }
    }

    /// Creates a new CatchStr from a `&mut str`,without checking if the referent is in the heap.
    ///
    /// # Safety
    ///
    /// This function should only be used with data returned by leak from a safely constructed CatchStr or
    /// with data returned by `Box::leak(s.into_boxed_str())` otherwise this will trigger undefined behavior
    /// if [`seal`](#method.seal) is called.
    pub unsafe fn from_leaked(leaked: &'a mut str) -> Self {
        CatchStr { leaked }
    }
}

/// A wrapper for an implementation of drop that [`mem::take`] the value and [`mem::forget`]s it.
///
/// This might be useful if you want assuring that a particular destructor not run if it can lead to
/// a double-free or another memory issue.
///
/// This type is particularly not recomended for reference types because as such they can never be null
/// and the value is still dropped. Neither on types with a costly initialization because it replaces the
/// forgotten value with the `Default` one,these values should not implement it anyways.
///
/// This type has the same implications that forget except for the fact that this ensures that the value
/// is never dropped even on panic,unless you abort.In general [`DontDropOpt`](./struct.DontDropOpt.html) is preferred.
///
/// It derefs to T.
///
/// [`mem::take`]: https://doc.rust-lang.org/core/mem/fn.take.html
#[repr(transparent)]
pub struct DontDrop<T: Default>(pub T);

impl<T: Default> DontDrop<T> {
    /// Returns the field,allowing it to be dropped again.
    pub fn into_inner(&mut self) -> T {
        take(&mut self.0)
    }
}

impl<T: Default> Deref for DontDrop<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T: Default> DerefMut for DontDrop<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T: Default> Drop for DontDrop<T> {
    fn drop(&mut self) {
        forget(take(&mut self.0));
    }
}

/// A wrapper for an implementation of drop that [`mem::forget`] the previous value and replace it with None.
///
/// This might be useful if you want assuring that a particular destructor not run if it can lead to
/// a double-free or another memory issue.
///
/// This type is particularly not recomended for reference types because as such they can never be null
/// and the value is still dropped.
///
/// This type has the same implications that [`mem::forget`] except for the fact that this ensures that the
/// value is never dropped even on panic,unless you abort.
///
/// It derefs to Option<T>.
#[repr(transparent)]
pub struct DontDropOpt<T>(Option<T>);

impl<T> DontDropOpt<T> {
    /// Construct a new `DontDropOpt` from a value,this has no effect if the value is a reference.
    pub fn new(a: T) -> Self {
        DontDropOpt(Some(a))
    }

    /// Returns the value,allowing it to be dropped again.
    pub fn into_inner(&mut self) -> Option<T> {
        self.0.take()
    }

    /// Unwraps the Option<T>,allowing it to be dropped again.
    /// 
    /// # Safety
    /// 
    /// This will panic if the type contained is None with debug_assertions enabled,otherwise triggers UB.
    pub unsafe fn into_inner_unchecked(&mut self) -> T {
        self.0.take().unwrap_or_else(|| unreachable_debug!("Called into_inner_unchecked with None value on DontDropOpt in debug."))
    } 
}

impl<T> Drop for DontDropOpt<T> {
    fn drop(&mut self) {
        forget(&mut self.0.take());
    }
}

impl<T> Deref for DontDropOpt<T> {
    type Target = Option<T>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> DerefMut for DontDropOpt<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}


/// A wrapper that calls the given closure at Drop. Useful when you have a conditional assign of one
/// that,once assigned,you want to warranty a call to it with the given T,and then drop it.
/// 
/// Currently this type has a value field of an `Option<T>`,because the closure needs to take ownership
/// doing use of the [take](https://doc.rust-lang.org/std/option/enum.Option.html#method.take) method on
/// `Option`.In case of `None` because there's no meaningful value for,drop returns at that point.
///
/// It derefs to Option<T>.
pub struct DropBy<T, F: FnMut(T)> {
    pub value: Option<T>,
    pub clos: F
}

impl<T, F: FnMut(T)> DropBy<T, F> {
    pub const fn new(value: T, clos: F) -> Self {
        let value = Some(value);
        DropBy { value, clos }
    }

    /// Takes the value,disabling any code in the closure.
    pub fn into_inner(&mut self) -> Option<T> {
        self.value.take()
    }

    /// Takes and unwraps the value,disabling any code in the closure.
    /// 
    /// # Safety
    /// 
    /// This will panic if the type contained is None with debug_assertions enabled,otherwise triggers UB.
    pub unsafe fn into_inner_unchecked(&mut self) -> T {
        self.value.take().unwrap_or_else(|| unreachable_debug!("Called into_inner_unchecked with None value on DropBy in debug."))
    } 
}

impl<T, F: FnMut(T)> Deref for DropBy<T, F> {
    type Target = Option<T>;

    fn deref(&self) -> &Self::Target {
        &self.value
    }
}

impl<T, F: FnMut(T)> DerefMut for DropBy<T, F> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.value
    }
}

impl<T, F: FnMut(T)> Drop for DropBy<T, F> {
    fn drop(&mut self) {
        
        let value = match self.value.take() {
            Some(a) => a,
            _ => return,
        };

        (self.clos)(value);
    }
}

/// An enum that can be all sorts of Catch's over T,useful when you do not known if you gonna have a Box,Vec or String and you want to
/// grant static temporal access to any of them safely.
pub enum CatchT<'a, T> {
    Catch(Catch<'a, T>),
    CatchSeq(CatchSeq<'a, T>),
    CatchStr(CatchStr<'a>),
}

/// A lazy-iniatialiazed cache for a Fn closure with a constant constructor.
pub struct LazyCache<P: Ord, V: Clone, C: Fn(P) -> V> {
    cache: MaybeUninit<BTreeMap<P, V>>,
    pub closure: C,
    init: bool
}

impl<P: Ord + Clone, V: Clone, C: Fn(P) -> V> LazyCache<P, V, C> {
    /// Construct a cache for a closure that is initialized in the first call to [call_cache](#method.call_cache).
    /// 
    /// This is particularly useful for fn pointers of recurrently used functions because it can be used
    /// on statics,althought you need make them mutable for actually call [call_cache](#method.call_cache).
    pub const fn new(closure: C) -> Self {
        Self {cache: MaybeUninit::uninit(), closure, init: false}
    }
    
    fn init(&mut self) {
        unsafe {
            self.cache.as_mut_ptr().write(BTreeMap::new());
            self.init = true;
        }
    }

    /// calls the inner closure with the givem arg after init the cache if it did not before.
    /// 
    /// # Panics
    /// 
    /// If the given closure panic the variable reading them from the MaybeUninit is guranteed to not
    /// drop and the Drop impl will do the job.
    /// 
    /// # Examples
    /// 
    /// ```
    /// use high_mem_utils::LazyCache;
    /// 
    /// fn foo(num: u32) -> u32 {
    ///     num
    /// }
    /// 
    /// let mut cache = LazyCache::new(foo);
    /// 
    /// assert_eq!(cache.call_cache(2), 2);
    /// assert_eq!(cache.call_cache(2), 2);
    /// assert_eq!(cache.call_cache(4), 4);
    /// ```
    pub fn call_cache(&mut self, arg: P) -> V {
    
        if !self.init {
            self.init();
        }
        
        let mut cache = unsafe { DontDropOpt::new(self.cache.as_ptr().read()) };
    
        let value = if (cache.as_ref().unwrap()).contains_key(&arg) {
            (cache.as_ref().unwrap().get(&arg).unwrap()).clone()
        } else {
            let temp = (self.closure)(arg.clone());
            cache.as_mut().unwrap().insert(arg, temp.clone());
            temp
        };

        self.cache = MaybeUninit::uninit();

        unsafe { self.cache.as_mut_ptr().write(cache.into_inner_unchecked()); }
        
        value
    }

    /// This method removes an argument from the cache and returns the value or None if there's no one
    /// or the cache is uninitialized.
    /// 
    /// # Examples
    /// 
    /// ```
    /// use high_mem_utils::LazyCache;
    /// 
    /// fn foo(num: u32) -> u32 {
    ///     num
    /// }
    /// 
    /// let mut cache = LazyCache::new(foo);
    /// 
    /// assert_eq!(cache.call_cache(2), 2);
    /// assert_eq!(cache.pop(&2), Some(2));
    /// assert_eq!(cache.pop(&2), None);
    /// ```
    pub fn pop(&mut self, arg: &P) -> Option<V> {
        let rem;

        if !self.init {
            return None;
        }

        let mut cache = unsafe { DontDropOpt::new(self.cache.as_ptr().read()) };

        if cache.as_ref().unwrap().contains_key(arg) {
            rem = Some(cache.as_ref().unwrap().get(arg).unwrap().clone());
            cache.as_mut().unwrap().remove(arg);
        } else {
            rem = None;
        }

	self.cache = MaybeUninit::uninit();

        unsafe { self.cache.as_mut_ptr().write(cache.into_inner_unchecked()); }

        rem
    }

    /// Clears the cache,removing all their values.This is no-op if the cache is not initialized.
    pub fn clear(&mut self) {
        if !self.init {
            return ();
        }

        let mut cache = unsafe { DontDropOpt::new(self.cache.as_ptr().read()) };
        cache.as_mut().unwrap().clear();

        self.cache = MaybeUninit::uninit();

        unsafe { self.cache.as_mut_ptr().write(cache.into_inner_unchecked()); }
    }

    /// Returns true if the cache is initialized,not neccesarily filled with an argument. Use ![is_empty](#method.is_empty)
    /// for that purporse.
    pub fn is_init(&self) -> bool {
        self.init
    }

    /// Returns true if the cache has no arguments or if it's not initialized.
    pub fn is_empty(&self) -> bool {
        if self.init {
            let read = unsafe { DontDropOpt::new(self.cache.as_ptr().read()) };
            read.as_ref().unwrap().is_empty()
        } else {
            true
        }
    }

}

impl<P: Ord, V: Clone, C: Fn(P) -> V> Drop for LazyCache<P, V, C> {
    fn drop(&mut self) {
        if self.init { // this checks if the cache field is init
            // assume_init takes an consumes the union so because we only need drop the data
            // and in this point we known it's impossible for the value to be used in another site
            // this is safe.
            let _thrash = unsafe { self.cache.as_ptr().read() };
        }
    }   
}