use std::{ops::{Index, IndexMut, Deref, DerefMut, Add, Sub, Mul}, marker::PhantomData, ptr::NonNull, fmt::{Debug, Display}};
use crate::prelude::*;

pub struct Gc<T> {
    ptr: NonNull<GcInner<T>>,
    phantom: PhantomData<GcInner<T>>
}

struct GcInner<T> {
    rc: usize,
    data: T
}

impl<T> Gc<T> {
    pub fn new(data: T) -> Self {
        let boxed = Box::new(GcInner {
            rc: 1,
            data,
        });
        Self {
            ptr: NonNull::new(Box::into_raw(boxed)).unwrap(),
            phantom: PhantomData
        }
    }
}

impl <T: Clone> Gc<T> {
    pub fn into_inner(self) -> T {
        unsafe {
            self.ptr.as_ref().data.clone()
        }
    }

    fn data(&self) -> T {
        unsafe {
            self.ptr.as_ref().data.clone()
        }
    }
}

impl <T: ValueClone> ValueClone for Gc<T> {
    fn deep_clone(&self) -> Self {
        unsafe {
            let data = self.ptr.as_ref().data.deep_clone();
            Self::new(data)
        }
    }

    fn shallow_clone(&self) -> Self {
        unsafe {
            let data = self.ptr.as_ref().data.shallow_clone();
            Self::new(data)
        }
    }
}

impl<T> From<T> for Gc<T> {
    fn from(value: T) -> Self {
        Gc::new(value)
    }
}

impl<T: IndexMut<Idx>, Idx> IndexMut<Idx> for Gc<T> {
    fn index_mut(&mut self, index: Idx) -> &mut Self::Output {
        self.deref_mut().index_mut(index)
    }
}

impl<T: Index<Idx>, Idx> Index<Idx> for Gc<T> {
    type Output = T::Output;

    fn index(&self, index: Idx) -> &Self::Output {
        self.deref().index(index)
    }
}

impl<T> DerefMut for Gc<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe {
            &mut self.ptr.as_mut().data
        }
    }
}

impl<T> Deref for Gc<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe {
            &self.ptr.as_ref().data
        }
    }
}

impl <T: PartialEq> PartialEq for Gc<T> {
    fn eq(&self, other: &Self) -> bool {
        self.deref().eq(other.deref())
    }
}

impl <T: Iterator> Iterator for Gc<T> {
    type Item = T::Item;

    fn next(&mut self) -> Option<Self::Item> {
        self.deref_mut().next()
    }
}

impl<T: Eq> Eq for Gc<T> {}

impl<T> Clone for Gc<T> {
    fn clone(&self) -> Self {
        unsafe {
            let inner = self.ptr.as_ptr().as_mut().unwrap();
            inner.rc += 1;

            Self {
                ptr: self.ptr,
                phantom: PhantomData
            }
        }
    }
}

impl<T> Drop for Gc<T> {
    fn drop(&mut self) {
        unsafe {
            let inner = self.ptr.as_mut();
            if inner.rc > 1 {
                inner.rc -= 1;
            } else {
                let _ = Box::from_raw(self.ptr.as_ptr());
            }
        }
    }
}

impl<T: Debug> Debug for Gc<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if f.alternate() {
            write!(f, "{:#?}", self.deref())
        } else {
            write!(f, "{:?}", self.deref())
        }
    }
}

impl<T: Display> Display for Gc<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if f.alternate() {
            write!(f, "{:#}", self.deref())
        } else {
            write!(f, "{}", self.deref())
        }
    }
}

impl <T: Add + Clone> Add for Gc<T> {
    type Output = T::Output;

    fn add(self, rhs: Self) -> Self::Output {
        let a = self.data();
        let b = rhs.data();
        a + b
    }
}

impl <T: Sub + Clone> Sub for Gc<T> {
    type Output = T::Output;

    fn sub(self, rhs: Self) -> Self::Output {
        let a = self.data();
        let b = rhs.data();
        a - b
    }
}

impl <T: Mul + Clone> Mul for Gc<T> {
    type Output = T::Output;

    fn mul(self, rhs: Self) -> Self::Output {
        let a = self.data();
        let b = rhs.data();
        a * b
    }
}