use bevy::{math::Vec3A, render::primitives::Aabb};

use crate::prelude::*;

/// Hit data for 3d objects in Global (not Local) space and the distance from the Camera
#[derive(Debug, Clone)]
pub(crate) struct Hit3d {
    pub distance: f32,
}

/// A 3D Triangle used for ray-intersection tests
#[derive(Debug)]
struct Triangle {
    v0: Vec3,
    v1: Vec3,
    v2: Vec3,
}

/// Helper functions for ray-intersect testing
impl Triangle {
    fn normal(&self) -> Vec3 {
        (self.edge_a()).cross(self.edge_b())
    }

    fn normal_plane(&self) -> Plane3d {
        // HACK: This should just be `try_from_points` or `try_new`
        match Direction3d::new((self.v1 - self.v0).cross(self.v2 - self.v0)) {
            Ok(normal) => Plane3d { normal },
            Err(_) => Plane3d::default(),
        }
    }

    fn edge_a(&self) -> Vec3 {
        self.v1 - self.v0
    }

    fn edge_b(&self) -> Vec3 {
        self.v2 - self.v0
    }

    fn edge0(&self) -> Vec3 {
        self.v1 - self.v0
    }

    fn edge1(&self) -> Vec3 {
        self.v2 - self.v1
    }

    fn edge2(&self) -> Vec3 {
        self.v0 - self.v2
    }
}

pub(crate) fn intersects_aabb_3d(ray: &Ray3d, aabb: &Aabb, gt: &GlobalTransform) -> Option<Hit3d> {
    let world_to_model = gt.compute_matrix().inverse();
    let ray_dir: Vec3A =  world_to_model.transform_vector3(*ray.direction).into();
    let ray_origin: Vec3A = world_to_model.transform_point3(ray.origin).into();

    let t0 = (aabb.min() - ray_origin) / ray_dir;
    let t1 = (aabb.max() - ray_origin) / ray_dir;
    let t_min = t0.min(t1);
    let t_max = t0.max(t1);

    let mut hit_near = t_min.x;
    let mut hit_far = t_max.x;

    if hit_near > t_max.y || t_min.y > hit_far {
        return None;
    }

    if t_min.y > hit_near {
        hit_near = t_min.y;
    }
    if t_max.y < hit_far {
        hit_far = t_max.y;
    }

    if (hit_near > t_max.z) || (t_min.z > hit_far) {
        return None;
    }

    if t_min.z > hit_near {
        hit_near = t_min.z;
    }
    if t_max.z < hit_far {
        hit_far = t_max.z;
    }
    Some(Hit3d { distance: (hit_near + hit_far) / 2.0 })
}

/// Heavily synthesized from these two resources:
/// * Textbook: https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-rendering-a-triangle/ray-triangle-intersection-geometric-solution.html
/// * Example: https://github.com/aevyrie/bevy_mod_raycast/blob/435d8ef100738797161ac3a9b910ea346a4ed6e6/src/raycast.rs#L43
pub(crate) fn intersects3d(ray: &Ray3d, mesh: &Mesh, gt: &GlobalTransform) -> Option<Hit3d> {
    // First do an Aabb intersection test
    if let Some(aabb) = mesh.compute_aabb() {
        // Do the Aabb test
        if let Some(_) = intersects_aabb_3d(ray, &aabb, gt) {
            // If it passes that do the real intersection test
            let attr = MeshVertexAttribute::new("Vertex_Position", 0, VertexFormat::Float32x3);
            if let Some(verts) = mesh.attribute(attr) {
                if let Some(idxs) = mesh.indices() {
                    match verts {
                        VertexAttributeValues::Float32x3(vals) => {
                            idxs.iter()
                                .array_chunks::<3>()
                                // Convert arrays to vec3
                                .map(|[x, y, z]| {
                                    [
                                        Vec3::from_array(vals[x]),
                                        Vec3::from_array(vals[y]),
                                        Vec3::from_array(vals[z]),
                                    ]
                                })
                                // Transform each point by the global transform
                                .map(|[a, b, c]| {
                                    [
                                        gt.transform_point(a),
                                        gt.transform_point(b),
                                        gt.transform_point(c),
                                    ]
                                })
                                // Collect everything into a triangle for easy operations
                                .map(|[v0, v1, v2]| Triangle { v0, v1, v2 })
                                .filter_map(|triangle| {
                                    // Calculate the distance this ray hits the plane normal to the tri
                                    if let Some(d) =
                                        ray.intersect_plane(triangle.v0, triangle.normal_plane())
                                    {
                                        // Calculate the point on that plane which intersects
                                        let p = ray.get_point(d);
                                        // Inside out test
                                        let hit = {
                                            // Determine if p is w/in edge0
                                            let c0 = triangle.edge0().cross(p - triangle.v0);
                                            // Determine if p is w/in edge1
                                            let c1 = triangle.edge1().cross(p - triangle.v1);
                                            // Determine if p is w/in edge2
                                            let c2 = triangle.edge2().cross(p - triangle.v2);

                                            // Check all three at once
                                            triangle.normal().dot(c0) > 0.0
                                                && triangle.normal().dot(c1) > 0.0
                                                && triangle.normal().dot(c2) > 0.0
                                        };
                                        hit.then_some(Hit3d { distance: d })
                                    } else {
                                        None
                                    }
                                })
                                .min_by(|a, b| a.distance.total_cmp(&b.distance))
                        }
                        _ => None,
                    }
                } else {
                    None
                }
            } else {
                None
            }
        } else {
            None
        }
    } else {
        None
    }
}