dvb-ci 0.10.0

//! Generic Service Gateway objects — ETSI TS 101 699 V1.1.1 §6.1.3, Tables 21-31
//! (PDF pp. 32-37). See `docs/ci_plus/input-modules.md`.
//!
//! A Type 'B' input module presents a **ServiceGateway** (Generic Service
//! Gateway) resource for **service-level** access. These calls are inherited by
//! all network-specific gateway resources (e.g. [`super::broadcast_service_gateway`]).
//! The Generic Service Gateway is never instantiated on its own (Table 87 NOTE);
//! its objects are modelled here so the network-specific gateways can route them.
//!
//! A service reference is the `{OriginalNetworkID, ServiceID}` pair (Figure 12).
//!
//! - `ServiceListReq` (`9F 80 00`, Table 22) — A → R: header-only.
//! - `ServiceListAck` (`9F 80 01`, Table 23) — R → A: version + service list.
//! - `ServiceListVersionReq` (`9F 80 02`, Table 24) — A → R: header-only.
//! - `ServiceListVersionAck` (`9F 80 03`, Table 25) — R → A: version number.
//! - `ServiceListChanged` (`9F 80 04`, Table 26) — R → A: new version number.
//! - `ServiceDescReq` (`9F 80 05`, Table 27) — A → R: a service reference.
//! - `ServiceDescAck` (`9F 80 06`, Table 28) — R → A: SDT-modelled service params.
//! - `GetServiceReq` (`9F 80 07`, Table 29) — A → R: a service reference.
//! - `GetServiceAck` (`9F 80 08`, Table 30) — R → A: service availability.

use crate::error::{Error, Result};
use crate::objects;
use crate::reserved::{ReservedOnes, ReservedZero};
use alloc::vec::Vec;
use broadcast_common::{Parse, Serialize};

/// Resource-scoped `apdu_tag`s for the Generic Service Gateway (Tables 22-30).
pub mod tag {
    use crate::tag::ApduTag;
    /// `ServiceListReqTag` = `9F 80 00`.
    pub const SERVICE_LIST_REQ: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x00);
    /// `ServiceListAckTag` = `9F 80 01`.
    pub const SERVICE_LIST_ACK: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x01);
    /// `ServiceListVersionReqTag` = `9F 80 02`.
    pub const SERVICE_LIST_VERSION_REQ: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x02);
    /// `ServiceListVersionAckTag` = `9F 80 03`.
    pub const SERVICE_LIST_VERSION_ACK: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x03);
    /// `ServiceListChangedTag` = `9F 80 04`.
    pub const SERVICE_LIST_CHANGED: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x04);
    /// `ServiceDescReqTag` = `9F 80 05`.
    pub const SERVICE_DESC_REQ: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x05);
    /// `ServiceDescAckTag` = `9F 80 06`.
    pub const SERVICE_DESC_ACK: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x06);
    /// `GetServiceReqTag` = `9F 80 07`.
    pub const GET_SERVICE_REQ: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x07);
    /// `GetServiceAckTag` = `9F 80 08`.
    pub const GET_SERVICE_ACK: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x08);
}

/// A service reference — the `{OriginalNetworkID, ServiceID}` pair (Figure 12).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ServiceReference {
    /// `OriginalNetworkID` (16-bit, allocated within ETR 162).
    pub original_network_id: u16,
    /// `ServiceID` (16-bit, unique within the original network).
    pub service_id: u16,
}

/// `ServiceListReq()` (Table 22) — A → R: header-only.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ServiceListReq {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,
}

/// `ServiceListVersionReq()` (Table 24) — A → R: header-only.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ServiceListVersionReq {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,
}

/// `ServiceListAck()` (Table 23) — R → A: the services the resource can supply.
#[derive(Debug, Clone, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ServiceListAck {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,

    /// `VersionNumber` — increments each time the service list is updated.
    pub version_number: u8,
    /// The service references (`NumberOfServices` of them, may be 0).
    pub services: Vec<ServiceReference>,
}

/// `ServiceListVersionAck()` (Table 25) — R → A: the service-list version.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ServiceListVersionAck {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,

    /// `VersionNumber`.
    pub version_number: u8,
}

