rustbac_client/

intrinsic.rs

//! Server-side intrinsic reporting engine.
//!
//! Implements ASHRAE 135 Clause 13 intrinsic reporting algorithms
//! for BACnet server objects. The engine evaluates property changes
//! against configured alarm conditions and generates event notifications.

use rustbac_core::types::{ObjectId, PropertyId};
use std::collections::HashMap;
use std::sync::RwLock;
use std::time::Instant;

/// BACnet event states for intrinsic reporting.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IntrinsicEventState {
    Normal,
    Fault,
    OffNormal,
    HighLimit,
    LowLimit,
}

impl IntrinsicEventState {
    /// Convert to the BACnet enumerated value.
    pub fn to_u32(self) -> u32 {
        match self {
            Self::Normal => 0,
            Self::Fault => 1,
            Self::OffNormal => 2,
            Self::HighLimit => 3,
            Self::LowLimit => 4,
        }
    }
}

/// Tracks which event-state transitions have been acknowledged.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AckedTransitions {
    pub to_offnormal: bool,
    pub to_fault: bool,
    pub to_normal: bool,
}

impl Default for AckedTransitions {
    fn default() -> Self {
        Self {
            to_offnormal: true,
            to_fault: true,
            to_normal: true,
        }
    }
}

/// Intrinsic reporting algorithm configuration.
#[derive(Debug, Clone)]
pub enum IntrinsicAlgorithm {
    /// CHANGE_OF_VALUE — fires when value changes by more than `cov_increment`.
    ChangeOfValue {
        cov_increment: f64,
    },
    /// OUT_OF_RANGE — fires when value exceeds high/low limits with deadband.
    OutOfRange {
        high_limit: f64,
        low_limit: f64,
        deadband: f64,
    },
    /// CHANGE_OF_STATE — fires when enumerated value matches an alarm value.
    ChangeOfState {
        alarm_values: Vec<u32>,
    },
    /// FLOATING_LIMIT — fires when value deviates from a setpoint by more than diff limits.
    FloatingLimit {
        setpoint_ref: ObjectId,
        setpoint_property: PropertyId,
        high_diff_limit: f64,
        low_diff_limit: f64,
        deadband: f64,
    },
    /// COMMAND_FAILURE — fires when feedback doesn't match command after time delay.
    CommandFailure {
        feedback_ref: ObjectId,
        feedback_property: PropertyId,
        time_delay_ms: u64,
    },
}

/// Internal state for a single enrolled object.
#[derive(Debug)]
struct IntrinsicState {
    object_id: ObjectId,
    algorithm: IntrinsicAlgorithm,
    current_event_state: IntrinsicEventState,
    acked_transitions: AckedTransitions,
    notification_class: u32,
    time_delay_ms: u64,
    /// When a pending transition was first detected (for time-delay).
    pending_since: Option<Instant>,
    /// The pending event state (waiting for time delay to elapse).
    pending_state: Option<IntrinsicEventState>,
    /// Last reported value (for COV algorithm).
    last_reported_value: Option<f64>,
}

/// A pending event notification generated by the engine.
#[derive(Debug, Clone)]
pub struct PendingEventNotification {
    /// The object that generated the event.
    pub object_id: ObjectId,
    /// The notification class for routing.
    pub notification_class: u32,
    /// The event state that triggered the notification.
    pub event_state: IntrinsicEventState,
    /// The previous event state.
    pub from_state: IntrinsicEventState,
    /// The property that was evaluated.
    pub property_id: PropertyId,
    /// The value that triggered the event (if applicable).
    pub value: Option<f64>,
}

/// Configuration for enrolling an object in intrinsic reporting.
pub struct IntrinsicEnrollment {
    pub object_id: ObjectId,
    pub algorithm: IntrinsicAlgorithm,
    pub notification_class: u32,
    pub time_delay_ms: u64,
}

/// Intrinsic reporting engine that evaluates property changes
/// against configured alarm conditions.
pub struct IntrinsicReportingEngine {
    states: RwLock<HashMap<ObjectId, IntrinsicState>>,
}

impl IntrinsicReportingEngine {
    /// Create a new empty engine.
    pub fn new() -> Self {
        Self {
            states: RwLock::new(HashMap::new()),
        }
    }

    /// Enroll an object for intrinsic reporting.
    pub fn enroll(&self, enrollment: IntrinsicEnrollment) {
        let state = IntrinsicState {
            object_id: enrollment.object_id,
            algorithm: enrollment.algorithm,
            current_event_state: IntrinsicEventState::Normal,
            acked_transitions: AckedTransitions::default(),
            notification_class: enrollment.notification_class,
            time_delay_ms: enrollment.time_delay_ms,
            pending_since: None,
            pending_state: None,
            last_reported_value: None,
        };
        self.states
            .write()
            .expect("IntrinsicReportingEngine lock")
            .insert(enrollment.object_id, state);
    }

