use std::fmt;
use std::str::FromStr;
use serde::Serialize;
use super::model::BulbClass;
use super::types::SceneId;
use crate::error::{Error, Result};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Category {
White,
Functional,
Progressive,
Dynamic,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
pub struct Adjustable {
pub speed: bool,
pub dimming: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
pub struct Scene {
id: u16,
name: &'static str,
category: Category,
kelvin: Option<u16>,
#[serde(skip)]
classes: u8,
adjustable: Adjustable,
}
const RGB: u8 = 1 << 0;
const TW: u8 = 1 << 1;
const DW: u8 = 1 << 2;
const PACED: Adjustable = Adjustable {
speed: true,
dimming: true,
};
const DIMMABLE: Adjustable = Adjustable {
speed: false,
dimming: true,
};
const FIXED: Adjustable = Adjustable {
speed: false,
dimming: false,
};
const SCENES: &[Scene] = &[
Scene::new(1, "Ocean", Category::Dynamic, RGB, PACED),
Scene::new(2, "Romance", Category::Dynamic, RGB, PACED),
Scene::new(3, "Sunset", Category::Dynamic, RGB, PACED),
Scene::new(4, "Party", Category::Dynamic, RGB, PACED),
Scene::new(5, "Fireplace", Category::Dynamic, RGB, PACED),
Scene::new(6, "Cozy", Category::Functional, RGB | TW, DIMMABLE),
Scene::new(7, "Forest", Category::Dynamic, RGB, PACED),
Scene::new(8, "Pastel colors", Category::Dynamic, RGB, PACED),
Scene::new(9, "Wake up", Category::Progressive, RGB | TW | DW, FIXED),
Scene::new(
10,
"Bedtime",
Category::Progressive,
RGB | TW | DW,
DIMMABLE,
),
Scene::white(11, "Warm white", 2700, RGB | TW),
Scene::white(12, "Daylight", 4200, RGB | TW),
Scene::white(13, "Cool white", 6500, RGB | TW | DW),
Scene::new(
14,
"Night light",
Category::Functional,
RGB | TW | DW,
FIXED,
),
Scene::new(15, "Focus", Category::Functional, RGB | TW, DIMMABLE),
Scene::new(16, "Relax", Category::Functional, RGB | TW, DIMMABLE),
Scene::new(17, "True colors", Category::Functional, RGB, DIMMABLE),
Scene::new(18, "TV time", Category::Functional, RGB | TW, DIMMABLE),
Scene::new(19, "Plant growth", Category::Functional, RGB, DIMMABLE),
Scene::new(20, "Spring", Category::Dynamic, RGB, PACED),
Scene::new(21, "Summer", Category::Dynamic, RGB, PACED),
Scene::new(22, "Fall", Category::Dynamic, RGB, PACED),
Scene::new(23, "Deep dive", Category::Dynamic, RGB, PACED),
Scene::new(24, "Jungle", Category::Dynamic, RGB, PACED),
Scene::new(25, "Mojito", Category::Dynamic, RGB, PACED),
Scene::new(26, "Club", Category::Dynamic, RGB, PACED),
Scene::new(27, "Christmas", Category::Dynamic, RGB, PACED),
Scene::new(28, "Halloween", Category::Dynamic, RGB, PACED),
Scene::new(
29,
"Candlelight",
Category::Dynamic,
RGB | TW | DW,
DIMMABLE,
),
Scene::new(30, "Golden white", Category::Dynamic, RGB | TW | DW, PACED),
Scene::new(31, "Pulse", Category::Dynamic, RGB | TW | DW, PACED),
Scene::new(32, "Steampunk", Category::Dynamic, RGB | TW | DW, PACED),
Scene::new(33, "Diwali", Category::Dynamic, RGB | TW | DW, PACED),
Scene::white(34, "White", 4000, RGB | DW),
Scene::new(35, "Alarm", Category::Dynamic, RGB | TW | DW, FIXED),
Scene::new(36, "Snowy sky", Category::Dynamic, RGB, PACED),
Scene::white(38, "Soft white", 3500, RGB),
Scene::white(39, "Crisp white", 5000, RGB),
Scene::new(40, "Dim-to-warm", Category::White, RGB | TW, DIMMABLE),
];
impl Scene {
const fn new(
id: u16,
name: &'static str,
category: Category,
classes: u8,
adjustable: Adjustable,
) -> Self {
Self {
id,
name,
category,
kelvin: None,
classes,
adjustable,
}
}
const fn white(id: u16, name: &'static str, kelvin: u16, classes: u8) -> Self {
Self {
id,
name,
category: Category::White,
kelvin: Some(kelvin),
classes,
adjustable: DIMMABLE,
}
}
#[must_use]
pub const fn all() -> &'static [Self] {
SCENES
}
#[must_use]
pub fn from_id(id: u16) -> Option<Self> {
SCENES.iter().copied().find(|scene| scene.id == id)
}
pub fn from_name(name: &str) -> Result<Self> {
SCENES
.iter()
.copied()
.find(|scene| normalised(scene.name).eq(normalised(name)))
.ok_or_else(|| Error::UnknownScene {
message: format!(
"no scene is called `{name}`; names are matched ignoring case, spaces \
and punctuation"
),
})
}
pub fn for_class(class: BulbClass) -> impl Iterator<Item = Self> {
SCENES
.iter()
.copied()
.filter(move |scene| scene.available_for(class))
}
#[must_use]
pub const fn id(self) -> SceneId {
SceneId::new_unchecked(self.id)
}
#[must_use]
pub const fn name(self) -> &'static str {
self.name
}
#[must_use]
pub const fn category(self) -> Category {
self.category
}
#[must_use]
pub const fn animates(self) -> bool {
matches!(self.category, Category::Dynamic | Category::Progressive)
}
#[must_use]
pub const fn adjustable(self) -> Adjustable {
self.adjustable
}
#[must_use]
pub const fn kelvin(self) -> Option<u16> {
self.kelvin
}
#[must_use]
pub const fn available_for(self, class: BulbClass) -> bool {
let bit = match class {
BulbClass::Rgb => RGB,
BulbClass::Tw | BulbClass::FanTw => TW,
BulbClass::Dw => DW,
BulbClass::Socket | BulbClass::FanDim => return false,
};
self.classes & bit != 0
}
}
impl FromStr for Scene {
type Err = Error;
fn from_str(name: &str) -> Result<Self> {
Self::from_name(name)
}
}
impl fmt::Display for Scene {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.name)
}
}
impl From<Scene> for SceneId {
fn from(scene: Scene) -> Self {
scene.id()
}
}
fn normalised(name: &str) -> impl Iterator<Item = char> + '_ {
name.chars()
.filter(|c| c.is_alphanumeric())
.map(|c| c.to_ascii_lowercase())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_table_covers_the_scenes_worth_sending() {
let ids: Vec<u16> = Scene::all().iter().map(|s| s.id().get()).collect();
let expected: Vec<u16> = (1..=36).chain(38..=40).collect();
assert_eq!(ids, expected);
}
#[test]
fn per_class_counts() {
assert_eq!(Scene::for_class(BulbClass::Rgb).count(), 39);
assert_eq!(Scene::for_class(BulbClass::Tw).count(), 17);
assert_eq!(Scene::for_class(BulbClass::Dw).count(), 11);
assert_eq!(Scene::for_class(BulbClass::FanTw).count(), 17);
assert_eq!(Scene::for_class(BulbClass::Socket).count(), 0);
assert_eq!(Scene::for_class(BulbClass::FanDim).count(), 0);
}
#[test]
fn the_tunable_white_list_is_the_one_both_sources_agree_on() {
let tw: Vec<u16> = Scene::for_class(BulbClass::Tw)
.map(|scene| scene.id().get())
.collect();
assert_eq!(
tw,
[
6, 9, 10, 11, 12, 13, 14, 15, 16, 18, 29, 30, 31, 32, 33, 35, 40
]
);
}
#[test]
fn the_dimmable_white_list_follows_the_vendor_table() {
let dw: Vec<u16> = Scene::for_class(BulbClass::Dw)
.map(|scene| scene.id().get())
.collect();
assert_eq!(dw, [9, 10, 13, 14, 29, 30, 31, 32, 33, 34, 35]);
}
#[test]
fn ids_and_names_round_trip() {
for scene in Scene::all() {
assert_eq!(Scene::from_id(scene.id().get()), Some(*scene));
assert_eq!(Scene::from_name(scene.name()).unwrap(), *scene);
assert_eq!(scene.to_string(), scene.name());
}
}
#[test]
fn names_are_unique() {
for scene in Scene::all() {
let clashes = Scene::all()
.iter()
.filter(|other| normalised(other.name()).eq(normalised(scene.name())))
.count();
assert_eq!(clashes, 1, "`{scene}` is not a unique name");
}
}
#[test]
fn the_two_scenes_nobody_names_are_labelled_by_us() {
let ours = [(38, "Soft white"), (39, "Crisp white")];
for (id, name) in ours {
let scene = Scene::from_id(id).unwrap();
assert_eq!(scene.name(), name);
assert_eq!(scene.category(), Category::White);
assert_eq!(Scene::from_name(name).unwrap().id().get(), id);
}
assert_eq!(Scene::from_id(41), None);
}
#[test]
fn names_are_matched_leniently() {
let deep_dive = Scene::from_id(23).unwrap();
for spelling in [
"Deep dive",
"deep dive",
"deep-dive",
"DEEPDIVE",
"Deep_Dive",
] {
assert_eq!(Scene::from_name(spelling).unwrap(), deep_dive, "{spelling}");
}
for (spelling, id) in [
("Wake-up", 9), ("Plantgrowth", 19), ("TV time", 18),
("Dim-to-warm", 40),
("Bed Time", 10), ("Wakeup", 9), ("Deepdive", 23), ("Pastel Colors", 8),
] {
assert_eq!(
Scene::from_name(spelling).unwrap().id().get(),
id,
"{spelling}"
);
}
}
#[test]
fn an_unknown_name_names_itself_in_the_error() {
let err = Scene::from_name("Cozy Whitest").unwrap_err();
assert!(
matches!(&err, Error::UnknownScene { message } if message.contains("`Cozy Whitest`")),
"{err}"
);
}
#[test]
fn ids_that_are_not_scenes_are_none() {
for id in [0, 37, 41, 42, 100, 248, 256, 265, 1000] {
assert_eq!(Scene::from_id(id), None, "{id}");
}
}
#[test]
fn animating_is_not_the_same_as_taking_a_speed() {
let animates_without_a_speed = [9, 10, 29, 35];
for id in animates_without_a_speed {
let scene = Scene::from_id(id).unwrap();
assert!(scene.animates(), "{scene} should animate");
assert!(!scene.adjustable().speed, "{scene} should take no speed");
}
let party = Scene::from_id(4).unwrap();
assert!(party.animates() && party.adjustable().speed);
let cozy = Scene::from_id(6).unwrap();
assert_eq!(cozy.category(), Category::Functional);
assert!(!cozy.animates() && !cozy.adjustable().speed);
}
#[test]
fn the_undimmable_scenes_are_the_measured_three() {
let undimmable: Vec<u16> = Scene::all()
.iter()
.filter(|scene| !scene.adjustable().dimming)
.map(|scene| scene.id().get())
.collect();
assert_eq!(undimmable, [9, 14, 35]);
}
#[test]
fn the_whites_report_the_temperature_they_run_at() {
let ladder: Vec<(u16, u16)> = Scene::all()
.iter()
.filter_map(|scene| Some((scene.id().get(), scene.kelvin()?)))
.collect();
assert_eq!(
ladder,
[
(11, 2700),
(12, 4200),
(13, 6500),
(34, 4000),
(38, 3500),
(39, 5000)
]
);
for scene in Scene::all().iter().filter(|s| s.kelvin().is_some()) {
assert_eq!(scene.category(), Category::White, "{scene}");
}
assert_eq!(Scene::from_id(40).unwrap().kelvin(), None);
}
#[test]
fn a_scene_serialises_as_its_id_name_and_behaviour() {
let json = serde_json::to_value(Scene::from_id(23).unwrap()).unwrap();
assert_eq!(
json,
serde_json::json!({
"id": 23,
"name": "Deep dive",
"category": "dynamic",
"kelvin": null,
"adjustable": {"speed": true, "dimming": true},
})
);
}
}