//! 3D 数学基础：向量、仿射矩阵、摄像机基向量、投影射线和三角形相交。
//! 矩阵组合顺序决定局部变换如何进入父坐标系；接近退化的逆矩阵、法线和射线使用 Option 拒绝无效计算。
//!
use serde::{Deserialize, Serialize};
use std::ops::{Add, Mul, Sub};

#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
/// 三维数学向量；构造不校验分量，需在输入边界显式调用 valid，不是托管 Vec3 对象。
pub struct Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}
impl Vec3 {
    /// 直接保存三个分量，不隐式归一化或拒绝非有限值。
    pub const fn new(x: f32, y: f32, z: f32) -> Self {
        Self { x, y, z }
    }
    /// 计算向量点积，用于方向投影、光照和相交判断。
    pub fn dot(self, b: Self) -> f32 {
        self.x * b.x + self.y * b.y + self.z * b.z
    }
    /// 计算右手叉积，用于摄像机基向量和三角形法线。
    pub fn cross(self, b: Self) -> Self {
        Self::new(
            self.y * b.z - self.z * b.y,
            self.z * b.x - self.x * b.z,
            self.x * b.y - self.y * b.x,
        )
    }
    /// 计算向量长度；归一化前还需检查是否接近零。
    pub fn length(self) -> f32 {
        self.dot(self).sqrt()
    }
    /// 仅在长度有效且不退化时返回单位向量，避免除零产生非有限结果。
    pub fn normalized(self) -> Option<Self> {
        // 先求模长，拒绝非有限值和长度不大于 1e-6 的向量；返回 None 让相机/法线调用方停止退化计算。
        let length = self.length();
        (length.is_finite() && length > 1e-6).then(|| self * (1.0 / length))
    }
    /// 要求三维向量各分量有限、绝对值不超过一百万；构造和算术运算不会自动调用此检查。
    pub fn valid(self) -> bool {
        // 构造函数与算术运算不会自动验证；此入口显式要求每个分量有限且绝对值至多一百万。
        [self.x, self.y, self.z]
            .iter()
            .all(|v| v.is_finite() && v.abs() <= 1_000_000.0)
    }
}
impl Add for Vec3 {
    type Output = Self;
    /// 按分量执行向量加减或标量乘法，保持数学运算不依赖 VM 状态。
    fn add(self, b: Self) -> Self {
        Self::new(self.x + b.x, self.y + b.y, self.z + b.z)
    }
}
impl Sub for Vec3 {
    type Output = Self;
    /// 按分量执行向量加减或标量乘法，保持数学运算不依赖 VM 状态。
    fn sub(self, b: Self) -> Self {
        Self::new(self.x - b.x, self.y - b.y, self.z - b.z)
    }
}
impl Mul<f32> for Vec3 {
    type Output = Self;
    /// 按分量执行向量加减或标量乘法，保持数学运算不依赖 VM 状态。
    fn mul(self, b: f32) -> Self {
        Self::new(self.x * b, self.y * b, self.z * b)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
/// 仿射 4×4 变换矩阵，支持局部到世界的组合与求逆。
pub struct Matrix(pub [f32; 16]);
impl Default for Matrix {
    /// 建立类型约定的初始值，供尚未发布或尚未交互的状态使用。
    fn default() -> Self {
        Self([
            1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.,
        ])
    }
}
impl Matrix {
    /// 求仿射世界矩阵的逆；退化或不可逆时返回空值。
    pub fn inverse(self) -> Option<Self> {
        // 这里按仿射矩阵处理：最后一行假设为 [0,0,0,1]，只逆左上 3×3，不实现一般透视矩阵求逆。
        let m = self.0;
        let determinant = m[0] * (m[5] * m[10] - m[6] * m[9]) - m[1] * (m[4] * m[10] - m[6] * m[8])
            + m[2] * (m[4] * m[9] - m[5] * m[8]);
        // 接近零行列式意味着某方向被压扁或数值不稳定；不能继续除以 determinant。
        if !determinant.is_finite() || determinant.abs() < 1e-9 {
            return None;
        }
        // 用伴随矩阵除行列式得到线性部分逆矩阵；先把逆平移留为零。
        let d = 1. / determinant;
        let mut out = Self([
            (m[5] * m[10] - m[6] * m[9]) * d,
            (m[2] * m[9] - m[1] * m[10]) * d,
            (m[1] * m[6] - m[2] * m[5]) * d,
            0.,
            (m[6] * m[8] - m[4] * m[10]) * d,
            (m[0] * m[10] - m[2] * m[8]) * d,
            (m[2] * m[4] - m[0] * m[6]) * d,
            0.,
            (m[4] * m[9] - m[5] * m[8]) * d,
            (m[1] * m[8] - m[0] * m[9]) * d,
            (m[0] * m[5] - m[1] * m[4]) * d,
            0.,
            0.,
            0.,
            0.,
            1.,
        ]);
        // 仿射逆平移为 -A⁻¹t。此时 out 平移为零，所以 point 只应用刚求得的线性逆变换。
        let translation = out.point(Vec3::new(m[3], m[7], m[11])) * -1.;
        out.0[3] = translation.x;
        out.0[7] = translation.y;
        out.0[11] = translation.z;
        Some(out)
    }
    /// 组合父子仿射变换，调用顺序决定局部坐标最终落在哪个世界位置。
    pub fn compose(self, local: Self) -> Self {
        // 行主序存储，点视作列向量；self.compose(local) = self × local，即先应用 local 再应用 self。
        let mut out = [0.; 16];
        for row in 0..4 {
            for col in 0..4 {
                out[row * 4 + col] = (0..4)
                    .map(|k| self.0[row * 4 + k] * local.0[k * 4 + col])
                    .sum();
            }
        }
        Self(out)
    }
    /// 对一个位置应用矩阵，包括平移项；不要用它代替纯方向变换。
    pub fn point(self, p: Vec3) -> Vec3 {
        Vec3::new(
            self.0[0] * p.x + self.0[1] * p.y + self.0[2] * p.z + self.0[3],
            self.0[4] * p.x + self.0[5] * p.y + self.0[6] * p.z + self.0[7],
            self.0[8] * p.x + self.0[9] * p.y + self.0[10] * p.z + self.0[11],
        )
    }
    /// 由平移、角度旋转和缩放构造局部仿射矩阵。
    pub fn trs(position: Vec3, rotation: Vec3, scale: Vec3) -> Self {
        // 输入欧拉角单位为度，先转换为弧度。组合为 T × Rz × Ry × Rx × S，列分别乘对应缩放轴。
        let (sx, cx) = rotation.x.to_radians().sin_cos();
        let (sy, cy) = rotation.y.to_radians().sin_cos();
        let (sz, cz) = rotation.z.to_radians().sin_cos();
        // Local X, then Y, then Z rotation; scale first, translation last.
        Self([
            cz * cy * scale.x,
            (cz * sy * sx - sz * cx) * scale.y,
            (cz * sy * cx + sz * sx) * scale.z,
            position.x,
            sz * cy * scale.x,
            (sz * sy * sx + cz * cx) * scale.y,
            (sz * sy * cx - cz * sx) * scale.z,
            position.y,
            -sy * scale.x,
            cy * sx * scale.y,
            cy * cx * scale.z,
            position.z,
            0.,
            0.,
            0.,
            1.,
        ])
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
/// 投影策略：透视视场角或正交可见高度。
pub enum Projection {
    // fov 表示垂直视场角（度），水平范围再乘视口宽高比。
    Perspective { fov: f32 },
    // height 是相机空间可见总高度，与深度无关；宽度为 height × aspect。
    Orthographic { height: f32 },
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
/// 原生摄像机描述，包括观察基、近远面和投影参数；宽高比由视口提供。
pub struct Camera {
    pub position: Vec3,
    pub target: Vec3,
    pub up: Vec3,
    pub near: f32,
    pub far: f32,
    pub projection: Projection,
}
impl Default for Camera {
    /// 建立类型约定的初始值，供尚未发布或尚未交互的状态使用。
    fn default() -> Self {
        Self {
            position: Vec3::new(0., 0., 5.),
            target: Vec3::default(),
            up: Vec3::new(0., 1., 0.),
            near: 0.1,
            far: 1000.,
            projection: Projection::Perspective { fov: 50. },
        }
    }
}
#[derive(Debug, Clone, Copy)]
/// 摄像机的右、上、前单位基向量。
pub struct Basis {
    pub right: Vec3,
    pub up: Vec3,
    pub forward: Vec3,
}
impl Camera {
    /// 从观察位置、目标和上方向建立正交相机基；方向退化时拒绝。
    pub fn basis(self) -> Option<Basis> {
        // forward 指向观察目标；up 输入只提供大致上方向，叉积后重新正交化。
        // 位置等于目标、up 为零或与前向平行时，normalized 返回 None。
        let forward = (self.target - self.position).normalized()?;
        let right = forward.cross(self.up).normalized()?;
        let up = right.cross(forward).normalized()?;
        Some(Basis { right, up, forward })
    }
    /// 验证相机向量/观察基、裁剪面次序和投影参数；退化方向、非法视场角或正交高度均返回 false。
    pub fn valid(self) -> bool {
        // 除了向量范围，还要求有效观察基、0 < near < far，以及合法视场角或正交高度。
        self.position.valid()
            && self.target.valid()
            && self.up.valid()
            && self.basis().is_some()
            && self.near.is_finite()
            && self.far.is_finite()
            && self.near > 0.
            && self.far > self.near
            && self.far <= 1_000_000.
            && match self.projection {
                Projection::Perspective { fov } => fov.is_finite() && (1.0..=175.0).contains(&fov),
                Projection::Orthographic { height } => {
                    height.is_finite() && height > 0. && height <= 1_000_000.
                }
            }
    }
    /// 把世界点投影到相机的右/上/前基向量坐标。
    pub fn view(self, basis: Basis, p: Vec3) -> Vec3 {
        // 先把世界点相对化，再点乘正交基；这里前方 z 为正，与某些图形 API 的负 z 约定不同。
        let p = p - self.position;
        Vec3::new(p.dot(basis.right), p.dot(basis.up), p.dot(basis.forward))
    }
    /// 从视口归一化坐标生成透视或正交射线；宽高比由具体视口提供。
    pub fn ray(self, u: f32, v: f32, aspect: f32) -> Option<Ray> {
        let basis = self.basis()?;
        // u/v 通常是视口内 [0,1]，映射到 [-1,1] 并翻转屏幕 y。
        // 此函数不钳制输入，捕获拖动可以从视口外继续生成射线；aspect 由调用方保证有效。
        let (x, y) = (u * 2. - 1., 1. - v * 2.);
        match self.projection {
            Projection::Perspective { fov } => {
                // 透视射线共用相机原点，方向沿前向加上视平面偏移，最后归一化。
                let half = (fov.to_radians() / 2.).tan();
                Some(Ray {
                    origin: self.position,
                    direction: (basis.forward
                        + basis.right * (x * half * aspect)
                        + basis.up * (y * half))
                        .normalized()?,
                })
            }
            // 正交射线方向都为 forward，只改变起点在相机右/上平面中的位置。
            Projection::Orthographic { height } => Some(Ray {
                origin: self.position
                    + basis.right * (x * height * aspect / 2.)
                    + basis.up * (y * height / 2.),
                direction: basis.forward,
            }),
        }
    }
}
#[derive(Debug, Clone, Copy)]
/// 世界坐标中的射线原点与方向，供网格和面板求交。
pub struct Ray {
    pub origin: Vec3,
    pub direction: Vec3,
}
impl Ray {
    /// 求射线与三角形相交距离和重心坐标，拒绝退化三角形及射线起点后方的交点。
    pub fn triangle(self, a: Vec3, b: Vec3, c: Vec3) -> Option<(f32, [f32; 3])> {
        // Möller–Trumbore 求交：使用两条三角形边与叉积解重心系数，不先构造平面方程。
        let ab = b - a;
        let ac = c - a;
        let p = self.direction.cross(ac);
        let determinant = ab.dot(p);
        // 近零表示射线与面平行或三角形退化；保留正负行列式，因此不做背面剔除。
        if determinant.abs() < 1e-7 {
            return None;
        }
        let inverse = 1.0 / determinant;
        let t = self.origin - a;
        // u 是顶点 b 的重心权重，必须位于 [0,1]；v 是 c 的权重，a 的权重由 1-u-v 得到。
        let u = t.dot(p) * inverse;
        if !(0.0..=1.0).contains(&u) {
            return None;
        }
        let q = t.cross(ab);
        let v = self.direction.dot(q) * inverse;
        if v < 0. || u + v > 1. {
            return None;
        }
        // 返回的是射线参数 t，方向为单位向量时才等于世界距离；负值在射线起点后方，被拒绝。
        let distance = ac.dot(q) * inverse;
        (distance >= 0.).then_some((distance, [1. - u - v, u, v]))
    }
}