use crate::math::{Matrix, Point, Rect};

use crate::shapes::{
    arrow_cap_path, merge_fills, square_cap_path, triangle_cap_path, Corners, Fill, ImageFill,
    Path, Shape, Side, Stroke, StrokeCap, StrokeKind, StrokeStyle, SvgAttrs, Type,
};
use skia_safe::{self as skia, ImageFilter, RRect};

use super::{filters, RenderState, SurfaceId};
use crate::error::{Error, Result};
use crate::get_resources;
use crate::render::filters::compose_filters;
use crate::render::{get_dest_rect, get_source_rect};

#[allow(clippy::too_many_arguments)]
pub(super) fn draw_stroke_on_rect(
    canvas: &skia::Canvas,
    stroke: &Stroke,
    rect: &Rect,
    corners: &Option<Corners>,
    paint: &skia::Paint,
    scale: f32,
    shadow: Option<&ImageFilter>,
    blur: Option<&ImageFilter>,
    miter: Option<[f32; 4]>,
    antialias: bool,
) {
    let stroke_rect = stroke.aligned_rect(rect, scale);
    let mut paint = paint.clone();

    // Apply both blur and shadow filters if present, composing them if necessary.
    let filter = compose_filters(blur, shadow);
    paint.set_image_filter(filter);

    // Per-side widths render as a band between an outer and an inner rect.
    if let Some(widths) = stroke.per_side_widths() {
        draw_per_side_stroke_on_rect(
            canvas, stroke, rect, corners, &paint, widths, scale, miter, antialias,
        );
        return;
    }

    // Radii as Skia fits them to the shape, so the stroke follows the fill.
    let shape_radii = corners.map(|radii| *RRect::new_rect_radii(*rect, &radii).radii_ref());

    // By default just draw the rect. Only dotted inner/outer strokes need
    // clipping to prevent the dotted pattern from appearing in wrong areas.
    let draw_stroke = || match &shape_radii {
        Some(radii) => {
            let radii = stroke.outer_corners(radii);
            let rrect = RRect::new_rect_radii(stroke_rect, &radii);
            canvas.draw_rrect(rrect, &paint);
        }
        None => {
            canvas.draw_rect(stroke_rect, &paint);
        }
    };

    // Dotted inner/outer strokes need clipping to prevent the dotted
    // pattern from appearing in wrong areas.
    if let Some(clip_op) = stroke.clip_op() {
        // Use a neutral layer (no extra paint) so opacity and filters
        // come solely from the stroke paint. This avoids applying
        // stroke alpha twice for dotted inner/outer strokes.
        let layer_rec = skia::canvas::SaveLayerRec::default();
        canvas.save_layer(&layer_rec);
        match corners {
            Some(radii) => {
                let rrect = RRect::new_rect_radii(*rect, radii);
                canvas.clip_rrect(rrect, clip_op, antialias);
            }
            None => {
                canvas.clip_rect(*rect, clip_op, antialias);
            }
        }
        draw_stroke();
        canvas.restore();
    } else if stroke.kind == StrokeKind::Inner
        && (stroke.width >= rect.width()
            || stroke.width >= rect.height()
            || inner_corners_collapse(stroke, rect, &shape_radii))
    {
        // When the inner stroke width exceeds a shape dimension, the inset
        // rect goes negative and the stroke overflows outside the shape.
        // Same when the inset radii can't follow the shape corners.
        // Fall back to the same approach as the SVG renderer: draw with
        // doubled width centered on the original shape and clip to it.
        canvas.save();
        match corners {
            Some(radii) => {
                let rrect = RRect::new_rect_radii(*rect, radii);
                canvas.clip_rrect(rrect, skia::ClipOp::Intersect, antialias);
            }
            None => {
                canvas.clip_rect(*rect, skia::ClipOp::Intersect, antialias);
            }
        }
        let mut inner_paint = paint.clone();
        inner_paint.set_stroke_width(stroke.width * 2.0);
        match corners {
            Some(radii) => {
                let rrect = RRect::new_rect_radii(*rect, radii);
                canvas.draw_rrect(rrect, &inner_paint);
            }
            None => {
                canvas.draw_rect(*rect, &inner_paint);
            }
        }
        canvas.restore();
    } else {
        draw_stroke();
    }
}

/// Whether the inset radii clamp to zero or get rescaled by Skia to fit.
fn inner_corners_collapse(stroke: &Stroke, rect: &Rect, radii: &Option<Corners>) -> bool {
    let Some(radii) = radii else {
        return false;
    };
    if matches!(stroke.style, StrokeStyle::Dotted | StrokeStyle::Dashed) {
        return false;
    }
    let wanted = stroke.outer_corners(radii);
    let inset = RRect::new_rect_radii(stroke.outer_rect(rect), &wanted);
    radii
        .iter()
        .zip(wanted.iter().zip(inset.radii_ref()))
        .any(|(shape, (want, got))| shape.x > 0.0 && (want.x <= 0.0 || want != got))
}

