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

pub struct Renderer {
    pub enabled: bool,
    pub cast_shadows: u8,
    pub game_object: PPtr<GameObject>,
    pub materials: Vec<PPtr<Material>>,
}
pub struct MeshRenderer {
    pub renderer: Renderer,
    pub additional_vertex_streams: PPtr<Mesh>,
}

pub struct SkinnedMeshRenderer {
    pub renderer: Renderer,
    pub bones: Vec<PPtr<Transform>>,
    pub mesh: PPtr<Mesh>,
    pub root_bone: PPtr<Transform>,
}

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

impl FromValue for MeshRenderer {
    fn from_value(v: Value) -> Result<Self> {
        let mut fields = v.as_class("MeshRenderer")?;
        Ok(Self {
            additional_vertex_streams: fields.field("m_AdditionalVertexStreams")?,
            renderer: Renderer::from_fields(fields)?,
        })
    }
}
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")?,
            mesh: fields.field("m_Mesh")?,
            bones: fields
                .remove("m_Bones")
                .unwrap()
                .as_vector()
                .unwrap()
                .into_iter()
                .map(|e| e.parse().unwrap())
                .collect(),
            renderer: Renderer::from_fields(fields)?,
        })
    }
}