dvb-ci 0.12.0

//! Resource Manager v2 objects — ETSI TS 101 699 V1.1.1 §4.2.1, Tables 3-7
//! (PDF pp. 13-17). See `private/specs-verified/dvb/dvb-ci/ci_plus/resource-manager-v2.md`.
//!
//! Resource ID `0x00010042`. Adds Module ID establishment to the EN 50221 v1
//! Resource Manager. The three v1 objects (Profile Enquiry, Profile Reply,
//! Profile Changed) are layout-identical to EN 50221 but are re-defined here so
//! the v2 resource owns its own object set:
//!
//! - `profile_enq` (`9F 80 10`, Table 3) — header-only enquiry.
//! - `profile_reply` (`9F 80 11`, Table 4) — list of `resource_identifier()`s.
//! - `profile_changed` (`9F 80 12`, Table 5) — header-only notification.
//! - `module_id_send` (`9F 80 13`, Table 6) — module returns its Module ID.
//! - `module_id_command` (`9F 80 14`, Table 7) — host ack / sets the Module ID.

use crate::error::{Error, Result};
use crate::objects;
use crate::reserved::ReservedZero;
use crate::resource::ResourceId;
use alloc::vec::Vec;
use broadcast_common::len::need_in;
use broadcast_common::{Parse, Serialize};

/// Resource-scoped `apdu_tag`s for the Resource Manager v2 (Table 87 / Tables 3-7).
pub mod tag {
    use crate::tag::ApduTag;
    /// `Tprofile_enq` = `9F 80 10`.
    pub const PROFILE_ENQ: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x10);
    /// `Tprofile_reply` = `9F 80 11`.
    pub const PROFILE_REPLY: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x11);
    /// `Tprofile_changed` = `9F 80 12`.
    pub const PROFILE_CHANGED: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x12);
    /// `Tmodule_id_send` = `9F 80 13`.
    pub const MODULE_ID_SEND: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x13);
    /// `Tmodule_id_command` = `9F 80 14`.
    pub const MODULE_ID_COMMAND: ApduTag = ApduTag::from_bytes(0x9F, 0x80, 0x14);
}

/// `profile_enq()` — Profile Enquiry, empty body (Table 3).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ProfileEnq {
    /// 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,
}

/// `profile_changed()` — Profile Changed, empty body (Table 5).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ProfileChanged {
    /// 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,
}

/// `profile_reply()` — the list of resources the sender provides (Table 4).
#[derive(Debug, Clone, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ProfileReply {
    /// 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,

    /// Advertised `resource_identifier()`s, in wire order (`length_field = N*4`).
    pub resources: Vec<ResourceId>,
}

/// `module_id_send()` — module returns its current Module ID (Table 6).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ModuleIdSend {
    /// 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 6-bit Module ID (`0` if the host has not allocated one). Only the low
    /// 6 bits are significant; the top 2 bits are reserved.
    pub module_id: u8,
    /// The 2-bit `reserved` field in front of `module_id` as received, preserved so the
    /// object re-serializes byte-for-byte; `0` when hand-built.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub reserved: ReservedZero<2>,
}

/// `command` values for `module_id_command()` (Table 7).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[non_exhaustive]
pub enum ModuleIdCommandKind {
    /// `0x01` — host accepts the Module ID; module continues to Profile.
    Acknowledgement,
    /// `0x02` — `module_id` carries a new ID to set.
    SetModuleId,
    /// Any other value (reserved).
    Reserved(u8),
}

