//! The `assets` crate stores all audio and image assets that need to be
//! loaded during runtime

use std::error::Error;

use raylib::{RaylibHandle, RaylibThread, audio::RaylibAudio};

#[expect(dead_code)]
type Sound = raylib::audio::Sound<'static>;

/// The `AudioData` container initalizes the audio subsystem
/// for raylib, leaks it (to gurentee audio is statically loaded),
/// then loads all needed audio samples
#[derive(Debug)]
pub struct AudioData {}
impl AudioData {
	pub(crate) fn load() -> Result<Self, Box<dyn Error>> {
		// Phantom handle to the raylib audio subsystem
		// Raylib doesnt use a handle, but the rust bindings
		// have one to ensure memory safety.
		//
		// We must leak this handle after allocating it,
		// if we dont then all audio will be unloaded :(
		//
		// NOTE: would this cause issues if `AudioData::load` was
		// called multiple times?
		let _handle = Box::leak(Box::new(RaylibAudio::init_audio_device()?));

		// TODO: load audio samples

		//let example = handle.new_sound("example.ogg")?;

		Ok(Self {})
	}
}

/// The `ImageData` container loads all game sprites, and other images into memory.
#[derive(Debug)]
pub(crate) struct ImageData {}
impl ImageData {
	pub(crate) fn load(
		_handle: &mut RaylibHandle,
		_thread: &RaylibThread,
	) -> Result<Self, Box<dyn Error>> {
		// TODO: load image data

		//let example = handle.load_texture(&thread, "example.png");

		Ok(Self {})
	}
}

#[derive(Debug)]
pub(crate) struct Assets {
	/// Audio needs to be accessible outside of the renderer
	pub(crate) audio: AudioData,
	/// Images are only needed by the renderer
	pub(crate) image: ImageData,
}
impl Assets {
	pub(crate) fn load(
		handle: &mut RaylibHandle,
		thread: &RaylibThread,
	) -> Result<Self, Box<dyn Error>> {
		let audio = AudioData::load()?;
		let image = ImageData::load(handle, thread)?;

		Ok(Self { audio, image })
	}
}