use super::*;

/// A 2-dimensional vector.
///
/// This is two `f32` values, `x` and `y`.
#[derive(Clone, Copy, Default, PartialEq)]
#[repr(C)]
pub struct Vec2 {
  pub(crate) x: f32,
  pub(crate) y: f32,
}
unsafe impl Zeroable for Vec2 {}
unsafe impl Pod for Vec2 {}

impl core::fmt::Debug for Vec2 {
  /// Passes the formatter along to the fields, so you can use any normal `f32`
  /// Debug format arguments that you like.
  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
    f.write_str("Vec2 { x: ")?;
    core::fmt::Debug::fmt(&self.x, f)?;
    f.write_str(", y: ")?;
    core::fmt::Debug::fmt(&self.y, f)?;
    f.write_str(" }")
  }
}

impl core::fmt::Display for Vec2 {
  /// Display formats without labels like a 2-tuple.
  ///
  /// Passes the formatter along to the fields, so you can use any normal `f32`
  /// Display format arguments that you like.
  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
    f.write_str("(")?;
    core::fmt::Display::fmt(&self.x, f)?;
    f.write_str(", ")?;
    core::fmt::Display::fmt(&self.y, f)?;
    f.write_str(")")
  }
}

impl core::fmt::LowerExp for Vec2 {
  /// LowerExp formats like Display, but with the lower exponent.
  ///
  /// Passes the formatter along to the fields, so you can use any normal `f32`
  /// LowerExp format arguments that you like.
  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
    f.write_str("(")?;
    core::fmt::LowerExp::fmt(&self.x, f)?;
    f.write_str(", ")?;
    core::fmt::LowerExp::fmt(&self.y, f)?;
    f.write_str(")")
  }
}

impl core::fmt::UpperExp for Vec2 {
  /// UpperExp formats like Display, but with the upper exponent.
  ///
  /// Passes the formatter along to the fields, so you can use any normal `f32`
  /// UpperExp format arguments that you like.
  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
    f.write_str("(")?;
    core::fmt::UpperExp::fmt(&self.x, f)?;
    f.write_str(", ")?;
    core::fmt::UpperExp::fmt(&self.y, f)?;
    f.write_str(")")
  }
}

impl Index<usize> for Vec2 {
  type Output = f32;
  #[inline(always)]
  fn index(&self, index: usize) -> &f32 {
    match index {
      0 => &self.x,
      1 => &self.y,
      otherwise => panic!("Vec2 index out of bounds: {}", otherwise),
    }
  }
}
impl IndexMut<usize> for Vec2 {
  #[inline(always)]
  fn index_mut(&mut self, index: usize) -> &mut f32 {
    match index {
      0 => &mut self.x,
      1 => &mut self.y,
      otherwise => panic!("Vec2 index out of bounds: {}", otherwise),
    }
  }
}

impl AsRef<[f32; 2]> for Vec2 {
  #[inline(always)]
  fn as_ref(&self) -> &[f32; 2] {
    cast_ref(self)
  }
}
impl AsMut<[f32; 2]> for Vec2 {
  #[inline(always)]
  fn as_mut(&mut self) -> &mut [f32; 2] {
    cast_mut(self)
  }
}

impl From<[f32; 2]> for Vec2 {
  #[inline]
  fn from([x, y]: [f32; 2]) -> Self {
    Self { x, y }
  }
}
impl From<Vec2> for [f32; 2] {
  #[inline]
  fn from(Vec2 { x, y }: Vec2) -> Self {
    [x, y]
  }
}

#[cfg(feature = "mint")]
impl From<mint::Vector2<f32>> for Vec2 {
  #[inline]
  fn from(mint::Vector2 { x, y }: mint::Vector2<f32>) -> Self {
    Self { x, y }
  }
}
#[cfg(feature = "mint")]
impl From<Vec2> for mint::Vector2<f32> {
  #[inline]
  fn from(Vec2 { x, y }: Vec2) -> Self {
    Self { x, y }
  }
}

