//! Provides a [`Vector2`].
//! ```
//! # use vecto::Vec2;
//! let mut v = Vec2::new(5.0, 7.0);
//! v *= 2.0;
//! assert_eq!(v, Vec2::new(10.0, 14.0));
//! ````
#![allow(mixed_script_confusables)]
#![warn(clippy::pedantic, clippy::dbg_macro, missing_docs)]
mod from;
mod ops;

#[doc(hidden)]
pub trait Kinda
where
    Self: Sized,
{
    fn kinda_eq(self, other: Self, tolerance: f32) -> bool;
    fn approx_eq(self, other: Self) -> bool;
}

impl Kinda for f32 {
    fn kinda_eq(self, other: Self, tolerance: f32) -> bool {
        if self == other {
            true
        } else {
            (self - other).abs() < tolerance
        }
    }

    fn approx_eq(self, other: Self) -> bool {
        self.kinda_eq(other, 0.00001)
    }
}

impl Kinda for Vec2 {
    fn kinda_eq(self, other: Self, tolerance: f32) -> bool {
        self.x.kinda_eq(other.x, tolerance) && self.y.kinda_eq(other.y, tolerance)
    }

    fn approx_eq(self, other: Self) -> bool {
        self.kinda_eq(other, 0.00001)
    }
}

use umath::generic_float::{FloatAlone, Rounding};

/// Alias for <code>[`Vector2`]<[`f32`]></code>
pub type Vec2 = Vector2<f32>;

/// Vector2.
#[derive(Copy, Clone, PartialEq, PartialOrd, Default, Hash, Eq, Ord)]
#[repr(C)]
pub struct Vector2<T> {
    /// The vector's X component.
    pub x: T,
    /// The vector's Y component.
    pub y: T,
}

impl<T: std::fmt::Debug> std::fmt::Debug for Vector2<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "({:?}, {:?})", self.x, self.y)
    }
}

impl<T> Vector2<T> {
    /// Construct a new [`Vector2`].
    pub const fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: Copy> Vector2<T> {
    /// Construct a new [`Vector2`] with x and y set to the given value.
    pub const fn splat(x: T) -> Self {
        Self { x, y: x }
    }
}

impl Vec2 {
    /// Zero unit vector. `(0, 0)`
    pub const ZERO: Vec2 = Vec2::new(0.0, 0.0);
    /// Right unit vector. `(1, 0)`
    pub const RIGHT: Vec2 = Vec2::new(1.0, 0.0);
    /// Left unit vector. `(-1, 0)`
    pub const LEFT: Vec2 = Vec2::new(-1.0, 0.0);
    /// Up unit vector. Y-Down, so points -Y. `(0, -1)`
    pub const UP: Vec2 = Vec2::new(0.0, -1.0);
    /// Down unit vector. Y-Down, so points +Y. `(0, 1)`
    pub const DOWN: Vec2 = Vec2::new(0.0, 1.0);
}

impl Vector2<f64> {
    /// Zero unit vector. `(0, 0)`
    pub const ZERO: Vec2 = Vec2::new(0.0, 0.0);
    /// Right unit vector. `(1, 0)`
    pub const RIGHT: Vec2 = Vec2::new(1.0, 0.0);
    /// Left unit vector. `(-1, 0)`
    pub const LEFT: Vec2 = Vec2::new(-1.0, 0.0);
    /// Up unit vector. Y-Down, so points -Y. `(0, -1)`
    pub const UP: Vec2 = Vec2::new(0.0, -1.0);
    /// Down unit vector. Y-Down, so points +Y. `(0, 1)`
    pub const DOWN: Vec2 = Vec2::new(0.0, 1.0);
}

impl<T: std::ops::Neg<Output = T>> Vector2<T> {
    /// Returns a perpendicular vector, rotated 90 degrees counter-clockwise, with the same length.
    #[must_use = "Does not modify in place."]
    pub fn orthogonal(self) -> Self {
        Self::new(self.y, -self.x)
    }
}

impl<T: FloatAlone> Vector2<T> {
    /// Creates a unit [`Vector2`] rotated to the given angle (radians).
    /// This is equivalent to `Vec2::new(angle.cos(), angle.sin())`.
    /// ```
    /// # use vecto::{Vec2, Kinda};
    /// # use std::f32::consts::PI;
    /// assert_eq!(Vec2::from_angle(0.0), Vec2::RIGHT);
    /// assert_eq!(Vec2::RIGHT.angle(), 0.0);
    /// assert!(Vec2::from_angle(PI / 2.0).approx_eq(Vec2::new(0.0, 1.0)));
    /// ```
    pub fn from_angle(angle: T) -> Self {
        Self::new(angle.cos(), angle.sin())
    }