    /// Remove an object from intrinsic reporting.
    pub fn unenroll(&self, object_id: ObjectId) {
        self.states
            .write()
            .expect("IntrinsicReportingEngine lock")
            .remove(&object_id);
    }

    /// Evaluate a property change and return any pending notifications.
    ///
    /// Call this whenever a monitored property value changes.
    /// The `setpoint_value` parameter is only needed for FloatingLimit;
    /// pass `None` otherwise.
    /// The `feedback_value` parameter is only needed for CommandFailure;
    /// pass `None` otherwise.
    pub fn evaluate(
        &self,
        object_id: ObjectId,
        property_id: PropertyId,
        value: f64,
        setpoint_value: Option<f64>,
        feedback_value: Option<f64>,
    ) -> Vec<PendingEventNotification> {
        let mut states = self
            .states
            .write()
            .expect("IntrinsicReportingEngine lock");

        let state = match states.get_mut(&object_id) {
            Some(s) => s,
            None => return Vec::new(),
        };

        let now = Instant::now();
        let mut notifications = Vec::new();

        // COV is special: it fires notifications without changing event state.
        if let IntrinsicAlgorithm::ChangeOfValue { cov_increment } = &state.algorithm {
            let should_fire = match state.last_reported_value {
                Some(last) => (value - last).abs() > *cov_increment,
                None => true, // First evaluation always fires.
            };
            if should_fire {
                state.last_reported_value = Some(value);
                notifications.push(PendingEventNotification {
                    object_id,
                    notification_class: state.notification_class,
                    event_state: state.current_event_state,
                    from_state: state.current_event_state,
                    property_id,
                    value: Some(value),
                });
            }
            return notifications;
        }

        let new_state = match &state.algorithm {
            IntrinsicAlgorithm::OutOfRange {
                high_limit,
                low_limit,
                deadband,
            } => evaluate_out_of_range(
                value,
                *high_limit,
                *low_limit,
                *deadband,
                state.current_event_state,
            ),
            IntrinsicAlgorithm::ChangeOfValue { .. } => unreachable!(),
            IntrinsicAlgorithm::ChangeOfState { alarm_values } => {
                evaluate_change_of_state(value as u32, alarm_values)
            }
            IntrinsicAlgorithm::FloatingLimit {
                high_diff_limit,
                low_diff_limit,
                deadband,
                ..
            } => {
                let setpoint = setpoint_value.unwrap_or(0.0);
                evaluate_floating_limit(
                    value,
                    setpoint,
                    *high_diff_limit,
                    *low_diff_limit,
                    *deadband,
                    state.current_event_state,
                )
            }
            IntrinsicAlgorithm::CommandFailure { time_delay_ms, .. } => {
                let feedback = feedback_value.unwrap_or(value);
                evaluate_command_failure(value, feedback, *time_delay_ms, state, now)
            }
        };

        if new_state != state.current_event_state {
            // Check time delay.
            if state.time_delay_ms == 0 {
                // Immediate transition.
                let from = state.current_event_state;
                state.current_event_state = new_state;
                state.pending_since = None;
                state.pending_state = None;

                // Update acked_transitions.
                match new_state {
                    IntrinsicEventState::Normal => {
                        state.acked_transitions.to_normal = false;
                    }
                    IntrinsicEventState::OffNormal
                    | IntrinsicEventState::HighLimit
                    | IntrinsicEventState::LowLimit => {
                        state.acked_transitions.to_offnormal = false;
                    }
                    IntrinsicEventState::Fault => {
                        state.acked_transitions.to_fault = false;
                    }
                }

                if let IntrinsicAlgorithm::ChangeOfValue { .. } = &state.algorithm {
                    state.last_reported_value = Some(value);
                }

                notifications.push(PendingEventNotification {
                    object_id,
                    notification_class: state.notification_class,
                    event_state: new_state,
                    from_state: from,
                    property_id,
                    value: Some(value),
                });
            } else {
                // Time delay pending.
                match state.pending_state {
                    Some(pending) if pending == new_state => {
                        // Same pending state — check if delay elapsed.
                        if let Some(since) = state.pending_since {
                            if now.duration_since(since).as_millis() as u64 >= state.time_delay_ms {
                                let from = state.current_event_state;
                                state.current_event_state = new_state;
                                state.pending_since = None;
                                state.pending_state = None;

                                match new_state {
                                    IntrinsicEventState::Normal => {
                                        state.acked_transitions.to_normal = false;
                                    }
                                    IntrinsicEventState::OffNormal
                                    | IntrinsicEventState::HighLimit
                                    | IntrinsicEventState::LowLimit => {
                                        state.acked_transitions.to_offnormal = false;
                                    }
                                    IntrinsicEventState::Fault => {
                                        state.acked_transitions.to_fault = false;
                                    }
                                }

                                if let IntrinsicAlgorithm::ChangeOfValue { .. } = &state.algorithm {
                                    state.last_reported_value = Some(value);
                                }

                                notifications.push(PendingEventNotification {
                                    object_id,
                                    notification_class: state.notification_class,
                                    event_state: new_state,
                                    from_state: from,
                                    property_id,
                                    value: Some(value),
                                });
                            }
                        }
                    }
                    _ => {
                        // New pending state — start delay timer.
                        state.pending_since = Some(now);
                        state.pending_state = Some(new_state);
                    }
                }
            }
        } else {
            // Value returned to current state — cancel any pending transition.
            state.pending_since = None;
            state.pending_state = None;
        }

        notifications
    }

