lights/src/render.rs

use ws281x_rpi::Ws2812Rpi;

use crate::{animations::Animation, DBPool};

use smart_leds::{SmartLedsWrite, RGB, RGB8};
use std::error::Error;
use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Clone, Debug)]
struct LocalLedConfiguration {
    tag: Option<String>,
    start: usize,
    end: usize,
}

#[derive(Clone)]
pub struct LigthSetting {
    start: Option<usize>,
    end: Option<usize>,
    tags: Option<String>,
    color: RGB8,
}

#[derive(Clone)]
pub struct KeyFrame {
    duration: u128,
    settings: Vec<LigthSetting>,
}

#[derive(Clone)]
pub struct RenderAnimation {
    key_frames: Vec<KeyFrame>,
    priority: u32,
    name: String,

    current_frame: usize,
    start_time: u128,
    reset: bool,
}

pub struct Render {
    conn: DBPool,
    num_leds: u32,

    last_render: u128,
    last_update: u128,

    ws: Option<Ws2812Rpi>,
    last: Vec<RGB<f64>>,

    animations: Vec<RenderAnimation>,

    local_led_config: Vec<LocalLedConfiguration>,
}

struct GetRender {
    data: Vec<RGB<f64>>,
    delta: u128,
    time: u128,
}

fn try_into_usize(input: Option<u32>) -> Option<usize> {
    if input.is_none() {
        return None;
    }

    let t: Result<usize, _> = input.unwrap().try_into();

    if t.is_err() {
        return None;
    }

    return t.ok();
}

impl Render {
    pub fn new(conn: DBPool) -> Result<Render, Box<dyn Error>> {
        let mut render = Render {
            conn,
            num_leds: 0,
            last_render: 0,
            last_update: 0,
            ws: None,
            animations: vec![],
            local_led_config: vec![],
            last: vec![],
        };

        render.load_config()?;

        return Ok(render);
    }

    pub fn load_config(&mut self) -> Result<(), Box<dyn Error>> {
        println!("Load config");
        // GPIO Pin 10 is SPI
        // Other modes and PINs are available depending on the Raspberry Pi revision
        // Additional OS configuration might be needed for any mode.
        // Check https://github.com/jgarff/rpi_ws281x for more information.
        const PIN: i32 = 18;

        let conn = self.conn.get()?;

        let stmt = conn.prepare("SELECT ledcount, tags from configuration;");

        if stmt.is_err() || stmt.as_ref().ok().is_none() {
            Err(format!(
                "Something went wrong while reading the database {:?}",
                stmt.as_ref().err()
            ))?;
        }

        let mut stmt = stmt?;

        struct Data {
            ledcount: u32,
            tag: String,
        }

        let version_iter = stmt.query_map([], |row| {
            Ok(Data {
                ledcount: row.get(0)?,
                tag: row.get(1)?,
            })
        });

        if version_iter.is_err() || version_iter.as_ref().ok().is_none() {
            Err(format!(
                "Something went wrong while reading the database {:?}",
                version_iter.as_ref().err()
            ))?;
        }

        let version_iter = version_iter.ok().unwrap();

        let mut current_pos = 0;

        let mut local_led_config = Vec::new();

        for data in version_iter {
            let data = data?;

            let tag = if data.tag.is_empty() {
                None
            } else {
                Some(data.tag)
            };

            let start = current_pos;
            let end = current_pos + data.ledcount;
            current_pos = end;

            let start: Result<usize, _> = start.try_into();
            let end: Result<usize, _> = end.try_into();

            if start.is_err() || start.ok().is_none() || end.is_err() || end.ok().is_none() {
                println!("Skiping loading configuration");
                continue;
            }

            let start = start.ok().unwrap();
            let end = end.ok().unwrap();

            local_led_config.push(LocalLedConfiguration { tag, start, end });
        }

        self.num_leds = current_pos;
        println!(
            "Loaded: {} leds, with config: {:?}",
            self.num_leds, local_led_config
        );
        self.local_led_config = local_led_config;

        self.ws = Some(Ws2812Rpi::new(current_pos as i32, PIN).unwrap());

        Ok(())
    }

    pub fn add_animation(&mut self, animation: Animation) {
        println!("Added animation");

        let mut key_frames = Vec::new();

        for frame in animation.get_frames().iter() {
            let mut light_settings = Vec::new();

            for setting in frame.get_settings() {
                light_settings.push(LigthSetting {
                    tags: setting.get_tags(),
                    start: try_into_usize(setting.get_start()),
                    end: try_into_usize(setting.get_end()),
                    color: RGB8::new(setting.get_r(), setting.get_g(), setting.get_b()),
                });
            }

            key_frames.push(KeyFrame {
                duration: (frame.get_duration() as u128) * (1000 as u128),
                settings: light_settings,
            })
        }

        let new_animation = RenderAnimation {
            key_frames,
            priority: animation.get_priority(),
            name: animation.get_name(),
            current_frame: 0,
            start_time: 0,
            reset: animation.get_repeat(),
        };

        self.animations.push(new_animation);

        self.animations
            .sort_by(|a, b| a.priority.partial_cmp(&b.priority).unwrap())
    }

    pub fn blank(&mut self) {
        self.animations = Vec::new();
    }

    pub fn remove_animation(&mut self, animation_name: String) {
        self.animations = self
            .animations
            .clone()
            .into_iter()
            .filter(|ani| !ani.name.eq(&animation_name))
            .collect::<Vec<RenderAnimation>>();
    }

