use std::error::Error;
use std::num::NonZeroU32;
use std::sync::Arc;

use alligator_resources::texture::{LoadError, Rgba16Texture, TextureId, TextureManager};
use image::{EncodableLayout, GenericImage, RgbaImage};
use texture_packer::TexturePacker;
use texture_packer::{
	exporter::{ExportResult, ImageExporter},
	TexturePackerConfig,
};
use thiserror::Error;

/// The texture did not fit in the texture atlas
#[derive(Debug, Error)]
#[error("{:?}", .0)]
pub struct PackError(PackErrorInternal);

// TODO this can be removed when a new texture packer is made
type PackErrorInternal = impl std::fmt::Debug;

#[derive(Error, Debug)]
pub enum TextureError {
	#[error("{:?}", .0)]
	TextureTooLarge(#[from] PackError),
	#[error("{}", .0)]
	BadImage(#[from] LoadError),
	#[error("Unexpected Error (this is a bug in alligator_render): {}", .0)]
	Unexpected(#[source] Box<dyn Error>),
}

/// Simpler constructor for a wgpu extent3d
const fn extent_3d(width: u32, height: u32) -> wgpu::Extent3d {
	wgpu::Extent3d {
		width,
		height,
		depth_or_array_layers: 1,
	}
}

/// A texture atlas, usable by the renderer
// TODO make this Debug
// TODO make these resizable
pub struct TextureAtlas {
	textures: Arc<TextureManager>,
	packer: TexturePacker<'static, Rgba16Texture, TextureId>,
	diffuse_texture: wgpu::Texture,
	diffuse_bind_group: wgpu::BindGroup,
	image: RgbaImage,
	width: u32,
	height: u32,
	changed: bool,
}

macro_rules! texture_info {
	($name: ident, $prop: ident, $divisor: ident) => {
		pub fn $name(&mut self, id: TextureId) -> Result<f32, TextureError> {
			let frame = match self.texture_frame(id) {
				Some(frame) => frame,
				None => {
					self.load_texture(id)?;
					self.texture_frame(id).unwrap()
				}
			};
			let property = frame.frame.$prop;
			let value = property as f32 / self.$divisor as f32;
			Ok(value)
		}
	};
}

impl TextureAtlas {
	/// Creates a new texture atlas, with the given size
	// TODO why is this u32?
	// TODO this is still too large
	pub fn new(
		device: &wgpu::Device,
		textures: Arc<TextureManager>,
		width: u32,
		height: u32,
	) -> (Self, wgpu::BindGroupLayout) {
		let atlas_size = extent_3d(width, height);
		let diffuse_texture = device.create_texture(&wgpu::TextureDescriptor {
			label: Some("Diffuse Texture"),
			size: atlas_size,
			mip_level_count: 1,
			sample_count: 1,
			dimension: wgpu::TextureDimension::D2,
			format: wgpu::TextureFormat::Rgba8Unorm,
			usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
			view_formats: &[wgpu::TextureFormat::Rgba8UnormSrgb],
		});

		// TODO I don't think this refreshes anything
		let diffuse_texture_view =
			diffuse_texture.create_view(&wgpu::TextureViewDescriptor::default());

		let diffuse_sampler = device.create_sampler(&wgpu::SamplerDescriptor::default());

		let texture_bind_group_layout =
			device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
				label: Some("Texture Bind Group Layout"),
				entries: &[
					wgpu::BindGroupLayoutEntry {
						binding: 0,
						visibility: wgpu::ShaderStages::FRAGMENT,
						ty: wgpu::BindingType::Texture {
							sample_type: wgpu::TextureSampleType::Float { filterable: true },
							view_dimension: wgpu::TextureViewDimension::D2,
							multisampled: false,
						},
						count: None,
					},
					wgpu::BindGroupLayoutEntry {
						binding: 1,
						visibility: wgpu::ShaderStages::FRAGMENT,
						ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
						count: None,
					},
				],
			});

		let diffuse_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
			label: Some("Diffuse Bind Group"),
			layout: &texture_bind_group_layout,
			entries: &[
				wgpu::BindGroupEntry {
					binding: 0,
					resource: wgpu::BindingResource::TextureView(&diffuse_texture_view),
				},
				wgpu::BindGroupEntry {
					binding: 1,
					resource: wgpu::BindingResource::Sampler(&diffuse_sampler),
				},
			],
		});

		(
			Self {
				textures,
				packer: TexturePacker::new_skyline(TexturePackerConfig {
					max_width: width,
					max_height: height,
					allow_rotation: false,
					trim: false,
					texture_padding: 0,
					..Default::default()
				}),
				diffuse_texture,
				diffuse_bind_group,
				width,
				height,
				image: RgbaImage::from_raw(
					width,
					height,
					vec![0; 4 * width as usize * height as usize],
				)
				.unwrap(),
				changed: true,
			},
			texture_bind_group_layout,
		)
	}

	/// get the bind group for the texture
	pub(crate) const fn bind_group(&self) -> &wgpu::BindGroup {
		&self.diffuse_bind_group
	}

	/// Load a new subtexture from memory
	pub fn load_texture(&mut self, id: TextureId) -> Result<TextureId, TextureError> {
		self.changed = true;
		let img = self.textures.load_texture(id)?;
		self.packer.pack_own(id, img).map_err(PackError)?;
		Ok(id)
	}

	/// Get the frame for s particular subtexture
	fn texture_frame(&self, id: TextureId) -> Option<&texture_packer::Frame<TextureId>> {
		self.packer.get_frame(&id)
	}

	texture_info!(texture_width, w, width);
	texture_info!(texture_height, h, height);
	texture_info!(texture_x, x, width);
	texture_info!(texture_y, y, height);

	/// Fill the cached image
	fn fill_image(&mut self) -> ExportResult<()> {
		let atlas = {
			profiling::scope!("export atlas");
			ImageExporter::export(&self.packer)?
		};
		profiling::scope!("copy image");
		self.image
			.copy_from(&atlas, 0, 0)
			.expect("image cache is too small");
		Ok(())
	}

	/// Clear the texture atlas, and give it a new size
	pub fn clear(&mut self, width: u32, height: u32) {
		self.changed = true;
		self.width = width;
		self.height = height;
		self.packer = TexturePacker::new_skyline(TexturePackerConfig {
			max_width: self.width,
			max_height: self.height,
			..Default::default()
		});
	}

	/// Fill the GPU texture atlas
	#[profiling::function]
	pub(crate) fn fill_textures(&mut self, queue: &wgpu::Queue) {
		// saves time if nothing changed since the last time we did this
		// FIXME This doesn't do much good once we get procedurally generated animation
		//       We'll have to create our own texture packer, with mutable subtextures,
		//       and more efficient algorithms. This'll also make frame times more consistent
		if !self.changed {
			return;
		}

		let atlas_size = extent_3d(self.width, self.height);

		// put the packed texture into the base image
		if let Err(e) = self.fill_image() {
			log::error!("{}", e);
		}

		// copy that to the gpu
		queue.write_texture(
			wgpu::ImageCopyTexture {
				texture: &self.diffuse_texture,
				mip_level: 0,
				origin: wgpu::Origin3d::ZERO,
				aspect: wgpu::TextureAspect::All,
			},
			self.image.as_bytes(),
			wgpu::ImageDataLayout {
				offset: 0,
				bytes_per_row: NonZeroU32::new(atlas_size.width * 4),
				rows_per_image: NonZeroU32::new(atlas_size.height),
			},
			atlas_size,
		);

		self.changed = false;
	}
}