#[cfg(feature = "serde")]
impl serde::Serialize for Vec2 {
  #[inline]
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: serde::Serializer,
  {
    <[f32; 2]>::from(*self).serialize(serializer)
  }
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Vec2 {
  #[inline]
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: serde::Deserializer<'de>,
  {
    Ok(Self::from(<[f32; 2]>::deserialize(deserializer)?))
  }
}

impl Add for Vec2 {
  type Output = Self;
  #[inline]
  fn add(self, rhs: Self) -> Self {
    Self {
      x: self.x + rhs.x,
      y: self.y + rhs.y,
    }
  }
}
impl Add<f32> for Vec2 {
  type Output = Self;
  #[inline]
  fn add(self, rhs: f32) -> Self {
    Self {
      x: self.x + rhs,
      y: self.y + rhs,
    }
  }
}
impl Add<Vec2> for f32 {
  type Output = Vec2;
  #[inline]
  fn add(self, rhs: Vec2) -> Vec2 {
    Vec2::splat(self) + rhs
  }
}
impl AddAssign for Vec2 {
  #[inline]
  fn add_assign(&mut self, rhs: Self) {
    *self = *self + rhs
  }
}
impl AddAssign<f32> for Vec2 {
  #[inline]
  fn add_assign(&mut self, rhs: f32) {
    *self = *self + rhs
  }
}

impl Sub for Vec2 {
  type Output = Self;
  #[inline]
  fn sub(self, rhs: Self) -> Self {
    Self {
      x: self.x - rhs.x,
      y: self.y - rhs.y,
    }
  }
}
impl Sub<f32> for Vec2 {
  type Output = Self;
  #[inline]
  fn sub(self, rhs: f32) -> Self {
    Self {
      x: self.x - rhs,
      y: self.y - rhs,
    }
  }
}
impl Sub<Vec2> for f32 {
  type Output = Vec2;
  #[inline]
  fn sub(self, rhs: Vec2) -> Vec2 {
    Vec2::splat(self) - rhs
  }
}
impl SubAssign for Vec2 {
  #[inline]
  fn sub_assign(&mut self, rhs: Self) {
    *self = *self - rhs
  }
}
impl SubAssign<f32> for Vec2 {
  #[inline]
  fn sub_assign(&mut self, rhs: f32) {
    *self = *self - rhs
  }
}

impl Neg for Vec2 {
  type Output = Self;
  #[inline]
  fn neg(self) -> Self {
    Self {
      x: -self.x,
      y: -self.y,
    }
  }
}

impl Mul<f32> for Vec2 {
  type Output = Self;
  #[inline]
  fn mul(self, rhs: f32) -> Self {
    Self {
      x: self.x * rhs,
      y: self.y * rhs,
    }
  }
}
impl Mul<Vec2> for f32 {
  type Output = Vec2;
  #[inline]
  fn mul(self, rhs: Vec2) -> Vec2 {
    rhs * self
  }
}
impl MulAssign<f32> for Vec2 {
  #[inline]
  fn mul_assign(&mut self, rhs: f32) {
    *self = *self * rhs;
  }
}

impl Mul for Vec2 {
  type Output = Self;
  /// Non-mathematical component-wise multiplication (GLSL-style)
  #[inline]
  fn mul(self, rhs: Self) -> Self {
    Self {
      x: self.x * rhs.x,
      y: self.y * rhs.y,
    }
  }
}
impl MulAssign for Vec2 {
  #[inline]
  fn mul_assign(&mut self, rhs: Self) {
    *self = *self * rhs;
  }
}

/// ## Accessors
impl Vec2 {
  /// Gets the `x` component of this vector.
  #[inline(always)]
  pub fn x(self) -> f32 {
    self.x
  }
  /// Gets the `y` component of this vector.
  #[inline(always)]
  pub fn y(self) -> f32 {
    self.y
  }
  /// `&mut` to the `x` component of this vector.
  #[inline(always)]
  pub fn x_mut(&mut self) -> &mut f32 {
    &mut self.x
  }
  /// `&mut` to the `y` component of this vector.
  #[inline(always)]
  pub fn y_mut(&mut self) -> &mut f32 {
    &mut self.y
  }
}

/// ## Constructors
impl Vec2 {
  /// Makes a new `Vec2`
  #[inline(always)]
  pub fn new(x: f32, y: f32) -> Self {
    Self { x, y }
  }

  /// Splats the given value across all components.
  #[inline]
  pub fn splat(v: f32) -> Self {
    Self { x: v, y: v }
  }

  /// Extends this 2d vec into a 3d vec with the `z` given.
  #[inline]
  pub fn to_vec3(self, z: f32) -> Vec3 {
    Vec3::from([self.x, self.y, z])
  }
}

/// ## Operations
impl Vec2 {
  /// Dot product.
  ///
  /// This is the sum of the component-wise multiplication of the two values.
  /// Order doesn't matter. Positive dot product means the vectors are pointing
  /// in the same general direction, zero dot product means they're
  /// perpendicular, and negative dot product means they have opposite general
  /// direction.
  #[inline]
  pub fn dot(self, rhs: Self) -> f32 {
    let t = self * rhs;
    t.x() + t.y()
  }

  /// The length / magnitude of the vector.
  ///
  /// * `sqrt(x^2 + y^2)`
  #[inline]
  pub fn length(self) -> f32 {
    lokacore::sqrt_f32(self.length2())
  }

  /// The squared length / magnitude of the vector.
  ///
  /// * `x^2 + y^2 + z^2`
  #[inline]
  pub fn length2(self) -> f32 {
    let sq = self * self;
    sq.x() + sq.y()
  }

  /// Generates a new vector where the length is 1.0
  ///
  /// Or, well, as close as it can get. Floating point, and all that.
  #[inline]
  pub fn normalize(self) -> Self {
    let len = self.length();
    Self::new(self.x() / len, self.y() / len)
  }
}