use std::collections::HashMap;
use wgpu::{Device, Buffer};
use crate::render::{create_circle_vertices, create_sphere_vertices, Geometry, Shape, Vertex};
use wgpu::util::DeviceExt;

pub struct GeometryManager {
    pub geometries: HashMap<Shape, Geometry>,
}

impl GeometryManager {
    pub fn new(device: &Device) -> Self {
        let mut geometries = HashMap::new();

        // Circle
        let (circle_vertices, circle_indices) = create_circle_vertices(512, 0.5, [0.5, 0.5, 0.5]);
        geometries.insert(
            Shape::Circle,
            Self::create_geometry(device, &circle_vertices, &circle_indices),
        );

        // Sphere
        let (sphere_vertices, sphere_indices) = create_sphere_vertices(32, 32, 0.5, [0.5, 0.5, 0.5]);
        geometries.insert(
            Shape::Sphere,
            Self::create_geometry(device, &sphere_vertices, &sphere_indices),
        );

        // Füge hier beliebige weitere Shapes hinzu

        Self { geometries }
    }

    pub fn get(&self, shape: &Shape) -> Option<&Geometry> {
        self.geometries.get(shape)
    }

    pub fn shapes(&self) -> impl Iterator<Item = Shape> + '_ {
        self.geometries.keys().copied()
    }

    fn create_geometry(device: &Device, vertices: &[Vertex], indices: &[u16]) -> Geometry {
        let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Vertex Buffer"),
            contents: bytemuck::cast_slice(vertices),
            usage: wgpu::BufferUsages::VERTEX,
        });

        let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Index Buffer"),
            contents: bytemuck::cast_slice(indices),
            usage: wgpu::BufferUsages::INDEX,
        });

        Geometry {
            vertex_buffer,
            index_buffer,
            index_count: indices.len() as u32,
        }
    }
}