/// Draws a rect/frame stroke whose sides have different widths as the area
/// between an outer and an inner (rounded) rect, mitered like CSS borders.
/// Dashed/dotted styles cut that band per side, each side fitting a whole
/// number of dashes the way a browser fits a dashed border.
#[allow(clippy::too_many_arguments)]
fn draw_per_side_stroke_on_rect(
    canvas: &skia::Canvas,
    stroke: &Stroke,
    rect: &Rect,
    corners: &Option<Corners>,
    paint: &skia::Paint,
    widths: [f32; 4],
    scale: f32,
    miter: Option<[f32; 4]>,
    antialias: bool,
) {
    // Strokes sharing a border box are shaped by the whole box: a side this one
    // does not paint still sets the radii its corners curve to, as in CSS.
    let band_widths: [f32; 4] = match miter {
        Some(profile) => std::array::from_fn(|side| {
            if widths[side] > 0.0 {
                widths[side]
            } else {
                profile[side]
            }
        }),
        None => widths,
    };
    let [top, right, bottom, left] = band_widths;

    // Fraction of each side width growing outward / inward from the shape
    // boundary, per stroke alignment.
    let (out_f, in_f) = match stroke.kind {
        StrokeKind::Inner => (0.0, 1.0),
        StrokeKind::Center => (0.5, 0.5),
        StrokeKind::Outer => (1.0, 0.0),
    };

    let outer = Rect::from_ltrb(
        rect.left - left * out_f,
        rect.top - top * out_f,
        rect.right + right * out_f,
        rect.bottom + bottom * out_f,
    );
    let inner = Rect::from_ltrb(
        rect.left + left * in_f,
        rect.top + top * in_f,
        rect.right - right * in_f,
        rect.bottom - bottom * in_f,
    );
    // When a side width exceeds the shape dimension the inner rect collapses
    // and the whole outer rect is filled, like CSS collapsing borders.
    let has_hole = inner.width() > 0.0 && inner.height() > 0.0;

    let mut fill_paint = paint.clone();
    fill_paint.set_style(skia::PaintStyle::Fill);
    fill_paint.set_path_effect(None);
    fill_paint.set_anti_alias(antialias);

    let mut pb = skia::PathBuilder::new();
    let (outer_radii, inner_radii) = match corners {
        Some(radii) => {
            // Straight (zero-radius) corners stay sharp; rounded ones keep
            // their curvature parallel to the shape edge, like CSS borders.
            let grow = |radius: f32, delta: f32| {
                if radius > 0.0 {
                    radius + delta
                } else {
                    0.0
                }
            };
            let shrink = |radius: f32, delta: f32| (radius - delta).max(0.0);
            // Adjacent side widths per corner, matching the Skia radii order:
            // [top-left, top-right, bottom-right, bottom-left].
            let side_deltas = [(left, top), (right, top), (right, bottom), (left, bottom)];
            let mut outer_radii = *radii;
            let mut inner_radii = *radii;
            for (i, (dx, dy)) in side_deltas.into_iter().enumerate() {
                outer_radii[i].x = grow(outer_radii[i].x, dx * out_f);
                outer_radii[i].y = grow(outer_radii[i].y, dy * out_f);
                inner_radii[i].x = shrink(inner_radii[i].x, dx * in_f);
                inner_radii[i].y = shrink(inner_radii[i].y, dy * in_f);
            }
            pb.add_rrect(RRect::new_rect_radii(outer, &outer_radii), None, None);
            if has_hole {
                pb.add_rrect(RRect::new_rect_radii(inner, &inner_radii), None, None);
            }
            (Some(outer_radii), Some(inner_radii))
        }
        None => {
            pb.add_rect(outer, None, None);
            if has_hole {
                pb.add_rect(inner, None, None);
            }
            (None, None)
        }
    };

    let mut band = pb.detach();
    band.set_fill_type(skia::PathFillType::EvenOdd);

    // Solid is the common case and the whole band is one fill. A collapsed
    // band has no sides left to walk, so it fills solid too.
    let style = stroke.with_width(stroke.max_width()).style_at_scale(scale);
    let pattern = if style == StrokeStyle::Solid || !has_hole {
        None
    } else {
        expand_side_patterns(
            stroke,
            style,
            rect,
            &outer,
            &inner,
            inner_radii,
            widths,
            antialias,
        )
    };

    // Sides this stroke shares with another per-side stroke meet on a diagonal,
    // so each one keeps only its own wedge of the corner.
    let wedges = miter.and_then(|profile| side_wedges(&outer, outer_radii, profile, widths));

    if pattern.is_none() && wedges.is_none() {
        canvas.draw_path(&band, &fill_paint);
        return;
    }

    // A filtered stroke draws inside a filtered layer, so the blur or shadow
    // sees the clipped geometry rather than the whole band.
    match fill_paint.image_filter() {
        Some(filter) => {
            fill_paint.set_image_filter(None);
            let mut layer_paint = skia::Paint::default();
            layer_paint.set_image_filter(filter);
            let layer_rec = skia::canvas::SaveLayerRec::default().paint(&layer_paint);
            canvas.save_layer(&layer_rec);
        }
        None => {
            canvas.save();
        }
    }

    if let Some(wedges) = &wedges {
        canvas.clip_path(wedges, skia::ClipOp::Intersect, antialias);
    }

    match &pattern {
        Some(pattern) => {
            // Square corners need no clip: the side strips tile the band exactly.
            // Rounded corners curve past them, and dots straddle the boundary.
            let rounded = corners.is_some_and(|radii| radii.iter().any(|r| r.x > 0.0 || r.y > 0.0));
            if rounded || style == StrokeStyle::Dotted {
                canvas.clip_path(&band, skia::ClipOp::Intersect, antialias);
            }
            canvas.draw_path(pattern, &fill_paint);
        }
        None => {
            canvas.draw_path(&band, &fill_paint);
        }
    }
    canvas.restore();
}

/// Where a corner's miter line sits at the outer edge and at `depth` into the
/// side. It runs through the centre of curvature, so a corner splits on its arc.
fn miter_offsets(radius: (f32, f32), own: f32, adjacent: f32, depth: f32) -> (f32, f32) {
    if own <= 0.0 {
        return (0.0, adjacent);
    }
    // A corner with no neighbour to meet belongs to this side alone.
    let (along, across) = if adjacent > 0.0 { radius } else { (0.0, 0.0) };
    let slope = adjacent / own;
    (along - across * slope, along - (across - depth) * slope)
}

/// The CSS miter wedges for the sides this stroke paints, each narrowing to a
/// diagonal where it meets a neighbour. `None` when it already fills the profile.
fn side_wedges(
    outer: &Rect,
    outer_radii: Option<Corners>,
    profile: [f32; 4],
    widths: [f32; 4],
) -> Option<skia::Path> {
    if widths == profile {
        return None;
    }
    let [top, right, bottom, left] = profile;
    let radii = outer_radii.unwrap_or_default();

    let mut pb = skia::PathBuilder::new();
    let mut wedged = false;
    for side in Side::ALL {
        if widths[side.index()] <= 0.0 {
            continue;
        }
        // Each side runs from its own corner to the next one clockwise.
        let lead = side.index();
        let trail = (lead + 1) % 4;
        let (own, ccw, cw) = match side {
            Side::Top => (top, left, right),
            Side::Right => (right, top, bottom),
            Side::Bottom => (bottom, right, left),
            Side::Left => (left, bottom, top),
        };
        // A corner radius is an ellipse: the component along the side sets where
        // the miter meets it, the one across it sets how deep the corner runs.
        let (lead_radius, trail_radius) = match side {
            Side::Top | Side::Bottom => (
                (radii[lead].x, radii[lead].y),
                (radii[trail].x, radii[trail].y),
            ),
            Side::Right | Side::Left => (
                (radii[lead].y, radii[lead].x),
                (radii[trail].y, radii[trail].x),
            ),
        };
        // A rounded corner bulges past the straight strip, so the wedge reaches
        // deeper than the side is thick. The band trims whatever overshoots.
        let depth = own + lead_radius.1.max(trail_radius.1);
        let (a_out, a_in) = miter_offsets(lead_radius, own, ccw, depth);
        let (b_out, b_in) = miter_offsets(trail_radius, own, cw, depth);
        let quad = match side {
            Side::Top => [
                (outer.left + a_out, outer.top),
                (outer.right - b_out, outer.top),
                (outer.right - b_in, outer.top + depth),
                (outer.left + a_in, outer.top + depth),
            ],
            Side::Right => [
                (outer.right, outer.top + a_out),
                (outer.right, outer.bottom - b_out),
                (outer.right - depth, outer.bottom - b_in),
                (outer.right - depth, outer.top + a_in),
            ],
            Side::Bottom => [
                (outer.right - a_out, outer.bottom),
                (outer.left + b_out, outer.bottom),
                (outer.left + b_in, outer.bottom - depth),
                (outer.right - a_in, outer.bottom - depth),
            ],
            Side::Left => [
                (outer.left, outer.bottom - a_out),
                (outer.left, outer.top + b_out),
                (outer.left + depth, outer.top + b_in),
                (outer.left + depth, outer.bottom - a_in),
            ],
        };
        pb.add_polygon(&quad.map(Point::from), true);
        wedged = true;
    }
    wedged.then(|| pb.detach())
}