    pub fn proccess_settings(&mut self, data: &mut Vec<RGB<f64>>, settings: &Vec<LigthSetting>) {
        fn load_led_into_light(data: &mut Vec<RGB<f64>>, color: RGB8, start: usize, end: usize) {
            for i in start..=end {
                data[i] = RGB::new(color.r as f64, color.g as f64, color.b as f64);
            }
        }

        for setting in settings {
            if setting.tags.is_some() {
                let tags = setting.tags.as_ref().unwrap().to_string();
                let tags = tags.split(",");
                let tags_fn = |t: String| tags.clone().into_iter().any(|tag| tag.eq(&t));
                for config in self.local_led_config.clone() {
                    if config.tag.is_some() && tags_fn(config.tag.unwrap()) {
                        load_led_into_light(data, setting.color, config.start, config.end);
                    }
                }
            }

            if setting.start.is_some() && setting.end.is_some() {
                load_led_into_light(
                    data,
                    setting.color,
                    setting.start.unwrap(),
                    setting.end.unwrap(),
                );
            }
        }
    }

    fn get_render(&mut self) -> GetRender {
        let mut data: Vec<RGB<f64>> = vec![RGB::default(); self.num_leds.try_into().unwrap()];

        let time = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("Time went backwards")
            .as_millis();

        if self.last_render == 0 {
            self.last_render = time;
        }

        let delta = time - self.last_render;

        self.last_render = time;

        let mut to_clean: Vec<String> = Vec::new();

        let animations = self
            .animations
            .clone()
            .iter_mut()
            .map(|animation| {
                let mut animation = animation.to_owned();

                let mut start_time = animation.start_time;

                if start_time == 0 {
                    animation.start_time = time;
                    animation.current_frame = 0;

                    self.proccess_settings(&mut data, &animation.key_frames[0].settings);
                    return animation;
                }

                while start_time + animation.key_frames[animation.current_frame].duration < time {
                    start_time += animation.key_frames[animation.current_frame].duration;
                    animation.start_time = start_time;

                    if animation.current_frame + 1 >= animation.key_frames.len() {
                        if animation.reset {
                            animation.start_time = time;
                            animation.current_frame = 0;
                            self.proccess_settings(&mut data, &animation.key_frames[0].settings);
                        } else {
                            to_clean.push(animation.name.to_string());
                        }
                        return animation;
                    }

                    animation.current_frame += 1;
                }

                let cf = animation.current_frame;

                self.proccess_settings(&mut data, &animation.key_frames[cf].settings);

                return animation;
            })
            .collect();

        self.animations = animations;

        to_clean
            .iter()
            .for_each(|i| self.remove_animation(i.to_string()));

        return GetRender { data, delta, time };
    }

    pub fn render(&mut self) {
        if self.ws.is_none() {
            return;
        }

        let get_render = self.get_render();

        let data = get_render.data;
        let delta = get_render.delta;
        let time = get_render.time;

        if self.last.is_empty() || !self.last.clone().iter().eq(data.clone().iter()) {
            if self.last.len() == 0 {
                self.last = data.clone();
            }

            let lerp_data: Vec<RGB<f64>> = data
                .iter()
                .zip(&self.last)
                .map(|(d, l)| l.lerp(d, delta as f64))
                .collect();

            if (time - self.last_update) < 33 {
                self.last = lerp_data;
                return;
            }

            println!("Render");

            self.last_update = time;


            //println!("d:{:?}\n l:{:?}", data[25], lerp_data[25]);

            let to_set_data: Vec<RGB<u8>> = rgbs_f64_to_u8(&lerp_data);

            let err = self.ws.as_mut().unwrap().write(to_set_data.into_iter());

            if err.is_err() || err.ok().is_none() {
                println!("Failed to write data");
            }

            self.last = lerp_data;
        }
    }

    pub fn im_render(&mut self) {
        if self.ws.is_none() {
            return;
        }

        let data = self.get_render().data;

        if self.last.is_empty() || !self.last.clone().iter().eq(data.clone().iter()) {
            if self.last.len() == 0 {
                self.last = data.clone();
            }

            let to_set_data: Vec<RGB<u8>> = rgbs_f64_to_u8(&data);

            let err = self.ws.as_mut().unwrap().write(to_set_data.into_iter());

            if err.is_err() || err.ok().is_none() {
                println!("Failed to write data");
            }

            self.last = data;
        }
    }
}

pub fn rgbs_f64_to_u8(data: &Vec<RGB<f64>>) -> Vec<RGB<u8>> {
    data.clone()
        .iter()
        .map(|a| RGB::new(a.r as u8, a.g as u8, a.b as u8))
        .collect()
}

pub trait Lerp {
    fn lerp(self, other: &Self, diff: f64) -> Self;
}

impl Lerp for f64 {
    fn lerp(self, other: &Self, diff: f64) -> Self {
        let delta = diff / 1000.0;

        let change = (*other - self) * 0.8 * delta;

        let lerped = self + change;

        if (*other - self).abs() < 0.49 && diff != 0.0 {
            *other
        } else {
            lerped
        }
    }
}

impl Lerp for RGB<f64> {
    fn lerp(self, other: &Self, diff: f64) -> Self {
        RGB::new(
            self.r.lerp(&other.r, diff),
            self.g.lerp(&other.g, diff),
            self.b.lerp(&other.b, diff),
        )
    }
}