bmx055 0.1.0

use bitflags::bitflags;

use crate::register_address::{RegRead, WhoAmIA, WhoAmIG, WhoAmIM};

/// All possible errors in this crate
#[derive(Debug)]
pub enum Error<CommE, PinE> {
    /// I²C / SPI communication error
    Comm(CommE),
    /// Chip-select pin error (SPI)
    Pin(PinE),
    /// Invalid input data provided
    InvalidInputData,
}

/// All possible errors in this crate
#[derive(Debug)]
pub struct ModeChangeError<CommE, PinE, DEV> {
    /// I²C / SPI communication error
    pub error: Error<CommE, PinE>,
    /// Original device without mode changed
    pub dev: DEV,
}

/// Device operation modes
pub mod mode {
    /// Marker type for magnetometer in one-shot (single) mode.
    #[derive(Debug)]
    pub enum MagOneShot {}
    /// Marker type for magnetometer in continuous mode.
    #[derive(Debug)]
    pub enum MagContinuous {}
}

/// An Accelerometer ID.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AccelerometerId {
    raw: u8,
}

impl AccelerometerId {
    pub(crate) fn from_bits_truncate(raw: u8) -> Self {
        Self { raw }
    }

    /// Raw accelerometer ID.
    pub const fn raw(&self) -> u8 {
        self.raw
    }

    /// Check if the ID corresponds to the expected value.
    pub const fn is_correct(&self) -> bool {
        self.raw == WhoAmIA::ID
    }
}

/// An acceleration measurement.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Acceleration {
    pub(crate) x: u16,
    pub(crate) y: u16,
    pub(crate) z: u16,
    pub(crate) mode: AccelMode,
    pub(crate) range: AccelRange,
}

impl RegRead<(u16, u16, u16)> for Acceleration {
    type Output = (u16, u16, u16);

    /// ACC_X_Y_Z
    const ADDR: u8 = 0x02;

    #[inline(always)]
    fn from_data(data: (u16, u16, u16)) -> Self::Output {
        data
    }
}

impl Acceleration {
    /// Raw acceleration in X-direction.
    #[inline]
    pub const fn x_raw(&self) -> u16 {
        self.x
    }

    /// Raw acceleration in Y-direction.
    #[inline]
    pub const fn y_raw(&self) -> u16 {
        self.y
    }

    /// Raw acceleration in Z-direction.
    #[inline]
    pub const fn z_raw(&self) -> u16 {
        self.z
    }

    /// Raw acceleration in X-, Y- and Z-directions.
    #[inline]
    pub const fn xyz_raw(&self) -> (u16, u16, u16) {
        (self.x, self.y, self.z)
    }

    /// Unscaled acceleration in X-direction.
    #[inline]
    pub const fn x_unscaled(&self) -> i16 {
        (self.x as i16) / 0b1_0000
    }

    /// Unscaled acceleration in Y-direction.
    #[inline]
    pub const fn y_unscaled(&self) -> i16 {
        (self.y as i16) / 0b1_0000
    }

    /// Unscaled acceleration in Z-direction.
    #[inline]
    pub const fn z_unscaled(&self) -> i16 {
        (self.z as i16) / 0b1_0000
    }

    /// Unscaled acceleration in X-, Y- and Z-directions.
    #[inline]
    pub const fn xyz_unscaled(&self) -> (i16, i16, i16) {
        let factor = 0b1_0000;

        (
            (self.x as i16) / factor,
            (self.y as i16) / factor,
            (self.z as i16) / factor,
        )
    }

    /// Acceleration in X-direction in m*g* (milli-*g*).
    #[inline]
    pub const fn x_mg(&self) -> i32 {
        self.x_unscaled() as i32
    }

    /// Acceleration in Y-direction in m*g* (milli-*g*).
    #[inline]
    pub const fn y_mg(&self) -> i32 {
        self.y_unscaled() as i32
    }

    /// Acceleration in Z-direction in m*g* (milli-*g*).
    #[inline]
    pub const fn z_mg(&self) -> i32 {
        self.z_unscaled() as i32
    }

    /// Acceleration in X-, Y- and Z-directions in m*g* (milli-*g*).
    #[inline]
    pub const fn xyz_mg(&self) -> (i32, i32, i32) {
        let (x_unscaled, y_unscaled, z_unscaled) = self.xyz_unscaled();
        let scaling_factor = 1;

        (
            (x_unscaled as i32) * scaling_factor,
            (y_unscaled as i32) * scaling_factor,
            (z_unscaled as i32) * scaling_factor,
        )
    }
}

/// Accelerometer bandwidth
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum AccelBandwidth {
    /// 7.81 Hz
    Hz7_81,
    /// 15.63 Hz
    Hz15_63,
    /// 31.25 Hz
    Hz31_25,
    /// 62.5 Hz
    Hz62_5,
    /// 125 Hz
    Hz125,
    /// 250 Hz
    Hz250,
    /// 500 Hz
    Hz500,
    /// 1.000 Hz
    Hz1000,
}

