#![allow(clippy::identity_op)]

/// Outputs render info in a format suitable for e.g. OpenGL.
use crate::{
    color::Color,
    fonts::Fonts,
    math::{remap, vec2, Vec2, TAU},
    types::PaintCmd,
};

#[derive(Clone, Copy, Debug, Default, Serialize)]
pub struct Vertex {
    /// Pixel coordinates
    pub pos: Vec2,
    /// Texel indices into the texture
    pub uv: (u16, u16),
    /// sRGBA
    pub color: Color,
}

#[derive(Clone, Debug, Default, Serialize)]
pub struct Mesh {
    /// Draw as triangles (i.e. the length is a multiple of three)
    pub indices: Vec<u32>,
    pub vertices: Vec<Vertex>,
}

impl Mesh {
    pub fn append(&mut self, mesh: &Mesh) {
        let index_offset = self.vertices.len() as u32;
        for index in &mesh.indices {
            self.indices.push(index_offset + index);
        }
        self.vertices.extend(mesh.vertices.iter());
    }

    fn triangle(&mut self, a: u32, b: u32, c: u32) {
        self.indices.push(a);
        self.indices.push(b);
        self.indices.push(c);
    }

    /// Uniformly colored rectangle
    pub fn add_rect(&mut self, top_left: Vertex, bottom_right: Vertex) {
        debug_assert_eq!(top_left.color, bottom_right.color);

        let idx = self.vertices.len() as u32;
        self.triangle(idx + 0, idx + 1, idx + 2);
        self.triangle(idx + 2, idx + 1, idx + 3);

        let top_right = Vertex {
            pos: vec2(bottom_right.pos.x, top_left.pos.y),
            uv: (bottom_right.uv.0, top_left.uv.1),
            color: top_left.color,
        };
        let botom_left = Vertex {
            pos: vec2(top_left.pos.x, bottom_right.pos.y),
            uv: (top_left.uv.0, bottom_right.uv.1),
            color: top_left.color,
        };
        self.vertices.push(top_left);
        self.vertices.push(top_right);
        self.vertices.push(botom_left);
        self.vertices.push(bottom_right);
    }

    /// Split a large mesh into many small.
    /// All the returned meshes will have indices that fit into u16.
    pub fn split_to_u16(self) -> Vec<Mesh> {
        const MAX_SIZE: u32 = 1 << 16;

        if self.vertices.len() < MAX_SIZE as usize {
            return vec![self]; // Common-case optimization
        }

        let mut output = vec![];
        let mut index_cursor = 0;

        while index_cursor < self.indices.len() {
            let span_start = index_cursor;
            let mut min_vindex = self.indices[index_cursor];
            let mut max_vindex = self.indices[index_cursor];

            while index_cursor < self.indices.len() {
                let (mut new_min, mut new_max) = (min_vindex, max_vindex);
                for i in 0..3 {
                    let idx = self.indices[index_cursor + i];
                    new_min = new_min.min(idx);
                    new_max = new_max.max(idx);
                }

                if new_max - new_min < MAX_SIZE {
                    // Triangle fits
                    min_vindex = new_min;
                    max_vindex = new_max;
                    index_cursor += 3;
                } else {
                    break;
                }
            }

            assert!(
                index_cursor > span_start,
                "One triangle spanned more than {} vertices",
                MAX_SIZE
            );

            output.push(Mesh {
                indices: self.indices[span_start..index_cursor]
                    .iter()
                    .map(|vi| vi - min_vindex)
                    .collect(),
                vertices: self.vertices[(min_vindex as usize)..=(max_vindex as usize)].to_vec(),
            });
        }
        return output;
    }
}

#[derive(Clone, Copy, PartialEq)]
pub enum PathType {
    Open,
    Closed,
}
use self::PathType::*;

pub struct Mesher {
    pub anti_alias: bool,
    pub aa_size: f32,

    /// Where the output goes
    pub mesh: Mesh,
}

impl Mesher {
    pub fn new(pixels_per_point: f32) -> Mesher {
        Mesher {
            anti_alias: true,
            aa_size: 1.0 / pixels_per_point,
            mesh: Default::default(),
        }
    }

