rizzma 1.14.1

//! The [`Line2D`] artist: a stroked polyline through `(x, y)` data points.
//!
//! Mirrors matplotlib's `Line2D` for the stroke-only case (markers are deferred
//! to a follow-up). Drawing zips the `x`/`y` data into points, builds a
//! [`Path`] via [`Line2D::path`] — one subpath per run of finite points, so a
//! `NaN` is a gap in the stroke rather than a joined vertex — and strokes it
//! through the [`Renderer`].

use crate::core::{Affine2D, Bbox, Path, PathCode, PathSegment, color::Rgba};
use crate::render::{CapStyle, GraphicsContext, JoinStyle, Renderer};

use crate::artist::marker::Snap;
use crate::artist::{Artist, MarkerStyle};

/// A 2D line: a stroked polyline through paired `x`/`y` data.
///
/// Constructed with [`Line2D::new`], then customized either with the
/// consuming `with_*` builders (`Line2D::new(x, y).with_color(c)`) or, on a
/// line that already lives on an axes, with the `&mut self` `set_*` setters
/// (`ax.plot(&x, &y).set_color(c)`). Each `with_*` delegates to its `set_*`
/// twin, so the two families are always in sync. The defaults mirror
/// matplotlib: opaque black, `1.5`-point width, butt caps, miter joins,
/// visible, and zorder `2.0`.
#[derive(Debug, Clone, PartialEq)]
pub struct Line2D {
    /// X coordinates of the data points, in data space.
    xdata: Vec<f64>,
    /// Y coordinates of the data points, in data space.
    ydata: Vec<f64>,
    /// Stroke color.
    color: Rgba,
    /// Stroke width in points.
    linewidth: f64,
    /// Optional dash pattern as `(offset, on_off_lengths)` in points.
    dashes: Option<(f64, Vec<f64>)>,
    /// Cap style of a solid line's ends; `None` until set, or resolved from
    /// the axes' rc as the line is added.
    cap: Option<CapStyle>,
    /// Join style of a solid line's corners; `None` as for `cap`.
    join: Option<JoinStyle>,
    /// Cap style of a dashed line's dashes; `None` as for `cap`.
    dash_cap: Option<CapStyle>,
    /// Join style of a dashed line's corners; `None` as for `cap`.
    dash_join: Option<JoinStyle>,
    /// Whether the line is drawn.
    visible: bool,
    /// Stacking order; higher draws on top.
    zorder: f64,
    /// Legend label, collected by
    /// [`Axes::legend_auto`](crate::figure::Axes::legend_auto); `None` for an
    /// anonymous line.
    label: Option<String>,
    /// The markers drawn at the data points, if any (matplotlib's `"o-"`).
    marker: Option<LineMarker>,
}

/// The markers a [`Line2D`] draws at its data points: matplotlib's `marker`,
/// `markersize`, `markerfacecolor`, `markeredgecolor`, `markeredgewidth`
/// and `markevery`.
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct LineMarker {
    /// The matplotlib marker code (`'o'`, `'s'`, `'^'`, `'x'`, …).
    pub(crate) code: char,
    /// Marker diameter in points.
    pub(crate) size: f64,
    /// Face color; `None` follows the line color.
    pub(crate) face: Option<Rgba>,
    /// Edge color; `None` follows the line color.
    pub(crate) edge: Option<Rgba>,
    /// Edge width in points.
    pub(crate) edge_width: f64,
    /// Mark every `every`-th point, starting with the first.
    pub(crate) every: usize,
}

/// matplotlib's `lines.markersize`, in points.
const DEFAULT_MARKER_SIZE: f64 = 6.0;
/// matplotlib's `lines.markeredgewidth`, in points.
const DEFAULT_MARKER_EDGE_WIDTH: f64 = 1.0;

impl LineMarker {
    /// The marker `code` at matplotlib's default size and edge width, colored
    /// like its line; `None` for an unknown code.
    fn new(code: char) -> Option<Self> {
        MarkerStyle::from_char(code)?;
        Some(Self {
            code,
            size: DEFAULT_MARKER_SIZE,
            face: None,
            edge: None,
            edge_width: DEFAULT_MARKER_EDGE_WIDTH,
            every: 1,
        })
    }

