hiroz 0.2.0

//! Wire format types for rcl_interfaces parameter messages.
//!
//! These types match the ROS 2 rcl_interfaces message definitions exactly
//! for CDR serialization compatibility. They are hand-implemented because
//! hiroz cannot depend on hiroz-msgs (circular dependency).
//!
//! The type hashes are computed from the .msg/.srv definitions and must
//! match those generated by hiroz-codegen for interop with rclcpp nodes.

use serde::{Deserialize, Serialize};

use crate::ServiceTypeInfo;
use crate::ZBuf;
use crate::dynamic::{FieldType, MessageSchema, TypeDescriptionService};
use crate::entity::{TypeHash, TypeInfo};
use crate::msg::{SerdeCdrSerdes, ZMessage, ZService};

// ============================================================================
// Parameter type constants (from ParameterType.msg)
// ============================================================================

pub mod parameter_type {
    pub const NOT_SET: u8 = 0;
    pub const BOOL: u8 = 1;
    pub const INTEGER: u8 = 2;
    pub const DOUBLE: u8 = 3;
    pub const STRING: u8 = 4;
    pub const BYTE_ARRAY: u8 = 5;
    pub const BOOL_ARRAY: u8 = 6;
    pub const INTEGER_ARRAY: u8 = 7;
    pub const DOUBLE_ARRAY: u8 = 8;
    pub const STRING_ARRAY: u8 = 9;
}

// ============================================================================
// Message types (from rcl_interfaces/msg/)
// ============================================================================

/// FloatingPointRange.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireFloatingPointRange {
    pub from_value: f64,
    pub to_value: f64,
    pub step: f64,
}

/// IntegerRange.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireIntegerRange {
    pub from_value: i64,
    pub to_value: i64,
    pub step: u64,
}

/// ParameterValue.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireParameterValue {
    pub r#type: u8,
    pub bool_value: bool,
    pub integer_value: i64,
    pub double_value: f64,
    pub string_value: String,
    pub byte_array_value: ZBuf,
    pub bool_array_value: Vec<bool>,
    pub integer_array_value: Vec<i64>,
    pub double_array_value: Vec<f64>,
    pub string_array_value: Vec<String>,
}

/// Parameter.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireParameter {
    pub name: String,
    pub value: WireParameterValue,
}

/// ParameterDescriptor.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireParameterDescriptor {
    pub name: String,
    pub r#type: u8,
    pub description: String,
    pub additional_constraints: String,
    pub read_only: bool,
    pub dynamic_typing: bool,
    pub floating_point_range: Vec<WireFloatingPointRange>,
    pub integer_range: Vec<WireIntegerRange>,
}

/// ParameterEvent.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireParameterEvent {
    pub stamp: WireTime,
    pub node: String,
    pub new_parameters: Vec<WireParameter>,
    pub changed_parameters: Vec<WireParameter>,
    pub deleted_parameters: Vec<WireParameter>,
}

/// SetParametersResult.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireSetParametersResult {
    pub successful: bool,
    pub reason: String,
}

/// ListParametersResult.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireListParametersResult {
    pub names: Vec<String>,
    pub prefixes: Vec<String>,
}

/// ParameterEventDescriptors.msg
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireParameterEventDescriptors {
    pub new_parameters: Vec<WireParameterDescriptor>,
    pub changed_parameters: Vec<WireParameterDescriptor>,
    pub deleted_parameters: Vec<WireParameterDescriptor>,
}

/// builtin_interfaces/Time (needed by ParameterEvent)
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WireTime {
    pub sec: i32,
    pub nanosec: u32,
}

// ============================================================================
// Service request/response types (from rcl_interfaces/srv/)
// ============================================================================

/// DescribeParameters.srv request
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DescribeParametersRequest {
    pub names: Vec<String>,
}

/// DescribeParameters.srv response
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DescribeParametersResponse {
    pub descriptors: Vec<WireParameterDescriptor>,
}

/// GetParameters.srv request
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetParametersRequest {
    pub names: Vec<String>,
}

/// GetParameters.srv response
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetParametersResponse {
    pub values: Vec<WireParameterValue>,
}

/// GetParameterTypes.srv request
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetParameterTypesRequest {
    pub names: Vec<String>,
}

/// GetParameterTypes.srv response
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetParameterTypesResponse {
    pub types: Vec<u8>,
}

/// ListParameters.srv request
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ListParametersRequest {
    pub prefixes: Vec<String>,
    pub depth: u64,
}

/// ListParameters.srv response
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ListParametersResponse {
    pub result: WireListParametersResult,
}

/// SetParameters.srv request
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetParametersRequest {
    pub parameters: Vec<WireParameter>,
}

/// SetParameters.srv response
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetParametersResponse {
    pub results: Vec<WireSetParametersResult>,
}

