use {
    prisma::{Rgb},
    cgmath::{Vector2},
    std::boxed::Box,
    crate::view::ColorGrid
};



pub trait FixtureDriver {
    fn send(&self, pixels: &Vec<Rgb<u8>>);
}

pub struct Fixture {
    pub resolution: Vector2<u32>,
    pub position: Vector2<f32>,
    pub rotation: f32,
    pub scale: f32,
    pub brightness: f32,
    pub buffer: Vec< Rgb<u8> >,
    pub driver: Option<Box<dyn FixtureDriver>>
}

impl Fixture {
    pub fn new_stripe() -> Self {
        let mut fixture = Fixture {
            resolution: Vector2::new(1, 72),
            position: Vector2::new(0.0, 0.0),
            rotation: 0.0,
            scale: 0.015,
            brightness: 0.8,
            buffer: Vec::new(),
            driver: None
        };
        fixture.buffer.resize(
            (fixture.resolution.x*fixture.resolution.y) as usize,
            Rgb::new(0,0,0));
        fixture
    }

    pub fn new_matrix() -> Self {
        let mut fixture = Fixture {
            resolution: Vector2::new(15, 20),
            position: Vector2::new(0.0, 0.0),
            rotation: 0.0,
            scale: 0.03,
            brightness: 0.8,
            buffer: Vec::new(),
            driver: None
        };
        fixture.buffer.resize(
            (fixture.resolution.x*fixture.resolution.y) as usize,
            Rgb::new(0,0,0)
        );
        fixture
    }

    pub fn with_driver(mut self, driver: Box<dyn FixtureDriver>) -> Self {
        self.driver = Some(driver);
        self
    }

    pub fn offset(mut self, offset: Vector2<f32>) -> Self {
        self.position += offset;
        self
    }

    pub fn get_global_pos(&self, pixel_pos: &Vector2<u32>) -> Vector2<f32> {
        let centered_pixpos : Vector2<f32>
            = pixel_pos.map(|f| f as f32) - (self.resolution.map(|f| f as f32)/2.0);
        self.position + centered_pixpos * self.scale
    }

    pub fn update_buffer(&mut self, view: &Box<dyn ColorGrid>) {
        for xi in 0 .. self.resolution.x {
            for yi in 0 ..self.resolution.y {
                let gpos = self.get_global_pos(&Vector2::new(xi, yi));
                let col = view.get(&gpos);

                let index = xi + yi * self.resolution.x;
                self.buffer[index as usize] = Rgb::new(
                    (col.red() * 255.0 * self.brightness) as u8,
                    (col.green() * 255.0 * self.brightness) as u8,
                    (col.blue() * 255.0 * self.brightness) as u8
                );
            }
        }
    }
}