    /// Acknowledge a transition for an enrolled object.
    pub fn acknowledge(
        &self,
        object_id: ObjectId,
        event_state: IntrinsicEventState,
    ) -> bool {
        let mut states = self
            .states
            .write()
            .expect("IntrinsicReportingEngine lock");
        if let Some(state) = states.get_mut(&object_id) {
            match event_state {
                IntrinsicEventState::Normal => {
                    state.acked_transitions.to_normal = true;
                }
                IntrinsicEventState::OffNormal
                | IntrinsicEventState::HighLimit
                | IntrinsicEventState::LowLimit => {
                    state.acked_transitions.to_offnormal = true;
                }
                IntrinsicEventState::Fault => {
                    state.acked_transitions.to_fault = true;
                }
            }
            true
        } else {
            false
        }
    }

    /// Get the current event state for an enrolled object.
    pub fn event_state(&self, object_id: ObjectId) -> Option<IntrinsicEventState> {
        self.states
            .read()
            .expect("IntrinsicReportingEngine lock")
            .get(&object_id)
            .map(|s| s.current_event_state)
    }

    /// Get the acked transitions for an enrolled object.
    pub fn acked_transitions(&self, object_id: ObjectId) -> Option<AckedTransitions> {
        self.states
            .read()
            .expect("IntrinsicReportingEngine lock")
            .get(&object_id)
            .map(|s| s.acked_transitions)
    }
}

impl Default for IntrinsicReportingEngine {
    fn default() -> Self {
        Self::new()
    }
}

// ─────────────────────────────────────────────────────────────────────────────
// Algorithm implementations
// ─────────────────────────────────────────────────────────────────────────────

fn evaluate_out_of_range(
    value: f64,
    high_limit: f64,
    low_limit: f64,
    deadband: f64,
    current_state: IntrinsicEventState,
) -> IntrinsicEventState {
    match current_state {
        IntrinsicEventState::Normal => {
            if value > high_limit {
                IntrinsicEventState::HighLimit
            } else if value < low_limit {
                IntrinsicEventState::LowLimit
            } else {
                IntrinsicEventState::Normal
            }
        }
        IntrinsicEventState::HighLimit => {
            if value < low_limit {
                IntrinsicEventState::LowLimit
            } else if value <= high_limit - deadband {
                IntrinsicEventState::Normal
            } else {
                IntrinsicEventState::HighLimit
            }
        }
        IntrinsicEventState::LowLimit => {
            if value > high_limit {
                IntrinsicEventState::HighLimit
            } else if value >= low_limit + deadband {
                IntrinsicEventState::Normal
            } else {
                IntrinsicEventState::LowLimit
            }
        }
        _ => {
            // From Fault or OffNormal, re-evaluate fresh.
            if value > high_limit {
                IntrinsicEventState::HighLimit
            } else if value < low_limit {
                IntrinsicEventState::LowLimit
            } else {
                IntrinsicEventState::Normal
            }
        }
    }
}

fn evaluate_change_of_state(value: u32, alarm_values: &[u32]) -> IntrinsicEventState {
    if alarm_values.contains(&value) {
        IntrinsicEventState::OffNormal
    } else {
        IntrinsicEventState::Normal
    }
}