/// Expands each side's dash or dot pattern into the geometry it paints, fitted
/// so the side begins and ends on a dash. `None` when no side produced any.
#[allow(clippy::too_many_arguments)]
fn expand_side_patterns(
    stroke: &Stroke,
    style: StrokeStyle,
    rect: &Rect,
    outer: &Rect,
    inner: &Rect,
    inner_radii: Option<Corners>,
    widths: [f32; 4],
    antialias: bool,
) -> Option<skia::Path> {
    let mut pb = skia::PathBuilder::new();
    let mut expanded = false;

    let mut stamp_paint = skia::Paint::default();
    stamp_paint.set_style(skia::PaintStyle::Stroke);
    stamp_paint.set_stroke_cap(skia::paint::Cap::Butt);
    stamp_paint.set_anti_alias(antialias);

    for side in Side::ALL {
        let width = widths[side.index()];
        if width <= 0.0 {
            continue;
        }

        let mut side_stroke = stroke.with_width(width);
        side_stroke.style = style;

        // Where the uniform renderer would stroke this width, so inner/outer
        // dots still come out as half circles once the band clips them.
        let line = side_stroke.outer_rect(rect);
        let (start, end) = match side {
            Side::Top => ((outer.left, line.top), (outer.right, line.top)),
            Side::Right => ((line.right, outer.top), (line.right, outer.bottom)),
            Side::Bottom => ((outer.right, line.bottom), (outer.left, line.bottom)),
            Side::Left => ((line.left, outer.bottom), (line.left, outer.top)),
        };
        let length = match side {
            Side::Top | Side::Bottom => outer.width(),
            Side::Right | Side::Left => outer.height(),
        };

        let Some(effect) = side_stroke.path_effect_fitted(length) else {
            continue;
        };
        stamp_paint.set_stroke_width(width);
        stamp_paint.set_path_effect(effect);

        let line_path = {
            let mut line_pb = skia::PathBuilder::new();
            line_pb.move_to(start);
            line_pb.line_to(end);
            line_pb.detach()
        };

        let mut outline = skia::PathBuilder::new();
        if skia::path_utils::fill_path_with_paint(
            &line_path,
            &stamp_paint,
            &mut outline,
            None,
            None,
        ) {
            pb.add_path(&outline.detach(), None);
            expanded = true;
        }
    }

    // A rounded band's corner notches paint solid, as a browser does for uneven
    // widths. Dots are discrete and must not weld into a solid corner.
    if style != StrokeStyle::Dotted {
        if let Some(radii) = inner_radii {
            for patch in corner_patches(outer, inner, &radii) {
                pb.add_rect(patch, None, None);
                expanded = true;
            }
        }
    }

    expanded.then(|| pb.detach())
}

/// The corner boxes of a rounded band, from each side's leading outer corner to
/// where that corner's inner arc meets the straight edges.
fn corner_patches(outer: &Rect, inner: &Rect, inner_radii: &Corners) -> Vec<Rect> {
    Side::ALL
        .into_iter()
        .filter_map(|side| {
            let radius = inner_radii[side.index()];
            if radius.x <= 0.0 && radius.y <= 0.0 {
                return None;
            }
            let (left, right) = match side {
                Side::Top | Side::Left => (outer.left, inner.left + radius.x),
                Side::Right | Side::Bottom => (inner.right - radius.x, outer.right),
            };
            let (top, bottom) = match side {
                Side::Top | Side::Right => (outer.top, inner.top + radius.y),
                Side::Bottom | Side::Left => (inner.bottom - radius.y, outer.bottom),
            };
            let patch = Rect::from_ltrb(left, top, right, bottom);
            (patch.width() > 0.0 && patch.height() > 0.0).then_some(patch)
        })
        .collect()
}

#[allow(clippy::too_many_arguments)]
pub(super) fn draw_stroke_on_circle(
    canvas: &skia::Canvas,
    stroke: &Stroke,
    rect: &Rect,
    paint: &skia::Paint,
    scale: f32,
    shadow: Option<&ImageFilter>,
    blur: Option<&ImageFilter>,
    antialias: bool,
) {
    let stroke_rect = stroke.aligned_rect(rect, scale);
    let mut paint = paint.clone();

    // Apply both blur and shadow filters if present, composing them if necessary.
    let filter = compose_filters(blur, shadow);
    paint.set_image_filter(filter);

    // Dotted inner/outer strokes need clipping to prevent the dotted
    // pattern from appearing in wrong areas.
    if let Some(clip_op) = stroke.clip_op() {
        // Use a neutral layer (no extra paint) so opacity and filters
        // come solely from the stroke paint. This avoids applying
        // stroke alpha twice for dotted inner/outer strokes.
        let layer_rec = skia::canvas::SaveLayerRec::default();
        canvas.save_layer(&layer_rec);
        let clip_path = {
            let mut pb = skia::PathBuilder::new();
            pb.add_oval(rect, None, None);
            pb.detach()
        };
        canvas.clip_path(&clip_path, clip_op, antialias);
        canvas.draw_oval(stroke_rect, &paint);
        canvas.restore();
    } else if stroke.kind == StrokeKind::Inner
        && (stroke.width >= rect.width() || stroke.width >= rect.height())
    {
        // When the inner stroke width exceeds a shape dimension, the inset
        // rect goes negative and the stroke overflows outside the shape.
        // Fall back to the same approach as the SVG renderer: draw with
        // doubled width centered on the original shape and clip to it.
        canvas.save();
        let clip_path = {
            let mut pb = skia::PathBuilder::new();
            pb.add_oval(rect, None, None);
            pb.detach()
        };
        canvas.clip_path(&clip_path, skia::ClipOp::Intersect, antialias);
        let mut inner_paint = paint.clone();
        inner_paint.set_stroke_width(stroke.width * 2.0);
        canvas.draw_oval(*rect, &inner_paint);
        canvas.restore();
    } else {
        canvas.draw_oval(stroke_rect, &paint);
    }
}

