use std::{
    mem::{size_of, transmute},
    sync::Arc,
};

use glam::{
    f32::{Mat4, Vec3, Vec4},
    Vec4Swizzles,
};

use metal::*;

pub const GEOMETRY_MASK_TRIANGLE: u32 = 1;
pub const GEOMETRY_MASK_SPHERE: u32 = 2;
pub const GEOMETRY_MASK_LIGHT: u32 = 4;

pub const FACE_MASK_NONE: u16 = 0;
pub const FACE_MASK_NEGATIVE_X: u16 = 1 << 0;
pub const FACE_MASK_POSITIVE_X: u16 = 1 << 1;
pub const FACE_MASK_NEGATIVE_Y: u16 = 1 << 2;
pub const FACE_MASK_POSITIVE_Y: u16 = 1 << 3;
pub const FACE_MASK_NEGATIVE_Z: u16 = 1 << 4;
pub const FACE_MASK_POSITIVE_Z: u16 = 1 << 5;
pub const FACE_MASK_ALL: u16 = (1 << 6) - 1;

pub trait Geometry {
    fn upload_to_buffers(&mut self) {
        todo!()
    }
    fn clear(&mut self) {
        todo!()
    }
    fn get_geometry_descriptor(&self) -> AccelerationStructureGeometryDescriptor {
        todo!()
    }
    fn get_resources(&self) -> Vec<Resource> {
        todo!()
    }
    fn get_intersection_function_name(&self) -> Option<&str> {
        None
    }
}

pub fn compute_triangle_normal(v0: &Vec3, v1: &Vec3, v2: &Vec3) -> Vec3 {
    let e1 = Vec3::normalize(*v1 - *v0);
    let e2 = Vec3::normalize(*v2 - *v0);
    return Vec3::cross(e1, e2);
}

#[derive(Default)]
#[repr(C)]
pub struct Triangle {
    pub normals: [Vec4; 3],
    pub colours: [Vec4; 3],
}

pub fn get_managed_buffer_storage_mode() -> MTLResourceOptions {
    return MTLResourceOptions::StorageModeManaged;
}

pub struct TriangleGeometry {
    pub device: Device,
    pub name: String,
    pub index_buffer: Option<Buffer>,
    pub vertex_position_buffer: Option<Buffer>,
    pub vertex_normal_buffer: Option<Buffer>,
    pub vertex_colour_buffer: Option<Buffer>,
    pub per_primitive_data_buffer: Option<Buffer>,
    pub indices: Vec<u16>,
    pub vertices: Vec<Vec4>,
    pub normals: Vec<Vec4>,
    pub colours: Vec<Vec4>,
    pub triangles: Vec<Triangle>,
}

impl TriangleGeometry {
    pub fn new(device: Device, name: String) -> Self {
        Self {
            device,
            name,
            index_buffer: None,
            vertex_position_buffer: None,
            vertex_normal_buffer: None,
            vertex_colour_buffer: None,
            per_primitive_data_buffer: None,
            indices: Vec::new(),
            vertices: Vec::new(),
            normals: Vec::new(),
            colours: Vec::new(),
            triangles: Vec::new(),
        }
    }

