//! Module for PCGs that use their own current memory address to pick the
//! stream.
//!
//! This works just like the `Pick` flavor of PCGs, except that instead of
//! storing a stream value along with the state the generator it just uses its
//! own `&mut` cast into a `usize`, then cast into the state type (`|1`, to make
//! it odd).
//!
//! Seeding these things is a little weird. Normally a PCG will run once or
//! twice as part of the seeding process, and when this generator is run as part
//! of seeding it has to use its position on the stack, but when it's returned
//! to the caller its position changes, which puts it into a new stream.
//! However, if that bugs you in the slightest I guess you'd have never selected
//! this PRNG in the first place.

use super::*;

const DEFAULT_MEM_SEED: u128 = 245720598905631564143578724636268694099;

/// A PCG with 8 bits of state, mem address stream
#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct PCGMemU8 {
  state: u8,
}
impl PCGMemU8 {
  /// Seeds the generator
  pub fn seed(seed: u8) -> Self {
    let mut out = Self { state: 0 };
    let inc = unsafe { NonZeroU8::new_unchecked(&mut out as *mut Self as usize as u8 | 1) };
    out.state = lcg8(out.state, PCG_DEFAULT_MULTIPLIER_8, inc);
    out.state = out.state.wrapping_add(seed);
    out.state = lcg8(out.state, PCG_DEFAULT_MULTIPLIER_8, inc);
    out
  }
  /// Gives a generator of the exact values you put in
  pub const fn exact(state: u8) -> Self {
    Self { state }
  }
  /// Gives the next same-size output.
  pub fn next_u8(&mut self) -> u8 {
    let output = rxs_m_xs_8_8(self.state);
    let inc = unsafe { NonZeroU8::new_unchecked(self as *mut Self as usize as u8 | 1) };
    let next_state = lcg8(self.state, PCG_DEFAULT_MULTIPLIER_8, inc);
    self.state = next_state;
    output
  }
}
impl From<u64> for PCGMemU8 {
  fn from(seed: u64) -> Self {
    Self::seed(seed as u8)
  }
}
impl Default for PCGMemU8 {
  fn default() -> Self {
    Self::seed(DEFAULT_MEM_SEED as u8)
  }
}

/// A PCG with 16 bits of state, mem address stream
#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct PCGMemU16 {
  state: u16,
}
impl PCGMemU16 {
  /// Seeds the generator
  pub fn seed(seed: u16) -> Self {
    let mut out = Self { state: 0 };
    let inc = unsafe { NonZeroU16::new_unchecked(&mut out as *mut Self as usize as u16 | 1) };
    out.state = lcg16(out.state, PCG_DEFAULT_MULTIPLIER_16, inc);
    out.state = out.state.wrapping_add(seed);
    out.state = lcg16(out.state, PCG_DEFAULT_MULTIPLIER_16, inc);
    out
  }
  /// Gives a generator of the exact values you put in
  pub const fn exact(state: u16) -> Self {
    Self { state }
  }
  /// Gives the next half-size output, using rotation
  pub fn next_u8(&mut self) -> u8 {
    let inc = unsafe { NonZeroU16::new_unchecked(self as *mut Self as usize as u16 | 1) };
    let output = xsh_rr_16_8(self.state);
    let next_state = lcg16(self.state, PCG_DEFAULT_MULTIPLIER_16, inc);
    self.state = next_state;
    output
  }
  /// Gives the next half-size output, using a shift
  pub fn next_u8shift(&mut self) -> u8 {
    let inc = unsafe { NonZeroU16::new_unchecked(self as *mut Self as usize as u16 | 1) };
    let output = xsh_rs_16_8(self.state);
    let next_state = lcg16(self.state, PCG_DEFAULT_MULTIPLIER_16, inc);
    self.state = next_state;
    output
  }
  /// Gives the next same-size output.
  pub fn next_u16(&mut self) -> u16 {
    let inc = unsafe { NonZeroU16::new_unchecked(self as *mut Self as usize as u16 | 1) };
    let output = rxs_m_xs_16_16(self.state);
    let next_state = lcg16(self.state, PCG_DEFAULT_MULTIPLIER_16, inc);
    self.state = next_state;
    output
  }
}
impl From<u64> for PCGMemU16 {
  fn from(seed: u64) -> Self {
    Self::seed(seed as u16)
  }
}
impl Default for PCGMemU16 {
  fn default() -> Self {
    Self::seed(DEFAULT_MEM_SEED as u16)
  }
}