/// SetParametersAtomically.srv request
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetParametersAtomicallyRequest {
    pub parameters: Vec<WireParameter>,
}

/// SetParametersAtomically.srv response
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetParametersAtomicallyResponse {
    pub result: WireSetParametersResult,
}

// ============================================================================
// ZService marker types + ServiceTypeInfo implementations
// ============================================================================

pub struct DescribeParametersSrv;

impl ZService for DescribeParametersSrv {
    type Request = DescribeParametersRequest;
    type Response = DescribeParametersResponse;
}

impl ServiceTypeInfo for DescribeParametersSrv {
    fn service_type_info() -> TypeInfo {
        TypeInfo::new(
            "rcl_interfaces::srv::dds_::DescribeParameters_",
            TypeHash::from_rihs_string(
                "RIHS01_845b484d71eb0673dae682f2e3ba3c4851a65a3dcfb97bddd82c5b57e91e4cff",
            )
            .expect("Invalid RIHS hash"),
        )
    }
}

pub struct GetParametersSrv;

impl ZService for GetParametersSrv {
    type Request = GetParametersRequest;
    type Response = GetParametersResponse;
}

impl ServiceTypeInfo for GetParametersSrv {
    fn service_type_info() -> TypeInfo {
        TypeInfo::new(
            "rcl_interfaces::srv::dds_::GetParameters_",
            TypeHash::from_rihs_string(
                "RIHS01_bf9803d5c74cf989a5de3e0c2e99444599a627c7ff75f97b8c05b01003675cbc",
            )
            .expect("Invalid RIHS hash"),
        )
    }
}

pub struct GetParameterTypesSrv;

impl ZService for GetParameterTypesSrv {
    type Request = GetParameterTypesRequest;
    type Response = GetParameterTypesResponse;
}

impl ServiceTypeInfo for GetParameterTypesSrv {
    fn service_type_info() -> TypeInfo {
        TypeInfo::new(
            "rcl_interfaces::srv::dds_::GetParameterTypes_",
            TypeHash::from_rihs_string(
                "RIHS01_da199c878688b3e530bdfe3ca8f74cb9fa0c303101e980a9e8f260e25e1c80ca",
            )
            .expect("Invalid RIHS hash"),
        )
    }
}

pub struct ListParametersSrv;

impl ZService for ListParametersSrv {
    type Request = ListParametersRequest;
    type Response = ListParametersResponse;
}

impl ServiceTypeInfo for ListParametersSrv {
    fn service_type_info() -> TypeInfo {
        TypeInfo::new(
            "rcl_interfaces::srv::dds_::ListParameters_",
            TypeHash::from_rihs_string(
                "RIHS01_3e6062bfbb27bfb8730d4cef2558221f51a11646d78e7bb30a1e83afac3aad9d",
            )
            .expect("Invalid RIHS hash"),
        )
    }
}

pub struct SetParametersSrv;

impl ZService for SetParametersSrv {
    type Request = SetParametersRequest;
    type Response = SetParametersResponse;
}

impl ServiceTypeInfo for SetParametersSrv {
    fn service_type_info() -> TypeInfo {
        TypeInfo::new(
            "rcl_interfaces::srv::dds_::SetParameters_",
            TypeHash::from_rihs_string(
                "RIHS01_56eed9a67e169f9cb6c1f987bc88f868c14a8fc9f743a263bc734c154015d7e0",
            )
            .expect("Invalid RIHS hash"),
        )
    }
}

pub struct SetParametersAtomicallySrv;

impl ZService for SetParametersAtomicallySrv {
    type Request = SetParametersAtomicallyRequest;
    type Response = SetParametersAtomicallyResponse;
}

impl ServiceTypeInfo for SetParametersAtomicallySrv {
    fn service_type_info() -> TypeInfo {
        TypeInfo::new(
            "rcl_interfaces::srv::dds_::SetParametersAtomically_",
            TypeHash::from_rihs_string(
                "RIHS01_0e192ef259c07fc3c07a13191d27002222e65e00ccec653ca05e856f79285fcd",
            )
            .expect("Invalid RIHS hash"),
        )
    }
}

// ============================================================================
// ParameterEvent type info (for the publisher)
// ============================================================================

/// Type info for ParameterEvent message (used for the /parameter_events publisher).
pub fn parameter_event_type_info() -> TypeInfo {
    TypeInfo::new(
        "rcl_interfaces::msg::dds_::ParameterEvent_",
        TypeHash::from_rihs_string(
            "RIHS01_043e627780fcad87a22d225bc2a037361dba713fca6a6b9f4b869a5aa0393204",
        )
        .expect("Invalid RIHS hash"),
    )
}

/// Constant for ListParameters: recursively get parameters with unlimited depth.
pub const DEPTH_RECURSIVE: u64 = 0;