/// Accelerometer mode
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum AccelMode {
    /// Normal mode
    Normal,
}

/// Accelerometer g-range
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum AccelRange {
    /// Plus or minus 2g
    G2 = 2,
    /// Plus or minus 4g
    G4 = 4,
    /// Plus or minus 8g
    G8 = 8,
    /// Plus or minus 16g
    G16 = 16,
}

bitflags! {
    #[derive(Debug, Default, Copy, Clone, PartialEq)]
    pub struct StatusFlags: u8 {
        const DATA_INT      = 0b10000000;
        const FIFO_WM_INT   = 0b01000000;
        const FIFO_FULL_INT = 0b00100000;
    }
}

/// Data status
#[derive(Debug, Default, Clone, Copy, PartialEq)]
pub struct Status {
    flags: StatusFlags,
}

impl Status {
    pub(crate) const fn new(flags: StatusFlags) -> Self {
        Self { flags }
    }

    /// X-, Y- and Z-axis new data available.
    #[inline]
    pub const fn xyz_new_data(&self) -> bool {
        self.flags.contains(StatusFlags::DATA_INT)
    }
}

bitflags! {
    #[derive(Debug, Default, Copy, Clone, PartialEq)]
    pub struct GyroStatusFlags: u8 {
        const DATA_INT        = 0b10000000;
        const AUTO_OFFSET_INT = 0b01000000;
        const FAST_OFFSET_INT = 0b00100000;
        const FIFO_INT        = 0b00010000;
    }
}

/// Gyroscope data status
#[derive(Debug, Default, Clone, Copy, PartialEq)]
pub struct GyroStatus {
    flags: GyroStatusFlags,
}

impl GyroStatus {
    pub(crate) const fn new(flags: GyroStatusFlags) -> Self {
        Self { flags }
    }

    /// X-, Y- and Z-axis new data available.
    #[inline]
    pub const fn xyz_new_data(&self) -> bool {
        self.flags.contains(GyroStatusFlags::DATA_INT)
    }
}

/// A temperature measurement.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Temperature {
    pub(crate) raw: u8,
}

impl RegRead<u8> for Temperature {
    type Output = Self;

    /// OUT_TEMP_L_A
    const ADDR: u8 = 0x08;

    #[inline]
    fn from_data(data: u8) -> Self::Output {
        Temperature { raw: data }
    }
}

impl Temperature {
    const CENTER: f32 = 23.0;

    /// Raw temperature.
    #[inline]
    pub const fn raw(&self) -> u8 {
        self.raw
    }

    /// Unscaled temperature.
    #[inline]
    pub const fn unscaled(&self) -> i8 {
        self.raw as i8
    }

    /// Temperature in °C.
    #[inline]
    pub fn degrees_celsius(&self) -> f32 {
        f32::from(self.unscaled()) / 2.0 + Self::CENTER
    }
}

/// Gyroscope filter bandwidth
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum GyroFilterBandwidth {
    /// 32 Hz, ODR 100 Hz
    Hz32,
    /// 64 Hz, ODR 200 Hz
    Hz64,
    /// 12 Hz, ODR 100 Hz
    Hz12,
    /// 23 Hz, ODR 200 Hz
    Hz23,
    /// 47 Hz, ODR 400 Hz
    Hz47,
    /// 116 Hz, ODR 1000 Hz
    Hz116,
    /// 230 Hz, ODR 2000 Hz
    Hz230,
    /// 523 Hz, ODR 2000 Hz
    Hz523,
}

/// Gyroscope mode
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum GyroMode {
    /// Normal mode
    Normal,
}

/// Gyroscope range
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum GyroRange {
    /// Plus or minus 2000 °/s
    R2000 = 2000,
    /// Plus or minus 1000 °/s
    R1000 = 1000,
    /// Plus or minus 500 °/s
    R500 = 500,
    /// Plus or minus 250 °/s
    R250 = 250,
    /// Plus or minus 125 °/s
    R125 = 125,
}

/// An angular rate measurement.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AngularRate {
    pub(crate) x: u16,
    pub(crate) y: u16,
    pub(crate) z: u16,
    pub(crate) mode: GyroMode,
    pub(crate) range: GyroRange,
}

impl RegRead<(u16, u16, u16)> for AngularRate {
    type Output = (u16, u16, u16);

    /// GYR_X_Y_Z
    const ADDR: u8 = 0x02;

    #[inline(always)]
    fn from_data(data: (u16, u16, u16)) -> Self::Output {
        data
    }
}

impl AngularRate {
    /// Raw angular rate in X-direction.
    #[inline]
    pub const fn x_raw(&self) -> u16 {
        self.x
    }

