use std::collections::HashMap;
use std::path::Path;
use std::sync::Arc;

use exun::{RawUnexpected, ResultErrorExt};
use image::RgbaImage;
use packer::{RectanglePacker, TextureAtlas};

type ExunResult<T> = Result<T, RawUnexpected>;

pub struct TextureManager {
	textures: HashMap<Arc<str>, TextureMetadata>,
	loaded_textures: HashMap<Arc<str>, Arc<RgbaImage>>,
	packer: RectanglePacker,
	target_size: usize,
	current_size: usize,
}

struct TextureMetadata {
	path: Arc<Path>,
	size: usize,
}

impl TextureManager {
	pub fn new(target_size: usize) -> Self {
		Self {
			textures: HashMap::new(),
			loaded_textures: HashMap::new(),
			packer: RectanglePacker::new(),
			target_size,
			current_size: 0,
		}
	}

	pub fn add_texture(&mut self, name: Arc<str>, path: Arc<Path>, size: usize) {
		self.textures.insert(name, TextureMetadata { path, size });
	}

	pub fn try_preload(&mut self, name: Arc<str>) -> ExunResult<Option<bool>> {
		let Some(metadata) = self.textures.get(&name) else {
			return Ok(None);
		};

		if self.current_size + metadata.size < self.target_size {
			self.load(name)?;
			Ok(Some(true))
		} else {
			Ok(Some(false))
		}
	}

	pub fn load(&mut self, name: Arc<str>) -> ExunResult<Option<()>> {
		let Some(metadata) = self.textures.get(&name) else {
			return Ok(None);
		};

		self.current_size += metadata.size;
		let texture = image::open(&metadata.path).unexpect()?.to_rgba8();
		self.loaded_textures.insert(name, Arc::new(texture));

		Ok(Some(()))
	}

	pub fn unload(&mut self, name: Arc<str>) -> Option<()> {
		self.loaded_textures.remove(&name)?;
		Some(())
	}

	pub fn pack_texture(&mut self, name: Arc<str>) -> ExunResult<()> {
		if !self.loaded_textures.contains_key(&name) {
			self.load(name.clone())?;
		}

		self.packer.add_texture(
			name.clone(),
			self.loaded_textures
				.get(&name)
				.expect("we checked to make sure it was loaded")
				.clone(),
		);

		Ok(())
	}

	pub fn reset_packer(&mut self) {
		self.packer = RectanglePacker::new();
	}

	pub fn reload_texture_atlas(
		&mut self,
		min_width: u32,
		min_height: u32,
	) -> ExunResult<TextureAtlas> {
		self.packer.output(min_width, min_height)
	}
}