navcore_enc_store/

check.rs

//! Whether a leg is safe, and if not, where it stops being safe.
//!
//! Two rules govern every check performed here.
//!
//! **The safety contour decides.** It is the mariner's own setting,
//! the same value the chart is drawn with, so what the check calls
//! unsafe matches what the chart displays as unsafe.
//!
//! **An unknown answer is treated as unsafe.** A rock with no charted
//! depth, an obstruction with no sounding, or water outside the
//! chart's own coverage are all reported rather than passed over
//! silently.

use geo::{BoundingRect, Contains, Intersects, Point, Rect};
use nav_math::{METRES_PER_NM, Position};

use crate::corridor::Leg;
use crate::store::{ChartStore, Feature, StoreError};

/// What the vessel needs to be safe.
///
/// One number for now: the mariner's own safety contour. Air draught
/// and beam belong here once the chart can answer them; a setting the
/// check cannot honour would be worse than omitting it.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Vessel {
    /// The mariner's safety contour, in metres.
    pub safety_contour_m: f64,
}

/// How much a finding matters.
///
/// Declaration order is the ranking, worst first: a danger outranks
/// silence, silence outranks a coarse answer, and all three outrank
/// an advisory. `Unsurveyed` and `Coarse` rank above `Caution` because
/// they describe how far the check itself can be trusted, not a
/// property of the water.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Severity {
    /// The vessel cannot pass here: land, water shallower than the safety
    /// contour, or a danger whose depth is unknown.
    Unsafe,
    /// The chart has no coverage here. Reports an unanswered question,
    /// not clear water.
    Unsurveyed,
    /// There is data, but it was compiled at a scale too small to answer
    /// the question that was asked of it. A clear result here means "no
    /// danger was drawn at this scale", which is a weaker statement than
    /// "there is no danger".
    Coarse,
    /// Passable, but the mariner has to know: a restricted area, a traffic
    /// separation scheme, a cable field nobody should anchor in.
    Caution,
}

/// How much of a chart's own scale a position on it can be trusted to.
///
/// Half a millimetre at compilation scale: the standard cartographic
/// figure for the finest detail drawable on and readable from a chart.
/// At 1:1,500,000 this is 750 m; at 1:12,000 it is 6 m. This is the
/// accuracy the charts were compiled to, and converts a compilation
/// scale into the maximum positional error this check accounts for.
const PLOTTING_ACCURACY_MM: f64 = 0.5;

/// How far out the chart may be, in metres, at a given compilation scale.
#[must_use]
fn accuracy_m(compilation_scale: f64) -> f64 {
    compilation_scale * PLOTTING_ACCURACY_MM / 1000.0
}

/// One thing found along a leg.
#[derive(Debug, Clone, PartialEq)]
pub struct Finding {
    /// How much it matters.
    pub severity: Severity,
    /// S-57 object class, or `M_COVR` for a gap in coverage.
    pub class: String,
    /// How far along the leg it was first met, in nautical miles.
    pub along_track_nm: f64,
    /// How far along the leg it was last met.
    ///
    /// Equal to [`Self::along_track_nm`] for a hazard met at a single
    /// point. A two-mile stretch of shoal water is reported as one
    /// finding with two ends, not as multiple findings at each
    /// sampled interval.
    pub until_nm: f64,
    /// The position on the leg where the finding starts, for a caller
    /// to know where to look -- not the hazard's own centre, which for
    /// a large area may be a position the vessel never approaches.
    pub position: Position,
    /// Why it was reported, in words fit to put on a screen.
    pub reason: String,
}

impl Finding {
    /// Whether this was met along a stretch rather than at one spot.
    #[must_use]
    pub fn is_stretch(&self) -> bool {
        self.until_nm > self.along_track_nm
    }
}

/// Object classes that are always a stop, whatever their attributes say.
const ALWAYS_UNSAFE: [&str; 1] = ["LNDARE"];

/// Object classes whose charted depth is compared with the safety contour.
///
/// S-57 chart symbology rule CS(DEPARE03) handles these two classes
/// together: a dredged area is shaded and contoured identically to a
/// depth area, so both are checked the same way.
const DEPTH_AREAS: [&str; 2] = ["DEPARE", "DRGARE"];