fn draw_outer_stroke_path(
    canvas: &skia::Canvas,
    path: &skia::Path,
    paint: &skia::Paint,
    blur: Option<&ImageFilter>,
    antialias: bool,
) {
    let mut outer_paint = skia::Paint::default();
    outer_paint.set_blend_mode(skia::BlendMode::SrcOver);
    outer_paint.set_anti_alias(antialias);

    if let Some(filter) = blur {
        outer_paint.set_image_filter(filter.clone());
    }

    let layer_rec = skia::canvas::SaveLayerRec::default().paint(&outer_paint);
    canvas.save_layer(&layer_rec);
    canvas.draw_path(path, paint);

    let mut clear_paint = skia::Paint::default();
    clear_paint.set_blend_mode(skia::BlendMode::Clear);
    clear_paint.set_anti_alias(antialias);
    canvas.draw_path(path, &clear_paint);

    canvas.restore();
}

// For inner stroke we draw a center stroke (with double width) and clip to the original path (that way the extra outer stroke is removed)
fn draw_inner_stroke_path(
    canvas: &skia::Canvas,
    path: &skia::Path,
    paint: &skia::Paint,
    blur: Option<&ImageFilter>,
    antialias: bool,
) {
    let mut inner_paint = skia::Paint::default();
    inner_paint.set_anti_alias(antialias);
    if let Some(filter) = blur {
        inner_paint.set_image_filter(filter.clone());
    }

    let layer_rec = skia::canvas::SaveLayerRec::default().paint(&inner_paint);
    canvas.save_layer(&layer_rec);
    canvas.clip_path(path, skia::ClipOp::Intersect, antialias);
    canvas.draw_path(path, paint);
    canvas.restore();
}

// For outer stroke we draw a center stroke (with double width) and use another path with blend mode clear to remove the inner stroke added
#[allow(clippy::too_many_arguments)]
fn draw_stroke_on_path(
    canvas: &skia::Canvas,
    stroke: &Stroke,
    path: &Path,
    paint: &skia::Paint,
    path_transform: Option<&Matrix>,
    shadow: Option<&ImageFilter>,
    blur: Option<&ImageFilter>,
    svg_attrs: Option<&SvgAttrs>,
    antialias: bool,
) {
    let is_open = path.is_open();

    let mut draw_paint = paint.clone();
    let filter = compose_filters(blur, shadow);
    draw_paint.set_image_filter(filter);

    // Move path_transform from the path geometry to the canvas so the
    // stroke width is not distorted by non-uniform shape scaling.
    // The path coordinates are already in world space, so we draw the
    // raw path on a canvas where the shape transform has been undone:
    //   canvas * path_transform = View × parents (no shape scale/rotation)
    // This matches the SVG renderer, which bakes the transform into path
    // coordinates and never sets a transform attribute on the element.
    let save_count = canvas.save();
    if let Some(pt) = path_transform {
        canvas.concat(pt);
    }

    let skia_path = path.to_skia_path(svg_attrs);
    match stroke.render_kind(is_open) {
        StrokeKind::Inner => {
            draw_inner_stroke_path(canvas, &skia_path, &draw_paint, blur, antialias);
        }
        StrokeKind::Center => {
            canvas.draw_path(&skia_path, &draw_paint);
        }
        StrokeKind::Outer => {
            draw_outer_stroke_path(canvas, &skia_path, &draw_paint, blur, antialias);
        }
    }

    handle_stroke_caps(&skia_path, stroke, canvas, is_open, paint, blur, antialias);

    canvas.restore_to_count(save_count);
}

fn handle_stroke_cap(
    canvas: &skia::Canvas,
    cap: StrokeCap,
    width: f32,
    paint: &mut skia::Paint,
    p1: &Point,
    p2: &Point,
) {
    paint.set_style(skia::PaintStyle::Fill);
    match cap {
        StrokeCap::LineArrow => {
            // We also draw this square cap to fill the gap between the path and the arrow
            draw_square_cap(canvas, paint, p1, p2, width, 0.);
            paint.set_style(skia::PaintStyle::Stroke);
            draw_arrow_cap(canvas, paint, p1, p2, width * 4.);
        }
        StrokeCap::TriangleArrow => {
            draw_triangle_cap(canvas, paint, p1, p2, width * 4.);
        }
        StrokeCap::SquareMarker => {
            draw_square_cap(canvas, paint, p1, p2, width * 4., 0.);
        }
        StrokeCap::CircleMarker => {
            canvas.draw_circle((p1.x, p1.y), width * 2., paint);
        }
        StrokeCap::DiamondMarker => {
            draw_square_cap(canvas, paint, p1, p2, width * 4., 45.);
        }
        StrokeCap::Round => {
            canvas.draw_circle((p1.x, p1.y), width / 2.0, paint);
        }
        StrokeCap::Square => {
            draw_square_cap(canvas, paint, p1, p2, width, 0.);
        }
    }
}

#[allow(clippy::too_many_arguments)]
pub(super) fn handle_stroke_caps(
    path: &skia::Path,
    stroke: &Stroke,
    canvas: &skia::Canvas,
    is_open: bool,
    paint: &skia::Paint,
    blur: Option<&ImageFilter>,
    _antialias: bool,
) {
    // Closed shapes don't have caps
    if !is_open {
        return;
    }

    // When both ends share the same simple line cap, Skia already drew it
    // natively via `PaintCap` on the stroke paint, so skip the manual overlay.
    if stroke.to_skia_linecap().is_some() {
        return;
    }

    // Curves can have duplicated points, so let's remove consecutive duplicated points
    let mut points = path.points().to_vec();
    points.dedup();

    if let [first_point, .., last_point] = points.as_slice() {
        let mut paint_stroke = paint.clone();

        paint_stroke.set_path_effect(None);

        if let Some(filter) = blur {
            paint_stroke.set_image_filter(filter.clone());
        }

        if let Some(cap) = stroke.cap_start {
            handle_stroke_cap(
                canvas,
                cap,
                stroke.width,
                &mut paint_stroke,
                first_point,
                &points[1],
            );
        }

        if let Some(cap) = stroke.cap_end {
            handle_stroke_cap(
                canvas,
                cap,
                stroke.width,
                &mut paint_stroke,
                last_point,
                &points[points.len() - 2],
            );
        }
    }
}

