use ether_dream::protocol::DacPoint;

fn clamp(val: f32, min: f32, max: f32) -> f32 {
	if val < min {
		return min;
	}
	if val > max {
		return max;
	}
	val
}

#[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 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 {
		print!(".");
		let control = 0;
		let (u1, u2) = (0, 0);
		let i = 255;
		let x = clamp(pt.x, -32000 as f32, 32000 as f32);
		let y = clamp(pt.y, -32000 as f32, 32000 as f32);
		DacPoint {
			control,
			x: x as i16,
			y: y as i16,
			i,
			r: pt.color.r.into(),
			g: pt.color.g.into(),
			b: pt.color.b.into(),
			u1,
			u2,
		}
	}
}