lyra-engine/lyra-resource/src/resource_manager.rs

use std::{sync::Arc, collections::{HashMap, hash_map::DefaultHasher}, hash::{Hash, Hasher}, any::Any};

use thiserror::Error;

use crate::{resource::Resource, loader::{ResourceLoader, LoaderError, texture::TextureLoader, model::ModelLoader}};

pub trait ResourceStorage: Send + Sync + Any + 'static {
    fn as_any(&self) -> &dyn Any;
    fn as_any_mut(&mut self) -> &mut dyn Any;
    fn as_arc_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync>;
}

/// Implements this trait for anything that fits the type bounds
impl<T: Send + Sync + 'static> ResourceStorage for T {
    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }

    fn as_arc_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync> {
        self.clone()
    }
}

#[derive(Error, Debug)]
pub enum RequestError {
    #[error("{0}")]
    Loader(LoaderError),
    #[error("The file extension is unsupported: '{0}'")]
    UnsupportedFileExtension(String),
}

impl From<LoaderError> for RequestError {
    fn from(value: LoaderError) -> Self {
        RequestError::Loader(value)
    }
}

pub struct ResourceManager {
    resources: HashMap<String, Arc<dyn ResourceStorage>>,
    loaders: Vec<Box<dyn ResourceLoader>>,
}

impl ResourceManager {
    pub fn new() -> Self {
        Self {
            resources: HashMap::new(),
            loaders: vec![ Box::new(TextureLoader::default()), Box::new(ModelLoader::default()) ],
        }
    }

    pub fn request<T: Send + Sync + Any + 'static>(&mut self, path: &str) -> Result<Arc<Resource<T>>, RequestError> {
        match self.resources.get(&path.to_string()) {
            Some(res) => {
                let res = res.clone().as_arc_any();
                let res = res.downcast::<Resource<T>>().expect("Failure to downcast resource");

                Ok(res)
            },
            None => {
                if let Some(loader) = self.loaders.iter()
                        .find(|l| l.does_support_file(path)) {

                    // Load the resource and store it
                    let res = loader.load(path)?;
                    self.resources.insert(path.to_string(), res.clone());

                    // convert Arc<dyn ResourceStorage> to Arc<Resource<T>
                    let res = res.as_arc_any();
                    let res = res.downcast::<Resource<T>>()
                        .expect("Failure to downcast resource! Does the loader return an `Arc<Resource<T>>`?");

                    Ok(res)
                } else {
                    Err(RequestError::UnsupportedFileExtension(path.to_string()))
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use std::io;

    use crate::{Texture, ResourceState};

    use super::*;

    fn get_image(path: &str) -> String {
        let manifest = std::env::var("CARGO_MANIFEST_DIR").unwrap();
        
        format!("{manifest}/test_files/img/{path}")
    }

    #[test]
    fn load_image() {
        let mut man = ResourceManager::new();
        let res = man.request::<Texture>(&get_image("squiggles.png")).unwrap();
        assert_eq!(res.state, ResourceState::Ready);
        let img = res.data.as_ref();
        img.unwrap();
    }

    /// Ensures that only one copy of the same thing made
    #[test]
    fn ensure_single() {
        let mut man = ResourceManager::new();
        let res = man.request::<Texture>(&get_image("squiggles.png")).unwrap();
        assert_eq!(Arc::strong_count(&res), 2);

        let resagain = man.request::<Texture>(&get_image("squiggles.png")).unwrap();
        assert_eq!(Arc::strong_count(&resagain), 3);
    }

    /// Ensures that an error is returned when a file that doesn't exist is requested
    #[test]
    fn ensure_none() {
        let mut man = ResourceManager::new();
        let res = man.request::<Texture>(&get_image("squigglesfff.png"));
        let err = res.err().unwrap();
        
        assert!(
            match err {
                // make sure the error is NotFound
                RequestError::Loader(LoaderError::IoError(e)) if e.kind() == io::ErrorKind::NotFound => true,
                _ => false
            }
        );
    }
}