pub mod assetinfo;
pub mod gameobject;
pub mod material;
pub mod mesh;
pub mod pptr;
pub mod streaming_info;
pub mod texture2d;
pub mod transform;
pub mod vectors;
pub mod renderer;
pub mod shader;
pub mod cubemap;
pub mod render_settings;
pub mod audio_clip;
pub mod streamed_resource;

use crate::object::{Value, parser::FromValue};
use anyhow::Result;
use assetinfo::AssetInfo;
use gameobject::GameObject;
use material::Material;
use mesh::Mesh;
use pptr::PPtr;
use serde::Serialize;
use std::collections::BTreeMap;
use streaming_info::StreamingInfo;
use texture2d::Texture2D;
use transform::Transform;

#[derive(Debug, Serialize)]
pub enum HValue {
    AssetInfo(AssetInfo),
    GameObject(GameObject),
    Transform(Transform),
    PPtr(PPtr),
    StreamingInfo(StreamingInfo),
    Texture2D(Texture2D),
    Mesh(Mesh),
    Material(Material),

    Pair(Box<HValue>, Box<HValue>),
    Value([Value; 1]),
    Map(BTreeMap<String, HValue>),
    Array(Vec<HValue>),
    Object {
        class: String,
        fields: BTreeMap<String, HValue>,
    },
}

impl HValue {
    pub fn from_value(v: Value) -> Result<HValue> {
        Ok(match v {
            value @ Value::Object { .. } => {
                let class = value.class_name().unwrap();
                match class.as_str() {
                    x if x.starts_with("PPtr<") => Self::PPtr(PPtr::from_value(value)?),
                    "AssetInfo" => Self::AssetInfo(AssetInfo::from_value(value)?),
                    "GameObject" => Self::GameObject(GameObject::from_value(value)?),
                    "Transform" => Self::Transform(Transform::from_value(value)?),
                    "Texture2D" => Self::Texture2D(Texture2D::from_value(value)?),
                    "Mesh" => Self::Mesh(Mesh::from_value(value)?),
                    "Material" => Self::Material(Material::from_value(value)?),
                    _ => Self::Value([value]),
                }
            }
            Value::Array(a) => Self::Array(
                a.into_iter()
                    .map(|e| HValue::from_value(e))
                    .collect::<Result<Vec<_>>>()?,
            ),
            x => Self::Value([x]),
        })
    }
    pub fn as_value(&self) -> Option<&Value> {
        if let HValue::Value(v) = self {
            Some(&v[0])
        } else {
            None
        }
    }
    pub fn as_pptr(self) -> Option<PPtr> {
        if let HValue::PPtr(v) = self {
            Some(v)
        } else {
            None
        }
    }
    pub fn as_array(self) -> Option<Vec<HValue>> {
        if let HValue::Array(v) = self {
            Some(v)
        } else {
            None
        }
    }
    pub fn as_class(self, name: &str) -> Option<BTreeMap<String, HValue>> {
        if let HValue::Object { class, fields } = self {
            if class == name { Some(fields) } else { None }
        } else {
            None
        }
    }
}