use crate::{math::*, *};
use mb3_dat::Patch9;
#[derive(Clone, Copy, Debug)]
pub struct Sample {
    pub point: DVec3,
    pub normal: DVec3,
}
#[derive(Debug)]
pub struct Mesh {
    pub points: Vec<DVec3>,
    pub normals: Vec<DVec3>,
    pub columns: usize,
    pub rows: usize,
    pub bounds: Aabb,
    pub stats: Stats,
}
fn shape(p: &Patch9) -> Result<(usize, usize)> {
    let au = p.anchors_u as usize;
    let av = p.anchors_v as usize;
    if au < 3 || av < 3 || au % 2 == 0 || av % 2 == 0 || p.quads_u < 2 || p.quads_v < 2 {
        return Err(Error::InvalidDimensions);
    }
    if p.anchors.len() != au.checked_mul(av).ok_or(Error::Overflow)? {
        return Err(Error::InconsistentData);
    }
    Ok((au / 2, av / 2))
}
fn basis(t: f64) -> ([f64; 3], [f64; 3]) {
    (
        [(1. - t) * (1. - t), 2. * t * (1. - t), t * t],
        [-2. * (1. - t), 2. - 4. * t, 2. * t],
    )
}
fn evaluate(
    p: &Patch9,
    tile_u: usize,
    tile_v: usize,
    u: f64,
    v: f64,
    policy: Policy,
) -> Result<Sample> {
    let (bu, du) = basis(u);
    let (bv, dv) = basis(v);
    let mut point = [0.; 3];
    let mut tangent_u = [0.; 3];
    let mut tangent_v = [0.; 3];
    for j in 0..3 {
        for i in 0..3 {
            let index = (tile_u * 2 + i) + (tile_v * 2 + j) * (p.anchors_u as usize);
            let a = from_f32(*p.anchors.get(index).ok_or(Error::InconsistentData)?)?;
            point = add(point, scale(a, bu[i] * bv[j]));
            tangent_u = add(tangent_u, scale(a, du[i] * bv[j]));
            tangent_v = add(tangent_v, scale(a, bu[i] * dv[j]));
        }
    }
    let n = cross(unit(tangent_v)?, unit(tangent_u)?);
    if length(n) <= policy.angular_epsilon {
        return Err(Error::Degenerate);
    }
    Ok(Sample {
        point: finite(point)?,
        normal: unit(n)?,
    })
}
pub fn sample(
    p: &Patch9,
    tile_u: usize,
    tile_v: usize,
    u: f64,
    v: f64,
    policy: Policy,
) -> Result<Sample> {
    let policy = policy.validate()?;
    let (tu, tv) = shape(p)?;
    if tile_u >= tu
        || tile_v >= tv
        || !u.is_finite()
        || !v.is_finite()
        || !(0. ..=1.).contains(&u)
        || !(0. ..=1.).contains(&v)
    {
        return Err(Error::InvalidDimensions);
    }
    evaluate(p, tile_u, tile_v, u, v, policy)
}
pub fn tessellate(p: &Patch9, policy: Policy, limits: ComputeLimits) -> Result<Mesh> {
    let policy = policy.validate()?;
    let (tu, tv) = shape(p)?;
    let qu = p.quads_u as usize;
    let qv = p.quads_v as usize;
    let columns = tu
        .checked_mul(qu)
        .and_then(|n| n.checked_add(1))
        .ok_or(Error::Overflow)?;
    let rows = tv
        .checked_mul(qv)
        .and_then(|n| n.checked_add(1))
        .ok_or(Error::Overflow)?;
    let n = columns.checked_mul(rows).ok_or(Error::Overflow)?;
    if n > limits.max_vertices {
        return Err(Error::Limit);
    }
    let mut b = Budget {
        limits,
        stats: Stats::default(),
    };
    b.work(p.anchors.len())?;
    for v in &p.anchors {
        from_f32(*v)?;
    }
    let mut points = b.reserve(n)?;
    let mut normals = b.reserve(n)?;
    for y in 0..rows {
        let ty = (y / qv).min(tv - 1);
        let v = (y - ty * qv) as f64 / qv as f64;
        for x in 0..columns {
            b.work(9)?;
            let tx = (x / qu).min(tu - 1);
            let u = (x - tx * qu) as f64 / qu as f64;
            let s = evaluate(p, tx, ty, u, v, policy)?;
            points.push(s.point);
            normals.push(s.normal);
        }
    }
    let bounds = Aabb::from_points(points.iter().copied())?.ok_or(Error::Degenerate)?;
    b.stats.vertices = n;
    Ok(Mesh {
        points,
        normals,
        columns,
        rows,
        bounds,
        stats: b.stats,
    })
}
#[cfg(test)]
pub(crate) fn flat(au: u32, av: u32) -> Patch9 {
    Patch9 {
        anchors_u: au,
        anchors_v: av,
        quads_u: 2,
        quads_v: 2,
        anchors: (0..av)
            .flat_map(|v| (0..au).map(move |u| [u as f32, 0., v as f32]))
            .collect(),
        computed: None,
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn flat_patch_endpoints_grid_and_normals() {
        let p = flat(3, 3);
        let m = tessellate(&p, Policy::default(), ComputeLimits::default()).unwrap();
        assert_eq!((m.columns, m.rows), (3, 3));
        assert_eq!(m.points[0], [0., 0., 0.]);
        assert_eq!(m.points[8], [2., 0., 2.]);
        assert!(m.normals.iter().all(|v| *v == [0., 1., 0.]));
        assert_eq!(m.bounds.min, [0.; 3]);
    }
    #[test]
    fn curvature_midpoint_and_shared_seams() {
        let mut p = flat(5, 3);
        p.anchors[1][1] = 4.;
        p.anchors[6][1] = 4.;
        p.anchors[11][1] = 4.;
        let left = sample(&p, 0, 0, 1., 0.5, Policy::default()).unwrap();
        let right = sample(&p, 1, 0, 0., 0.5, Policy::default()).unwrap();
        assert_eq!(left.point, right.point);
        assert_eq!(
            sample(&p, 0, 0, 0.5, 0.5, Policy::default()).unwrap().point,
            [1., 2., 1.]
        );
        let m = tessellate(&p, Policy::default(), ComputeLimits::default()).unwrap();
        assert_eq!((m.columns, m.rows), (5, 3));
    }
    #[test]
    fn bad_shapes_degeneracy_and_limits() {
        let mut p = flat(3, 3);
        p.anchors.pop();
        assert!(tessellate(&p, Policy::default(), ComputeLimits::default()).is_err());
        p = flat(3, 3);
        p.anchors.fill([0.; 3]);
        assert!(tessellate(&p, Policy::default(), ComputeLimits::default()).is_err());
        p = flat(3, 3);
        for l in [
            ComputeLimits {
                max_vertices: 8,
                ..Default::default()
            },
            ComputeLimits {
                max_work: 1,
                ..Default::default()
            },
            ComputeLimits {
                max_owned_bytes: 1,
                ..Default::default()
            },
        ] {
            assert!(tessellate(&p, Policy::default(), l).is_err());
        }
        assert!(sample(&p, 1, 0, 0., 0., Policy::default()).is_err());
        p.quads_u = u32::MAX;
        p.quads_v = u32::MAX;
        assert!(tessellate(&p, Policy::default(), ComputeLimits::default()).is_err());
    }
}