/// A PCG with 32 bits of state, mem address stream
#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct PCGMemU32 {
  state: u32,
}
impl PCGMemU32 {
  /// Seeds the generator
  pub fn seed(seed: u32) -> Self {
    let mut out = Self { state: 0 };
    let inc = unsafe { NonZeroU32::new_unchecked(&mut out as *mut Self as usize as u32 | 1) };
    out.state = lcg32(out.state, PCG_DEFAULT_MULTIPLIER_32, inc);
    out.state = out.state.wrapping_add(seed);
    out.state = lcg32(out.state, PCG_DEFAULT_MULTIPLIER_32, inc);
    out
  }
  /// Gives a generator of the exact values you put in
  pub const fn exact(state: u32) -> Self {
    Self { state }
  }
  /// Gives the next half-size output, using rotation
  pub fn next_u16(&mut self) -> u16 {
    let inc = unsafe { NonZeroU32::new_unchecked(self as *mut Self as usize as u32 | 1) };
    let output = xsh_rr_32_16(self.state);
    let next_state = lcg32(self.state, PCG_DEFAULT_MULTIPLIER_32, inc);
    self.state = next_state;
    output
  }
  /// Gives the next half-size output, using a shift
  pub fn next_u16shift(&mut self) -> u16 {
    let inc = unsafe { NonZeroU32::new_unchecked(self as *mut Self as usize as u32 | 1) };
    let output = xsh_rs_32_16(self.state);
    let next_state = lcg32(self.state, PCG_DEFAULT_MULTIPLIER_32, inc);
    self.state = next_state;
    output
  }
  /// Gives the next same-size output.
  pub fn next_u32(&mut self) -> u32 {
    let inc = unsafe { NonZeroU32::new_unchecked(self as *mut Self as usize as u32 | 1) };
    let output = rxs_m_xs_32_32(self.state);
    let next_state = lcg32(self.state, PCG_DEFAULT_MULTIPLIER_32, inc);
    self.state = next_state;
    output
  }
}
impl From<u64> for PCGMemU32 {
  fn from(seed: u64) -> Self {
    Self::seed(seed as u32)
  }
}
impl Default for PCGMemU32 {
  fn default() -> Self {
    Self::seed(DEFAULT_MEM_SEED as u32)
  }
}

/// A PCG with 64 bits of state, mem address stream
#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct PCGMemU64 {
  state: u64,
}
impl PCGMemU64 {
  /// Seeds the generator
  pub fn seed(seed: u64) -> Self {
    let mut out = Self { state: 0 };
    let inc = unsafe { NonZeroU64::new_unchecked(&mut out as *mut Self as usize as u64 | 1) };
    out.state = lcg64(out.state, PCG_DEFAULT_MULTIPLIER_64, inc);
    out.state = out.state.wrapping_add(seed);
    out.state = lcg64(out.state, PCG_DEFAULT_MULTIPLIER_64, inc);
    out
  }
  /// Gives a generator of the exact values you put in
  pub const fn exact(state: u64) -> Self {
    Self { state }
  }
  /// Gives the next half-size output, using rotation
  pub fn next_u32(&mut self) -> u32 {
    let inc = unsafe { NonZeroU64::new_unchecked(self as *mut Self as usize as u64 | 1) };
    let output = xsh_rr_64_32(self.state);
    let next_state = lcg64(self.state, PCG_DEFAULT_MULTIPLIER_64, inc);
    self.state = next_state;
    output
  }
  /// Gives the next half-size output, using a shift
  pub fn next_u32shift(&mut self) -> u32 {
    let inc = unsafe { NonZeroU64::new_unchecked(self as *mut Self as usize as u64 | 1) };
    let output = xsh_rs_64_32(self.state);
    let next_state = lcg64(self.state, PCG_DEFAULT_MULTIPLIER_64, inc);
    self.state = next_state;
    output
  }
  /// Gives the next half-size output, using xsl rr
  pub fn next_u32xslrr(&mut self) -> u32 {
    let inc = unsafe { NonZeroU64::new_unchecked(self as *mut Self as usize as u64 | 1) };
    let output = xsl_rr_64_32(self.state);
    let next_state = lcg64(self.state, PCG_DEFAULT_MULTIPLIER_64, inc);
    self.state = next_state;
    output
  }
  /// Gives the next same-size output.
  pub fn next_u64(&mut self) -> u64 {
    let inc = unsafe { NonZeroU64::new_unchecked(self as *mut Self as usize as u64 | 1) };
    let output = rxs_m_xs_64_64(self.state);
    let next_state = lcg64(self.state, PCG_DEFAULT_MULTIPLIER_64, inc);
    self.state = next_state;
    output
  }
  /// Gives the next same-size output, using xsl rr rr
  pub fn next_u64xsl2rr(&mut self) -> u64 {
    let inc = unsafe { NonZeroU64::new_unchecked(self as *mut Self as usize as u64 | 1) };
    let output = xsl_rr_rr_64_64(self.state);
    let next_state = lcg64(self.state, PCG_DEFAULT_MULTIPLIER_64, inc);
    self.state = next_state;
    output
  }
}
impl From<u64> for PCGMemU64 {
  fn from(seed: u64) -> Self {
    Self::seed(seed)
  }
}
impl Default for PCGMemU64 {
  fn default() -> Self {
    Self::seed(DEFAULT_MEM_SEED as u64)
  }
}