    /// This marker as read from a portable figure, refused when its code is
    /// unknown or its size, edge width or spacing is not drawable.
    #[cfg(feature = "portable")]
    pub(crate) fn validated(self) -> Result<Self, crate::portable::PortableError> {
        let drawable = MarkerStyle::from_char(self.code).is_some()
            && self.size.is_finite()
            && self.size >= 0.0
            && self.edge_width.is_finite()
            && self.edge_width >= 0.0
            && self.every >= 1;
        if drawable {
            Ok(self)
        } else {
            Err(crate::portable::PortableError::Malformed(format!(
                "line marker {:?} is not drawable",
                self.code
            )))
        }
    }

    /// Stamp the marker at each of `points` (device pixels, y-up) for a line
    /// of `color`, with the marker's join and, for the raster backend, its
    /// snap threshold, as matplotlib's `Line2D` hands them to
    /// `draw_markers`. The pixel marker (`','`) is one unstroked pixel at any
    /// size.
    pub(crate) fn draw(&self, renderer: &mut dyn Renderer, points: &[[f64; 2]], color: Rgba) {
        let Some(style) = MarkerStyle::from_char(self.code) else {
            return;
        };
        let pixel = self.code == ',';
        let size = if pixel {
            1.0
        } else {
            renderer.points_to_pixels(self.size)
        };
        let edge_width = if pixel { 0.0 } else { self.edge_width };
        let marker = style.scaled(size);
        let points: Vec<[f64; 2]> = points
            .iter()
            .copied()
            .filter(|[x, y]| x.is_finite() && y.is_finite())
            .collect();
        if points.is_empty() {
            return;
        }
        // Agg strokes markers with a miter limit of the edge width in pixels,
        // so sharp mitered corners fall back to bevels. Curves and lines
        // have no corners for it to act on.
        let curved = marker
            .iter_segments()
            .any(|s| matches!(s, PathSegment::Quad(..) | PathSegment::Cubic(..)));
        let corners = style.join() == JoinStyle::Miter && !curved;
        let gc = GraphicsContext {
            line_width: edge_width,
            stroke: Some(self.edge.unwrap_or(color)),
            join: style.join(),
            miter_limit: corners.then(|| renderer.points_to_pixels(edge_width)),
            snap: match style.snap() {
                Snap::From(threshold) => Some(size >= threshold),
                Snap::Auto => None,
            },
            ..GraphicsContext::new()
        };
        let face = style.is_filled().then(|| self.face.unwrap_or(color));
        renderer.draw_markers(
            &gc,
            &marker,
            &Affine2D::identity(),
            &Path::from_polyline(&points),
            &Affine2D::identity(),
            face,
        );
    }
}

/// The cap and join styles new lines take, solid and dashed: matplotlib's
/// `lines.solid_capstyle`, `lines.solid_joinstyle`, `lines.dash_capstyle`
/// and `lines.dash_joinstyle`.
#[derive(Debug, Clone, Copy, PartialEq)]
pub(crate) struct LineStyles {
    pub(crate) cap: CapStyle,
    pub(crate) join: JoinStyle,
    pub(crate) dash_cap: CapStyle,
    pub(crate) dash_join: JoinStyle,
}

impl LineStyles {
    /// The styles `rc` gives new lines.
    pub(crate) fn from_rc(rc: &crate::core::RcParams) -> Self {
        Self {
            cap: rc.lines_solid_capstyle,
            join: rc.lines_solid_joinstyle,
            dash_cap: rc.lines_dash_capstyle,
            dash_join: rc.lines_dash_joinstyle,
        }
    }
}

impl Default for LineStyles {
    /// matplotlib's defaults: projecting caps and round joins when solid,
    /// butt caps and round joins when dashed.
    fn default() -> Self {
        Self {
            cap: CapStyle::Projecting,
            join: JoinStyle::Round,
            dash_cap: CapStyle::Butt,
            dash_join: JoinStyle::Round,
        }
    }
}

