grafo 0.16.1

//! The `shape` module provides structures and methods for creating and managing graphical shapes
//! within the Grafo library. It supports both simple and complex shapes, including rectangles and
//! custom paths with stroke properties. Fill color is per-instance and set via the renderer.
//!
//! # Examples
//!
//! Creating and using different shapes:
//!
//! ```rust
//! use grafo::Stroke;
//! use grafo::{Shape, ShapeBuilder, BorderRadii};
//! use grafo::Color;
//!
//! // Create a simple rectangle
//! let rect = Shape::rect(
//!     [(0.0, 0.0), (100.0, 50.0)],
//!     Stroke::new(2.0, Color::BLACK), // Black stroke with width 2.0
//! );
//!
//! // Create a rounded rectangle
//! let rounded_rect = Shape::rounded_rect(
//!     [(0.0, 0.0), (100.0, 50.0)],
//!     BorderRadii::new(10.0),
//!     Stroke::new(1.5, Color::BLACK), // Black stroke with width 1.5
//! );
//!
//! // Build a custom shape using ShapeBuilder
//! let custom_shape = Shape::builder()
//!     .stroke(Stroke::new(3.0, Color::BLACK)) // Black stroke with width 3.0
//!     .begin((0.0, 0.0))
//!     .line_to((50.0, 10.0))
//!     .line_to((50.0, 50.0))
//!     .close()
//!     .build();
//! ```

use crate::cache::CachedTessellation;
use crate::gradient::types::Fill;
use crate::util::{GradientCache, PoolManager};
use crate::vertex::{CustomVertex, InstanceTransform};
use crate::{Color, Stroke};
use ahash::AHashMap;
use lyon::lyon_tessellation::{
    BuffersBuilder, FillOptions, FillTessellator, FillVertex, VertexBuffers,
};
use lyon::path::Winding;
use lyon::tessellation::FillVertexConstructor;
use smallvec::SmallVec;
use std::sync::Arc;

#[derive(Debug, Clone)]
pub struct CachedShapeHandle {
    pub(crate) tessellation: Arc<CachedTessellation>,
    /// Whether the original shape was an axis-aligned rectangle. Used to enable scissor-based
    /// clipping instead of stencil for rect parents.
    pub(crate) is_rect: bool,
    /// The local-space bounding rect when `is_rect` is true, for scissor computation.
    pub(crate) rect_bounds: Option<[(f32, f32); 2]>,
    pub(crate) geometry_id: Option<u64>,
}

impl CachedShapeHandle {
    /// Creates a new `CachedShapeHandle`.
    ///
    /// `geometry_id` is the tessellator cache key. Callers such as
    /// [`Renderer::load_shape`](crate::Renderer::load_shape) and
    /// [`Renderer::add_shape`](crate::Renderer::add_shape) must derive it from shape content, not
    /// draw-tree identity: two different shapes must not share the same `geometry_id` unless
    /// their tessellated geometry is identical.
    ///
    /// This value flows into the tessellation cache and later into
    /// `preparation::append_aggregated_geometry_for_shape`, so collisions are a correctness
    /// hazard rather than just a performance miss. A stable hash of the path or other
    /// content-derived shape data is a good way to satisfy this contract. Pass `None` when no
    /// reliable content-derived id is available.
    pub(crate) fn new(
        shape: &Shape,
        tessellator: &mut FillTessellator,
        pool: &mut PoolManager,
        geometry_id: Option<u64>,
    ) -> Self {
        let (is_rect, rect_bounds) = match shape {
            Shape::Rect(r) => (true, Some(r.rect)),
            _ => (false, None),
        };
        let tessellation = shape.tessellate(tessellator, pool, geometry_id);
        Self {
            tessellation,
            is_rect,
            rect_bounds,
            geometry_id,
        }
    }

    #[inline]
    pub(crate) fn vertex_buffers(&self) -> &Arc<VertexBuffers<CustomVertex, u16>> {
        &self.tessellation.vertex_buffers
    }

    #[inline]
    pub(crate) fn local_bounds(&self) -> [(f32, f32); 2] {
        self.tessellation.local_bounds
    }

    #[inline]
    pub(crate) fn texture_mapping_size(&self) -> [f32; 2] {
        self.tessellation.texture_mapping_size
    }
}

fn rect_size(rect_bounds: [(f32, f32); 2]) -> [f32; 2] {
    [
        (rect_bounds[1].0 - rect_bounds[0].0).abs().max(1e-6),
        (rect_bounds[1].1 - rect_bounds[0].1).abs().max(1e-6),
    ]
}

fn compute_vertex_bounds(vertices: &[CustomVertex]) -> [(f32, f32); 2] {
    if vertices.is_empty() {
        return [(0.0, 0.0), (1.0, 1.0)];
    }

    let mut min_x = f32::INFINITY;
    let mut min_y = f32::INFINITY;
    let mut max_x = f32::NEG_INFINITY;
    let mut max_y = f32::NEG_INFINITY;

    for vertex in vertices {
        let x = vertex.position[0];
        let y = vertex.position[1];
        if x < min_x {
            min_x = x;
        }
        if y < min_y {
            min_y = y;
        }
        if x > max_x {
            max_x = x;
        }
        if y > max_y {
            max_y = y;
        }
    }

    [(min_x, min_y), (max_x, max_y)]
}

/// Represents a graphical shape, which can be either a custom path or a simple rectangle.
///
/// # Variants
///
/// - `Path(PathShape)`: A custom path shape defined using Bézier curves and lines.
/// - `Rect(RectShape)`: A simple rectangular shape with optional rounded corners.
///
/// # Examples
///
/// ```rust
/// use grafo::Stroke;
/// use grafo::{Shape, BorderRadii};
/// use grafo::Color;
///
/// // Create a simple rectangle
/// let rect = Shape::rect(
///     [(0.0, 0.0), (100.0, 50.0)],
///     Stroke::new(2.0, Color::BLACK), // Black stroke with width 2.0
/// );
///
/// // Create a custom path shape
/// let custom_path = Shape::builder()
///     .stroke(Stroke::new(1.0, Color::BLACK))
///     .begin((0.0, 0.0))
///     .line_to((50.0, 10.0))
///     .line_to((50.0, 50.0))
///     .close()
///     .build();
/// ```
#[derive(Debug, Clone)]
pub enum Shape {
    /// A custom path shape defined using Bézier curves and lines.
    Path(PathShape),
    /// A simple rectangular shape.
    Rect(RectShape),
}

impl Shape {
    /// Creates a new [`ShapeBuilder`] for constructing complex shapes.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::Shape;
    ///
    /// let builder = Shape::builder();
    /// ```
    pub fn builder() -> ShapeBuilder {
        ShapeBuilder::new()
    }

    /// Creates a simple rectangle shape with the specified coordinates and stroke.
    ///
    /// # Parameters
    ///
    /// - `rect`: An array containing two tuples representing the top-left and bottom-right
    ///   coordinates of the rectangle.
    /// - `stroke`: The stroke properties of the rectangle.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::Color;
    /// use grafo::Stroke;
    /// use grafo::Shape;
    ///
    /// let rect = Shape::rect(
    ///     [(0.0, 0.0), (100.0, 50.0)],
    ///     Stroke::new(2.0, Color::BLACK), // Black stroke with width 2.0
    /// );
    /// ```
    pub fn rect(rect: [(f32, f32); 2], stroke: Stroke) -> Shape {
        let rect_shape = RectShape::new(rect, stroke);
        Shape::Rect(rect_shape)
    }

