use stl_io::{self, Normal, Triangle, Vertex};

use crate::layers::{Layer, Layers};

fn new_triangle(p1: &Vertex, p2: &Vertex, p3: &Vertex) -> stl_io::Triangle {
    // Set Vector U to (Triangle.p2 minus Triangle.p1)
    // Set Vector V to (Triangle.p3 minus Triangle.p1)

    // Set Normal.x to (multiply U.y by V.z) minus (multiply U.z by V.y)
    // Set Normal.y to (multiply U.z by V.x) minus (multiply U.x by V.z)
    // Set Normal.z to (multiply U.x by V.y) minus (multiply U.y by V.x)

    let u = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
    let v = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];

    let n_x = (u[1] * v[2]) - (u[2] * v[1]);
    let n_y = (u[2] * v[0]) - (u[0] * v[2]);
    let n_z = (u[0] * v[1]) - (u[1] * v[0]);

    stl_io::Triangle {
        normal: Normal::new([n_x, n_y, n_z]),
        vertices: [*p1, *p2, *p3],
    }
}

/// Find a point on the cirle at a given angle (in radians).
fn vertex_on_circle(center: &Vertex, radius: f32, angle: f32) -> Vertex {
    let x = center[0] + (radius * angle.cos());
    let y = center[1] + (radius * angle.sin());
    let z = center[2];

    Vertex::new([x, y, z])
}

fn vertexes_on_circle(layer: &Layer, steps: u32) -> Vec<Vertex> {
    let mut result = Vec::with_capacity(steps as usize);
    let stepsize = std::f64::consts::TAU / steps as f64;

    for i in 0..steps {
        let angle = (i as f64 * stepsize) as f32;
        result.push(vertex_on_circle(&layer.center, layer.radius, angle));
    }
    result
}

fn tube_base(center: &Vertex, edge: &[Vertex]) -> Vec<Triangle> {
    let mut result = Vec::with_capacity(edge.len());

    for i in 0..edge.len() {
        result.push(new_triangle(center, &edge[(i + 1) % edge.len()], &edge[i]));
    }

    result
}

fn tube_sides(botoom_edge: &[Vertex], top_edge: &[Vertex]) -> Vec<Triangle> {
    assert_eq!(botoom_edge.len(), top_edge.len());

    let mut result = Vec::with_capacity(2 * botoom_edge.len());

    for i in 0..botoom_edge.len() {
        let j = (i + 1) % botoom_edge.len();

        result.push(new_triangle(&botoom_edge[i], &top_edge[j], &top_edge[i]));
        result.push(new_triangle(&botoom_edge[i], &botoom_edge[j], &top_edge[j]));
    }

    result
}

fn tube_top(center: &Vertex, edge: &[Vertex]) -> Vec<Triangle> {
    // The top is the same, except the normals are reversed. We can do that by reversing the order of the vertexes.
    let mut edge = edge.to_owned();
    edge.reverse();

    tube_base(center, &edge)
}

pub fn render(layers: &Layers, resolution: f32) -> Vec<Triangle> {
    // Top and Bottom must be a single point, and must be at least one middle layer.
    assert!(!layers.layers.is_empty());

    // How many vertexes per circle. IE: the resolution of the circle.
    let circle_steps =
        ((layers.max_radius() * std::f32::consts::TAU) / resolution).max(64.0) as u32;

    let mut layer_vertexes: Vec<Vec<Vertex>> = Vec::with_capacity(layers.layers.len());

    for layer in &layers.layers {
        layer_vertexes.push(vertexes_on_circle(layer, circle_steps));
    }

    // Estimate triangle count: base + sides + top
    let estimated_triangles = layers.layers.len() * circle_steps as usize * 2;
    let mut result: Vec<Triangle> = Vec::with_capacity(estimated_triangles as usize);

    result.append(&mut tube_base(&layers.base, &layer_vertexes[0]));
    for i in 0..layer_vertexes.len() - 1 {
        result.append(&mut tube_sides(&layer_vertexes[i], &layer_vertexes[i + 1]));
    }
    result.append(&mut tube_top(&layers.top, layer_vertexes.last().unwrap()));

    result
}

#[cfg(test)]
mod tests {
    use approx::relative_eq;

    use super::*;

