use std::borrow::Cow;
use std::collections::HashMap;
use std::fs::read_to_string;
use std::path::{Path, PathBuf};

use crate::asset::{Assets, Handle as AssetHandle, Submitter as AssetSubmitter};
use crate::material::Material;
use crate::texture::Texture;

#[derive(Debug, Clone)]
pub struct Map
{
    pub assets: HashMap<Cow<'static, str>, AssetHandle<Material>>,
}

/// Material asset import settings.
#[derive(Debug)]
#[non_exhaustive]
pub struct Settings {}

pub fn add_importers(assets: &mut Assets)
{
    assets.set_importer(["mtl"], import_wavefront_mtl_asset);
}

fn import_wavefront_mtl_asset(
    asset_submitter: &mut AssetSubmitter<'_>,
    path: &Path,
    _settings: Option<&'_ Settings>,
) -> Result<(), Error>
{
    let named_materials = crate::file_format::wavefront::mtl::parse(
        &read_to_string(path)
            .map_err(|err| Error::ReadFailed(err, path.to_path_buf()))?,
    )?;

    let mut mat_asset_map = Map {
        assets: HashMap::with_capacity(named_materials.len()),
    };

    for material in named_materials {
        let mut material_builder = Material::builder()
            .ambient(material.ambient)
            .diffuse(material.diffuse)
            .specular(material.specular)
            .shininess(material.shininess);

        if let Some(ambient_map) = material.ambient_map {
            material_builder = material_builder.ambient_map(Texture::new(
                asset_submitter.submit_load_other(ambient_map.path.as_path()),
            ));
        }

        if let Some(diffuse_map) = material.diffuse_map {
            material_builder = material_builder.diffuse_map(Texture::new(
                asset_submitter.submit_load_other(diffuse_map.path.as_path()),
            ));
        }

        if let Some(specular_map) = material.specular_map {
            material_builder = material_builder.specular_map(Texture::new(
                asset_submitter.submit_load_other(specular_map.path.as_path()),
            ));
        }

        let material_name = material.name;
        let material = material_builder.build();

        let material_asset =
            asset_submitter.submit_store_named(material_name.clone(), material);

        mat_asset_map
            .assets
            .insert(material_name.into(), material_asset);
    }

    asset_submitter.submit_store(mat_asset_map);

    Ok(())
}

#[derive(Debug, thiserror::Error)]
enum Error
{
    #[error("Failed to read file {}", .1.display())]
    ReadFailed(#[source] std::io::Error, PathBuf),

    #[error(transparent)]
    Other(#[from] crate::file_format::wavefront::mtl::Error),
}