impl ModuleIdCommandKind {
    /// Decode a `command` byte.
    #[must_use]
    pub fn from_u8(v: u8) -> Self {
        match v {
            0x01 => Self::Acknowledgement,
            0x02 => Self::SetModuleId,
            other => Self::Reserved(other),
        }
    }
    /// Wire byte.
    #[must_use]
    pub const fn to_u8(self) -> u8 {
        match self {
            Self::Acknowledgement => 0x01,
            Self::SetModuleId => 0x02,
            Self::Reserved(v) => v,
        }
    }
    /// Spec token, or `"reserved"`.
    #[must_use]
    pub fn name(&self) -> &'static str {
        match self {
            Self::Acknowledgement => "Acknowledgement",
            Self::SetModuleId => "Set_ModuleID",
            Self::Reserved(_) => "reserved",
        }
    }
}
broadcast_common::impl_spec_display!(ModuleIdCommandKind, Reserved);

/// `module_id_command()` — host acknowledges or sets the Module ID (Table 7).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct ModuleIdCommand {
    /// 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,

    /// `command`.
    pub command: ModuleIdCommandKind,
    /// The 6-bit Module ID (significant only for `Set_ModuleID`).
    pub module_id: u8,
    /// The 2-bit `reserved` field in front of `module_id` as received, preserved so the
    /// object re-serializes byte-for-byte; `0` when hand-built.
    #[cfg_attr(feature = "serde", serde(skip))]
    pub reserved: ReservedZero<2>,
}

// --- profile_enq / profile_changed / profile_reply ---
//
// Layout-identical to EN 50221 §8.4.1 (module doc): delegate to
// `objects::resource_manager` rather than re-implementing the framing and the
// resource-id list walk (audit r10-O-5).

use crate::objects::resource_manager as v1;

impl<'a> Parse<'a> for ProfileEnq {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let v = v1::ProfileEnq::parse(bytes)?;
        Ok(Self {
            length_form: v.length_form,
        })
    }
}
impl Serialize for ProfileEnq {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        v1::ProfileEnq {
            length_form: self.length_form,
        }
        .serialized_len()
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        v1::ProfileEnq {
            length_form: self.length_form,
        }
        .serialize_into(buf)
    }
}

impl<'a> Parse<'a> for ProfileChanged {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let v = v1::ProfileChange::parse(bytes)?;
        Ok(Self {
            length_form: v.length_form,
        })
    }
}
impl Serialize for ProfileChanged {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        v1::ProfileChange {
            length_form: self.length_form,
        }
        .serialized_len()
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        v1::ProfileChange {
            length_form: self.length_form,
        }
        .serialize_into(buf)
    }
}

impl<'a> Parse<'a> for ProfileReply {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let v = v1::Profile::parse(bytes)?;
        Ok(Self {
            length_form: v.length_form,
            resources: v.resources,
        })
    }
}
impl Serialize for ProfileReply {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        objects::apdu_len(self.resources.len() * ResourceId::LEN, self.length_form)
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        // `Profile` owns its list, so this clones the (4-byte) ids once.
        v1::Profile {
            length_form: self.length_form,
            resources: self.resources.clone(),
        }
        .serialize_into(buf)
    }
}

// --- module_id_send ---

// reserved(2) + module_id(6).
const MODULE_ID_SEND_BODY: usize = 1;

impl<'a> Parse<'a> for ModuleIdSend {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let (length_form, body) =
            objects::parse_apdu_header(bytes, tag::MODULE_ID_SEND, "module_id_send")?;
        need_in(body, MODULE_ID_SEND_BODY, "module_id_send")?;
        crate::objects::reject_trailing_body(body, MODULE_ID_SEND_BODY, "module_id_send")?;
        Ok(Self {
            length_form,
            module_id: body[0] & 0x3F,
            reserved: ReservedZero::from_bits(body[0] >> 6),
        })
    }
}
impl Serialize for ModuleIdSend {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        objects::apdu_len(MODULE_ID_SEND_BODY, self.length_form)
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        objects::fit_bits(u64::from(self.module_id), 6, "module_id_send module_id")?;
        let pos = objects::write_apdu_header(
            tag::MODULE_ID_SEND,
            MODULE_ID_SEND_BODY,
            self.length_form,
            buf,
        )?;
        // reserved(2), module_id(6). Range-checked above.
        buf[pos] = (self.reserved.get() << 6) | self.module_id;
        Ok(pos + MODULE_ID_SEND_BODY)
    }
}