/// Point and area dangers carrying a sounding.
const SOUNDED_DANGERS: [&str; 3] = ["OBSTRN", "UWTROC", "WRECKS"];

/// Classes worth a word, in the order a mariner would want to hear them.
const CAUTIONS: [&str; 6] = ["BRIDGE", "RESARE", "TSSLPT", "ACHARE", "CBLARE", "PIPARE"];

/// The chart's own statement of where it has data.
const COVERAGE: &str = "M_COVR";

/// The compilation scale the pipeline writes onto every feature, upper
/// case because the store folds attribute names that way.
///
/// Source-independent by design: the OeSENC path takes it from the SENC
/// header's native scale, the S-57 path from the dataset's own DSPM/CSCL
/// field, and both write it under this one name. Nothing here needs to
/// know which kind of chart it is reading.
const SCALE_ATTRIBUTE: &str = "COMPILATION_SCALE";

/// Checks one leg against a chart.
///
/// Findings are returned in the order they occur along the leg.
///
/// # Errors
///
/// If the chart cannot be read.
pub fn check_leg(
    store: &ChartStore,
    leg: Leg,
    vessel: Vessel,
) -> Result<Vec<Finding>, StoreError> {
    let Some(band) = leg.band() else {
        return Ok(Vec::new());
    };
    let Some(bounds) = band.bounding_rect() else {
        return Ok(Vec::new());
    };

    let segments = leg.segments();
    let mut met = Vec::new();

    for class in store.object_classes() {
        // Classes the check has no rule for are not queried at all. On a
        // chart exported with every object class that is most of the file,
        // and reading it to decide it means nothing is work for nothing.
        if !has_rule(&class) {
            continue;
        }
        for feature in store.features_in(&class, bounds)? {
            let Some(verdict) = judge(&feature, vessel) else {
                continue;
            };
            let Some(segment) = segments
                .iter()
                .find(|segment| segment.band.intersects(&feature.geometry))
            else {
                continue;
            };

            met.push(Met {
                finding: Finding {
                    severity: verdict.severity,
                    class: feature.class.clone(),
                    along_track_nm: segment.start_nm,
                    until_nm: segment.start_nm,
                    position: segment.start,
                    reason: verdict.reason.clone(),
                },
                depth_m: verdict.depth_m,
                reasons: vec![verdict.reason],
            });
        }
    }

    let mut findings = collapse(met);
    findings.extend(coverage(store, &leg, bounds, leg.narrowest_xtd_nm())?);

    findings.sort_by(|a, b| {
        a.along_track_nm
            .total_cmp(&b.along_track_nm)
            .then(a.severity.cmp(&b.severity))
    });
    Ok(findings)
}

/// One feature's verdict, before it is placed on the leg.
struct Verdict {
    severity: Severity,
    reason: String,
    /// The depth that made it a finding, when there is one. Used to decide
    /// which reason survives when neighbouring findings are collapsed:
    /// `None` means the depth is unknown, which outranks any known one.
    depth_m: Option<f64>,
}

impl Verdict {
    fn unsafe_at(depth_m: Option<f64>, reason: String) -> Option<Self> {
        Some(Self {
            severity: Severity::Unsafe,
            reason,
            depth_m,
        })
    }

    fn caution(reason: String) -> Option<Self> {
        Some(Self {
            severity: Severity::Caution,
            reason,
            depth_m: None,
        })
    }
}

/// One finding with the working state the collapsing needs.
struct Met {
    finding: Finding,
    depth_m: Option<f64>,
    /// The distinct reasons merged into this one, so a stretch that is land
    /// in five places does not claim five different things, and one that is
    /// several different things can say so.
    reasons: Vec<String>,
}

/// Whether the check has anything to say about a class at all.
fn has_rule(class: &str) -> bool {
    ALWAYS_UNSAFE.contains(&class)
        || DEPTH_AREAS.contains(&class)
        || SOUNDED_DANGERS.contains(&class)
        || CAUTIONS.contains(&class)
}

