use std::fmt;

#[derive(Clone, Copy, Debug)]
pub struct PixelColor {
    pub(crate) red: u8,
    pub(crate) green: u8,
    pub(crate) blue: u8,
}

impl PixelColor {
    fn new() -> Self {
        Default::default()
    }
}

impl fmt::Display for PixelColor {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "[{},{},{}]", self.red, self.green, self.blue)
    }
}

impl Default for PixelColor {
    fn default() -> Self {
        PixelColor {
            red: 0,
            green: 0,
            blue: 0,
        }
    }
}

#[derive(Copy, Clone)]
pub struct Strip<const N: usize> {
    pub strip: [PixelColor; N],
}

impl<const N: usize> Strip<N> {
    pub fn to_array(&self) -> Vec<u8> {
        let mut data: Vec<u8> = vec![];

        for i in 0..N {
            data.append(&mut vec![
                self.strip[i].red,
                self.strip[i].green,
                self.strip[i].blue,
            ]);
        }
        data
    }
}

impl<const N: usize> Default for Strip<N> {
    fn default() -> Self {
        Strip {
            strip: [PixelColor::new(); N],
        }
    }
}

pub struct RainbowPattern<const N: usize> {
    pub(crate) current_iteration: usize,
    pub(crate) max_iteration: Option<usize>,
}

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

    fn next(&mut self) -> Option<Self::Item> {
        if let Some(nbr_iteration) = self.max_iteration {
            if nbr_iteration == self.current_iteration {
                return None;
            }
        }
        let mut strip = Strip::default();
        let step = 255 / N;
        for i in 0..N {
            let pos = (i * step + self.current_iteration) as u8;
            strip.strip[i] = wheel(pos)
        }
        self.current_iteration = self.current_iteration + 1;
        Some(strip)
    }
}

fn wheel(index: u8) -> PixelColor {
    let pos = 255 - index;
    match pos {
        0..=85 => PixelColor {
            red: 255 - (pos * 3),
            green: 0,
            blue: pos * 3,
        },
        86..=170 => {
            let pos = pos - 85;
            PixelColor {
                red: 0,
                green: pos * 3,
                blue: 255 - (pos * 3),
            }
        }
        _ => {
            let pos = pos - 170;
            return PixelColor {
                red: pos * 3,
                green: 255 - (pos * 3),
                blue: 0,
            };
        }
    }
}