impl Line2D {
    /// Construct a [`Line2D`] from `xdata` and `ydata` with matplotlib-ish
    /// defaults: opaque black, `1.5`-point width, visible, and zorder `2.0`.
    /// Caps and joins follow the rc of the axes the line is added to
    /// (matplotlib's `lines.solid_capstyle` and friends: projecting caps and
    /// round joins when solid, butt caps and round joins when dashed).
    ///
    /// The `x` and `y` vectors are paired index-wise at draw time; only the
    /// common prefix is drawn if they differ in length. A non-finite `x` or `y`
    /// (`NaN`, `±inf`) breaks the stroke: the points before and after it are
    /// not joined, matplotlib's idiom for a series with missing samples.
    #[must_use]
    pub fn new(xdata: Vec<f64>, ydata: Vec<f64>) -> Self {
        Self {
            xdata,
            ydata,
            color: Rgba::BLACK,
            linewidth: 1.5,
            dashes: None,
            cap: None,
            join: None,
            dash_cap: None,
            dash_join: None,
            visible: true,
            zorder: 2.0,
            label: None,
            marker: None,
        }
    }

    /// The legend label, if any.
    #[must_use]
    pub fn label(&self) -> Option<&str> {
        self.label.as_deref()
    }

    /// The stroke color.
    #[must_use]
    pub fn color(&self) -> Rgba {
        self.color
    }

    /// Replace the line's data in place (for live/streaming updates), keeping
    /// every style property. The `x` and `y` slices are paired index-wise at
    /// draw time exactly as at construction.
    pub fn set_data(&mut self, x: &[f64], y: &[f64]) -> &mut Self {
        self.xdata = x.to_vec();
        self.ydata = y.to_vec();
        self
    }

    /// Set the stroke color in place.
    pub fn set_color(&mut self, color: Rgba) -> &mut Self {
        self.color = color;
        self
    }

    /// Set the stroke width in points in place.
    pub fn set_linewidth(&mut self, linewidth: f64) -> &mut Self {
        self.linewidth = linewidth;
        self
    }

    /// Set the dash pattern as `(offset, on_off_lengths)` in points in place;
    /// `None` draws a solid stroke.
    pub fn set_dashes(&mut self, dashes: Option<(f64, Vec<f64>)>) -> &mut Self {
        self.dashes = dashes;
        self
    }

    /// Set the cap style of the line's ends and dashes, solid or dashed, in
    /// place.
    pub fn set_cap(&mut self, cap: CapStyle) -> &mut Self {
        self.cap = Some(cap);
        self.dash_cap = Some(cap);
        self
    }

    /// Set the join style of the line's corners, solid or dashed, in place.
    pub fn set_join(&mut self, join: JoinStyle) -> &mut Self {
        self.join = Some(join);
        self.dash_join = Some(join);
        self
    }

    /// Set the cap style used while the line is solid, in place
    /// (matplotlib's `set_solid_capstyle`).
    pub fn set_solid_capstyle(&mut self, cap: CapStyle) -> &mut Self {
        self.cap = Some(cap);
        self
    }

    /// Set the join style used while the line is solid, in place
    /// (matplotlib's `set_solid_joinstyle`).
    pub fn set_solid_joinstyle(&mut self, join: JoinStyle) -> &mut Self {
        self.join = Some(join);
        self
    }

    /// Set the cap style used while the line is dashed, in place
    /// (matplotlib's `set_dash_capstyle`).
    pub fn set_dash_capstyle(&mut self, cap: CapStyle) -> &mut Self {
        self.dash_cap = Some(cap);
        self
    }

    /// Set the join style used while the line is dashed, in place
    /// (matplotlib's `set_dash_joinstyle`).
    pub fn set_dash_joinstyle(&mut self, join: JoinStyle) -> &mut Self {
        self.dash_join = Some(join);
        self
    }

    /// Stroke dashes with the solid cap and join, as every line did before
    /// schema 21 kept them apart.
    #[cfg(feature = "portable")]
    pub(crate) fn dash_like_solid(&mut self) {
        self.dash_cap = self.cap;
        self.dash_join = self.join;
    }