    /// Raw angular rate in Y-direction.
    #[inline]
    pub const fn y_raw(&self) -> u16 {
        self.y
    }

    /// Raw angular rate in Z-direction.
    #[inline]
    pub const fn z_raw(&self) -> u16 {
        self.z
    }

    /// Raw angular rate in X-, Y- and Z-directions.
    #[inline]
    pub const fn xyz_raw(&self) -> (u16, u16, u16) {
        (self.x, self.y, self.z)
    }

    /// Unscaled angular rate in X-direction.
    #[inline]
    pub const fn x_unscaled(&self) -> i16 {
        self.x as i16
    }

    /// Unscaled angular rate in Y-direction.
    #[inline]
    pub const fn y_unscaled(&self) -> i16 {
        self.y as i16
    }

    /// Unscaled angular rate in Z-direction.
    #[inline]
    pub const fn z_unscaled(&self) -> i16 {
        self.z as i16
    }

    /// Unscaled angular rate in X-, Y- and Z-directions.
    #[inline]
    pub const fn xyz_unscaled(&self) -> (i16, i16, i16) {
        (self.x as i16, self.y as i16, self.z as i16)
    }

    /// Angular rate in X-direction in °/s (degree per second)
    #[inline]
    pub fn x_dps(&self) -> f64 {
        let factor: f64 = (self.range as i32 as f64) / 32767_f64;
        (self.x_unscaled() as f64) * factor
    }

    /// Angular rate in Y-direction in °/s (degree per second)
    #[inline]
    pub fn y_dps(&self) -> f64 {
        let factor: f64 = (self.range as i32 as f64) / 32767_f64;
        (self.y_unscaled() as f64) * factor
    }

    /// Angular rate in Z-direction in °/s (degree per second)
    #[inline]
    pub fn z_dps(&self) -> f64 {
        let factor: f64 = (self.range as i32 as f64) / 32767_f64;
        (self.z_unscaled() as f64) * factor
    }

    /// Angular rate in X-, Y- and Z-directions °/s (degree per second)
    #[inline]
    pub fn xyz_dps(&self) -> (f64, f64, f64) {
        let (x_unscaled, y_unscaled, z_unscaled) = self.xyz_unscaled();
        let scaling_factor: f64 = (self.range as i32 as f64) / 32767_f64;

        (
            (x_unscaled as f64) * scaling_factor,
            (y_unscaled as f64) * scaling_factor,
            (z_unscaled as f64) * scaling_factor,
        )
    }
}

/// A Gyroscope ID.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct GyroscopeId {
    raw: u8,
}

impl GyroscopeId {
    pub(crate) fn from_bits_truncate(raw: u8) -> Self {
        Self { raw }
    }

    /// Raw accelerometer ID.
    pub const fn raw(&self) -> u8 {
        self.raw
    }

    /// Check if the ID corresponds to the expected value.
    pub const fn is_correct(&self) -> bool {
        self.raw == WhoAmIG::ID
    }
}

/// A Magnetometer ID.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MagnetometerId {
    raw: u8,
}

impl MagnetometerId {
    pub(crate) fn from_bits_truncate(raw: u8) -> Self {
        Self { raw }
    }

    /// Raw magnetometer ID.
    pub const fn raw(&self) -> u8 {
        self.raw
    }

    /// Check if the ID corresponds to the expected value.
    pub const fn is_correct(&self) -> bool {
        self.raw == WhoAmIM::ID
    }
}

/// Magnetometer op mode
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MagOpMode {
    Normal,
    Forced,
    Sleep,
}

/// A magnetic field data measurement.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MagneticFieldData {
    pub(crate) x: u16,
    pub(crate) y: u16,
    pub(crate) z: u16,
    pub(crate) rhall: u16,
    pub trim_data: TrimData,
}

impl RegRead<(u16, u16, u16, u16)> for MagneticFieldData {
    type Output = (u16, u16, u16, u16);

    /// MAG_X_Y_Z_RHALL
    const ADDR: u8 = 0x42;

    #[inline(always)]
    fn from_data(data: (u16, u16, u16, u16)) -> Self::Output {
        data
    }
}

impl MagneticFieldData {
    /// Raw value X
    #[inline]
    pub const fn x_raw(&self) -> u16 {
        self.x
    }

    /// Raw value Y
    #[inline]
    pub const fn y_raw(&self) -> u16 {
        self.y
    }

    /// Raw value Z
    #[inline]
    pub const fn z_raw(&self) -> u16 {
        self.z
    }

    /// Raw value RHALL
    #[inline]
    pub const fn rhall_raw(&self) -> u16 {
        self.rhall
    }

