dvb-si 13.0.0

//! S2Xv2 Satellite Delivery System Descriptor — ETSI EN 300 468 §6.4.6.5.3
//! (tag_extension `0x24`).
//!
//! Body layout: Table 144a (outer shell) + Table 144b
//! (`S2Xv2_satellite_delivery_system_info()`).
//! Mode coding: Table 144c.
//!
//! The descriptor has a fixed 18-byte core followed by several conditional
//! blocks gated on `S2Xv2_mode`, `multiple_input_stream_flag`,
//! `channel_bond`, and sub-flags. The trailing `for` loop of
//! `reserved_zero_future_use` bytes is kept verbatim in `reserved_tail`.
use super::*;
use crate::descriptors::satellite_delivery_system::{Polarization, RollOff};
use alloc::vec::Vec;
use broadcast_common::len::{need_in, need_out};

impl<'a> ExtensionBodyDef<'a> for S2Xv2SatelliteDeliverySystem<'a> {
    const TAG_EXTENSION: u8 = 0x24;
    const NAME: &'static str = "S2XV2_SATELLITE_DELIVERY_SYSTEM";
}

// Fixed-size constants (Table 144b).
/// Fixed core: delivery_system_id(4) + packed_byte_4(1) + packed_byte_5(1)
/// + packed_byte_6(1) + satellite_id(3) + frequency(4) + symbol_rate(4) = 18.
const S2XV2_CORE_LEN: usize = 18;
/// Scrambling sequence block: reserved(6 bits) + scrambling_sequence_index(18 bits) = 3 bytes.
const S2XV2_SCRAMBLING_LEN: usize = 3;
/// Superframe block minimum (no beamhopping): 4 + 3 + 1 = 8 bytes.
const S2XV2_SUPERFRAME_MIN_LEN: usize = 8;
/// Superframe block with beamhopping: 8 + 4 = 12 bytes.
const S2XV2_SUPERFRAME_BH_LEN: usize = 12;

/// Spec default of every `reserved_zero_future_use` region of the S2Xv2
/// descriptor (Tables 144a-144b; `reserved_zero_future_use` since its
/// introduction in V1.18.1, audit §6.1 row C): all zeros. (V1.19.1 carved
/// `NCR_reference` out of a 3-bit region; that bit is typed, the remaining 2
/// bits are `reserved_zero_future_use_2`.)
pub const S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT: u8 = 0;
/// Width mask of the 2-bit region (byte 5 top bits; superframe byte 1 bits 5:4).
const RZFU_2_MASK: u8 = 0x03;
/// Width mask of the 6-bit region ahead of the scrambling index.
const RZFU_6_MASK: u8 = 0x3F;
/// Width mask of the 7-bit region ahead of `num_channel_bonds_minus_one`.
const RZFU_7_MASK: u8 = 0x7F;

/// S2Xv2 mode — ETSI EN 300 468 Table 144c.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[non_exhaustive]
pub enum S2Xv2Mode {
    /// Reserved for future use (0).
    Reserved0,
    /// S2X (1).
    S2X,
    /// S2X + time slicing (2).
    S2XTimeSlicing,
    /// Reserved for future use (3).
    Reserved3,
    /// S2X superframe (Annex E of ETSI EN 302 307-2) (4).
    S2XSuperframe,
    /// S2X superframe + timeslicing (5).
    S2XSuperframeTimeSlicing,
    /// Reserved / future use (6–15).
    Reserved(u8),
}

impl S2Xv2Mode {
    /// Construct from a raw `u8`; every value maps to a variant (total, lossless).
    #[must_use]
    pub fn from_u8(v: u8) -> Self {
        match v {
            0 => Self::Reserved0,
            1 => Self::S2X,
            2 => Self::S2XTimeSlicing,
            3 => Self::Reserved3,
            4 => Self::S2XSuperframe,
            5 => Self::S2XSuperframeTimeSlicing,
            other => Self::Reserved(other),
        }
    }

    /// Inverse of [`from_u8`](Self::from_u8); `Self::Reserved` emits its stored value.
    #[must_use]
    pub const fn to_u8(self) -> u8 {
        match self {
            Self::Reserved0 => 0,
            Self::S2X => 1,
            Self::S2XTimeSlicing => 2,
            Self::Reserved3 => 3,
            Self::S2XSuperframe => 4,
            Self::S2XSuperframeTimeSlicing => 5,
            Self::Reserved(v) => v,
        }
    }

    /// Human-readable spec name per Table 144c.
    #[must_use]
    pub fn name(self) -> &'static str {
        match self {
            Self::Reserved0 => "reserved for future use",
            Self::S2X => "S2X",
            Self::S2XTimeSlicing => "S2X + time slicing",
            Self::Reserved3 => "reserved for future use",
            Self::S2XSuperframe => "S2X superframe",
            Self::S2XSuperframeTimeSlicing => "S2X superframe + timeslicing",
            Self::Reserved(_) => "reserved",
        }
    }

    /// True for modes where `scrambling_sequence_selector` / scrambling index apply
    /// (Table 144b: modes 1 and 2).
    #[must_use]
    pub fn has_scrambling_selector(self) -> bool {
        matches!(self, Self::S2X | Self::S2XTimeSlicing)
    }

    /// True for modes where `timeslice_number` is present
    /// (Table 144b: modes 2 and 5).
    #[must_use]
    pub fn has_timeslice(self) -> bool {
        matches!(self, Self::S2XTimeSlicing | Self::S2XSuperframeTimeSlicing)
    }

    /// True for modes where the superframe block is present
    /// (Table 144b: modes 4 and 5).
    #[must_use]
    pub fn has_superframe(self) -> bool {
        matches!(self, Self::S2XSuperframe | Self::S2XSuperframeTimeSlicing)
    }
}
broadcast_common::impl_spec_display!(S2Xv2Mode, Reserved);

/// Superframe block present in S2Xv2_mode 4 and 5 (Table 144b §6.4.6.5.3).
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[non_exhaustive]
pub struct S2Xv2Superframe {
    /// `SOSF_WH_sequence_number` (8 bits).
    pub sosf_wh_sequence_number: u8,
    /// `SFFI_selector` (1 bit) — gates `sffi`.
    pub sffi_selector: bool,
    /// `beam_hopping_time_plan_selector` (1 bit) — gates `beamhopping_time_plan_id`.
    pub beam_hopping_time_plan_selector: bool,
    /// `reserved_zero_future_use(2)` after the two selectors (2 bits,
    /// right-aligned). Captured on parse, re-emitted verbatim; `Default` is
    /// [`S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT`] (`0`).
    pub reserved_zero_future_use_2: u8,
    /// `reference_scrambling_index` (20 bits).
    pub reference_scrambling_index: u32,
    /// `SFFI` (4 bits), present iff `sffi_selector == 1`; stored as raw nibble.
    pub sffi: Option<u8>,
    /// `reserved_zero_future_use(4)` taking the `SFFI` nibble's place when
    /// `sffi_selector == 0` (4 bits); ignored on serialize when `sffi` is
    /// present. Same policy as above.
    pub reserved_zero_future_use_4: u8,
    /// `payload_scrambling_index` (20 bits).
    pub payload_scrambling_index: u32,
    /// `beamhopping_time_plan_id` (32 bits), present iff
    /// `beam_hopping_time_plan_selector == 1`.
    pub beamhopping_time_plan_id: Option<u32>,
    /// `superframe_pilots_WH_sequence_number` (5 bits) — `[7:3]` of the final byte.
    pub superframe_pilots_wh_sequence_number: u8,
    /// `postamble_PLI` (3 bits) — `[2:0]` of the final byte.
    pub postamble_pli: u8,
}

