use serde::{Deserialize, Serialize};
use super::scene::Scene;
use super::types::{
Channel, Devices, Dimming, Kelvin, PULSE_SCENE_ID, PulseDelta, Ratio, SceneId, Speed,
};
use crate::error::{Error, Result};
use crate::protocol::Request;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ColourMode {
Channels {
r: Option<Channel>,
g: Option<Channel>,
b: Option<Channel>,
c: Option<Channel>,
w: Option<Channel>,
},
Temp(Kelvin),
Scene(SceneId),
}
impl ColourMode {
const CHANNELS: &'static str = "r/g/b/c/w";
const fn empty_channels() -> Self {
Self::Channels {
r: None,
g: None,
b: None,
c: None,
w: None,
}
}
const fn name(self) -> &'static str {
match self {
Self::Channels { .. } => Self::CHANNELS,
Self::Temp(_) => "temp",
Self::Scene(_) => "sceneId",
}
}
const fn is_empty(self) -> bool {
matches!(
self,
Self::Channels {
r: None,
g: None,
b: None,
c: None,
w: None
}
)
}
fn is_dark(self) -> bool {
let Self::Channels { r, g, b, c, w } = self else {
return false;
};
let (mut set, mut lit) = (false, false);
for channel in [r, g, b, c, w].into_iter().flatten() {
set = true;
lit |= channel.get() != 0;
}
set && !lit
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PilotBuilder {
state: Option<bool>,
dimming: Option<Dimming>,
speed: Option<Speed>,
ratio: Option<Ratio>,
devices: Option<Devices>,
colour: Option<ColourMode>,
conflict: Option<(&'static str, &'static str)>,
}
impl PilotBuilder {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn state(mut self, on: bool) -> Self {
self.state = Some(on);
self
}
#[must_use]
pub fn dimming(mut self, dimming: Dimming) -> Self {
self.dimming = Some(dimming);
self
}
#[must_use]
pub fn speed(mut self, speed: Speed) -> Self {
self.speed = Some(speed);
self
}
#[must_use]
pub fn ratio(mut self, ratio: Ratio) -> Self {
self.ratio = Some(ratio);
self
}
#[must_use]
pub fn devices(mut self, devices: Devices) -> Self {
self.devices = Some(devices);
self
}
#[must_use]
pub fn rgb(mut self, r: Channel, g: Channel, b: Channel) -> Self {
if let Some(ColourMode::Channels {
r: rs,
g: gs,
b: bs,
..
}) = self.channels()
{
*rs = Some(r);
*gs = Some(g);
*bs = Some(b);
}
self
}
#[must_use]
pub fn rgbw(self, r: Channel, g: Channel, b: Channel, w: Channel) -> Self {
self.rgb(r, g, b).warm_white(w)
}
#[must_use]
pub fn rgbww(self, r: Channel, g: Channel, b: Channel, c: Channel, w: Channel) -> Self {
self.rgb(r, g, b).cold_white(c).warm_white(w)
}
#[must_use]
pub fn cold_white(mut self, c: Channel) -> Self {
if let Some(ColourMode::Channels { c: slot, .. }) = self.channels() {
*slot = Some(c);
}
self
}
#[must_use]
pub fn warm_white(mut self, w: Channel) -> Self {
if let Some(ColourMode::Channels { w: slot, .. }) = self.channels() {
*slot = Some(w);
}
self
}
#[must_use]
pub fn temp(mut self, temp: Kelvin) -> Self {
self.set_colour(ColourMode::Temp(temp));
self
}
#[must_use]
pub fn scene(mut self, scene: SceneId) -> Self {
self.set_colour(ColourMode::Scene(scene));
self
}
pub fn set_pilot(&self) -> Result<Request> {
self.to_request("setPilot")
}
pub fn set_state(&self) -> Result<Request> {
self.to_request("setState")
}
pub fn params(&self) -> Result<PilotParams> {
if let Some((rejected, existing)) = self.conflict {
return Err(Error::InvalidParam {
message: format!(
"`{rejected}` conflicts with `{existing}`: colour, colour temperature \
and scene are mutually exclusive in one request"
),
});
}
if self.is_empty() {
return Err(Error::InvalidParam {
message: "pilot params must set at least one field".into(),
});
}
if self.colour.is_some_and(ColourMode::is_dark) {
return Err(Error::InvalidParam {
message: "`r`/`g`/`b`/`c`/`w` are all zero, and a channel write with nothing lit \
in it is discarded: to go dark use `state(false)`, and to go dim use \
`dimming`"
.into(),
});
}
self.check_speed()?;
let mut params = PilotParams {
state: self.state,
dimming: self.dimming,
speed: self.speed,
ratio: self.ratio,
devices: self.devices,
..PilotParams::default()
};
match self.colour {
Some(ColourMode::Channels { r, g, b, c, w }) => {
params.r = r;
params.g = g;
params.b = b;
params.c = c;
params.w = w;
}
Some(ColourMode::Temp(temp)) => params.temp = Some(temp),
Some(ColourMode::Scene(scene)) => params.scene_id = Some(scene),
None => {}
}
Ok(params)
}
fn check_speed(&self) -> Result<()> {
if self.speed.is_none() {
return Ok(());
}
let refuse = |reason: String| {
Err(Error::InvalidParam {
message: format!("`speed` sets the rate of an animating scene, but {reason}"),
})
};
match self.colour {
Some(ColourMode::Channels { .. }) => {
refuse("this request sets `r`/`g`/`b`/`c`/`w`, which stops any scene".to_owned())
}
Some(ColourMode::Temp(_)) => {
refuse("this request sets `temp`, which stops any scene".to_owned())
}
Some(ColourMode::Scene(scene)) if !scene.takes_speed() => refuse(format!(
"the rate of `{}` cannot be set",
scene.scene().map_or_else(
|| format!("scene {}", scene.get()),
|scene| scene.to_string()
)
)),
_ => Ok(()),
}
}
fn channels(&mut self) -> Option<&mut ColourMode> {
match self.colour {
Some(ColourMode::Channels { .. }) => self.colour.as_mut(),
Some(other) => {
self.note_conflict(ColourMode::CHANNELS, other.name());
None
}
None => {
self.colour = Some(ColourMode::empty_channels());
self.colour.as_mut()
}
}
}
fn set_colour(&mut self, mode: ColourMode) {
match self.colour {
Some(existing) if existing.name() != mode.name() => {
self.note_conflict(mode.name(), existing.name());
}
_ => self.colour = Some(mode),
}
}
fn note_conflict(&mut self, rejected: &'static str, existing: &'static str) {
self.conflict.get_or_insert((rejected, existing));
}
fn is_empty(&self) -> bool {
self.state.is_none()
&& self.dimming.is_none()
&& self.speed.is_none()
&& self.ratio.is_none()
&& self.devices.is_none()
&& self.colour.is_none_or(ColourMode::is_empty)
}
fn to_request(&self, method: &str) -> Result<Request> {
Request::with_params(method, &self.params()?)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
pub struct PilotParams {
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub r: Option<Channel>,
#[serde(skip_serializing_if = "Option::is_none")]
pub g: Option<Channel>,
#[serde(skip_serializing_if = "Option::is_none")]
pub b: Option<Channel>,
#[serde(skip_serializing_if = "Option::is_none")]
pub c: Option<Channel>,
#[serde(skip_serializing_if = "Option::is_none")]
pub w: Option<Channel>,
#[serde(skip_serializing_if = "Option::is_none")]
pub dimming: Option<Dimming>,
#[serde(skip_serializing_if = "Option::is_none")]
pub temp: Option<Kelvin>,
#[serde(rename = "sceneId", skip_serializing_if = "Option::is_none")]
pub scene_id: Option<SceneId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub speed: Option<Speed>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ratio: Option<Ratio>,
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Devices>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
#[serde(default)]
pub struct Pilot {
#[serde(skip_serializing_if = "Option::is_none")]
pub mac: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rssi: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub r: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub g: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub b: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub c: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub w: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub dimming: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub temp: Option<u16>,
#[serde(rename = "sceneId", skip_serializing_if = "Option::is_none")]
pub scene_id: Option<u16>,
#[serde(skip_serializing_if = "Option::is_none")]
pub effect: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub speed: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ratio: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<u8>,
#[serde(rename = "src", skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
}
impl Pilot {
#[must_use]
pub fn scene(&self) -> Option<Scene> {
Scene::from_id(self.scene_id?)
}
#[must_use]
pub fn is_pulsing(&self) -> bool {
self.effect.as_deref() == Some("pulse") || self.scene_id == Some(PULSE_SCENE_ID)
}
#[must_use]
pub fn rgb(&self) -> Option<(u8, u8, u8)> {
Some((self.r?, self.g?, self.b?))
}
#[must_use]
pub fn rgbw(&self) -> Option<(u8, u8, u8, u8)> {
Some((self.r?, self.g?, self.b?, self.w?))
}
#[must_use]
pub fn rgbww(&self) -> Option<(u8, u8, u8, u8, u8)> {
Some((self.r?, self.g?, self.b?, self.c?, self.w?))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
pub struct PulseParams {
pub delta: PulseDelta,
pub duration: u32,
}
impl PulseParams {
pub fn new(delta: i32, duration_ms: u32) -> Result<Self> {
let delta = PulseDelta::new(delta)?;
if duration_ms == 0 {
return Err(Error::InvalidParam {
message: "duration must be at least 1 ms, got 0".to_owned(),
});
}
Ok(Self {
delta,
duration: duration_ms,
})
}
pub fn request(&self) -> Result<Request> {
Request::with_params("pulse", self)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
pub struct Success {
pub success: bool,
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn wire(request: &Request) -> serde_json::Value {
serde_json::to_value(request).expect("a request always serialises")
}
#[test]
fn conflicting_colour_modes_are_rejected() {
let cases = [
PilotBuilder::new().temp(Kelvin::new(2700).unwrap()).rgb(
Channel::new(1),
Channel::new(2),
Channel::new(3),
),
PilotBuilder::new()
.rgb(Channel::new(1), Channel::new(2), Channel::new(3))
.temp(Kelvin::new(4000).unwrap()),
PilotBuilder::new()
.temp(Kelvin::new(4000).unwrap())
.scene(SceneId::new(4).unwrap()),
PilotBuilder::new().scene(SceneId::new(4).unwrap()).rgb(
Channel::new(1),
Channel::new(2),
Channel::new(3),
),
PilotBuilder::new()
.temp(Kelvin::new(4000).unwrap())
.warm_white(Channel::new(10)),
];
for builder in cases {
let err = builder.set_pilot().unwrap_err();
assert!(
matches!(&err, Error::InvalidParam { message } if message.contains("mutually exclusive")),
"{err}"
);
}
}
#[test]
fn the_conflict_message_names_both_modes() {
let err = PilotBuilder::new()
.temp(Kelvin::new(2700).unwrap())
.scene(SceneId::new(4).unwrap())
.set_pilot()
.unwrap_err();
let message = err.to_string();
assert!(message.contains("`sceneId`"), "{message}");
assert!(message.contains("`temp`"), "{message}");
}
#[test]
fn resetting_the_same_mode_is_not_a_conflict() {
let params = PilotBuilder::new()
.temp(Kelvin::new(2700).unwrap())
.temp(Kelvin::new(4000).unwrap())
.params()
.unwrap();
assert_eq!(params.temp.unwrap().get(), 4000);
let params = PilotBuilder::new()
.rgb(Channel::new(1), Channel::new(2), Channel::new(3))
.rgb(Channel::new(4), Channel::new(5), Channel::new(6))
.params()
.unwrap();
assert_eq!(params.r.unwrap().get(), 4);
}
#[test]
fn non_colour_fields_compose_with_a_scene() {
let params = PilotBuilder::new()
.scene(SceneId::new(4).unwrap())
.speed(Speed::new(100).unwrap())
.dimming(Dimming::new(40).unwrap())
.state(true)
.params()
.unwrap();
assert_eq!(params.scene_id.unwrap().get(), 4);
assert_eq!(params.speed.unwrap().get(), 100);
assert_eq!(params.dimming.unwrap().get(), 40);
assert_eq!(params.state, Some(true));
}
#[test]
fn speed_is_allowed_where_it_can_do_something() {
let speed = Speed::new(100).unwrap();
let params = PilotBuilder::new()
.scene(SceneId::new(4).unwrap())
.speed(speed)
.params()
.unwrap();
assert_eq!(params.speed.unwrap().get(), 100);
assert!(
PilotBuilder::new()
.scene(SceneId::new(36).unwrap())
.speed(speed)
.params()
.is_ok()
);
let params = PilotBuilder::new().speed(speed).params().unwrap();
assert_eq!(params.speed.unwrap().get(), 100);
assert!(params.scene_id.is_none());
}
#[test]
fn speed_is_refused_where_it_cannot() {
let speed = Speed::new(100).unwrap();
let cases = [
(
PilotBuilder::new()
.scene(SceneId::new(11).unwrap())
.speed(speed),
"Warm white",
),
(
PilotBuilder::new()
.rgb(Channel::new(1), Channel::new(2), Channel::new(3))
.speed(speed),
"r`/`g`/`b",
),
(
PilotBuilder::new()
.temp(Kelvin::new(2700).unwrap())
.speed(speed),
"temp",
),
];
for (builder, expected) in cases {
let err = builder.set_pilot().unwrap_err();
let message = err.to_string();
assert!(message.contains("`speed`"), "{message}");
assert!(message.contains(expected), "{message}");
}
}
#[test]
fn a_reported_scene_id_is_named_only_when_the_table_knows_it() {
let named: Pilot = serde_json::from_str(r#"{"sceneId":23,"speed":100}"#).unwrap();
assert_eq!(named.scene().map(Scene::name), Some("Deep dive"));
for raw in [r#"{"sceneId":0}"#, r#"{"sceneId":256}"#, "{}"] {
let pilot: Pilot = serde_json::from_str(raw).unwrap();
assert_eq!(pilot.scene(), None, "{raw}");
}
}
#[test]
fn white_channels_compose_with_rgb_in_either_order() {
let after = PilotBuilder::new()
.rgb(Channel::new(1), Channel::new(2), Channel::new(3))
.cold_white(Channel::new(4))
.warm_white(Channel::new(5))
.params()
.unwrap();
let before = PilotBuilder::new()
.cold_white(Channel::new(4))
.warm_white(Channel::new(5))
.rgb(Channel::new(1), Channel::new(2), Channel::new(3))
.params()
.unwrap();
assert_eq!(after, before);
assert_eq!(after.c.unwrap().get(), 4);
assert_eq!(after.w.unwrap().get(), 5);
assert_eq!(after.r.unwrap().get(), 1);
}
#[test]
fn rgbww_is_its_three_setters_and_nothing_more() {
let tuple = PilotBuilder::new()
.rgbww(
Channel::new(255),
Channel::new(80),
Channel::new(0),
Channel::new(12),
Channel::new(34),
)
.params()
.unwrap();
let separately = PilotBuilder::new()
.rgb(Channel::new(255), Channel::new(80), Channel::new(0))
.cold_white(Channel::new(12))
.warm_white(Channel::new(34))
.params()
.unwrap();
assert_eq!(tuple, separately);
}
#[test]
fn a_channel_write_with_nothing_lit_in_it_is_rejected() {
let dark = [
PilotBuilder::new().rgb(Channel::new(0), Channel::new(0), Channel::new(0)),
PilotBuilder::new().warm_white(Channel::new(0)),
PilotBuilder::new()
.state(true)
.rgb(Channel::new(0), Channel::new(0), Channel::new(0))
.cold_white(Channel::new(0)),
];
for builder in dark {
let err = builder.set_pilot().unwrap_err();
assert!(
matches!(&err, Error::InvalidParam { message } if message.contains("all zero")),
"{err}"
);
}
let lit = PilotBuilder::new()
.rgb(Channel::new(0), Channel::new(0), Channel::new(0))
.warm_white(Channel::new(1))
.params()
.unwrap();
assert_eq!(lit.r.unwrap().get(), 0);
assert_eq!(lit.w.unwrap().get(), 1);
}
#[test]
fn empty_builder_is_rejected() {
let err = PilotBuilder::new().set_pilot().unwrap_err();
assert!(matches!(err, Error::InvalidParam { .. }));
}
#[test]
fn wire_format_matches_recorded_traffic() {
let cases = [
(
PilotBuilder::new().state(true).set_pilot().unwrap(),
json!({"method": "setPilot", "params": {"state": true}}),
),
(
PilotBuilder::new()
.dimming(Dimming::new(40).unwrap())
.set_pilot()
.unwrap(),
json!({"method": "setPilot", "params": {"dimming": 40}}),
),
(
PilotBuilder::new()
.rgb(Channel::new(255), Channel::new(80), Channel::new(0))
.set_pilot()
.unwrap(),
json!({"method": "setPilot", "params": {"r": 255, "g": 80, "b": 0}}),
),
(
PilotBuilder::new()
.rgbw(
Channel::new(255),
Channel::new(80),
Channel::new(0),
Channel::new(12),
)
.set_pilot()
.unwrap(),
json!({"method": "setPilot", "params": {"r": 255, "g": 80, "b": 0, "w": 12}}),
),
(
PilotBuilder::new()
.rgbww(
Channel::new(0),
Channel::new(128),
Channel::new(255),
Channel::new(0),
Channel::new(0),
)
.set_pilot()
.unwrap(),
json!({
"method": "setPilot",
"params": {"r": 0, "g": 128, "b": 255, "c": 0, "w": 0},
}),
),
(
PilotBuilder::new()
.warm_white(Channel::new(200))
.set_pilot()
.unwrap(),
json!({"method": "setPilot", "params": {"w": 200}}),
),
(
PilotBuilder::new()
.temp(Kelvin::new(5000).unwrap())
.set_pilot()
.unwrap(),
json!({"method": "setPilot", "params": {"temp": 5000}}),
),
(
PilotBuilder::new()
.scene(SceneId::new(4).unwrap())
.speed(Speed::new(100).unwrap())
.set_pilot()
.unwrap(),
json!({"method": "setPilot", "params": {"sceneId": 4, "speed": 100}}),
),
(
PilotBuilder::new()
.state(true)
.ratio(Ratio::new(75).unwrap())
.devices(Devices::new(2).unwrap())
.set_pilot()
.unwrap(),
json!({
"method": "setPilot",
"params": {"state": true, "ratio": 75, "devices": 2},
}),
),
(
PilotBuilder::new()
.rgb(Channel::new(255), Channel::new(0), Channel::new(0))
.set_state()
.unwrap(),
json!({"method": "setState", "params": {"r": 255, "g": 0, "b": 0}}),
),
];
for (request, expected) in cases {
assert_eq!(wire(&request), expected);
}
}
#[test]
fn pilot_parses_partial_results() {
let colour: Pilot = serde_json::from_str(
r#"{"mac":"9877d5230f0a","rssi":-53,"state":true,"sceneId":0,"r":255,"g":0,"b":0,"c":0,"w":0,"dimming":40}"#,
)
.unwrap();
assert_eq!(colour.rgb(), Some((255, 0, 0)));
assert_eq!(colour.rgbw(), Some((255, 0, 0, 0)));
assert_eq!(colour.rgbww(), Some((255, 0, 0, 0, 0)));
assert!(colour.temp.is_none());
let white: Pilot = serde_json::from_str(
r#"{"mac":"9877d5230f0a","state":true,"sceneId":11,"temp":2700,"dimming":100}"#,
)
.unwrap();
assert_eq!(white.temp, Some(2700));
assert!(white.r.is_none());
assert_eq!(white.scene_id, Some(11));
assert_eq!(white.rgb(), None);
assert_eq!(white.rgbw(), None);
}
#[test]
fn a_reported_value_the_builder_would_refuse_still_parses() {
let pilot: Pilot = serde_json::from_str(r#"{"state":false,"dimming":0}"#).unwrap();
assert_eq!(pilot.dimming, Some(0));
}
}