/// A PCG with 128 bits of state, mem address stream
#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct PCGMemU128 {
  state: u128,
}
impl PCGMemU128 {
  /// Seeds the generator
  pub fn seed(seed: u128) -> Self {
    let mut out = Self { state: 0 };
    let inc = unsafe { NonZeroU128::new_unchecked(&mut out as *mut Self as usize as u128 | 1) };
    out.state = lcg128(out.state, PCG_DEFAULT_MULTIPLIER_128, inc);
    out.state = out.state.wrapping_add(seed);
    out.state = lcg128(out.state, PCG_DEFAULT_MULTIPLIER_128, inc);
    out
  }
  /// Gives a generator of the exact values you put in
  pub const fn exact(state: u128) -> Self {
    Self { state }
  }
  /// Gives the next half-size output, using rotation
  pub fn next_u64(&mut self) -> u64 {
    let inc = unsafe { NonZeroU128::new_unchecked(self as *mut Self as usize as u128 | 1) };
    let output = xsh_rr_128_64(self.state);
    let next_state = lcg128(self.state, PCG_DEFAULT_MULTIPLIER_128, inc);
    self.state = next_state;
    output
  }
  /// Gives the next half-size output, using a shift
  pub fn next_u64shift(&mut self) -> u64 {
    let inc = unsafe { NonZeroU128::new_unchecked(self as *mut Self as usize as u128 | 1) };
    let output = xsh_rs_128_64(self.state);
    let next_state = lcg128(self.state, PCG_DEFAULT_MULTIPLIER_128, inc);
    self.state = next_state;
    output
  }
  /// Gives the next half-size output, using xsl rr
  pub fn next_u64xslrr(&mut self) -> u64 {
    let inc = unsafe { NonZeroU128::new_unchecked(self as *mut Self as usize as u128 | 1) };
    let output = xsl_rr_128_64(self.state);
    let next_state = lcg128(self.state, PCG_DEFAULT_MULTIPLIER_128, inc);
    self.state = next_state;
    output
  }
  /// Gives the next same-size output.
  pub fn next_u128(&mut self) -> u128 {
    let inc = unsafe { NonZeroU128::new_unchecked(self as *mut Self as usize as u128 | 1) };
    let output = rxs_m_xs_128_128(self.state);
    let next_state = lcg128(self.state, PCG_DEFAULT_MULTIPLIER_128, inc);
    self.state = next_state;
    output
  }
  /// Gives the next same-size output, using xsl rr rr
  pub fn next_u128xsl2rr(&mut self) -> u128 {
    let inc = unsafe { NonZeroU128::new_unchecked(self as *mut Self as usize as u128 | 1) };
    let output = xsl_rr_rr_128_128(self.state);
    let next_state = lcg128(self.state, PCG_DEFAULT_MULTIPLIER_128, inc);
    self.state = next_state;
    output
  }
}
impl From<u64> for PCGMemU128 {
  fn from(seed: u64) -> Self {
    Self::seed(seed as u128)
  }
}
impl Default for PCGMemU128 {
  fn default() -> Self {
    Self::seed(DEFAULT_MEM_SEED)
  }
}