// --- module_id_command ---

// command(8) + reserved(2) + module_id(6).
const MODULE_ID_COMMAND_BODY: usize = 2;

impl<'a> Parse<'a> for ModuleIdCommand {
    type Error = Error;
    fn parse(bytes: &'a [u8]) -> Result<Self> {
        let (length_form, body) =
            objects::parse_apdu_header(bytes, tag::MODULE_ID_COMMAND, "module_id_command")?;
        need_in(body, MODULE_ID_COMMAND_BODY, "module_id_command")?;
        crate::objects::reject_trailing_body(body, MODULE_ID_COMMAND_BODY, "module_id_command")?;
        Ok(Self {
            length_form,
            command: ModuleIdCommandKind::from_u8(body[0]),
            module_id: body[1] & 0x3F,
            reserved: ReservedZero::from_bits(body[1] >> 6),
        })
    }
}
impl Serialize for ModuleIdCommand {
    type Error = Error;
    fn serialized_len(&self) -> usize {
        objects::apdu_len(MODULE_ID_COMMAND_BODY, self.length_form)
    }
    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
        objects::fit_bits(u64::from(self.module_id), 6, "module_id_command module_id")?;
        let pos = objects::write_apdu_header(
            tag::MODULE_ID_COMMAND,
            MODULE_ID_COMMAND_BODY,
            self.length_form,
            buf,
        )?;
        buf[pos] = self.command.to_u8();
        // reserved(2), module_id(6). Range-checked above.
        buf[pos + 1] = (self.reserved.get() << 6) | self.module_id;
        Ok(pos + MODULE_ID_COMMAND_BODY)
    }
}

