// Copyright (c) 2016-2017 <daggerbot@gmail.com>
// This software is available under the terms of the zlib license.
// See COPYING.md for more information.

use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Not, Rem, Shl, Shr, Sub};

use numeric::{Lerp, One, RawFrom, Sqrt, TryAdd, TryDiv, TryMul, TrySub, Zero};

use complex::Complex;

/// Two dimensional vector structure.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
#[cfg_attr(feature = "serde_derive", derive(Serialize, Deserialize))]
pub struct Vec2<T> (pub T, pub T);

impl<T> Vec2<T> {
    pub fn dot (self, rhs: Vec2<T>) -> T where T: Add<Output = T> + Mul<Output = T> {
        (self * rhs).sum()
    }

    pub fn magnitude (self) -> T where T: Copy + Add<Output = T> + Mul<Output = T> + Sqrt {
        self.square_magnitude().sqrt()
    }

    pub fn product (self) -> T where T: Mul<Output = T> {
        self.0 * self.1
    }

    pub fn square_magnitude (self) -> T where T: Copy + Add<Output = T> + Mul<Output = T> {
        self.0 * self.0 + self.1 * self.1
    }

    pub fn sum (self) -> T where T: Add<Output = T> {
        self.0 + self.1
    }

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

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

impl<T> From<Complex<T>> for Vec2<T> {
    fn from (other: Complex<T>) -> Vec2<T> { Vec2(other.0, other.1) }
}

impl<S: Lerp<T>, T: Copy> Lerp<T> for Vec2<S> {
    fn lerp (a: Vec2<S>, b: Vec2<S>, t: T) -> Vec2<S> {
        Vec2(S::lerp(a.0, b.0, t), S::lerp(a.1, b.1, t))
    }
}

impl<T: One> One for Vec2<T> {
    fn one () -> Vec2<T> { Vec2(T::one(), T::one()) }
}

impl<F, T: RawFrom<F>> RawFrom<Vec2<F>> for Vec2<T> {
    fn raw_from (other: Vec2<F>) -> Vec2<T> { Vec2(T::raw_from(other.0), T::raw_from(other.1)) }
}

impl<T: Zero> Zero for Vec2<T> {
    fn zero () -> Vec2<T> { Vec2(T::zero(), T::zero()) }
}

/// Three dimensional vector structure.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
#[cfg_attr(feature = "serde_derive", derive(Serialize, Deserialize))]
pub struct Vec3<T> (pub T, pub T, pub T);

impl<T> Vec3<T> {
    pub fn dot (self, rhs: Vec3<T>) -> T where T: Add<Output = T> + Mul<Output = T> {
        (self * rhs).sum()
    }

    pub fn magnitude (self) -> T where T: Copy + Add<Output = T> + Mul<Output = T> + Sqrt {
        self.square_magnitude().sqrt()
    }

    pub fn product (self) -> T where T: Mul<Output = T> {
        self.0 * self.1 * self.2
    }

    pub fn square_magnitude (self) -> T where T: Copy + Add<Output = T> + Mul<Output = T> {
        self.0 * self.0 + self.1 * self.1 + self.2 * self.2
    }

