nmea-kit 0.5.0

use crate::nmea::field::{FieldReader, FieldWriter, NmeaEncodable};

/// BBM — AIS Broadcast Binary Message.
///
/// Wire: `num_frags,frag_num,msg_id,channel,vdl_msg_num,payload,fill_bits`
///
/// Note: BBM sentences use the `!` prefix on the wire but field parsing
/// is identical to `$`-prefixed sentences at the field layer.
#[derive(Debug, Clone, PartialEq)]
pub struct Bbm {
    /// Total number of sentences needed.
    pub num_frags: Option<u8>,
    /// Fragment number of this sentence.
    pub frag_num: Option<u8>,
    /// Sequential message identifier.
    pub msg_id: Option<u8>,
    /// VHF channel (A or B).
    pub channel: Option<char>,
    /// VDL message number.
    pub vdl_msg_num: Option<u8>,
    /// Encoded AIS payload (armored ASCII).
    pub payload: Option<String>,
    /// Number of fill bits (0–5).
    pub fill_bits: Option<u8>,
}

impl Bbm {
    /// Parse fields from a decoded NMEA frame.
    /// Always returns `Some`; missing or malformed fields become `None`.
    pub fn parse(fields: &[&str]) -> Option<Self> {
        let mut r = FieldReader::new(fields);
        let num_frags = r.u8();
        let frag_num = r.u8();
        let msg_id = r.u8();
        let channel = r.char();
        let vdl_msg_num = r.u8();
        let payload = r.string();
        let fill_bits = r.u8();
        Some(Self {
            num_frags,
            frag_num,
            msg_id,
            channel,
            vdl_msg_num,
            payload,
            fill_bits,
        })
    }
}

impl NmeaEncodable for Bbm {
    const SENTENCE_TYPE: &str = "BBM";

    fn encode(&self) -> Vec<String> {
        let mut w = FieldWriter::new();
        w.u8(self.num_frags);
        w.u8(self.frag_num);
        w.u8(self.msg_id);
        w.char(self.channel);
        w.u8(self.vdl_msg_num);
        w.string(self.payload.as_deref());
        w.u8(self.fill_bits);
        w.finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parse_frame;

    #[test]
    fn bbm_empty() {
        let s = Bbm {
            num_frags: None,
            frag_num: None,
            msg_id: None,
            channel: None,
            vdl_msg_num: None,
            payload: None,
            fill_bits: None,
        }
        .to_sentence("AI");
        let f = parse_frame(s.trim()).expect("valid");
        let b = Bbm::parse(&f.fields).expect("parse");
        assert!(b.num_frags.is_none());
        assert!(b.channel.is_none());
        assert!(b.payload.is_none());
    }

    #[test]
    fn bbm_encode_roundtrip() {
        let original = Bbm {
            num_frags: Some(1),
            frag_num: Some(1),
            msg_id: Some(0),
            channel: Some('A'),
            vdl_msg_num: Some(6),
            payload: Some("test".to_string()),
            fill_bits: Some(0),
        };
        let sentence = original.to_sentence("AI");
        let frame = parse_frame(sentence.trim()).expect("re-parse");
        let parsed = Bbm::parse(&frame.fields).expect("parse");
        assert_eq!(original, parsed);
    }

    #[test]
    fn bbm_aibbm_gonmea() {
        let original = Bbm {
            num_frags: Some(2),
            frag_num: Some(1),
            msg_id: Some(3),
            channel: Some('B'),
            vdl_msg_num: Some(8),
            payload: Some("broadcastdata".to_string()),
            fill_bits: Some(1),
        };
        let sentence = original.to_sentence("AI");
        let frame = parse_frame(sentence.trim()).expect("re-parse");
        let b = Bbm::parse(&frame.fields).expect("parse BBM");
        assert_eq!(b.num_frags, Some(2));
        assert_eq!(b.frag_num, Some(1));
        assert_eq!(b.msg_id, Some(3));
        assert_eq!(b.channel, Some('B'));
        assert_eq!(b.vdl_msg_num, Some(8));
        assert_eq!(b.payload, Some("broadcastdata".to_string()));
        assert_eq!(b.fill_bits, Some(1));
    }
}