    pub fn fill_closed_path(&mut self, points: &[Vec2], normals: &[Vec2], color: Color) {
        assert_eq!(points.len(), normals.len());
        let n = points.len() as u32;
        let vert = |pos, color| Vertex {
            pos,
            uv: (0, 0),
            color,
        };
        let mesh = &mut self.mesh;
        if self.anti_alias {
            let color_outer = color.transparent();
            let idx_inner = mesh.vertices.len() as u32;
            let idx_outer = idx_inner + 1;
            for i in 2..n {
                mesh.triangle(idx_inner + 2 * (i - 1), idx_inner, idx_inner + 2 * i);
            }
            let mut i0 = n - 1;
            for i1 in 0..n {
                let dm = normals[i1 as usize] * self.aa_size * 0.5;
                mesh.vertices.push(vert(points[i1 as usize] - dm, color));
                mesh.vertices
                    .push(vert(points[i1 as usize] + dm, color_outer));
                mesh.triangle(idx_inner + i1 * 2, idx_inner + i0 * 2, idx_outer + 2 * i0);
                mesh.triangle(idx_outer + i0 * 2, idx_outer + i1 * 2, idx_inner + 2 * i1);
                i0 = i1;
            }
        } else {
            let idx = mesh.vertices.len() as u32;
            mesh.vertices
                .extend(points.iter().map(|&pos| vert(pos, color)));
            for i in 2..n {
                mesh.triangle(idx, idx + i - 1, idx + i);
            }
        }
    }

    pub fn paint_path(
        &mut self,
        path_type: PathType,
        points: &[Vec2],
        normals: &[Vec2],
        color: Color,
        width: f32,
    ) {
        assert_eq!(points.len(), normals.len());
        let n = points.len() as u32;
        let hw = width / 2.0;
        let idx = self.mesh.vertices.len() as u32;

        let vert = |pos, color| Vertex {
            pos,
            uv: (0, 0),
            color,
        };
        let mesh = &mut self.mesh;

        if self.anti_alias {
            let color_outer = color.transparent();
            let thin_line = width <= 1.0;
            let mut color_inner = color;
            if thin_line {
                // Fade out as it gets thinner:
                color_inner.a = (f32::from(color_inner.a) * width).round() as u8;
            }
            // TODO: line caps ?
            let mut i0 = n - 1;
            for i1 in 0..n {
                let connect_with_previous = path_type == PathType::Closed || i1 > 0;
                if thin_line {
                    let p = points[i1 as usize];
                    let n = normals[i1 as usize];
                    mesh.vertices.push(vert(p + n * self.aa_size, color_outer));
                    mesh.vertices.push(vert(p, color_inner));
                    mesh.vertices.push(vert(p - n * self.aa_size, color_outer));

                    if connect_with_previous {
                        mesh.triangle(idx + 3 * i0 + 0, idx + 3 * i0 + 1, idx + 3 * i1 + 0);
                        mesh.triangle(idx + 3 * i0 + 1, idx + 3 * i1 + 0, idx + 3 * i1 + 1);

                        mesh.triangle(idx + 3 * i0 + 1, idx + 3 * i0 + 2, idx + 3 * i1 + 1);
                        mesh.triangle(idx + 3 * i0 + 2, idx + 3 * i1 + 1, idx + 3 * i1 + 2);
                    }
                } else {
                    let hw = (width - self.aa_size) * 0.5;
                    let p = points[i1 as usize];
                    let n = normals[i1 as usize];
                    mesh.vertices
                        .push(vert(p + n * (hw + self.aa_size), color_outer));
                    mesh.vertices.push(vert(p + n * (hw + 0.0), color_inner));
                    mesh.vertices.push(vert(p - n * (hw + 0.0), color_inner));
                    mesh.vertices
                        .push(vert(p - n * (hw + self.aa_size), color_outer));

                    if connect_with_previous {
                        mesh.triangle(idx + 4 * i0 + 0, idx + 4 * i0 + 1, idx + 4 * i1 + 0);
                        mesh.triangle(idx + 4 * i0 + 1, idx + 4 * i1 + 0, idx + 4 * i1 + 1);

                        mesh.triangle(idx + 4 * i0 + 1, idx + 4 * i0 + 2, idx + 4 * i1 + 1);
                        mesh.triangle(idx + 4 * i0 + 2, idx + 4 * i1 + 1, idx + 4 * i1 + 2);

                        mesh.triangle(idx + 4 * i0 + 2, idx + 4 * i0 + 3, idx + 4 * i1 + 2);
                        mesh.triangle(idx + 4 * i0 + 3, idx + 4 * i1 + 2, idx + 4 * i1 + 3);
                    }
                }
                i0 = i1;
            }
        } else {
            let last_index = if path_type == Closed { n } else { n - 1 };
            for i in 0..last_index {
                mesh.triangle(
                    idx + (2 * i + 0) % (2 * n),
                    idx + (2 * i + 1) % (2 * n),
                    idx + (2 * i + 2) % (2 * n),
                );
                mesh.triangle(
                    idx + (2 * i + 2) % (2 * n),
                    idx + (2 * i + 1) % (2 * n),
                    idx + (2 * i + 3) % (2 * n),
                );
            }

            for (&p, &n) in points.iter().zip(normals) {
                mesh.vertices.push(vert(p + hw * n, color));
                mesh.vertices.push(vert(p - hw * n, color));
            }
        }
    }