crate::dispatch::declare_resource_apdus! {
    /// Resource-scoped dispatch over the Resource Manager v2 objects (Tables 3-7).
    #[derive(Debug, Clone, PartialEq, Eq)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
    #[non_exhaustive]
    pub enum ResourceManagerV2Apdu ("resource_manager_v2") {
        /// `profile_enq` (`9F 80 10`).
        ProfileEnq(ProfileEnq) = tag::PROFILE_ENQ,
        /// `profile_reply` (`9F 80 11`).
        ProfileReply(ProfileReply) = tag::PROFILE_REPLY,
        /// `profile_changed` (`9F 80 12`).
        ProfileChanged(ProfileChanged) = tag::PROFILE_CHANGED,
        /// `module_id_send` (`9F 80 13`).
        ModuleIdSend(ModuleIdSend) = tag::MODULE_ID_SEND,
        /// `module_id_command` (`9F 80 14`).
        ModuleIdCommand(ModuleIdCommand) = tag::MODULE_ID_COMMAND,
    }
}

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

    #[test]
    fn profile_enq_round_trips() {
        let bytes = ProfileEnq::default().try_to_bytes().unwrap();
        assert_eq!(bytes, [0x9F, 0x80, 0x10, 0x00]);
        assert_eq!(ProfileEnq::parse(&bytes).unwrap(), ProfileEnq::default());
    }

    #[test]
    fn profile_changed_round_trips() {
        let bytes = ProfileChanged::default().try_to_bytes().unwrap();
        assert_eq!(bytes, [0x9F, 0x80, 0x12, 0x00]);
        assert_eq!(
            ProfileChanged::parse(&bytes).unwrap(),
            ProfileChanged::default()
        );
    }

    #[test]
    fn profile_reply_multi_round_trips_and_bites() {
        let p = ProfileReply {
            length_form: crate::length::LengthForm::Minimal,
            resources: alloc::vec![ResourceId(0x0001_0042), ResourceId(0x0002_0042)],
        };
        let bytes = p.try_to_bytes().unwrap();
        // tag(3) + len(1) + 2*4 = 12; len = 0x08.
        assert_eq!(
            bytes,
            [
                0x9F, 0x80, 0x11, 0x08, 0x00, 0x01, 0x00, 0x42, 0x00, 0x02, 0x00, 0x42
            ]
        );
        assert_eq!(ProfileReply::parse(&bytes).unwrap(), p);
        let mut other = p.clone();
        other.resources[1] = ResourceId(0x0022_0041);
        assert_ne!(bytes, other.try_to_bytes().unwrap());
    }

    #[test]
    fn module_id_send_round_trips_and_bites() {
        let m = ModuleIdSend {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            module_id: 0x03,
        };
        let bytes = m.try_to_bytes().unwrap();
        assert_eq!(bytes, [0x9F, 0x80, 0x13, 0x01, 0x03]);
        assert_eq!(ModuleIdSend::parse(&bytes).unwrap(), m);
        // top 2 bits ignored on read.
        let parsed = ModuleIdSend::parse(&[0x9F, 0x80, 0x13, 0x01, 0xC3]).unwrap();
        assert_eq!(parsed.module_id, 0x03);
        let other = ModuleIdSend {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            module_id: 0x04,
        };
        assert_ne!(bytes, other.try_to_bytes().unwrap());
    }

    #[test]
    fn module_id_command_round_trips_and_bites() {
        let m = ModuleIdCommand {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            command: ModuleIdCommandKind::SetModuleId,
            module_id: 0x05,
        };
        let bytes = m.try_to_bytes().unwrap();
        assert_eq!(bytes, [0x9F, 0x80, 0x14, 0x02, 0x02, 0x05]);
        assert_eq!(ModuleIdCommand::parse(&bytes).unwrap(), m);
        assert_eq!(m.command.name(), "Set_ModuleID");
        let mut other = m;
        other.command = ModuleIdCommandKind::Acknowledgement;
        assert_ne!(bytes, other.try_to_bytes().unwrap());
    }

    #[test]
    fn dispatch_routes_each_tag() {
        let enq = ProfileEnq::default().try_to_bytes().unwrap();
        assert!(matches!(
            ResourceManagerV2Apdu::parse(&enq).unwrap(),
            ResourceManagerV2Apdu::ProfileEnq(_)
        ));
        let mic = ModuleIdCommand {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            command: ModuleIdCommandKind::Acknowledgement,
            module_id: 1,
        }
        .try_to_bytes()
        .unwrap();
        let parsed = ResourceManagerV2Apdu::parse(&mic).unwrap();
        assert!(matches!(parsed, ResourceManagerV2Apdu::ModuleIdCommand(_)));
        // dispatch enum round-trips.
        assert_eq!(parsed.try_to_bytes().unwrap(), mic);
    }

    #[test]
    fn oversized_module_id_send_is_rejected_not_wrapped() {
        // Before the fix, 0x43 (exceeds 6 bits) silently wrapped to 0x03 in
        // the module_id field and returned Ok.
        let m = ModuleIdSend {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            module_id: 0x43,
        };
        let mut buf = [0u8; 16];
        assert!(matches!(
            m.serialize_into(&mut buf),
            Err(Error::InvalidObject { .. })
        ));
    }

    #[test]
    fn max_module_id_send_still_serializes_and_round_trips() {
        let m = ModuleIdSend {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            module_id: 0x3F,
        }; // the 6-bit maximum
        let bytes = m.try_to_bytes().unwrap();
        assert_eq!(ModuleIdSend::parse(&bytes).unwrap(), m);
    }

    #[test]
    fn oversized_module_id_command_is_rejected_not_wrapped() {
        let m = ModuleIdCommand {
            reserved: Default::default(),
            length_form: crate::length::LengthForm::Minimal,
            command: ModuleIdCommandKind::SetModuleId,
            module_id: 0x43,
        };
        let mut buf = [0u8; 16];
        assert!(matches!(
            m.serialize_into(&mut buf),
            Err(Error::InvalidObject { .. })
        ));
    }
}