use crate::core::image::HostImage;
use crate::core::material::CreateMaterial;
use crate::core::texture::SpectrumTexture;
use crate::utils::upload::ArenaUpload;
use crate::utils::{FileLoc, TextureParameterDictionary};
use crate::Arena;
use anyhow::Result;
use shared::core::material::Material;
use shared::core::spectrum::Spectrum;
use shared::core::texture::SpectrumType;
use shared::materials::{DiffuseMaterial, DiffuseTransmissionMaterial};
use shared::spectra::ConstantSpectrum;
use shared::textures::SpectrumConstantTexture;
use std::collections::HashMap;
use std::sync::Arc;

impl CreateMaterial for DiffuseMaterial {
    fn create(
        parameters: &TextureParameterDictionary,
        normal_map: Option<Arc<HostImage>>,
        _named_materials: &HashMap<String, Material>,
        _loc: &FileLoc,
        arena: &Arena,
    ) -> Result<Material> {
        let reflectance = parameters
            .get_spectrum_texture("reflectance", None, SpectrumType::Albedo)
            .unwrap_or_else(|| {
                Arc::new(SpectrumTexture::Constant(
                    SpectrumConstantTexture::new(Spectrum::Constant(ConstantSpectrum::new(0.5))),
                ))
            });
        let displacement = parameters.get_float_texture_or_null("displacement")?;

        let specific = DiffuseMaterial {
            reflectance: arena.upload(reflectance),
            displacement: arena.upload(displacement),
            normal_map: arena.upload(normal_map),
        };
        Ok(Material::Diffuse(specific))
    }
}

impl CreateMaterial for DiffuseTransmissionMaterial {
    fn create(
        _parameters: &TextureParameterDictionary,
        _normal_map: Option<Arc<HostImage>>,
        _named_materials: &HashMap<String, Material>,
        _loc: &FileLoc,
        _arena: &Arena,
    ) -> Result<Material> {
        todo!()
    }
}