use anyhow::Result;
use std::{
    collections::{HashMap, HashSet},
    sync::Arc,
};
use weareshared::{
    packets::{ReadWrite, Resource},
    resources::Prefab,
    tree::SceneTree,
};
use wgpu::Buffer;

use crate::download::Downloader;

pub struct ScenePreparer {
    index_buffers: HashMap<Resource, Arc<Buffer>>,
    vertex_buffers_x3: HashMap<[Resource; 1], Arc<Buffer>>,
    vertex_buffers_x2: HashMap<[Resource; 2], Arc<Buffer>>,
    vertex_buffers_x1: HashMap<[Resource; 3], Arc<Buffer>>,
    parts: HashMap<Resource, Arc<RPart>>,
    prefabs: HashMap<Resource, RPrefab>,
    prefabs_needed: HashSet<Resource>,
}

pub struct RPrefab(pub Vec<Arc<RPart>>);
pub struct RPart {
    pub index_count: u32,
    pub index: Arc<Buffer>,
    pub positions: Arc<Buffer>,
    pub normals: Arc<Buffer>,
}

impl ScenePreparer {
    pub fn new() -> Self {
        Self {
            index_buffers: HashMap::new(),
            vertex_buffers_x3: HashMap::new(),
            vertex_buffers_x2: HashMap::new(),
            vertex_buffers_x1: HashMap::new(),
            parts: HashMap::new(),
            prefabs: HashMap::new(),
            prefabs_needed: HashSet::new(),
        }
    }
    fn update(&mut self, dls: &mut Downloader) -> Result<()> {
        for pres in &self.prefabs_needed {
            if let Some(buf) = dls.try_get(*pres)? {
                let prefab = Prefab::read(&mut buf.as_slice())?;
                
            }
        }
        Ok(())
    }
}