#![feature(iter_array_chunks)]
use anyhow::Result;
use clap::Parser;
use std::{
    net::{SocketAddr, TcpStream},
    path::PathBuf,
};
use weareshared::{
    packets::{Object, Packet},
    resources::{Indecies, Part, Prefab, VertexAttributes},
    store::ResourceStore,
};

#[derive(Parser)]
struct Args {
    address: SocketAddr,
    scene: PathBuf,
}

fn main() -> Result<()> {
    env_logger::init_from_env("LOG");
    let args = Args::parse();

    let mut sock = TcpStream::connect(args.address)?;
    let store = ResourceStore::new_memory();

    let (gltf, buffers, _) = gltf::import(args.scene)?;

    for node in gltf.nodes() {
        if let Some(mesh) = node.mesh() {
            for p in mesh.primitives() {
                let reader = p.reader(|buf| Some(&buffers[buf.index()]));
                let mut attrs = vec![vec![]; 3];
                for p in reader.read_positions().unwrap() {
                    attrs[0].push(p[0]);
                    attrs[1].push(p[1]);
                    attrs[2].push(p[2]);
                }
                let index = reader
                    .read_indices()
                    .unwrap()
                    .into_u32()
                    .map(|e| e as u16)
                    .array_chunks::<3>()
                    .collect::<Vec<_>>();

                let part = Part {
                    vertex: attrs
                        .into_iter()
                        .map(|d| {
                            let mut out = Vec::new();
                            VertexAttributes(d).serialize(&mut out)?;
                            store.set(&out)
                        })
                        .collect::<Result<Vec<_>, _>>()?,
                    index: Some({
                        let mut out = Vec::new();
                        Indecies(index).serialize(&mut out)?;
                        store.set(&out)?
                    }),
                    ..Part::default()
                };
                let mut out = Vec::new();
                part.serialize(&mut out)?;
                Packet::Add(Object::new(), store.set(&out)?).serialize(&mut sock)?;
            }
        }
    }

    store.iter(|d| {
        Packet::RespondResource(d.to_vec())
            .serialize(&mut sock)
            .unwrap();
    })?;

    loop {
        let packet = Packet::deserialize(&mut sock)?;
        match packet {
            Packet::RequestResource(hash) => {
                if let Some(d) = store.get(hash)? {
                    Packet::RespondResource(d).serialize(&mut sock)?;
                }
            }
            _ => (),
        }
    }
}