/// `ServiceListChanged()` (Table 26) — R → A: the service list changed.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ServiceListChanged {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,

    /// `VersionNumber` — the new version.
    pub version_number: u8,
}

/// `ServiceDescReq()` (Table 27) — A → R: request info on a particular service.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ServiceDescReq {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,

    /// The service reference being queried.
    pub service: ServiceReference,
}

/// `ServiceDescAck()` (Table 28) — R → A: SDT-modelled service parameters and a
/// descriptor loop. The parameters mirror the SDT in ETS 300 468.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ServiceDescAck<'a> {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,

    /// The service reference being described.
    pub service: ServiceReference,
    /// `EIT_schedule_flag` — SDT meaning (ETS 300 468).
    pub eit_schedule_flag: bool,
    /// `EIT_present_following_flag` — SDT meaning.
    pub eit_present_following_flag: bool,
    /// `running_status` — 3-bit SDT running status (the spec prose "6 bit" is a
    /// typo; 3 bits is authoritative — see `docs/ci_plus/input-modules.md`).
    pub running_status: u8,
    /// `free_CA_mode` — SDT meaning.
    pub free_ca_mode: bool,
    /// The SDT descriptor loop (`descriptors_loop_length` bytes), carried verbatim;
    /// walk it with the dvb-si descriptor parsers.
    #[cfg_attr(feature = "serde", serde(borrow, with = "crate::objects::bytes_serde"))]
    pub descriptors: &'a [u8],
    /// The 6-bit `reserved` field (`reserved_future_use`) in front of `EIT_schedule_flag` as received, preserved so the
    /// object re-serializes byte-for-byte; `0b11_1111` when hand-built.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub reserved: ReservedOnes<6>,
}

/// `GetServiceReq()` (Table 29) — A → R: request the resource to provide a
/// service. An absent service reference (zero following bytes) requests a
/// network disconnect.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct GetServiceReq {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,

    /// The requested service reference, or `None` for a network-disconnect request.
    pub service: Option<ServiceReference>,
}

/// `GetServiceAck()` (Table 30) — R → A: availability of a requested service.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct GetServiceAck {
    /// How the `length_field` was coded on the wire: a non-minimal long form
    /// (e.g. `82 00 09`) is preserved so the object re-serializes
    /// byte-for-byte; [`LengthForm::Minimal`](crate::length::LengthForm::Minimal) for a hand-built value.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub length_form: crate::length::LengthForm,

    /// The service reference replied about.
    pub service: ServiceReference,
    /// `ServiceTerminated` — `1`: the service has finished (or a disconnect was
    /// requested); navigation reverts to the host.
    pub service_terminated: bool,
    /// `ServiceNotAvailable` — `1`: the requested service is not available.
    pub service_not_available: bool,
    /// `CAServiceFlag` — `1`: conditional-access restrictions apply.
    pub ca_service_flag: bool,
    /// `ActualService` — the actual service id (MPEG program number) delivered;
    /// `0` = no valid TS (the host should not attempt to decode).
    pub actual_service: u16,
    /// The 5-bit `reserved` field in front of `ServiceTerminated` as received, preserved so the
    /// object re-serializes byte-for-byte; `0` when hand-built.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub reserved: ReservedZero<5>,
}

// --- header-only objects ---

crate::dispatch::declare_empty_apdu!(ServiceListReq, tag::SERVICE_LIST_REQ, "ServiceListReq");
crate::dispatch::declare_empty_apdu!(
    ServiceListVersionReq,
    tag::SERVICE_LIST_VERSION_REQ,
    "ServiceListVersionReq"
);

// --- single version-byte objects ---

macro_rules! version_byte_object {
    ($ty:ty, $tag:expr, $what:literal) => {
        impl<'a> Parse<'a> for $ty {
            type Error = Error;
            fn parse(bytes: &'a [u8]) -> Result<Self> {
                let (length_form, body) = objects::parse_apdu_header(bytes, $tag, $what)?;
                if body.is_empty() {
                    return Err(Error::BufferTooShort {
                        need: 1,
                        have: 0,
                        what: $what,
                    });
                }
                objects::reject_trailing_body(body, 1, $what)?;
                Ok(Self {
                    length_form,
                    version_number: body[0],
                })
            }
        }
        impl Serialize for $ty {
            type Error = Error;
            fn serialized_len(&self) -> usize {
                objects::apdu_len(1, self.length_form)
            }
            fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
                let pos = objects::write_apdu_header($tag, 1, self.length_form, buf)?;
                buf[pos] = self.version_number;
                Ok(pos + 1)
            }
        }
    };
}

