aw-lights/src/pattern.rs

use crate::color::Rgb;
use serde::{Deserialize, Serialize};
use std::collections::vec_deque;
use std::iter;

pub mod collide;
pub mod fade;
pub mod flashing;
pub mod moving_pixel;
pub mod moving_rainbow;
pub mod orb;
pub mod solid;
pub use collide::{Collide, CollideParams};
pub use fade::{Fade, FadeParams};
pub use flashing::{Flashing, FlashingParams};
pub use moving_pixel::{MovingPixel, MovingPixelParams};
pub use moving_rainbow::{MovingRainbow, MovingRainbowParams};
pub use orb::{Orb, OrbParams};
pub use solid::{Solid, SolidParams};

pub trait FormRender {
    fn render(&self) -> String;
}
pub trait InputRender {
    fn render(&self, name: &str) -> String;
}

impl InputRender for bool {
    fn render(&self, name: &str) -> String {
        format!(
            r#"<input type="checkbox" name="{}" {}/>"#,
            name,
            if *self { " checked" } else { "" },
        )
    }
}

impl InputRender for Rgb {
    fn render(&self, name: &str) -> String {
        format!(
            r#"<input rust-input="inc" type="color" value="{}" name="{}" />"#,
            self.to_hex_str(),
            name,
        )
    }
}

impl InputRender for Vec<Rgb> {
    fn render(&self, name: &str) -> String {
        self.iter()
            .chain(iter::once(&Rgb::default()))
            .enumerate()
            .fold(String::new(), |acc, (i, c)| {
                acc + &c.render(&format!("{}-{}", name, i)) + "\n"
            })
    }
}

impl InputRender for u8 {
    fn render(&self, name: &str) -> String {
        format!(
            r#"<input type="number" max="255" min="0" step="1" value="{}" name="{}" />"#,
            self, name,
        )
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub enum Parameters {
    Collide(CollideParams),
    Fade(FadeParams),
    MovingPixel(MovingPixelParams),
    MovingRainbow(MovingRainbowParams),
    Orb(OrbParams),
    Solid(SolidParams),
    Flashing(FlashingParams),
}

impl Parameters {
    pub fn into_pattern(self) -> Box<dyn Pattern + Send + Sync> {
        match self {
            Self::Collide(ref p) => Box::new(Collide::new(p)),
            Self::Fade(ref p) => Box::new(Fade::new(p)),
            Self::MovingPixel(ref p) => Box::new(MovingPixel::new(p)),
            Self::MovingRainbow(ref p) => Box::new(MovingRainbow::new(p)),
            Self::Orb(ref p) => Box::new(Orb::new(p)),
            Self::Solid(ref p) => Box::new(Solid::new(p)),
            Self::Flashing(ref p) => Box::new(Flashing::new(p)),
        }
    }
}

pub trait Pattern: std::fmt::Debug + Send + Sync {
    fn init(&mut self, num_lights: u16) -> Result<(), ()>;
    fn step(&mut self) -> Result<bool, ()>;
    fn get_strip(&self) -> vec_deque::Iter<Rgb>;
}

// #[cfg(test)]
// mod tests {
//     use super::*;
//     const NUM_LIGHTS: u16 = 10;
//     fn test_strip() -> Vec<Rgb> {
//         vec![color::BLACK; NUM_LIGHTS.into()]
//     }
//     #[test]
//     fn moving_pixel() {
//         let color = Rgb(123, 152, 89);
//         let mut pat = MovingPixel::new(color.clone());
//         let mut strip = test_strip();

//         assert!(pat.init(&mut strip, NUM_LIGHTS).is_ok());
//         // One is my color
//         assert_eq!(strip.iter().filter(|c| **c == color).count(), 1);
//         // The rest are off
//         assert_eq!(
//             strip.iter().filter(|c| **c == color::BLACK).count(),
//             (NUM_LIGHTS - 1).into()
//         );
//         pat.step(&mut strip);
//         // One is my color
//         assert_eq!(strip.iter().filter(|c| **c == color).count(), 1);
//         // The rest are off
//         assert_eq!(
//             strip.iter().filter(|c| **c == color::BLACK).count(),
//             (NUM_LIGHTS - 1).into()
//         );
//     }
//     #[test]
//     fn solid() {}
//     #[test]
//     fn moving_rainbow() {}
//     #[test]
//     fn fade() {}
//     #[test]
//     fn collide() {}
// }