#![feature(iter_array_chunks)]
use anyhow::Result;
use clap::Parser;
use std::{
    net::{SocketAddr, TcpStream},
    path::PathBuf,
};
use weareshared::{
    packets::{Object, Packet, ReadWrite},
    resources::{Attribute, AttributeArray, IndexArray, Part},
    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 pos_x = vec![];
                let mut pos_y = vec![];
                let mut pos_z = vec![];
                let mut norm_x = vec![];
                let mut norm_y = vec![];
                let mut norm_z = vec![];
                for p in reader.read_positions().unwrap() {
                    pos_x.push(p[0]);
                    pos_y.push(p[1]);
                    pos_z.push(p[2]);
                }
                for p in reader.read_normals().unwrap() {
                    norm_x.push(p[0]);
                    norm_y.push(p[1]);
                    norm_z.push(p[2]);
                }
                let index = reader
                    .read_indices()
                    .unwrap()
                    .into_u32()
                    .map(|e| e as u16)
                    .array_chunks::<3>()
                    .collect::<Vec<_>>();

                let part = store.set(
                    &Part {
                        va_position: Some([
                            Attribute::Vertex(store.set(&AttributeArray(pos_x).write_alloc())?),
                            Attribute::Vertex(store.set(&AttributeArray(pos_y).write_alloc())?),
                            Attribute::Vertex(store.set(&AttributeArray(pos_z).write_alloc())?),
                        ]),
                        va_normal: Some([
                            Attribute::Vertex(store.set(&AttributeArray(norm_x).write_alloc())?),
                            Attribute::Vertex(store.set(&AttributeArray(norm_y).write_alloc())?),
                            Attribute::Vertex(store.set(&AttributeArray(norm_z).write_alloc())?),
                        ]),
                        index: Some(store.set(&IndexArray(index).write_alloc())?),
                        ..Part::default()
                    }
                    .write_alloc(),
                )?;
                Packet::Add(Object::new(), part).write(&mut sock)?;
            }
        }
    }

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

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