use anyhow::Result;
use bytemuck;
use cgmath::{EuclideanSpace, Matrix4, Point2, Rad, Vector3};
use galactica_constants;
use rand::seq::SliceRandom;
use std::{iter, rc::Rc};
use wgpu;
use winit::{self, dpi::LogicalSize, window::Window};

use crate::{
	content,
	globaluniform::{GlobalDataContent, GlobalUniform, ObjectData},
	pipeline::PipelineBuilder,
	starfield::Starfield,
	texturearray::TextureArray,
	vertexbuffer::{
		consts::{SPRITE_INDICES, SPRITE_VERTICES},
		types::{ObjectInstance, ParticleInstance, StarfieldInstance, TexturedVertex, UiInstance},
		BufferObject, VertexBuffer,
	},
	ObjectSprite, RenderState, UiSprite, OPENGL_TO_WGPU_MATRIX,
};

/// A high-level GPU wrapper. Consumes game state,
/// produces pretty pictures.
pub struct GPUState {
	/// The window to we draw on
	pub window: Window,

	/// The size of the window we draw on
	pub window_size: winit::dpi::PhysicalSize<u32>,

	device: wgpu::Device,
	config: wgpu::SurfaceConfiguration,
	surface: wgpu::Surface,
	queue: wgpu::Queue,

	window_aspect: f32,

	object_pipeline: wgpu::RenderPipeline,
	starfield_pipeline: wgpu::RenderPipeline,
	particle_pipeline: wgpu::RenderPipeline,
	ui_pipeline: wgpu::RenderPipeline,

	starfield: Starfield,
	texture_array: TextureArray,
	global_uniform: GlobalUniform,
	vertex_buffers: VertexBuffers,
}

struct VertexBuffers {
	object: Rc<VertexBuffer>,
	starfield: Rc<VertexBuffer>,
	ui: Rc<VertexBuffer>,

	/// The index of the next particle slot we'll write to.
	/// This must cycle to 0 whenever it exceeds the size
	/// of the particle instance array.
	particle_array_head: u64,
	particle: Rc<VertexBuffer>,
}

/// Basic wgsl preprocesser
fn preprocess_shader(
	shader: &str,
	global_uniform: &GlobalUniform,
	global_uniform_group: u32,
) -> String {
	// Insert dynamically-generated global definitions
	let shader = shader.replace(
		"// INCLUDE: global uniform header",
		&global_uniform.shader_header(global_uniform_group),
	);

	// Insert common functions
	let shader = shader.replace(
		"// INCLUDE: animate.wgsl",
		&include_str!(concat!(
			env!("CARGO_MANIFEST_DIR"),
			"/shaders/include/",
			"animate.wgsl"
		)),
	);

	return shader;
}