    /// Give every cap and join style not yet set the value `styles` gives it.
    pub(crate) fn resolve_styles(&mut self, styles: &LineStyles) {
        self.cap.get_or_insert(styles.cap);
        self.join.get_or_insert(styles.join);
        self.dash_cap.get_or_insert(styles.dash_cap);
        self.dash_join.get_or_insert(styles.dash_join);
    }

    /// The cap and join the line strokes with now: the dashed pair while it
    /// has a dash pattern, the solid pair otherwise, matplotlib's defaults
    /// for any unset.
    fn cap_join(&self) -> (CapStyle, JoinStyle) {
        let defaults = LineStyles::default();
        if self.dashes.as_ref().is_some_and(|(_, p)| !p.is_empty()) {
            (
                self.dash_cap.unwrap_or(defaults.dash_cap),
                self.dash_join.unwrap_or(defaults.dash_join),
            )
        } else {
            (
                self.cap.unwrap_or(defaults.cap),
                self.join.unwrap_or(defaults.join),
            )
        }
    }

    /// Show or hide the line in place.
    pub fn set_visible(&mut self, visible: bool) -> &mut Self {
        self.visible = visible;
        self
    }

    /// Set the stacking order in place; higher draws on top.
    pub fn set_zorder(&mut self, zorder: f64) -> &mut Self {
        self.zorder = zorder;
        self
    }

    /// Set the legend label in place. Labels are collected by
    /// [`Axes::legend_auto`](crate::figure::Axes::legend_auto); a label
    /// starting with `_` is kept on the line but never shown in a legend, as
    /// in matplotlib.
    pub fn set_label(&mut self, label: impl Into<String>) -> &mut Self {
        self.label = Some(label.into());
        self
    }

    /// Set the stroke color, returning `self` for chaining.
    #[must_use]
    pub fn with_color(mut self, color: Rgba) -> Self {
        self.set_color(color);
        self
    }

    /// Set the stroke width in points, returning `self` for chaining.
    #[must_use]
    pub fn with_linewidth(mut self, linewidth: f64) -> Self {
        self.set_linewidth(linewidth);
        self
    }

    /// Set the dash pattern as `(offset, on_off_lengths)` in points, returning
    /// `self` for chaining.
    #[must_use]
    pub fn with_dashes(mut self, dashes: Option<(f64, Vec<f64>)>) -> Self {
        self.set_dashes(dashes);
        self
    }

    /// Set the line cap style, returning `self` for chaining.
    #[must_use]
    pub fn with_cap(mut self, cap: CapStyle) -> Self {
        self.set_cap(cap);
        self
    }

    /// Set the line join style, returning `self` for chaining.
    #[must_use]
    pub fn with_join(mut self, join: JoinStyle) -> Self {
        self.set_join(join);
        self
    }

    /// Set whether the line is drawn, returning `self` for chaining.
    #[must_use]
    pub fn with_visible(mut self, visible: bool) -> Self {
        self.set_visible(visible);
        self
    }

    /// Set the stacking order, returning `self` for chaining.
    #[must_use]
    pub fn with_zorder(mut self, zorder: f64) -> Self {
        self.set_zorder(zorder);
        self
    }

    /// Set the legend label, returning `self` for chaining; see
    /// [`set_label`](Line2D::set_label).
    #[must_use]
    pub fn with_label(mut self, label: impl Into<String>) -> Self {
        self.set_label(label);
        self
    }

    /// Draw a marker at every data point: matplotlib's `plot(x, y, "o-")`.
    /// `code` is a matplotlib marker code (`"o"`, `"s"`, `"^"`, `"D"`,
    /// `"x"`, `"+"`, `"*"`, …); an unknown code, or `""`, removes the markers.
    /// They are 6 points across and colored like the line until restyled,
    /// and a legend sample shows one in the middle of its line.
    ///
    /// ![line markers](https://raw.githubusercontent.com/OrbitalCommons/rizzma/gh-pages/gallery_line_markers.png)
    ///
    /// ```
    /// use rizzma::Figure;
    ///
    /// let mut fig = Figure::new(4.0, 3.0);
    /// let ax = fig.add_subplot(1, 1, 1);
    /// ax.plot(&[1.0, 2.0, 3.0, 4.0], &[1.0, 3.0, 2.0, 4.0])
    ///     .set_marker("o")
    ///     .set_label("measured");
    /// ax.legend_auto();
    /// assert!(!fig.encode_png().unwrap().is_empty());
    /// ```
    pub fn set_marker(&mut self, code: &str) -> &mut Self {
        let mut chars = code.chars();
        self.marker = match (chars.next(), chars.next()) {
            (Some(c), None) => LineMarker::new(c).map(|new| match self.marker.take() {
                Some(old) => LineMarker { code: c, ..old },
                None => new,
            }),
            _ => None,
        };
        self
    }