fn evaluate_floating_limit(
    value: f64,
    setpoint: f64,
    high_diff_limit: f64,
    low_diff_limit: f64,
    deadband: f64,
    current_state: IntrinsicEventState,
) -> IntrinsicEventState {
    let high_threshold = setpoint + high_diff_limit;
    let low_threshold = setpoint - low_diff_limit;

    match current_state {
        IntrinsicEventState::Normal => {
            if value > high_threshold {
                IntrinsicEventState::HighLimit
            } else if value < low_threshold {
                IntrinsicEventState::LowLimit
            } else {
                IntrinsicEventState::Normal
            }
        }
        IntrinsicEventState::HighLimit => {
            if value < low_threshold {
                IntrinsicEventState::LowLimit
            } else if value <= high_threshold - deadband {
                IntrinsicEventState::Normal
            } else {
                IntrinsicEventState::HighLimit
            }
        }
        IntrinsicEventState::LowLimit => {
            if value > high_threshold {
                IntrinsicEventState::HighLimit
            } else if value >= low_threshold + deadband {
                IntrinsicEventState::Normal
            } else {
                IntrinsicEventState::LowLimit
            }
        }
        _ => {
            if value > high_threshold {
                IntrinsicEventState::HighLimit
            } else if value < low_threshold {
                IntrinsicEventState::LowLimit
            } else {
                IntrinsicEventState::Normal
            }
        }
    }
}

fn evaluate_command_failure(
    command_value: f64,
    feedback_value: f64,
    _time_delay_ms: u64,
    _state: &IntrinsicState,
    _now: Instant,
) -> IntrinsicEventState {
    // Simple comparison: if feedback doesn't match command, it's OffNormal.
    // Time delay is handled by the outer evaluate() method.
    if (command_value - feedback_value).abs() > f64::EPSILON {
        IntrinsicEventState::OffNormal
    } else {
        IntrinsicEventState::Normal
    }
}

