use core::cell::RefCell;
use crate::clusters::generated::identify as spec_identify;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb};
use crate::platform::{Duration, Instant};
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter};
use super::Cluster;
pub use spec_identify::attribute::{IDENTIFY_TIME, IDENTIFY_TYPE};
pub use spec_identify::command::{IDENTIFY, TRIGGER_EFFECT};
pub use spec_identify::{
EffectIdentifierEnum, EffectVariantEnum, ID, IdentifyTypeEnum, PICS, REVISION,
};
pub const TICK: Duration = Duration::from_secs(1);
pub trait IdentifyHooks {
fn identifying(&self, on: bool);
fn trigger_effect(&self, effect: EffectIdentifierEnum, variant: EffectVariantEnum) {
let _ = (effect, variant);
}
}
#[derive(Debug)]
pub struct Identify<'a, H: IdentifyHooks> {
hooks: &'a H,
kind: IdentifyTypeEnum,
state: RefCell<State>,
}
#[derive(Debug, Clone, Copy)]
struct State {
remaining: u16,
next_tick: Option<Instant>,
}
impl<'a, H: IdentifyHooks> Identify<'a, H> {
#[must_use]
pub const fn new(hooks: &'a H, kind: IdentifyTypeEnum) -> Self {
Self {
hooks,
kind,
state: RefCell::new(State {
remaining: 0,
next_tick: None,
}),
}
}
pub fn conforming(optional: &Optional<'_>) -> crate::error::Result<Conforming<2, 2, 0, 0>> {
Conforming::new(&spec_identify::CLUSTER, 0, optional)
}
pub const WITH_TRIGGER_EFFECT: Optional<'static> = Optional {
attributes: &[],
commands: &[TRIGGER_EFFECT],
events: &[],
};
#[must_use]
pub fn remaining(&self) -> u16 {
self.state.borrow().remaining
}
#[must_use]
pub fn is_identifying(&self) -> bool {
self.remaining() > 0
}
#[must_use]
pub const fn kind(&self) -> IdentifyTypeEnum {
self.kind
}
pub fn set_time(&self, seconds: u16, now: Instant) {
let transition = {
let mut state = self.state.borrow_mut();
let was = state.remaining > 0;
state.remaining = seconds;
state.next_tick = (seconds > 0).then(|| now.saturating_add(TICK));
let is = seconds > 0;
(was != is).then_some(is)
};
if let Some(on) = transition {
self.hooks.identifying(on);
}
}
#[must_use]
pub fn wake_at(&self) -> Option<Instant> {
self.state.borrow().next_tick
}
pub fn poll(&self, now: Instant) {
let stopped = {
let mut state = self.state.borrow_mut();
let Some(mut due) = state.next_tick else {
return;
};
let mut ticks = 0u32;
while now >= due && state.remaining > 0 && ticks < MAX_CATCH_UP {
ticks = ticks.saturating_add(1);
due = due.saturating_add(TICK);
state.remaining = state.remaining.saturating_sub(1);
}
if state.remaining == 0 {
state.next_tick = None;
true
} else {
state.next_tick = Some(due);
false
}
};
if stopped {
self.hooks.identifying(false);
}
}
}
const MAX_CATCH_UP: u32 = 3600;
impl<H: IdentifyHooks> ClusterHandler for Identify<'_, H> {
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
match resolved.attribute {
IDENTIFY_TIME => full(w.unsigned(tag, u64::from(self.remaining()))),
IDENTIFY_TYPE => full(w.unsigned(tag, u64::from(self.kind.value()))),
_ => Err(Status::UnsupportedAttribute),
}
}
fn write(
&self,
resolved: &Resolved<'_>,
data: &[u8],
_op: crate::im::WriteOp,
ctx: &InteractionContext<'_>,
) -> Result<(), Status> {
if resolved.attribute != IDENTIFY_TIME {
return Err(Status::UnsupportedWrite);
}
let mut reader = TlvReader::new_in(data, ContainerKind::Structure);
let element = reader
.next_element()
.map_err(|_| Status::InvalidAction)?
.ok_or(Status::InvalidAction)?;
let seconds = u16::try_from(element.unsigned().map_err(|_| Status::ConstraintError)?)
.map_err(|_| Status::ConstraintError)?;
self.set_time(seconds, ctx.now);
Ok(())
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
let fields = fields.ok_or(StatusIb::from(Status::InvalidCommand))?;
match resolved.command.id {
IDENTIFY => {
let decoded: spec_identify::IdentifyFields = super::decode_fields(fields)?;
self.set_time(decoded.identify_time, ctx.now);
Ok(None)
}
TRIGGER_EFFECT => {
let decoded: spec_identify::TriggerEffectFields = super::decode_fields(fields)?;
self.hooks
.trigger_effect(decoded.effect_identifier, decoded.effect_variant);
Ok(None)
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<H: IdentifyHooks> crate::clusters::groups::Identifying for Identify<'_, H> {
fn is_identifying(&self) -> bool {
Self::is_identifying(self)
}
}
impl<H: IdentifyHooks> Cluster for Identify<'_, H> {
const ID: ClusterId = ID;
}