use super::Vec2;
#[cfg(not(target_arch = "spirv"))]
use core::fmt;
use core::ops::*;

/// A 2-dimensional vector mask.
///
/// This type is typically created by comparison methods on `Vec2`.
#[derive(Clone, Copy, Default, PartialEq, Eq, Ord, PartialOrd, Hash)]
#[cfg_attr(not(target_arch = "spirv"), repr(C))]
#[cfg_attr(target_arch = "spirv", repr(simd))]
pub struct Vec2Mask(u32, u32);

impl Vec2Mask {
    /// Creates a new `Vec2Mask`.
    #[inline]
    pub fn new(x: bool, y: bool) -> Self {
        const MASK: [u32; 2] = [0, 0xff_ff_ff_ff];
        Self(MASK[x as usize], MASK[y as usize])
    }

    /// Returns a bitmask with the lowest two bits set from the elements of `self`.
    ///
    /// A true element results in a `1` bit and a false element in a `0` bit.  Element `x` goes
    /// into the first lowest bit, element `y` into the second, etc.
    #[inline]
    pub fn bitmask(self) -> u32 {
        (self.0 & 0x1) | (self.1 & 0x1) << 1
    }

    /// Returns true if any of the elements are true, false otherwise.
    ///
    /// In other words: `x || y`.
    #[inline]
    pub fn any(self) -> bool {
        // implementaton matches SSE2 `Vec4Mask` version
        ((self.0 | self.1) & 0x1) != 0
    }

    /// Returns true if all the elements are true, false otherwise.
    ///
    /// In other words: `x && y`.
    #[inline]
    pub fn all(self) -> bool {
        // implementaton matches SSE2 `Vec4Mask` version
        ((self.0 & self.1) & 0x1) != 0
    }

    /// Creates a `Vec2` from the elements in `if_true` and `if_false`, selecting which to use for
    /// each element of `self`.
    ///
    /// A true element in the mask uses the corresponding element from `if_true`, and false uses
    /// the element from `if_false`.
    #[inline]
    pub fn select(self, if_true: Vec2, if_false: Vec2) -> Vec2 {
        Vec2 {
            x: if self.0 != 0 { if_true.x } else { if_false.x },
            y: if self.1 != 0 { if_true.y } else { if_false.y },
        }
    }
}

impl BitAnd for Vec2Mask {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0, self.1 & other.1)
    }
}

impl BitAndAssign for Vec2Mask {
    #[inline]
    fn bitand_assign(&mut self, other: Self) {
        self.0 &= other.0;
        self.1 &= other.1;
    }
}

impl BitOr for Vec2Mask {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0, self.1 | other.1)
    }
}

impl BitOrAssign for Vec2Mask {
    #[inline]
    fn bitor_assign(&mut self, other: Self) {
        self.0 |= other.0;
        self.1 |= other.1;
    }
}

impl Not for Vec2Mask {
    type Output = Self;
    #[inline]
    fn not(self) -> Self {
        Self(!self.0, !self.1)
    }
}

#[cfg(not(target_arch = "spirv"))]
impl fmt::Debug for Vec2Mask {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Vec2Mask({:#x}, {:#x})", self.0, self.1)
    }
}

#[cfg(not(target_arch = "spirv"))]
impl fmt::Display for Vec2Mask {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "[{}, {}]", self.0 != 0, self.1 != 0)
    }
}

impl From<Vec2Mask> for [u32; 2] {
    #[inline]
    fn from(mask: Vec2Mask) -> Self {
        [mask.0, mask.1]
    }
}

impl AsRef<[u32; 2]> for Vec2Mask {
    #[inline]
    fn as_ref(&self) -> &[u32; 2] {
        unsafe { &*(self as *const Self as *const [u32; 2]) }
    }
}
