use super::{gameobject::GameObject, mesh::Mesh, pptr::PPtr, transform::Transform};
use crate::object::{
    Value,
    parser::{Fields, FromValue},
};
use anyhow::Result;

pub struct MeshRenderer {
    pub enabled: bool,
    pub mesh: PPtr<Mesh>,
    pub cast_shadows: u8,
    pub game_object: PPtr<GameObject>,
    pub materials: Vec<PPtr>,
}

pub struct SkinnedMeshRenderer {
    pub mesh_renderer: MeshRenderer,
    pub bones: Vec<PPtr<Transform>>,
    pub root_bone: PPtr<Transform>,
}

impl FromValue for MeshRenderer {
    fn from_value(v: Value) -> Result<Self> {
        Self::from_fields(v.as_class("MeshRenderer")?)
    }
}
impl MeshRenderer {
    pub fn from_fields(mut fields: Fields) -> Result<Self> {
        Ok(Self {
            enabled: fields.field("m_Enabled")?,
            mesh: fields.field("m_Mesh")?,
            cast_shadows: fields.field("m_CastShadows")?,
            game_object: fields.field("m_GameObject")?,
            materials: fields
                .remove("m_Materials")
                .unwrap()
                .as_vector()
                .unwrap()
                .into_iter()
                .map(|e| e.parse().unwrap())
                .collect(),
        })
    }
}

impl FromValue for SkinnedMeshRenderer {
    fn from_value(v: Value) -> Result<Self> {
        let mut fields = v.as_class("SkinnedMeshRenderer")?;
        Ok(Self {
            root_bone: fields.field("m_RootBone")?,
            bones: fields
                .remove("m_Bones")
                .unwrap()
                .as_vector()
                .unwrap()
                .into_iter()
                .map(|e| e.parse().unwrap())
                .collect(),
            mesh_renderer: MeshRenderer::from_fields(fields)?,
        })
    }
}