use crate::asset::{
    Asset,
    Assets,
    Dependency as AssetDependency,
    Event as AssetEvent,
    Events as AssetEvents,
    Handle as AssetHandle,
    Label as AssetLabel,
};
use crate::ecs::sole::Single;
use crate::ecs::Component;
use crate::material::Material;
use crate::mesh::Mesh;

pub mod asset;

#[derive(Debug, Default)]
#[non_exhaustive]
pub struct Model {}

impl Asset for Model
{
    fn dependencies(&self) -> impl Iterator<Item = AssetDependency<'_>>
    {
        [].into_iter()
    }
}

#[derive(Debug, Clone, Component)]
#[allow(clippy::module_name_repetitions)]
pub struct ModelMesh
{
    pub asset: AssetHandle<Mesh>,
}

#[derive(Debug, Clone, Component)]
#[allow(clippy::module_name_repetitions)]
pub struct ModelMaterial
{
    pub asset: AssetHandle<MaterialDescription>,
}

#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct MaterialDescription
{
    pub asset: AssetHandle<Material>,
    pub loading_material: Option<AssetLabel<'static>>,
}

impl MaterialDescription
{
    #[must_use]
    pub fn new(asset: AssetHandle<Material>) -> Self
    {
        Self { asset, loading_material: None }
    }

    #[must_use]
    pub fn with_loading_material(mut self, loading_material: AssetLabel<'static>)
        -> Self
    {
        self.loading_material = Some(loading_material);
        self
    }
}

impl Asset for MaterialDescription
{
    fn dependencies(&self) -> impl Iterator<Item = AssetDependency<'_>>
    {
        self.loading_material.iter().map(|material_label| {
            AssetDependency::new::<Material>(AssetLabel {
                path: (&*material_label.path).into(),
                name: material_label.name.as_deref().map(Into::into),
            })
        })
    }
}

pub(crate) fn set_stored_mat_descs_handles(
    mut assets: Single<Assets>,
    asset_events: Single<AssetEvents>,
)
{
    let assets = assets.get_mut().unwrap();
    let asset_events = asset_events.get().unwrap();

    for AssetEvent::Stored(asset_id, ..) in asset_events.iter_last_tick() {
        let asset_handle = AssetHandle::<MaterialDescription>::from_id(*asset_id);

        if !assets.is_loaded_and_has_type(&asset_handle) {
            continue;
        }

        let material_asset = {
            let Some(material_desc) = assets.get(&asset_handle) else {
                unreachable!();
            };

            if let Some(material_label) = &material_desc.loading_material {
                let Some(material_asset) =
                    assets.get_handle_to_loaded::<Material>(material_label.clone())
                else {
                    unreachable!();
                };

                Some(material_asset)
            } else {
                None
            }
        };

        let Some(material_asset) = material_asset else {
            continue;
        };

        let Some(material_desc) = assets.get_mut(&asset_handle) else {
            unreachable!();
        };

        material_desc.asset = material_asset;
    }
}