    /// Raw values X, Y, Z and RHALL
    #[inline]
    pub const fn xyzr_raw(&self) -> (u16, u16, u16, u16) {
        (self.x, self.y, self.z, self.rhall)
    }

    /// Unscaled X
    #[inline]
    pub const fn x_unscaled(&self) -> i16 {
        (self.x as i16) >> 3
    }

    /// Unscaled Y
    #[inline]
    pub const fn y_unscaled(&self) -> i16 {
        (self.y as i16) >> 3
    }

    /// Unscaled Z
    #[inline]
    pub const fn z_unscaled(&self) -> i16 {
        (self.z as i16) >> 1
    }

    /// Unscaled RHALL
    #[inline]
    pub const fn rhall_unscaled(&self) -> u16 {
        self.rhall >> 2
    }

    /// Data ready
    #[inline]
    pub const fn data_ready(&self) -> bool {
        self.rhall & 0b0000_0000_0000_0001 == 1
    }

    /// Unscaled X, Y, Z and RHALL
    #[inline]
    pub const fn xyzr_unscaled(&self) -> (i16, i16, i16, u16) {
        (
            self.x_unscaled(),
            self.y_unscaled(),
            self.z_unscaled(),
            self.rhall_unscaled(),
        )
    }
}

/// Trim data X1Y1
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TrimX1Y1 {
    dig_x1: i8,
    dig_y1: i8,
}

impl RegRead<[u8; 2]> for TrimX1Y1 {
    type Output = TrimX1Y1;

    /// MAG_DIG_X1
    const ADDR: u8 = 0x5d;

    #[inline(always)]
    fn from_data(data: [u8; 2]) -> Self::Output {
        TrimX1Y1 {
            dig_x1: i8::from_le_bytes([data[0]]),
            dig_y1: i8::from_le_bytes([data[1]]),
        }
    }
}

/// Trim data XYZ
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TrimXYZ {
    dig_z4: i16,
    dig_x2: i8,
    dig_y2: i8,
}

impl RegRead<[u8; 4]> for TrimXYZ {
    type Output = TrimXYZ;

    /// MAG_DIG_Z4_LSB
    const ADDR: u8 = 0x62;

    #[inline(always)]
    fn from_data(data: [u8; 4]) -> Self::Output {
        TrimXYZ {
            dig_z4: i16::from_le_bytes([data[0], data[1]]),
            dig_x2: i8::from_le_bytes([data[2]]),
            dig_y2: i8::from_le_bytes([data[3]]),
        }
    }
}

/// Trim data XY1XY2
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TrimXY1XY2 {
    dig_z2: i16,
    dig_z1: i16,
    dig_xyz1: u16,
    dig_z3: i16,
    dig_xy1: u8,
    dig_xy2: i8,
}

impl RegRead<[u8; 10]> for TrimXY1XY2 {
    type Output = TrimXY1XY2;

    /// MAG_DIG_Z2_LSB
    const ADDR: u8 = 0x68;

    #[inline(always)]
    fn from_data(data: [u8; 10]) -> Self::Output {
        TrimXY1XY2 {
            dig_z2: i16::from_le_bytes([data[0], data[1]]),
            dig_z1: i16::from_le_bytes([data[2], data[3]]),
            dig_xyz1: u16::from_le_bytes([data[4], data[5]]) & 0x7fff,
            dig_z3: i16::from_le_bytes([data[6], data[7]]),
            dig_xy1: data[8],
            dig_xy2: i8::from_le_bytes([data[9]]),
        }
    }
}

/// Trim data
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TrimData {
    pub(crate) dig_x1: i8,
    pub(crate) dig_y1: i8,
    pub(crate) dig_z4: i16,
    pub(crate) dig_x2: i8,
    pub(crate) dig_y2: i8,
    pub(crate) dig_z2: i16,
    pub(crate) dig_z1: i16,
    pub(crate) dig_xyz1: u16,
    pub(crate) dig_z3: i16,
    pub(crate) dig_xy1: u8,
    pub(crate) dig_xy2: i8,
}

impl From<(TrimX1Y1, TrimXYZ, TrimXY1XY2)> for TrimData {
    #[inline(always)]
    fn from(
        (
            TrimX1Y1 { dig_x1, dig_y1 },
            TrimXYZ {
                dig_z4,
                dig_x2,
                dig_y2,
            },
            TrimXY1XY2 {
                dig_z2,
                dig_z1,
                dig_xyz1,
                dig_z3,
                dig_xy1,
                dig_xy2,
            },
        ): (TrimX1Y1, TrimXYZ, TrimXY1XY2),
    ) -> Self {
        TrimData {
            dig_x1,
            dig_y1,
            dig_z4,
            dig_x2,
            dig_y2,
            dig_z2,
            dig_z1,
            dig_xyz1,
            dig_z3,
            dig_xy1,
            dig_xy2,
        }
    }
}