version_byte_object!(
    ServiceListVersionAck,
    tag::SERVICE_LIST_VERSION_ACK,
    "ServiceListVersionAck"
);
version_byte_object!(
    ServiceListChanged,
    tag::SERVICE_LIST_CHANGED,
    "ServiceListChanged"
);

// --- ServiceListAck ---

/// Width of one service reference on the wire (`OriginalNetworkID` + `ServiceID`).
const SERVICE_REF_LEN: usize = 4;
// VersionNumber(1) + NumberOfServices(2).
const SERVICE_LIST_ACK_PREFIX: usize = 3;

impl<'a> Parse<'a> for ServiceListAck {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let (length_form, body) =
            objects::parse_apdu_header(bytes, tag::SERVICE_LIST_ACK, "ServiceListAck")?;
        if body.len() < SERVICE_LIST_ACK_PREFIX {
            return Err(Error::BufferTooShort {
                need: SERVICE_LIST_ACK_PREFIX,
                have: body.len(),
                what: "ServiceListAck",
            });
        }
        let version_number = body[0];
        let count = u16::from_be_bytes([body[1], body[2]]) as usize;
        let list = &body[SERVICE_LIST_ACK_PREFIX..];
        if list.len() < count * SERVICE_REF_LEN {
            return Err(Error::LengthMismatch {
                what: "ServiceListAck services",
                declared: count * SERVICE_REF_LEN,
                actual: list.len(),
            });
        }
        objects::reject_trailing_body(list, count * SERVICE_REF_LEN, "ServiceListAck")?;
        let mut services = Vec::with_capacity(count);
        for chunk in list[..count * SERVICE_REF_LEN].chunks_exact(SERVICE_REF_LEN) {
            services.push(ServiceReference {
                original_network_id: u16::from_be_bytes([chunk[0], chunk[1]]),
                service_id: u16::from_be_bytes([chunk[2], chunk[3]]),
            });
        }
        Ok(Self {
            length_form,
            version_number,
            services,
        })
    }
}
impl Serialize for ServiceListAck {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        objects::apdu_len(
            SERVICE_LIST_ACK_PREFIX + self.services.len() * SERVICE_REF_LEN,
            self.length_form,
        )
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        if self.services.len() > u16::MAX as usize {
            return Err(Error::InvalidObject {
                what: "ServiceListAck",
                reason: "more than 65535 services",
            });
        }
        let body_len = SERVICE_LIST_ACK_PREFIX + self.services.len() * SERVICE_REF_LEN;
        let mut pos =
            objects::write_apdu_header(tag::SERVICE_LIST_ACK, body_len, self.length_form, buf)?;
        buf[pos] = self.version_number;
        buf[pos + 1..pos + 3].copy_from_slice(&(self.services.len() as u16).to_be_bytes());
        pos += SERVICE_LIST_ACK_PREFIX;
        for s in &self.services {
            buf[pos..pos + 2].copy_from_slice(&s.original_network_id.to_be_bytes());
            buf[pos + 2..pos + 4].copy_from_slice(&s.service_id.to_be_bytes());
            pos += SERVICE_REF_LEN;
        }
        Ok(pos)
    }
}

// --- ServiceDescReq (service reference) ---