    pub fn sum (self) -> T where T: Add<Output = T> {
        self.0 + self.1 + self.2
    }

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

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

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

impl<S: Lerp<T>, T: Copy> Lerp<T> for Vec3<S> {
    fn lerp (a: Vec3<S>, b: Vec3<S>, t: T) -> Vec3<S> {
        Vec3(S::lerp(a.0, b.0, t), S::lerp(a.1, b.1, t), S::lerp(a.2, b.2, t))
    }
}

impl<T: One> One for Vec3<T> {
    fn one () -> Vec3<T> { Vec3(T::one(), T::one(), T::one()) }
}

impl<T: Zero> Zero for Vec3<T> {
    fn zero () -> Vec3<T> { Vec3(T::zero(), T::zero(), T::zero()) }
}

macro_rules! impl_vec_ops {
    { $(impl $op_trait:ident::$op_fn:ident for $vec:ident($($idx:tt),*);)* } => { $(
        impl<T: $op_trait> $op_trait for $vec<T> {
            type Output = $vec<T::Output>;

            fn $op_fn (self) -> $vec<T::Output> {
                $vec($(T::$op_fn(self.$idx)),*)
            }
        }
    )* };
}

macro_rules! impl_vec_scalar_ops {
    { $(impl $op_trait:ident::$op_fn:ident for $vec:ident($($idx:tt),*);)* } => { $(
        impl<T: $op_trait<Output = T> + Copy> $op_trait<T> for $vec<T> {
            type Output = $vec<T>;

            fn $op_fn (self, rhs: T) -> $vec<T> {
                $vec($(T::$op_fn(self.$idx, rhs)),*)
            }
        }
    )* };
}

macro_rules! impl_vec_vec_ops {
    { $(impl $op_trait:ident::$op_fn:ident for $vec:ident($($idx:tt),*);)* } => { $(
        impl<T: $op_trait<Output = T>> $op_trait for $vec<T> {
            type Output = $vec<T>;

            fn $op_fn (self, rhs: $vec<T>) -> $vec<T> {
                $vec($(T::$op_fn(self.$idx, rhs.$idx)),*)
            }
        }
    )* };
}

macro_rules! impl_try_vec_vec_ops {
    { $(impl $op_trait:ident::$op_fn:ident for $vec:ident($($idx:tt),*);)* } => { $(
        impl<T: $op_trait<Output = T>> $op_trait for $vec<T> {
            type Output = $vec<T>;
            type Err = T::Err;

            fn $op_fn (self, rhs: $vec<T>) -> Result<$vec<T>, T::Err> {
                Ok($vec($(T::$op_fn(self.$idx, rhs.$idx)?),*))
            }
        }
    )* };
}

macro_rules! impl_vec_shift_ops {
    { $(impl $op_trait:ident::$op_fn:ident for $vec:ident($($idx:tt),*);)* } => { $(
        impl<R: Copy, T: $op_trait<R, Output = T>> $op_trait<R> for $vec<T> {
            type Output = $vec<T>;

            fn $op_fn (self, rhs: R) -> $vec<T> {
                $vec($(T::$op_fn(self.$idx, rhs)),*)
            }
        }
    )* };
}

impl_vec_ops! {
    impl Neg::neg for Vec2(0, 1);
    impl Neg::neg for Vec3(0, 1, 2);
    impl Not::not for Vec2(0, 1);
    impl Not::not for Vec3(0, 1, 2);
}

impl_vec_scalar_ops! {
    impl Mul::mul for Vec2(0, 1);
    impl Mul::mul for Vec3(0, 1, 2);
    impl Div::div for Vec2(0, 1);
    impl Div::div for Vec3(0, 1, 2);
    impl Rem::rem for Vec2(0, 1);
    impl Rem::rem for Vec3(0, 1, 2);
    impl BitAnd::bitand for Vec2(0, 1);
    impl BitAnd::bitand for Vec3(0, 1, 2);
    impl BitOr::bitor for Vec2(0, 1);
    impl BitOr::bitor for Vec3(0, 1, 2);
    impl BitXor::bitxor for Vec2(0, 1);
    impl BitXor::bitxor for Vec3(0, 1, 2);
}

impl_vec_vec_ops! {
    impl Add::add for Vec2(0, 1);
    impl Add::add for Vec3(0, 1, 2);
    impl Sub::sub for Vec2(0, 1);
    impl Sub::sub for Vec3(0, 1, 2);
    impl Mul::mul for Vec2(0, 1);
    impl Mul::mul for Vec3(0, 1, 2);
    impl Div::div for Vec2(0, 1);
    impl Div::div for Vec3(0, 1, 2);
    impl Rem::rem for Vec2(0, 1);
    impl Rem::rem for Vec3(0, 1, 2);
    impl BitAnd::bitand for Vec2(0, 1);
    impl BitAnd::bitand for Vec3(0, 1, 2);
    impl BitOr::bitor for Vec2(0, 1);
    impl BitOr::bitor for Vec3(0, 1, 2);
    impl BitXor::bitxor for Vec2(0, 1);
    impl BitXor::bitxor for Vec3(0, 1, 2);
}

impl_try_vec_vec_ops! {
    impl TryAdd::try_add for Vec2(0, 1);
    impl TryAdd::try_add for Vec3(0, 1, 2);
    impl TrySub::try_sub for Vec2(0, 1);
    impl TrySub::try_sub for Vec3(0, 1, 2);
    impl TryMul::try_mul for Vec2(0, 1);
    impl TryMul::try_mul for Vec3(0, 1, 2);
    impl TryDiv::try_div for Vec2(0, 1);
    impl TryDiv::try_div for Vec3(0, 1, 2);
}

impl_vec_shift_ops! {
    impl Shl::shl for Vec2(0, 1);
    impl Shl::shl for Vec3(0, 1, 2);
    impl Shr::shr for Vec2(0, 1);
    impl Shr::shr for Vec3(0, 1, 2);
}