// NOTE: Very WIP, Does not work!!

use anyhow::bail;
use bevy::{prelude::*, transform::components::Transform};
use unity_asset::environment::{Environment, EnvironmentObjectRef};
use unity_asset_binary::unity_version::UnityVersion;
use unity_asset_decode::mesh::MeshParser;

use crate::{BevyObject, BevyObjectData, unity::{component::{Component, mesh_renderer::MeshRenderer, transform::into_bevy_transform}, unity_value::try_unity_mesh_to_bevy}};

mod component;
mod unity_value;

#[derive(Debug)]
pub struct UnityGameObject{
  pub name: String,
  pub active: bool,

  pub transform: Transform,
  pub mesh_renderer: Option<MeshRenderer>,
  pub mesh_filter: Option<Mesh>,
}

pub fn load( path: &'static str ) -> anyhow::Result<Vec<BevyObject>>{
  let mesh_parser = MeshParser::new(UnityVersion::parse_version("2020.3.12f1").unwrap());

  let mut env = Environment::new();
  env.load(path)?;

  let mut gameobjects = vec![];

  for obj in env.objects(){
    match obj{
      EnvironmentObjectRef::Binary(v) => {
        if v.object.class_id() == 1{
          let obj = v.object.read()?;
          let go = obj.as_gameobject().unwrap();

          let mut components: Vec<Box<dyn Component>> = vec![];

          let mut transform = None;
          let mut mesh_renderer = None;
          let mut mesh_filter = None;

          let comps = obj.get("m_Component").unwrap().as_array().unwrap();

          for comp in comps{
            let obj = comp.as_object().unwrap().get("component").unwrap();
            let path_id = obj.as_object().unwrap().get("m_PathID").unwrap().as_i64().unwrap();

            let comp = env.find_binary_object(path_id).unwrap();
            let comp = comp.read().unwrap();

            match comp.class_id(){
              4 => transform = Some(into_bevy_transform(comp)), // Normal Transform
              224 => transform = Some(into_bevy_transform(comp)), // Rect Transform (gonna just treat it as normal)

              23 => mesh_renderer = Some(MeshRenderer::from(comp)),
              33 => {
                let mesh = comp.get("m_Mesh").unwrap();
                let path_id = mesh.as_object().unwrap().get("m_PathID").unwrap().as_i64().unwrap();

                let mesh = env.find_binary_object(path_id).unwrap();
                let mesh_obj = mesh.read().unwrap();

                if let Some(mesh) = try_unity_mesh_to_bevy(mesh_obj, &mesh_parser){
                  mesh_filter = Some(mesh);
                } else{
                  println!("[WARN] Failed to load mesh for: {}", go.name);
                }
              },

              _ => {}
            }
          }

          if transform.is_none(){ bail!("Cannot find transform for object {}", go.name); }

          let gameobject = UnityGameObject {
            name: go.name,
            active: go.active,

            transform: transform.unwrap(),
            mesh_renderer,
            mesh_filter
          };

          gameobjects.push(gameobject);
          break;
        }
      },
      _ => {}
    }
  }

  let mut objs = vec![];

  for go in gameobjects{
    if go.active{
      if let Some(mesh) = go.mesh_filter{
        objs.push(BevyObject {
          name: go.name,
          transform: go.transform,
          data: BevyObjectData::Mesh(mesh)
        });
      }
    }
  }

  Ok(objs)
}