impl<'a> Parse<'a> for ServiceDescReq {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let (length_form, body) =
            objects::parse_apdu_header(bytes, tag::SERVICE_DESC_REQ, "ServiceDescReq")?;
        if body.len() < SERVICE_REF_LEN {
            return Err(Error::BufferTooShort {
                need: SERVICE_REF_LEN,
                have: body.len(),
                what: "ServiceDescReq",
            });
        }
        objects::reject_trailing_body(body, SERVICE_REF_LEN, "ServiceDescReq")?;
        Ok(Self {
            length_form,
            service: ServiceReference {
                original_network_id: u16::from_be_bytes([body[0], body[1]]),
                service_id: u16::from_be_bytes([body[2], body[3]]),
            },
        })
    }
}
impl Serialize for ServiceDescReq {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        objects::apdu_len(SERVICE_REF_LEN, self.length_form)
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        let pos = objects::write_apdu_header(
            tag::SERVICE_DESC_REQ,
            SERVICE_REF_LEN,
            self.length_form,
            buf,
        )?;
        buf[pos..pos + 2].copy_from_slice(&self.service.original_network_id.to_be_bytes());
        buf[pos + 2..pos + 4].copy_from_slice(&self.service.service_id.to_be_bytes());
        Ok(pos + SERVICE_REF_LEN)
    }
}

// --- ServiceDescAck ---

// OriginalNetworkID(2) + ServiceID(2) + flags/status/loop_len(3) = 7 fixed bytes.
const SERVICE_DESC_ACK_PREFIX: usize = SERVICE_REF_LEN + 3;

impl<'a> Parse<'a> for ServiceDescAck<'a> {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let (length_form, body) =
            objects::parse_apdu_header(bytes, tag::SERVICE_DESC_ACK, "ServiceDescAck")?;
        if body.len() < SERVICE_DESC_ACK_PREFIX {
            return Err(Error::BufferTooShort {
                need: SERVICE_DESC_ACK_PREFIX,
                have: body.len(),
                what: "ServiceDescAck",
            });
        }
        // byte 4: reserved_future_use(6) + EIT_schedule(1) + EIT_present_following(1)
        let flags = body[4];
        // byte 5..6: running_status(3) + free_CA_mode(1) + descriptors_loop_length(12)
        let b5 = body[5];
        let b6 = body[6];
        let running_status = (b5 >> 5) & 0x07;
        let free_ca_mode = (b5 & 0x10) != 0;
        let loop_len = ((u16::from(b5 & 0x0F) << 8) | u16::from(b6)) as usize;
        let desc_start = SERVICE_DESC_ACK_PREFIX;
        let desc_end = desc_start + loop_len;
        if body.len() < desc_end {
            return Err(Error::LengthMismatch {
                what: "ServiceDescAck descriptors",
                declared: loop_len,
                actual: body.len() - desc_start,
            });
        }
        objects::reject_trailing_body(body, desc_end, "ServiceDescAck")?;
        Ok(Self {
            length_form,
            service: ServiceReference {
                original_network_id: u16::from_be_bytes([body[0], body[1]]),
                service_id: u16::from_be_bytes([body[2], body[3]]),
            },
            eit_schedule_flag: (flags & 0x02) != 0,
            eit_present_following_flag: (flags & 0x01) != 0,
            running_status,
            free_ca_mode,
            descriptors: &body[desc_start..desc_end],
            reserved: ReservedOnes::from_bits(flags >> 2),
        })
    }
}
impl Serialize for ServiceDescAck<'_> {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        objects::apdu_len(
            SERVICE_DESC_ACK_PREFIX + self.descriptors.len(),
            self.length_form,
        )
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        if self.descriptors.len() > 0x0FFF {
            return Err(Error::InvalidObject {
                what: "ServiceDescAck",
                reason: "descriptors loop longer than 4095 bytes",
            });
        }
        objects::fit_bits(
            u64::from(self.running_status),
            3,
            "ServiceDescAck running_status",
        )?;
        let body_len = SERVICE_DESC_ACK_PREFIX + self.descriptors.len();
        let mut pos =
            objects::write_apdu_header(tag::SERVICE_DESC_ACK, body_len, self.length_form, buf)?;
        buf[pos..pos + 2].copy_from_slice(&self.service.original_network_id.to_be_bytes());
        buf[pos + 2..pos + 4].copy_from_slice(&self.service.service_id.to_be_bytes());
        // reserved_future_use(6), EIT_schedule(1), EIT_present_following(1).
        buf[pos + 4] = (self.reserved.get() << 2)
            | (u8::from(self.eit_schedule_flag) << 1)
            | u8::from(self.eit_present_following_flag);
        let loop_len = self.descriptors.len() as u16;
        // running_status(3), free_CA_mode(1), descriptors_loop_length(12).
        // running_status range-checked above.
        buf[pos + 5] = (self.running_status << 5)
            | (u8::from(self.free_ca_mode) << 4)
            | ((loop_len >> 8) as u8 & 0x0F);
        buf[pos + 6] = loop_len as u8;
        pos += SERVICE_DESC_ACK_PREFIX;
        buf[pos..pos + self.descriptors.len()].copy_from_slice(self.descriptors);
        Ok(pos + self.descriptors.len())
    }
}