fn draw_square_cap(
    canvas: &skia::Canvas,
    paint: &skia::Paint,
    center: &Point,
    direction: &Point,
    size: f32,
    extra_rotation: f32,
) {
    canvas.draw_path(
        &square_cap_path(center, direction, size, extra_rotation),
        paint,
    );
}

fn draw_arrow_cap(
    canvas: &skia::Canvas,
    paint: &skia::Paint,
    center: &Point,
    direction: &Point,
    size: f32,
) {
    canvas.draw_path(&arrow_cap_path(center, direction, size), paint);
}

fn draw_triangle_cap(
    canvas: &skia::Canvas,
    paint: &skia::Paint,
    center: &Point,
    direction: &Point,
    size: f32,
) {
    canvas.draw_path(&triangle_cap_path(center, direction, size), paint);
}

fn draw_image_stroke_in_container(
    render_state: &mut RenderState,
    shape: &Shape,
    stroke: &Stroke,
    image_fill: &ImageFill,
    antialias: bool,
    surface_id: SurfaceId,
) -> Result<()> {
    let scale = render_state.get_scale();
    let lod_stroke;
    let stroke = if matches!(shape.shape_type, Type::Path(_) | Type::Bool(_)) {
        lod_stroke = stroke.path_lod_at_scale(shape.is_open(), scale);
        &lod_stroke
    } else {
        stroke
    };
    let Some(image) = get_resources().images.get(&image_fill.id()) else {
        return Ok(());
    };

    let size = image.dimensions();
    let canvas = render_state.surfaces.canvas_and_mark_dirty(surface_id);
    let container = &shape.selrect;
    let path_transform = shape.to_path_transform();
    let svg_attrs = shape.svg_attrs.as_ref();

    // Save canvas and layer state
    let mut pb = skia::Paint::default();
    pb.set_blend_mode(skia::BlendMode::SrcOver);
    pb.set_anti_alias(antialias);
    if let Some(filter) = shape.image_filter(1.) {
        pb.set_image_filter(filter);
    }

    let layer_rec = skia::canvas::SaveLayerRec::default().paint(&pb);
    canvas.save_layer(&layer_rec);

    // Draw the stroke based on the shape type, we are using this stroke as
    // a "selector" of the area of the image we want to show.
    let outer_rect = stroke.aligned_rect(container, scale);

    match &shape.shape_type {
        shape_type @ (Type::Rect(_) | Type::Frame(_)) => {
            let paint = stroke.to_paint(&outer_rect, svg_attrs, antialias);
            draw_stroke_on_rect(
                canvas,
                stroke,
                container,
                &shape_type.corners(),
                &paint,
                scale,
                None,
                None,
                Stroke::per_side_profile(shape.visible_strokes()),
                antialias,
            );
        }
        Type::Circle => {
            let paint = stroke.to_paint(&outer_rect, svg_attrs, antialias);
            draw_stroke_on_circle(
                canvas, stroke, container, &paint, scale, None, None, antialias,
            );
        }

        shape_type @ (Type::Path(_) | Type::Bool(_)) => {
            if let Some(p) = shape_type.path() {
                canvas.save();

                let path = p.to_skia_path(svg_attrs).make_transform(
                    &path_transform.ok_or(Error::CriticalError("No path transform".to_string()))?,
                );
                let stroke_kind = stroke.render_kind(p.is_open());
                match stroke_kind {
                    StrokeKind::Inner => {
                        canvas.clip_path(&path, skia::ClipOp::Intersect, antialias);
                    }
                    StrokeKind::Center => {}
                    StrokeKind::Outer => {
                        canvas.clip_path(&path, skia::ClipOp::Difference, antialias);
                    }
                }
                let is_open = p.is_open();
                let paint = stroke.to_stroked_paint(is_open, &outer_rect, svg_attrs, antialias);
                canvas.draw_path(&path, &paint);
                if stroke.render_kind(is_open) == StrokeKind::Outer {
                    // Small extra inner stroke to overlap with the fill
                    // and avoid unnecesary artifacts.
                    let mut thin_paint = paint.clone();
                    thin_paint.set_stroke_width(1. / scale);
                    canvas.draw_path(&path, &thin_paint);
                }
                handle_stroke_caps(
                    &path,
                    stroke,
                    canvas,
                    is_open,
                    &paint,
                    shape.image_filter(1.).as_ref(),
                    antialias,
                );
                canvas.restore();
            }
        }

        _ => unreachable!("This shape should not have strokes"),
    }

    // Draw the image. We are using now the SrcIn blend mode,
    // so the rendered piece of image will the area of the
    // stroke over the image.
    let mut image_paint = skia::Paint::default();
    image_paint.set_blend_mode(skia::BlendMode::SrcIn);
    image_paint.set_anti_alias(antialias);
    if let Some(filter) = shape.image_filter(1.) {
        image_paint.set_image_filter(filter);
    }

    let src_rect = get_source_rect(size, container, image_fill);
    let dest_rect = get_dest_rect(container, stroke.delta());

    canvas.clip_rect(dest_rect, skia::ClipOp::Intersect, antialias);
    canvas.draw_image_rect_with_sampling_options(
        image,
        Some((&src_rect, skia::canvas::SrcRectConstraint::Strict)),
        dest_rect,
        get_resources().sampling_options,
        &image_paint,
    );

    // Clear outer stroke for paths if necessary. When adding an outer stroke we need to empty the stroke added too in the inner area.
    if let Type::Path(p) = &shape.shape_type {
        if stroke.render_kind(p.is_open()) == StrokeKind::Outer {
            let path = p.to_skia_path(svg_attrs).make_transform(
                &path_transform.ok_or(Error::CriticalError("No path transform".to_string()))?,
            );
            let mut clear_paint = skia::Paint::default();
            clear_paint.set_blend_mode(skia::BlendMode::Clear);
            clear_paint.set_anti_alias(antialias);
            canvas.draw_path(&path, &clear_paint);
        }
    }

    // Restore canvas state
    canvas.restore();
    Ok(())
}