    /// Creates a rectangle shape with rounded corners.
    ///
    /// # Parameters
    ///
    /// - `rect`: An array containing two tuples representing the top-left and bottom-right
    ///   coordinates of the rectangle.
    /// - `border_radii`: The radii for each corner of the rectangle.
    /// - `stroke`: The stroke properties of the rectangle.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::Color;
    /// use grafo::Stroke;
    /// use grafo::{Shape, BorderRadii};
    ///
    /// let rounded_rect = Shape::rounded_rect(
    ///     [(0.0, 0.0), (100.0, 50.0)],
    ///     BorderRadii::new(10.0),
    ///     Stroke::new(1.5, Color::BLACK), // Black stroke with width 1.5
    /// );
    /// ```
    pub fn rounded_rect(rect: [(f32, f32); 2], border_radii: BorderRadii, stroke: Stroke) -> Shape {
        let mut path_builder = lyon::path::Path::builder();
        let box2d = lyon::math::Box2D::new(rect[0].into(), rect[1].into());

        path_builder.add_rounded_rectangle(&box2d, &border_radii.into(), Winding::Positive);
        let path = path_builder.build();

        let path_shape = PathShape { path, stroke };
        Shape::Path(path_shape)
    }

    pub(crate) fn tessellate(
        &self,
        tessellator: &mut FillTessellator,
        buffers_pool: &mut PoolManager,
        tesselation_cache_key: Option<u64>,
    ) -> Arc<CachedTessellation> {
        match &self {
            Shape::Path(path_shape) => {
                path_shape.tessellate(tessellator, buffers_pool, tesselation_cache_key)
            }
            Shape::Rect(rect_shape) => {
                if let Some(cache_key) = tesselation_cache_key {
                    if let Some(cached_tessellation) = buffers_pool
                        .tessellation_cache
                        .get_vertex_buffers(&cache_key)
                    {
                        return cached_tessellation;
                    }
                }

                let min_width = rect_shape.rect[0].0;
                let min_height = rect_shape.rect[0].1;
                let max_width = rect_shape.rect[1].0;
                let max_height = rect_shape.rect[1].1;

                // Compute UVs mapping the rectangle to [0,1] in local space
                let w = (max_width - min_width).max(1e-6);
                let h = (max_height - min_height).max(1e-6);
                let uv =
                    |x: f32, y: f32| -> [f32; 2] { [(x - min_width) / w, (y - min_height) / h] };

                let quad = [
                    CustomVertex {
                        position: [min_width, min_height],
                        tex_coords: uv(min_width, min_height),
                        normal: [0.0, 0.0],
                        coverage: 1.0,
                    },
                    CustomVertex {
                        position: [max_width, min_height],
                        tex_coords: uv(max_width, min_height),
                        normal: [0.0, 0.0],
                        coverage: 1.0,
                    },
                    CustomVertex {
                        position: [max_width, max_height],
                        tex_coords: uv(max_width, max_height),
                        normal: [0.0, 0.0],
                        coverage: 1.0,
                    },
                    CustomVertex {
                        position: [min_width, max_height],
                        tex_coords: uv(min_width, max_height),
                        normal: [0.0, 0.0],
                        coverage: 1.0,
                    },
                ];
                let indices = [0u16, 1, 2, 0, 2, 3];
                let local_bounds = rect_shape.rect;

                let mut vertex_buffers = buffers_pool.lyon_vertex_buffers_pool.get_vertex_buffers();

                vertex_buffers.vertices.extend(quad);
                vertex_buffers.indices.extend(indices);

                // Generate AA fringe geometry for the rect
                generate_aa_fringe(
                    &mut vertex_buffers.vertices,
                    &mut vertex_buffers.indices,
                    &mut buffers_pool.aa_fringe_scratch,
                );

                let tessellation = Arc::new(CachedTessellation {
                    vertex_buffers: Arc::new(vertex_buffers),
                    local_bounds,
                    texture_mapping_size: rect_size(local_bounds),
                });

                if let Some(tesselation_cache_key) = tesselation_cache_key {
                    buffers_pool
                        .tessellation_cache
                        .insert_vertex_buffers(tesselation_cache_key, Arc::clone(&tessellation));
                }

                tessellation
            }
        }
    }
}

impl From<PathShape> for Shape {
    fn from(value: PathShape) -> Self {
        Shape::Path(value)
    }
}

impl From<RectShape> for Shape {
    fn from(value: RectShape) -> Self {
        Shape::Rect(value)
    }
}

impl AsRef<Shape> for Shape {
    fn as_ref(&self) -> &Shape {
        self
    }
}

/// Represents a simple rectangular shape with a fill color and stroke.
///
/// You typically do not need to use `RectShape` directly; instead, use the [`Shape::rect`] method.
///
/// # Fields
///
/// - `rect`: An array containing two tuples representing the top-left and bottom-right
///   coordinates of the rectangle.
/// - `stroke`: The stroke properties of the rectangle.
///
/// # Examples
///
/// ```rust
/// use grafo::RectShape;
/// use grafo::Stroke;
/// use grafo::Color;
///
/// let rect_shape = RectShape::new(
///     [(0.0, 0.0), (100.0, 50.0)],
///     Stroke::new(2.0, Color::BLACK), // Black stroke with width 2.0
/// );
/// ```
#[derive(Debug, Clone)]
pub struct RectShape {
    /// An array containing two tuples representing the top-left and bottom-right coordinates
    /// of the rectangle.
    pub(crate) rect: [(f32, f32); 2],
    /// The stroke properties of the rectangle.
    #[allow(unused)]
    pub(crate) stroke: Stroke,
}

impl RectShape {
    /// Creates a new `RectShape` with the specified coordinates and stroke.
    ///
    /// # Parameters
    ///
    /// - `rect`: An array containing two tuples representing the top-left and bottom-right
    ///   coordinates of the rectangle.
    /// - `stroke`: The stroke properties of the rectangle.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::RectShape;
    /// use grafo::Stroke;
    /// use grafo::Color;
    ///
    /// let rect_shape = RectShape::new(
    ///     [(0.0, 0.0), (100.0, 50.0)],
    ///     Stroke::new(2.0, Color::BLACK), // Black stroke with width 2.0
    /// );
    /// ```
    pub fn new(rect: [(f32, f32); 2], stroke: Stroke) -> Self {
        Self { rect, stroke }
    }
}

/// Represents a custom path shape with stroke.
///
/// You typically do not need to use `PathShape` directly; instead, use the [`Shape::builder`]
/// method to construct complex shapes.
///
/// # Fields
///
/// - `path`: The geometric path defining the shape.
/// - `stroke`: The stroke properties of the shape.
///
/// # Examples
///
/// ```rust
/// use grafo::{Shape, PathShape};
/// use grafo::Stroke;
/// use grafo::Color;
///
/// // Replace this with your own path
/// let path = lyon::path::Path::builder().build();
///
/// let path_shape = PathShape::new(
///     path,
///     Stroke::new(1.0, Color::BLACK), // Black stroke with width 1.0
/// );
///
/// let shape = Shape::Path(path_shape);
/// ```
#[derive(Clone, Debug)]
pub struct PathShape {
    /// The geometric path defining the shape.
    pub(crate) path: lyon::path::Path,
    /// The stroke properties of the shape.
    #[allow(unused)]
    pub(crate) stroke: Stroke,
}

