#![no_std]
#![warn(missing_docs)]

//! Lokathor's crate of core-only odds and ends.

use core::{
  marker::PhantomData,
  mem::{align_of, size_of},
  num::*,
  ptr::NonNull,
};

pub mod arch;

mod marker;
pub use marker::*;

/// The
/// [wrapping](https://doc.rust-lang.org/std/primitive.i8.html#method.wrapping_abs)
/// absolute value of any signed integer.
///
/// * `branchless_abs!(a, type)`
///
/// Branchless, so you can use it in a `const` context.
#[macro_export]
macro_rules! branchless_abs {
  ($x:expr, $u:ty) => {{
    const SHIFT: u32 = core::mem::size_of::<$u>().wrapping_mul(8).wrapping_sub(1) as u32;
    let mask = ($x as $u).wrapping_shr(SHIFT);
    ($x as $u).wrapping_add(mask) ^ mask
  }};
}

/// The minimum of two integer values.
///
/// * `branchless_min!(a, b, type)`
///
/// Branchless, so you can use it in a `const` context.
#[macro_export]
macro_rules! branchless_min {
  ($x:expr, $y:expr, $u:ty) => {
    $y ^ (($x ^ $y) & (($x < $y) as $u).wrapping_neg())
  };
}

/// The maximum of two integer values.
///
/// * `branchless_max!(a, b, type)`
///
/// Branchless, so you can use it in a `const` context.
#[macro_export]
macro_rules! branchless_max {
  ($x:expr, $y:expr, $u:ty) => {
    $x ^ (($x ^ $y) & (($x < $y) as $u).wrapping_neg())
  };
}

/// If an unsigned value is a power of 2 (or is 0).
///
/// * `branchless_pow_of_2_or_zero!(a)`
///
/// Branchless, so you can use it in a `const` context.
#[macro_export]
macro_rules! branchless_pow_of_2_or_zero {
  ($v:expr) => {
    $v & $v.wrapping_sub(1) == 0
  };
}

/// If two signed values have opposite sign (zero counts as positive).
///
/// * `branchless_opposite_sign!(x, y)`
///
/// Branchless, so you can use it in a `const` context.
#[macro_export]
macro_rules! branchless_opposite_sign {
  ($x:expr, $y:expr) => {
    ($x ^ $y) < 0
  };
}

/// Force bits of an unsigned value off or on.
///
/// * `branchless_force_bits!(flag, mask, word, type)`
///
/// Branchless, so you can use it in a `const` context.
#[macro_export]
macro_rules! branchless_force_bits {
  ($f:expr, $m:expr, $w:expr, $t:ty) => {
    // Note(Lokathor): super-scalar form: (w & ~m) | (-f & m)
    $w ^ ((($f as $t).wrapping_neg() ^ $w) & $m)
  };
}

/// Negate a signed integer value or not.
///
/// * `branchless_negate!(negate, val, type)`
///
/// Branchless, so you can use it in a `const` context.
#[macro_export]
macro_rules! branchless_negate {
  ($f_negate:expr, $v:expr, $t:ty) => {
    ($v ^ ($f_negate as $t).wrapping_neg()).wrapping_add($f_negate as $t)
  };
}

/// Bitwise merge two values according to a bit mask.
///
/// * `branchless_masked_merge!(mask_yes, mask_no, mask)`
///
/// Branchless, so you can use it in a `const` context.
#[macro_export]
macro_rules! branchless_masked_merge {
  ($mask_yes:expr, $mask_no:expr, $mask:expr) => {
    (($mask_yes ^ $mask_no) & $mask) ^ $mask_no
  };
}

/// Wrap the inner value to a minimum alignment of 2.
///
/// This is for alignment shenanigans, you're not expected to use it in a
/// struct, more just in function arguments and such.
#[derive(Debug, Clone, Copy)]
#[repr(align(2))]
pub struct Align2<T>(pub T);

/// Wrap the inner value to a minimum alignment of 4.
///
/// This is for alignment shenanigans, you're not expected to use it in a
/// struct, more just in function arguments and such.
#[derive(Debug, Clone, Copy)]
#[repr(align(4))]
pub struct Align4<T>(pub T);

/// Wrap the inner value to a minimum alignment of 8.
///
/// This is for alignment shenanigans, you're not expected to use it in a
/// struct, more just in function arguments and such.
#[derive(Debug, Clone, Copy)]
#[repr(align(8))]
pub struct Align8<T>(pub T);

/// Wrap the inner value to a minimum alignment of 16.
///
/// This is for alignment shenanigans, you're not expected to use it in a
/// struct, more just in function arguments and such.
#[derive(Debug, Clone, Copy)]
#[repr(align(16))]
pub struct Align16<T>(pub T);