/// Renders all strokes for a shape. Merges strokes that share the same
/// geometry (kind, width, style, caps) into a single draw call to avoid
/// anti-aliasing edge bleed between them.
pub fn render(
    render_state: &mut RenderState,
    shape: &Shape,
    strokes: &[&Stroke],
    surface_id: Option<SurfaceId>,
    antialias: bool,
    outset: Option<f32>,
) -> Result<()> {
    if strokes.is_empty() {
        return Ok(());
    }

    let has_image_fills = strokes.iter().any(|s| matches!(s.fill, Fill::Image(_)));
    let can_merge = !has_image_fills && strokes.len() > 1 && strokes_share_geometry(strokes);

    if !can_merge {
        // When blur is active, render all strokes into a single offscreen surface
        // and apply blur once to the composite. This prevents blur from making
        // edges semi-transparent and revealing strokes underneath.
        if let Some(image_filter) = shape.image_filter(1.) {
            let mut content_bounds = shape.selrect;
            // Expand for outset if provided
            if let Some(s) = outset.filter(|&s| s > 0.0) {
                content_bounds.outset((s, s));
            }
            let max_margin = strokes
                .iter()
                .map(|s| s.bounds_width(shape.is_open()))
                .fold(0.0f32, f32::max);
            if max_margin > 0.0 {
                content_bounds.inset((-max_margin, -max_margin));
            }
            let max_cap = strokes
                .iter()
                .map(|s| s.cap_bounds_margin())
                .fold(0.0f32, f32::max);
            if max_cap > 0.0 {
                content_bounds.inset((-max_cap, -max_cap));
            }
            let bounds = image_filter.compute_fast_bounds(content_bounds);
            let target = surface_id.unwrap_or(SurfaceId::Strokes);
            if filters::render_with_filter_surface(
                render_state,
                bounds,
                target,
                |state, temp_surface| {
                    // Use save_layer with the blur filter so it applies once
                    // to the composite of all strokes, not per-stroke.
                    let canvas = state.surfaces.canvas(temp_surface);
                    let mut blur_paint = skia::Paint::default();
                    blur_paint.set_image_filter(image_filter.clone());
                    let layer_rec = skia::canvas::SaveLayerRec::default().paint(&blur_paint);
                    canvas.save_layer(&layer_rec);

                    for stroke in strokes.iter().rev() {
                        // bypass_filter=true prevents each stroke from creating
                        // its own filter surface. The blur on the paint inside
                        // draw functions is harmless — it composes with the
                        // layer's filter but the layer filter is the dominant one.
                        render_single_internal(
                            state,
                            shape,
                            stroke,
                            Some(temp_surface),
                            None,
                            antialias,
                            true,
                            true,
                            outset,
                        )?;
                    }

                    state.surfaces.canvas(temp_surface).restore();
                    Ok(())
                },
            )? {
                return Ok(());
            }
        }

        // No blur or filter surface unavailable — draw strokes individually.
        for stroke in strokes.iter().rev() {
            render_single(
                render_state,
                shape,
                stroke,
                surface_id,
                None,
                antialias,
                outset,
            )?;
        }
        return Ok(());
    }

    render_merged(
        render_state,
        shape,
        strokes,
        surface_id,
        antialias,
        false,
        outset,
    )
}

fn strokes_share_geometry(strokes: &[&Stroke]) -> bool {
    strokes.windows(2).all(|pair| {
        pair[0].kind == pair[1].kind
            && pair[0].width == pair[1].width
            && pair[0].widths == pair[1].widths
            && pair[0].style == pair[1].style
            && pair[0].cap_start == pair[1].cap_start
            && pair[0].cap_end == pair[1].cap_end
    })
}

fn render_merged(
    render_state: &mut RenderState,
    shape: &Shape,
    strokes: &[&Stroke],
    surface_id: Option<SurfaceId>,
    antialias: bool,
    bypass_filter: bool,
    outset: Option<f32>,
) -> Result<()> {
    let representative = *strokes
        .last()
        .expect("render_merged expects at least one stroke");

    let blur_filter = if bypass_filter {
        None
    } else {
        shape.image_filter(1.)
    };

    // Handle blur filter
    if !bypass_filter {
        if let Some(image_filter) = blur_filter.clone() {
            let mut content_bounds = shape.selrect;
            // Expand for outset if provided
            if let Some(s) = outset.filter(|&s| s > 0.0) {
                content_bounds.outset((s, s));
            }
            let stroke_margin = representative.bounds_width(shape.is_open());
            if stroke_margin > 0.0 {
                content_bounds.inset((-stroke_margin, -stroke_margin));
            }
            let cap_margin = representative.cap_bounds_margin();
            if cap_margin > 0.0 {
                content_bounds.inset((-cap_margin, -cap_margin));
            }
            let bounds = image_filter.compute_fast_bounds(content_bounds);
            let target = surface_id.unwrap_or(SurfaceId::Strokes);
            if filters::render_with_filter_surface(
                render_state,
                bounds,
                target,
                |state, temp_surface| {
                    let blur_filter = image_filter.clone();

                    state.surfaces.apply_mut(temp_surface as u32, |surface| {
                        let canvas = surface.canvas();
                        let mut blur_paint = skia::Paint::default();
                        blur_paint.set_image_filter(blur_filter.clone());
                        let layer_rec = skia::canvas::SaveLayerRec::default().paint(&blur_paint);
                        canvas.save_layer(&layer_rec);
                    });

                    render_merged(
                        state,
                        shape,
                        strokes,
                        Some(temp_surface),
                        antialias,
                        true,
                        outset,
                    )?;

                    state.surfaces.apply_mut(temp_surface as u32, |surface| {
                        surface.canvas().restore();
                    });
                    Ok(())
                },
            )? {
                return Ok(());
            }
        }
    }

    // `merge_fills` puts fills[0] on top (each new fill goes under the accumulated shader
    // via SrcOver), matching the non-merged path where strokes[0] is drawn last (on top).
    let fills: Vec<Fill> = strokes.iter().map(|s| s.fill.clone()).collect();

    // Expand selrect if outset is provided
    let selrect = if let Some(s) = outset.filter(|&s| s > 0.0) {
        let mut r = shape.selrect;
        r.outset((s, s));
        r
    } else {
        shape.selrect
    };

    let merged = merge_fills(&fills, selrect);
    let scale = render_state.get_scale();
    let target_surface = surface_id.unwrap_or(SurfaceId::Strokes);
    let canvas = render_state.surfaces.canvas_and_mark_dirty(target_surface);
    let svg_attrs = shape.svg_attrs.as_ref();
    let path_transform = shape.to_path_transform();

    match &shape.shape_type {
        shape_type @ (Type::Rect(_) | Type::Frame(_)) => {
            let mut paint = representative.to_paint(&selrect, svg_attrs, antialias);
            paint.set_shader(merged.shader());
            draw_stroke_on_rect(
                canvas,
                representative,
                &selrect,
                &shape_type.corners(),
                &paint,
                scale,
                None,
                blur_filter.as_ref(),
                Stroke::per_side_profile(shape.visible_strokes()),
                antialias,
            );
        }
        Type::Circle => {
            let mut paint = representative.to_paint(&selrect, svg_attrs, antialias);
            paint.set_shader(merged.shader());
            draw_stroke_on_circle(
                canvas,
                representative,
                &selrect,
                &paint,
                scale,
                None,
                blur_filter.as_ref(),
                antialias,
            );
        }
        Type::Text(_) => {}
        shape_type @ (Type::Path(_) | Type::Bool(_)) => {
            if let Some(path) = shape_type.path() {
                let is_open = path.is_open();
                let lod_stroke = representative.path_lod_at_scale(is_open, scale);
                let mut paint =
                    lod_stroke.to_stroked_paint(is_open, &selrect, svg_attrs, antialias);
                paint.set_shader(merged.shader());
                draw_stroke_on_path(
                    canvas,
                    &lod_stroke,
                    path,
                    &paint,
                    path_transform.as_ref(),
                    None,
                    blur_filter.as_ref(),
                    svg_attrs,
                    antialias,
                );
            }
        }
        _ => unreachable!("This shape should not have strokes"),
    }
    Ok(())
}

