use crate::NodeId;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use zwave_security::SecurityClass;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum InterviewStage {
#[default]
New,
ProtocolInfo,
NodeInfo,
Security,
Identity,
Versions,
Endpoints,
CommandClasses,
Complete,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum NodeStatus {
#[default]
Unknown,
Alive,
Awake,
Asleep,
Dead,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct ProtocolInfo {
pub listening: bool,
pub flirs: bool,
pub routing: bool,
pub controller: bool,
pub basic: u8,
pub generic: u8,
pub specific: u8,
}
impl ProtocolInfo {
pub fn sleeping(&self) -> bool {
!self.listening && !self.flirs
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct CcSupport {
pub version: u8,
pub secure: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct Capabilities {
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub sensors: BTreeMap<u8, Vec<u8>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meter: Option<(u8, Vec<u8>)>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub notifications: BTreeMap<u8, Vec<u8>>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub binary_sensors: Vec<u8>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub switch_type: Option<u8>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct Endpoint {
#[serde(default)]
pub generic: u8,
#[serde(default)]
pub specific: u8,
#[serde(default)]
pub ccs: BTreeMap<u16, CcSupport>,
#[serde(default)]
pub caps: Capabilities,
}
impl Endpoint {
pub fn supports(&self, cc: u16) -> bool {
self.ccs.contains_key(&cc)
}
pub fn version(&self, cc: u16) -> u8 {
self.ccs.get(&cc).map(|c| c.version.max(1)).unwrap_or(0)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct Manufacturer {
pub manufacturer_id: u16,
pub product_type: u16,
pub product_id: u16,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct NodeRecord {
pub id: NodeId,
#[serde(default)]
pub protocol: ProtocolInfo,
#[serde(default)]
pub stage: InterviewStage,
#[serde(default)]
pub security: Vec<SecurityClass>,
#[serde(default)]
pub secure_ccs_known: bool,
#[serde(default)]
pub manufacturer: Option<Manufacturer>,
#[serde(default)]
pub firmware: Option<String>,
#[serde(default)]
pub zwave_plus: Option<(u8, u8, u16, u16)>,
#[serde(default)]
pub endpoints: BTreeMap<u8, Endpoint>,
#[serde(default)]
pub wake_up_interval: Option<u32>,
#[serde(default)]
pub neighbors: Vec<NodeId>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub location: Option<String>,
#[serde(default)]
pub dsk: Option<String>,
}
impl NodeRecord {
pub fn new(id: NodeId) -> Self {
let mut r = NodeRecord {
id,
..Default::default()
};
r.endpoints.insert(0, Endpoint::default());
r
}
pub fn root(&self) -> &Endpoint {
static EMPTY: std::sync::OnceLock<Endpoint> = std::sync::OnceLock::new();
self.endpoints
.get(&0)
.unwrap_or_else(|| EMPTY.get_or_init(Endpoint::default))
}
pub fn root_mut(&mut self) -> &mut Endpoint {
self.endpoints.entry(0).or_default()
}
pub fn highest_s2(&self) -> Option<SecurityClass> {
self.security.iter().copied().filter(|c| c.is_s2()).max()
}
pub fn s0_only(&self) -> bool {
self.highest_s2().is_none() && self.security.contains(&SecurityClass::S0Legacy)
}
pub fn needs_security(&self, endpoint: u8, cc: u16) -> bool {
if self.security.is_empty() {
return false;
}
if matches!(cc, 0x98 | 0x9f) {
return false;
}
match self.endpoints.get(&endpoint).and_then(|e| e.ccs.get(&cc)) {
Some(s) => s.secure || !self.secure_ccs_known,
None => !self.secure_ccs_known || endpoint != 0,
}
}
}