use ether_dream::protocol::DacPoint;

#[derive(Debug, Clone, Copy, Default, PartialEq)]
pub struct Point {
    pub x: f32,
    pub y: f32,
    pub color: Color,
}

#[derive(Debug, Clone, Copy, Default, PartialEq)]
pub struct Color {
    pub r: u8,
    pub g: u8,
    pub b: u8,
}

impl Point {
    pub fn diff(p1: &Self, p2: &Self) -> Self {
        Point {
            x: p1.x - p2.x,
            y: p1.y - p2.y,
            color: Color { r: 0, g: 0, b: 0 },
        }
    }

    pub fn normalize(&mut self) -> Self {
        let length = (self.x * self.x + self.y * self.y).sqrt();
        self.x = self.x / length;
        self.y = self.y / length;
        *self
    }

    pub fn cross(&self, pt: &Self) -> f32 {
        self.x * pt.x + self.y * pt.y
    }
}

// normalaize
// diff

impl From<Color> for u32 {
    fn from(value: Color) -> Self {
        let r = value.r as u32;
        let g = value.g as u32;
        let b = (value.b) as u32;
        (r << 16) + (g << 8) + b
    }
}

impl From<(f32, f32, u32)> for Point {
    fn from((x, y, color): (f32, f32, u32)) -> Point {
        let r = (color >> 16) as u8;
        let g = ((color >> 8) & 255) as u8;
        let b = (color & 255) as u8;
        Point {
            x,
            y,
            color: Color { r, g, b },
        }
    }
}

impl From<Point> for helios_dac::Point {
    fn from(pt: Point) -> helios_dac::Point {
        let x = pt.x.clamp(0.0, 4095.0) as u16;
        let y = pt.y.clamp(0.0, 4095.0) as u16;
        helios_dac::Point {
            coordinate: (x, y).into(),
            color: helios_dac::Color::new(pt.color.r, pt.color.g, pt.color.b),
            intensity: 0xFF,
        }
    }
}

impl From<Point> for DacPoint {
    fn from(pt: Point) -> DacPoint {
        let control = 0;
        let (u1, u2) = (0, 0);
        let i = 255;
        DacPoint {
            control,
            x: pt.x as i16,
            y: pt.y as i16,
            i,
            r: pt.color.r.into(),
            g: pt.color.g.into(),
            b: pt.color.b.into(),
            u1,
            u2,
        }
    }
}