    /// Draw markers at the data points, returning `self`; see
    /// [`set_marker`](Line2D::set_marker).
    #[must_use]
    pub fn with_marker(mut self, code: &str) -> Self {
        self.set_marker(code);
        self
    }

    /// The marker code, if the line draws markers.
    #[must_use]
    pub fn marker(&self) -> Option<char> {
        self.marker.as_ref().map(|m| m.code)
    }

    /// Set the marker diameter in points (matplotlib's `markersize`,
    /// default 6). Takes effect once a marker is set.
    pub fn set_markersize(&mut self, size: f64) -> &mut Self {
        if let Some(marker) = &mut self.marker {
            marker.size = size;
        }
        self
    }

    /// Set the marker fill color (matplotlib's `markerfacecolor`; the line
    /// color by default). Takes effect once a marker is set.
    pub fn set_markerfacecolor(&mut self, color: Rgba) -> &mut Self {
        if let Some(marker) = &mut self.marker {
            marker.face = Some(color);
        }
        self
    }

    /// Set the marker edge color (matplotlib's `markeredgecolor`; the line
    /// color by default). Takes effect once a marker is set.
    pub fn set_markeredgecolor(&mut self, color: Rgba) -> &mut Self {
        if let Some(marker) = &mut self.marker {
            marker.edge = Some(color);
        }
        self
    }

    /// Set the marker edge width in points (matplotlib's `markeredgewidth`,
    /// default 1). Takes effect once a marker is set.
    pub fn set_markeredgewidth(&mut self, width: f64) -> &mut Self {
        if let Some(marker) = &mut self.marker {
            marker.edge_width = width;
        }
        self
    }

    /// Mark only every `n`-th point, starting with the first (matplotlib's
    /// integer `markevery`; `0` and `1` mark every point). Takes effect once
    /// a marker is set.
    pub fn set_markevery(&mut self, n: usize) -> &mut Self {
        if let Some(marker) = &mut self.marker {
            marker.every = n.max(1);
        }
        self
    }

    /// The line's marker, for its legend sample and portable form.
    pub(crate) fn line_marker(&self) -> Option<&LineMarker> {
        self.marker.as_ref()
    }

    /// Draw the line's markers, each data point passed through `map` (an
    /// axes' scales) and then `transform`.
    pub(crate) fn draw_markers_mapped(
        &self,
        renderer: &mut dyn Renderer,
        transform: &Affine2D,
        map: &dyn Fn(f64, f64) -> [f64; 2],
    ) {
        let Some(marker) = self.marker.as_ref().filter(|_| self.visible) else {
            return;
        };
        let points: Vec<[f64; 2]> = self
            .xdata
            .iter()
            .zip(&self.ydata)
            .step_by(marker.every)
            .map(|(&x, &y)| {
                let [sx, sy] = map(x, y);
                let (dx, dy) = transform.transform_point((sx, sy));
                [dx, dy]
            })
            .collect();
        marker.draw(renderer, &points, self.color);
    }

    /// The `(x, y)` data points zipped into a `Vec<[f64; 2]>`.
    #[must_use]
    pub fn points(&self) -> Vec<[f64; 2]> {
        self.xdata
            .iter()
            .zip(self.ydata.iter())
            .map(|(&x, &y)| [x, y])
            .collect()
    }