    pub fn add_cube_face_with_cube_vertices(
        &mut self,
        cube_vertices: &[Vec3],
        colour: Vec3,
        i0: u16,
        i1: u16,
        i2: u16,
        i3: u16,
        inward_normals: bool,
    ) {
        let v0 = cube_vertices[i0 as usize];
        let v1 = cube_vertices[i1 as usize];
        let v2 = cube_vertices[i2 as usize];
        let v3 = cube_vertices[i3 as usize];

        let n0 = compute_triangle_normal(&v0, &v1, &v2) * if inward_normals { -1f32 } else { 1f32 };
        let n1 = compute_triangle_normal(&v0, &v2, &v3) * if inward_normals { -1f32 } else { 1f32 };

        let first_index = self.indices.len();
        let base_index = self.vertices.len() as u16;

        self.indices.push(base_index + 0);
        self.indices.push(base_index + 1);
        self.indices.push(base_index + 2);
        self.indices.push(base_index + 0);
        self.indices.push(base_index + 2);
        self.indices.push(base_index + 3);

        self.vertices.push(From::from((v0, 0.0)));
        self.vertices.push(From::from((v1, 0.0)));
        self.vertices.push(From::from((v2, 0.0)));
        self.vertices.push(From::from((v3, 0.0)));

        self.normals
            .push(From::from((Vec3::normalize(n0 + n1), 0.0)));
        self.normals.push(From::from((n0, 0.0)));
        self.normals
            .push(From::from((Vec3::normalize(n0 + n1), 0.0)));
        self.normals.push(From::from((n1, 0.0)));

        for _ in 0..4 {
            self.colours.push(From::from((colour, 0.0)));
        }

        for triangle_index in 0..2 {
            let mut triangle = Triangle::default();
            for i in 0..3 {
                let index = self.indices[first_index + triangle_index * 3 + i];
                triangle.normals[i] = self.normals[index as usize];
                triangle.colours[i] = self.colours[index as usize];
            }
            self.triangles.push(triangle);
        }
    }

    pub fn add_cube_with_faces(
        &mut self,
        face_mask: u16,
        colour: Vec3,
        transform: Mat4,
        inward_normals: bool,
    ) {
        let mut cube_vertices = [
            Vec3::new(-0.5, -0.5, -0.5),
            Vec3::new(0.5, -0.5, -0.5),
            Vec3::new(-0.5, 0.5, -0.5),
            Vec3::new(0.5, 0.5, -0.5),
            Vec3::new(-0.5, -0.5, 0.5),
            Vec3::new(0.5, -0.5, 0.5),
            Vec3::new(-0.5, 0.5, 0.5),
            Vec3::new(0.5, 0.5, 0.5),
        ];

        for i in 0..8 {
            let transformed_vertex = Vec4::from((cube_vertices[i], 1.0));
            let transformed_vertex = transform * transformed_vertex;
            cube_vertices[i] = transformed_vertex.xyz();
        }

        const CUBE_INDICES: [[u16; 4]; 6] = [
            [0, 4, 6, 2],
            [1, 3, 7, 5],
            [0, 1, 5, 4],
            [2, 6, 7, 3],
            [0, 2, 3, 1],
            [4, 5, 7, 6],
        ];

        for face in 0..6 {
            if face_mask & (1 << face) != 0 {
                self.add_cube_face_with_cube_vertices(
                    &cube_vertices,
                    colour,
                    CUBE_INDICES[face][0],
                    CUBE_INDICES[face][1],
                    CUBE_INDICES[face][2],
                    CUBE_INDICES[face][3],
                    inward_normals,
                );
            }
        }
    }
}