// --- GetServiceReq ---

impl<'a> Parse<'a> for GetServiceReq {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let (length_form, body) =
            objects::parse_apdu_header(bytes, tag::GET_SERVICE_REQ, "GetServiceReq")?;
        let service = if body.is_empty() {
            None
        } else {
            if body.len() < SERVICE_REF_LEN {
                return Err(Error::BufferTooShort {
                    need: SERVICE_REF_LEN,
                    have: body.len(),
                    what: "GetServiceReq",
                });
            }
            objects::reject_trailing_body(body, SERVICE_REF_LEN, "GetServiceReq")?;
            Some(ServiceReference {
                original_network_id: u16::from_be_bytes([body[0], body[1]]),
                service_id: u16::from_be_bytes([body[2], body[3]]),
            })
        };
        Ok(Self {
            length_form,
            service,
        })
    }
}
impl Serialize for GetServiceReq {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        objects::apdu_len(
            if self.service.is_some() {
                SERVICE_REF_LEN
            } else {
                0
            },
            self.length_form,
        )
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        match self.service {
            None => objects::write_apdu_header(tag::GET_SERVICE_REQ, 0, self.length_form, buf),
            Some(s) => {
                let pos = objects::write_apdu_header(
                    tag::GET_SERVICE_REQ,
                    SERVICE_REF_LEN,
                    self.length_form,
                    buf,
                )?;
                buf[pos..pos + 2].copy_from_slice(&s.original_network_id.to_be_bytes());
                buf[pos + 2..pos + 4].copy_from_slice(&s.service_id.to_be_bytes());
                Ok(pos + SERVICE_REF_LEN)
            }
        }
    }
}

// --- GetServiceAck ---

// OriginalNetworkID(2) + ServiceID(2) + flags(1) + ActualService(2).
const GET_SERVICE_ACK_BODY: usize = SERVICE_REF_LEN + 1 + 2;

impl<'a> Parse<'a> for GetServiceAck {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let (length_form, body) =
            objects::parse_apdu_header(bytes, tag::GET_SERVICE_ACK, "GetServiceAck")?;
        if body.len() < GET_SERVICE_ACK_BODY {
            return Err(Error::BufferTooShort {
                need: GET_SERVICE_ACK_BODY,
                have: body.len(),
                what: "GetServiceAck",
            });
        }
        crate::objects::reject_trailing_body(body, GET_SERVICE_ACK_BODY, "GetServiceAck")?;
        // byte 4: Reserved(5) + ServiceTerminated(1) + ServiceNotAvailable(1) + CAServiceFlag(1)
        let flags = body[4];
        Ok(Self {
            length_form,
            service: ServiceReference {
                original_network_id: u16::from_be_bytes([body[0], body[1]]),
                service_id: u16::from_be_bytes([body[2], body[3]]),
            },
            service_terminated: (flags & 0x04) != 0,
            service_not_available: (flags & 0x02) != 0,
            ca_service_flag: (flags & 0x01) != 0,
            actual_service: u16::from_be_bytes([body[5], body[6]]),
            reserved: ReservedZero::from_bits(flags >> 3),
        })
    }
}
impl Serialize for GetServiceAck {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        objects::apdu_len(GET_SERVICE_ACK_BODY, self.length_form)
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        let pos = objects::write_apdu_header(
            tag::GET_SERVICE_ACK,
            GET_SERVICE_ACK_BODY,
            self.length_form,
            buf,
        )?;
        buf[pos..pos + 2].copy_from_slice(&self.service.original_network_id.to_be_bytes());
        buf[pos + 2..pos + 4].copy_from_slice(&self.service.service_id.to_be_bytes());
        // Reserved(5), then the three flag bits.
        buf[pos + 4] = (self.reserved.get() << 3)
            | (u8::from(self.service_terminated) << 2)
            | (u8::from(self.service_not_available) << 1)
            | u8::from(self.ca_service_flag);
        buf[pos + 5..pos + 7].copy_from_slice(&self.actual_service.to_be_bytes());
        Ok(pos + GET_SERVICE_ACK_BODY)
    }
}

