use crate::patterns::{Pattern, PixelColor};
use crate::Strip;
use serde::{Deserialize, Serialize};

/// # fade pattern
/// fade from one color to an other
#[derive(Serialize, Deserialize, Debug, Eq, Hash, PartialEq, Copy, Clone)]
pub struct Fade<const N: usize> {
    #[serde(default)]
    pub(crate) current_iteration: usize,
    pub(crate) steps: usize,
    pub(crate) begin_color: PixelColor,
    pub(crate) end_color: PixelColor,
}

fn fade_value(value_start: u8, value_end: u8, index: usize, nbr_iter: usize) -> u8 {
    ((value_start as usize * (nbr_iter - index) + value_end as usize * index) / nbr_iter) as u8
}

impl<const N: usize> Pattern for Fade<N> {
    type Strip = Strip<N>;

    fn init(&mut self) -> Option<Self::Strip> {
        None
    }

    fn is_last_iteration(&self) -> bool {
        self.current_iteration >= self.steps
    }
}

impl<const N: usize> Iterator for Fade<N> {
    type Item = Strip<N>;

    fn next(&mut self) -> Option<Self::Item> {
        let mut strip = Strip::default();

        if self.is_last_iteration() {
            return None;
        }

        let red = fade_value(
            self.begin_color.red,
            self.end_color.red,
            self.current_iteration,
            self.steps,
        );
        let green = fade_value(
            self.begin_color.green,
            self.end_color.green,
            self.current_iteration,
            self.steps,
        );
        let blue = fade_value(
            self.begin_color.blue,
            self.end_color.blue,
            self.current_iteration,
            self.steps,
        );

        let current_color = PixelColor { red, green, blue };

        strip.fill(current_color);

        self.current_iteration += 1;
        Some(strip)
    }
}