impl Geometry for TriangleGeometry {
    fn upload_to_buffers(&mut self) {
        self.index_buffer = Some(unsafe {
            self.device.new_buffer_with_data(
                transmute(self.indices.as_ptr()),
                (self.indices.len() * size_of::<u16>()) as NSUInteger,
                get_managed_buffer_storage_mode(),
            )
        });
        self.vertex_position_buffer = Some(unsafe {
            self.device.new_buffer_with_data(
                transmute(self.vertices.as_ptr()),
                (self.vertices.len() * size_of::<Vec4>()) as NSUInteger,
                get_managed_buffer_storage_mode(),
            )
        });
        self.vertex_normal_buffer = Some(unsafe {
            self.device.new_buffer_with_data(
                transmute(self.normals.as_ptr()),
                (self.normals.len() * size_of::<Vec4>()) as NSUInteger,
                get_managed_buffer_storage_mode(),
            )
        });
        self.vertex_colour_buffer = Some(unsafe {
            self.device.new_buffer_with_data(
                transmute(self.colours.as_ptr()),
                (self.colours.len() * size_of::<Vec4>()) as NSUInteger,
                get_managed_buffer_storage_mode(),
            )
        });
        self.per_primitive_data_buffer = Some(unsafe {
            self.device.new_buffer_with_data(
                transmute(self.triangles.as_ptr()),
                (self.triangles.len() * size_of::<Triangle>()) as NSUInteger,
                get_managed_buffer_storage_mode(),
            )
        });
        self.index_buffer
            .as_ref()
            .unwrap()
            .did_modify_range(NSRange::new(
                0,
                self.index_buffer.as_ref().unwrap().length(),
            ));
        self.vertex_position_buffer
            .as_ref()
            .unwrap()
            .did_modify_range(NSRange::new(
                0,
                self.vertex_position_buffer.as_ref().unwrap().length(),
            ));
        self.vertex_normal_buffer
            .as_ref()
            .unwrap()
            .did_modify_range(NSRange::new(
                0,
                self.vertex_normal_buffer.as_ref().unwrap().length(),
            ));
        self.vertex_colour_buffer
            .as_ref()
            .unwrap()
            .did_modify_range(NSRange::new(
                0,
                self.vertex_colour_buffer.as_ref().unwrap().length(),
            ));
        self.per_primitive_data_buffer
            .as_ref()
            .unwrap()
            .did_modify_range(NSRange::new(
                0,
                self.per_primitive_data_buffer.as_ref().unwrap().length(),
            ));

        self.index_buffer
            .as_ref()
            .unwrap()
            .set_label(&format!("index buffer of {}", self.name));
        self.vertex_position_buffer
            .as_ref()
            .unwrap()
            .set_label(&format!("vertex position buffer of {}", self.name));
        self.vertex_normal_buffer
            .as_ref()
            .unwrap()
            .set_label(&format!("vertex normal buffer of {}", self.name));
        self.vertex_colour_buffer
            .as_ref()
            .unwrap()
            .set_label(&format!("vertex colour buffer of {}", self.name));
        self.per_primitive_data_buffer
            .as_ref()
            .unwrap()
            .set_label(&format!("per primitive data buffer of {}", self.name));
    }

    fn clear(&mut self) {
        self.indices.clear();
        self.vertices.clear();
        self.normals.clear();
        self.colours.clear();
        self.triangles.clear();
    }

    fn get_geometry_descriptor(&self) -> AccelerationStructureGeometryDescriptor {
        let descriptor = AccelerationStructureTriangleGeometryDescriptor::descriptor();

        descriptor.set_index_buffer(Some(self.index_buffer.as_ref().unwrap()));
        descriptor.set_index_type(MTLIndexType::UInt16);
        descriptor.set_vertex_buffer(Some(self.vertex_position_buffer.as_ref().unwrap()));
        descriptor.set_vertex_stride(size_of::<Vec4>() as NSUInteger);
        descriptor.set_triangle_count((self.indices.len() / 3) as NSUInteger);
        descriptor
            .set_primitive_data_buffer(Some(self.per_primitive_data_buffer.as_ref().unwrap()));
        descriptor.set_primitive_data_stride(size_of::<Triangle>() as NSUInteger);
        descriptor.set_primitive_data_element_size(size_of::<Triangle>() as NSUInteger);
        From::from(descriptor)
    }

    fn get_resources(&self) -> Vec<Resource> {
        vec![
            From::from(self.index_buffer.as_ref().unwrap().clone()),
            From::from(self.vertex_normal_buffer.as_ref().unwrap().clone()),
            From::from(self.vertex_colour_buffer.as_ref().unwrap().clone()),
        ]
    }
}

#[repr(C)]
pub struct BoundingBox {
    pub min: Vec3,
    pub max: Vec3,
}

#[repr(C)]
pub struct Sphere {
    pub origin_radius_squared: Vec4,
    pub colour_radius: Vec4,
}