impl GPUState {
	/// Make a new GPUState that draws on `window`
	pub async fn new(window: Window, ct: &content::Content) -> Result<Self> {
		let window_size = window.inner_size();
		let window_aspect = window_size.width as f32 / window_size.height as f32;

		let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
			backends: wgpu::Backends::all(),
			..Default::default()
		});

		let surface = unsafe { instance.create_surface(&window) }.unwrap();

		// Basic setup
		let device;
		let queue;
		let config;

		{
			let adapter = instance
				.request_adapter(&wgpu::RequestAdapterOptions {
					power_preference: wgpu::PowerPreference::default(),
					compatible_surface: Some(&surface),
					force_fallback_adapter: false,
				})
				.await
				.unwrap();

			(device, queue) = adapter
				.request_device(
					&wgpu::DeviceDescriptor {
						features: wgpu::Features::TEXTURE_BINDING_ARRAY | wgpu::Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
						// We may need limits if we compile for wasm
						limits: wgpu::Limits::default(),
						label: Some("gpu device"),
					},
					None,
				)
				.await
				.unwrap();

			// Assume sRGB
			let surface_caps = surface.get_capabilities(&adapter);
			let surface_format = surface_caps
				.formats
				.iter()
				.copied()
				.filter(|f| f.is_srgb())
				.filter(|f| f.has_stencil_aspect())
				.next()
				.unwrap_or(surface_caps.formats[0]);

			config = wgpu::SurfaceConfiguration {
				usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
				format: surface_format,
				width: window_size.width,
				height: window_size.height,
				present_mode: surface_caps.present_modes[0],
				alpha_mode: surface_caps.alpha_modes[0],
				view_formats: vec![],
			};

			surface.configure(&device, &config);
		}

		let vertex_buffers = VertexBuffers {
			object: Rc::new(VertexBuffer::new::<TexturedVertex, ObjectInstance>(
				"object",
				&device,
				Some(SPRITE_VERTICES),
				Some(SPRITE_INDICES),
				galactica_constants::OBJECT_SPRITE_INSTANCE_LIMIT,
			)),

			starfield: Rc::new(VertexBuffer::new::<TexturedVertex, StarfieldInstance>(
				"starfield",
				&device,
				Some(SPRITE_VERTICES),
				Some(SPRITE_INDICES),
				galactica_constants::STARFIELD_SPRITE_INSTANCE_LIMIT,
			)),

			ui: Rc::new(VertexBuffer::new::<TexturedVertex, UiInstance>(
				"ui",
				&device,
				Some(SPRITE_VERTICES),
				Some(SPRITE_INDICES),
				galactica_constants::UI_SPRITE_INSTANCE_LIMIT,
			)),

			particle_array_head: 0,
			particle: Rc::new(VertexBuffer::new::<TexturedVertex, ParticleInstance>(
				"particle",
				&device,
				Some(SPRITE_VERTICES),
				Some(SPRITE_INDICES),
				galactica_constants::PARTICLE_SPRITE_INSTANCE_LIMIT,
			)),
		};

		// Load uniforms
		let global_uniform = GlobalUniform::new(&device);
		let texture_array = TextureArray::new(&device, &queue, ct)?;

		// Make sure these match the indices in each shader
		let bind_group_layouts = &[
			&texture_array.bind_group_layout,
			&global_uniform.bind_group_layout,
		];

		// Create render pipelines
		let object_pipeline = PipelineBuilder::new("object", &device)
			.set_shader(&preprocess_shader(
				&include_str!(concat!(
					env!("CARGO_MANIFEST_DIR"),
					"/shaders/",
					"object.wgsl"
				)),
				&global_uniform,
				1,
			))
			.set_format(config.format)
			.set_triangle(true)
			.set_vertex_buffer(&vertex_buffers.object)
			.set_bind_group_layouts(bind_group_layouts)
			.build();

		let starfield_pipeline = PipelineBuilder::new("starfield", &device)
			.set_shader(&preprocess_shader(
				&include_str!(concat!(
					env!("CARGO_MANIFEST_DIR"),
					"/shaders/",
					"starfield.wgsl"
				)),
				&global_uniform,
				1,
			))
			.set_format(config.format)
			.set_triangle(true)
			.set_vertex_buffer(&vertex_buffers.starfield)
			.set_bind_group_layouts(bind_group_layouts)
			.build();

		let ui_pipeline = PipelineBuilder::new("ui", &device)
			.set_shader(&preprocess_shader(
				&include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/shaders/", "ui.wgsl")),
				&global_uniform,
				1,
			))
			.set_format(config.format)
			.set_triangle(true)
			.set_vertex_buffer(&vertex_buffers.ui)
			.set_bind_group_layouts(bind_group_layouts)
			.build();

		let particle_pipeline = PipelineBuilder::new("particle", &device)
			.set_shader(&preprocess_shader(
				&include_str!(concat!(
					env!("CARGO_MANIFEST_DIR"),
					"/shaders/",
					"particle.wgsl"
				)),
				&global_uniform,
				1,
			))
			.set_format(config.format)
			.set_triangle(true)
			.set_vertex_buffer(&vertex_buffers.particle)
			.set_bind_group_layouts(bind_group_layouts)
			.build();

		let mut starfield = Starfield::new();
		starfield.regenerate();

		return Ok(Self {
			device,
			config,
			surface,
			queue,

			window,
			window_size,
			window_aspect,

			object_pipeline,
			starfield_pipeline,
			ui_pipeline,
			particle_pipeline,

			starfield,
			texture_array,
			global_uniform,
			vertex_buffers,
		});
	}

	/// Get the window this GPUState is attached to
	pub fn window(&self) -> &Window {
		&self.window
	}

	/// Update window size.
	/// This should be called whenever our window is resized.
	pub fn resize(&mut self) {
		let new_size = self.window.inner_size();
		if new_size.width > 0 && new_size.height > 0 {
			self.window_size = new_size;
			self.window_aspect = new_size.width as f32 / new_size.height as f32;
			self.config.width = new_size.width;
			self.config.height = new_size.height;
			self.surface.configure(&self.device, &self.config);
		}
		self.update_starfield_buffer()
	}

	/// Create a ObjectInstance for an object and add it to `instances`.
	fn push_object_sprite(
		&self,
		state: &RenderState,
		instances: &mut Vec<ObjectInstance>,
		clip_ne: Point2<f32>,
		clip_sw: Point2<f32>,
		s: &ObjectSprite,
	) {
		// Position adjusted for parallax
		// TODO: adjust parallax for zoom?
		let pos: Point2<f32> = {
			(Point2 {
				x: s.pos.x,
				y: s.pos.y,
			} - state.camera_pos.to_vec())
				/ s.pos.z
		};

		// Game dimensions of this sprite post-scale.
		// Post-scale width or height, whichever is larger.
		// This is in game units.
		//
		// We take the maximum to account for rotated sprites.
		let m = (s.size / s.pos.z) * s.sprite.aspect.max(1.0);

		// Don't draw sprites that are off the screen
		if pos.x < clip_ne.x - m
			|| pos.y > clip_ne.y + m
			|| pos.x > clip_sw.x + m
			|| pos.y < clip_sw.y - m
		{
			return;
		}

		let idx = instances.len();
		// Write this object's location data
		self.queue.write_buffer(
			&self.global_uniform.object_buffer,
			ObjectData::SIZE * idx as u64,
			bytemuck::cast_slice(&[ObjectData {
				xpos: s.pos.x,
				ypos: s.pos.y,
				zpos: s.pos.z,
				angle: Rad::from(s.angle).0,
				size: s.size,
				parent: 0,
				is_child: 0,
				_padding: Default::default(),
			}]),
		);

		// Push this object's instance
		instances.push(ObjectInstance {
			sprite_index: s.sprite.get_index(),
			object_index: idx as u32,
		});

		// Add children
		if let Some(children) = &s.children {
			for c in children {
				self.queue.write_buffer(
					&self.global_uniform.object_buffer,
					ObjectData::SIZE * instances.len() as u64,
					bytemuck::cast_slice(&[ObjectData {
						xpos: c.pos.x,
						ypos: c.pos.y,
						zpos: c.pos.z,
						angle: Rad::from(c.angle).0,
						size: c.size,
						parent: idx as u32,
						is_child: 1,
						_padding: Default::default(),
					}]),
				);

				instances.push(ObjectInstance {
					sprite_index: c.sprite.get_index(),
					object_index: instances.len() as u32,
				});
			}
		}
	}

	/// Create a UiInstance for a ui sprite and add it to `instances`
	fn push_ui_sprite(&self, instances: &mut Vec<UiInstance>, s: &UiSprite) {
		let logical_size: LogicalSize<f32> =
			self.window_size.to_logical(self.window.scale_factor());

		let width = s.dimensions.x;
		let height = s.dimensions.y;

		// Compute square scale, since we must apply screen aspect ratio
		// AFTER rotation.
		let scale = Matrix4::from_nonuniform_scale(
			width / logical_size.height,
			height / logical_size.height,
			1.0,
		);
		let rotate = Matrix4::from_angle_z(s.angle);
		let translate = Matrix4::from_translation(match s.pos {
			super::AnchoredUiPosition::NwC(p) => Vector3 {
				// Note the signs. Positive y points north!
				x: -1.0 + p.x / (logical_size.width / 2.0),
				y: 1.0 + p.y / (logical_size.height / 2.0),
				z: 0.0,
			},
			super::AnchoredUiPosition::NwNw(p) => Vector3 {
				x: -1.0 + (width / 2.0 + p.x) / (logical_size.width / 2.0),
				y: 1.0 - (height / 2.0 - p.y) / (logical_size.height / 2.0),
				z: 0.0,
			},
			super::AnchoredUiPosition::NwNe(p) => Vector3 {
				x: -1.0 - (width / 2.0 - p.x) / (logical_size.width / 2.0),
				y: 1.0 - (height / 2.0 - p.y) / (logical_size.height / 2.0),
				z: 0.0,
			},
			super::AnchoredUiPosition::NwSw(p) => Vector3 {
				x: -1.0 + (width / 2.0 + p.x) / (logical_size.width / 2.0),
				y: 1.0 + (height / 2.0 + p.y) / (logical_size.height / 2.0),
				z: 0.0,
			},
			super::AnchoredUiPosition::NwSe(p) => Vector3 {
				x: -1.0 - (width / 2.0 - p.x) / (logical_size.width / 2.0),
				y: 1.0 + (height / 2.0 + p.y) / (logical_size.height / 2.0),
				z: 0.0,
			},
		});
		let screen_aspect = Matrix4::from_nonuniform_scale(1.0 / self.window_aspect, 1.0, 1.0);

		instances.push(UiInstance {
			transform: (OPENGL_TO_WGPU_MATRIX * translate * screen_aspect * rotate * scale).into(),
			sprite_index: s.sprite.get_index(),
			color: s.color.unwrap_or([1.0, 1.0, 1.0, 1.0]),
		});
	}

	/// Make an instance for all the game's sprites
	/// (Objects and UI)
	/// This will Will panic if any X_SPRITE_INSTANCE_LIMIT is exceeded.
	fn update_sprite_instances(&self, state: &RenderState) -> (usize, usize) {
		let mut object_instances: Vec<ObjectInstance> = Vec::new();

		// Game coordinates (relative to camera) of ne and sw corners of screen.
		// Used to skip off-screen sprites.
		let clip_ne = Point2::from((-self.window_aspect, 1.0)) * state.camera_zoom;
		let clip_sw = Point2::from((self.window_aspect, -1.0)) * state.camera_zoom;

		for s in &state.object_sprites {
			self.push_object_sprite(state, &mut object_instances, clip_ne, clip_sw, &s);
		}

		// Enforce sprite limit
		if object_instances.len() as u64 > galactica_constants::OBJECT_SPRITE_INSTANCE_LIMIT {
			// TODO: no panic, handle this better.
			panic!("Sprite limit exceeded!")
		}

		self.queue.write_buffer(
			&self.vertex_buffers.object.instances,
			0,
			bytemuck::cast_slice(&object_instances),
		);

		let mut ui_instances: Vec<UiInstance> = Vec::new();

		for s in &state.ui_sprites {
			self.push_ui_sprite(&mut ui_instances, &s);
		}

		if ui_instances.len() as u64 > galactica_constants::UI_SPRITE_INSTANCE_LIMIT {
			panic!("Ui sprite limit exceeded!")
		}

		self.queue.write_buffer(
			&self.vertex_buffers.ui.instances,
			0,
			bytemuck::cast_slice(&ui_instances),
		);

		return (object_instances.len(), ui_instances.len());
	}

	/// Make a StarfieldInstance for each star that needs to be drawn.
	/// Will panic if STARFIELD_INSTANCE_LIMIT is exceeded.
	///
	/// Starfield data rarely changes, so this is called only when it's needed.
	pub fn update_starfield_buffer(&mut self) {
		self.queue.write_buffer(
			&self.vertex_buffers.starfield.instances,
			0,
			bytemuck::cast_slice(&self.starfield.make_instances(self.window_aspect)),
		);
	}

	/// Initialize the rendering engine
	pub fn init(&mut self) {
		// Update global values
		self.queue.write_buffer(
			&self.global_uniform.atlas_buffer,
			0,
			bytemuck::cast_slice(&[self.texture_array.image_locations]),
		);
		self.queue.write_buffer(
			&self.global_uniform.sprite_buffer,
			0,
			bytemuck::cast_slice(&[self.texture_array.sprite_data]),
		);

		self.update_starfield_buffer();
	}

	/// Main render function. Draws sprites on a window.
	pub fn render(&mut self, state: RenderState) -> Result<(), wgpu::SurfaceError> {
		let output = self.surface.get_current_texture()?;
		let view = output
			.texture
			.create_view(&wgpu::TextureViewDescriptor::default());

		let mut encoder = self
			.device
			.create_command_encoder(&wgpu::CommandEncoderDescriptor {
				label: Some("render encoder"),
			});

		let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
			label: Some("render pass"),

			color_attachments: &[Some(wgpu::RenderPassColorAttachment {
				view: &view,
				resolve_target: None,
				ops: wgpu::Operations {
					load: wgpu::LoadOp::Clear(wgpu::Color {
						r: 0.0,
						g: 0.0,
						b: 0.0,
						a: 1.0,
					}),
					store: wgpu::StoreOp::Store,
				},
			})],
			depth_stencil_attachment: None,
			occlusion_query_set: None,
			timestamp_writes: None,
		});

		let s = state.content.get_starfield_handle();

		// Update global values
		self.queue.write_buffer(
			&self.global_uniform.data_buffer,
			0,
			bytemuck::cast_slice(&[GlobalDataContent {
				camera_position: state.camera_pos.into(),
				camera_zoom: [state.camera_zoom, 0.0],
				camera_zoom_limits: [galactica_constants::ZOOM_MIN, galactica_constants::ZOOM_MAX],
				window_size: [
					self.window_size.width as f32,
					self.window_size.height as f32,
				],
				window_aspect: [self.window_aspect, 0.0],
				starfield_sprite: [s.get_index(), 0],
				starfield_tile_size: [galactica_constants::STARFIELD_SIZE as f32, 0.0],
				starfield_size_limits: [
					galactica_constants::STARFIELD_SIZE_MIN,
					galactica_constants::STARFIELD_SIZE_MAX,
				],
				current_time: [state.current_time, 0.0],
			}]),
		);

		// Write all new particles to GPU buffer
		state.new_particles.shuffle(&mut rand::thread_rng());
		for i in state.new_particles.iter() {
			self.queue.write_buffer(
				&self.vertex_buffers.particle.instances,
				ParticleInstance::SIZE * self.vertex_buffers.particle_array_head,
				bytemuck::cast_slice(&[ParticleInstance {
					position: [i.pos.x, i.pos.y],
					velocity: i.velocity.into(),
					angle: i.angle.0,
					angvel: i.angvel.0,
					size: i.size,
					sprite_index: i.sprite.get_index(),
					created: state.current_time,
					expires: state.current_time + i.lifetime,
				}]),
			);
			self.vertex_buffers.particle_array_head += 1;
			if self.vertex_buffers.particle_array_head
				== galactica_constants::PARTICLE_SPRITE_INSTANCE_LIMIT
			{
				self.vertex_buffers.particle_array_head = 0;
			}
		}
		state.new_particles.clear();

		// Create sprite instances
		let (n_object, n_ui) = self.update_sprite_instances(&state);

		// These should match the indices in each shader,
		// and should each have a corresponding bind group layout.
		render_pass.set_bind_group(0, &self.texture_array.bind_group, &[]);
		render_pass.set_bind_group(1, &self.global_uniform.bind_group, &[]);

		// Starfield pipeline
		self.vertex_buffers.starfield.set_in_pass(&mut render_pass);
		render_pass.set_pipeline(&self.starfield_pipeline);
		render_pass.draw_indexed(
			0..SPRITE_INDICES.len() as u32,
			0,
			0..self.starfield.instance_count,
		);

		// Sprite pipeline
		self.vertex_buffers.object.set_in_pass(&mut render_pass);
		render_pass.set_pipeline(&self.object_pipeline);
		render_pass.draw_indexed(0..SPRITE_INDICES.len() as u32, 0, 0..n_object as _);

		// Particle pipeline
		self.vertex_buffers.particle.set_in_pass(&mut render_pass);
		render_pass.set_pipeline(&self.particle_pipeline);
		render_pass.draw_indexed(
			0..SPRITE_INDICES.len() as u32,
			0,
			0..galactica_constants::PARTICLE_SPRITE_INSTANCE_LIMIT as _,
		);

		// Ui pipeline
		self.vertex_buffers.ui.set_in_pass(&mut render_pass);
		render_pass.set_pipeline(&self.ui_pipeline);
		render_pass.draw_indexed(0..SPRITE_INDICES.len() as u32, 0, 0..n_ui as _);

		// begin_render_pass borrows encoder mutably, so we can't call finish()
		// without dropping this variable.
		drop(render_pass);

		self.queue.submit(iter::once(encoder.finish()));
		output.present();

		Ok(())
	}
}