use std::collections::HashMap;

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

use crate::{handle::SpriteHandle, Content, ContentBuildContext, EffectHandle, OutfitSpace};

pub(crate) mod syntax {
	use crate::part::{effect::syntax::EffectReference, outfitspace};
	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 mass: f32,
		pub collision: Vec<[f32; 2]>,
		pub angular_drag: f32,
		pub linear_drag: f32,
		pub space: outfitspace::syntax::OutfitSpace,
		pub collapse: Option<Collapse>,
		pub damage: Option<Damage>,
	}

	#[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,
	}

	#[derive(Debug, Deserialize)]
	pub struct Damage {
		pub hull: f32,
		pub effects: Vec<DamageEffectSpawner>,
	}

	#[derive(Debug, Deserialize)]
	pub struct DamageEffectSpawner {
		pub effect: EffectReference,
		pub frequency: f32,
		pub pos: Option<[f32; 2]>,
	}

	// TODO:
	// plural or not? document!
	#[derive(Debug, Deserialize)]
	pub struct Collapse {
		pub length: f32,
		pub effects: Vec<CollapseEffectSpawner>,
		pub event: Vec<CollapseEvent>,
	}

	#[derive(Debug, Deserialize)]
	pub struct CollapseEffectSpawner {
		pub effect: EffectReference,
		pub count: f32,
		pub pos: Option<[f32; 2]>,
	}

	#[derive(Debug, Deserialize)]
	#[serde(untagged)]
	pub enum CollapseEvent {
		Effect(EffectCollapseEvent),
	}

	#[derive(Debug, Deserialize)]
	pub struct EffectCollapseEvent {
		pub time: f32,
		pub effects: Vec<CollapseEffectSpawner>,
	}
}

// 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: SpriteHandle,

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

	/// The mass of this ship
	pub mass: 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,

	/// Reduction in angular velocity over time
	pub angular_drag: f32,

	/// Reduction in velocity over time
	pub linear_drag: f32,

	/// Outfit space in this ship
	pub space: OutfitSpace,

	/// Ship collapse sequence
	pub collapse: ShipCollapse,

	/// Damaged ship effects
	pub damage: ShipDamage,
}

/// 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>,
}

/// Parameters for a ship's collapse sequence
#[derive(Debug, Clone)]
pub struct ShipCollapse {
	/// Collapse sequence length, in seconds
	pub length: f32,

	/// Effects to create during collapse
	pub effects: Vec<CollapseEffectSpawner>,

	/// Scripted events during ship collapse
	pub events: Vec<CollapseEvent>,
}

/// Parameters for damaged ship effects
#[derive(Debug, Clone)]
pub struct ShipDamage {
	/// Show damaged ship effects if hull is below this value
	pub hull: f32,

	/// Effects to create during collapse
	pub effects: Vec<DamageEffectSpawner>,
}

/// An effect shown when a ship is damaged
#[derive(Debug, Clone)]
pub struct DamageEffectSpawner {
	/// The effect to create
	pub effect: EffectHandle,

	/// How often to create this effect
	pub frequency: f32,

	/// Where to create is effect.
	/// Position is random if None.
	pub pos: Option<Point2<f32>>,
}

/// An effect shown during a ship collapse sequence
#[derive(Debug, Clone)]
pub struct CollapseEffectSpawner {
	/// The effect to create
	pub effect: EffectHandle,

	/// How many effects to create
	pub count: f32,

	/// Where to create this effect.
	/// Position is random if None.
	pub pos: Option<Point2<f32>>,
}

/// A scripted event during a ship collapse sequence
#[derive(Debug, Clone)]
pub enum CollapseEvent {
	/// A scripted effect during a ship collapse sequence
	Effect(EffectCollapseEvent),
}

/// A scripted effect during a ship collapse sequence
#[derive(Debug, Clone)]
pub struct EffectCollapseEvent {
	/// When to trigger this event
	pub time: f32,

	/// The effect to create
	pub effects: Vec<CollapseEffectSpawner>,
}

impl crate::Build for Ship {
	type InputSyntaxType = HashMap<String, syntax::Ship>;

	fn build(
		ship: Self::InputSyntaxType,
		build_context: &mut ContentBuildContext,
		ct: &mut Content,
	) -> Result<()> {
		for (ship_name, ship) in ship {
			let handle = match ct.sprite_index.get(&ship.sprite) {
				None => bail!(
					"In ship `{}`: sprite `{}` doesn't exist",
					ship_name,
					ship.sprite
				),
				Some(t) => *t,
			};

			let size = ship.size;
			let aspect = ct.get_sprite(handle).aspect;

			let collapse = {
				if let Some(c) = ship.collapse {
					let mut effects = Vec::new();
					for e in c.effects {
						effects.push(CollapseEffectSpawner {
							effect: e
								.effect
								.to_handle(build_context, ct)
								.with_context(|| format!("while loading ship `{}`", ship_name))?,
							count: e.count,
							pos: e.pos.map(|p| Point2 {
								x: p[0] * (size / 2.0) * aspect,
								y: p[1] * size / 2.0,
							}),
						});
					}

					let mut events = Vec::new();
					for e in c.event {
						match e {
							syntax::CollapseEvent::Effect(e) => {
								let mut effects = Vec::new();
								for g in e.effects {
									effects.push(CollapseEffectSpawner {
										effect: g
											.effect
											.to_handle(build_context, ct)
											.with_context(|| {
												format!("while loading ship `{}`", ship_name)
											})?,
										count: g.count,
										pos: g.pos.map(|p| Point2 {
											x: p[0] * (size / 2.0) * aspect,
											y: p[1] * size / 2.0,
										}),
									})
								}

								events.push(CollapseEvent::Effect(EffectCollapseEvent {
									time: e.time,
									effects,
								}))
							}
						}
					}

					ShipCollapse {
						length: c.length,
						effects,
						events,
					}
				} else {
					// Default collapse sequence
					ShipCollapse {
						length: 0.0,
						effects: vec![],
						events: vec![],
					}
				}
			};

			let damage = {
				if let Some(c) = ship.damage {
					let mut effects = Vec::new();
					for e in c.effects {
						effects.push(DamageEffectSpawner {
							effect: e
								.effect
								.to_handle(build_context, ct)
								.with_context(|| format!("while loading ship `{}`", ship_name))?,
							frequency: e.frequency,
							pos: e.pos.map(|p| Point2 {
								x: p[0] * (size / 2.0) * aspect,
								y: p[1] * size / 2.0,
							}),
						});
					}

					ShipDamage {
						hull: c.hull,
						effects: effects,
					}
				} else {
					// Default damage effects
					ShipDamage {
						hull: 0.0,
						effects: vec![],
					}
				}
			};

			ct.ships.push(Self {
				aspect,
				collapse,
				damage,
				name: ship_name,
				sprite: handle,
				mass: ship.mass,
				space: OutfitSpace::from(ship.space),
				angular_drag: ship.angular_drag,
				linear_drag: ship.linear_drag,
				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: (0..ship.collision.len())
						.map(|x| {
							// Auto-generate mesh lines:
							// [ [0, 1], [1, 2], ..., [n, 0] ]
							let next = if x == ship.collision.len() - 1 {
								0
							} else {
								x + 1
							};
							[x as u32, next as u32]
						})
						.collect(),
					points: ship
						.collision
						.iter()
						.map(|x| point![x[0] * (size / 2.0) * aspect, x[1] * size / 2.0])
						.collect(),
				},
			});
		}

		return Ok(());
	}
}