#![no_std]

extern crate alloc;

use alloc::boxed::Box;
use alloc::rc::Rc;
use alloc::sync::Arc;
use core::cmp;
use core::fmt::{self, Debug, Display, Pointer};
use core::hash::{Hash, Hasher};
use core::ops::{Deref, DerefMut};

#[derive(Clone, Copy)]
#[repr(transparent)]
pub struct SuperPin<Ptr> {
	pointer: Ptr,
}

#[macro_export]
macro_rules! superpin {
	($value: expr $(,)?) => {
		$crate::SuperPin<&mut _> { pointer: &mut { $value } }
	};
}

impl<Ptr: Debug> Debug for SuperPin<Ptr> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Debug::fmt(&self.pointer, f)
	}
}

impl<Ptr: Display> Display for SuperPin<Ptr> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Display::fmt(&self.pointer, f)
	}
}

impl<Ptr: Pointer> Pointer for SuperPin<Ptr> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Pointer::fmt(&self.pointer, f)
	}
}

impl<Ptr: Deref, Q: Deref> PartialEq<SuperPin<Q>> for SuperPin<Ptr>
where
	Ptr::Target: PartialEq<Q::Target>,
{
	fn eq(&self, other: &SuperPin<Q>) -> bool {
		Ptr::Target::eq(self, other)
	}

	#[allow(clippy::partialeq_ne_impl)] // We need to copy what the Ptr type does
	fn ne(&self, other: &SuperPin<Q>) -> bool {
		Ptr::Target::ne(self, other)
	}
}

impl<Ptr: Deref<Target: Eq>> Eq for SuperPin<Ptr> {}

impl<Ptr: Deref, Q: Deref> PartialOrd<SuperPin<Q>> for SuperPin<Ptr>
where
	Ptr::Target: PartialOrd<Q::Target>,
{
	fn partial_cmp(&self, other: &SuperPin<Q>) -> Option<cmp::Ordering> {
		Ptr::Target::partial_cmp(self, other)
	}

	fn lt(&self, other: &SuperPin<Q>) -> bool {
		Ptr::Target::lt(self, other)
	}

	fn le(&self, other: &SuperPin<Q>) -> bool {
		Ptr::Target::le(self, other)
	}

	fn gt(&self, other: &SuperPin<Q>) -> bool {
		Ptr::Target::gt(self, other)
	}

	fn ge(&self, other: &SuperPin<Q>) -> bool {
		Ptr::Target::ge(self, other)
	}
}

impl<Ptr: Deref<Target: Ord>> Ord for SuperPin<Ptr> {
	fn cmp(&self, other: &Self) -> cmp::Ordering {
		Ptr::Target::cmp(self, other)
	}
}

impl<Ptr: Deref> Hash for SuperPin<Ptr>
where
	<Ptr as Deref>::Target: Hash,
{
	fn hash<H: Hasher>(&self, state: &mut H) {
		self.pointer.hash(state);
	}
}

impl<Ptr: Deref> Deref for SuperPin<Ptr> {
	type Target = Ptr::Target;

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

impl<Ptr: DerefMut> DerefMut for SuperPin<Ptr> {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.pointer
	}
}

impl<T: ?Sized> From<Box<T>> for SuperPin<Box<T>> {
	fn from(value: Box<T>) -> Self {
		// safety: It's not possible to move or replace the insides of a
		//         SuperPin<Box<T>>, so it's safe to pin it directly without
		//         any additional requirements.
		unsafe { Self::new_unchecked(value) }
	}
}

impl<Ptr> SuperPin<Ptr> {
	pub fn boxed<T>(x: T) -> SuperPin<Box<T>> {
		SuperPin::from(Box::new(x))
	}

	pub fn rc<T>(value: T) -> SuperPin<Rc<T>> {
		// safety: It's not possible to move anything behind an Rc
		unsafe { SuperPin::new_unchecked(Rc::new(value)) }
	}

	pub fn arc<T>(value: T) -> SuperPin<Arc<T>> {
		// safety: It's not possible to move anything behind an Arc
		unsafe { SuperPin::new_unchecked(Arc::new(value)) }
	}
}