/// Merges findings of the same class that follow one another along the leg.
///
/// Without this a leg running two miles along a shoal reports the same thing
/// eight times, and the one finding that matters is buried among them.
fn collapse(mut met: Vec<Met>) -> Vec<Finding> {
    met.sort_by(|a, b| {
        a.finding
            .class
            .cmp(&b.finding.class)
            .then(a.finding.severity.cmp(&b.finding.severity))
            .then(a.finding.along_track_nm.total_cmp(&b.finding.along_track_nm))
    });

    let mut merged: Vec<Met> = Vec::new();
    for item in met {
        match merged.last_mut() {
            Some(open) if adjoins(open, &item) => absorb(open, item),
            _ => merged.push(item),
        }
    }

    merged
        .into_iter()
        .map(|mut item| {
            if item.reasons.len() > 1 {
                let others = item.reasons.len() - 1;
                item.finding.reason = format!("{} +{others} more", item.finding.reason);
            }
            item.finding
        })
        .collect()
}

/// Whether two findings are the same thing continuing.
fn adjoins(open: &Met, next: &Met) -> bool {
    open.finding.class == next.finding.class
        && open.finding.severity == next.finding.severity
        // Neighbouring pieces of the leg, or the same piece. A gap of more
        // than one piece is a second encounter and stays its own finding.
        && next.finding.along_track_nm <= open.finding.until_nm + crate::corridor::SEGMENT_NM + 1e-9
}

/// Folds one finding into the stretch it continues.
fn absorb(open: &mut Met, next: Met) {
    open.finding.until_nm = open.finding.until_nm.max(next.finding.until_nm);

    // The worst member's words survive. Shallower beats deeper, and an
    // unknown depth beats both -- if a leg crosses water charted at 2 m and
    // water charted at nothing at all, the second is what to say out loud.
    let next_is_worse = match (open.depth_m, next.depth_m) {
        (Some(_), None) => true,
        (Some(open_m), Some(next_m)) => next_m < open_m,
        (None, _) => false,
    };
    if next_is_worse {
        open.finding.reason.clone_from(&next.finding.reason);
        open.depth_m = next.depth_m;
    }

    if !open.reasons.contains(&next.finding.reason) {
        open.reasons.push(next.finding.reason);
    }
}

/// What one feature means for this vessel, or `None` if it means nothing.
fn judge(feature: &Feature, vessel: Vessel) -> Option<Verdict> {
    let class = feature.class.as_str();
    let named = feature.name().map_or(String::new(), |name| format!(" ({name})"));

    if ALWAYS_UNSAFE.contains(&class) {
        // Land has no depth to rank, and none is needed: nothing collapses
        // against it that could be worse.
        return Verdict::unsafe_at(Some(f64::NEG_INFINITY), format!("land{named}"));
    }

    if DEPTH_AREAS.contains(&class) {
        return match feature.number("DRVAL1") {
            Some(depth_m) if depth_m >= vessel.safety_contour_m => None,
            Some(depth_m) => Verdict::unsafe_at(
                Some(depth_m),
                format!(
                    "charted from {depth_m:.1} m, inside the {:.1} m safety contour{named}",
                    vessel.safety_contour_m
                ),
            ),
            // CS(DEPARE03)'s own fail-safe: a depth area with no DRVAL1 is
            // treated as drying, because the alternative is treating unknown
            // water as deep water. Said in those words, too -- quoting the
            // fail-safe value as though it were a charted depth would put a
            // number on the screen that no survey ever measured.
            None => Verdict::unsafe_at(None, format!("no charted depth, treated as drying{named}")),
        };
    }

    if SOUNDED_DANGERS.contains(&class) {
        return match feature.number("VALSOU") {
            Some(depth_m) if depth_m >= vessel.safety_contour_m => None,
            Some(depth_m) => {
                Verdict::unsafe_at(Some(depth_m), format!("sounded {depth_m:.1} m{named}"))
            }
            // No sounding at all. S-52 draws these as isolated dangers for
            // the same reason: an obstruction of unknown depth is one to
            // stay away from, not one to assume is deep.
            None => Verdict::unsafe_at(None, format!("depth unknown{named}")),
        };
    }

    if CAUTIONS.contains(&class) {
        let detail = match class {
            "BRIDGE" => feature
                .number("VERCLR")
                .map_or_else(|| "bridge".to_owned(), |m| format!("bridge, {m:.1} m clear")),
            "RESARE" => "restricted area".to_owned(),
            "TSSLPT" => "traffic separation scheme".to_owned(),
            "ACHARE" => "anchorage".to_owned(),
            "CBLARE" => "submarine cables, do not anchor".to_owned(),
            "PIPARE" => "pipelines, do not anchor".to_owned(),
            other => other.to_owned(),
        };
        return Verdict::caution(format!("{detail}{named}"));
    }

    None
}

