//! `NcBoxMask`

/// A bitmask for drawing borders, gradients and corners.
///
/// # Flags
/// - [`GradTop`][NcBoxMask::GradTop]
/// - [`GradRight`][NcBoxMask::GradRight]
/// - [`GradBottom`][NcBoxMask::GradBottom]
/// - [`GradLeft`][NcBoxMask::GradLeft]
/// - [`MaskTop`][NcBoxMask::MaskTop]
/// - [`MaskRight`][NcBoxMask::MaskRight]
/// - [`MaskBottom`][NcBoxMask::MaskBottom]
/// - [`MaskLeft`][NcBoxMask::MaskLeft]
/// - [`CornerMask`][NcBoxMask::CornerMask]
/// - [`CornerShift`][NcBoxMask::CornerShift]
/// - [`None`][NcBoxMask::None]
///
/// # Default
/// *[`NcBoxMask::None`]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct NcBoxMask(pub c_api::NcBoxMask_u32);

/// # Constants
impl NcBoxMask {
    /// Top gradient mask.
    pub const GradTop: Self = Self(c_api::NCBOXGRAD_TOP);

    /// Right gradient mask.
    pub const GradRight: Self = Self(c_api::NCBOXGRAD_RIGHT);

    /// Bottom gradient mask.
    pub const GradBottom: Self = Self(c_api::NCBOXGRAD_BOTTOM);

    /// Left gradient mask.
    pub const GradLeft: Self = Self(c_api::NCBOXGRAD_LEFT);

    /// Top border mask.
    pub const MaskTop: Self = Self(c_api::NCBOXMASK_TOP);

    /// Right border mask.
    pub const MaskRight: Self = Self(c_api::NCBOXMASK_RIGHT);

    /// Bottom border mask.
    pub const MaskBottom: Self = Self(c_api::NCBOXMASK_BOTTOM);

    /// Left border mask.
    pub const MaskLeft: Self = Self(c_api::NCBOXMASK_LEFT);

    /// Corner mask to control the drawing of boxes corners.
    ///
    /// By default, vertexes are drawn whether their connecting edges are drawn
    /// or not. The value of the bits control this, and are interpreted as the
    /// number of connecting edges necessary to draw a given corner.
    ///
    /// At 0 (the default), corners are always drawn. At 3, corners are never
    /// drawn (since at most 2 edges can touch a box's corner).
    pub const CornerMask: Self = Self(c_api::NCBOXCORNER_MASK);

    /// The number of bits [`CornerMask`] is shifted.
    ///
    /// [`CornerMask`]: NcBoxMask#associatedconstant.CornerMask
    pub const CornerShift: Self = Self(c_api::NCBOXCORNER_SHIFT);

    /// None of the bits set.
    pub const None: Self = Self(0);
}

/// # Methods
impl NcBoxMask {
    /// Returns true if the current style has included the `other_style`.
    pub fn has(&self, other: impl Into<NcBoxMask>) -> bool {
        let other = other.into();
        (self.0 & other.0) == other.0
    }

    /// Adds the `other_style` to the current style.
    pub fn add(&mut self, other: impl Into<NcBoxMask>) {
        self.0 |= other.into().0
    }
}

mod std_impls {
    use super::{c_api::NcBoxMask_u32, NcBoxMask};

    impl Default for NcBoxMask {
        fn default() -> Self {
            Self::None
        }
    }

    crate::from_primitive![NcBoxMask, NcBoxMask_u32];
    crate::unit_impl_from![NcBoxMask, NcBoxMask_u32];
    crate::unit_impl_ops![bitwise; NcBoxMask, NcBoxMask_u32];
    crate::unit_impl_fmt![bases+display; NcBoxMask];
}

pub(crate) mod c_api {
    use crate::c_api::ffi;