    pub fn paint(&mut self, fonts: &Fonts, commands: &[PaintCmd]) {
        let mut path_points = Vec::new();
        let mut path_normals = Vec::new();

        for cmd in commands {
            match cmd {
                PaintCmd::Circle {
                    center,
                    fill_color,
                    outline,
                    radius,
                } => {
                    path_points.clear();
                    path_normals.clear();

                    let n = 32; // TODO: parameter
                    for i in 0..n {
                        let angle = remap(i as f32, 0.0, n as f32, 0.0, TAU);
                        let normal = vec2(angle.cos(), angle.sin());
                        path_normals.push(normal);
                        path_points.push(*center + *radius * normal);
                    }

                    if let Some(color) = fill_color {
                        self.fill_closed_path(&path_points, &path_normals, *color);
                    }
                    if let Some(outline) = outline {
                        self.paint_path(
                            Closed,
                            &path_points,
                            &path_normals,
                            outline.color,
                            outline.width,
                        );
                    }
                }
                PaintCmd::Mesh(cmd_frame) => {
                    self.mesh.append(cmd_frame);
                }
                PaintCmd::Line {
                    points,
                    color,
                    width,
                } => {
                    let n = points.len();
                    if n >= 2 {
                        path_points = points.clone();
                        path_normals.clear();

                        path_normals.push((path_points[1] - path_points[0]).normalized().rot90());
                        for i in 1..n - 1 {
                            let n0 = (path_points[i] - path_points[i - 1]).normalized().rot90();
                            let n1 = (path_points[i + 1] - path_points[i]).normalized().rot90();
                            let v = (n0 + n1) / 2.0;
                            let normal = v / v.length_sq();
                            path_normals.push(normal); // TODO: handle VERY sharp turns better
                        }
                        path_normals.push(
                            (path_points[n - 1] - path_points[n - 2])
                                .normalized()
                                .rot90(),
                        );

                        self.paint_path(Open, &path_points, &path_normals, *color, *width);
                    }
                }
                PaintCmd::Rect {
                    corner_radius,
                    fill_color,
                    outline,
                    rect,
                } => {
                    path_points.clear();
                    path_normals.clear();

                    let min = rect.min();
                    let max = rect.max();

                    let cr = corner_radius
                        .min(rect.width() * 0.5)
                        .min(rect.height() * 0.5);

                    if cr <= 0.0 {
                        path_points.push(vec2(min.x, min.y));
                        path_normals.push(vec2(-1.0, -1.0));
                        path_points.push(vec2(max.x, min.y));
                        path_normals.push(vec2(1.0, -1.0));
                        path_points.push(vec2(max.x, max.y));
                        path_normals.push(vec2(1.0, 1.0));
                        path_points.push(vec2(min.x, max.y));
                        path_normals.push(vec2(-1.0, 1.0));
                    } else {
                        let n = 8;

                        let mut add_arc = |c, quadrant| {
                            let quadrant = quadrant as f32;

                            const RIGHT_ANGLE: f32 = TAU / 4.0;
                            for i in 0..=n {
                                let angle = remap(
                                    i as f32,
                                    0.0,
                                    n as f32,
                                    quadrant * RIGHT_ANGLE,
                                    (quadrant + 1.0) * RIGHT_ANGLE,
                                );
                                let normal = vec2(angle.cos(), angle.sin());
                                path_points.push(c + cr * normal);
                                path_normals.push(normal);
                            }
                        };

                        add_arc(vec2(max.x - cr, max.y - cr), 0);
                        add_arc(vec2(min.x + cr, max.y - cr), 1);
                        add_arc(vec2(min.x + cr, min.y + cr), 2);
                        add_arc(vec2(max.x - cr, min.y + cr), 3);
                    }

                    if let Some(color) = fill_color {
                        self.fill_closed_path(&path_points, &path_normals, *color);
                    }
                    if let Some(outline) = outline {
                        self.paint_path(
                            Closed,
                            &path_points,
                            &path_normals,
                            outline.color,
                            outline.width,
                        );
                    }
                }
                PaintCmd::Text {
                    color,
                    pos,
                    text,
                    text_style,
                    x_offsets,
                } => {
                    let font = &fonts[*text_style];
                    for (c, x_offset) in text.chars().zip(x_offsets.iter()) {
                        if let Some(glyph) = font.uv_rect(c) {
                            let mut top_left = Vertex {
                                pos: *pos + glyph.offset + vec2(*x_offset, 0.0),
                                uv: glyph.min,
                                color: *color,
                            };
                            top_left.pos.x = font.round_to_pixel(top_left.pos.x); // Pixel-perfection.
                            top_left.pos.y = font.round_to_pixel(top_left.pos.y); // Pixel-perfection.
                            let bottom_right = Vertex {
                                pos: top_left.pos + glyph.size,
                                uv: glyph.max,
                                color: *color,
                            };
                            self.mesh.add_rect(top_left, bottom_right);
                        }
                    }
                }
            }
        }
    }
}