impl Default for S2Xv2Superframe {
    /// Zero/`None` field values with the spec-default reserved bits.
    fn default() -> Self {
        Self {
            sosf_wh_sequence_number: 0,
            sffi_selector: false,
            beam_hopping_time_plan_selector: false,
            reserved_zero_future_use_2: S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT,
            reference_scrambling_index: 0,
            sffi: None,
            reserved_zero_future_use_4: S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT,
            payload_scrambling_index: 0,
            beamhopping_time_plan_id: None,
            superframe_pilots_wh_sequence_number: 0,
            postamble_pli: 0,
        }
    }
}

impl S2Xv2Superframe {
    /// Wire length in bytes.
    #[must_use]
    pub fn serialized_len(&self) -> usize {
        if self.beam_hopping_time_plan_selector {
            S2XV2_SUPERFRAME_BH_LEN
        } else {
            S2XV2_SUPERFRAME_MIN_LEN
        }
    }
}

/// S2Xv2_satellite_delivery_system body (Tables 144a–144b, §6.4.6.5.3).
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
#[non_exhaustive]
pub struct S2Xv2SatelliteDeliverySystem<'a> {
    /// `delivery_system_id` (32 bits).
    pub delivery_system_id: u32,
    /// `S2Xv2_mode` (4 bits) — Table 144c.
    pub s2xv2_mode: S2Xv2Mode,
    /// `multiple_input_stream_flag` (1 bit).
    pub multiple_input_stream_flag: bool,
    /// `roll_off` (3 bits) — EN 300 468 Table 144 (same table as S2X).
    pub roll_off: RollOff,
    /// `reserved_zero_future_use(2)` at the top of byte 5 (2 bits,
    /// right-aligned). Captured on parse, re-emitted verbatim; `Default` is
    /// [`S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT`] (`0`).
    pub reserved_zero_future_use_2: u8,
    /// `NCR_reference` (1 bit) — Table 144c1.
    pub ncr_reference: bool,
    /// `NCR_version` (1 bit).
    pub ncr_version: bool,
    /// `channel_bond` (2 bits).
    pub channel_bond: u8,
    /// `polarization` (2 bits).
    pub polarization: Polarization,
    /// `scrambling_sequence_selector` (1 bit), present (and parsed) iff
    /// `s2xv2_mode ∈ {1, 2}`; `None` means the bit was `reserved_zero_future_use`.
    pub scrambling_sequence_selector: Option<bool>,
    /// `reserved_zero_future_use(1)`: the top bit of byte 6 when it is NOT
    /// `scrambling_sequence_selector` (i.e. `scrambling_sequence_selector` is
    /// `None`, `s2xv2_mode` outside `{1, 2}`); ignored on serialize when the
    /// selector is `Some`. Same policy as above.
    pub reserved_zero_future_use_1: u8,
    /// `TS_GS_S2X_mode` (2 bits) — Table 143 (raw value).
    pub ts_gs_s2x_mode: u8,
    /// `receiver_profiles` (5 bits) — raw bitmask (Table 141 semantics apply).
    pub receiver_profiles: u8,
    /// `satellite_id` (24 bits).
    pub satellite_id: u32,
    /// `frequency` (32 bits).
    pub frequency: u32,
    /// `symbol_rate` (32 bits).
    pub symbol_rate: u32,
    /// `input_stream_identifier` (8 bits), present iff `multiple_input_stream_flag`.
    pub input_stream_identifier: Option<u8>,
    /// `reserved_zero_future_use(6)` ahead of `scrambling_sequence_index`
    /// (6 bits); on the wire only together with the index. Same policy as above.
    pub reserved_zero_future_use_6: u8,
    /// `scrambling_sequence_index` (18 bits), present iff
    /// `s2xv2_mode ∈ {1, 2}` **and** `scrambling_sequence_selector == 1`.
    pub scrambling_sequence_index: Option<u32>,
    /// `timeslice_number` (8 bits), present iff `s2xv2_mode ∈ {2, 5}`.
    pub timeslice_number: Option<u8>,
    /// `reserved_zero_future_use(7)` ahead of `num_channel_bonds_minus_one`
    /// (7 bits); on the wire only when `channel_bond == 1`. Same policy as above.
    pub reserved_zero_future_use_7: u8,
    /// Secondary delivery system IDs from the `channel_bond` loop (one per
    /// entry, 32 bits each), present iff `channel_bond == 1`.
    pub secondary_delivery_system_ids: Vec<u32>,
    /// Superframe block, present iff `s2xv2_mode ∈ {4, 5}`.
    pub superframe: Option<S2Xv2Superframe>,
    /// Trailing `reserved_zero_future_use` bytes (verbatim from the closing `for` loop).
    #[cfg_attr(feature = "serde", serde(borrow))]
    pub reserved_tail: &'a [u8],
}

impl Default for S2Xv2SatelliteDeliverySystem<'_> {
    /// Zero/first-variant field values with the spec-default reserved bits.
    fn default() -> Self {
        Self {
            delivery_system_id: 0,
            s2xv2_mode: S2Xv2Mode::from_u8(0),
            multiple_input_stream_flag: false,
            roll_off: RollOff::from_u8(0),
            reserved_zero_future_use_2: S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT,
            ncr_reference: false,
            ncr_version: false,
            channel_bond: 0,
            polarization: Polarization::from_u8(0),
            scrambling_sequence_selector: None,
            reserved_zero_future_use_1: S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT,
            ts_gs_s2x_mode: 0,
            receiver_profiles: 0,
            satellite_id: 0,
            frequency: 0,
            symbol_rate: 0,
            input_stream_identifier: None,
            reserved_zero_future_use_6: S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT,
            scrambling_sequence_index: None,
            timeslice_number: None,
            reserved_zero_future_use_7: S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT,
            secondary_delivery_system_ids: Vec::new(),
            superframe: None,
            reserved_tail: &[],
        }
    }
}