/// What the chart says about its own data along the leg.
///
/// Two questions, asked of the same M_COVR features in one pass, because
/// they are the same question at different strengths: *is* there data here,
/// and is it fine enough to answer what was asked. Without the first, a leg
/// running off the edge of the coverage comes back clean, and "no danger
/// found" reads identically to "no data". Without the second, a corridor of
/// fifty metres checked against a chart compiled at 1:1,500,000 comes back
/// clean too -- against data that could not have shown a fifty-metre
/// feature in the first place.
fn coverage(
    store: &ChartStore,
    leg: &Leg,
    bounds: Rect<f64>,
    vessel_corridor_nm: f64,
) -> Result<Vec<Finding>, StoreError> {
    if !store.object_classes().iter().any(|class| class == COVERAGE) {
        return Ok(Vec::new());
    }

    let covers: Vec<Feature> = store
        .features_in(COVERAGE, bounds)?
        .into_iter()
        // CATCOV 1 is "coverage available"; anything else is a hole the
        // chart drew on purpose.
        .filter(|feature| feature.number("CATCOV").unwrap_or(1.0) == 1.0)
        .collect();

    // Every piece boundary, and the far end of the leg. The end matters on
    // its own account: without it a leg that runs out of coverage in its
    // last few hundred metres reports nothing -- silence exactly where the
    // chart stops knowing, which is what this test exists to prevent.
    let samples = leg
        .segments()
        .into_iter()
        .map(|segment| (segment.start_nm, segment.start))
        .chain(std::iter::once((leg.length_nm(), leg.to)));

    let corridor_m = vessel_corridor_nm * METRES_PER_NM;
    let mut findings = Vec::new();
    let mut gap: Option<Run> = None;
    let mut coarse: Option<Run> = None;

    for (along_nm, position) in samples {
        let point = Point::new(position.lon_deg, position.lat_deg);
        let here: Vec<&Feature> = covers
            .iter()
            .filter(|feature| feature.geometry.contains(&point))
            .collect();

        // The finest chart covering this spot answers for it: an overview
        // cell spanning half the Mediterranean does not make the harbour
        // plan underneath it any less detailed.
        let finest = here
            .iter()
            .filter_map(|feature| feature.number(SCALE_ATTRIBUTE))
            .filter(|scale| *scale > 0.0)
            .reduce(f64::min);

        // A stretch with no data at all is the other finding and is not
        // also called coarse, or every gap would be reported twice.
        let coarse_here = if here.is_empty() {
            None
        } else {
            too_coarse(finest, corridor_m)
        };

        if here.is_empty() {
            gap.get_or_insert(Run::at(along_nm, position));
        } else if let Some(run) = gap.take() {
            findings.push(run.into_gap(along_nm));
        }

        match coarse_here {
            Some(scale) => {
                let run = coarse.get_or_insert(Run::at(along_nm, position));
                run.worst_scale = worse_scale(run.worst_scale, scale);
            }
            None => {
                if let Some(run) = coarse.take() {
                    findings.push(run.into_coarse(along_nm, corridor_m));
                }
            }
        }
    }

    // Runs still open at the far end of the leg close there.
    let end_nm = leg.length_nm();
    if let Some(run) = gap.take() {
        findings.push(run.into_gap(end_nm));
    }
    if let Some(run) = coarse.take() {
        findings.push(run.into_coarse(end_nm, corridor_m));
    }

    Ok(findings)
}

/// A stretch of leg being accumulated: where it started, and the worst
/// thing seen along it so far.
struct Run {
    start_nm: f64,
    start: Position,
    /// The coarsest compilation scale met along the run. `None` means one
    /// of the charts along it stated no scale at all, which outranks any
    /// number.
    worst_scale: Option<f64>,
}

impl Run {
    fn at(start_nm: f64, start: Position) -> Self {
        Self {
            start_nm,
            start,
            worst_scale: Some(0.0),
        }
    }

