use anyhow::Result;
use cgmath::Point2;

pub(super) mod syntax {
	use serde::Deserialize;
	// Raw serde syntax structs.
	// These are never seen by code outside this crate.

	#[derive(Debug, Deserialize)]
	pub struct Ship {
		pub sprite: String,
		pub size: f32,
		pub engines: Vec<Engine>,
		pub guns: Vec<Gun>,
		pub hull: f32,
	}

	#[derive(Debug, Deserialize)]
	pub struct Engine {
		pub x: f32,
		pub y: f32,
		pub size: f32,
	}

	#[derive(Debug, Deserialize)]
	pub struct Gun {
		pub x: f32,
		pub y: f32,
	}
}

// Processed data structs.
// These are exported.

#[derive(Debug, Clone)]
pub struct Ship {
	pub name: String,
	pub sprite: String,
	pub size: f32,
	pub engines: Vec<EnginePoint>,
	pub guns: Vec<GunPoint>,
	pub hull: f32,
}

#[derive(Debug, Clone)]
pub struct EnginePoint {
	pub pos: Point2<f32>,
	pub size: f32,
}

#[derive(Debug, Clone)]
pub struct GunPoint {
	pub pos: Point2<f32>,
}

impl super::Build for Ship {
	fn build(root: &super::syntax::Root) -> Result<Vec<Self>> {
		let ship = if let Some(ship) = &root.ship {
			ship
		} else {
			return Ok(vec![]);
		};

		let mut out = Vec::new();
		for (ship_name, ship) in ship {
			let size = ship.size;

			out.push(Self {
				name: ship_name.to_owned(),
				sprite: ship.sprite.to_owned(),
				size,
				hull: ship.hull,
				engines: ship
					.engines
					.iter()
					.map(|e| EnginePoint {
						pos: Point2 {
							x: e.x * size,
							y: e.y * size,
						},
						size: e.size,
					})
					.collect(),
				guns: ship
					.guns
					.iter()
					.map(|e| GunPoint {
						pos: Point2 {
							x: e.x * size,
							y: e.y * size,
						},
					})
					.collect(),
			});
		}

		return Ok(out);
	}
}