    #[test]
    fn new_triangle_normal() {
        // Simple triangle
        let a = Vertex::new([1.0, 0.0, 0.0]);
        let b = Vertex::new([0.0, 1.0, 0.0]);
        let c = Vertex::new([-1.0, 0.0, 0.0]);

        let tri = new_triangle(&a, &b, &c);

        assert_eq!(tri.normal, Normal::new([0.0, 0.0, 2.0]));

        // Same triangle, reverse order.
        let tri = new_triangle(&c, &b, &a);

        assert_eq!(tri.normal, Normal::new([0.0, 0.0, -2.0]));

        // Uneven numbers.
        let a = Vertex::new([2.0, 0.0, 0.0]);
        let b = Vertex::new([0.0, 3.0, 0.0]);
        let c = Vertex::new([-4.0, 0.0, 0.0]);

        let tri_big = new_triangle(&a, &b, &c);

        assert_eq!(tri_big.normal, Normal::new([0.0, 0.0, 18.0]));
    }

    fn validate_vec_vertex_relative_eq(val: &Vec<Vertex>, expected: &Vec<Vertex>) {
        let mut pass = true;

        if val.len() != expected.len() {
            pass = false;
        }

        for i in 0..val.len() {
            for j in 0..3 {
                if !relative_eq!(val[i][j], expected[i][j]) {
                    pass = false;
                }
            }
        }

        if !pass {
            // We re-compare here (which will always fail) to get the friendly error message,
            // which I can't figure out how to generate directly.
            assert_eq!(val, expected);
        }
    }

    #[test]
    fn vertexes_on_circle_basic() {
        let val = vertexes_on_circle(
            &Layer {
                center: Vertex::new([0.0, 0.0, 0.0]),
                radius: 1.0,
            },
            4,
        );

        let expected = [
            Vertex::new([1.0, 0.0, 0.0]),
            Vertex::new([0.0, 1.0, 0.0]),
            Vertex::new([-1.0, 0.0, 0.0]),
            Vertex::new([0.0, -1.0, 0.0]),
        ]
        .to_vec();

        validate_vec_vertex_relative_eq(&val, &expected);
    }

    #[test]
    fn vertexes_on_circle_complex() {
        let val = vertexes_on_circle(
            &Layer {
                center: Vertex::new([4.0, 5.0, 6.0]),
                radius: 3.0,
            },
            4,
        );

        let expected = [
            Vertex::new([7.0, 5.0, 6.0]),
            Vertex::new([4.0, 8.0, 6.0]),
            Vertex::new([1.0, 5.0, 6.0]),
            Vertex::new([4.0, 2.0, 6.0]),
        ]
        .to_vec();

        validate_vec_vertex_relative_eq(&val, &expected);
    }

    #[test]
    fn tube_base_test() {
        // fn tube_base(center: &Vertex, edge: &Vec<Vertex>) -> Vec<Triangle> {

        let center = Vertex::new([0.0, 0.0, 0.0]);
        let edge = vertexes_on_circle(
            &Layer {
                center: center.clone(),
                radius: 1.0,
            },
            4,
        );

        let triangles = tube_base(&center, &edge);

        assert_eq!(triangles.len(), edge.len());

        for t in triangles {
            // All of these triangles should have the same normal (down).
            assert_eq!(t.normal, Vertex::new([0.0, 0.0, -1.0]));
        }
    }

    #[test]
    fn tube_top_test() {
        let center = Vertex::new([0.0, 0.0, 0.0]);
        let edge = vertexes_on_circle(
            &Layer {
                center: center.clone(),
                radius: 1.0,
            },
            4,
        );

        let triangles = tube_top(&center, &edge);

        assert_eq!(triangles.len(), edge.len());

        for t in triangles {
            // All of these triangles should have the same normal (up).
            assert_eq!(t.normal, Vertex::new([0.0, 0.0, 1.0]));
        }
    }

    #[test]
    fn render_test() {
        let layers = Layers {
            base: Vertex::new([0.0, 0.0, 0.0]),
            layers: [
                Layer {
                    center: Vertex::new([0.0, 0.0, 1.0]),
                    radius: 1.0,
                },
                Layer {
                    center: Vertex::new([0.0, 0.0, 2.0]),
                    radius: 1.0,
                },
            ]
            .to_vec(),
            top: Vertex::new([0.0, 0.0, 3.0]),
        };

        let mesh = render(&layers, 10.0); // Large resolution ensures minimum steps of 64.

        // 64 triangles for top, 128 for sides, 64 for bottom.
        assert_eq!(mesh.len(), 64 + 128 + 64);

        for i in 0..mesh.len() {
            if i < 64 {
                assert!(mesh[i].normal[2] < 0.0) // Bottom triangles point down.
            } else if i < (64 + 128) {
                assert!(mesh[i].normal[2] == 0.0) // side triangles point out.
            } else {
                assert!(mesh[i].normal[2] > 0.0) // top triangles point up.
            }
        }
    }
}