    /// Controls the drawing of borders, gradients and corners.
    ///
    /// It's recommended to use [`NcBoxMask`][crate::NcBoxMask] instead.
    ///
    /// `NcBoxMax_u32` is defined in the least significant byte, where bits [3, 0] are
    /// are a border mask, and bits [7, 4] are a gradient mask.
    ///
    /// The drawing of the corners is defined in the second byte,
    /// see [`NCBOXCORNER_MASK`].
    ///
    /// # Associated `c_api` constants
    /// - [`NCBOXGRAD_TOP`]
    /// - [`NCBOXGRAD_RIGHT`]
    /// - [`NCBOXGRAD_BOTTOM`]
    /// - [`NCBOXGRAD_LEFT`]
    /// - [`NCBOXMASK_TOP`]
    /// - [`NCBOXMASK_RIGHT`]
    /// - [`NCBOXMASK_BOTTOM`]
    /// - [`NCBOXMASK_LEFT`]
    /// - [`NCBOXCORNER_MASK`]
    /// - [`NCBOXCORNER_SHIFT`]
    ///
    /// ## Diagram
    ///
    /// ```txt
    /// MASK_TOP    0x0001  0b00000001
    /// MASK_RIGHT  0x0002  0b00000010
    /// MASK_BOTTOM 0x0004  0b00000100
    /// MASK_LEFT   0x0008  0b00001000
    ///
    /// GRAD_TOP    0x0010  0b00010000
    /// GRAD_RIGHT  0x0020  0b00100000
    /// GRAD_BOTTOM 0x0040  0b01000000
    /// GRAD_LEFT   0x0080  0b10000000
    ///
    /// NCBOXCORNER_MASK  0x0300  0b00000111_00000000
    ///
    /// NCBOXCORNER_SHIFT 8
    /// ```
    pub type NcBoxMask_u32 = u32;

    /// [`NcBoxMask_u32`] top gradient mask.
    pub const NCBOXGRAD_TOP: NcBoxMask_u32 = ffi::NCBOXGRAD_TOP;

    /// [`NcBoxMask_u32`] right gradient mask.
    pub const NCBOXGRAD_RIGHT: NcBoxMask_u32 = ffi::NCBOXGRAD_RIGHT;

    /// [`NcBoxMask_u32`] bottom gradient mask.
    pub const NCBOXGRAD_BOTTOM: NcBoxMask_u32 = ffi::NCBOXGRAD_BOTTOM;

    /// [`NcBoxMask_u32`] left gradient mask.
    pub const NCBOXGRAD_LEFT: NcBoxMask_u32 = ffi::NCBOXGRAD_LEFT;

    /// [`NcBoxMask_u32`] top border mask.
    pub const NCBOXMASK_TOP: NcBoxMask_u32 = ffi::NCBOXMASK_TOP;

    /// [`NcBoxMask_u32`] right border mask.
    pub const NCBOXMASK_RIGHT: NcBoxMask_u32 = ffi::NCBOXMASK_RIGHT;

    /// [`NcBoxMask_u32`] bottom border mask.
    pub const NCBOXMASK_BOTTOM: NcBoxMask_u32 = ffi::NCBOXMASK_BOTTOM;

    /// [`NcBoxMask_u32`] left border mask.
    pub const NCBOXMASK_LEFT: NcBoxMask_u32 = ffi::NCBOXMASK_LEFT;

    /// [`NcBoxMask_u32`] corner mask to control the drawing of boxes corners.
    ///
    /// By default, vertexes are drawn whether their connecting edges are drawn
    /// or not. The value of the bits control this, and are interpreted as the
    /// number of connecting edges necessary to draw a given corner.
    ///
    /// At 0 (the default), corners are always drawn. At 3, corners are never
    /// drawn (since at most 2 edges can touch a box's corner).
    pub const NCBOXCORNER_MASK: NcBoxMask_u32 = ffi::NCBOXCORNER_MASK;

    /// [`NcBoxMask_u32`] the number of bits [`NCBOXCORNER_MASK`] is shifted.
    pub const NCBOXCORNER_SHIFT: NcBoxMask_u32 = ffi::NCBOXCORNER_SHIFT;
}