#![doc = "This file was automatically generated, do not edit"]
use crate::MavlinkVersion;
use crate::{bytes::Bytes, bytes_mut::BytesMut, error::*, Message, MessageData};
#[allow(unused_imports)]
use bitflags::bitflags;
#[allow(unused_imports)]
use num_derive::FromPrimitive;
#[allow(unused_imports)]
use num_derive::ToPrimitive;
#[allow(unused_imports)]
use num_traits::FromPrimitive;
#[allow(unused_imports)]
use num_traits::ToPrimitive;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
#[doc = "id: 17000"]
#[doc = "Test all field types."]
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct TEST_TYPES_DATA {
    #[doc = "uint64_t."]
    pub u64: u64,
    #[doc = "int64_t."]
    pub s64: i64,
    #[doc = "double."]
    pub d: f64,
    #[doc = "uint64_t_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub u64_array: [u64; 3],
    #[doc = "int64_t_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub s64_array: [i64; 3],
    #[doc = "double_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub d_array: [f64; 3],
    #[doc = "uint32_t."]
    pub u32: u32,
    #[doc = "int32_t."]
    pub s32: i32,
    #[doc = "float."]
    pub f: f32,
    #[doc = "uint32_t_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub u32_array: [u32; 3],
    #[doc = "int32_t_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub s32_array: [i32; 3],
    #[doc = "float_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub f_array: [f32; 3],
    #[doc = "uint16_t."]
    pub u16: u16,
    #[doc = "int16_t."]
    pub s16: i16,
    #[doc = "uint16_t_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub u16_array: [u16; 3],
    #[doc = "int16_t_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub s16_array: [i16; 3],
    #[doc = "char."]
    pub c: u8,
    #[doc = "string."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub s: [u8; 10],
    #[doc = "uint8_t."]
    pub u8: u8,
    #[doc = "int8_t."]
    pub s8: i8,
    #[doc = "uint8_t_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub u8_array: [u8; 3],
    #[doc = "int8_t_array."]
    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
    pub s8_array: [i8; 3],
}
impl TEST_TYPES_DATA {
    pub const ENCODED_LEN: usize = 179usize;
    pub const DEFAULT: Self = Self {
        u64: 0_u64,
        s64: 0_i64,
        d: 0.0_f64,
        u64_array: [0_u64; 3usize],
        s64_array: [0_i64; 3usize],
        d_array: [0.0_f64; 3usize],
        u32: 0_u32,
        s32: 0_i32,
        f: 0.0_f32,
        u32_array: [0_u32; 3usize],
        s32_array: [0_i32; 3usize],
        f_array: [0.0_f32; 3usize],
        u16: 0_u16,
        s16: 0_i16,
        u16_array: [0_u16; 3usize],
        s16_array: [0_i16; 3usize],
        c: 0_u8,
        s: [0_u8; 10usize],
        u8: 0_u8,
        s8: 0_i8,
        u8_array: [0_u8; 3usize],
        s8_array: [0_i8; 3usize],
    };
}
impl Default for TEST_TYPES_DATA {
    fn default() -> Self {
        Self::DEFAULT.clone()
    }
}
impl MessageData for TEST_TYPES_DATA {
    type Message = MavMessage;
    const ID: u32 = 17000u32;
    const NAME: &'static str = "TEST_TYPES";
    const EXTRA_CRC: u8 = 103u8;
    const ENCODED_LEN: usize = 179usize;
    fn deser(_version: MavlinkVersion, __input: &[u8]) -> Result<Self, ParserError> {
        let avail_len = __input.len();
        let mut payload_buf = [0; Self::ENCODED_LEN];
        let mut buf = if avail_len < Self::ENCODED_LEN {
            payload_buf[0..avail_len].copy_from_slice(__input);
            Bytes::new(&payload_buf)
        } else {
            Bytes::new(__input)
        };
        let mut __struct = Self::default();
        __struct.u64 = buf.get_u64_le();
        __struct.s64 = buf.get_i64_le();
        __struct.d = buf.get_f64_le();
        for v in &mut __struct.u64_array {
            let val = buf.get_u64_le();
            *v = val;
        }
        for v in &mut __struct.s64_array {
            let val = buf.get_i64_le();
            *v = val;
        }
        for v in &mut __struct.d_array {
            let val = buf.get_f64_le();
            *v = val;
        }
        __struct.u32 = buf.get_u32_le();
        __struct.s32 = buf.get_i32_le();
        __struct.f = buf.get_f32_le();
        for v in &mut __struct.u32_array {
            let val = buf.get_u32_le();
            *v = val;
        }
        for v in &mut __struct.s32_array {
            let val = buf.get_i32_le();
            *v = val;
        }
        for v in &mut __struct.f_array {
            let val = buf.get_f32_le();
            *v = val;
        }
        __struct.u16 = buf.get_u16_le();
        __struct.s16 = buf.get_i16_le();
        for v in &mut __struct.u16_array {
            let val = buf.get_u16_le();
            *v = val;
        }
        for v in &mut __struct.s16_array {
            let val = buf.get_i16_le();
            *v = val;
        }
        __struct.c = buf.get_u8();
        for v in &mut __struct.s {
            let val = buf.get_u8();
            *v = val;
        }
        __struct.u8 = buf.get_u8();
        __struct.s8 = buf.get_i8();
        for v in &mut __struct.u8_array {
            let val = buf.get_u8();
            *v = val;
        }
        for v in &mut __struct.s8_array {
            let val = buf.get_i8();
            *v = val;
        }
        Ok(__struct)
    }
    fn ser(&self, version: MavlinkVersion, bytes: &mut [u8]) -> usize {
        let mut __tmp = BytesMut::new(bytes);
        __tmp.put_u64_le(self.u64);
        __tmp.put_i64_le(self.s64);
        __tmp.put_f64_le(self.d);
        for val in &self.u64_array {
            __tmp.put_u64_le(*val);
        }
        for val in &self.s64_array {
            __tmp.put_i64_le(*val);
        }
        for val in &self.d_array {
            __tmp.put_f64_le(*val);
        }
        __tmp.put_u32_le(self.u32);
        __tmp.put_i32_le(self.s32);
        __tmp.put_f32_le(self.f);
        for val in &self.u32_array {
            __tmp.put_u32_le(*val);
        }
        for val in &self.s32_array {
            __tmp.put_i32_le(*val);
        }
        for val in &self.f_array {
            __tmp.put_f32_le(*val);
        }
        __tmp.put_u16_le(self.u16);
        __tmp.put_i16_le(self.s16);
        for val in &self.u16_array {
            __tmp.put_u16_le(*val);
        }
        for val in &self.s16_array {
            __tmp.put_i16_le(*val);
        }
        __tmp.put_u8(self.c);
        for val in &self.s {
            __tmp.put_u8(*val);
        }
        __tmp.put_u8(self.u8);
        __tmp.put_i8(self.s8);
        for val in &self.u8_array {
            __tmp.put_u8(*val);
        }
        for val in &self.s8_array {
            __tmp.put_i8(*val);
        }
        if matches!(version, MavlinkVersion::V2) {
            let len = __tmp.len();
            crate::remove_trailing_zeroes(&bytes[..len])
        } else {
            __tmp.len()
        }
    }
}
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(tag = "type"))]
pub enum MavMessage {
    TEST_TYPES(TEST_TYPES_DATA),
}
impl Message for MavMessage {
    fn parse(version: MavlinkVersion, id: u32, payload: &[u8]) -> Result<Self, ParserError> {
        match id {
            TEST_TYPES_DATA::ID => TEST_TYPES_DATA::deser(version, payload).map(Self::TEST_TYPES),
            _ => Err(ParserError::UnknownMessage { id }),
        }
    }
    fn message_name(&self) -> &'static str {
        match self {
            Self::TEST_TYPES(..) => TEST_TYPES_DATA::NAME,
        }
    }
    fn message_id(&self) -> u32 {
        match self {
            Self::TEST_TYPES(..) => TEST_TYPES_DATA::ID,
        }
    }
    fn message_id_from_name(name: &str) -> Result<u32, &'static str> {
        match name {
            TEST_TYPES_DATA::NAME => Ok(TEST_TYPES_DATA::ID),
            _ => Err("Invalid message name."),
        }
    }
    fn default_message_from_id(id: u32) -> Result<Self, &'static str> {
        match id {
            TEST_TYPES_DATA::ID => Ok(Self::TEST_TYPES(TEST_TYPES_DATA::default())),
            _ => Err("Invalid message id."),
        }
    }
    fn ser(&self, version: MavlinkVersion, bytes: &mut [u8]) -> usize {
        match self {
            Self::TEST_TYPES(body) => body.ser(version, bytes),
        }
    }
    fn extra_crc(id: u32) -> u8 {
        match id {
            TEST_TYPES_DATA::ID => TEST_TYPES_DATA::EXTRA_CRC,
            _ => 0,
        }
    }
}