/// Wrap the inner value to a minimum alignment of 32.
///
/// This is for alignment shenanigans, you're not expected to use it in a
/// struct, more just in function arguments and such.
#[derive(Debug, Clone, Copy)]
#[repr(align(32))]
pub struct Align32<T>(pub T);

/// Re-interprets `&T` as `&[u8]`.
///
/// Any ZST becomes an empty slice, and in that case the pointer value of that
/// empty slice might not match the pointer value of the input reference.
#[inline]
pub fn bytes_of<T: Pod>(t: &T) -> &[u8] {
  try_cast_slice::<T, u8>(core::slice::from_ref(t)).unwrap_or(&[])
}

/// Re-interprets `&mut T` as `&mut [u8]`.
///
/// Any ZST becomes an empty slice, and in that case the pointer value of that
/// empty slice might not match the pointer value of the input reference.
#[inline]
pub fn bytes_of_mut<T: Pod>(t: &mut T) -> &mut [u8] {
  try_cast_slice_mut::<T, u8>(core::slice::from_mut(t)).unwrap_or(&mut [])
}

/// As `align_to`, but safe because of the [`Pod`] bound.
#[inline]
pub fn pod_align_to<T: Pod, U: Pod>(vals: &[T]) -> (&[T], &[U], &[T]) {
  unsafe { vals.align_to::<U>() }
}

/// As `align_to_mut`, but safe because of the [`Pod`] bound.
#[inline]
pub fn pod_align_to_mut<T: Pod, U: Pod>(vals: &mut [T]) -> (&mut [T], &mut [U], &mut [T]) {
  unsafe { vals.align_to_mut::<U>() }
}

/// The things that can go wrong when casting between [`Pod`] data forms.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PodCastError {
  /// You tried to cast a slice to an element type with a higher alignment
  /// requirement but the slice wasn't aligned.
  TargetAlignmentGreaterAndInputNotAligned,
  /// You tried to cast between a zero-sized type and a non-zero-sized type.
  /// Because the output slice resizes based on the input and output types, it's
  /// fairly nonsensical to throw a ZST into the mix. You can go from a ZST to
  /// another ZST, if you want.
  CantConvertBetweenZSTAndNonZST,
  /// If the element size changes then the output slice changes length
  /// accordingly. If the output slice wouldn't be a whole number of elements
  /// then the conversion fails.
  OutputSliceWouldHaveSlop,
  /// When casting an individual `T`, `&T`, or `&mut T` value the source size
  /// and destination size must be an exact match.
  SizeMismatch,
}

/// As [`try_cast`], but unwraps the result for you.
#[inline]
pub fn cast<A: Pod, B: Pod>(a: A) -> B {
  try_cast(a).unwrap()
}

/// Try to cast `T` into `U`.
///
/// ## Failure
///
/// * If the types don't have the same size this fails.
#[inline]
pub fn try_cast<A: Pod, B: Pod>(a: A) -> Result<B, PodCastError> {
  if size_of::<A>() == size_of::<B>() {
    let mut b = B::zeroed();
    // Note(Lokathor): We copy in terms of `u8` because that allows us to bypass
    // any potential alignment difficulties.
    let ap = &a as *const A as *const u8;
    let bp = &mut b as *mut B as *mut u8;
    unsafe { ap.copy_to_nonoverlapping(bp, size_of::<A>()) };
    Ok(b)
  } else {
    Err(PodCastError::SizeMismatch)
  }
}

/// As [`try_cast_slice`], but unwraps the result for you.
#[inline]
pub fn cast_slice<A: Pod, B: Pod>(a: &[A]) -> &[B] {
  try_cast_slice(a).unwrap()
}

/// As [`try_cast_slice_mut`], but unwraps the result for you.
#[inline]
pub fn cast_slice_mut<A: Pod, B: Pod>(a: &[A]) -> &[B] {
  try_cast_slice(a).unwrap()
}

/// As [`try_cast_ref`], but unwraps the result for you.
#[inline]
pub fn cast_ref<A: Pod, B: Pod>(a: &A) -> &B {
  try_cast_ref(a).unwrap()
}

/// As [`try_cast_mut`], but unwraps the result for you.
#[inline]
pub fn cast_mut<A: Pod, B: Pod>(a: &mut A) -> &mut B {
  try_cast_mut(a).unwrap()
}