pub struct SphereGeometry {
    pub device: Device,
    pub sphere_buffer: Option<Buffer>,
    pub bounding_box_buffer: Option<Buffer>,
    pub per_primitive_data_buffer: Option<Buffer>,
    pub spheres: Vec<Sphere>,
}

impl SphereGeometry {
    pub fn new(device: Device) -> Self {
        Self {
            device,
            sphere_buffer: None,
            bounding_box_buffer: None,
            per_primitive_data_buffer: None,
            spheres: Vec::new(),
        }
    }

    pub fn add_sphere_with_origin(&mut self, origin: Vec3, radius: f32, colour: Vec3) {
        self.spheres.push(Sphere {
            origin_radius_squared: Vec4::from((origin, radius * radius)),
            colour_radius: Vec4::from((colour, radius)),
        });
    }
}

impl Geometry for SphereGeometry {
    fn upload_to_buffers(&mut self) {
        self.sphere_buffer = Some(unsafe {
            self.device.new_buffer_with_data(
                transmute(self.spheres.as_ptr()),
                (self.spheres.len() * size_of::<Sphere>()) as NSUInteger,
                get_managed_buffer_storage_mode(),
            )
        });
        self.sphere_buffer
            .as_ref()
            .unwrap()
            .set_label("sphere buffer");
        let mut bounding_boxes = Vec::new();
        for sphere in &self.spheres {
            bounding_boxes.push(BoundingBox {
                min: sphere.origin_radius_squared.xyz() - sphere.colour_radius.w,
                max: sphere.origin_radius_squared.xyz() + sphere.colour_radius.w,
            });
        }
        self.bounding_box_buffer = Some(unsafe {
            self.device.new_buffer_with_data(
                transmute(bounding_boxes.as_ptr()),
                (bounding_boxes.len() * size_of::<BoundingBox>()) as NSUInteger,
                get_managed_buffer_storage_mode(),
            )
        });
        self.bounding_box_buffer
            .as_ref()
            .unwrap()
            .set_label("bounding box buffer");
        self.sphere_buffer
            .as_ref()
            .unwrap()
            .did_modify_range(NSRange::new(
                0,
                self.sphere_buffer.as_ref().unwrap().length(),
            ));
        self.bounding_box_buffer
            .as_ref()
            .unwrap()
            .did_modify_range(NSRange::new(
                0,
                self.bounding_box_buffer.as_ref().unwrap().length(),
            ));
    }

    fn clear(&mut self) {
        self.spheres.clear();
    }

    fn get_geometry_descriptor(&self) -> AccelerationStructureGeometryDescriptor {
        let descriptor = AccelerationStructureBoundingBoxGeometryDescriptor::descriptor();
        descriptor.set_bounding_box_buffer(Some(self.bounding_box_buffer.as_ref().unwrap()));
        descriptor.set_bounding_box_count(self.spheres.len() as NSUInteger);
        descriptor.set_primitive_data_buffer(Some(&self.sphere_buffer.as_ref().unwrap()));
        descriptor.set_primitive_data_stride(size_of::<Sphere>() as NSUInteger);
        descriptor.set_primitive_data_element_size(size_of::<Sphere>() as NSUInteger);
        From::from(descriptor)
    }

    fn get_resources(&self) -> Vec<Resource> {
        return vec![From::from(self.sphere_buffer.as_ref().unwrap().clone())];
    }

    fn get_intersection_function_name(&self) -> Option<&str> {
        Some("sphereIntersectionFunction")
    }
}

pub struct GeometryInstance {
    pub geometry: Arc<dyn Geometry>,
    pub transform: Mat4,
    pub mask: u32,
    pub index_in_scene: NSUInteger,
}

#[repr(C)]
pub struct AreaLight {
    pub position: Vec4,
    pub forward: Vec4,
    pub right: Vec4,
    pub up: Vec4,
    pub colour: Vec4,
}