    /// Returns a new vector with all components in absolute values (i.e. positive).
    #[must_use = "Does not modify in place."]
    pub fn abs(self) -> Self {
        Self::new(self.x.abs(), self.y.abs())
    }

    /// Returns this vector's angle with respect to the positive X axis, or the [`Vec2::RIGHT`] vector, in radians.
    /// ```
    /// # use vecto::Vec2;
    /// # use std::f32::consts::PI;
    /// assert_eq!(Vec2::RIGHT.angle(), 0.0);
    /// assert_eq!(Vec2::DOWN.angle(), PI / 2.0); // 90 degrees
    /// assert_eq!(Vec2::new(1.0, -1.0).angle(), -PI / 4.0); // -45 degrees
    /// ```
    pub fn angle(&self) -> T {
        self.y.atan2(self.x)
    }

    /// Returns the cross product of `self` and `with`.
    pub fn cross(&self, with: &Self) -> T {
        self.x * with.y - self.y * with.x
    }

    /// Returns the distance from `self` to `to`.
    pub fn distance_to(&self, to: &Self) -> T {
        ((self.x - to.x) * (self.x - to.x) + (self.y - to.y) * (self.y - to.y)).sqrt()
    }

    /// Returns the dot product of `self` and `with`.
    pub fn dot(&self, with: &Self) -> T {
        self.x * with.x + self.y * with.y
    }

    /// Returns the length(magnitude) of `self`.
    /// ```
    /// # use vecto::Vec2;
    /// assert_eq!(Vec2::splat(10.0).length(), 10.0 * 2.0f32.sqrt());
    /// ```
    pub fn length(&self) -> T {
        (self.x * self.x + self.y * self.y).sqrt()
    }

    /// Returns the squared length of `self`. Faster than [`Self::length`].
    /// ```
    /// # use vecto::Vec2;
    /// assert_eq!(Vec2::splat(10.0).length_squared(), 200.0);
    /// ```
    pub fn length_squared(&self) -> T {
        self.x * self.x + self.y * self.y
    }

    /// Returns the vector with a new maximum length.
    /// ```
    /// # use vecto::{Kinda, Vec2};
    /// assert!(Vec2::splat(10.).limit_length(1.0).approx_eq(Vec2::splat(1.0 / 2.0f32.sqrt())));
    /// assert!(Vec2::splat(10.).limit_length(5.0).approx_eq(Vec2::splat(1.0 / 2.0f32.sqrt() * 5.0)));
    /// ```
    #[must_use = "Does not modify in place."]
    pub fn limit_length(self, len: T) -> Self {
        let l = self.length();
        if l > unsafe { T::zero() } && len < l {
            return (self / l) * len;
        }
        self
    }

    /// Returns the result of scaling the vector to unit length.
    /// Equivalent to v / v.length().
    ///
    /// Note: This function may struggle with denormal values.
    /// ```
    /// # use vecto::{Kinda, Vec2};
    /// assert!(Vec2::RIGHT.normalized().approx_eq(Vec2::RIGHT));
    /// assert!(Vec2::splat(1.0).normalized().approx_eq(Vec2::splat(0.5f32.sqrt())));
    /// ```
    #[must_use = "Does not modify in place."]
    pub fn normalized(self) -> Self {
        let l = self.length_squared();
        if l != unsafe { T::zero() } {
            return self / l.sqrt();
        }
        self
    }

    /// Rotates this vector by `angle` radians.
    /// ```
    /// # use vecto::{Kinda, Vec2};
    /// # use std::f32::consts::TAU;
    /// let v = Vec2::new(1.2, 3.4);
    /// assert!(v.rotated(TAU).approx_eq(Vec2::new(1.2, 3.4))); // full circle rotation
    /// assert!(v.rotated(TAU / 4.0).approx_eq(Vec2::new(-3.4, 1.2)));
    /// assert!(v.rotated(TAU / 3.0).approx_eq(Vec2::new(-3.5444863, -0.6607695)));
    /// assert!(v.rotated(TAU / 2.0).approx_eq(v.rotated(TAU / -2.0)));
    /// ```
    #[must_use = "Does not modify in place."]
    pub fn rotated(self, angle: T) -> Self {
        Vector2::new(
            self.x * angle.cos() - self.y * angle.sin(),
            self.x * angle.sin() + self.y * angle.cos(),
        )
    }
}

impl<T: Rounding> Vector2<T> {
    /// Returns a new vector with all components rounded up (towards positive infinity).
    #[must_use = "Does not modify in place."]
    pub fn ceil(self) -> Self {
        Self::new(self.x.ceil(), self.y.ceil())
    }

    /// Returns a new vector with all components rounded down (towards negative infinity).
    #[must_use = "Does not modify in place."]
    pub fn floor(self) -> Self {
        Self::new(self.x.floor(), self.y.floor())
    }
}