/// Encode an UnconfirmedEventNotification PDU.
///
/// Returns the encoded bytes or `None` if the buffer is too small.
pub fn encode_unconfirmed_event_notification(
    process_id: u32,
    initiating_device_id: ObjectId,
    event_object_id: ObjectId,
    event_state: IntrinsicEventState,
    notification_class: u32,
    from_state: IntrinsicEventState,
) -> Option<Vec<u8>> {
    use rustbac_core::apdu::UnconfirmedRequestHeader;
    use rustbac_core::encoding::primitives::encode_ctx_unsigned;
    use rustbac_core::encoding::writer::Writer;
    use rustbac_core::npdu::Npdu;

    let mut buf = [0u8; 1400];
    let mut w = Writer::new(&mut buf);

    Npdu::new(0).encode(&mut w).ok()?;

    // UnconfirmedEventNotification service choice = 0x03
    UnconfirmedRequestHeader {
        service_choice: 0x03,
    }
    .encode(&mut w)
    .ok()?;

    // [0] process-identifier
    encode_ctx_unsigned(&mut w, 0, process_id).ok()?;
    // [1] initiating-device-identifier
    encode_ctx_unsigned(&mut w, 1, initiating_device_id.raw()).ok()?;
    // [2] event-object-identifier
    encode_ctx_unsigned(&mut w, 2, event_object_id.raw()).ok()?;
    // [4] notification-class
    encode_ctx_unsigned(&mut w, 4, notification_class).ok()?;
    // [9] event-type — 0 = change-of-bitstring (placeholder; actual type depends on algorithm)
    encode_ctx_unsigned(&mut w, 9, 0).ok()?;
    // [11] to-state
    encode_ctx_unsigned(&mut w, 11, event_state.to_u32()).ok()?;

    Some(w.as_written().to_vec())
}

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

    fn av(instance: u32) -> ObjectId {
        ObjectId::new(ObjectType::AnalogValue, instance)
    }

    #[test]
    fn out_of_range_high_limit() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::OutOfRange {
                high_limit: 100.0,
                low_limit: 0.0,
                deadband: 5.0,
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        // Normal → HighLimit
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 105.0, None, None);
        assert_eq!(notifs.len(), 1);
        assert_eq!(notifs[0].event_state, IntrinsicEventState::HighLimit);
        assert_eq!(notifs[0].from_state, IntrinsicEventState::Normal);
    }

    #[test]
    fn out_of_range_deadband_hysteresis() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::OutOfRange {
                high_limit: 100.0,
                low_limit: 0.0,
                deadband: 5.0,
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        // Go to HighLimit
        engine.evaluate(av(1), PropertyId::PresentValue, 105.0, None, None);

        // Still HighLimit (within deadband: 100 - 5 = 95, value is 97)
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 97.0, None, None);
        assert!(notifs.is_empty());

        // Back to Normal (below deadband threshold: 94 < 95)
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 94.0, None, None);
        assert_eq!(notifs.len(), 1);
        assert_eq!(notifs[0].event_state, IntrinsicEventState::Normal);
    }

    #[test]
    fn out_of_range_low_limit() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::OutOfRange {
                high_limit: 100.0,
                low_limit: 10.0,
                deadband: 2.0,
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 5.0, None, None);
        assert_eq!(notifs.len(), 1);
        assert_eq!(notifs[0].event_state, IntrinsicEventState::LowLimit);
    }

    #[test]
    fn change_of_value_fires_on_increment() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::ChangeOfValue {
                cov_increment: 1.0,
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        // First evaluation always fires (no last reported value).
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 50.0, None, None);
        assert_eq!(notifs.len(), 1);

        // Small change — no notification.
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 50.5, None, None);
        assert!(notifs.is_empty());

        // Large change — notification.
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 52.0, None, None);
        assert_eq!(notifs.len(), 1);
    }

    #[test]
    fn change_of_state_alarm() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::ChangeOfState {
                alarm_values: vec![3, 5],
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        // Normal value
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 1.0, None, None);
        assert!(notifs.is_empty());

        // Alarm value
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 3.0, None, None);
        assert_eq!(notifs.len(), 1);
        assert_eq!(notifs[0].event_state, IntrinsicEventState::OffNormal);
    }

    #[test]
    fn floating_limit() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::FloatingLimit {
                setpoint_ref: av(2),
                setpoint_property: PropertyId::PresentValue,
                high_diff_limit: 5.0,
                low_diff_limit: 5.0,
                deadband: 2.0,
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        // Setpoint = 50, value = 56 > 50 + 5 = 55 → HighLimit
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 56.0, Some(50.0), None);
        assert_eq!(notifs.len(), 1);
        assert_eq!(notifs[0].event_state, IntrinsicEventState::HighLimit);
    }

    #[test]
    fn command_failure() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::CommandFailure {
                feedback_ref: av(2),
                feedback_property: PropertyId::PresentValue,
                time_delay_ms: 0,
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        // Command=50, Feedback=50 → Normal
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 50.0, None, Some(50.0));
        assert!(notifs.is_empty());

        // Command=50, Feedback=30 → OffNormal
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 50.0, None, Some(30.0));
        assert_eq!(notifs.len(), 1);
        assert_eq!(notifs[0].event_state, IntrinsicEventState::OffNormal);
    }

    #[test]
    fn time_delay_pending() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::OutOfRange {
                high_limit: 100.0,
                low_limit: 0.0,
                deadband: 5.0,
            },
            notification_class: 1,
            time_delay_ms: 10000, // 10 seconds
        });

        // Value exceeds limit but time delay hasn't elapsed.
        let notifs = engine.evaluate(av(1), PropertyId::PresentValue, 105.0, None, None);
        assert!(notifs.is_empty(), "should not fire before time delay");

        // State should still be Normal.
        assert_eq!(
            engine.event_state(av(1)),
            Some(IntrinsicEventState::Normal)
        );
    }

    #[test]
    fn acknowledge_transition() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::OutOfRange {
                high_limit: 100.0,
                low_limit: 0.0,
                deadband: 5.0,
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        engine.evaluate(av(1), PropertyId::PresentValue, 105.0, None, None);

        let acked = engine.acked_transitions(av(1)).unwrap();
        assert!(!acked.to_offnormal);

        engine.acknowledge(av(1), IntrinsicEventState::HighLimit);

        let acked = engine.acked_transitions(av(1)).unwrap();
        assert!(acked.to_offnormal);
    }

    #[test]
    fn enroll_unenroll() {
        let engine = IntrinsicReportingEngine::new();
        engine.enroll(IntrinsicEnrollment {
            object_id: av(1),
            algorithm: IntrinsicAlgorithm::OutOfRange {
                high_limit: 100.0,
                low_limit: 0.0,
                deadband: 5.0,
            },
            notification_class: 1,
            time_delay_ms: 0,
        });

        assert!(engine.event_state(av(1)).is_some());
        engine.unenroll(av(1));
        assert!(engine.event_state(av(1)).is_none());
    }

    #[test]
    fn encode_event_notification_produces_bytes() {
        let result = encode_unconfirmed_event_notification(
            1,
            ObjectId::new(ObjectType::Device, 42),
            av(1),
            IntrinsicEventState::HighLimit,
            1,
            IntrinsicEventState::Normal,
        );
        assert!(result.is_some());
        assert!(result.unwrap().len() > 10);
    }
}