impl<Ptr: Deref> SuperPin<Ptr> {
	pub unsafe fn new_unchecked(pointer: Ptr) -> Self {
		Self { pointer }
	}

	pub fn as_ref(&self) -> SuperPin<&<Ptr as Deref>::Target> {
		// safety: the pointee cannot move while it is pinned
		unsafe { SuperPin::new_unchecked(self.pointer.deref()) }
	}

	pub unsafe fn into_inner_unchecked(pin: SuperPin<Ptr>) -> Ptr {
		// safety: the caller must ensure that the value is not moved
		pin.pointer
	}
}

impl<Ptr: DerefMut> SuperPin<Ptr> {
	pub fn as_mut(&mut self) -> SuperPin<&mut <Ptr as Deref>::Target> {
		// safety: the pointee cannot move while it is pinned
		unsafe { SuperPin::new_unchecked(self.pointer.deref_mut()) }
	}

	pub fn set(&mut self, value: <Ptr as Deref>::Target)
	where
		<Ptr as Deref>::Target: Sized,
	{
		// safety: the destructor is run and a new valid value of the same type is
		//         put in its place, so no pinning invariant is violated
		*self.pointer.deref_mut() = value;
	}
}

impl<'a, T: ?Sized> SuperPin<&'a T> {
	pub unsafe fn map_unchecked<U: ?Sized>(self, func: impl FnOnce(&T) -> &U) -> SuperPin<&'a U> {
		let new_pointer = func(self.pointer);

		// safety: the caller is responsible for upholding the invariants of
		//         SuperPin::new_unchecked
		unsafe { SuperPin::new_unchecked(new_pointer) }
	}

	pub fn get_ref(self) -> &'a T {
		// safety: it is impossible to move out of a shared pointer
		self.pointer
	}
}

impl<'a, T: ?Sized> SuperPin<&'a mut T> {
	pub fn into_ref(self) -> SuperPin<&'a T> {
		// safety: it is impossible to move out of a shared pointer
		unsafe { SuperPin::new_unchecked(&*self.pointer) }
	}

	pub unsafe fn get_unchecked_mut(self) -> &'a mut T {
		// safety: the caller must ensure the value is not moved out of the pointer
		self.pointer
	}

	pub unsafe fn map_unchecked_mut<U: ?Sized>(
		self,
		func: impl FnOnce(&mut T) -> &mut U,
	) -> SuperPin<&'a mut U> {
		let pointer = &mut *self.pointer;
		let new_pointer = func(pointer);

		// safety: the caller must uphold the invariants of SuperPin::new_unchecked
		unsafe { SuperPin::new_unchecked(new_pointer) }
	}
}

impl<T: ?Sized> SuperPin<&'static T> {
	pub fn static_ref(r: &'static T) -> Self {
		// safety: T is borrowed for the 'static lifetime, which never ends
		unsafe { SuperPin::new_unchecked(r) }
	}
}

impl<T: ?Sized> SuperPin<&'static mut T> {
	pub fn static_mut(r: &'static mut T) -> Self {
		// safety: T is borrowed for the 'static lifetime, which never ends
		unsafe { SuperPin::new_unchecked(r) }
	}
}

impl<'a, T> SuperPin<&'a Option<T>> {
	pub fn as_option_ref(self) -> Option<SuperPin<&'a T>> {
		unsafe {
			SuperPin::get_ref(self)
				.as_ref()
				// safety: x has to be pinned, because it comes from self
				.map(|x| SuperPin::new_unchecked(x))
		}
	}
}

impl<'a, T> SuperPin<&'a mut Option<T>> {
	pub fn as_option_mut(self) -> Option<SuperPin<&'a mut T>> {
		unsafe {
			// safety: the value is never moved
			SuperPin::get_unchecked_mut(self)
				.as_mut()
				// safety: x has to be pinned, because it comes from self
				.map(|x| SuperPin::new_unchecked(x))
		}
	}
}