use serde::Serialize;
use super::scene::Scene;
use crate::error::{Error, Result};
macro_rules! bounded_newtype {
(
$(#[$attr:meta])*
$name:ident($repr:ty), $wire:literal, $min:literal ..= $max:literal
) => {
$(#[$attr])*
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
pub struct $name($repr);
impl $name {
pub const MIN: $repr = $min;
pub const MAX: $repr = $max;
#[doc = concat!("Builds a `", $wire, "` value.")]
#[doc = concat!("`", stringify!($min), "..=", stringify!($max), "`.")]
pub fn new(value: $repr) -> Result<Self> {
if (Self::MIN..=Self::MAX).contains(&value) {
Ok(Self(value))
} else {
Err(Error::InvalidParam {
message: format!(
concat!($wire, " must be {}..={}, got {}"),
Self::MIN,
Self::MAX,
value,
),
})
}
}
#[must_use]
pub const fn get(self) -> $repr {
self.0
}
}
impl From<$name> for $repr {
fn from(value: $name) -> Self {
value.0
}
}
};
}
macro_rules! open_newtype {
($(#[$attr:meta])* $name:ident($repr:ty)) => {
$(#[$attr])*
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
pub struct $name($repr);
impl $name {
#[doc = concat!("`", stringify!($repr), "`")]
#[must_use]
pub const fn new(value: $repr) -> Self {
Self(value)
}
#[must_use]
pub const fn get(self) -> $repr {
self.0
}
}
impl From<$repr> for $name {
fn from(value: $repr) -> Self {
Self(value)
}
}
impl From<$name> for $repr {
fn from(value: $name) -> Self {
value.0
}
}
};
}
open_newtype! {
Channel(u8)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
pub struct SceneId(u16);
pub const PULSE_SCENE_ID: u16 = 248;
const USER_SLOTS: std::ops::RangeInclusive<u16> = 256..=265;
impl SceneId {
pub fn new(value: u16) -> Result<Self> {
if Scene::from_id(value).is_some() || USER_SLOTS.contains(&value) {
return Ok(Self(value));
}
let detail = match value {
37 => " — writing 37 leaves scene mode and sets a 2200 K colour \
temperature, so send `temp: 2200` if that is what you meant"
.to_owned(),
41 => " — 41 plays a white of about 6200 K at roughly a third of \
normal brightness, and no `dimming` recovers the rest, so \
send `temp: 6200` instead"
.to_owned(),
PULSE_SCENE_ID => " — 248 is the internal slot reported by `getPilot` \
while `pulse` is running; writing it via `setPilot` clamps it \
to 41, so call `Bulb::pulse` instead"
.to_owned(),
42..=247 => {
format!(
" — the bulb accepts {value} and silently clamps it to 41, which is \
itself refused here"
)
}
_ => String::new(),
};
Err(Error::UnknownScene {
message: format!(
"{value} is not a scene worth sending: ids run 1..=36 and 38..=40{detail}"
),
})
}
pub fn user_slot(slot: u8) -> Result<Self> {
if (1..=10).contains(&slot) {
Ok(Self(255 + u16::from(slot)))
} else {
Err(Error::UnknownScene {
message: format!("there are ten user slots, 1..=10, and {slot} is not one"),
})
}
}
pub(super) const fn new_unchecked(value: u16) -> Self {
Self(value)
}
#[must_use]
pub const fn get(self) -> u16 {
self.0
}
#[must_use]
pub fn scene(self) -> Option<Scene> {
Scene::from_id(self.0)
}
#[must_use]
pub fn as_user_slot(self) -> Option<u8> {
USER_SLOTS.contains(&self.0).then(|| (self.0 - 255) as u8)
}
#[must_use]
pub fn takes_speed(self) -> bool {
self.scene().is_none_or(|scene| scene.adjustable().speed)
}
}
impl TryFrom<u16> for SceneId {
type Error = Error;
fn try_from(value: u16) -> Result<Self> {
Self::new(value)
}
}
impl From<SceneId> for u16 {
fn from(value: SceneId) -> Self {
value.0
}
}
bounded_newtype! {
Dimming(u8), "dimming", 1..=100
}
bounded_newtype! {
Speed(u8), "speed", 10..=200
}
bounded_newtype! {
Kelvin(u16), "temp", 1000..=12_000
}
bounded_newtype! {
Ratio(u8), "ratio", 0..=100
}
bounded_newtype! {
Devices(u8), "devices", 1..=3
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
pub struct PulseDelta(i32);
impl PulseDelta {
pub const MIN: i32 = -100;
pub const MAX: i32 = 100;
pub fn new(value: i32) -> Result<Self> {
if value != 0 && (Self::MIN..=Self::MAX).contains(&value) {
Ok(Self(value))
} else {
Err(Error::InvalidParam {
message: format!("delta must be in -100..=-1 or 1..=100 (non-zero), got {value}"),
})
}
}
#[must_use]
pub const fn get(self) -> i32 {
self.0
}
}
impl From<PulseDelta> for i32 {
fn from(value: PulseDelta) -> Self {
value.0
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dimming_rejects_zero_and_over_100() {
assert!(Dimming::new(0).is_err());
assert!(Dimming::new(101).is_err());
assert_eq!(Dimming::new(1).unwrap().get(), 1);
assert_eq!(Dimming::new(100).unwrap().get(), 100);
}
#[test]
fn the_measured_edges_are_the_enforced_edges() {
assert!(Speed::new(9).is_err());
assert_eq!(Speed::new(10).unwrap().get(), 10);
assert_eq!(Speed::new(200).unwrap().get(), 200);
assert!(Speed::new(201).is_err());
assert!(Kelvin::new(999).is_err());
assert_eq!(Kelvin::new(1000).unwrap().get(), 1000);
assert_eq!(Kelvin::new(2700).unwrap().get(), 2700);
assert_eq!(Kelvin::new(10_001).unwrap().get(), 10_001);
assert_eq!(Kelvin::new(12_000).unwrap().get(), 12_000);
assert!(Kelvin::new(12_001).is_err());
assert_eq!(Ratio::new(0).unwrap().get(), 0);
assert_eq!(Ratio::new(100).unwrap().get(), 100);
assert!(Ratio::new(101).is_err());
assert!(Devices::new(0).is_err());
assert_eq!(Devices::new(1).unwrap().get(), 1);
assert_eq!(Devices::new(3).unwrap().get(), 3);
assert!(Devices::new(4).is_err());
}
#[test]
fn every_channel_value_is_a_valid_one() {
assert_eq!(Channel::new(0).get(), 0);
assert_eq!(Channel::new(255).get(), 255);
assert_eq!(Channel::from(12u8).get(), 12);
}
#[test]
fn a_scene_id_has_to_be_one_the_bulb_plays() {
assert_eq!(SceneId::new(4).unwrap().get(), 4);
assert_eq!(u16::from(SceneId::try_from(40).unwrap()), 40);
let deep_dive = SceneId::new(23).unwrap().scene().expect("23 is a scene");
assert_eq!(deep_dive.name(), "Deep dive");
for id in [0, 249, 255, 266, 1000] {
assert!(SceneId::new(id).is_err(), "{id}");
}
let message = SceneId::new(37).unwrap_err().to_string();
assert!(message.contains("2200 K"), "{message}");
let message = SceneId::new(41).unwrap_err().to_string();
assert!(message.contains("6200 K"), "{message}");
assert!(message.contains("a third"), "{message}");
let message = SceneId::new(100).unwrap_err().to_string();
assert!(message.contains("clamps it to 41"), "{message}");
}
#[test]
fn the_user_slots_are_addressable() {
for (slot, id) in [(1u8, 256u16), (2, 257), (10, 265)] {
let scene_id = SceneId::user_slot(slot).unwrap();
assert_eq!(scene_id.get(), id);
assert_eq!(scene_id.as_user_slot(), Some(slot));
assert_eq!(scene_id.scene(), None);
assert!(scene_id.takes_speed());
assert_eq!(SceneId::new(id).unwrap(), scene_id);
}
assert!(SceneId::user_slot(0).is_err());
assert!(SceneId::user_slot(11).is_err());
assert_eq!(SceneId::new(4).unwrap().as_user_slot(), None);
}
#[test]
fn the_error_names_the_wire_field_and_the_bound() {
let message = Dimming::new(0).unwrap_err().to_string();
assert!(
message.contains("dimming must be 1..=100, got 0"),
"{message}"
);
}
}