struct VertexConverter {}

impl VertexConverter {
    fn new() -> Self {
        Self {}
    }
}

impl FillVertexConstructor<CustomVertex> for VertexConverter {
    fn new_vertex(&mut self, vertex: FillVertex) -> CustomVertex {
        CustomVertex {
            position: vertex.position().to_array(),
            tex_coords: [0.0, 0.0],
            normal: [0.0, 0.0],
            coverage: 1.0,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
struct BoundaryVertexKey {
    x_bits: u32,
    y_bits: u32,
}

impl BoundaryVertexKey {
    fn from_position(position: [f32; 2]) -> Self {
        Self {
            x_bits: normalized_float_bits(position[0]),
            y_bits: normalized_float_bits(position[1]),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
struct BoundaryEdgeKey {
    start: BoundaryVertexKey,
    end: BoundaryVertexKey,
}

impl BoundaryEdgeKey {
    fn new(start_position: [f32; 2], end_position: [f32; 2]) -> Self {
        let start = BoundaryVertexKey::from_position(start_position);
        let end = BoundaryVertexKey::from_position(end_position);
        if start <= end {
            Self { start, end }
        } else {
            Self {
                start: end,
                end: start,
            }
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq)]
struct BoundaryEdge {
    start_vertex_index: u16,
    end_vertex_index: u16,
    opposite_vertex_index: u16,
    triangle_index: usize,
}

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
struct BoundaryCornerKey {
    vertex_key: BoundaryVertexKey,
    component_index: usize,
}

#[derive(Clone, Copy, Debug, PartialEq)]
struct BoundaryCornerNormalData {
    accumulated_normal: [f32; 2],
    source_vertex_index: u16,
}

pub(crate) struct AaFringeScratch {
    edge_use_counts: AHashMap<BoundaryEdgeKey, (usize, BoundaryEdge)>,
    edge_owners: AHashMap<BoundaryEdgeKey, SmallVec<[usize; 2]>>,
    incident_triangles_by_vertex: AHashMap<BoundaryVertexKey, SmallVec<[usize; 4]>>,
    triangle_adjacency: AHashMap<(BoundaryVertexKey, usize), SmallVec<[usize; 4]>>,
    visited_triangles: AHashMap<usize, usize>,
    triangle_component_map: AHashMap<(usize, BoundaryVertexKey), usize>,
    boundary_corner_normals: AHashMap<BoundaryCornerKey, BoundaryCornerNormalData>,
    outer_vertex_indices: AHashMap<BoundaryCornerKey, u16>,
    boundary_edges: Vec<BoundaryEdge>,
    triangle_stack: Vec<usize>,
}

impl AaFringeScratch {
    pub(crate) fn new() -> Self {
        Self {
            edge_use_counts: AHashMap::new(),
            edge_owners: AHashMap::new(),
            incident_triangles_by_vertex: AHashMap::new(),
            triangle_adjacency: AHashMap::new(),
            visited_triangles: AHashMap::new(),
            triangle_component_map: AHashMap::new(),
            boundary_corner_normals: AHashMap::new(),
            outer_vertex_indices: AHashMap::new(),
            boundary_edges: Vec::new(),
            triangle_stack: Vec::new(),
        }
    }

    fn clear(&mut self) {
        self.edge_use_counts.clear();
        self.edge_owners.clear();
        self.incident_triangles_by_vertex.clear();
        self.triangle_adjacency.clear();
        self.visited_triangles.clear();
        self.triangle_component_map.clear();
        self.boundary_corner_normals.clear();
        self.outer_vertex_indices.clear();
        self.boundary_edges.clear();
        self.triangle_stack.clear();
    }

    pub(crate) fn trim(&mut self) {
        self.edge_use_counts.shrink_to_fit();
        self.edge_owners.shrink_to_fit();
        self.incident_triangles_by_vertex.shrink_to_fit();
        self.triangle_adjacency.shrink_to_fit();
        self.visited_triangles.shrink_to_fit();
        self.triangle_component_map.shrink_to_fit();
        self.boundary_corner_normals.shrink_to_fit();
        self.outer_vertex_indices.shrink_to_fit();
        self.boundary_edges.shrink_to_fit();
        self.triangle_stack.shrink_to_fit();
    }
}

fn normalized_float_bits(value: f32) -> u32 {
    if value == 0.0 {
        0.0f32.to_bits()
    } else {
        value.to_bits()
    }
}

// ---------------------------------------------------------------------------
// Anti-Aliasing: Inflated-Geometry Fringe Generation
// ---------------------------------------------------------------------------

/// Identifies boundary edges (edges belonging to only one triangle) from a triangle index buffer.
///
/// Returns a list of `(vertex_a, vertex_b, opposite_vertex)` tuples. The `opposite_vertex` is
/// the third vertex of the triangle that owns the edge — it is used to determine which side
/// of the edge faces outward (away from the triangle interior).
fn build_boundary_data(vertices: &[CustomVertex], indices: &[u16], scratch: &mut AaFringeScratch) {
    scratch.clear();

    for (triangle_index, tri) in indices.chunks_exact(3).enumerate() {
        let a = tri[0];
        let b = tri[1];
        let c = tri[2];
        let vertex_keys = [a, b, c].map(|vertex_index| {
            BoundaryVertexKey::from_position(vertices[vertex_index as usize].position)
        });

        for &vertex_key in &vertex_keys {
            scratch
                .incident_triangles_by_vertex
                .entry(vertex_key)
                .or_default()
                .push(triangle_index);
        }

        for &(i, j, opp) in &[(a, b, c), (b, c, a), (c, a, b)] {
            let key =
                BoundaryEdgeKey::new(vertices[i as usize].position, vertices[j as usize].position);
            scratch
                .edge_use_counts
                .entry(key)
                .and_modify(|(count, _)| *count += 1)
                .or_insert((
                    1,
                    BoundaryEdge {
                        start_vertex_index: i,
                        end_vertex_index: j,
                        opposite_vertex_index: opp,
                        triangle_index,
                    },
                ));
            scratch
                .edge_owners
                .entry(key)
                .or_default()
                .push(triangle_index);
        }
    }

    scratch.boundary_edges.extend(
        scratch
            .edge_use_counts
            .values()
            .filter_map(|(count, boundary_edge)| (*count == 1).then_some(*boundary_edge)),
    );
}

fn build_triangle_component_map(scratch: &mut AaFringeScratch) {
    for (edge_key, owners) in &scratch.edge_owners {
        if owners.len() < 2 {
            continue;
        }

        for &vertex_key in &[edge_key.start, edge_key.end] {
            for (owner_index, &owner_triangle_index) in owners.iter().enumerate() {
                for &other_triangle_index in &owners[owner_index + 1..] {
                    scratch
                        .triangle_adjacency
                        .entry((vertex_key, owner_triangle_index))
                        .or_default()
                        .push(other_triangle_index);
                    scratch
                        .triangle_adjacency
                        .entry((vertex_key, other_triangle_index))
                        .or_default()
                        .push(owner_triangle_index);
                }
            }
        }
    }

    for (&vertex_key, incident_triangles) in &scratch.incident_triangles_by_vertex {
        scratch.visited_triangles.clear();
        let mut component_index = 0usize;

        for &triangle_index in incident_triangles {
            if scratch.visited_triangles.contains_key(&triangle_index) {
                continue;
            }

            scratch.triangle_stack.push(triangle_index);
            while let Some(current_triangle_index) = scratch.triangle_stack.pop() {
                if scratch
                    .visited_triangles
                    .insert(current_triangle_index, component_index)
                    .is_some()
                {
                    continue;
                }

                if let Some(neighbors) = scratch
                    .triangle_adjacency
                    .get(&(vertex_key, current_triangle_index))
                {
                    for &neighbor_triangle_index in neighbors {
                        if !scratch
                            .visited_triangles
                            .contains_key(&neighbor_triangle_index)
                        {
                            scratch.triangle_stack.push(neighbor_triangle_index);
                        }
                    }
                }
            }

            component_index += 1;
        }

        for (&triangle_index, &component_index) in &scratch.visited_triangles {
            scratch
                .triangle_component_map
                .insert((triangle_index, vertex_key), component_index);
        }
    }
}

/// Generates a thin fringe of antialiasing triangles around shape boundaries.
///
/// For each boundary edge, two triangles are added, forming a quad that fades from
/// `coverage = 1.0` (at the original boundary) to `coverage = 0.0` (at the outer fringe).
/// The actual screen-space offset is computed in the vertex shader, so the fringe positions
/// in the buffer are identical to the source boundary vertices — only the `normal` and
/// `coverage` fields differ.
#[cfg(test)]
fn find_boundary_edges<'a>(
    vertices: &[CustomVertex],
    indices: &[u16],
    scratch: &'a mut AaFringeScratch,
) -> &'a [BoundaryEdge] {
    build_boundary_data(vertices, indices, scratch);
    &scratch.boundary_edges
}

fn generate_aa_fringe(
    vertices: &mut Vec<CustomVertex>,
    indices: &mut Vec<u16>,
    scratch: &mut AaFringeScratch,
) {
    build_boundary_data(vertices, indices, scratch);

    if scratch.boundary_edges.is_empty() {
        return;
    }

    build_triangle_component_map(scratch);

    // --- Step 1: Compute per-boundary-vertex averaged outward (miter) normals ---

    for boundary_edge in &scratch.boundary_edges {
        let pa = vertices[boundary_edge.start_vertex_index as usize].position;
        let pb = vertices[boundary_edge.end_vertex_index as usize].position;
        let po = vertices[boundary_edge.opposite_vertex_index as usize].position;

        let dx = pb[0] - pa[0];
        let dy = pb[1] - pa[1];
        let edge_len = (dx * dx + dy * dy).sqrt();
        if edge_len < 1e-10 {
            continue;
        }

        let n1 = [-dy / edge_len, dx / edge_len];
        let n2 = [dy / edge_len, -dx / edge_len];

        let to_opp = [po[0] - pa[0], po[1] - pa[1]];
        let dot1 = n1[0] * to_opp[0] + n1[1] * to_opp[1];
        let outward = if dot1 < 0.0 { n1 } else { n2 };

        for &vertex_index in &[
            boundary_edge.start_vertex_index,
            boundary_edge.end_vertex_index,
        ] {
            let vertex_key =
                BoundaryVertexKey::from_position(vertices[vertex_index as usize].position);
            let component_index = *scratch
                .triangle_component_map
                .get(&(boundary_edge.triangle_index, vertex_key))
                .unwrap_or_else(|| {
                    panic!(
                    "missing triangle component mapping for triangle {} and boundary vertex {:?}",
                    boundary_edge.triangle_index,
                    vertex_key
                )
                });
            let entry = scratch
                .boundary_corner_normals
                .entry(BoundaryCornerKey {
                    vertex_key,
                    component_index,
                })
                .or_insert(BoundaryCornerNormalData {
                    accumulated_normal: [0.0, 0.0],
                    source_vertex_index: vertex_index,
                });
            entry.accumulated_normal[0] += outward[0];
            entry.accumulated_normal[1] += outward[1];
        }
    }

    for boundary_corner_normal in scratch.boundary_corner_normals.values_mut() {
        let len = (boundary_corner_normal.accumulated_normal[0]
            * boundary_corner_normal.accumulated_normal[0]
            + boundary_corner_normal.accumulated_normal[1]
                * boundary_corner_normal.accumulated_normal[1])
            .sqrt();
        if len > 1e-10 {
            boundary_corner_normal.accumulated_normal[0] /= len;
            boundary_corner_normal.accumulated_normal[1] /= len;
        }
    }

    // --- Step 2: Create outer fringe (duplicate) vertices ---

    vertices.reserve(scratch.boundary_corner_normals.len());
    indices.reserve(scratch.boundary_edges.len() * 6);

    for (&boundary_corner_key, boundary_corner_normal) in &scratch.boundary_corner_normals {
        let source_vertex = &vertices[boundary_corner_normal.source_vertex_index as usize];
        let outer_vertex = CustomVertex {
            position: source_vertex.position,
            tex_coords: source_vertex.tex_coords,
            normal: boundary_corner_normal.accumulated_normal,
            coverage: 0.0,
        };
        let new_idx = vertices.len() as u16;
        vertices.push(outer_vertex);
        scratch
            .outer_vertex_indices
            .insert(boundary_corner_key, new_idx);
    }

    // --- Step 3: Emit fringe quads (two triangles per boundary edge) ---

    for boundary_edge in &scratch.boundary_edges {
        let start_vertex_key = BoundaryVertexKey::from_position(
            vertices[boundary_edge.start_vertex_index as usize].position,
        );
        let end_vertex_key = BoundaryVertexKey::from_position(
            vertices[boundary_edge.end_vertex_index as usize].position,
        );
        let pa = vertices[boundary_edge.start_vertex_index as usize].position;
        let pb = vertices[boundary_edge.end_vertex_index as usize].position;
        let po = vertices[boundary_edge.opposite_vertex_index as usize].position;

        let dx = pb[0] - pa[0];
        let dy = pb[1] - pa[1];
        let edge_len = (dx * dx + dy * dy).sqrt();
        if edge_len < 1e-10 {
            continue;
        }

        let start_component_index = *scratch
            .triangle_component_map
            .get(&(boundary_edge.triangle_index, start_vertex_key))
            .unwrap_or_else(|| {
                panic!(
                    "missing triangle component mapping for triangle {} and boundary vertex {:?}",
                    boundary_edge.triangle_index, start_vertex_key
                )
            });
        let end_component_index = *scratch
            .triangle_component_map
            .get(&(boundary_edge.triangle_index, end_vertex_key))
            .unwrap_or_else(|| {
                panic!(
                    "missing triangle component mapping for triangle {} and boundary vertex {:?}",
                    boundary_edge.triangle_index, end_vertex_key
                )
            });

        let start_boundary_corner_key = BoundaryCornerKey {
            vertex_key: start_vertex_key,
            component_index: start_component_index,
        };
        let start_outer_vertex_index = match scratch
            .outer_vertex_indices
            .get(&start_boundary_corner_key)
        {
            Some(&idx) => idx,
            None => {
                debug_assert!(
                    false,
                    "missing outer vertex index for {:?} (start_vertex_key: {:?}, start_component_index: {})",
                    start_boundary_corner_key,
                    start_vertex_key,
                    start_component_index
                );
                continue;
            }
        };
        let end_boundary_corner_key = BoundaryCornerKey {
            vertex_key: end_vertex_key,
            component_index: end_component_index,
        };
        let end_outer_vertex_index = match scratch
            .outer_vertex_indices
            .get(&end_boundary_corner_key)
        {
            Some(&idx) => idx,
            None => {
                debug_assert!(
                    false,
                    "missing outer vertex index for {:?} (end_vertex_key: {:?}, end_component_index: {})",
                    end_boundary_corner_key,
                    end_vertex_key,
                    end_component_index
                );
                continue;
            }
        };

        let cross = (pb[0] - pa[0]) * (po[1] - pa[1]) - (pb[1] - pa[1]) * (po[0] - pa[0]);

        if cross >= 0.0 {
            indices.push(boundary_edge.start_vertex_index);
            indices.push(boundary_edge.end_vertex_index);
            indices.push(start_outer_vertex_index);

            indices.push(boundary_edge.end_vertex_index);
            indices.push(end_outer_vertex_index);
            indices.push(start_outer_vertex_index);
        } else {
            indices.push(boundary_edge.start_vertex_index);
            indices.push(start_outer_vertex_index);
            indices.push(boundary_edge.end_vertex_index);

            indices.push(boundary_edge.end_vertex_index);
            indices.push(start_outer_vertex_index);
            indices.push(end_outer_vertex_index);
        }
    }
}

impl PathShape {
    /// Creates a new `PathShape` with the specified path and stroke.
    ///
    /// # Parameters
    ///
    /// - `path`: The geometric path defining the shape.
    /// - `stroke`: The stroke properties of the shape.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::PathShape;
    /// use grafo::Stroke;
    /// use lyon::path::Path;
    ///
    /// let path = Path::builder().build();
    /// let path_shape = PathShape::new(path, Stroke::default());
    /// ```
    pub fn new(path: lyon::path::Path, stroke: Stroke) -> Self {
        Self { path, stroke }
    }

    /// Tessellates the path shape into vertex and index buffers for rendering.
    ///
    /// # Parameters
    ///
    /// - `depth`: The depth value used for rendering order.
    ///
    /// # Returns
    ///
    /// A `VertexBuffers` structure containing the tessellated vertices and indices.
    /// ```
    pub(crate) fn tessellate(
        &self,
        tessellator: &mut FillTessellator,
        buffers_pool: &mut PoolManager,
        tesselation_cache_key: Option<u64>,
    ) -> Arc<CachedTessellation> {
        if let Some(cache_key) = tesselation_cache_key {
            if let Some(cached_tessellation) = buffers_pool
                .tessellation_cache
                .get_vertex_buffers(&cache_key)
            {
                return cached_tessellation;
            }
        }

        let mut buffers: VertexBuffers<CustomVertex, u16> =
            buffers_pool.lyon_vertex_buffers_pool.get_vertex_buffers();
        let local_bounds = self.tessellate_into_buffers(
            &mut buffers,
            tessellator,
            &mut buffers_pool.aa_fringe_scratch,
        );

        #[allow(clippy::manual_is_multiple_of)]
        let needs_index_padding = buffers.indices.len() % 2 != 0;
        if needs_index_padding {
            buffers.indices.push(0);
        }

        let tessellation = Arc::new(CachedTessellation {
            vertex_buffers: Arc::new(buffers),
            local_bounds,
            texture_mapping_size: rect_size(local_bounds),
        });

        if let Some(cache_key) = tesselation_cache_key {
            buffers_pool
                .tessellation_cache
                .insert_vertex_buffers(cache_key, Arc::clone(&tessellation));
        }

        tessellation
    }

    fn tessellate_into_buffers(
        &self,
        buffers: &mut VertexBuffers<CustomVertex, u16>,
        tessellator: &mut FillTessellator,
        aa_fringe_scratch: &mut AaFringeScratch,
    ) -> [(f32, f32); 2] {
        let options = FillOptions::default();

        let vertex_converter = VertexConverter::new();

        tessellator
            .tessellate_path(
                &self.path,
                &options,
                &mut BuffersBuilder::new(buffers, vertex_converter),
            )
            .unwrap();

        let local_bounds = compute_vertex_bounds(&buffers.vertices);

        // Generate UVs for the tessellated path using its axis-aligned bounding box in local space
        if !buffers.vertices.is_empty() {
            let w = (local_bounds[1].0 - local_bounds[0].0).max(1e-6);
            let h = (local_bounds[1].1 - local_bounds[0].1).max(1e-6);
            for v in buffers.vertices.iter_mut() {
                let u = (v.position[0] - local_bounds[0].0) / w;
                let vcoord = (v.position[1] - local_bounds[0].1) / h;
                v.tex_coords = [u, vcoord];
            }
        }

        // Generate AA fringe geometry after UVs are computed so fringe vertices
        // inherit the correct tex_coords from their source boundary vertices.
        generate_aa_fringe(
            &mut buffers.vertices,
            &mut buffers.indices,
            aa_fringe_scratch,
        );

        local_bounds
    }
}

/// Controls how bound textures are fit into a shape's local texture-coordinate space.
#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash)]
pub enum ShapeTextureFitMode {
    /// Normalize the shape bounds to `[0, 1]` and stretch the texture to cover them fully.
    #[default]
    Stretch,
    /// Treat one texture texel as one physical pixel before the shape transform is applied.
    /// Translation does not affect the mapping, while scale, rotation, and perspective affect
    /// the texture together with the shape. Outside the original texture footprint, sampling does
    /// not crop to transparency; the unclipped area instead shows the underlying fill/background
    /// according to normal compositing.
    OriginalSize,
}

#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash)]
pub struct ShapeTextureOptions {
    pub texture_id: Option<u64>,
    pub fit_mode: ShapeTextureFitMode,
}

impl ShapeTextureOptions {
    pub fn new(texture_id: u64) -> Self {
        Self {
            texture_id: Some(texture_id),
            fit_mode: ShapeTextureFitMode::Stretch,
        }
    }

    pub fn fit_mode(mut self, fit_mode: ShapeTextureFitMode) -> Self {
        self.fit_mode = fit_mode;
        self
    }
}

#[derive(Clone, Debug)]
pub struct ShapeDrawCommandOptions {
    pub transform: Option<InstanceTransform>,
    pub clips_children: bool,
    pub background_texture: ShapeTextureOptions,
    pub foreground_texture: ShapeTextureOptions,
    pub fill: Option<Fill>,
}

impl Default for ShapeDrawCommandOptions {
    fn default() -> Self {
        Self {
            transform: None,
            clips_children: true,
            background_texture: ShapeTextureOptions::default(),
            foreground_texture: ShapeTextureOptions::default(),
            fill: None,
        }
    }
}

impl ShapeDrawCommandOptions {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn transform(mut self, transform: InstanceTransform) -> Self {
        self.transform = Some(transform);
        self
    }

    pub fn clips_children(mut self, clips_children: bool) -> Self {
        self.clips_children = clips_children;
        self
    }

    pub fn background_texture(mut self, background_texture: ShapeTextureOptions) -> Self {
        self.background_texture = background_texture;
        self
    }

    pub fn foreground_texture(mut self, foreground_texture: ShapeTextureOptions) -> Self {
        self.foreground_texture = foreground_texture;
        self
    }

    pub fn background_texture_id(mut self, background_texture_id: u64) -> Self {
        self.background_texture.texture_id = Some(background_texture_id);
        self
    }

    pub fn foreground_texture_id(mut self, foreground_texture_id: u64) -> Self {
        self.foreground_texture.texture_id = Some(foreground_texture_id);
        self
    }

    pub fn texture_fit_mode(mut self, texture_fit_mode: ShapeTextureFitMode) -> Self {
        self.background_texture.fit_mode = texture_fit_mode;
        self.foreground_texture.fit_mode = texture_fit_mode;
        self
    }

    pub fn background_texture_fit_mode(
        mut self,
        background_texture_fit_mode: ShapeTextureFitMode,
    ) -> Self {
        self.background_texture.fit_mode = background_texture_fit_mode;
        self
    }

    pub fn foreground_texture_fit_mode(
        mut self,
        foreground_texture_fit_mode: ShapeTextureFitMode,
    ) -> Self {
        self.foreground_texture.fit_mode = foreground_texture_fit_mode;
        self
    }

    pub fn fill(mut self, fill: Fill) -> Self {
        self.fill = Some(fill);
        self
    }

    pub fn color(mut self, color: Color) -> Self {
        self.fill = Some(Fill::Solid(color));
        self
    }
}

#[derive(Debug)]
pub(crate) struct CachedShapeDrawData {
    pub(crate) cached_shape: CachedShapeHandle,
    pub(crate) index_buffer_range: Option<(usize, usize)>,
    pub(crate) is_empty: bool,
    /// Stencil reference assigned during render traversal (parent + 1). Cleared after frame.
    pub(crate) stencil_ref: Option<u32>,
    /// Index into the per-frame instance transform buffer
    pub(crate) instance_index: Option<usize>,
    /// Optional per-shape transform applied in clip-space (post-normalization)
    pub(crate) transform: Option<InstanceTransform>,
    /// Optional texture ids associated with this cached shape
    pub(crate) texture_ids: [Option<u64>; 2],
    /// Optional per-instance color override (normalized [0,1]). If None, use cached shape default.
    pub(crate) color_override: Option<[f32; 4]>,
    /// The fill for this shape (solid color or gradient). If None, transparent.
    pub(crate) fill: Option<Fill>,
    /// Cached gradient bind group, refreshed when the fill or gradient layout changes.
    pub(crate) gradient_bind_group: Option<Arc<wgpu::BindGroup>>,
    /// Persistent uniform buffer for backdrop material parameters.
    pub(crate) backdrop_material_params_buffer: Option<wgpu::Buffer>,
    /// Cached gradient+backdrop bind group reused while the captured output texture is stable.
    pub(crate) backdrop_gradient_bind_group: Option<wgpu::BindGroup>,
    /// Stable id of the pooled texture referenced by `backdrop_gradient_bind_group`.
    pub(crate) backdrop_gradient_texture_id: Option<u64>,
    /// Whether this node is a leaf in the draw tree (no children).
    pub(crate) is_leaf: bool,
    /// When `false`, skip stencil increment/decrement for this parent
    /// (children render without being clipped to this shape).
    pub(crate) clips_children: bool,
}

impl CachedShapeDrawData {
    pub fn new(cached_shape: CachedShapeHandle, options: &ShapeDrawCommandOptions) -> Self {
        Self {
            cached_shape,
            // Will be set during add_command
            index_buffer_range: None,
            is_empty: false,
            // Data from options
            transform: options.transform,
            texture_ids: [
                options.background_texture.texture_id,
                options.foreground_texture.texture_id,
            ],
            clips_children: options.clips_children,
            color_override: match options.fill.as_ref() {
                Some(Fill::Solid(color)) => Some(color.normalize()),
                _ => None,
            },
            fill: options.fill.clone(),
            // Set later after buffer update
            instance_index: None,
            // Set during render traversal
            stencil_ref: None,
            gradient_bind_group: None,
            backdrop_material_params_buffer: None,
            backdrop_gradient_bind_group: None,
            backdrop_gradient_texture_id: None,
            is_leaf: true,
        }
    }

    pub fn refresh_gradient_bind_group(
        &mut self,
        gradient_cache: &mut GradientCache,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        layout: &wgpu::BindGroupLayout,
        sampler: &wgpu::Sampler,
        layout_epoch: u64,
    ) {
        self.gradient_bind_group = match self.fill.as_mut() {
            Some(Fill::Gradient(gradient)) => Some(gradient_cache.get_or_create_bind_group(
                &mut gradient.data,
                device,
                queue,
                layout,
                sampler,
                layout_epoch,
            )),
            _ => None,
        };
    }

    pub fn prepare_gradient_backdrop_material_params_buffer(
        &mut self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        backdrop_sampling_uniform: crate::pipeline::BackdropSamplingUniform,
    ) -> Option<wgpu::Buffer> {
        let params = {
            let gradient = match self.fill.as_ref() {
                Some(Fill::Gradient(gradient)) => gradient,
                _ => return None,
            };

            crate::gradient::gpu::GpuMaterialParams::from_gradient_data(&gradient.data)
                .with_backdrop_sampling(backdrop_sampling_uniform)
        };

        if let Some(existing_buffer) = self.backdrop_material_params_buffer.as_ref() {
            queue.write_buffer(existing_buffer, 0, bytemuck::bytes_of(&params));
        } else {
            self.backdrop_material_params_buffer = Some(crate::pipeline::create_buffer_init(
                device,
                Some("gradient_backdrop_material_params_buffer"),
                bytemuck::bytes_of(&params),
                wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
            ));
        }

        self.backdrop_material_params_buffer.clone()
    }

    #[allow(clippy::too_many_arguments)]
    pub fn prepare_backdrop_gradient_bind_group(
        &mut self,
        gradient_cache: &mut GradientCache,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        layout: &wgpu::BindGroupLayout,
        material_params_buffer: &wgpu::Buffer,
        gradient_sampler: &wgpu::Sampler,
        backdrop_texture_id: u64,
        backdrop_view: &wgpu::TextureView,
        backdrop_sampler: &wgpu::Sampler,
    ) -> Option<&wgpu::BindGroup> {
        if self.backdrop_gradient_texture_id != Some(backdrop_texture_id) {
            let gradient = match self.fill.as_mut() {
                Some(Fill::Gradient(gradient)) => gradient,
                _ => return None,
            };

            self.backdrop_gradient_bind_group =
                Some(gradient_cache.create_backdrop_gradient_bind_group(
                    &mut gradient.data,
                    device,
                    queue,
                    layout,
                    material_params_buffer,
                    gradient_sampler,
                    backdrop_view,
                    backdrop_sampler,
                ));
            self.backdrop_gradient_texture_id = Some(backdrop_texture_id);
        }

        self.backdrop_gradient_bind_group.as_ref()
    }
}

/// A builder for creating complex shapes using a fluent interface.
///
/// The `ShapeBuilder` allows you to define the stroke and path of a shape using
/// method chaining. Fill is assigned per instance through the renderer, and an
/// unset fill renders as transparent. You also can get it from the [`Shape::builder`] method.
///
/// # Examples
///
/// ```rust
/// use grafo::Color;
/// use grafo::Stroke;
/// use grafo::ShapeBuilder;
///
/// let custom_shape = ShapeBuilder::new()
///     // Fill is set per-instance via the renderer (renderer.set_shape_color)
///     .stroke(Stroke::new(3.0, Color::BLACK)) // Black stroke with width 3.0
///     .begin((0.0, 0.0))
///     .line_to((50.0, 10.0))
///     .line_to((50.0, 50.0))
///     .close()
///     .build();
/// ```
#[derive(Clone)]
pub struct ShapeBuilder {
    /// The stroke properties of the shape.
    stroke: Stroke,
    /// The path builder used to construct the shape's geometric path.
    path_builder: lyon::path::Builder,
}

impl Default for ShapeBuilder {
    /// Creates a default `ShapeBuilder` with a black stroke.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::ShapeBuilder;    ///
    /// let builder = ShapeBuilder::default();
    /// ```
    fn default() -> Self {
        Self::new()
    }
}

impl ShapeBuilder {
    /// Creates a new `ShapeBuilder` with a default black stroke.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::ShapeBuilder;
    ///
    /// let builder = ShapeBuilder::new();
    /// ```
    pub fn new() -> Self {
        Self {
            stroke: Stroke::new(1.0, Color::rgb(0, 0, 0)),
            path_builder: lyon::path::Path::builder(),
        }
    }

    /// Sets the stroke properties of the shape.
    ///
    /// # Parameters
    ///
    /// - `stroke`: The desired stroke properties.
    ///
    /// # Returns
    ///
    /// The updated `ShapeBuilder` instance.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::Stroke;
    /// use grafo::Color;
    /// use grafo::ShapeBuilder;
    ///
    /// let builder = ShapeBuilder::new().stroke(Stroke::new(2.0, Color::BLACK)); // Black stroke with width 2.0
    /// ```
    pub fn stroke(mut self, stroke: Stroke) -> Self {
        self.stroke = stroke;
        self
    }

    /// Begin path at point
    ///
    /// # Parameters
    ///
    /// - `point`: The start point of the shape.
    ///
    /// # Returns
    ///
    /// The updated `ShapeBuilder` instance.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::ShapeBuilder;
    ///
    /// let builder = ShapeBuilder::new().begin((0.0, 0.0));
    /// ```
    pub fn begin(mut self, point: (f32, f32)) -> Self {
        self.path_builder.begin(point.into());
        self
    }

    /// Draws a line from the current point to the specified point.
    ///
    /// # Parameters
    ///
    /// - `point`: The end point of the line.
    ///
    /// # Returns
    ///
    /// The updated `ShapeBuilder` instance.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::ShapeBuilder;
    ///
    /// let builder = ShapeBuilder::new().begin((0.0, 0.0)).line_to((50.0, 10.0));
    /// ```
    pub fn line_to(mut self, point: (f32, f32)) -> Self {
        self.path_builder.line_to(point.into());
        self
    }

    /// Draws a cubic Bézier curve from the current point to the specified end point.
    ///
    /// # Parameters
    ///
    /// - `ctrl`: The first control point.
    /// - `ctrl2`: The second control point.
    /// - `to`: The end point of the curve.
    ///
    /// # Returns
    ///
    /// The updated `ShapeBuilder` instance.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::ShapeBuilder;
    ///
    /// let builder = ShapeBuilder::new()
    ///     .begin((0.0, 0.0))
    ///     .cubic_bezier_to((20.0, 30.0), (40.0, 30.0), (50.0, 10.0));
    /// ```
    pub fn cubic_bezier_to(mut self, ctrl: (f32, f32), ctrl2: (f32, f32), to: (f32, f32)) -> Self {
        self.path_builder
            .cubic_bezier_to(ctrl.into(), ctrl2.into(), to.into());
        self
    }

    /// Draws a quadratic Bézier curve from the current point to the specified end point.
    ///
    /// # Parameters
    ///
    /// - `ctrl`: The control point.
    /// - `to`: The end point of the curve.
    ///
    /// # Returns
    ///
    /// The updated `ShapeBuilder` instance.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::ShapeBuilder;
    ///
    /// let builder = ShapeBuilder::new()
    ///     .begin((0.0, 0.0))
    ///     .quadratic_bezier_to((25.0, 40.0), (50.0, 10.0));
    /// ```
    pub fn quadratic_bezier_to(mut self, ctrl: (f32, f32), to: (f32, f32)) -> Self {
        self.path_builder
            .quadratic_bezier_to(ctrl.into(), to.into());
        self
    }

    /// Closes the current sub-path by drawing a line back to the starting point.
    ///
    /// # Returns
    ///
    /// The updated `ShapeBuilder` instance.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::ShapeBuilder;
    ///
    /// let builder = ShapeBuilder::new().begin((0.0, 0.0)).close();
    /// ```
    pub fn close(mut self) -> Self {
        self.path_builder.close();
        self
    }

    /// Builds the [`Shape`] from the accumulated path, fill color, and stroke.
    ///
    /// # Returns
    ///
    /// A `Shape` instance representing the constructed shape.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::ShapeBuilder;
    ///
    /// let shape = ShapeBuilder::new()
    ///     .begin((0.0, 0.0))
    ///     .line_to((50.0, 10.0))
    ///     .line_to((50.0, 50.0))
    ///     .close()
    ///     .build();
    /// ```
    pub fn build(self) -> Shape {
        let path = self.path_builder.build();
        Shape::Path(PathShape {
            path,
            stroke: self.stroke,
        })
    }
}

impl From<ShapeBuilder> for Shape {
    fn from(value: ShapeBuilder) -> Self {
        value.build()
    }
}

/// A set of border radii for a rounded rectangle
#[derive(Copy, Clone, PartialEq, PartialOrd, Debug, Default)]
pub struct BorderRadii {
    pub top_left: f32,
    pub top_right: f32,
    pub bottom_left: f32,
    pub bottom_right: f32,
}

/// Represents the radii of each corner for a rounded rectangle.
///
/// # Fields
///
/// - `top_left`: Radius of the top-left corner.
/// - `top_right`: Radius of the top-right corner.
/// - `bottom_left`: Radius of the bottom-left corner.
/// - `bottom_right`: Radius of the bottom-right corner.
///
/// # Examples
///
/// Creating uniform and non-uniform border radii:
///
/// ```rust
/// use grafo::BorderRadii;
///
/// // Uniform border radii
/// let uniform_radii = BorderRadii::new(10.0);
///
/// // Custom border radii
/// let custom_radii = BorderRadii {
///     top_left: 5.0,
///     top_right: 10.0,
///     bottom_left: 15.0,
///     bottom_right: 20.0,
/// };
/// ```
impl BorderRadii {
    /// Creates a new `BorderRadii` with the same radius for all corners.
    ///
    /// # Parameters
    ///
    /// - `radius`: The radius to apply to all corners.
    ///
    /// # Returns
    ///
    /// A `BorderRadii` instance with uniform corner radii.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use grafo::BorderRadii;
    ///
    /// let radii = BorderRadii::new(10.0);
    /// ```
    pub fn new(radius: f32) -> Self {
        let r = radius.abs();
        BorderRadii {
            top_left: r,
            top_right: r,
            bottom_left: r,
            bottom_right: r,
        }
    }
}

impl core::fmt::Display for BorderRadii {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        // In the order of a well known convention (CSS) clockwise from top left
        write!(
            f,
            "BorderRadii({}, {}, {}, {})",
            self.top_left, self.top_right, self.bottom_left, self.bottom_right
        )
    }
}

impl From<BorderRadii> for lyon::path::builder::BorderRadii {
    fn from(val: BorderRadii) -> Self {
        lyon::path::builder::BorderRadii {
            top_left: val.top_left,
            top_right: val.top_right,
            bottom_left: val.bottom_left,
            bottom_right: val.bottom_right,
        }
    }
}

pub(crate) trait DrawShapeCommand {
    fn index_buffer_range(&self) -> Option<(usize, usize)>; // (start_index, index_count)
    fn is_empty(&self) -> bool;
    fn stencil_ref_mut(&mut self) -> &mut Option<u32>;
    fn instance_index_mut(&mut self) -> &mut Option<usize>;
    fn instance_index(&self) -> Option<usize>;
    fn transform(&self) -> Option<InstanceTransform>;
    fn texture_id(&self, layer: usize) -> Option<u64>;
    fn local_bounds(&self) -> [(f32, f32); 2];
    fn instance_color_override(&self) -> Option<[f32; 4]>;
    fn has_gradient_fill(&self) -> bool;
    fn gradient_bind_group(&self) -> Option<&std::sync::Arc<wgpu::BindGroup>>;
    fn clips_children(&self) -> bool;
    fn is_rect(&self) -> bool;
    fn rect_bounds(&self) -> Option<[(f32, f32); 2]>;
}

impl DrawShapeCommand for CachedShapeDrawData {
    #[inline]
    fn index_buffer_range(&self) -> Option<(usize, usize)> {
        self.index_buffer_range
    }

    #[inline]
    fn is_empty(&self) -> bool {
        self.is_empty
    }

    #[inline]
    fn stencil_ref_mut(&mut self) -> &mut Option<u32> {
        &mut self.stencil_ref
    }

    #[inline]
    fn instance_index_mut(&mut self) -> &mut Option<usize> {
        &mut self.instance_index
    }

    #[inline]
    fn instance_index(&self) -> Option<usize> {
        self.instance_index
    }

    #[inline]
    fn transform(&self) -> Option<InstanceTransform> {
        self.transform
    }

    #[inline]
    fn texture_id(&self, layer: usize) -> Option<u64> {
        self.texture_ids.get(layer).copied().unwrap_or(None)
    }

    #[inline]
    fn local_bounds(&self) -> [(f32, f32); 2] {
        self.cached_shape.local_bounds()
    }

    #[inline]
    fn instance_color_override(&self) -> Option<[f32; 4]> {
        self.color_override
    }

    #[inline]
    fn has_gradient_fill(&self) -> bool {
        matches!(&self.fill, Some(Fill::Gradient(_)))
    }

    #[inline]
    fn gradient_bind_group(&self) -> Option<&std::sync::Arc<wgpu::BindGroup>> {
        self.gradient_bind_group.as_ref()
    }

    #[inline]
    fn clips_children(&self) -> bool {
        self.clips_children
    }

    #[inline]
    fn is_rect(&self) -> bool {
        self.cached_shape.is_rect
    }

    #[inline]
    fn rect_bounds(&self) -> Option<[(f32, f32); 2]> {
        self.cached_shape.rect_bounds
    }
}

#[cfg(test)]
mod tests {
    use super::{
        find_boundary_edges, generate_aa_fringe, AaFringeScratch, BoundaryVertexKey, CustomVertex,
        RectShape, Shape,
    };
    use crate::{util::PoolManager, Stroke};
    use lyon::lyon_tessellation::FillTessellator;
    use std::num::NonZeroUsize;

    fn test_vertex(position: [f32; 2]) -> CustomVertex {
        CustomVertex {
            position,
            tex_coords: [0.0, 0.0],
            normal: [0.0, 0.0],
            coverage: 1.0,
        }
    }

    #[test]
    fn aa_fringe_ignores_internal_seams_with_duplicate_vertices() {
        let mut vertices = vec![
            test_vertex([0.0, 0.0]),
            test_vertex([1.0, 0.0]),
            test_vertex([1.0, 1.0]),
            test_vertex([0.0, 0.0]),
            test_vertex([1.0, 1.0]),
            test_vertex([0.0, 1.0]),
        ];
        let mut indices = vec![0, 1, 2, 3, 4, 5];
        let mut aa_fringe_scratch = AaFringeScratch::new();

        let boundary_edges = find_boundary_edges(&vertices, &indices, &mut aa_fringe_scratch);
        assert_eq!(boundary_edges.len(), 4);

        generate_aa_fringe(&mut vertices, &mut indices, &mut aa_fringe_scratch);

        assert_eq!(vertices.len(), 10);
        assert_eq!(indices.len(), 30);

        let outer_vertex_count = vertices
            .iter()
            .filter(|vertex| vertex.coverage == 0.0)
            .count();
        assert_eq!(outer_vertex_count, 4);

        let unique_outer_vertex_positions = vertices
            .iter()
            .filter(|vertex| vertex.coverage == 0.0)
            .map(|vertex| BoundaryVertexKey::from_position(vertex.position))
            .collect::<std::collections::BTreeSet<_>>();
        assert_eq!(unique_outer_vertex_positions.len(), 4);
    }

    #[test]
    fn rect_tessellation_uses_shared_quad_corners() {
        let rect_shape = RectShape::new([(10.0, 20.0), (30.0, 50.0)], Stroke::default());
        let mut tessellator = FillTessellator::new();
        let mut pool_manager = PoolManager::new(NonZeroUsize::new(1).unwrap());

        let tessellated_geometry =
            Shape::Rect(rect_shape).tessellate(&mut tessellator, &mut pool_manager, None);

        assert_eq!(tessellated_geometry.vertex_buffers.vertices.len(), 8);
        assert_eq!(tessellated_geometry.vertex_buffers.indices.len(), 30);

        let fill_vertex_count = tessellated_geometry
            .vertex_buffers
            .vertices
            .iter()
            .filter(|vertex| vertex.coverage == 1.0)
            .count();
        assert_eq!(fill_vertex_count, 4);
    }

    #[test]
    fn aa_fringe_keeps_distinct_corners_for_point_touching_triangles() {
        let mut vertices = vec![
            test_vertex([0.0, 0.0]),
            test_vertex([1.0, 0.0]),
            test_vertex([0.0, 1.0]),
            test_vertex([0.0, 0.0]),
            test_vertex([-1.0, 0.0]),
            test_vertex([0.0, -1.0]),
        ];
        let mut indices = vec![0, 1, 2, 3, 4, 5];
        let mut aa_fringe_scratch = AaFringeScratch::new();

        generate_aa_fringe(&mut vertices, &mut indices, &mut aa_fringe_scratch);

        let outer_vertices = vertices
            .iter()
            .filter(|vertex| vertex.coverage == 0.0)
            .collect::<Vec<_>>();
        assert_eq!(outer_vertices.len(), 6);

        let shared_point_outer_vertices = outer_vertices
            .iter()
            .filter(|vertex| {
                BoundaryVertexKey::from_position(vertex.position)
                    == BoundaryVertexKey::from_position([0.0, 0.0])
            })
            .count();
        assert_eq!(shared_point_outer_vertices, 2);
    }

    #[test]
    fn aa_fringe_skips_zero_length_boundary_edges() {
        let mut vertices = vec![
            test_vertex([5.0, 5.0]),
            test_vertex([5.0, 5.0]),
            test_vertex([6.0, 5.0]),
        ];
        let mut indices = vec![0, 1, 2];
        let mut aa_fringe_scratch = AaFringeScratch::new();

        generate_aa_fringe(&mut vertices, &mut indices, &mut aa_fringe_scratch);

        assert_eq!(vertices.len(), 3);
        assert_eq!(indices.len(), 3);
    }
}