    /// The data-space stroke path: one subpath per run of two or more
    /// consecutive finite points.
    ///
    /// A non-finite `x` or `y` ends the current run without adding a vertex,
    /// so the stroke lifts across the gap instead of joining its neighbours
    /// (matplotlib treats `NaN` as a break). Isolated finite points between
    /// gaps have no stroke and are dropped. Without gaps the result is the
    /// plain implicit polyline (`codes` is `None`); with gaps every vertex is
    /// coded, each run opening with a [`PathCode::MoveTo`].
    #[must_use]
    pub fn path(&self) -> Path {
        let points = self.points();
        if points.iter().all(|[x, y]| x.is_finite() && y.is_finite()) {
            return Path::from_polyline(&points);
        }

        let mut vertices: Vec<[f64; 2]> = Vec::with_capacity(points.len());
        let mut codes: Vec<PathCode> = Vec::with_capacity(points.len());
        for run in points
            .split(|[x, y]| !x.is_finite() || !y.is_finite())
            .filter(|run| run.len() >= 2)
        {
            vertices.extend_from_slice(run);
            codes.push(PathCode::MoveTo);
            codes.extend(std::iter::repeat_n(PathCode::LineTo, run.len() - 1));
        }
        Path::new(vertices, Some(codes))
    }

    /// Draw this line's stroke style against an already-built data-space path.
    ///
    /// This lets an owning axes pre-transform nonlinear-scale geometry while
    /// reusing the line's color, width, dash, cap, and join settings.
    pub fn draw_path(&self, renderer: &mut dyn Renderer, path: &Path, transform: &Affine2D) {
        if !self.visible || path.vertices().len() < 2 {
            return;
        }
        let (cap, join) = self.cap_join();
        let gc = GraphicsContext {
            line_width: self.linewidth,
            dashes: self.dashes.clone(),
            cap,
            join,
            stroke: Some(self.color),
            ..GraphicsContext::new()
        };
        renderer.draw_path(&gc, path, transform, None);
    }
}

impl Artist for Line2D {
    fn draw(&self, renderer: &mut dyn Renderer, transform: &Affine2D) {
        if !self.visible {
            return;
        }
        self.draw_path(renderer, &self.path(), transform);
        self.draw_markers_mapped(renderer, transform, &|x, y| [x, y]);
    }

    fn zorder(&self) -> f64 {
        self.zorder
    }

    fn visible(&self) -> bool {
        self.visible
    }

    fn data_extents(&self) -> Option<Bbox> {
        let mut xmin = f64::INFINITY;
        let mut ymin = f64::INFINITY;
        let mut xmax = f64::NEG_INFINITY;
        let mut ymax = f64::NEG_INFINITY;
        let mut any = false;
        for (&x, &y) in self.xdata.iter().zip(self.ydata.iter()) {
            if !x.is_finite() || !y.is_finite() {
                continue;
            }
            xmin = xmin.min(x);
            ymin = ymin.min(y);
            xmax = xmax.max(x);
            ymax = ymax.max(y);
            any = true;
        }
        if any {
            Some(Bbox::from_extents(xmin, ymin, xmax, ymax))
        } else {
            None
        }
    }
}

#[cfg(feature = "portable")]
impl Line2D {
    /// Flatten this line into its wire form, banking the data as accessors.
    pub(crate) fn to_portable(
        &self,
        bank: &mut crate::portable::data::BankWriter,
    ) -> crate::portable::spec::LineSpec {
        let defaults = LineStyles::default();
        let cap = self.cap.unwrap_or(defaults.cap);
        let join = self.join.unwrap_or(defaults.join);
        let dash_cap = self.dash_cap.unwrap_or(defaults.dash_cap);
        let dash_join = self.dash_join.unwrap_or(defaults.dash_join);
        crate::portable::spec::LineSpec {
            x: bank.push_f64(&self.xdata),
            y: bank.push_f64(&self.ydata),
            color: self.color,
            linewidth: self.linewidth,
            dashes: self.dashes.clone(),
            cap,
            join,
            dash_cap: (dash_cap != defaults.dash_cap).then_some(dash_cap),
            dash_join: (dash_join != defaults.dash_join).then_some(dash_join),
            visible: self.visible,
            zorder: self.zorder,
            label: self.label.clone(),
            marker: self.marker.clone(),
        }
    }