/// Try to convert a `&T` into `&U`.
///
/// ## Failure
///
/// * If the reference isn't aligned in the new type
/// * If the source type and target type aren't the same size.
#[inline]
pub fn try_cast_ref<A: Pod, B: Pod>(a: &A) -> Result<&B, PodCastError> {
  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
  // after monomorphization.
  if align_of::<B>() > align_of::<A>() && (a as *const A as usize) % align_of::<B>() != 0 {
    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
  } else if size_of::<B>() == size_of::<A>() {
    Ok(unsafe {
      (a as *const A as *const B)
        .as_ref()
        .unwrap_or_else(|| core::hint::unreachable_unchecked())
    })
  } else {
    Err(PodCastError::SizeMismatch)
  }
}

/// As [`try_cast_ref`], but `mut`.
#[inline]
pub fn try_cast_mut<A: Pod, B: Pod>(a: &mut A) -> Result<&mut B, PodCastError> {
  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
  // after monomorphization.
  if align_of::<B>() > align_of::<A>() && (a as *mut A as usize) % align_of::<B>() != 0 {
    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
  } else if size_of::<B>() == size_of::<A>() {
    Ok(unsafe {
      (a as *mut A as *mut B)
        .as_mut()
        .unwrap_or_else(|| core::hint::unreachable_unchecked())
    })
  } else {
    Err(PodCastError::SizeMismatch)
  }
}

/// Try to convert `&[T]` into `&[U]` (possibly with a change in length).
///
/// * `input.as_ptr() as usize == output.as_ptr() as usize`
/// * `input.len() * size_of::<A>() == output.len() * size_of::<B>()`
///
/// ## Failure
///
/// * If the target type has a greater alignment requirement and the input slice
///   isn't aligned.
/// * If the target element type is a different size from the current element
///   type, and the output slice wouldn't be a whole number of elements when
///   accounting for the size change (eg: three `u16` values is 1.5 `u32`
///   values, so that's a failure).
/// * Similarly, you can't convert between a
///   [ZST](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts)
///   and a non-ZST.
#[inline]
pub fn try_cast_slice<A: Pod, B: Pod>(a: &[A]) -> Result<&[B], PodCastError> {
  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
  // after monomorphization.
  if align_of::<B>() > align_of::<A>() && (a.as_ptr() as usize) % align_of::<B>() != 0 {
    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
  } else if size_of::<B>() == size_of::<A>() {
    Ok(unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, a.len()) })
  } else if size_of::<A>() == 0 || size_of::<B>() == 0 {
    Err(PodCastError::CantConvertBetweenZSTAndNonZST)
  } else if core::mem::size_of_val(a) % size_of::<B>() == 0 {
    let new_len = core::mem::size_of_val(a) / size_of::<B>();
    Ok(unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, new_len) })
  } else {
    Err(PodCastError::OutputSliceWouldHaveSlop)
  }
}

/// As [`try_cast_slice`], but `mut`.
#[inline]
pub fn try_cast_slice_mut<A: Pod, B: Pod>(a: &mut [A]) -> Result<&mut [B], PodCastError> {
  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
  // after monomorphization.
  if align_of::<B>() > align_of::<A>() && (a.as_ptr() as usize) % align_of::<B>() != 0 {
    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
  } else if size_of::<B>() == size_of::<A>() {
    Ok(unsafe { core::slice::from_raw_parts_mut(a.as_ptr() as *mut B, a.len()) })
  } else if size_of::<A>() == 0 || size_of::<B>() == 0 {
    Err(PodCastError::CantConvertBetweenZSTAndNonZST)
  } else if core::mem::size_of_val(a) % size_of::<B>() == 0 {
    let new_len = core::mem::size_of_val(a) / size_of::<B>();
    Ok(unsafe { core::slice::from_raw_parts_mut(a.as_ptr() as *mut B, new_len) })
  } else {
    Err(PodCastError::OutputSliceWouldHaveSlop)
  }
}

/// `f32` absolute value, because it's `std` only right now.
///
/// will probably be removed if `f32::abs` becomes `core`.
#[inline(always)]
pub fn abs_f32(f: f32) -> f32 {
  // Note(Lokathor): Only tested on little-endian, but ScottMCM of T-lang claims
  // that this will be fine on big-endian machines so #TRUST
  f32::from_bits(f.to_bits() & (core::i32::MAX as u32))
}

/// `f64` absolute value, because it's `std` only right now.
///
/// will probably be removed if `f64::abs` becomes `core`.
#[inline]
pub fn abs_f64(f: f64) -> f64 {
  // Note(Lokathor): Only tested on little-endian, but ScottMCM of T-lang claims
  // that this will be fine on big-endian machines so #TRUST
  f64::from_bits(f.to_bits() & (core::i64::MAX as u64))
}