impl<'a> Parse<'a> for S2Xv2SatelliteDeliverySystem<'a> {
    type Error = crate::error::Error;
    fn parse(sel: &'a [u8]) -> Result<Self> {
        need_in(sel, S2XV2_CORE_LEN, "S2Xv2 body")?;
        // Bytes 0–3: delivery_system_id.
        let (dsid_bytes, _) = sel.split_first_chunk::<4>().ok_or(Error::BufferTooShort(
            broadcast_common::error::BufferTooShort {
                need: S2XV2_CORE_LEN,
                have: sel.len(),
                what: "S2Xv2 body",
            },
        ))?;
        let delivery_system_id = u32::from_be_bytes(*dsid_bytes);
        // Byte 4: S2Xv2_mode(4) | multiple_input_stream_flag(1) | roll_off(3).
        let b4 = sel[4];
        let s2xv2_mode = S2Xv2Mode::from_u8(b4 >> 4);
        let multiple_input_stream_flag = (b4 & 0x08) != 0;
        let roll_off = RollOff::from_u8(b4 & 0x07);
        // Byte 5: reserved(2) | NCR_reference(1) | NCR_version(1) | channel_bond(2) | polarization(2).
        let b5 = sel[5];
        let reserved_zero_future_use_2 = b5 >> 6;
        let ncr_reference = (b5 & 0x20) != 0;
        let ncr_version = (b5 & 0x10) != 0;
        let channel_bond = (b5 >> 2) & 0x03;
        let polarization = Polarization::from_u8(b5 & 0x03);
        // Byte 6: scrambling_or_reserved(1) | TS_GS_S2X_mode(2) | receiver_profiles(5).
        let b6 = sel[6];
        let raw_scrambling_bit = (b6 >> 7) & 0x01;
        let ts_gs_s2x_mode = (b6 >> 5) & 0x03;
        let receiver_profiles = b6 & 0x1F;
        let scrambling_sequence_selector = if s2xv2_mode.has_scrambling_selector() {
            Some(raw_scrambling_bit != 0)
        } else {
            None
        };
        // The top bit of byte 6 is `reserved_zero_future_use` unless the mode
        // gives it the selector meaning.
        let reserved_zero_future_use_1 = if scrambling_sequence_selector.is_none() {
            raw_scrambling_bit
        } else {
            S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT
        };
        // Bytes 7–9: satellite_id (24 bits, big-endian).
        let satellite_id = (u32::from(sel[7]) << 16) | (u32::from(sel[8]) << 8) | u32::from(sel[9]);
        // Bytes 10–13: frequency (32 bits).
        let (freq_bytes, _) = sel[10..]
            .split_first_chunk::<4>()
            .ok_or(Error::BufferTooShort(
                broadcast_common::error::BufferTooShort {
                    need: S2XV2_CORE_LEN,
                    have: sel.len(),
                    what: "S2Xv2 body",
                },
            ))?;
        let frequency = u32::from_be_bytes(*freq_bytes);
        // Bytes 14–17: symbol_rate (32 bits).
        let (sr_bytes, _) = sel[14..]
            .split_first_chunk::<4>()
            .ok_or(Error::BufferTooShort(
                broadcast_common::error::BufferTooShort {
                    need: S2XV2_CORE_LEN,
                    have: sel.len(),
                    what: "S2Xv2 body",
                },
            ))?;
        let symbol_rate = u32::from_be_bytes(*sr_bytes);
        let mut pos = S2XV2_CORE_LEN;

        // Conditional: input_stream_identifier.
        let input_stream_identifier = if multiple_input_stream_flag {
            need_in(sel, pos + 1, "S2Xv2 body (input_stream_identifier)")?;
            let isi = sel[pos];
            pos += 1;
            Some(isi)
        } else {
            None
        };

        // Conditional: scrambling_sequence_index (mode 1 or 2, selector == 1).
        let mut reserved_zero_future_use_6 = S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT;
        let scrambling_sequence_index = if scrambling_sequence_selector == Some(true) {
            need_in(
                sel,
                pos + S2XV2_SCRAMBLING_LEN,
                "S2Xv2 body (scrambling_sequence_index)",
            )?;
            // reserved(6) | scrambling_sequence_index(18).
            reserved_zero_future_use_6 = sel[pos] >> 2;
            let idx = (u32::from(sel[pos] & 0x03) << 16)
                | (u32::from(sel[pos + 1]) << 8)
                | u32::from(sel[pos + 2]);
            pos += S2XV2_SCRAMBLING_LEN;
            Some(idx)
        } else {
            None
        };

        // Conditional: timeslice_number (mode 2 or 5).
        let timeslice_number = if s2xv2_mode.has_timeslice() {
            need_in(sel, pos + 1, "S2Xv2 body (timeslice_number)")?;
            let ts = sel[pos];
            pos += 1;
            Some(ts)
        } else {
            None
        };

        // Conditional: channel_bond loop.
        let mut reserved_zero_future_use_7 = S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT;
        let secondary_delivery_system_ids = if channel_bond == 1 {
            need_in(sel, pos + 1, "S2Xv2 body (channel_bond header)")?;
            let bond_byte = sel[pos];
            pos += 1;
            // reserved(7) | num_channel_bonds_minus_one(1).
            reserved_zero_future_use_7 = bond_byte >> 1;
            let n = (bond_byte & 0x01) as usize + 1;
            let mut ids = Vec::with_capacity(n);
            for _ in 0..n {
                need_in(sel, pos + 4, "S2Xv2 body (secondary_delivery_system_id)")?;
                let (id_bytes, _) = sel
                    .get(pos..)
                    .and_then(|s| s.split_first_chunk::<4>())
                    .ok_or(Error::BufferTooShort(
                        broadcast_common::error::BufferTooShort {
                            need: pos + 4,
                            have: sel.len(),
                            what: "S2Xv2 body (secondary_delivery_system_id)",
                        },
                    ))?;
                let id = u32::from_be_bytes(*id_bytes);
                ids.push(id);
                pos += 4;
            }
            ids
        } else {
            Vec::new()
        };

        // Conditional: superframe block (mode 4 or 5).
        let superframe = if s2xv2_mode.has_superframe() {
            need_in(
                sel,
                pos + S2XV2_SUPERFRAME_MIN_LEN,
                "S2Xv2 body (superframe)",
            )?;
            let sosf_wh_sequence_number = sel[pos];
            // pos+1: SFFI_selector(1) | BH_selector(1) | reserved(2) | ref_scram_hi(4).
            let b1 = sel[pos + 1];
            let sffi_selector = (b1 & 0x80) != 0;
            let beam_hopping_time_plan_selector = (b1 & 0x40) != 0;
            let sf_reserved_zero_future_use_2 = (b1 >> 4) & RZFU_2_MASK;
            let ref_scram_hi = u32::from(b1 & 0x0F);
            let reference_scrambling_index =
                (ref_scram_hi << 16) | (u32::from(sel[pos + 2]) << 8) | u32::from(sel[pos + 3]);
            // pos+4: SFFI_or_reserved(4) | psi_hi(4).
            let b4s = sel[pos + 4];
            let sffi = if sffi_selector { Some(b4s >> 4) } else { None };
            let sf_reserved_zero_future_use_4 = if sffi_selector {
                S2XV2_RESERVED_ZERO_FUTURE_USE_DEFAULT
            } else {
                b4s >> 4
            };
            let psi_hi = u32::from(b4s & 0x0F);
            let payload_scrambling_index =
                (psi_hi << 16) | (u32::from(sel[pos + 5]) << 8) | u32::from(sel[pos + 6]);
            pos += 7;
            // Conditional: beamhopping_time_plan_id.
            let beamhopping_time_plan_id = if beam_hopping_time_plan_selector {
                need_in(sel, pos + 4, "S2Xv2 body (beamhopping_time_plan_id)")?;
                let (bh_bytes, _) = sel
                    .get(pos..)
                    .and_then(|s| s.split_first_chunk::<4>())
                    .ok_or(Error::BufferTooShort(
                        broadcast_common::error::BufferTooShort {
                            need: pos + 4,
                            have: sel.len(),
                            what: "S2Xv2 body (beamhopping_time_plan_id)",
                        },
                    ))?;
                let id = u32::from_be_bytes(*bh_bytes);
                pos += 4;
                Some(id)
            } else {
                None
            };
            // Final superframe byte: pilots(5) | postamble_PLI(3).
            need_in(sel, pos + 1, "S2Xv2 body (superframe final byte)")?;
            let last = sel[pos];
            let superframe_pilots_wh_sequence_number = (last >> 3) & 0x1F;
            let postamble_pli = last & 0x07;
            pos += 1;
            Some(S2Xv2Superframe {
                sosf_wh_sequence_number,
                sffi_selector,
                beam_hopping_time_plan_selector,
                reserved_zero_future_use_2: sf_reserved_zero_future_use_2,
                reference_scrambling_index,
                sffi,
                reserved_zero_future_use_4: sf_reserved_zero_future_use_4,
                payload_scrambling_index,
                beamhopping_time_plan_id,
                superframe_pilots_wh_sequence_number,
                postamble_pli,
            })
        } else {
            None
        };

        Ok(S2Xv2SatelliteDeliverySystem {
            delivery_system_id,
            s2xv2_mode,
            multiple_input_stream_flag,
            roll_off,
            reserved_zero_future_use_2,
            ncr_reference,
            ncr_version,
            channel_bond,
            polarization,
            scrambling_sequence_selector,
            reserved_zero_future_use_1,
            ts_gs_s2x_mode,
            receiver_profiles,
            satellite_id,
            frequency,
            symbol_rate,
            input_stream_identifier,
            reserved_zero_future_use_6,
            scrambling_sequence_index,
            timeslice_number,
            reserved_zero_future_use_7,
            secondary_delivery_system_ids,
            superframe,
            reserved_tail: &sel[pos..],
        })
    }
}