/// Renders a single stroke. Used by the shadow module which needs per-stroke
/// shadow filters.
#[allow(clippy::too_many_arguments)]
pub fn render_single(
    render_state: &mut RenderState,
    shape: &Shape,
    stroke: &Stroke,
    surface_id: Option<SurfaceId>,
    shadow: Option<&ImageFilter>,
    antialias: bool,
    outset: Option<f32>,
) -> Result<()> {
    render_single_internal(
        render_state,
        shape,
        stroke,
        surface_id,
        shadow,
        antialias,
        false,
        false,
        outset,
    )
}

#[allow(clippy::too_many_arguments)]
fn render_single_internal(
    render_state: &mut RenderState,
    shape: &Shape,
    stroke: &Stroke,
    surface_id: Option<SurfaceId>,
    shadow: Option<&ImageFilter>,
    antialias: bool,
    bypass_filter: bool,
    skip_blur: bool,
    outset: Option<f32>,
) -> Result<()> {
    if !bypass_filter {
        if let Some(image_filter) = shape.image_filter(1.) {
            let mut content_bounds = shape.selrect;
            // Expand for outset if provided
            if let Some(s) = outset.filter(|&s| s > 0.0) {
                content_bounds.outset((s, s));
            }
            let stroke_margin = stroke.bounds_width(shape.is_open());
            if stroke_margin > 0.0 {
                content_bounds.inset((-stroke_margin, -stroke_margin));
            }
            let cap_margin = stroke.cap_bounds_margin();
            if cap_margin > 0.0 {
                content_bounds.inset((-cap_margin, -cap_margin));
            }
            let bounds = image_filter.compute_fast_bounds(content_bounds);

            let target = surface_id.unwrap_or(SurfaceId::Strokes);
            if filters::render_with_filter_surface(
                render_state,
                bounds,
                target,
                |state, temp_surface| {
                    render_single_internal(
                        state,
                        shape,
                        stroke,
                        Some(temp_surface),
                        shadow,
                        antialias,
                        true,
                        true,
                        outset,
                    )
                },
            )? {
                return Ok(());
            }
        }
    }

    let scale = render_state.get_scale();
    let target_surface = surface_id.unwrap_or(SurfaceId::Strokes);
    let canvas = render_state.surfaces.canvas_and_mark_dirty(target_surface);
    let selrect = shape.selrect;
    let path_transform = shape.to_path_transform();
    let svg_attrs = shape.svg_attrs.as_ref();

    let blur = if skip_blur {
        None
    } else {
        shape.image_filter(1.)
    };

    if !matches!(shape.shape_type, Type::Text(_))
        && shadow.is_none()
        && matches!(stroke.fill, Fill::Image(_))
    {
        if let Fill::Image(image_fill) = &stroke.fill {
            draw_image_stroke_in_container(
                render_state,
                shape,
                stroke,
                image_fill,
                antialias,
                target_surface,
            )?;
        }
    } else {
        match &shape.shape_type {
            shape_type @ (Type::Rect(_) | Type::Frame(_)) => {
                let paint = stroke.to_paint(&selrect, svg_attrs, antialias);
                draw_stroke_on_rect(
                    canvas,
                    stroke,
                    &selrect,
                    &shape_type.corners(),
                    &paint,
                    scale,
                    shadow,
                    blur.as_ref(),
                    Stroke::per_side_profile(shape.visible_strokes()),
                    antialias,
                );
            }
            Type::Circle => {
                let paint = stroke.to_paint(&selrect, svg_attrs, antialias);
                draw_stroke_on_circle(
                    canvas,
                    stroke,
                    &selrect,
                    &paint,
                    scale,
                    shadow,
                    blur.as_ref(),
                    antialias,
                );
            }
            Type::Text(_) => {}
            shape_type @ (Type::Path(_) | Type::Bool(_)) => {
                if let Some(path) = shape_type.path() {
                    let is_open = path.is_open();
                    let lod_stroke = stroke.path_lod_at_scale(is_open, scale);
                    let stroke = &lod_stroke;
                    let mut paint =
                        stroke.to_stroked_paint(is_open, &selrect, svg_attrs, antialias);
                    // Apply outset by increasing stroke width
                    if let Some(s) = outset.filter(|&s| s > 0.0) {
                        let current_width = paint.stroke_width();
                        // Path stroke kinds are built differently:
                        // - Center uses the stroke width directly.
                        // - Inner/Outer use a doubled width plus clipping/clearing logic.
                        // Compensate outset so visual growth is comparable across kinds.
                        let outset_growth = match stroke.render_kind(is_open) {
                            StrokeKind::Center => s * 2.0,
                            StrokeKind::Inner | StrokeKind::Outer => s * 4.0,
                        };
                        paint.set_stroke_width(current_width + outset_growth);
                    }
                    draw_stroke_on_path(
                        canvas,
                        stroke,
                        path,
                        &paint,
                        path_transform.as_ref(),
                        shadow,
                        blur.as_ref(),
                        svg_attrs,
                        antialias,
                    );
                }
            }
            _ => unreachable!("This shape should not have strokes"),
        }
    }
    Ok(())
}