    /// Reconstruct a line from its wire form during portable-figure import.
    pub(crate) fn from_portable(
        spec: &crate::portable::spec::LineSpec,
        reader: &crate::portable::data::BankReader<'_>,
    ) -> Result<Line2D, crate::portable::PortableError> {
        Ok(Line2D {
            xdata: reader.f64s(&spec.x)?,
            ydata: reader.f64s(&spec.y)?,
            color: spec.color,
            linewidth: spec.linewidth,
            dashes: spec.dashes.clone(),
            cap: Some(spec.cap),
            join: Some(spec.join),
            dash_cap: Some(spec.dash_cap.unwrap_or(LineStyles::default().dash_cap)),
            dash_join: Some(spec.dash_join.unwrap_or(LineStyles::default().dash_join)),
            visible: spec.visible,
            zorder: spec.zorder,
            label: spec.label.clone(),
            marker: spec.marker.clone().map(LineMarker::validated).transpose()?,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn path_without_gaps_is_the_implicit_polyline() {
        let line = Line2D::new(vec![0.0, 1.0, 2.0], vec![0.0, 1.0, 0.5]);
        let path = line.path();
        assert_eq!(path.vertices(), &[[0.0, 0.0], [1.0, 1.0], [2.0, 0.5]]);
        assert!(path.codes().is_none());
    }

    #[test]
    fn nan_splits_the_stroke_into_subpaths() {
        // 0-1 joined, gap, 3-4 joined: the stroke must not bridge 1.0 -> 3.0.
        let line = Line2D::new(
            vec![0.0, 1.0, 2.0, 3.0, 4.0],
            vec![0.0, 1.0, f64::NAN, 3.0, 4.0],
        );
        let path = line.path();
        assert_eq!(
            path.vertices(),
            &[[0.0, 0.0], [1.0, 1.0], [3.0, 3.0], [4.0, 4.0]]
        );
        assert_eq!(
            path.codes(),
            Some(
                [
                    PathCode::MoveTo,
                    PathCode::LineTo,
                    PathCode::MoveTo,
                    PathCode::LineTo,
                ]
                .as_slice()
            )
        );
        let subpaths = path.flatten(0.1);
        assert_eq!(subpaths.len(), 2, "one flattened polyline per finite run");
    }

    #[test]
    fn non_finite_x_and_isolated_points_are_gaps_too() {
        // inf in x breaks the run; the lone finite point at index 3 has no
        // stroke and is dropped; the trailing pair survives.
        let line = Line2D::new(
            vec![0.0, 1.0, f64::INFINITY, 3.0, f64::NAN, 5.0, 6.0],
            vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
        );
        let path = line.path();
        assert_eq!(
            path.vertices(),
            &[[0.0, 0.0], [1.0, 1.0], [5.0, 5.0], [6.0, 6.0]]
        );
        // Extents still ignore only the non-finite samples themselves.
        let e = line.data_extents().unwrap();
        assert_eq!((e.xmin(), e.xmax()), (0.0, 6.0));
    }

    #[test]
    fn all_gaps_draws_nothing() {
        let line = Line2D::new(vec![0.0, 1.0], vec![f64::NAN, f64::NAN]);
        assert!(line.path().vertices().is_empty());
        let mut r = MockRenderer::default();
        line.draw(&mut r, &Affine2D::identity());
        assert!(r.calls.is_empty());
    }

    #[test]
    fn gapped_line_strokes_only_finite_vertices() {
        let line = Line2D::new(
            vec![0.0, 1.0, 2.0, 3.0, 4.0],
            vec![0.0, 1.0, f64::NAN, 3.0, 4.0],
        );
        let mut r = MockRenderer::default();
        line.draw(&mut r, &Affine2D::identity());
        // One draw_path call carrying the four finite vertices (two runs).
        assert_eq!(r.calls.len(), 1);
        assert_eq!(r.calls[0].0, 4);
    }

    /// The `set_*` setters and the `with_*` builders must produce identical
    /// lines, so styling through a `&mut Line2D` handle is never a second-class
    /// path.
    #[test]
    fn set_and_with_setters_agree() {
        let built = Line2D::new(vec![0.0, 1.0], vec![0.0, 1.0])
            .with_color(Rgba::RED)
            .with_linewidth(3.0)
            .with_dashes(Some((0.0, vec![4.0, 2.0])))
            .with_cap(CapStyle::Round)
            .with_join(JoinStyle::Round)
            .with_visible(false)
            .with_zorder(7.0)
            .with_label("p50");

        let mut set = Line2D::new(vec![0.0, 1.0], vec![0.0, 1.0]);
        set.set_color(Rgba::RED)
            .set_linewidth(3.0)
            .set_dashes(Some((0.0, vec![4.0, 2.0])))
            .set_cap(CapStyle::Round)
            .set_join(JoinStyle::Round)
            .set_visible(false)
            .set_zorder(7.0)
            .set_label("p50");

        assert_eq!(built, set);
        assert_eq!(set.color(), Rgba::RED);
        assert!(!set.visible());
        assert_eq!(set.label(), Some("p50"));
        assert_eq!(Line2D::new(vec![], vec![]).label(), None);
    }

    /// A [`Renderer`] that records, per `draw_path` call, the path's vertex
    /// count and the stroke color from the [`GraphicsContext`].
    #[derive(Default)]
    struct MockRenderer {
        calls: Vec<(usize, Option<Rgba>)>,
    }

    impl Renderer for MockRenderer {
        fn draw_path(
            &mut self,
            gc: &GraphicsContext,
            path: &Path,
            _transform: &Affine2D,
            _fill: Option<Rgba>,
        ) {
            self.calls.push((path.vertices().len(), gc.stroke));
        }

        fn canvas_size(&self) -> (f64, f64) {
            (100.0, 100.0)
        }
    }

    #[test]
    fn three_point_line_draws_once_with_color() {
        let line = Line2D::new(vec![0.0, 1.0, 2.0], vec![0.0, 1.0, 0.0]).with_color(Rgba::RED);
        let mut r = MockRenderer::default();
        line.draw(&mut r, &Affine2D::identity());
        assert_eq!(r.calls, vec![(3, Some(Rgba::RED))]);
    }

    #[test]
    fn invisible_line_draws_nothing() {
        let line = Line2D::new(vec![0.0, 1.0], vec![0.0, 1.0]).with_visible(false);
        let mut r = MockRenderer::default();
        line.draw(&mut r, &Affine2D::identity());
        assert!(r.calls.is_empty());
    }

    #[test]
    fn single_point_line_draws_nothing() {
        let line = Line2D::new(vec![0.0], vec![0.0]);
        let mut r = MockRenderer::default();
        line.draw(&mut r, &Affine2D::identity());
        assert!(r.calls.is_empty());
    }

    #[test]
    fn data_extents_bounds_finite_points() {
        let line = Line2D::new(vec![1.0, 3.0, 2.0], vec![-1.0, 4.0, 0.0]);
        let e = line.data_extents().expect("non-empty");
        assert_eq!(e.xmin(), 1.0);
        assert_eq!(e.xmax(), 3.0);
        assert_eq!(e.ymin(), -1.0);
        assert_eq!(e.ymax(), 4.0);
    }

    #[test]
    fn data_extents_ignores_nan_point() {
        let line = Line2D::new(vec![1.0, f64::NAN, 2.0], vec![1.0, 5.0, 2.0]);
        let e = line.data_extents().expect("non-empty");
        // The NaN x-point is skipped, so x stays in [1, 2] and y in [1, 2].
        assert_eq!(e.xmin(), 1.0);
        assert_eq!(e.xmax(), 2.0);
        assert_eq!(e.ymin(), 1.0);
        assert_eq!(e.ymax(), 2.0);
    }

    #[test]
    fn data_extents_empty_is_none() {
        let line = Line2D::new(vec![], vec![]);
        assert!(line.data_extents().is_none());
    }

    #[test]
    fn default_zorder_is_two() {
        let line = Line2D::new(vec![0.0, 1.0], vec![0.0, 1.0]);
        assert_eq!(line.zorder(), 2.0);
    }
}