impl Serialize for S2Xv2SatelliteDeliverySystem<'_> {
    type Error = crate::error::Error;
    fn serialized_len(&self) -> usize {
        S2XV2_CORE_LEN
            + usize::from(self.input_stream_identifier.is_some())
            + if self.scrambling_sequence_selector == Some(true) {
                S2XV2_SCRAMBLING_LEN
            } else {
                0
            }
            + usize::from(self.timeslice_number.is_some())
            + if self.channel_bond == 1 {
                1 + self.secondary_delivery_system_ids.len() * 4
            } else {
                0
            }
            + self.superframe.as_ref().map_or(0, |sf| sf.serialized_len())
            + self.reserved_tail.len()
    }

    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        let len = self.serialized_len();
        need_out(buf, len)?;
        // Bytes 0–3: delivery_system_id.
        buf[0..4].copy_from_slice(&self.delivery_system_id.to_be_bytes());
        // Byte 4: S2Xv2_mode(4) | multiple_input_stream_flag(1) | roll_off(3).
        buf[4] = (broadcast_common::len::fit_mask(self.s2xv2_mode.to_u8(), 0x0F, "s2xv2_mode")?
            << 4)
            | (u8::from(self.multiple_input_stream_flag) << 3)
            | broadcast_common::len::fit_mask(self.roll_off.to_u8(), 0x07, "roll_off")?;
        // Byte 5: reserved(2) | NCR_reference(1) | NCR_version(1) | channel_bond(2) | polarization(2).
        buf[5] = (broadcast_common::len::fit_mask(
            self.reserved_zero_future_use_2,
            RZFU_2_MASK,
            "reserved_zero_future_use_2",
        )? << 6)
            | (u8::from(self.ncr_reference) << 5)
            | (u8::from(self.ncr_version) << 4)
            | (broadcast_common::len::fit_mask(self.channel_bond, 0x03, "channel_bond")? << 2)
            | broadcast_common::len::fit_mask(self.polarization.to_u8(), 0x03, "polarization")?;
        // Byte 6: scrambling_or_reserved(1) | TS_GS_S2X_mode(2) | receiver_profiles(5).
        let scram_bit: u8 = match self.scrambling_sequence_selector {
            Some(true) => 1,
            Some(false) => 0,
            // The bit is reserved_zero_future_use for this mode.
            None => broadcast_common::len::fit_mask(
                self.reserved_zero_future_use_1,
                1,
                "reserved_zero_future_use_1",
            )?,
        };
        buf[6] = (scram_bit << 7)
            | (broadcast_common::len::fit_mask(self.ts_gs_s2x_mode, 0x03, "ts_gs_s2x_mode")? << 5)
            | broadcast_common::len::fit_mask(self.receiver_profiles, 0x1F, "receiver_profiles")?;
        // Bytes 7–9: satellite_id (24 bits): reject, never drop the top byte.
        broadcast_common::len::fit_bits(u64::from(self.satellite_id), 24, "satellite_id")?;
        buf[7] = (self.satellite_id >> 16) as u8;
        buf[8] = (self.satellite_id >> 8) as u8;
        buf[9] = self.satellite_id as u8;
        // Bytes 10–13: frequency.
        buf[10..14].copy_from_slice(&self.frequency.to_be_bytes());
        // Bytes 14–17: symbol_rate.
        buf[14..18].copy_from_slice(&self.symbol_rate.to_be_bytes());
        let mut p = S2XV2_CORE_LEN;
        // Conditional: input_stream_identifier.
        if let Some(isi) = self.input_stream_identifier {
            buf[p] = isi;
            p += 1;
        }
        // Conditional: scrambling block.
        if self.scrambling_sequence_selector == Some(true) {
            let idx = self
                .scrambling_sequence_index
                .ok_or(Error::ValueOutOfRange {
                    field: "scrambling_sequence_index",
                    reason: "required when scrambling_sequence_selector is set",
                })?;
            let idx =
                broadcast_common::len::fit_mask(idx, 0x0003_FFFF, "scrambling_sequence_index")?;
            buf[p] = (broadcast_common::len::fit_mask(
                self.reserved_zero_future_use_6,
                RZFU_6_MASK,
                "reserved_zero_future_use_6",
            )? << 2)
                | ((idx >> 16) as u8 & 0x03);
            buf[p + 1] = (idx >> 8) as u8;
            buf[p + 2] = idx as u8;
            p += S2XV2_SCRAMBLING_LEN;
        }
        // Conditional: timeslice_number.
        if let Some(ts) = self.timeslice_number {
            buf[p] = ts;
            p += 1;
        }
        // Conditional: channel bond loop.
        if self.channel_bond == 1 {
            // reserved(7) | num_channel_bonds_minus_one(1). Wraps to u64::MAX for a
            // zero-length list, which `fit_bits` rejects rather than masking to 0.
            let minus_one = (self.secondary_delivery_system_ids.len() as u64).wrapping_sub(1);
            let n =
                broadcast_common::len::fit_bits(minus_one, 1, "num_channel_bonds_minus_one")? as u8;
            buf[p] = (broadcast_common::len::fit_mask(
                self.reserved_zero_future_use_7,
                RZFU_7_MASK,
                "reserved_zero_future_use_7",
            )? << 1)
                | n;
            p += 1;
            for &id in &self.secondary_delivery_system_ids {
                buf[p..p + 4].copy_from_slice(&id.to_be_bytes());
                p += 4;
            }
        }
        // Conditional: superframe block.
        if let Some(sf) = &self.superframe {
            // 20-bit scrambling indices: wider values used to be masked down
            // silently (audit r03-W3 class).
            broadcast_common::len::fit_bits(
                u64::from(sf.reference_scrambling_index),
                20,
                "reference_scrambling_index",
            )?;
            broadcast_common::len::fit_bits(
                u64::from(sf.payload_scrambling_index),
                20,
                "payload_scrambling_index",
            )?;
            buf[p] = sf.sosf_wh_sequence_number;
            let ref_hi = (sf.reference_scrambling_index >> 16) as u8 & 0x0F;
            buf[p + 1] = (u8::from(sf.sffi_selector) << 7)
                | (u8::from(sf.beam_hopping_time_plan_selector) << 6)
                | (broadcast_common::len::fit_mask(
                    sf.reserved_zero_future_use_2,
                    RZFU_2_MASK,
                    "reserved_zero_future_use_2",
                )? << 4)
                | ref_hi;
            buf[p + 2] = (sf.reference_scrambling_index >> 8) as u8;
            buf[p + 3] = sf.reference_scrambling_index as u8;
            // sffi_selector promises the 4 SFFI bits on the wire; fabricating
            // 0 would invent a bypass index (r03-W5).
            let sffi_nibble: u8 = if sf.sffi_selector {
                sf.sffi.ok_or(Error::ValueOutOfRange {
                    field: "sffi",
                    reason: "required when sffi_selector is set",
                })?
            } else {
                // The nibble is reserved_zero_future_use when SFFI is absent.
                sf.reserved_zero_future_use_4
            };
            let sffi_nibble = broadcast_common::len::fit_mask(sffi_nibble, 0x0F, "sffi")?;
            let psi_hi = (sf.payload_scrambling_index >> 16) as u8 & 0x0F;
            buf[p + 4] = (sffi_nibble << 4) | psi_hi;
            buf[p + 5] = (sf.payload_scrambling_index >> 8) as u8;
            buf[p + 6] = sf.payload_scrambling_index as u8;
            p += 7;
            if sf.beam_hopping_time_plan_selector {
                // The selector reserved 4 bytes in serialized_len; the Option
                // must agree or the tail byte lands in the wrong place
                // (r03-W5).
                let bh_id = sf.beamhopping_time_plan_id.ok_or(Error::ValueOutOfRange {
                    field: "beamhopping_time_plan_id",
                    reason: "required when beam_hopping_time_plan_selector is set",
                })?;
                buf[p..p + 4].copy_from_slice(&bh_id.to_be_bytes());
                p += 4;
            }
            buf[p] = (broadcast_common::len::fit_mask(
                sf.superframe_pilots_wh_sequence_number,
                0x1F,
                "superframe_pilots_wh_sequence_number",
            )? << 3)
                | broadcast_common::len::fit_mask(sf.postamble_pli, 0x07, "postamble_pli")?;
            p += 1;
        }
        // Reserved tail.
        buf[p..p + self.reserved_tail.len()].copy_from_slice(self.reserved_tail);
        Ok(len)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::descriptors::extension::test_support::*;
    use crate::descriptors::extension::{ExtensionBody, ExtensionDescriptor, ExtensionTag};

    /// Build a minimal valid 18-byte selector for S2Xv2 mode 1 (no optional fields).
    fn minimal_mode1_sel() -> Vec<u8> {
        let mut sel = Vec::new();
        // delivery_system_id = 0x0102_0304
        sel.extend_from_slice(&0x0102_0304u32.to_be_bytes());
        // b4: S2Xv2_mode=1(0x10), mis=0, roll_off=2(0x02) → 0x12
        sel.push(0x12);
        // b5: reserved(2)=0, NCR_reference=1(0x20), NCR_version=0,
        //     channel_bond=0, polarization=1(LinearVertical) → 0x21
        sel.push(0x21);
        // b6: scram_sel=0(mode 1 → uses actual bit), ts_gs=3(0x60), recv_prof=0x07 → 0x67
        sel.push(0x67);
        // satellite_id = 0x010203
        sel.extend_from_slice(&[0x01, 0x02, 0x03]);
        // frequency = 0x1234_5678
        sel.extend_from_slice(&0x1234_5678u32.to_be_bytes());
        // symbol_rate = 0xABCD_EF01
        sel.extend_from_slice(&0xABCD_EF01u32.to_be_bytes());
        sel
    }

    /// #1129: `satellite_id` is 24 bits; a wider value must error rather than
    /// silently drop its top byte.
    #[test]
    fn satellite_id_over_24_bits_is_rejected() {
        let bytes = wrap(0x24, &minimal_mode1_sel());
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        let ExtensionBody::S2Xv2SatelliteDeliverySystem(b) = &d.body else {
            panic!("expected S2Xv2");
        };
        let mut b = b.clone();
        b.satellite_id = 0x0100_0000;
        let mut buf = vec![0u8; b.serialized_len()];
        assert!(matches!(
            b.serialize_into(&mut buf),
            Err(Error::FieldOverflow(_))
        ));
        b.satellite_id = 0x00FF_FFFF;
        assert!(b.serialize_into(&mut buf).is_ok());
    }

    #[test]
    fn parse_s2xv2_mode1_no_scrambling_round_trip() {
        // S2Xv2 mode 1, no scrambling, no MIS, no tail.
        let sel = minimal_mode1_sel();
        let bytes = wrap(0x24, &sel);
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        assert_eq!(d.kind(), Some(ExtensionTag::S2Xv2SatelliteDeliverySystem));
        match &d.body {
            ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                assert_eq!(b.delivery_system_id, 0x0102_0304);
                assert_eq!(b.s2xv2_mode, S2Xv2Mode::S2X);
                assert!(!b.multiple_input_stream_flag);
                assert_eq!(b.roll_off, RollOff::Alpha020);
                assert!(b.ncr_reference);
                assert!(!b.ncr_version);
                assert_eq!(b.channel_bond, 0);
                assert_eq!(b.polarization, Polarization::LinearVertical);
                assert_eq!(b.scrambling_sequence_selector, Some(false));
                assert_eq!(b.ts_gs_s2x_mode, 3);
                assert_eq!(b.receiver_profiles, 0x07);
                assert_eq!(b.satellite_id, 0x010203);
                assert_eq!(b.frequency, 0x1234_5678);
                assert_eq!(b.symbol_rate, 0xABCD_EF01);
                assert!(b.input_stream_identifier.is_none());
                assert!(b.scrambling_sequence_index.is_none());
                assert!(b.timeslice_number.is_none());
                assert!(b.secondary_delivery_system_ids.is_empty());
                assert!(b.superframe.is_none());
                assert!(b.reserved_tail.is_empty());
            }
            other => panic!("expected S2Xv2, got {other:?}"),
        }
        round_trip(&d);
    }

    #[test]
    fn parse_s2xv2_mode1_scrambling_and_mis_round_trip() {
        // S2Xv2 mode 1, scrambling_selector=1, MIS=1, ISI=0x42,
        // scrambling_sequence_index=0x1ABCD.
        let mut sel = Vec::new();
        sel.extend_from_slice(&0xDEAD_BEEFu32.to_be_bytes()); // delivery_system_id
        // b4: mode=1(0x10), mis=1(0x08), roll_off=1(0x01) → 0x19
        sel.push(0x19);
        // b5: NCR_reference=0, NCR_version=1(0x10), channel_bond=0, polarization=3 → 0x13
        sel.push(0x13);
        // b6: scram_sel=1(0x80), ts_gs=0, recv_prof=0x1F → 0x9F
        sel.push(0x9F);
        sel.extend_from_slice(&[0xAA, 0xBB, 0xCC]); // satellite_id
        sel.extend_from_slice(&0x0000_0001u32.to_be_bytes()); // frequency
        sel.extend_from_slice(&0x0000_0002u32.to_be_bytes()); // symbol_rate
        sel.push(0x42); // input_stream_identifier (MIS=1)
        // scrambling block: reserved(6)=0 | scrambling_sequence_index(18) = 0x1ABCD
        // 0x1ABCD >> 16 = 0x01 (& 0x03), mid = 0xAB, lo = 0xCD
        sel.extend_from_slice(&[0x01, 0xAB, 0xCD]);
        let bytes = wrap(0x24, &sel);
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        match &d.body {
            ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                assert_eq!(b.delivery_system_id, 0xDEAD_BEEF);
                assert_eq!(b.s2xv2_mode, S2Xv2Mode::S2X);
                assert!(b.multiple_input_stream_flag);
                // b4 = 0x19: mode=1, mis=1, roll_off=1 → Alpha025
                assert_eq!(b.roll_off, RollOff::Alpha025);
                assert!(!b.ncr_reference);
                assert!(b.ncr_version);
                assert_eq!(b.channel_bond, 0);
                assert_eq!(b.polarization, Polarization::CircularRight);
                assert_eq!(b.scrambling_sequence_selector, Some(true));
                assert_eq!(b.ts_gs_s2x_mode, 0);
                assert_eq!(b.receiver_profiles, 0x1F);
                assert_eq!(b.input_stream_identifier, Some(0x42));
                assert_eq!(b.scrambling_sequence_index, Some(0x1ABCD));
                assert!(b.timeslice_number.is_none());
                assert!(b.secondary_delivery_system_ids.is_empty());
                assert!(b.superframe.is_none());
            }
            other => panic!("expected S2Xv2, got {other:?}"),
        }
        round_trip(&d);
    }

    #[test]
    fn parse_s2xv2_mode2_timeslice_round_trip() {
        // S2Xv2 mode 2 (S2X + timeslicing): timeslice_number present, no MIS.
        let mut sel = Vec::new();
        sel.extend_from_slice(&0x0000_0001u32.to_be_bytes());
        // b4: mode=2(0x20), mis=0, roll_off=0 → 0x20
        sel.push(0x20);
        sel.push(0x00); // b5
        // b6: scram_sel=0, ts_gs=0, recv_prof=1 → 0x01
        sel.push(0x01);
        sel.extend_from_slice(&[0, 0, 0]); // satellite_id
        sel.extend_from_slice(&[0, 0, 0, 0]); // frequency
        sel.extend_from_slice(&[0, 0, 0, 0]); // symbol_rate
        sel.push(0x07); // timeslice_number (mode 2 → has_timeslice)
        let bytes = wrap(0x24, &sel);
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        match &d.body {
            ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                assert_eq!(b.s2xv2_mode, S2Xv2Mode::S2XTimeSlicing);
                assert_eq!(b.timeslice_number, Some(0x07));
                assert!(b.scrambling_sequence_index.is_none());
                assert!(b.secondary_delivery_system_ids.is_empty());
                assert!(b.superframe.is_none());
            }
            other => panic!("expected S2Xv2, got {other:?}"),
        }
        round_trip(&d);
    }

    #[test]
    fn parse_s2xv2_channel_bond_round_trip() {
        // S2Xv2 mode 0 (reserved), channel_bond=1, two secondary IDs.
        let mut sel = Vec::new();
        sel.extend_from_slice(&0xFFFF_FFFFu32.to_be_bytes()); // delivery_system_id
        // b4: mode=0, mis=0, roll_off=0 → 0x00
        sel.push(0x00);
        // b5: channel_bond=1(0x04), polarization=0 → 0x04
        sel.push(0x04);
        // b6: all zero
        sel.push(0x00);
        sel.extend_from_slice(&[0, 0, 0]); // satellite_id
        sel.extend_from_slice(&[0, 0, 0, 0]); // frequency
        sel.extend_from_slice(&[0, 0, 0, 0]); // symbol_rate
        // channel_bond header: reserved(7)=0 | num_channel_bonds_minus_one(1)=1 → N=2
        sel.push(0x01);
        sel.extend_from_slice(&0x1111_1111u32.to_be_bytes()); // id[0]
        sel.extend_from_slice(&0x2222_2222u32.to_be_bytes()); // id[1]
        let bytes = wrap(0x24, &sel);
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        match &d.body {
            ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                assert_eq!(b.channel_bond, 1);
                assert_eq!(
                    b.secondary_delivery_system_ids,
                    vec![0x1111_1111, 0x2222_2222]
                );
                assert!(b.superframe.is_none());
            }
            other => panic!("expected S2Xv2, got {other:?}"),
        }
        round_trip(&d);
    }

    #[test]
    fn parse_s2xv2_superframe_no_beamhopping_round_trip() {
        // S2Xv2 mode 4 (superframe), SFFI_selector=1, no beamhopping.
        let mut sel = Vec::new();
        sel.extend_from_slice(&0x0000_0002u32.to_be_bytes()); // delivery_system_id
        // b4: mode=4(0x40), mis=0, roll_off=0 → 0x40
        sel.push(0x40);
        sel.push(0x00); // b5
        // b6: no scrambling_selector (mode 4), ts_gs=1(0x20), recv_prof=3(0x03) → 0x23
        sel.push(0x23);
        sel.extend_from_slice(&[0, 0, 0]); // satellite_id
        sel.extend_from_slice(&[0, 0, 0, 0]); // frequency
        sel.extend_from_slice(&[0, 0, 0, 0]); // symbol_rate
        // Superframe block:
        sel.push(0xAB); // sosf_wh_sequence_number
        // b1: SFFI_selector=1(0x80), BH=0, reserved=0, ref_scram_hi=0x05 → 0x85
        sel.push(0x85);
        sel.push(0x12); // ref_scram_mid
        sel.push(0x34); // ref_scram_lo → ref_scram = 0x051234
        // b4: SFFI=0x9(0x90), psi_hi=0x06(0x06) → 0x96
        sel.push(0x96);
        sel.push(0x78); // psi_mid
        sel.push(0x90); // psi_lo → psi = 0x067890
        // no beamhopping_time_plan_id
        // final: pilots=0x1A(5b)=0b11010, postamble=0x03(3b)=0b011 → 0b11010_011 = 0xD3
        sel.push(0xD3);
        let bytes = wrap(0x24, &sel);
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        match &d.body {
            ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                assert_eq!(b.s2xv2_mode, S2Xv2Mode::S2XSuperframe);
                assert!(b.superframe.is_some());
                let sf = b.superframe.as_ref().unwrap();
                assert_eq!(sf.sosf_wh_sequence_number, 0xAB);
                assert!(sf.sffi_selector);
                assert!(!sf.beam_hopping_time_plan_selector);
                assert_eq!(sf.reference_scrambling_index, 0x05_1234);
                assert_eq!(sf.sffi, Some(0x9));
                assert_eq!(sf.payload_scrambling_index, 0x06_7890);
                assert!(sf.beamhopping_time_plan_id.is_none());
                assert_eq!(sf.superframe_pilots_wh_sequence_number, 0x1A);
                assert_eq!(sf.postamble_pli, 0x03);
            }
            other => panic!("expected S2Xv2, got {other:?}"),
        }
        round_trip(&d);
    }

    #[test]
    fn parse_s2xv2_superframe_with_beamhopping_round_trip() {
        // S2Xv2 mode 5 (superframe + timeslicing), SFFI=0, beam_hopping=1.
        let mut sel = Vec::new();
        sel.extend_from_slice(&0x0000_0003u32.to_be_bytes()); // delivery_system_id
        // b4: mode=5(0x50), mis=0, roll_off=0 → 0x50
        sel.push(0x50);
        sel.push(0x00); // b5
        // b6: mode 5 has no scrambling_selector, so scram bit is reserved→0; ts_gs=0, recv_prof=0
        sel.push(0x00);
        sel.extend_from_slice(&[0, 0, 0]); // satellite_id
        sel.extend_from_slice(&[0, 0, 0, 0]); // frequency
        sel.extend_from_slice(&[0, 0, 0, 0]); // symbol_rate
        // timeslice_number (mode 5 → has_timeslice)
        sel.push(0x0F);
        // Superframe block:
        sel.push(0x01); // sosf_wh_sequence_number
        // b1: SFFI=0, BH=1(0x40), reserved=0, ref_scram_hi=0x0A → 0x4A
        sel.push(0x4A);
        sel.push(0xBC); // ref_scram_mid
        sel.push(0xDE); // ref_scram_lo → ref_scram = 0x0ABCDE
        // b4: sffi_or_reserved(4)=0, psi_hi=0x00 → 0x00
        sel.push(0x00);
        sel.push(0x00); // psi_mid
        sel.push(0xFF); // psi_lo → psi = 0x0000FF
        // beamhopping_time_plan_id = 0x1234_5678
        sel.extend_from_slice(&0x1234_5678u32.to_be_bytes());
        // final: pilots=0x05(5b)=0b00101, postamble=0x07(3b)=0b111 → 0b00101_111 = 0x2F
        sel.push(0x2F);
        let bytes = wrap(0x24, &sel);
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        match &d.body {
            ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                assert_eq!(b.s2xv2_mode, S2Xv2Mode::S2XSuperframeTimeSlicing);
                assert_eq!(b.timeslice_number, Some(0x0F));
                let sf = b.superframe.as_ref().unwrap();
                assert!(!sf.sffi_selector);
                assert!(sf.beam_hopping_time_plan_selector);
                assert_eq!(sf.reference_scrambling_index, 0x0A_BCDE);
                assert!(sf.sffi.is_none());
                assert_eq!(sf.payload_scrambling_index, 0x0000FF);
                assert_eq!(sf.beamhopping_time_plan_id, Some(0x1234_5678));
                assert_eq!(sf.superframe_pilots_wh_sequence_number, 0x05);
                assert_eq!(sf.postamble_pli, 0x07);
            }
            other => panic!("expected S2Xv2, got {other:?}"),
        }
        round_trip(&d);
    }

    #[test]
    fn parse_s2xv2_reserved_tail_preserved() {
        // Mode 0 (reserved): no conditionals fire, tail preserved verbatim.
        let mut sel = Vec::new();
        sel.extend_from_slice(&0x0000_0000u32.to_be_bytes());
        // b4: mode=0, mis=0, roll_off=2 → 0x02
        sel.push(0x02);
        sel.push(0x00); // b5
        sel.push(0x00); // b6
        sel.extend_from_slice(&[0, 0, 0]);
        sel.extend_from_slice(&[0, 0, 0, 0]);
        sel.extend_from_slice(&[0, 0, 0, 0]);
        sel.extend_from_slice(&[0xDE, 0xAD, 0xBE, 0xEF]); // reserved_tail
        let bytes = wrap(0x24, &sel);
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        match &d.body {
            ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                assert_eq!(b.s2xv2_mode, S2Xv2Mode::Reserved0);
                assert_eq!(b.reserved_tail, &[0xDE, 0xAD, 0xBE, 0xEF]);
            }
            other => panic!("expected S2Xv2, got {other:?}"),
        }
        round_trip(&d);
    }

    #[test]
    fn parse_s2xv2_rejects_truncated() {
        // Only 10 bytes — less than S2XV2_CORE_LEN (18).
        let sel = vec![0u8; 10];
        let bytes = wrap(0x24, &sel);
        assert!(matches!(
            ExtensionDescriptor::parse(&bytes).unwrap_err(),
            crate::error::Error::BufferTooShort(..)
        ));
    }

    #[test]
    fn s2xv2_mode_roundtrip_all_values() {
        for b in 0..=0x0Fu8 {
            assert_eq!(S2Xv2Mode::from_u8(b).to_u8(), b);
        }
    }

    #[cfg(feature = "serde")]
    #[test]
    fn serde_serialize_s2xv2() {
        let sel = minimal_mode1_sel();
        let bytes = wrap(0x24, &sel);
        let d = ExtensionDescriptor::parse(&bytes).unwrap();
        let json = serde_json::to_string(&d).unwrap();
        // tag_extension = 0x24 = 36
        assert!(json.contains("\"tag_extension\":36"));
        assert!(json.contains("\"s2Xv2SatelliteDeliverySystem\""));
    }
    #[test]
    fn serialize_rejects_beamhopping_id_missing_when_selector_set() {
        // r03-W5: the selector reserved 4 bytes in serialized_len, but the
        // writer keyed on the Option, so `Some(selector) + None(id)` panicked
        // (or misframed) instead of erroring.
        let superframe = S2Xv2Superframe {
            beam_hopping_time_plan_selector: true,
            ..Default::default()
        };
        let d = S2Xv2SatelliteDeliverySystem {
            delivery_system_id: 1,
            s2xv2_mode: S2Xv2Mode::from_u8(4),
            superframe: Some(superframe),
            ..Default::default()
        };
        let mut buf = vec![0u8; d.serialized_len()];
        assert!(matches!(
            d.serialize_into(&mut buf).unwrap_err(),
            Error::ValueOutOfRange {
                field: "beamhopping_time_plan_id",
                ..
            }
        ));
    }

    /// Every reserved_zero_future_use region of the S2Xv2 body re-serializes
    /// byte-identically: byte-5 rzfu(2), byte-6 top bit (rzfu when the mode has
    /// no selector), scrambling rzfu(6), bond-count rzfu(7), superframe
    /// rzfu(2) and rzfu(4) (when SFFI is absent).
    #[test]
    fn reserved_preserved() {
        // mode 4 (superframe, no scrambling selector), channel_bond=1.
        for (r2, r1, r7, sf2, sf4) in [
            (0u8, 0u8, 0u8, 0u8, 0u8),
            (3, 1, 0x7F, 3, 0x0F),
            (2, 1, 0x2A, 1, 0x05),
            (1, 0, 0x40, 2, 0x0A),
        ] {
            let mut sel = Vec::new();
            sel.extend_from_slice(&0x0000_0002u32.to_be_bytes());
            sel.push(0x40); // mode 4
            sel.push((r2 << 6) | 0x04); // rzfu(2) | channel_bond=1
            sel.push((r1 << 7) | 0x23); // rzfu(1) (mode 4: no selector) | ts_gs=1 | profiles=3
            sel.extend_from_slice(&[0x01, 0x02, 0x03]);
            sel.extend_from_slice(&0x1234_5678u32.to_be_bytes());
            sel.extend_from_slice(&0x0000_0001u32.to_be_bytes());
            sel.push(r7 << 1); // bond count: rzfu(7) | minus_one=0
            sel.extend_from_slice(&0x1111_1111u32.to_be_bytes());
            // superframe: sffi_selector=0, bh=0
            sel.push(0xAB);
            sel.push((sf2 << 4) | 0x05);
            sel.extend_from_slice(&[0x12, 0x34]);
            sel.push((sf4 << 4) | 0x06);
            sel.extend_from_slice(&[0x78, 0x90]);
            sel.push(0xD3);
            let bytes = wrap(0x24, &sel);
            let d = ExtensionDescriptor::parse(&bytes).unwrap();
            match &d.body {
                ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                    assert_eq!(b.reserved_zero_future_use_2, r2);
                    assert_eq!(b.reserved_zero_future_use_1, r1);
                    assert_eq!(b.reserved_zero_future_use_7, r7);
                    let sf = b.superframe.as_ref().unwrap();
                    assert_eq!(sf.reserved_zero_future_use_2, sf2);
                    assert_eq!(sf.reserved_zero_future_use_4, sf4);
                }
                other => panic!("expected S2Xv2, got {other:?}"),
            }
            let mut buf = vec![0u8; d.serialized_len()];
            d.serialize_into(&mut buf).unwrap();
            assert_eq!(buf, bytes);
        }
        // mode 1 with scrambling selector: rzfu(6) ahead of the index.
        for r6 in [0u8, 0x3F, 0x2A, 0x01] {
            let mut sel = Vec::new();
            sel.extend_from_slice(&0xDEAD_BEEFu32.to_be_bytes());
            sel.push(0x10);
            sel.push(0x01);
            sel.push(0x80 | 0x07); // scrambling selector = 1
            sel.extend_from_slice(&[0xAA, 0xBB, 0xCC]);
            sel.extend_from_slice(&1u32.to_be_bytes());
            sel.extend_from_slice(&2u32.to_be_bytes());
            sel.extend_from_slice(&[(r6 << 2) | 0x01, 0xAB, 0xCD]);
            let bytes = wrap(0x24, &sel);
            let d = ExtensionDescriptor::parse(&bytes).unwrap();
            match &d.body {
                ExtensionBody::S2Xv2SatelliteDeliverySystem(b) => {
                    assert_eq!(b.reserved_zero_future_use_6, r6);
                    assert_eq!(b.reserved_zero_future_use_1, 0);
                }
                other => panic!("expected S2Xv2, got {other:?}"),
            }
            let mut buf = vec![0u8; d.serialized_len()];
            d.serialize_into(&mut buf).unwrap();
            assert_eq!(buf, bytes);
        }
    }

    /// `Default`-constructed values serialize every reserved region as zero.
    #[test]
    fn default_reserved_is_spec_value() {
        let d = S2Xv2SatelliteDeliverySystem {
            s2xv2_mode: S2Xv2Mode::from_u8(4),
            channel_bond: 1,
            secondary_delivery_system_ids: vec![0x1111_1111],
            superframe: Some(S2Xv2Superframe::default()),
            ..Default::default()
        };
        let mut buf = vec![0u8; d.serialized_len()];
        d.serialize_into(&mut buf).unwrap();
        assert_eq!(buf[5] & 0xC0, 0); // byte-5 rzfu(2)
        assert_eq!(buf[6] & 0x80, 0); // byte-6 rzfu(1)
        assert_eq!(buf[18], 0x00); // bond count: rzfu(7)=0 | minus_one=0
        // superframe starts after the 4-byte bond id: [sosf, rzfu/ref, ref, ref, rzfu4/psi, ..]
        assert_eq!(buf[23 + 1] & 0x30, 0);
        assert_eq!(buf[23 + 4] & 0xF0, 0);
    }
}