use std::collections::HashMap;

use anyhow::{bail, Result};
use cgmath::Point2;
use nalgebra::{point, Point};

use crate::{Content, TextureHandle};

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,
		pub collision: Collision,
		pub aspect: f32,
	}

	#[derive(Debug, Deserialize)]
	pub struct Collision {
		pub points: Vec<[f32; 2]>,
		pub indices: Vec<[u32; 2]>,
	}

	#[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.

/// Represents a ship chassis.
#[derive(Debug, Clone)]
pub struct Ship {
	/// This ship's name
	pub name: String,

	/// This ship's sprite
	pub sprite: TextureHandle,

	/// The size of this ship.
	/// Measured as unrotated height,
	/// in terms of game units.
	pub size: f32,

	/// Engine points on this ship.
	/// This is where engine flares are drawn.
	pub engines: Vec<EnginePoint>,

	/// Gun points on this ship.
	/// A gun outfit can be mounted on each.
	pub guns: Vec<GunPoint>,

	/// This ship's hull strength
	pub hull: f32,

	/// Collision shape for this ship
	pub collision: Collision,

	/// Remove later
	pub aspect: f32,
}

/// Collision shape for this ship
#[derive(Debug, Clone)]
pub struct Collision {
	pub points: Vec<Point<f32, 2>>,
	pub indices: Vec<[u32; 2]>,
}

/// An engine point on a ship.
/// This is where flares are drawn.
#[derive(Debug, Clone)]
pub struct EnginePoint {
	/// This engine point's position, in game units,
	/// relative to the ship's center.
	pub pos: Point2<f32>,

	/// The size of the flare that should be drawn
	/// at this point, measured as height in game units.
	pub size: f32,
}

/// A gun point on a ship.
#[derive(Debug, Clone)]
pub struct GunPoint {
	/// This gun point's position, in game units,
	/// relative to the ship's center.
	pub pos: Point2<f32>,
}

impl super::Build for Ship {
	type InputSyntax = HashMap<String, syntax::Ship>;

	fn build(ship: Self::InputSyntax, ct: &mut Content) -> Result<()> {
		for (ship_name, ship) in ship {
			let size = ship.size;
			let aspect = ship.aspect;

			let th = match ct.texture_index.get(&ship.sprite) {
				None => bail!(
					"In ship `{}`: texture `{}` doesn't exist",
					ship_name,
					ship.sprite
				),
				Some(t) => *t,
			};

			ct.ships.push(Self {
				aspect,
				name: ship_name.to_owned(),
				sprite: th,
				size,
				hull: ship.hull,
				engines: ship
					.engines
					.iter()
					.map(|e| EnginePoint {
						pos: Point2 {
							x: e.x * size * aspect / 2.0,
							y: e.y * size / 2.0,
						},
						size: e.size,
					})
					.collect(),
				guns: ship
					.guns
					.iter()
					.map(|e| GunPoint {
						pos: Point2 {
							x: e.x * size * aspect / 2.0,
							y: e.y * size / 2.0,
						},
					})
					.collect(),
				collision: Collision {
					indices: ship.collision.indices.clone(),
					points: ship
						.collision
						.points
						.iter()
						.map(|x| point![x[0] * (size / 2.0) * aspect, x[1] * size / 2.0])
						.collect(),
				},
			});
		}

		return Ok(());
	}
}