// Render text paths (unused)
#[allow(dead_code)]
pub fn render_text_paths(
    render_state: &mut RenderState,
    shape: &Shape,
    stroke: &Stroke,
    paths: &Vec<(skia::Path, skia::Paint)>,
    surface_id: Option<SurfaceId>,
    shadow: Option<&ImageFilter>,
    antialias: bool,
) {
    let canvas = render_state
        .surfaces
        .canvas_and_mark_dirty(surface_id.unwrap_or(SurfaceId::Strokes));
    let selrect = &shape.selrect;
    let svg_attrs = shape.svg_attrs.as_ref();
    let mut paint: skia_safe::Handle<_> =
        stroke.to_text_stroked_paint(false, selrect, svg_attrs, antialias);

    if let Some(filter) = shadow {
        paint.set_image_filter(filter.clone());
    }

    match stroke.render_kind(false) {
        StrokeKind::Inner => {
            for (path, _) in paths {
                draw_inner_stroke_path(canvas, path, &paint, None, antialias);
            }
        }
        StrokeKind::Center => {
            for (path, _) in paths {
                canvas.draw_path(path, &paint);
            }
        }
        StrokeKind::Outer => {
            for (path, _) in paths {
                draw_outer_stroke_path(canvas, path, &paint, None, antialias);
            }
        }
    }
}

#[cfg(test)]
mod per_side_tests {
    use super::*;
    use crate::shapes::StrokeStyle;

    /// Outer-aligned radii for a 220x140 rect, radius 20, widths [10, 20, 15, 5]:
    /// each corner grows by its two adjacent widths, so they are wider than tall.
    fn outer_radii() -> Corners {
        [
            skia::Point::new(25.0, 30.0),
            skia::Point::new(40.0, 30.0),
            skia::Point::new(40.0, 35.0),
            skia::Point::new(25.0, 35.0),
        ]
    }

    /// Reads a wedge path back as a flat list of points.
    fn wedge_points(path: &skia::Path) -> Vec<(f32, f32)> {
        path.points().iter().map(|p| (p.x, p.y)).collect()
    }

    #[test]
    fn a_wedge_reads_the_radius_along_the_side_it_runs_on() {
        // The outer rect for an outer-aligned stroke: each edge pushed out by
        // that side's width.
        let outer = Rect::from_ltrb(-5.0, -10.0, 240.0, 155.0);
        let profile = [10.0, 20.0, 15.0, 5.0];

        // Only the right side is painted, as one stroke of a per-side colour set.
        let wedge = side_wedges(&outer, Some(outer_radii()), profile, [0.0, 20.0, 0.0, 0.0])
            .expect("the right side is painted, so it gets a wedge");

        // The corner ellipses are 40 wide and 30/35 tall, and a vertical side
        // reads the tall one, so the wedge meets the top edge at the corner.
        assert_eq!(
            wedge_points(&wedge),
            vec![(240.0, 0.0), (240.0, 150.0), (180.0, 105.0), (180.0, 30.0),]
        );
    }

    /// Whether `point` sits on the infinite line through `a` and `b`.
    fn on_line(a: (f32, f32), b: (f32, f32), point: (f32, f32)) -> bool {
        let cross = (b.0 - a.0) * (point.1 - a.1) - (b.1 - a.1) * (point.0 - a.0);
        cross.abs() < 1e-3
    }

    #[test]
    fn adjacent_wedges_share_one_miter_line() {
        let outer = Rect::from_ltrb(-5.0, -10.0, 240.0, 155.0);
        let profile = [10.0, 20.0, 15.0, 5.0];
        let radii = Some(outer_radii());

        let top = wedge_points(
            &side_wedges(&outer, radii, profile, [10.0, 0.0, 0.0, 0.0]).expect("top wedge"),
        );
        let right = wedge_points(
            &side_wedges(&outer, radii, profile, [0.0, 20.0, 0.0, 0.0]).expect("right wedge"),
        );

        // Both edges facing the top-right corner run through its centre of
        // curvature, so the two sides abut with neither a gap nor an overlap.
        let centre = (240.0 - 40.0, -10.0 + 30.0);
        assert!(on_line(top[1], top[2], centre), "top edge missed: {top:?}");
        assert!(
            on_line(right[0], right[3], centre),
            "right edge missed: {right:?}"
        );
        // And they are the same line, not merely two lines through one point.
        assert!(
            on_line(top[1], top[2], right[0]),
            "not collinear: {right:?}"
        );
    }

    /// Inner-aligned pattern for a 235x175 rect with a nominal 30/30 dash:
    /// neither side holds whole periods, so each stretches by its own amount.
    fn dashed_pattern() -> skia::Path {
        let rect = Rect::from_ltrb(0.0, 0.0, 235.0, 175.0);
        let widths = [16.0, 16.0, 16.0, 24.0];
        let mut stroke = Stroke::new_inner_stroke(
            16.0,
            StrokeStyle::Dashed,
            None,
            None,
            Some(30.0),
            Some(30.0),
        );
        stroke.widths = Some(widths);
        let inner = Rect::from_ltrb(24.0, 16.0, 235.0 - 16.0, 175.0 - 16.0);
        expand_side_patterns(
            &stroke,
            StrokeStyle::Dashed,
            &rect,
            &rect,
            &inner,
            None,
            widths,
            true,
        )
        .expect("dashed sides must produce a pattern")
    }

    #[test]
    fn each_side_starts_and_ends_on_a_dash() {
        let pattern = dashed_pattern();

        // Top side, over x. Sampled clear of the left and right strips so the
        // reading is the top side's own pattern.
        assert!(pattern.contains((30.0, 8.0)), "top must open with a dash");
        assert!(pattern.contains((210.0, 8.0)), "top must close with a dash");

        // Right side, over y, at the vertical stroke line (235 - 16 / 2).
        assert!(
            pattern.contains((227.0, 30.0)),
            "right must open with a dash"
        );
        assert!(
            pattern.contains((227.0, 145.0)),
            "right must close with a dash"
        );
    }

    #[test]
    fn sides_keep_their_own_gaps() {
        let pattern = dashed_pattern();
        // 235 stretches to 4 dashes of 33.57: the first gap is 33.57..67.14.
        assert!(!pattern.contains((50.0, 8.0)), "top gap was filled");
        // 175 stretches to 3 dashes of 35: the first gap is 35..70.
        assert!(!pattern.contains((227.0, 50.0)), "right gap was filled");
    }
}