    fn into_gap(self, until_nm: f64) -> Finding {
        Finding {
            severity: Severity::Unsurveyed,
            class: COVERAGE.to_owned(),
            along_track_nm: self.start_nm,
            until_nm,
            position: self.start,
            reason: "outside the chart's coverage".to_owned(),
        }
    }

    fn into_coarse(self, until_nm: f64, corridor_m: f64) -> Finding {
        // Both numbers, because "1:1,500,000" means little to most people
        // and "750 m" means everything.
        let reason = match self.worst_scale {
            Some(scale) => format!(
                "charted at 1:{scale:.0}, which places anything on it to about {}, \
                 wider than the {} corridor",
                metres(accuracy_m(scale)),
                metres(corridor_m)
            ),
            None => "the chart here does not state its compilation scale".to_owned(),
        };

        Finding {
            severity: Severity::Coarse,
            class: COVERAGE.to_owned(),
            along_track_nm: self.start_nm,
            until_nm,
            position: self.start,
            reason,
        }
    }
}

/// A distance in metres, written the way it would be spoken.
///
/// Whole metres once there are a few of them, a decimal below that: on a
/// harbour plan the corridor can be less than a metre wide, and rounding it
/// to "0 m" turns the explanation into nonsense.
fn metres(value: f64) -> String {
    if value >= 10.0 {
        format!("{value:.0} m")
    } else {
        format!("{value:.1} m")
    }
}

/// Whether covered water is charted finely enough to answer the question.
///
/// `Some(Some(scale))` when the chart cannot resolve the corridor and says
/// at what scale; `Some(None)` when it does not say at all, which takes the
/// same posture as an unsounded rock -- an unstated scale is not a fine
/// one. `None` when the data is good enough and there is nothing to report.
fn too_coarse(finest_scale: Option<f64>, corridor_m: f64) -> Option<Option<f64>> {
    match finest_scale {
        Some(scale) if accuracy_m(scale) > corridor_m => Some(Some(scale)),
        Some(_) => None,
        None => Some(None),
    }
}