crate::dispatch::declare_resource_apdus! {
    /// Resource-scoped dispatch over the Generic Service Gateway objects (Tables 22-30).
    #[derive(Debug, Clone, PartialEq, Eq)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
    #[non_exhaustive]
    pub enum ServiceGatewayApdu<'a> ("service_gateway") {
        /// `ServiceListReq` (`9F 80 00`).
        ServiceListReq(ServiceListReq) = tag::SERVICE_LIST_REQ,
        /// `ServiceListAck` (`9F 80 01`).
        ServiceListAck(ServiceListAck) = tag::SERVICE_LIST_ACK,
        /// `ServiceListVersionReq` (`9F 80 02`).
        ServiceListVersionReq(ServiceListVersionReq) = tag::SERVICE_LIST_VERSION_REQ,
        /// `ServiceListVersionAck` (`9F 80 03`).
        ServiceListVersionAck(ServiceListVersionAck) = tag::SERVICE_LIST_VERSION_ACK,
        /// `ServiceListChanged` (`9F 80 04`).
        ServiceListChanged(ServiceListChanged) = tag::SERVICE_LIST_CHANGED,
        /// `ServiceDescReq` (`9F 80 05`).
        ServiceDescReq(ServiceDescReq) = tag::SERVICE_DESC_REQ,
        /// `ServiceDescAck` (`9F 80 06`).
        ServiceDescAck(ServiceDescAck<'a>) = tag::SERVICE_DESC_ACK,
        /// `GetServiceReq` (`9F 80 07`).
        GetServiceReq(GetServiceReq) = tag::GET_SERVICE_REQ,
        /// `GetServiceAck` (`9F 80 08`).
        GetServiceAck(GetServiceAck) = tag::GET_SERVICE_ACK,
    }
}

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

    #[test]
    fn header_only_objects_round_trip() {
        assert_eq!(
            ServiceListReq::default().try_to_bytes().unwrap(),
            [0x9F, 0x80, 0x00, 0x00]
        );
        assert_eq!(
            ServiceListVersionReq::default().try_to_bytes().unwrap(),
            [0x9F, 0x80, 0x02, 0x00]
        );
        assert_eq!(
            ServiceListReq::parse(&[0x9F, 0x80, 0x00, 0x00]).unwrap(),
            ServiceListReq::default()
        );
    }

    #[test]
    fn service_list_ack_multi_round_trips_and_bites() {
        let ack = ServiceListAck {
            length_form: crate::length::LengthForm::Minimal,
            version_number: 0x07,
            services: alloc::vec![
                ServiceReference {
                    original_network_id: 0x0001,
                    service_id: 0x0064,
                },
                ServiceReference {
                    original_network_id: 0x0001,
                    service_id: 0x0065,
                },
            ],
        };
        let bytes = ack.try_to_bytes().unwrap();
        // tag(3) + len(1) + ver(1) + count(2) + 2*4 = 15; body = 11 = 0x0B.
        assert_eq!(
            bytes,
            [
                0x9F, 0x80, 0x01, 0x0B, 0x07, 0x00, 0x02, 0x00, 0x01, 0x00, 0x64, 0x00, 0x01, 0x00,
                0x65
            ]
        );
        assert_eq!(ServiceListAck::parse(&bytes).unwrap(), ack);
        let mut other = ack.clone();
        other.services[1].service_id = 0x0066;
        assert_ne!(bytes, other.try_to_bytes().unwrap());
    }

    #[test]
    fn service_list_ack_empty_round_trips() {
        let ack = ServiceListAck {
            length_form: crate::length::LengthForm::Minimal,
            version_number: 0x02,
            services: alloc::vec![],
        };
        let bytes = ack.try_to_bytes().unwrap();
        assert_eq!(bytes, [0x9F, 0x80, 0x01, 0x03, 0x02, 0x00, 0x00]);
        assert_eq!(ServiceListAck::parse(&bytes).unwrap(), ack);
    }

    #[test]
    fn version_ack_and_changed_round_trip_and_bite() {
        let v = ServiceListVersionAck {
            length_form: crate::length::LengthForm::Minimal,
            version_number: 9,
        };
        let bytes = v.try_to_bytes().unwrap();
        assert_eq!(bytes, [0x9F, 0x80, 0x03, 0x01, 0x09]);
        assert_eq!(ServiceListVersionAck::parse(&bytes).unwrap(), v);
        assert_ne!(
            bytes,
            ServiceListVersionAck {
                length_form: crate::length::LengthForm::Minimal,
                version_number: 10
            }
            .try_to_bytes()
            .unwrap()
        );

        let c = ServiceListChanged {
            length_form: crate::length::LengthForm::Minimal,
            version_number: 3,
        };
        let cbytes = c.try_to_bytes().unwrap();
        assert_eq!(cbytes, [0x9F, 0x80, 0x04, 0x01, 0x03]);
        assert_eq!(ServiceListChanged::parse(&cbytes).unwrap(), c);
    }

    #[test]
    fn service_desc_req_round_trips_and_bites() {
        let r = ServiceDescReq {
            length_form: crate::length::LengthForm::Minimal,
            service: ServiceReference {
                original_network_id: 0x1234,
                service_id: 0x5678,
            },
        };
        let bytes = r.try_to_bytes().unwrap();
        assert_eq!(bytes, [0x9F, 0x80, 0x05, 0x04, 0x12, 0x34, 0x56, 0x78]);
        assert_eq!(ServiceDescReq::parse(&bytes).unwrap(), r);
        let mut other = r;
        other.service.service_id = 0x5679;
        assert_ne!(bytes, other.try_to_bytes().unwrap());
    }

    #[test]
    fn service_desc_ack_round_trips_and_bites() {
        // 2 descriptors: 0x48 (service descriptor) len 2, and 0x52 len 1.
        let desc = [0x48, 0x02, 0xAA, 0xBB, 0x52, 0x01, 0x03];
        let ack = ServiceDescAck {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            service: ServiceReference {
                original_network_id: 0x0001,
                service_id: 0x0064,
            },
            eit_schedule_flag: true,
            eit_present_following_flag: false,
            running_status: 4, // running
            free_ca_mode: true,
            descriptors: &desc,
        };
        let bytes = ack.try_to_bytes().unwrap();
        // prefix(7) + 7 desc = 14 body; tag(3)+len(1)+14 = 18.
        // byte4 = 0xFC | (1<<1) | 0 = 0xFE
        // byte5 = (4<<5) | (1<<4) | (loop_len>>8) = 0x80 | 0x10 | 0x00 = 0x90
        // byte6 = loop_len = 7
        assert_eq!(
            bytes,
            [
                0x9F, 0x80, 0x06, 0x0E, 0x00, 0x01, 0x00, 0x64, 0xFE, 0x90, 0x07, 0x48, 0x02, 0xAA,
                0xBB, 0x52, 0x01, 0x03
            ]
        );
        let parsed = ServiceDescAck::parse(&bytes).unwrap();
        assert_eq!(parsed, ack);
        assert_eq!(parsed.running_status, 4);
        assert!(parsed.eit_schedule_flag);
        assert!(!parsed.eit_present_following_flag);
        assert!(parsed.free_ca_mode);
        let mut other = ack.clone();
        other.running_status = 1;
        assert_ne!(bytes, other.try_to_bytes().unwrap());
    }

    #[test]
    fn service_desc_ack_empty_loop() {
        let ack = ServiceDescAck {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            service: ServiceReference {
                original_network_id: 0xAAAA,
                service_id: 0xBBBB,
            },
            eit_schedule_flag: false,
            eit_present_following_flag: true,
            running_status: 0,
            free_ca_mode: false,
            descriptors: &[],
        };
        let bytes = ack.try_to_bytes().unwrap();
        // byte4 = 0xFC | 0 | 1 = 0xFD ; byte5 = 0 ; byte6 = 0
        assert_eq!(
            bytes,
            [
                0x9F, 0x80, 0x06, 0x07, 0xAA, 0xAA, 0xBB, 0xBB, 0xFD, 0x00, 0x00
            ]
        );
        assert_eq!(ServiceDescAck::parse(&bytes).unwrap(), ack);
    }

    #[test]
    fn get_service_req_with_and_without_ref() {
        let r = GetServiceReq {
            length_form: crate::length::LengthForm::Minimal,
            service: Some(ServiceReference {
                original_network_id: 0x0001,
                service_id: 0x0064,
            }),
        };
        let bytes = r.try_to_bytes().unwrap();
        assert_eq!(bytes, [0x9F, 0x80, 0x07, 0x04, 0x00, 0x01, 0x00, 0x64]);
        assert_eq!(GetServiceReq::parse(&bytes).unwrap(), r);

        let disconnect = GetServiceReq {
            length_form: crate::length::LengthForm::Minimal,
            service: None,
        };
        let dbytes = disconnect.try_to_bytes().unwrap();
        assert_eq!(dbytes, [0x9F, 0x80, 0x07, 0x00]);
        assert_eq!(GetServiceReq::parse(&dbytes).unwrap(), disconnect);
        assert_ne!(bytes, dbytes);
    }

    #[test]
    fn get_service_ack_round_trips_and_bites() {
        let ack = GetServiceAck {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            service: ServiceReference {
                original_network_id: 0x0001,
                service_id: 0x0064,
            },
            service_terminated: false,
            service_not_available: false,
            ca_service_flag: true,
            actual_service: 0x0064,
        };
        let bytes = ack.try_to_bytes().unwrap();
        // byte4 = CAServiceFlag = 0x01 ; ActualService = 0x0064
        assert_eq!(
            bytes,
            [
                0x9F, 0x80, 0x08, 0x07, 0x00, 0x01, 0x00, 0x64, 0x01, 0x00, 0x64
            ]
        );
        assert_eq!(GetServiceAck::parse(&bytes).unwrap(), ack);
        // Table 31: a "not available" combination.
        let mut other = ack;
        other.ca_service_flag = false;
        other.service_not_available = true;
        other.actual_service = 0;
        assert_ne!(bytes, other.try_to_bytes().unwrap());
        assert_eq!(other.try_to_bytes().unwrap()[8], 0x02);
    }

    #[test]
    fn dispatch_routes_each_tag() {
        let req = ServiceListReq::default().try_to_bytes().unwrap();
        assert!(matches!(
            ServiceGatewayApdu::parse(&req).unwrap(),
            ServiceGatewayApdu::ServiceListReq(_)
        ));
        let gs = GetServiceAck {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            service: ServiceReference::default(),
            service_terminated: true,
            service_not_available: false,
            ca_service_flag: false,
            actual_service: 0,
        }
        .try_to_bytes()
        .unwrap();
        let parsed = ServiceGatewayApdu::parse(&gs).unwrap();
        assert!(matches!(parsed, ServiceGatewayApdu::GetServiceAck(_)));
        assert_eq!(parsed.try_to_bytes().unwrap(), gs);
    }

    #[test]
    fn oversized_running_status_is_rejected_not_wrapped() {
        // Before the fix, 0x0A (exceeds 3 bits) silently wrapped to 0x02 in
        // the running_status field and returned Ok.
        let ack = ServiceDescAck {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            service: ServiceReference {
                original_network_id: 1,
                service_id: 1,
            },
            eit_schedule_flag: false,
            eit_present_following_flag: false,
            running_status: 0x0A,
            free_ca_mode: false,
            descriptors: &[],
        };
        let mut buf = [0u8; 32];
        assert!(matches!(
            ack.serialize_into(&mut buf),
            Err(Error::InvalidObject { .. })
        ));
    }

    #[test]
    fn max_running_status_still_serializes_and_round_trips() {
        let ack = ServiceDescAck {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            service: ServiceReference {
                original_network_id: 1,
                service_id: 1,
            },
            eit_schedule_flag: false,
            eit_present_following_flag: false,
            running_status: 0x07, // the 3-bit maximum
            free_ca_mode: false,
            descriptors: &[],
        };
        let bytes = ack.try_to_bytes().unwrap();
        assert_eq!(ServiceDescAck::parse(&bytes).unwrap(), ack);
    }
}