use std::ops::*;
use serde::{Serialize, Deserialize};
use crate::traits::*;

#[repr(C)]
#[derive(Copy, Clone, PartialEq, Debug, Default)]
#[derive(Serialize, Deserialize)]
pub struct Vec2<T> {
    pub x: T,
    pub y: T,
}

impl<T> Vec2<T> {
    pub const fn new(x: T, y: T) -> Self {
        Self { x, y, }
    }
}

impl<T: Scalar> Vec2<T> {
    #[inline(always)]
    pub fn of(v: T) -> Self {
        Self { x: v, y: v }
    }

    #[inline(always)]
    pub fn min(self, other: Self) -> Self {
        Self {
            x: self.x.min(other.x),
            y: self.y.min(other.y),
        }
    }

    #[inline(always)]
    pub fn max(self, other: Self) -> Self {
        Self {
            x: self.x.max(other.x),
            y: self.y.max(other.y),
        }
    }

    #[inline(always)]
    pub fn min_component(self) -> T {
        self.x.min(self.y)
    }

    #[inline(always)]
    pub fn max_component(self) -> T {
        self.y.max(self.y)
    }
}

impl<T: Number> Vec2<T> {
    pub const ZERO: Self = Self::new(T::ZERO, T::ZERO);
    pub const X: Self = Self::new(T::ONE, T::ZERO);
    pub const Y: Self = Self::new(T::ZERO, T::ONE);

    #[inline(always)]
    pub fn dot(self, other: Self) -> T {
        self.x * other.x + self.y * other.y
    }

    #[inline(always)]
    pub fn len2(self) -> T {
        self.dot(self)
    }

    #[inline(always)]
    pub fn distance2(self, other: Self) -> T {
        (self - other).len2()
    }

    #[inline(always)]
    pub fn reflect(self, other: Self) -> Self {
        self - other * T::TWO * self.dot(other)
    }
}

impl<T: Signed> Vec2<T> {
    #[inline(always)]
    pub fn abs(self) -> Self {
        Self {
            x: self.x.abs(), 
            y: self.y.abs(),
        }
    }
}

impl<T: Float> Vec2<T> {
    #[inline(always)]
    pub fn len(self) -> T {
        self.len2().sqrt()
    }
    
    #[inline(always)]
    pub fn distance(self, other: Self) -> T {
        self.distance2(other).sqrt()
    }

    #[inline(always)]
    pub fn normalized(self) -> Self {
        self * (T::ONE / self.len())
    }
}

impl<T: Number> Add for Vec2<T> {
    type Output = Self;

    #[inline(always)]
    fn add(self, other: Self) -> Self::Output {
        Self {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

impl<T: Number> AddAssign for Vec2<T> {
    #[inline(always)]
    fn add_assign(&mut self, other: Self) {
        self.x += other.x;
        self.y += other.y;
    }
}

impl<T: Number> Sub for Vec2<T> {
    type Output = Self;

    #[inline(always)]
    fn sub(self, other: Self) -> Self::Output {
        Self {
            x: self.x - other.x,
            y: self.y - other.y,
        }
    }
}

impl<T: Number> SubAssign for Vec2<T> {
    #[inline(always)]
    fn sub_assign(&mut self, other: Self) {
        self.x -= other.x;
        self.y -= other.y;
    }
}

impl<T: Number> Mul for Vec2<T> {
    type Output = Self;

    #[inline(always)]
    fn mul(self, other: Self) -> Self::Output {
        Self {
            x: self.x * other.x,
            y: self.y * other.y,
        }
    }
}

impl<T: Number> MulAssign for Vec2<T> {
    fn mul_assign(&mut self, other: Self) {
        self.x *= other.x;
        self.y *= other.y;
    }
}

impl<T: Number> Mul<T> for Vec2<T> {
    type Output = Self;

    #[inline(always)]
    fn mul(self, other: T) -> Self::Output {
        Self {
            x: self.x * other,
            y: self.y * other,
        }
    }
}

impl<T: Number> MulAssign<T> for Vec2<T> {
    #[inline(always)]
    fn mul_assign(&mut self, other: T) {
        self.x *= other;
        self.y *= other;
    }
}

impl<T: Number> Div for Vec2<T> {
    type Output = Self;

    #[inline(always)]
    fn div(self, other: Self) -> Self {
        Self {
            x: self.x / other.x,
            y: self.y / other.y,
        }
    }
}

impl<T: Number> DivAssign for Vec2<T> {
    #[inline(always)]
    fn div_assign(&mut self, other: Self) {
        self.x /= other.x;
        self.y /= other.y;
    }
}

impl<T: Number> Div<T> for Vec2<T> {
    type Output = Self;

    #[inline(always)]
    fn div(self, other: T) -> Self {
        Self {
            x: self.x / other,
            y: self.y / other,
        }
    }
}

impl<T: Number> DivAssign<T> for Vec2<T> {
    #[inline(always)]
    fn div_assign(&mut self, other: T) {
        self.x /= other;
        self.y /= other;
    }
}

impl<T: Signed> Neg for Vec2<T> {
    type Output = Self;

    #[inline(always)]
    fn neg(self) -> Self::Output {
        Self {
            x: -self.x, 
            y: -self.y, 
        }
    }
}

pub type Vec2b = Vec2<bool>;
pub type Vec2i = Vec2<i32>;
pub type Vec2u = Vec2<u32>;
pub type Vec2f = Vec2<f32>;
pub type Vec2d = Vec2<f64>;