/// The worse of two compilation scales: an unstated one beats every number,
/// and among numbers the larger denominator is the coarser chart.
fn worse_scale(open: Option<f64>, next: Option<f64>) -> Option<f64> {
    match (open, next) {
        (None, _) | (_, None) => None,
        (Some(open), Some(next)) => Some(open.max(next)),
    }
}

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

    /// A feature of one class with the attributes a test needs, without a
    /// database behind it. The geometry is a placeholder: `judge` looks at
    /// class and attributes only, and the geometry is what decides *whether*
    /// it is judged, which is the query's job and tested against a real
    /// chart.
    fn feature(class: &str, attributes: &[(&str, Attribute)]) -> Feature {
        Feature::for_test(
            class,
            geo::Geometry::Point(Point::new(13.7, 45.5)),
            attributes,
        )
    }

    fn vessel() -> Vessel {
        Vessel {
            safety_contour_m: 3.0,
        }
    }

    #[test]
    fn land_is_unsafe_whatever_else_it_says() {
        let verdict = judge(&feature("LNDARE", &[]), vessel()).expect("land is a finding");
        assert_eq!(verdict.severity, Severity::Unsafe);
    }

    #[test]
    fn water_deeper_than_the_safety_contour_is_not_reported_at_all() {
        let deep = feature("DEPARE", &[("DRVAL1", Attribute::Real(10.0))]);
        assert!(judge(&deep, vessel()).is_none());
    }

    #[test]
    fn water_shallower_than_the_safety_contour_stops_the_vessel() {
        let shoal = feature("DEPARE", &[("DRVAL1", Attribute::Real(2.0))]);
        let verdict = judge(&shoal, vessel()).expect("a shoal is a finding");
        assert_eq!(verdict.severity, Severity::Unsafe);
        assert!(verdict.reason.contains("2.0 m"), "{}", verdict.reason);
    }

    #[test]
    fn the_safety_contour_itself_is_the_boundary_and_counts_as_safe() {
        // A depth area charted at exactly the safety contour is on the safe
        // side of it: the contour is the line between safe and unsafe, and
        // S-52 shades the water at that value as safe.
        let exact = feature("DEPARE", &[("DRVAL1", Attribute::Real(3.0))]);
        assert!(judge(&exact, vessel()).is_none());
    }

    #[test]
    fn a_depth_area_with_no_depth_is_treated_as_drying() {
        // CS(DEPARE03)'s own fail-safe. Read as "unknown, therefore fine"
        // this is the single most dangerous thing the check could do.
        let unknown = feature("DEPARE", &[]);
        let verdict = judge(&unknown, vessel()).expect("unknown water is a finding");
        assert_eq!(verdict.severity, Severity::Unsafe);
        // And it must not report the fail-safe value as if it had been
        // surveyed: "charted from -1.0 m" is a depth nobody measured.
        assert!(verdict.reason.contains("no charted depth"), "{}", verdict.reason);
        assert!(!verdict.reason.contains("-1.0"), "{}", verdict.reason);
    }

    #[test]
    fn a_rock_with_no_sounding_is_a_danger_rather_than_a_shrug() {
        let rock = feature("UWTROC", &[]);
        let verdict = judge(&rock, vessel()).expect("an unsounded rock is a finding");
        assert_eq!(verdict.severity, Severity::Unsafe);
        assert!(verdict.reason.contains("unknown"), "{}", verdict.reason);
    }

    #[test]
    fn a_wreck_below_the_safety_contour_is_passed_over() {
        let deep_wreck = feature("WRECKS", &[("VALSOU", Attribute::Real(18.0))]);
        assert!(judge(&deep_wreck, vessel()).is_none());
    }

    #[test]
    fn an_area_to_know_about_is_a_caution_and_not_a_stop() {
        let restricted = feature(
            "RESARE",
            &[("OBJNAM", Attribute::Text("Rt Madona".into()))],
        );
        let verdict = judge(&restricted, vessel()).expect("a restricted area is a finding");
        assert_eq!(verdict.severity, Severity::Caution);
        assert!(verdict.reason.contains("Rt Madona"), "{}", verdict.reason);
    }

    #[test]
    fn a_class_with_no_rule_says_nothing() {
        // Silence for classes the check has no opinion on, rather than a
        // finding per charted object in the corridor.
        assert!(judge(&feature("BUISGL", &[]), vessel()).is_none());
    }

    /// A finding placed at a distance along a leg, as `check_leg` builds them.
    fn met(class: &str, along_nm: f64, depth_m: Option<f64>, reason: &str) -> Met {
        Met {
            finding: Finding {
                severity: Severity::Unsafe,
                class: class.to_owned(),
                along_track_nm: along_nm,
                until_nm: along_nm,
                position: Position::new(45.5, 13.7),
                reason: reason.to_owned(),
            },
            depth_m,
            reasons: vec![reason.to_owned()],
        }
    }

    #[test]
    fn the_same_thing_in_neighbouring_pieces_is_one_stretch() {
        let collapsed = collapse(vec![
            met("LNDARE", 1.50, Some(f64::NEG_INFINITY), "land"),
            met("LNDARE", 1.75, Some(f64::NEG_INFINITY), "land"),
            met("LNDARE", 2.00, Some(f64::NEG_INFINITY), "land"),
        ]);
        assert_eq!(collapsed.len(), 1, "{collapsed:#?}");
        assert_eq!(collapsed[0].along_track_nm, 1.50);
        assert_eq!(collapsed[0].until_nm, 2.00);
        assert!(collapsed[0].is_stretch());
    }

    #[test]
    fn meeting_the_same_class_again_later_is_a_second_finding() {
        // Two separate shoals with clear water between them are two things
        // to know about, not one two-mile stretch that is mostly fine.
        let collapsed = collapse(vec![
            met("DEPARE", 1.00, Some(2.0), "shoal"),
            met("DEPARE", 5.00, Some(2.0), "shoal"),
        ]);
        assert_eq!(collapsed.len(), 2, "{collapsed:#?}");
    }

    #[test]
    fn different_classes_never_merge() {
        let collapsed = collapse(vec![
            met("LNDARE", 1.00, None, "land"),
            met("DEPARE", 1.00, Some(2.0), "shoal"),
        ]);
        assert_eq!(collapsed.len(), 2, "{collapsed:#?}");
    }

    #[test]
    fn the_shallowest_member_of_a_stretch_is_the_one_reported() {
        // Crossing water charted at 2 m and then at 0.5 m, the mariner needs
        // to hear about the 0.5.
        let collapsed = collapse(vec![
            met("DEPARE", 1.00, Some(2.0), "charted from 2.0 m"),
            met("DEPARE", 1.25, Some(0.5), "charted from 0.5 m"),
        ]);
        assert_eq!(collapsed.len(), 1);
        assert!(collapsed[0].reason.starts_with("charted from 0.5 m"), "{}", collapsed[0].reason);
    }

    #[test]
    fn an_unknown_depth_outranks_every_known_one() {
        // Water nobody has charted is worse than water charted shallow: the
        // second has a number, the first is a question.
        let collapsed = collapse(vec![
            met("DEPARE", 1.00, Some(0.5), "charted from 0.5 m"),
            met("DEPARE", 1.25, None, "no charted depth, treated as drying"),
        ]);
        assert_eq!(collapsed.len(), 1);
        assert!(collapsed[0].reason.starts_with("no charted depth"), "{}", collapsed[0].reason);
    }

    #[test]
    fn a_stretch_that_is_several_different_things_says_so() {
        let collapsed = collapse(vec![
            met("DEPARE", 1.00, Some(2.0), "charted from 2.0 m"),
            met("DEPARE", 1.25, Some(0.5), "charted from 0.5 m"),
        ]);
        assert!(collapsed[0].reason.ends_with("+1 more"), "{}", collapsed[0].reason);
    }

    #[test]
    fn a_stretch_that_is_the_same_thing_throughout_stays_quiet_about_it() {
        let collapsed = collapse(vec![
            met("LNDARE", 1.00, Some(f64::NEG_INFINITY), "land"),
            met("LNDARE", 1.25, Some(f64::NEG_INFINITY), "land"),
        ]);
        assert_eq!(collapsed[0].reason, "land");
    }

    #[test]
    fn a_class_with_no_rule_is_never_queried() {
        assert!(has_rule("DEPARE"));
        assert!(has_rule("LNDARE"));
        assert!(!has_rule("SOUNDG"));
        assert!(!has_rule("BUISGL"));
    }

    #[test]
    fn severity_sorts_worst_first() {
        let mut severities = [
            Severity::Caution,
            Severity::Coarse,
            Severity::Unsurveyed,
            Severity::Unsafe,
        ];
        severities.sort();
        assert_eq!(
            severities,
            [
                Severity::Unsafe,
                Severity::Unsurveyed,
                Severity::Coarse,
                Severity::Caution
            ]
        );
    }

    #[test]
    fn half_a_millimetre_at_chart_scale_is_what_a_position_is_worth() {
        // The two ends of the range this actually meets: an overview cell
        // and a harbour plan.
        assert!((accuracy_m(1_500_000.0) - 750.0).abs() < 1e-9);
        assert!((accuracy_m(12_000.0) - 6.0).abs() < 1e-9);
    }

    #[test]
    fn a_harbour_plan_answers_a_narrow_corridor_and_an_overview_chart_does_not() {
        // The default corridor, fifty metres either side.
        let corridor_m = 0.05 * METRES_PER_NM;

        assert_eq!(too_coarse(Some(12_000.0), corridor_m), None);
        assert_eq!(too_coarse(Some(90_000.0), corridor_m), None);
        assert_eq!(
            too_coarse(Some(1_500_000.0), corridor_m),
            Some(Some(1_500_000.0))
        );
    }

    #[test]
    fn a_wide_corridor_forgives_a_coarser_chart() {
        // The question is not "is this chart detailed" but "is it detailed
        // enough for what was asked". A mile of tolerance either side is
        // answerable from a coastal chart.
        let corridor_m = 1.0 * METRES_PER_NM;
        assert_eq!(too_coarse(Some(1_500_000.0), corridor_m), None);
    }

    #[test]
    fn a_chart_that_does_not_state_its_scale_is_not_assumed_to_be_a_good_one() {
        assert_eq!(too_coarse(None, 10_000.0), Some(None));
    }

    #[test]
    fn the_coarsest_chart_along_a_stretch_is_the_one_reported() {
        assert_eq!(worse_scale(Some(12_000.0), Some(90_000.0)), Some(90_000.0));
        // And an unstated scale outranks every number, in both directions.
        assert_eq!(worse_scale(Some(1_500_000.0), None), None);
        assert_eq!(worse_scale(None, Some(12_000.0)), None);
    }
}