// ============================================================================
// ZMessage impls for service request/response types and ParameterEvent
// ============================================================================

impl ZMessage for DescribeParametersRequest {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for DescribeParametersResponse {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for GetParametersRequest {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for GetParametersResponse {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for GetParameterTypesRequest {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for GetParameterTypesResponse {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for ListParametersRequest {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for ListParametersResponse {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for SetParametersRequest {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for SetParametersResponse {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for SetParametersAtomicallyRequest {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for SetParametersAtomicallyResponse {
    type Serdes = SerdeCdrSerdes<Self>;
}
impl ZMessage for WireParameterEvent {
    type Serdes = SerdeCdrSerdes<Self>;
}

// ============================================================================
// Type-description-service schema registration
// ============================================================================
//
// These wire types are hand-written (no `MessageTypeInfo`) and `ParameterService`
// builds its `ZServer`s directly, bypassing `ZNode::create_service`'s
// auto-registration. Without explicit registration here, `discover_service_schema`
// can't resolve the six built-in parameter services every hiroz node exposes.
// Names follow codegen's `{pkg}/msg/{Name}Request`/`Response` convention.

fn floating_point_range_schema()
-> std::result::Result<std::sync::Arc<MessageSchema>, crate::dynamic::DynamicError> {
    MessageSchema::builder("rcl_interfaces/msg/FloatingPointRange")
        .field("from_value", FieldType::Float64)
        .field("to_value", FieldType::Float64)
        .field("step", FieldType::Float64)
        .build()
}

fn integer_range_schema()
-> std::result::Result<std::sync::Arc<MessageSchema>, crate::dynamic::DynamicError> {
    MessageSchema::builder("rcl_interfaces/msg/IntegerRange")
        .field("from_value", FieldType::Int64)
        .field("to_value", FieldType::Int64)
        .field("step", FieldType::Uint64)
        .build()
}

fn parameter_value_schema()
-> std::result::Result<std::sync::Arc<MessageSchema>, crate::dynamic::DynamicError> {
    MessageSchema::builder("rcl_interfaces/msg/ParameterValue")
        .field("type", FieldType::Uint8)
        .field("bool_value", FieldType::Bool)
        .field("integer_value", FieldType::Int64)
        .field("double_value", FieldType::Float64)
        .field("string_value", FieldType::String)
        .field(
            "byte_array_value",
            FieldType::Sequence(Box::new(FieldType::Uint8)),
        )
        .field(
            "bool_array_value",
            FieldType::Sequence(Box::new(FieldType::Bool)),
        )
        .field(
            "integer_array_value",
            FieldType::Sequence(Box::new(FieldType::Int64)),
        )
        .field(
            "double_array_value",
            FieldType::Sequence(Box::new(FieldType::Float64)),
        )
        .field(
            "string_array_value",
            FieldType::Sequence(Box::new(FieldType::String)),
        )
        .build()
}

fn parameter_schema()
-> std::result::Result<std::sync::Arc<MessageSchema>, crate::dynamic::DynamicError> {
    let value = parameter_value_schema()?;
    MessageSchema::builder("rcl_interfaces/msg/Parameter")
        .field("name", FieldType::String)
        .field("value", FieldType::Message(value))
        .build()
}

fn parameter_descriptor_schema()
-> std::result::Result<std::sync::Arc<MessageSchema>, crate::dynamic::DynamicError> {
    let fp_range = floating_point_range_schema()?;
    let int_range = integer_range_schema()?;
    MessageSchema::builder("rcl_interfaces/msg/ParameterDescriptor")
        .field("name", FieldType::String)
        .field("type", FieldType::Uint8)
        .field("description", FieldType::String)
        .field("additional_constraints", FieldType::String)
        .field("read_only", FieldType::Bool)
        .field("dynamic_typing", FieldType::Bool)
        // `[<=1]` in the real message, not unbounded — register as bounded so
        // GetTypeDescription reports the true constraint.
        .field(
            "floating_point_range",
            FieldType::BoundedSequence(Box::new(FieldType::Message(fp_range)), 1),
        )
        .field(
            "integer_range",
            FieldType::BoundedSequence(Box::new(FieldType::Message(int_range)), 1),
        )
        .build()
}

/// Schema for the `rcl_interfaces/msg/ParameterEvent` message that is
/// implicitly published on `/parameter_events` by every parameterized node.
fn parameter_event_schema()
-> std::result::Result<std::sync::Arc<MessageSchema>, crate::dynamic::DynamicError> {
    let parameter = parameter_schema()?;
    let stamp = MessageSchema::builder("builtin_interfaces/msg/Time")
        .field("sec", FieldType::Int32)
        .field("nanosec", FieldType::Uint32)
        .build()?;
    MessageSchema::builder("rcl_interfaces/msg/ParameterEvent")
        .field("stamp", FieldType::Message(stamp))
        .field("node", FieldType::String)
        .field(
            "new_parameters",
            FieldType::Sequence(Box::new(FieldType::Message(parameter.clone()))),
        )
        .field(
            "changed_parameters",
            FieldType::Sequence(Box::new(FieldType::Message(parameter.clone()))),
        )
        .field(
            "deleted_parameters",
            FieldType::Sequence(Box::new(FieldType::Message(parameter))),
        )
        .build()
}

fn set_parameters_result_schema()
-> std::result::Result<std::sync::Arc<MessageSchema>, crate::dynamic::DynamicError> {
    MessageSchema::builder("rcl_interfaces/msg/SetParametersResult")
        .field("successful", FieldType::Bool)
        .field("reason", FieldType::String)
        .build()
}

fn list_parameters_result_schema()
-> std::result::Result<std::sync::Arc<MessageSchema>, crate::dynamic::DynamicError> {
    MessageSchema::builder("rcl_interfaces/msg/ListParametersResult")
        .field("names", FieldType::Sequence(Box::new(FieldType::String)))
        .field("prefixes", FieldType::Sequence(Box::new(FieldType::String)))
        .build()
}

/// Register the request/response schemas for all 6 built-in `rcl_interfaces`
/// parameter services with `tds`, so `ZNode::discover_service_schema` can
/// resolve them for this node.
///
/// Best-effort: build/registration failures are logged and skipped rather than
/// failing node startup (matches `register_schema_with_type_description_service`).
pub(crate) fn register_parameter_schemas(tds: &TypeDescriptionService) {
    let register = |result: std::result::Result<
        std::sync::Arc<MessageSchema>,
        crate::dynamic::DynamicError,
    >| match result {
        Ok(schema) => {
            if let Err(error) = tds.register_schema(schema.clone()) {
                tracing::warn!(
                    "[PARAMS] Failed to register schema {} with type description service: {}",
                    schema.type_name,
                    error
                );
            }
        }
        Err(error) => {
            tracing::warn!(
                "[PARAMS] Failed to build parameter service schema: {}",
                error
            );
        }
    };

    let names_req = |type_name: &str| {
        MessageSchema::builder(type_name)
            .field("names", FieldType::Sequence(Box::new(FieldType::String)))
            .build()
    };

    register(names_req("rcl_interfaces/msg/DescribeParametersRequest"));
    register(parameter_descriptor_schema().and_then(|descriptor| {
        MessageSchema::builder("rcl_interfaces/msg/DescribeParametersResponse")
            .field(
                "descriptors",
                FieldType::Sequence(Box::new(FieldType::Message(descriptor))),
            )
            .build()
    }));

    register(names_req("rcl_interfaces/msg/GetParametersRequest"));
    register(parameter_value_schema().and_then(|value| {
        MessageSchema::builder("rcl_interfaces/msg/GetParametersResponse")
            .field(
                "values",
                FieldType::Sequence(Box::new(FieldType::Message(value))),
            )
            .build()
    }));

    register(names_req("rcl_interfaces/msg/GetParameterTypesRequest"));
    register(
        MessageSchema::builder("rcl_interfaces/msg/GetParameterTypesResponse")
            .field("types", FieldType::Sequence(Box::new(FieldType::Uint8)))
            .build(),
    );

    register(
        MessageSchema::builder("rcl_interfaces/msg/ListParametersRequest")
            .field("prefixes", FieldType::Sequence(Box::new(FieldType::String)))
            .field("depth", FieldType::Uint64)
            .build(),
    );
    register(list_parameters_result_schema().and_then(|result| {
        MessageSchema::builder("rcl_interfaces/msg/ListParametersResponse")
            .field("result", FieldType::Message(result))
            .build()
    }));

    let parameters_req = |type_name: &str| {
        parameter_schema().and_then(|parameter| {
            MessageSchema::builder(type_name)
                .field(
                    "parameters",
                    FieldType::Sequence(Box::new(FieldType::Message(parameter))),
                )
                .build()
        })
    };

    register(parameters_req("rcl_interfaces/msg/SetParametersRequest"));
    register(set_parameters_result_schema().and_then(|result| {
        MessageSchema::builder("rcl_interfaces/msg/SetParametersResponse")
            .field(
                "results",
                FieldType::Sequence(Box::new(FieldType::Message(result))),
            )
            .build()
    }));

    register(parameters_req(
        "rcl_interfaces/msg/SetParametersAtomicallyRequest",
    ));
    register(set_parameters_result_schema().and_then(|result| {
        MessageSchema::builder("rcl_interfaces/msg/SetParametersAtomicallyResponse")
            .field("result", FieldType::Message(result))
            .build()
    }));

    // The implicitly-published `/parameter_events` topic
    // (`rcl_interfaces/msg/ParameterEvent`).
    register(parameter_event_schema());
}