//! Convert to Sheet Metal: solid and shelled bodies with bend edges (with holes and round edges in
//! their faces), plates read from STEP files whose walls come in pieces, and plates with recesses.

use std::f64::consts::{FRAC_PI_2, PI, SQRT_2};

use serde_json::{Value, json};

use crate::Session;

fn run(s: &mut Session, id: &str, p: Value) -> Value {
    match s.execute(id, &p) {
        Ok(v) => v,
        Err(e) => panic!("{id} {p}: {e}"),
    }
}

fn volume(s: &mut Session) -> f64 {
    run(s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN)
}

fn bbox(s: &mut Session) -> ([f64; 3], [f64; 3]) {
    let m = run(s, "inspect.measure", json!({}));
    let b = &m["bodies"][0]["bbox"];
    let v = |k: &str| [0, 1, 2].map(|i| b[k][i].as_f64().unwrap_or(f64::NAN));
    (v("min"), v("max"))
}

fn flat(s: &mut Session) -> Value {
    run(s, "sheet.flat_pattern", json!({}))
}

fn flat_size(s: &mut Session) -> (f64, f64) {
    let f = flat(s);
    let v = |i: usize| f["flat_size_mm"][i].as_f64().unwrap_or(f64::NAN);
    (v(0), v(1))
}

/// Either way round (the flat frame's x runs along the fixed face's longest edge).
fn same_size(got: (f64, f64), want: (f64, f64), tol: f64) -> bool {
    ((got.0 - want.0).abs() < tol && (got.1 - want.1).abs() < tol) || ((got.0 - want.1).abs() < tol && (got.1 - want.0).abs() < tol)
}

/// The bend table's rows as (angle in whole degrees, direction, length).
fn bend_rows(s: &mut Session) -> Vec<(i64, String, f64)> {
    let rows = flat(s)["bends"].as_array().cloned().unwrap_or_default();
    let row = |b: &Value| {
        (
            b["angle_deg"].as_f64().unwrap_or(0.0).round() as i64,
            b["direction"].as_str().unwrap_or("").to_string(),
            b["length"].as_f64().unwrap_or(0.0),
        )
    };
    rows.iter().map(row).collect()
}

fn rule(s: &mut Session, name: &str, t: f64, k: f64, r: f64, gap: f64) {
    let mm = |v: f64| format!("{v} mm");
    run(
        s,
        "sheet.manage_rules",
        json!({"name": name, "thickness": mm(t), "k_factor": format!("{k}"), "bend_radius": mm(r), "gap": mm(gap), "active": true}),
    );
}

/// Bend deduction: twice the outside setback less the allowance.
fn deduction(theta: f64, r: f64, t: f64, k: f64) -> f64 {
    2.0 * (r + t) * (theta / 2.0).tan() - theta * (r + k * t)
}

const BOTTOM_EDGES: [[f64; 3]; 4] = [[50.0, 0.0, 0.0], [100.0, 30.0, 0.0], [50.0, 60.0, 0.0], [0.0, 30.0, 0.0]];

/// A 100 x 60 x 30 box shelled to `t` with its top open.
fn tray(s: &mut Session, t: f64) {
    run(s, "solid.box", json!({"length": 100, "width": 60, "height": 30, "body_name": "Tray"}));
    run(s, "solid.shell", json!({"faces": [[50, 30, 30]], "thickness": t}));
}

/// The folded tray's volume: base, four 90° bends and four walls cut back at the corners.
fn tray_volume(l: f64, w: f64, h: f64, t: f64, r: f64, gap: f64) -> f64 {
    let s = r + t;
    let cut = t + gap / SQRT_2;
    let base = (l - 2.0 * s) * (w - 2.0 * s);
    let bends = FRAC_PI_2 * (r + t / 2.0) * 2.0 * ((l - 2.0 * s) + (w - 2.0 * s));
    let walls = (h - s) * 2.0 * ((l - 2.0 * cut) + (w - 2.0 * cut));
    t * (base + bends + walls)
}

/// A strip `t` thick along the polyline `outer` (its material to the left of the way the line
/// runs, its ends cut square), extruded `len` along z as the body `Section`. Returns a point on
/// the edge at each corner of the polyline.
fn section(s: &mut Session, outer: &[(f64, f64)], t: f64, len: f64) -> Vec<[f64; 3]> {
    let n = outer.len();
    let dir = |i: usize| {
        let (a, b) = (outer[i], outer[i + 1]);
        let l = (b.0 - a.0).hypot(b.1 - a.1);
        ((b.0 - a.0) / l, (b.1 - a.1) / l)
    };
    let shift = |p: (f64, f64), d: (f64, f64)| (p.0 - d.1 * t, p.1 + d.0 * t);
    let mut inner = vec![shift(outer[0], dir(0))];
    for (i, &corner) in outer.iter().enumerate().take(n - 1).skip(1) {
        let (d0, d1) = (dir(i - 1), dir(i));
        let (p0, p1) = (shift(corner, d0), shift(corner, d1));
        let along = ((p1.0 - p0.0) * d1.1 - (p1.1 - p0.1) * d1.0) / (d0.0 * d1.1 - d0.1 * d1.0);
        inner.push((p0.0 + d0.0 * along, p0.1 + d0.1 * along));
    }
    inner.push(shift(outer[n - 1], dir(n - 2)));
    let pts: Vec<[f64; 2]> = outer.iter().chain(inner.iter().rev()).map(|p| [p.0, p.1]).collect();
    run(s, "sketch.create", json!({"plane": "XY", "name": "Section"}));
    run(s, "sketch.line", json!({"points": pts, "closed": true}));
    run(s, "sketch.finish", json!({}));
    run(s, "solid.extrude", json!({"sketch": "Section", "distance": len, "body_name": "Section"}));
    outer[1..n - 1].iter().map(|p| [p.0, p.1, len / 2.0]).collect()
}

/// A base 200 wide with walls 40 long at 72° and returns 15 long at 108° more, 300 long.
fn trapezoid_section(s: &mut Session, t: f64) -> Vec<[f64; 3]> {
    let (c, sn) = (72f64.to_radians().cos(), 72f64.to_radians().sin());
    let (x, y) = (100.0 + 40.0 * c, 40.0 * sn);
    section(s, &[(-x + 15.0, y), (-x, y), (-100.0, 0.0), (100.0, 0.0), (x, y), (x - 15.0, y)], t, 300.0)
}

#[test]
fn a_shelled_tray_keeps_its_walls_and_unfolds_by_the_k_factor() {
    let (t, k, r, gap) = (2.0, 0.44, 2.0, 0.5);
    let mut s = Session::default();
    // The shell's own thickness counts, not the rule's.
    rule(&mut s, "Test", 3.0, k, r, gap);
    tray(&mut s, t);
    let out = run(&mut s, "sheet.convert", json!({"body": "Tray", "face": [50, 30, 0], "bends": BOTTOM_EDGES}));
    assert!(out["warning"].is_null(), "{out}");
    assert!((flat(&mut s)["thickness"].as_f64().unwrap_or(0.0) - t).abs() < 1e-9);
    // Four 90° bends up, each as long as the base is between its setbacks (R + T at either end).
    let mut rows = bend_rows(&mut s);
    rows.sort_by(|a, b| a.2.total_cmp(&b.2));
    let want = [52.0, 52.0, 92.0, 92.0];
    assert!(rows.len() == 4 && rows.iter().zip(want).all(|(row, l)| row.0 == 90 && row.1 == "up" && (row.2 - l).abs() < 1e-6), "{rows:?}");
    let allowance = flat(&mut s)["bends"][0]["allowance"].as_f64().unwrap_or(0.0);
    assert!((allowance - FRAC_PI_2 * (r + k * t)).abs() < 1e-9, "{allowance}");
    // The envelope stays: the sharp edges became bends inside it.
    let (lo, hi) = bbox(&mut s);
    assert!(
        lo.iter().all(|v| v.abs() < 1e-6) && (hi[0] - 100.0).abs() < 1e-6 && (hi[1] - 60.0).abs() < 1e-6 && (hi[2] - 30.0).abs() < 1e-6,
        "{lo:?} {hi:?}"
    );
    // Flat: the outside lengths less two bend deductions each way.
    let bd = deduction(FRAC_PI_2, r, t, k);
    let want = (100.0 + 60.0 - 2.0 * bd, 60.0 + 60.0 - 2.0 * bd);
    assert!(same_size(flat_size(&mut s), want, 1e-6), "{:?} vs {want:?}", flat_size(&mut s));
    let v = volume(&mut s);
    let expect = tray_volume(100.0, 60.0, 30.0, t, r, gap);
    assert!((v - expect).abs() < 2e-3 * expect, "{v} vs {expect}");
    // Unfold: flat, one sheet thick, the same outline; refold gives the tray back.
    run(&mut s, "sheet.unfold", json!({}));
    let (lo, hi) = bbox(&mut s);
    assert!((hi[2] - lo[2] - t).abs() < 1e-6, "{lo:?} {hi:?}");
    assert!(same_size((hi[0] - lo[0], hi[1] - lo[1]), want, 1e-6), "{lo:?} {hi:?}");
    run(&mut s, "sheet.refold", json!({}));
    assert!((volume(&mut s) - v).abs() < 1e-6 * v);
    // It exports like a sheet made from flanges: an outline and four bend lines up.
    let dxf = run(&mut s, "sheet.export_dxf", json!({}));
    assert_eq!(dxf["bends"], 4);
    let lines: Vec<&str> = dxf["dxf"].as_str().unwrap_or_default().lines().collect();
    assert_eq!(lines.windows(2).filter(|w| w[0].trim() == "8" && w[1].trim() == "BEND_UP").count(), 4, "four bend lines");
    assert_eq!(run(&mut s, "sheet.export_bend_table", json!({"format": "json"}))["bends"], 4);
}

#[test]
fn bends_picked_inside_and_a_fixed_face_inside_give_the_same_sheet() {
    let (t, k, r, gap) = (2.0, 0.44, 2.0, 0.5);
    let inner = [[50.0, 2.0, 2.0], [98.0, 30.0, 2.0], [50.0, 58.0, 2.0], [2.0, 30.0, 2.0]];
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, gap);
    tray(&mut s, t);
    run(&mut s, "sheet.convert", json!({"body": "Tray", "face": [50, 30, 0], "bends": BOTTOM_EDGES}));
    let (v, f) = (volume(&mut s), flat_size(&mut s));
    // The inner edges (2 mm in and up) are the same bends.
    let mut a = Session::default();
    rule(&mut a, "Test", t, k, r, gap);
    tray(&mut a, t);
    run(&mut a, "sheet.convert", json!({"body": "Tray", "face": [50, 30, 0], "bends": inner}));
    assert!((volume(&mut a) - v).abs() < 1e-6 * v && same_size(flat_size(&mut a), f, 1e-9));
    // From the floor inside, the sheet's other skin is the fixed one: the bends turn down from it
    // and the flat is the inside lengths less the inside setbacks, L' + 2H' - 4R + 2BA, which is
    // the same blank.
    let mut b = Session::default();
    rule(&mut b, "Test", t, k, r, gap);
    tray(&mut b, t);
    run(&mut b, "sheet.convert", json!({"body": "Tray", "face": [50, 30, 2], "bends": BOTTOM_EDGES}));
    assert!(bend_rows(&mut b).iter().all(|row| row.0 == 90 && row.1 == "down"), "{:?}", bend_rows(&mut b));
    let ba = FRAC_PI_2 * (r + k * t);
    let inside = (96.0 + 2.0 * 28.0 - 4.0 * r + 2.0 * ba, 56.0 + 2.0 * 28.0 - 4.0 * r + 2.0 * ba);
    assert!(same_size(flat_size(&mut b), inside, 1e-6) && same_size(inside, f, 1e-6), "{:?} {inside:?} {f:?}", flat_size(&mut b));
    assert!((volume(&mut b) - v).abs() < 1e-6 * v, "{} vs {v}", volume(&mut b));
    let (lo, hi) = bbox(&mut b);
    assert!(lo.iter().all(|x| x.abs() < 1e-6) && (hi[0] - 100.0).abs() < 1e-6 && (hi[2] - 30.0).abs() < 1e-6, "{lo:?} {hi:?}");
}

#[test]
fn a_solid_block_takes_its_rules_thickness_inward() {
    let (k, r, gap) = (0.44, 2.0, 0.5);
    for (name, t) in [(None, 2.0), (Some("Thick"), 3.0)] {
        // The active rule, or the one the conversion names.
        let mut s = Session::default();
        rule(&mut s, "Thick", 3.0, k, r, gap);
        rule(&mut s, "Test", 2.0, k, r, gap);
        run(&mut s, "solid.box", json!({"length": 100, "width": 60, "height": 30, "body_name": "Block"}));
        let mut p = json!({"body": "Block", "face": [50, 30, 0], "bends": BOTTOM_EDGES});
        if let Some(n) = name {
            p["rule"] = json!(n);
        }
        run(&mut s, "sheet.convert", p);
        assert!((flat(&mut s)["thickness"].as_f64().unwrap_or(0.0) - t).abs() < 1e-9);
        // The block's faces are the sheet's outside; its top is left out.
        let (lo, hi) = bbox(&mut s);
        assert!(
            lo.iter().all(|v| v.abs() < 1e-6) && (hi[0] - 100.0).abs() < 1e-6 && (hi[1] - 60.0).abs() < 1e-6 && (hi[2] - 30.0).abs() < 1e-6,
            "{lo:?} {hi:?}"
        );
        let bd = deduction(FRAC_PI_2, r, t, k);
        assert!(same_size(flat_size(&mut s), (160.0 - 2.0 * bd, 120.0 - 2.0 * bd), 1e-6), "{:?}", flat_size(&mut s));
        let expect = tray_volume(100.0, 60.0, 30.0, t, r, gap);
        assert!((volume(&mut s) - expect).abs() < 2e-3 * expect, "{} vs {expect}", volume(&mut s));
    }
}

#[test]
fn a_trapezoid_section_unfolds_through_72_and_108_degree_bends() {
    let (t, k, r) = (2.0, 0.5, 1.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    let bends = trapezoid_section(&mut s, t);
    run(&mut s, "sheet.convert", json!({"body": "Section", "face": [0, 0, 150], "bends": bends}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 4 && rows.iter().all(|row| row.1 == "up" && (row.2 - 300.0).abs() < 1e-9), "{rows:?}");
    assert_eq!((rows.iter().filter(|row| row.0 == 72).count(), rows.iter().filter(|row| row.0 == 108).count()), (2, 2), "{rows:?}");
    let (a72, a108) = (72f64.to_radians(), 108f64.to_radians());
    let across = 200.0 + 2.0 * 40.0 + 2.0 * 15.0 - 2.0 * deduction(a72, r, t, k) - 2.0 * deduction(a108, r, t, k);
    assert!(same_size(flat_size(&mut s), (across, 300.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    // The section keeps its outside faces: the returns' tops stay 40 sin 72° up and the length
    // stays; the widest point is on the round of the 108° bend (outer radius R + T), whose
    // centre lies (R + T) / sin 36° from the sharp corner along the corner's bisector.
    let (lo, hi) = bbox(&mut s);
    let (c72, s72) = (a72.cos(), a72.sin());
    let rho = r + t;
    let bisector_x = (-c72 - 1.0) / (-c72 - 1.0).hypot(-s72);
    let wide = 2.0 * (100.0 + 40.0 * c72 + bisector_x * rho / 36f64.to_radians().sin() + rho);
    // (The box is measured on the tessellation: the round comes out a chord's sag inside.)
    assert!((hi[0] - lo[0] - wide).abs() < 2e-3 && (hi[1] - 40.0 * s72).abs() < 1e-6 && (hi[2] - lo[2] - 300.0).abs() < 1e-6, "{lo:?} {hi:?} {wide}");
    run(&mut s, "sheet.unfold", json!({}));
    let (lo, hi) = bbox(&mut s);
    let flat_box = [(hi[0] - lo[0], hi[1] - lo[1]), (hi[0] - lo[0], hi[2] - lo[2])];
    assert!(flat_box.iter().any(|b| same_size(*b, (across, 300.0), 1e-6)), "{lo:?} {hi:?}");
}

#[test]
fn a_z_section_bends_up_at_one_edge_and_down_at_the_other() {
    let (t, k, r) = (2.0, 0.5, 1.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    // Flange 60, web 40, flange 30 on one skin: its first corner is the outside of its bend,
    // its second the inside.
    let bends = section(&mut s, &[(0.0, 0.0), (60.0, 0.0), (60.0, 40.0), (90.0, 40.0)], t, 100.0);
    run(&mut s, "sheet.convert", json!({"body": "Section", "face": [30, 0, 50], "bends": bends}));
    let mut directions: Vec<String> = bend_rows(&mut s).into_iter().map(|row| row.1).collect();
    directions.sort();
    assert_eq!(directions, ["down", "up"]);
    // Outside setbacks R + T at the first bend, inside setbacks R at the second, and a 90°
    // allowance for each: 60 + 40 + 30 - 2 (R + T) - 2 R + π (R + K T) = 128.2832.
    let across = 130.0 - 2.0 * (r + t) - 2.0 * r + PI * (r + k * t);
    assert!((across - 128.283185).abs() < 1e-6);
    assert!(same_size(flat_size(&mut s), (across, 100.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    let (lo, hi) = bbox(&mut s);
    assert!(
        lo.iter().all(|v| v.abs() < 1e-6) && (hi[0] - 90.0).abs() < 1e-6 && (hi[1] - 42.0).abs() < 1e-6 && (hi[2] - 100.0).abs() < 1e-6,
        "{lo:?} {hi:?}"
    );
    // Three flat strips and two quarter rounds on the neutral radius R + T/2.
    let expect = t * 100.0 * ((60.0 - (r + t)) + (40.0 - (r + t) - r) + (30.0 - r) + PI * (r + t / 2.0));
    assert!((volume(&mut s) - expect).abs() < 2e-3 * expect, "{} vs {expect}", volume(&mut s));
}

#[test]
fn a_tapered_tray_converts_with_72_degree_walls_and_slanted_corners() {
    let (t, k, r, gap) = (2.0, 0.5, 1.0, 0.5);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, gap);
    run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Floor"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [200, 120]}));
    run(&mut s, "sketch.finish", json!({}));
    // Walls leaning out 18°: 72° bends from the floor.
    run(&mut s, "solid.extrude", json!({"sketch": "Floor", "distance": 40, "taper": "18 deg", "body_name": "Tray"}));
    let (lo, hi) = bbox(&mut s);
    assert!(hi[0] - lo[0] > 200.0 + 1.0, "the taper widens the top: {lo:?} {hi:?}");
    run(&mut s, "solid.shell", json!({"faces": [[100, 60, 40]], "thickness": t}));
    run(&mut s, "sheet.convert", json!({"body": "Tray", "face": [100, 60, 0], "bends": [[100, 0, 0], [200, 60, 0], [100, 120, 0], [0, 60, 0]]}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 4 && rows.iter().all(|row| row.0 == 72 && row.1 == "up"), "{rows:?}");
    let slant = 40.0 / 72f64.to_radians().sin();
    let bd = deduction(72f64.to_radians(), r, t, k);
    assert!(same_size(flat_size(&mut s), (200.0 + 2.0 * slant - 2.0 * bd, 120.0 + 2.0 * slant - 2.0 * bd), 1e-6), "{:?}", flat_size(&mut s));
    // The outside stays; the rim is cut square to the sheet, as a blank is, so the inside edge
    // of a wall leaning out 18° stands T sin 18° above the solid's level rim.
    let (lo2, hi2) = bbox(&mut s);
    assert!((0..2).all(|i| (lo2[i] - lo[i]).abs() < 1e-6 && (hi2[i] - hi[i]).abs() < 1e-6) && lo2[2].abs() < 1e-6, "{lo2:?} {hi2:?}");
    assert!((hi2[2] - 40.0 - t * 18f64.to_radians().sin()).abs() < 1e-6, "{hi2:?}");
    let v = volume(&mut s);
    run(&mut s, "sheet.unfold", json!({}));
    run(&mut s, "sheet.refold", json!({}));
    assert!((volume(&mut s) - v).abs() < 1e-6 * v);
}

#[test]
fn the_sheet_follows_the_solid_through_parameter_changes_undo_and_reopening() {
    let (t, k, r) = (2.0, 0.44, 2.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    run(&mut s, "parameters.add", json!({"name": "L", "expression": "100 mm"}));
    run(&mut s, "parameters.add", json!({"name": "T", "expression": "2 mm"}));
    run(&mut s, "solid.box", json!({"length": "L", "width": 60, "height": 30, "body_name": "Tray"}));
    run(&mut s, "solid.shell", json!({"faces": [[50, 30, 30]], "thickness": "T"}));
    run(&mut s, "sheet.convert", json!({"body": "Tray", "face": [50, 30, 0], "bends": BOTTOM_EDGES}));
    let bd = |t: f64| deduction(FRAC_PI_2, r, t, k);
    assert!(same_size(flat_size(&mut s), (160.0 - 2.0 * bd(t), 120.0 - 2.0 * bd(t)), 1e-6));
    // Longer: the right-hand bend edge moved from x = 100 to x = 140 and is found by its name.
    run(&mut s, "parameters.change", json!({"name": "L", "expression": "140 mm"}));
    assert!(s.model.results.iter().all(|x| x.error.is_none()), "{:?}", s.model.results.iter().map(|x| (&x.name, &x.error)).collect::<Vec<_>>());
    assert!(same_size(flat_size(&mut s), (200.0 - 2.0 * bd(t), 120.0 - 2.0 * bd(t)), 1e-6), "{:?}", flat_size(&mut s));
    let (_, hi) = bbox(&mut s);
    assert!((hi[0] - 140.0).abs() < 1e-6, "{hi:?}");
    // Thicker walls: the sheet takes the shell's new thickness.
    run(&mut s, "parameters.change", json!({"name": "T", "expression": "3 mm"}));
    assert!(s.model.results.iter().all(|x| x.error.is_none()));
    assert!((flat(&mut s)["thickness"].as_f64().unwrap_or(0.0) - 3.0).abs() < 1e-9);
    let thick = (200.0 - 2.0 * bd(3.0), 120.0 - 2.0 * bd(3.0));
    assert!(same_size(flat_size(&mut s), thick, 1e-6), "{:?}", flat_size(&mut s));
    run(&mut s, "edit.undo", json!({}));
    assert!(same_size(flat_size(&mut s), (200.0 - 2.0 * bd(t), 120.0 - 2.0 * bd(t)), 1e-6));
    run(&mut s, "edit.redo", json!({}));
    assert!(same_size(flat_size(&mut s), thick, 1e-6));
    // The design file keeps the bend edges, and reopens to the same sheet.
    let saved = s.doc.to_json();
    assert!(saved.contains("\"bends\""), "{saved}");
    let mut reopened = Session::new(solidcraft_doc::Document::from_json(&saved).unwrap());
    assert!(same_size(flat_size(&mut reopened), thick, 1e-6));
    // Bend edges came with format 17: a build from before them asks for an update.
    let version = serde_json::from_str::<Value>(&saved).unwrap()["format"].as_str().and_then(solidcraft_doc::format::version_of);
    assert!(version >= Some(17), "{version:?}");
}

/// Designs from before bend edges open unchanged: a plate conversion saves without `bends`, as
/// it always did, and a format 16 file with one is the same document and the same sheet.
#[test]
fn designs_from_before_bend_edges_open_unchanged() {
    let mut s = Session::default();
    rule(&mut s, "Test", 2.0, 0.44, 2.0, 0.5);
    run(&mut s, "solid.box", json!({"length": 100, "width": 60, "height": 2, "body_name": "Plate"}));
    run(&mut s, "sheet.convert", json!({"body": "Plate", "face": [50, 30, 2]}));
    let mut older: Value = serde_json::from_str(&s.doc.to_json()).unwrap();
    assert!(!older.to_string().contains("\"bends\""), "{older}");
    older["format"] = json!("solidcraft/16");
    let doc = solidcraft_doc::Document::from_json(&older.to_string()).unwrap();
    assert_eq!(doc, *s.doc);
    let mut reopened = Session::new(doc);
    assert!(reopened.model.results.iter().all(|x| x.error.is_none()));
    assert!(same_size(flat_size(&mut reopened), (100.0, 60.0), 1e-9), "{:?}", flat_size(&mut reopened));
    assert!((volume(&mut reopened) - 100.0 * 60.0 * 2.0).abs() < 1e-6);
    assert_eq!(flat(&mut reopened), flat(&mut s));
}

#[test]
fn bend_edges_changed_in_an_edit_are_the_ones_bent() {
    let (t, k, r) = (2.0, 0.44, 2.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    tray(&mut s, t);
    let made = run(&mut s, "sheet.convert", json!({"body": "Tray", "face": [50, 30, 0], "bends": BOTTOM_EDGES}));
    // Only the two long walls: a channel as long as the tray, 60 + 2 x 30 less two deductions
    // across. (By the names of the first two edges it would be the front and the right wall.)
    run(&mut s, "timeline.edit", json!({"feature": made["feature"], "set": {"bends": [BOTTOM_EDGES[0], BOTTOM_EDGES[2]]}}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 2 && rows.iter().all(|row| row.0 == 90 && row.1 == "up" && (row.2 - 100.0).abs() < 1e-6), "{rows:?}");
    let across = 120.0 - 2.0 * deduction(FRAC_PI_2, r, t, k);
    assert!(same_size(flat_size(&mut s), (100.0, across), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    // Its end walls are no faces of the sheet any more: the channel is open at both ends.
    let expect = t * 100.0 * ((60.0 - 2.0 * (r + t)) + 2.0 * (30.0 - (r + t)) + PI * (r + t / 2.0));
    assert!((volume(&mut s) - expect).abs() < 2e-3 * expect, "{} vs {expect}", volume(&mut s));
}

/// A channel 40 wide with walls 30 high (outside sizes), 2 thick and 100 long, its two corners
/// drawn as chamfers, as a model without bend radii draws a bend: 4 along each outer face and 2
/// along each inner one, the chords of an R 2 bend's outside (R + T) and inside (R).
fn chamfered_channel(s: &mut Session) {
    let pts = [[0, 30], [0, 4], [4, 0], [36, 0], [40, 4], [40, 30], [38, 30], [38, 4], [36, 2], [4, 2], [2, 4], [2, 30]];
    run(s, "sketch.create", json!({"plane": "XY", "name": "Channel"}));
    run(s, "sketch.line", json!({"points": pts, "closed": true}));
    run(s, "sketch.finish", json!({}));
    run(s, "solid.extrude", json!({"sketch": "Channel", "distance": 100, "body_name": "Channel"}));
}

#[test]
fn a_chamfer_picked_in_its_middle_is_one_bend_at_the_virtual_sharp() {
    // The rule's radius bends, not the one the chamfers stand for.
    let (t, k, r) = (2.0, 0.5, 3.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    chamfered_channel(&mut s);
    // The middle of each outer chamfer.
    run(&mut s, "sheet.convert", json!({"body": "Channel", "face": [20, 0, 50], "bends": [[2, 2, 50], [38, 2, 50]]}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 2 && rows.iter().all(|row| row.0 == 90 && row.1 == "up" && (row.2 - 100.0).abs() < 1e-6), "{rows:?}");
    // The outside lengths to the virtual sharps less a 90° deduction each:
    // 30 + 40 + 30 - 2 (2 (R + T) - π/2 (R + K T)) = 100 - 2 (10 - 2π) = 92.5664.
    let across = 100.0 - 2.0 * deduction(FRAC_PI_2, r, t, k);
    assert!((across - 92.566371).abs() < 1e-6);
    assert!(same_size(flat_size(&mut s), (across, 100.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    // The envelope of the sharp corners stays; the chamfers are gone into the bends.
    let (lo, hi) = bbox(&mut s);
    assert!(
        lo.iter().all(|v| v.abs() < 1e-6) && (hi[0] - 40.0).abs() < 1e-6 && (hi[1] - 30.0).abs() < 1e-6 && (hi[2] - 100.0).abs() < 1e-6,
        "{lo:?} {hi:?}"
    );
    // Three flat strips and two quarter rounds on the neutral radius R + T/2.
    let expect = t * 100.0 * (2.0 * (30.0 - (r + t)) + (40.0 - 2.0 * (r + t)) + PI * (r + t / 2.0));
    assert!((volume(&mut s) - expect).abs() < 2e-3 * expect, "{} vs {expect}", volume(&mut s));
    // The design keeps the chamfers' points and reopens to the same sheet.
    let saved = s.doc.to_json();
    let mut reopened = Session::new(solidcraft_doc::Document::from_json(&saved).unwrap());
    assert!(same_size(flat_size(&mut reopened), (across, 100.0), 1e-6), "{:?}", flat_size(&mut reopened));

    // Picked on the inner skin, from the inside of the base: the same sheet, bent down.
    let mut b = Session::default();
    rule(&mut b, "Test", t, k, r, 0.5);
    chamfered_channel(&mut b);
    run(&mut b, "sheet.convert", json!({"body": "Channel", "face": [20, 2, 50], "bends": [[3, 3, 50], [37, 3, 50]]}));
    assert!(bend_rows(&mut b).iter().all(|row| row.0 == 90 && row.1 == "down"), "{:?}", bend_rows(&mut b));
    assert!(same_size(flat_size(&mut b), (across, 100.0), 1e-6), "{:?}", flat_size(&mut b));
    assert!((volume(&mut b) - expect).abs() < 2e-3 * expect, "{} vs {expect}", volume(&mut b));

    // Points on a chamfer's edges pick those edges, as before: four 45° bends with the
    // chamfers as narrow faces of the sheet.
    let mut e = Session::default();
    rule(&mut e, "Test", t, k, r, 0.5);
    chamfered_channel(&mut e);
    run(&mut e, "sheet.convert", json!({"body": "Channel", "face": [20, 0, 50], "bends": [[0, 4, 50], [4, 0, 50], [36, 0, 50], [40, 4, 50]]}));
    let rows = bend_rows(&mut e);
    assert!(rows.len() == 4 && rows.iter().all(|row| row.0 == 45), "{rows:?}");
    // A chamfer and one of its edges at once is refused.
    let mut f = Session::default();
    rule(&mut f, "Test", t, k, r, 0.5);
    chamfered_channel(&mut f);
    let both = f.execute("sheet.convert", &json!({"body": "Channel", "face": [20, 0, 50], "bends": [[2, 2, 50], [4, 0, 50]]}));
    let msg = both.err().map(|x| x.to_string()).unwrap_or_default();
    assert!(msg.contains("not both"), "{msg}");
}

/// A strip `t` thick along the polyline `outer` (its material to the left of the way the line
/// runs, as [`section`]), extruded `len` along z as the body `Section`, its corners bent as a
/// sheet metal model draws them: an arc of radius `ri` on the inside of each bend and one of
/// `ri + t` on the outside, about one axis. Returns, per corner, a point in the middle of its
/// outer arc and one in the middle of its inner arc.
fn bent_section(s: &mut Session, outer: &[(f64, f64)], t: f64, ri: f64, len: f64) -> Vec<([f64; 3], [f64; 3])> {
    let n = outer.len();
    let dir = |i: usize| {
        let (a, b) = (outer[i], outer[i + 1]);
        let l = (b.0 - a.0).hypot(b.1 - a.1);
        ((b.0 - a.0) / l, (b.1 - a.1) / l)
    };
    let left = |d: (f64, f64)| (-d.1, d.0);
    let at = |p: (f64, f64), d: (f64, f64), k: f64| (p.0 + d.0 * k, p.1 + d.1 * k);
    // Per corner: where its arc starts and ends on the line's skin and on the other skin, the
    // middles of those two arcs, and the middles of its outer and its inner arc.
    let mut corners = Vec::new();
    for (i, &c) in outer.iter().enumerate().take(n - 1).skip(1) {
        let (d0, d1) = (dir(i - 1), dir(i));
        let (cross, dot) = (d0.0 * d1.1 - d0.1 * d1.0, d0.0 * d1.0 + d0.1 * d1.1);
        let theta = cross.abs().atan2(dot);
        // Turning toward the material, this skin is the bend's outside.
        let (rp, ro) = if cross > 0.0 { (ri + t, ri) } else { (ri, ri + t) };
        let a = at(c, d0, -rp * (theta / 2.0).tan());
        let b = at(c, d1, rp * (theta / 2.0).tan());
        let centre = at(a, left(d0), if cross > 0.0 { rp } else { -rp });
        let (ai, bi) = (at(a, left(d0), t), at(b, left(d1), t));
        let l = (c.0 - centre.0).hypot(c.1 - centre.1);
        let mid = |r: f64| (centre.0 + (c.0 - centre.0) / l * r, centre.1 + (c.1 - centre.1) / l * r);
        corners.push((a, b, ai, bi, mid(rp), mid(ro), (mid(ri + t), mid(ri))));
    }
    let xy = |p: (f64, f64)| [p.0, p.1];
    run(s, "sketch.create", json!({"plane": "XY", "name": "Section"}));
    let mut from = outer[0];
    for &(a, b, _, _, m, ..) in &corners {
        run(s, "sketch.line", json!({"points": [xy(from), xy(a)]}));
        run(s, "sketch.arc.three_point", json!({"start": xy(a), "end": xy(b), "through": xy(m)}));
        from = b;
    }
    let (last, first) = (at(outer[n - 1], left(dir(n - 2)), t), at(outer[0], left(dir(0)), t));
    run(s, "sketch.line", json!({"points": [xy(from), xy(outer[n - 1]), xy(last)]}));
    from = last;
    for &(_, _, ai, bi, _, m, _) in corners.iter().rev() {
        run(s, "sketch.line", json!({"points": [xy(from), xy(bi)]}));
        run(s, "sketch.arc.three_point", json!({"start": xy(bi), "end": xy(ai), "through": xy(m)}));
        from = ai;
    }
    run(s, "sketch.line", json!({"points": [xy(from), xy(first), xy(outer[0])]}));
    run(s, "sketch.finish", json!({}));
    run(s, "solid.extrude", json!({"sketch": "Section", "distance": len, "body_name": "Section"}));
    let z = len / 2.0;
    corners.iter().map(|&(.., (m, mi))| ([m.0, m.1, z], [mi.0, mi.1, z])).collect()
}

#[test]
fn a_bend_modelled_with_its_radius_is_one_bend_of_the_rules_radius() {
    // An L: a base 60 and a leg 40 to the sharp corner outside, 2 thick and 100 long, its
    // corner bent R 2 inside and R 4 outside. The rule bends R 3: its radius, not the model's.
    let (t, k, r) = (2.0, 0.5, 3.0);
    let l = |s: &mut Session| {
        rule(s, "Test", t, k, r, 0.5);
        bent_section(s, &[(0.0, 40.0), (0.0, 0.0), (60.0, 0.0)], t, 2.0, 100.0)[0]
    };
    let mut s = Session::default();
    let (outer, inner) = l(&mut s);
    run(&mut s, "sheet.convert", json!({"body": "Section", "face": [30, 0, 50], "bends": [outer]}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 1 && rows[0].0 == 90 && rows[0].1 == "up" && (rows[0].2 - 100.0).abs() < 1e-6, "{rows:?}");
    let allowance = flat(&mut s)["bends"][0]["allowance"].as_f64().unwrap_or(0.0);
    assert!((allowance - FRAC_PI_2 * (r + k * t)).abs() < 1e-9, "{allowance}");
    // The outside lengths to the virtual sharp less one 90° deduction:
    // 60 + 40 - (2 (R + T) - π/2 (R + K T)) = 100 - (10 - 2π) = 96.2832.
    let across = 100.0 - deduction(FRAC_PI_2, r, t, k);
    assert!((across - 96.283185).abs() < 1e-6);
    assert!(same_size(flat_size(&mut s), (across, 100.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    // The envelope of the sharp corner stays; the round is the rule's, R + T outside.
    let (lo, hi) = bbox(&mut s);
    assert!(
        lo.iter().all(|v| v.abs() < 1e-6) && (hi[0] - 60.0).abs() < 1e-6 && (hi[1] - 40.0).abs() < 1e-6 && (hi[2] - 100.0).abs() < 1e-6,
        "{lo:?} {hi:?}"
    );
    // Two flat strips and a quarter round on the neutral radius R + T/2.
    let expect = t * 100.0 * ((60.0 - (r + t)) + (40.0 - (r + t)) + FRAC_PI_2 * (r + t / 2.0));
    assert!((volume(&mut s) - expect).abs() < 2e-3 * expect, "{} vs {expect}", volume(&mut s));
    // The design keeps the cylinder's point and reopens to the same sheet.
    let saved = s.doc.to_json();
    let mut reopened = Session::new(solidcraft_doc::Document::from_json(&saved).unwrap());
    assert!(same_size(flat_size(&mut reopened), (across, 100.0), 1e-6), "{:?}", flat_size(&mut reopened));

    // The inner cylinder is the same bend; and from the inside of the base, the sheet's other
    // skin is the fixed one, the bend turning down from it, picked on either cylinder: the
    // inside lengths to the inner sharp, 58 + 38, less 2 R plus the allowance, the same blank.
    assert!((58.0 + 38.0 - 2.0 * r + allowance - across).abs() < 1e-9);
    for (face, bend, direction) in [([30.0, 0.0, 50.0], inner, "up"), ([30.0, 2.0, 50.0], outer, "down"), ([30.0, 2.0, 50.0], inner, "down")] {
        let mut b = Session::default();
        l(&mut b);
        run(&mut b, "sheet.convert", json!({"body": "Section", "face": face, "bends": [bend]}));
        assert!(bend_rows(&mut b).iter().all(|row| row.0 == 90 && row.1 == direction), "{face:?} {bend:?}: {:?}", bend_rows(&mut b));
        assert!(same_size(flat_size(&mut b), (across, 100.0), 1e-6), "{face:?} {bend:?}: {:?}", flat_size(&mut b));
        assert!((volume(&mut b) - expect).abs() < 2e-3 * expect, "{face:?} {bend:?}: {} vs {expect}", volume(&mut b));
    }
}

#[test]
fn a_channel_with_its_bends_modelled_folds_back_into_itself_under_its_own_radius() {
    // A channel 40 wide with walls 30 high to the sharp corners outside, 2 thick and 100 long,
    // bent R 2 inside, R 4 outside. Under a rule of that radius the sheet is the model.
    let (t, k, r) = (2.0, 0.44, 2.0);
    let channel = |s: &mut Session| {
        rule(s, "Test", t, k, r, 0.5);
        bent_section(s, &[(0.0, 30.0), (0.0, 0.0), (40.0, 0.0), (40.0, 30.0)], t, r, 100.0)
    };
    let mut s = Session::default();
    let corners = channel(&mut s);
    let solid = volume(&mut s);
    // Two flat walls, the base and two quarter rounds on the neutral radius R + T/2.
    let expect = t * 100.0 * (2.0 * (30.0 - (r + t)) + (40.0 - 2.0 * (r + t)) + PI * (r + t / 2.0));
    assert!((solid - expect).abs() < 2e-3 * expect, "{solid} vs {expect}");
    // One bend picked on its outer cylinder, the other on its inner one.
    run(&mut s, "sheet.convert", json!({"body": "Section", "face": [20, 0, 50], "bends": [corners[0].0, corners[1].1]}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 2 && rows.iter().all(|row| row.0 == 90 && row.1 == "up" && (row.2 - 100.0).abs() < 1e-6), "{rows:?}");
    // 30 + 40 + 30 less two deductions, 2 (R + T) - π/2 (R + K T) each.
    let across = 100.0 - 2.0 * deduction(FRAC_PI_2, r, t, k);
    assert!(same_size(flat_size(&mut s), (across, 100.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    // The same solid as before: its volume and its box.
    assert!((volume(&mut s) - solid).abs() < 1e-3 * solid, "{} vs {solid}", volume(&mut s));
    let (lo, hi) = bbox(&mut s);
    assert!(
        lo.iter().all(|v| v.abs() < 1e-6) && (hi[0] - 40.0).abs() < 1e-6 && (hi[1] - 30.0).abs() < 1e-6 && (hi[2] - 100.0).abs() < 1e-6,
        "{lo:?} {hi:?}"
    );
    // Unfold and refold keep it.
    run(&mut s, "sheet.unfold", json!({}));
    let (lo, hi) = bbox(&mut s);
    let flat_box = [(hi[0] - lo[0], hi[1] - lo[1]), (hi[0] - lo[0], hi[2] - lo[2]), (hi[1] - lo[1], hi[2] - lo[2])];
    assert!(flat_box.iter().any(|b| same_size(*b, (across, 100.0), 1e-6)), "{lo:?} {hi:?}");
    run(&mut s, "sheet.refold", json!({}));
    assert!((volume(&mut s) - solid).abs() < 1e-3 * solid);
}

#[test]
fn a_filleted_edge_of_a_solid_block_is_a_bend() {
    // A block's bottom edge rounded R 5: the faces either side meet at the old sharp edge,
    // the rule's thickness taken inward, an L with a 100 base and a 30 wall outside.
    let (t, k, r) = (2.0, 0.44, 2.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    run(&mut s, "solid.box", json!({"length": 100, "width": 60, "height": 30, "body_name": "Block"}));
    run(&mut s, "solid.fillet", json!({"edges": [[100, 30, 0]], "radius": 5}));
    let h = 5.0 * (1.0 - 0.5f64.sqrt());
    run(&mut s, "sheet.convert", json!({"body": "Block", "face": [50, 30, 0], "bends": [[100.0 - h, 30.0, h]]}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 1 && rows[0].0 == 90 && rows[0].1 == "up" && (rows[0].2 - 60.0).abs() < 1e-6, "{rows:?}");
    let across = 130.0 - deduction(FRAC_PI_2, r, t, k);
    assert!(same_size(flat_size(&mut s), (across, 60.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
}

#[test]
fn edge_flanges_and_cuts_work_on_a_converted_sheet() {
    let mut s = Session::default();
    rule(&mut s, "Test", 2.0, 0.44, 2.0, 0.5);
    tray(&mut s, 2.0);
    run(&mut s, "sheet.convert", json!({"body": "Tray", "face": [50, 30, 0], "bends": BOTTOM_EDGES}));
    let v0 = volume(&mut s);
    // A return flange on the front wall's top edge.
    run(&mut s, "sheet.flange", json!({"edges": [[50, 0, 30]], "height": 10, "angle": 90}));
    let v1 = volume(&mut s);
    assert!(v1 > v0 + 500.0, "{v0} {v1}");
    assert_eq!(bend_rows(&mut s).len(), 5);
    // A hole cut in the flat stays in the base when the tray is folded again.
    run(&mut s, "sheet.unfold", json!({}));
    run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Hole"}));
    run(&mut s, "sketch.circle.center", json!({"center": [50, 30], "radius": 5}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "Hole", "distance": 10, "operation": "cut", "direction": "symmetric"}));
    run(&mut s, "sheet.refold", json!({}));
    assert_eq!(flat(&mut s)["cutouts"].as_array().map(Vec::len), Some(1));
    let hole = PI * 25.0 * 2.0;
    assert!((volume(&mut s) - (v1 - hole)).abs() < 2e-3 * v1, "{} vs {}", volume(&mut s), v1 - hole);
}

#[test]
fn conversions_that_cannot_work_say_why() {
    let mut s = Session::default();
    rule(&mut s, "Wide", 2.0, 0.44, 40.0, 0.5);
    rule(&mut s, "Test", 2.0, 0.44, 2.0, 0.5);
    tray(&mut s, 2.0);
    let err = |s: &mut Session, p: Value| s.execute("sheet.convert", &p).err().map(|e| e.to_string()).unwrap_or_default();
    // A bend that doesn't reach the fixed face through other bends.
    let e = err(&mut s, json!({"body": "Tray", "face": [50, 30, 0], "bends": [[0, 0, 15]]}));
    assert!(e.contains("does not connect"), "{e}");
    // No edge there, and no face there.
    let e = err(&mut s, json!({"body": "Tray", "face": [50, 30, 0], "bends": [[50, 30, 0]]}));
    assert!(e.contains("no edge"), "{e}");
    let e = err(&mut s, json!({"body": "Tray", "face": [50, 30, -20], "bends": BOTTOM_EDGES}));
    assert!(e.contains("no face"), "{e}");
    // A loop of bends.
    let mut bends: Vec<[f64; 3]> = BOTTOM_EDGES.to_vec();
    bends.push([0.0, 0.0, 15.0]);
    let e = err(&mut s, json!({"body": "Tray", "face": [50, 30, 0], "bends": bends}));
    assert!(e.contains("loop"), "{e}");
    // Walls shorter than their bends' setbacks (a 40 mm bend radius on 30 mm walls).
    let e = err(&mut s, json!({"body": "Tray", "face": [50, 30, 0], "bends": BOTTOM_EDGES, "rule": "Wide"}));
    assert!(e.contains("setback"), "{e}");
    // The sheet's values are the rule's; an empty list of bends is not a plate.
    let e = err(&mut s, json!({"body": "Tray", "face": [50, 30, 0], "bends": BOTTOM_EDGES, "thickness": 3}));
    assert!(e.contains("the sheet metal rule sets it"), "{e}");
    let e = err(&mut s, json!({"body": "Tray", "face": [50, 30, 0], "bends": []}));
    assert!(e.contains("1…1000"), "{e}");
    // Curved faces.
    let mut c = Session::default();
    run(&mut c, "solid.cylinder", json!({"radius": 10, "height": 30, "body_name": "Rod"}));
    let e = err(&mut c, json!({"body": "Rod", "face": [0, 0, 30], "bends": [[10, 0, 30]]}));
    assert!(e.contains("curved"), "{e}");
    // Nothing changed.
    assert!(s.model.state().sheets.is_empty() && c.model.state().sheets.is_empty());
}

/// One side face of a plate written to STEP: flat from `a` to `b`, or a piece of a round wall
/// about `c` from `a` to `b` (counter-clockwise seen from +z when `ccw`).
#[derive(Clone, Copy)]
enum Wall {
    Flat([f64; 2], [f64; 2]),
    Round([f64; 2], [f64; 2], [f64; 2], bool),
}

impl Wall {
    fn ends(&self) -> ([f64; 2], [f64; 2]) {
        match *self {
            Wall::Flat(a, b) | Wall::Round(a, b, _, _) => (a, b),
        }
    }
}

/// A round hole of radius `r` about `c` (clockwise seen from +z), its wall in `pieces` cylinder
/// faces, the first seam at `seam` degrees.
fn hole(c: [f64; 2], r: f64, pieces: usize, seam: f64) -> Vec<Wall> {
    let at = |i: usize| {
        let a = (seam - 360.0 * i as f64 / pieces as f64).to_radians();
        [c[0] + r * a.cos(), c[1] + r * a.sin()]
    };
    (0..pieces).map(|i| Wall::Round(at(i), at(i + 1), c, false)).collect()
}

/// A rectangle (counter-clockwise), its bottom side split in two faces when `split`.
fn rectangle(w: f64, h: f64, split: bool) -> Vec<Wall> {
    let mut walls = if split {
        vec![Wall::Flat([0.0, 0.0], [w / 2.0, 0.0]), Wall::Flat([w / 2.0, 0.0], [w, 0.0])]
    } else {
        vec![Wall::Flat([0.0, 0.0], [w, 0.0])]
    };
    walls.extend([Wall::Flat([w, 0.0], [w, h]), Wall::Flat([w, h], [0.0, h]), Wall::Flat([0.0, h], [0.0, 0.0])]);
    walls
}

/// The entities of a STEP file, numbered as they are added; vertices and vertical edges once.
#[derive(Default)]
struct Step {
    lines: Vec<String>,
    vertices: Vec<([i64; 3], usize)>,
    verticals: Vec<([i64; 2], usize)>,
}

impl Step {
    fn add(&mut self, entity: String) -> usize {
        self.lines.push(format!("#{}={entity};", self.lines.len() + 1));
        self.lines.len()
    }

    fn point(&mut self, p: [f64; 3]) -> usize {
        self.add(format!("CARTESIAN_POINT('',({:.12},{:.12},{:.12}))", p[0], p[1], p[2]))
    }

    fn frame(&mut self, o: [f64; 3], z: [f64; 3], x: [f64; 3]) -> usize {
        let o = self.point(o);
        let z = self.add(format!("DIRECTION('',({:.12},{:.12},{:.12}))", z[0], z[1], z[2]));
        let x = self.add(format!("DIRECTION('',({:.12},{:.12},{:.12}))", x[0], x[1], x[2]));
        self.add(format!("AXIS2_PLACEMENT_3D('',#{o},#{z},#{x})"))
    }

    fn vertex(&mut self, p: [f64; 2], z: f64) -> usize {
        let key = [p[0], p[1], z].map(|v| (v * 1e9).round() as i64);
        if let Some((_, v)) = self.vertices.iter().find(|(k, _)| *k == key) {
            return *v;
        }
        let point = self.point([p[0], p[1], z]);
        let v = self.add(format!("VERTEX_POINT('',#{point})"));
        self.vertices.push((key, v));
        v
    }

    fn line(&mut self, a: [f64; 3], b: [f64; 3], va: usize, vb: usize) -> usize {
        let d = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
        let l = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt();
        let p = self.point(a);
        let dir = self.add(format!("DIRECTION('',({:.12},{:.12},{:.12}))", d[0] / l, d[1] / l, d[2] / l));
        let v = self.add(format!("VECTOR('',#{dir},{l:.12})"));
        let line = self.add(format!("LINE('',#{p},#{v})"));
        self.add(format!("EDGE_CURVE('',#{va},#{vb},#{line},.T.)"))
    }

    /// The wall's edge at height `z`.
    fn edge(&mut self, wall: Wall, z: f64) -> usize {
        let (a, b) = wall.ends();
        let (va, vb) = (self.vertex(a, z), self.vertex(b, z));
        match wall {
            Wall::Flat(..) => self.line([a[0], a[1], z], [b[0], b[1], z], va, vb),
            Wall::Round(_, _, c, ccw) => {
                let frame = self.frame([c[0], c[1], z], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
                let r = (a[0] - c[0]).hypot(a[1] - c[1]);
                let circle = self.add(format!("CIRCLE('',#{frame},{r:.12})"));
                self.add(format!("EDGE_CURVE('',#{va},#{vb},#{circle},{})", if ccw { ".T." } else { ".F." }))
            }
        }
    }

    fn vertical(&mut self, p: [f64; 2], t: f64) -> usize {
        let key = p.map(|v| (v * 1e9).round() as i64);
        if let Some((_, e)) = self.verticals.iter().find(|(k, _)| *k == key) {
            return *e;
        }
        let (v0, v1) = (self.vertex(p, 0.0), self.vertex(p, t));
        let e = self.line([p[0], p[1], 0.0], [p[0], p[1], t], v0, v1);
        self.verticals.push((key, e));
        e
    }

    fn edge_loop(&mut self, edges: &[(usize, bool)]) -> usize {
        let oriented: Vec<String> = edges
            .iter()
            .map(|(e, forward)| format!("#{}", self.add(format!("ORIENTED_EDGE('',*,*,#{e},{})", if *forward { ".T." } else { ".F." }))))
            .collect();
        self.add(format!("EDGE_LOOP('',({}))", oriented.join(",")))
    }
}

/// STEP text of a plate `t` thick standing on z = 0, its outline `loops` (the outer one
/// counter-clockwise, holes clockwise, seen from +z) with one side face per wall: a plane, or a
/// cylinder piece. Hand-written, the way exporters that split closed faces write them.
fn plate_step(loops: &[Vec<Wall>], t: f64) -> String {
    let mut s = Step::default();
    let bottom: Vec<Vec<usize>> = loops.iter().map(|l| l.iter().map(|w| s.edge(*w, 0.0)).collect()).collect();
    let top: Vec<Vec<usize>> = loops.iter().map(|l| l.iter().map(|w| s.edge(*w, t)).collect()).collect();
    let mut faces = Vec::new();
    for (i, walls) in loops.iter().enumerate() {
        for (j, wall) in walls.iter().enumerate() {
            let (a, b) = wall.ends();
            let (va, vb) = (s.vertical(a, t), s.vertical(b, t));
            let lp = s.edge_loop(&[(bottom[i][j], true), (vb, true), (top[i][j], false), (va, false)]);
            let bound = s.add(format!("FACE_OUTER_BOUND('',#{lp},.T.)"));
            let (surface, sense) = match *wall {
                Wall::Flat(a, b) => {
                    let l = (b[0] - a[0]).hypot(b[1] - a[1]);
                    let (dx, dy) = ((b[0] - a[0]) / l, (b[1] - a[1]) / l);
                    let frame = s.frame([a[0], a[1], 0.0], [dy, -dx, 0.0], [dx, dy, 0.0]);
                    (s.add(format!("PLANE('',#{frame})")), true)
                }
                Wall::Round(a, _, c, ccw) => {
                    let frame = s.frame([c[0], c[1], 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
                    let r = (a[0] - c[0]).hypot(a[1] - c[1]);
                    (s.add(format!("CYLINDRICAL_SURFACE('',#{frame},{r:.12})")), ccw)
                }
            };
            faces.push(s.add(format!("ADVANCED_FACE('',(#{bound}),#{surface},{})", if sense { ".T." } else { ".F." })));
        }
    }
    for (z, edges, up) in [(t, &top, true), (0.0, &bottom, false)] {
        let mut bounds = Vec::new();
        for (i, es) in edges.iter().enumerate() {
            let walk: Vec<(usize, bool)> = if up { es.iter().map(|e| (*e, true)).collect() } else { es.iter().rev().map(|e| (*e, false)).collect() };
            let lp = s.edge_loop(&walk);
            bounds.push(format!("#{}", s.add(format!("{}('',#{lp},.T.)", if i == 0 { "FACE_OUTER_BOUND" } else { "FACE_BOUND" }))));
        }
        let frame = s.frame([0.0, 0.0, z], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
        let plane = s.add(format!("PLANE('',#{frame})"));
        faces.push(s.add(format!("ADVANCED_FACE('',({}),#{plane},{})", bounds.join(","), if up { ".T." } else { ".F." })));
    }
    let faces: Vec<String> = faces.iter().map(|f| format!("#{f}")).collect();
    let shell = s.add(format!("CLOSED_SHELL('',({}))", faces.join(",")));
    let brep = s.add(format!("MANIFOLD_SOLID_BREP('Plate',#{shell})"));
    s.add(format!("SHAPE_REPRESENTATION('',(#{brep}),$)"));
    format!(
        "ISO-10303-21;\nHEADER;\nFILE_DESCRIPTION((''),'2;1');\nFILE_NAME('plate','',(''),(''),'','hand','');\nFILE_SCHEMA(('AUTOMOTIVE_DESIGN {{ 1 0 10303 214 1 1 1 1 }}'));\nENDSEC;\nDATA;\n{}\nENDSEC;\nEND-ISO-10303-21;\n",
        s.lines.join("\n")
    )
}

/// The plate inserted from a STEP file and converted, picked on its top face at `pick`.
fn convert_step_plate(tag: &str, loops: &[Vec<Wall>], t: f64, pick: [f64; 2]) -> Session {
    let path = std::env::temp_dir().join(format!("solidcraft-split-walls-{tag}-{}.step", std::process::id()));
    std::fs::write(&path, plate_step(loops, t)).unwrap();
    let mut s = Session::default();
    run(&mut s, "file.insert_step", json!({"path": path.to_string_lossy()}));
    let _ = std::fs::remove_file(&path);
    run(&mut s, "sheet.convert", json!({"body": "Plate", "face": [pick[0], pick[1], t]}));
    s
}

/// The flat pattern's cut-outs that are whole circles, as (radius, centre).
fn flat_circles(s: &mut Session) -> Vec<(f64, [f64; 2])> {
    let shapes = flat(s)["cutout_shapes"].as_array().cloned().unwrap_or_default();
    let c = |v: &Value| [v["center"][0].as_f64().unwrap_or(f64::NAN), v["center"][1].as_f64().unwrap_or(f64::NAN)];
    shapes.iter().filter_map(|x| x.get("circle")).map(|x| (x["radius"].as_f64().unwrap_or(f64::NAN), c(x))).collect()
}

/// How many entities of each kind the flat pattern's DXF has.
fn dxf_entities(s: &mut Session) -> (usize, usize, usize) {
    let dxf = run(s, "sheet.export_dxf", json!({}))["dxf"].as_str().unwrap_or("").replace("\r\n", "\n");
    // Group codes may be padded (`  0`): compare the code and value lines trimmed.
    let lines: Vec<&str> = dxf.lines().map(str::trim).collect();
    let n = |kind: &str| lines.chunks(2).filter(|pair| pair == &["0", kind]).count();
    (n("LINE"), n("ARC"), n("CIRCLE"))
}

/// A plate whose round holes' walls are two half-cylinders each (as many exporters write a hole)
/// converts with the holes as circles. It was refused as "not a plate of even thickness": its
/// holes came out as polygons, whose area missed the holes' by more than the plate check allows.
#[test]
fn a_plate_whose_hole_walls_are_half_cylinders_converts_with_round_holes() {
    let (w, t, r) = (30.0, 2.0, 2.0);
    let centres = [[6.0, 6.0], [24.0, 6.0], [24.0, 24.0], [6.0, 24.0]];
    let mut loops = vec![rectangle(w, w, false)];
    loops.extend(centres.iter().map(|c| hole(*c, r, 2, 90.0)));
    let mut s = convert_step_plate("halves", &loops, t, [15.0, 15.0]);
    let want = (w * w - 4.0 * PI * r * r) * t;
    assert!((volume(&mut s) - want).abs() < 1e-4 * want, "{} vs {want}", volume(&mut s));
    let circles = flat_circles(&mut s);
    assert_eq!(circles.len(), 4, "{circles:?}");
    assert!(circles.iter().all(|(radius, _)| (radius - r).abs() < 1e-9), "{circles:?}");
    // The holes keep their places: 18 apart along the sides, 18·√2 across.
    let d = |a: [f64; 2], b: [f64; 2]| (a[0] - b[0]).hypot(a[1] - b[1]);
    let mut gaps: Vec<f64> = (0..4).flat_map(|i| (i + 1..4).map(move |j| (i, j))).map(|(i, j)| d(circles[i].1, circles[j].1)).collect();
    gaps.sort_by(f64::total_cmp);
    assert!(gaps[..4].iter().all(|g| (g - 18.0).abs() < 1e-9) && gaps[4..].iter().all(|g| (g - 18.0 * SQRT_2).abs() < 1e-9), "{gaps:?}");
    // The DXF: the outline's four lines and one circle per hole.
    assert_eq!(dxf_entities(&mut s), (4, 0, 4));
}

/// Holes of any radius whose walls come in two, three or four pieces, seams anywhere: each is one
/// circle.
#[test]
fn hole_walls_in_any_number_of_pieces_each_make_one_circle() {
    let (t, holes) = (2.0, [([20.0, 30.0], 5.0, 2, 0.0), ([50.0, 30.0], 3.0, 3, 37.0), ([80.0, 30.0], 8.0, 4, 10.0)]);
    let mut loops = vec![rectangle(100.0, 60.0, false)];
    loops.extend(holes.iter().map(|(c, r, pieces, seam)| hole(*c, *r, *pieces, *seam)));
    let mut s = convert_step_plate("pieces", &loops, t, [35.0, 10.0]);
    let want = (6000.0 - PI * (25.0 + 9.0 + 64.0)) * t;
    assert!((volume(&mut s) - want).abs() < 1e-4 * want, "{} vs {want}", volume(&mut s));
    let mut radii: Vec<f64> = flat_circles(&mut s).iter().map(|c| c.0).collect();
    radii.sort_by(f64::total_cmp);
    assert!(radii.len() == 3 && radii.iter().zip([3.0, 5.0, 8.0]).all(|(a, b)| (a - b).abs() < 1e-9), "{radii:?}");
    assert_eq!(dxf_entities(&mut s), (4, 0, 3));
}

/// Other walls such files split: rounded corners in two pieces each, a slot whose round ends are
/// in two pieces each, a straight side in two faces. Each corner and slot end is one arc, the
/// side one line.
#[test]
fn rounded_corners_slot_ends_and_split_sides_convert_as_single_arcs_and_lines() {
    let (t, rc, rs, rh) = (2.0, 6.0, 4.0, 5.0);
    let quarter = |c: [f64; 2], from: f64, pieces: usize| -> Vec<Wall> {
        let at = |i: usize| {
            let a = (from + 90.0 * i as f64 / pieces as f64).to_radians();
            [c[0] + rc * a.cos(), c[1] + rc * a.sin()]
        };
        (0..pieces).map(|i| Wall::Round(at(i), at(i + 1), c, true)).collect()
    };
    // 100 x 60, corners rounded by 6, the bottom side in two faces.
    let mut outer = vec![Wall::Flat([rc, 0.0], [50.0, 0.0]), Wall::Flat([50.0, 0.0], [100.0 - rc, 0.0])];
    outer.extend(quarter([100.0 - rc, rc], -90.0, 2));
    outer.push(Wall::Flat([100.0, rc], [100.0, 60.0 - rc]));
    outer.extend(quarter([100.0 - rc, 60.0 - rc], 0.0, 2));
    outer.push(Wall::Flat([100.0 - rc, 60.0], [rc, 60.0]));
    outer.extend(quarter([rc, 60.0 - rc], 90.0, 2));
    outer.push(Wall::Flat([0.0, 60.0 - rc], [0.0, rc]));
    outer.extend(quarter([rc, rc], 180.0, 2));
    // A slot 30 between its end centres, 8 wide, each end in two pieces (clockwise).
    let (a, b) = ([45.0, 30.0], [75.0, 30.0]);
    let slot = vec![
        Wall::Flat([a[0], a[1] + rs], [b[0], b[1] + rs]),
        Wall::Round([b[0], b[1] + rs], [b[0] + rs, b[1]], b, false),
        Wall::Round([b[0] + rs, b[1]], [b[0], b[1] - rs], b, false),
        Wall::Flat([b[0], b[1] - rs], [a[0], a[1] - rs]),
        Wall::Round([a[0], a[1] - rs], [a[0] - rs, a[1]], a, false),
        Wall::Round([a[0] - rs, a[1]], [a[0], a[1] + rs], a, false),
    ];
    let loops = vec![outer, slot, hole([20.0, 30.0], rh, 2, 90.0)];
    let mut s = convert_step_plate("sides", &loops, t, [20.0, 50.0]);
    let area = 6000.0 - (4.0 - PI) * rc * rc - (30.0 * 2.0 * rs + PI * rs * rs) - PI * rh * rh;
    assert!((volume(&mut s) - area * t).abs() < 1e-4 * area * t, "{} vs {}", volume(&mut s), area * t);
    // The outline: four lines and four quarter arcs; the slot: two lines and two half arcs; the
    // hole: a circle.
    assert_eq!(dxf_entities(&mut s), (6, 6, 1));
    let shapes = flat(&mut s)["cutout_shapes"].as_array().cloned().unwrap_or_default();
    let slot = shapes.iter().find_map(|x| x["segments"].as_array().cloned()).unwrap_or_default();
    let sweeps: Vec<f64> = slot.iter().filter_map(|x| x["arc"]["sweep_deg"].as_f64()).map(f64::abs).collect();
    assert!(slot.len() == 4 && sweeps.len() == 2 && sweeps.iter().all(|x| (x - 180.0).abs() < 1e-6), "{slot:?}");
}

/// Holes drilled here come out as circles too (their walls are half-cylinders as well), and a
/// plate with many small ones converts: nine 4 mm holes in a 30 x 30 x 2 plate were refused too.
#[test]
fn a_plate_with_holes_drilled_here_converts_with_round_holes() {
    let (w, t, r) = (30.0, 2.0, 2.0);
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": w, "width": w, "height": t, "body_name": "Plate"}));
    for x in [6.0, 15.0, 24.0] {
        for y in [6.0, 15.0, 24.0] {
            run(&mut s, "solid.hole", json!({"position": [x, y, t], "diameter": 2.0 * r}));
        }
    }
    run(&mut s, "sheet.convert", json!({"body": "Plate", "face": [10.5, 10.5, t]}));
    let want = (w * w - 9.0 * PI * r * r) * t;
    assert!((volume(&mut s) - want).abs() < 1e-4 * want, "{} vs {want}", volume(&mut s));
    let circles = flat_circles(&mut s);
    assert!(circles.len() == 9 && circles.iter().all(|(radius, _)| (radius - r).abs() < 1e-9), "{circles:?}");
    assert_eq!(dxf_entities(&mut s), (4, 0, 9));
}

/// A box `l` x `w` x `t` with round holes (centre, diameter) drilled through it, converted,
/// picked on its top face.
fn convert_box(l: f64, w: f64, t: f64, holes: &[([f64; 2], f64)]) -> Session {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": l, "width": w, "height": t, "body_name": "Plate"}));
    for (c, d) in holes {
        run(&mut s, "solid.hole", json!({"position": [c[0], c[1], t], "diameter": d}));
    }
    run(&mut s, "sheet.convert", json!({"body": "Plate", "face": [l * 0.4, w * 0.25, t]}));
    s
}

/// A long thin strip converts. 1200 x 100 x 1 was refused with "no outline on that face": the
/// outline's tolerance was a thousandth of the body's size (1.2), more than the thickness, so the
/// far side's triangles counted as the picked face's and no boundary was left.
#[test]
fn a_long_thin_strip_converts() {
    let mut s = convert_box(1200.0, 100.0, 1.0, &[]);
    assert!((volume(&mut s) - 120_000.0).abs() < 1e-6 * 120_000.0, "{}", volume(&mut s));
    assert!(same_size(flat_size(&mut s), (1200.0, 100.0), 1e-6), "{:?}", flat_size(&mut s));
    let t = flat(&mut s)["flat_size_mm"][2].as_f64().unwrap_or(f64::NAN);
    assert!((t - 1.0).abs() < 1e-9, "{t}");
    assert_eq!(dxf_entities(&mut s), (4, 0, 0));
}

/// Plates further past that, a thousandth of their size two to six times their thickness: a
/// full sheet, a foil, a long bar.
#[test]
fn plates_thousands_of_times_longer_than_thick_convert() {
    for (l, w, t) in [(3000.0, 1500.0, 0.5), (400.0, 100.0, 0.2), (6000.0, 20.0, 1.0)] {
        let mut s = convert_box(l, w, t, &[]);
        let want = l * w * t;
        assert!((volume(&mut s) - want).abs() < 1e-6 * want, "{l} x {w} x {t}: {} vs {want}", volume(&mut s));
        assert!(same_size(flat_size(&mut s), (l, w), 1e-6), "{l} x {w} x {t}: {:?}", flat_size(&mut s));
        assert_eq!(dxf_entities(&mut s), (4, 0, 0), "{l} x {w} x {t}");
    }
}

/// The strip with round holes down to its thickness across keeps every one as a circle. At 1200
/// long it was refused; just under the old limit, 990 long, it converted without the 1 mm hole:
/// the outline's chords could sag 0.99, more than that hole's radius, and it fell out.
#[test]
fn a_long_thin_strip_keeps_its_small_round_holes() {
    let d = [10.0, 4.0, 2.0, 1.0];
    for l in [990.0, 1200.0] {
        let holes: Vec<([f64; 2], f64)> = d.iter().enumerate().map(|(i, d)| ([l * (i as f64 + 1.0) / 5.0, 50.0], *d)).collect();
        let mut s = convert_box(l, 100.0, 1.0, &holes);
        let want = l * 100.0 - PI / 4.0 * d.iter().map(|d| d * d).sum::<f64>();
        assert!((volume(&mut s) - want).abs() < 1e-5 * want, "{l}: {} vs {want}", volume(&mut s));
        let mut radii: Vec<f64> = flat_circles(&mut s).iter().map(|c| c.0).collect();
        radii.sort_by(f64::total_cmp);
        assert!(radii.len() == 4 && radii.iter().zip([0.5, 1.0, 2.0, 5.0]).all(|(a, b)| (a - b).abs() < 1e-9), "{l}: {radii:?}");
        assert_eq!(dxf_entities(&mut s), (4, 0, 4), "{l}");
    }
}

/// A 60 x 40 x 1 plate on XY.
fn plate(s: &mut Session) {
    run(s, "solid.box", json!({"length": 60, "width": 40, "height": 1, "body_name": "Plate"}));
}

/// The plate with what `draw` sketches on its top cut `depth` deep into it (the profiles at
/// `profiles`, all when none).
fn engraved_plate(s: &mut Session, depth: f64, draw: impl Fn(&mut Session), profiles: &[[f64; 2]]) {
    plate(s);
    run(s, "sketch.create", json!({"plane": "XY", "offset": 1, "name": "Label"}));
    draw(s);
    run(s, "sketch.finish", json!({}));
    let mut cut = json!({"sketch": "Label", "distance": depth, "direction": "negative", "operation": "cut"});
    if !profiles.is_empty() {
        cut["profiles"] = profiles.iter().map(|p| json!({"point": p})).collect();
    }
    run(s, "solid.extrude", cut);
}

fn label_rectangle(s: &mut Session) {
    run(s, "sketch.rectangle.two_point", json!({"p0": [10, 10], "p1": [30, 20]}));
}

fn contains(s: &Session, p: [f64; 3]) -> bool {
    s.model.state().bodies.first().is_some_and(|b| b.body.contains(solidcraft_geom::Vec3::new(p[0], p[1], p[2])))
}

/// The LINE entities a DXF draws on `layer` (group codes and values alternate, a line each).
fn lines_on(dxf: &str, layer: &str) -> usize {
    let lines: Vec<&str> = dxf.lines().map(str::trim).collect();
    let mut in_line = false;
    let mut count = 0;
    for pair in lines.chunks(2) {
        match pair {
            ["0", kind] => in_line = *kind == "LINE",
            ["8", name] if in_line && *name == layer => count += 1,
            _ => {}
        }
    }
    count
}

/// A plate with an engraving converts: the engraving is a pocket of the sheet, so the sheet keeps
/// the plate's shape, and its outline is the flat pattern's pocket, on the DXF's pocket layer.
/// Picked on the engraved face, the pocket starts from the sheet's z = 0 (the face picked);
/// picked on the other face, it ends at z = T.
#[test]
fn a_plate_with_an_engraving_converts_with_the_engraving_as_a_pocket() {
    for (pick, layer) in [([45.0, 30.0, 1.0], "POCKET_BOTTOM_Z0.000000_TO_0.100000_MM"), ([45.0, 30.0, 0.0], "POCKET_TOP_Z0.900000_TO_1.000000_MM")] {
        let mut s = Session::default();
        engraved_plate(&mut s, 0.1, label_rectangle, &[]);
        run(&mut s, "sheet.convert", json!({"body": "Plate", "face": pick}));
        assert!(s.model.results.iter().all(|r| r.error.is_none() && r.warning.is_none()), "{pick:?}: {:?}", s.model.results);
        // By hand: 60·40·1 less the engraving's 20·10·0.1; the faces' 2·60·40 + 2·(60 + 40)·1 and
        // the engraving's walls, 2·(20 + 10)·0.1.
        let m = run(&mut s, "inspect.measure", json!({}));
        assert!((m["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN) - 2380.0).abs() < 1e-6, "{pick:?}: {m}");
        assert!((m["total"]["area_mm2"].as_f64().unwrap_or(f64::NAN) - 5006.0).abs() < 1e-6, "{pick:?}: {m}");
        // It stays in the face it was cut into (the converted plate is as thick, wherever it lies).
        let (lo, hi) = bbox(&mut s);
        assert!((hi[2] - lo[2] - 1.0).abs() < 1e-9, "{pick:?}: {lo:?} {hi:?}");
        assert!(!contains(&s, [20.0, 15.0, hi[2] - 0.05]) && contains(&s, [20.0, 15.0, hi[2] - 0.15]), "{pick:?}");
        assert!(contains(&s, [45.0, 30.0, hi[2] - 0.05]), "{pick:?}");
        // The flat pattern: the whole plate, no cut-out, and the engraving as a pocket 0.1 deep.
        let f = flat(&mut s);
        assert!(same_size(flat_size(&mut s), (60.0, 40.0), 1e-9), "{f}");
        assert_eq!(f["cutouts"], json!([]), "{f}");
        let pockets = f["pockets"].as_array().cloned().unwrap_or_default();
        assert_eq!(pockets.len(), 1, "{f}");
        assert!((pockets[0]["depth_mm"].as_f64().unwrap_or(f64::NAN) - 0.1).abs() < 1e-9, "{f}");
        let corners: Vec<(f64, f64)> =
            pockets[0]["outline"].as_array().unwrap().iter().map(|p| (p[0].as_f64().unwrap(), p[1].as_f64().unwrap())).collect();
        let span = |k: fn(&(f64, f64)) -> f64| corners.iter().map(k).fold(f64::MIN, f64::max) - corners.iter().map(k).fold(f64::MAX, f64::min);
        assert!(same_size((span(|p| p.0), span(|p| p.1)), (20.0, 10.0), 1e-9), "{f}");
        // The DXF: the plate's outline and the engraving's, four lines each, on their layers.
        let dxf = run(&mut s, "sheet.export_dxf", json!({}))["dxf"].as_str().unwrap().to_string();
        assert_eq!((lines_on(&dxf, "OUTLINE"), lines_on(&dxf, layer)), (4, 4), "{pick:?}: {dxf}");
        // Nothing is stored for it: reopened, the design builds the same sheet.
        let mut reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
        assert!((volume(&mut reopened) - 2380.0).abs() < 1e-6);
        assert_eq!(flat(&mut reopened), f);
    }
}

/// A plate large enough that its tessellation tolerance (1/1000 of its size, 0.72 mm here) is
/// more than its engraving's depth keeps the engraving too.
#[test]
fn a_large_plate_keeps_an_engraving_shallower_than_its_tessellation_tolerance() {
    let mut s = Session::default();
    run(&mut s, "solid.box", json!({"length": 600, "width": 400, "height": 1, "body_name": "Plate"}));
    run(&mut s, "sketch.create", json!({"plane": "XY", "offset": 1, "name": "Label"}));
    label_rectangle(&mut s);
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "Label", "distance": 0.1, "direction": "negative", "operation": "cut"}));
    for pick in [[450.0, 300.0, 0.0], [450.0, 300.0, 1.0]] {
        let mut s = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
        run(&mut s, "sheet.convert", json!({"body": "Plate", "face": pick}));
        // 600·400·1 less the engraving's 20·10·0.1.
        assert!((volume(&mut s) - 239_980.0).abs() < 1e-3, "{pick:?}: {}", volume(&mut s));
        assert_eq!(flat(&mut s)["pockets"].as_array().map(Vec::len), Some(1), "{pick:?}");
    }
}

/// An engraved ring (an "O": a 5 mm circle round a 3 mm island) is one pocket with a hole; the
/// island stays at full thickness.
#[test]
fn an_engraved_ring_converts_as_a_pocket_round_its_island() {
    let mut s = Session::default();
    engraved_plate(
        &mut s,
        0.1,
        |s| {
            run(s, "sketch.circle.center", json!({"center": [20, 20], "radius": 5}));
            run(s, "sketch.circle.center", json!({"center": [20, 20], "radius": 3}));
        },
        &[[24.0, 20.0]],
    );
    // The extrude took the ring between the circles, not the island.
    assert!((volume(&mut s) - (2400.0 - 0.1 * PI * (25.0 - 9.0))).abs() < 1e-3, "{}", volume(&mut s));
    run(&mut s, "sheet.convert", json!({"body": "Plate", "face": [45, 30, 1]}));
    // The ring's circles are followed within 0.01 mm (1/100 of the thickness): its area within
    // 2/3 of that times the circumferences.
    let want = 2400.0 - 0.1 * PI * (25.0 - 9.0);
    assert!((volume(&mut s) - want).abs() < 0.1 * 0.01 * 2.0 / 3.0 * 2.0 * PI * 8.0, "{} vs {want}", volume(&mut s));
    let (_, hi) = bbox(&mut s);
    assert!(!contains(&s, [24.0, 20.0, hi[2] - 0.05]) && contains(&s, [20.0, 20.0, hi[2] - 0.05]));
    let f = flat(&mut s);
    assert_eq!(f["pockets"].as_array().map(Vec::len), Some(1), "{f}");
    assert_eq!(f["pockets"][0]["cutouts"].as_array().map(Vec::len), Some(1), "{f}");
}

/// What a plate's recesses can't be is refused with the reason, and leaves the design as it was:
/// a recess deeper than half the plate, recesses in both faces, a plate raised in places (its
/// recesses larger than the face they are in); a plate with a boss is no plate, as before. A bend
/// across a kept engraving is refused.
#[test]
fn recesses_a_plate_cannot_keep_are_refused_with_the_reason() {
    let err = |s: &mut Session, face: [f64; 3]| {
        s.execute("sheet.convert", &json!({"body": "Plate", "face": face})).err().map(|e| e.to_string()).unwrap_or_default()
    };
    let mut s = Session::default();
    engraved_plate(&mut s, 0.6, label_rectangle, &[]);
    let e = err(&mut s, [45.0, 30.0, 1.0]);
    assert!(e.contains("0.600 mm deep, more than half the plate's 1.000 mm"), "{e}");
    let mut s = Session::default();
    engraved_plate(&mut s, 0.1, label_rectangle, &[]);
    run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Under"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [40, 20], "p1": [50, 30]}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "Under", "distance": 0.1, "operation": "cut"}));
    let e = err(&mut s, [45.0, 10.0, 1.0]);
    assert!(e.contains("recesses in both faces"), "{e}");
    // A recess 0.3 mm deep leaving a 2 mm rim: rather a plate 0.3 mm thinner with a raised rim.
    let mut s = Session::default();
    engraved_plate(
        &mut s,
        0.3,
        |s| {
            run(s, "sketch.rectangle.two_point", json!({"p0": [2, 2], "p1": [58, 38]}));
        },
        &[],
    );
    let e = err(&mut s, [1.0, 1.0, 1.0]);
    assert!(e.contains("larger than the face they are in"), "{e}");
    // A 0.3 mm boss on the plate: the plate's top round it lies in no opening of the boss's top.
    let mut s = Session::default();
    plate(&mut s);
    run(&mut s, "sketch.create", json!({"plane": "XY", "offset": 1, "name": "Boss"}));
    label_rectangle(&mut s);
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "Boss", "distance": 0.3, "operation": "join"}));
    let e = err(&mut s, [20.0, 15.0, 1.3]);
    assert!(e.contains("not a plate of even thickness"), "{e}");
    assert!(s.model.state().sheets.is_empty());
    // A fold across a kept engraving; one clear of it bends.
    let mut s = Session::default();
    engraved_plate(&mut s, 0.1, label_rectangle, &[]);
    run(&mut s, "sheet.convert", json!({"body": "Plate", "face": [45, 30, 1]}));
    let (_, hi) = bbox(&mut s);
    let fold = |x: f64| json!({"points": [[x, 0, hi[2]], [x, 40, hi[2]]], "angle": 90});
    let e = s.execute("sheet.fold", &fold(20.0)).err().map(|e| e.to_string()).unwrap_or_default();
    assert!(e.contains("crosses a bend zone"), "{e}");
    run(&mut s, "sheet.fold", fold(45.0));
}

/// A bent part converted without bend edges is no plate, as before, whichever face is picked:
/// the faces of its legs inside its extent are no recesses. An L of two 2 mm plates at 90° (its
/// legs' faces lie beside its other faces, in no opening of them), a trapezoid section with
/// returns (faces of its legs on both sides of its base) and a tapered tray (its floor lies in
/// the opening of its rim, but filled it is no plate: its walls lean out).
#[test]
fn a_bent_part_without_bend_edges_is_still_no_plate() {
    let err = |s: &mut Session, body: &str, face: [f64; 3]| {
        s.execute("sheet.convert", &json!({"body": body, "face": face})).err().map(|e| e.to_string()).unwrap_or_default()
    };
    let no_plate = "not supported yet: converting bodies that are not a plate of even thickness without bend edges";
    let mut s = Session::default();
    section(&mut s, &[(0.0, 30.0), (0.0, 0.0), (50.0, 0.0)], 2.0, 40.0);
    for pick in [[25.0, 0.0, 20.0], [25.0, 2.0, 20.0], [1.0, 30.0, 20.0], [0.0, 15.0, 20.0], [2.0, 15.0, 20.0], [50.0, 1.0, 20.0]] {
        let e = err(&mut s, "Section", pick);
        assert!(e.contains(no_plate), "{pick:?}: {e}");
    }
    let mut s = Session::default();
    trapezoid_section(&mut s, 2.0);
    for pick in [[0.0, 0.0, 150.0], [0.0, 2.0, 150.0]] {
        let e = err(&mut s, "Section", pick);
        assert!(e.contains(no_plate), "{pick:?}: {e}");
    }
    let mut s = Session::default();
    run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Floor"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [200, 120]}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "Floor", "distance": 40, "taper": "18 deg", "body_name": "Tray"}));
    run(&mut s, "solid.shell", json!({"faces": [[100, 60, 40]], "thickness": 2}));
    let e = err(&mut s, "Tray", [100.0, 60.0, 0.0]);
    assert!(e.contains(no_plate), "{e}");
    assert!(s.model.state().sheets.is_empty());
}

/// The flat pattern's cut-outs that are no whole circle (slots), each by the middle of its arcs'
/// centres.
fn flat_slots(s: &mut Session) -> Vec<[f64; 2]> {
    let shapes = flat(s)["cutout_shapes"].as_array().cloned().unwrap_or_default();
    let centre = |segs: &Vec<Value>| {
        let c: Vec<[f64; 2]> = segs.iter().filter_map(|g| Some([g["arc"]["center"][0].as_f64()?, g["arc"]["center"][1].as_f64()?])).collect();
        let n = c.len().max(1) as f64;
        [c.iter().map(|p| p[0]).sum::<f64>() / n, c.iter().map(|p| p[1]).sum::<f64>() / n]
    };
    shapes.iter().filter_map(|x| x["segments"].as_array()).map(centre).collect()
}

/// A U channel 40 long (along z) and `t` thick: a web 100 wide on y = 0 and two legs 30 high,
/// outside lengths to the sharp corners. Returns a point on each outside corner (the bends).
fn channel(s: &mut Session, t: f64) -> Vec<[f64; 3]> {
    section(s, &[(0.0, 30.0), (0.0, 0.0), (100.0, 0.0), (100.0, 30.0)], t, 40.0)
}

/// The channel folded with two 90° bends, less `cut` mm² of its faces: the web and the legs
/// between their setbacks R + T, and two quarter rounds on the neutral radius R + T/2.
fn channel_volume(t: f64, r: f64, cut: f64) -> f64 {
    t * (40.0 * ((100.0 - 2.0 * (r + t)) + 2.0 * (30.0 - (r + t)) + PI * (r + t / 2.0)) - cut)
}

/// Holes and a slot in the faces of a channel converted by its bend edges are cut-outs of the
/// flat pattern, where the bend allowance puts them: in the fixed face (the web) and in the bent
/// ones (the legs). With bend edges, such faces were refused ("faces with curved edges").
#[test]
fn holes_and_a_slot_in_a_channels_faces_land_where_the_bends_put_them() {
    let (t, k, r) = (2.0, 0.4, 2.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    let bends = channel(&mut s, t);
    // Two 6 mm holes in the web, 30 from either outside corner; one in the right leg and a slot
    // 6 wide and 20 long in the left one, each centred 18 up the leg's outside.
    run(&mut s, "solid.hole", json!({"position": [30, 0, 20], "diameter": 6}));
    run(&mut s, "solid.hole", json!({"position": [70, 0, 20], "diameter": 6}));
    run(&mut s, "solid.hole", json!({"position": [100, 18, 20], "diameter": 6, "depth": 3}));
    run(&mut s, "sketch.create", json!({"plane": "YZ", "name": "Slot"}));
    run(&mut s, "sketch.slot.overall", json!({"p0": [18, 10], "p1": [18, 30], "width": 6}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "Slot", "distance": 3, "operation": "cut"}));
    run(&mut s, "sheet.convert", json!({"body": "Section", "face": [50, 0, 5], "bends": bends}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 2 && rows.iter().all(|row| row.0 == 90 && row.1 == "up" && (row.2 - 40.0).abs() < 1e-9), "{rows:?}");
    // T 2, R 2, K 0.4: BA = π/2 (R + K T) = 1.4 π, BD = 2 (R + T) - BA = 8 - 1.4 π = 3.6018; the
    // flat is the outside lengths less a BD per bend.
    let bd = deduction(FRAC_PI_2, r, t, k);
    assert!((bd - (8.0 - 1.4 * PI)).abs() < 1e-12);
    let across = 160.0 - 2.0 * bd;
    assert!(same_size(flat_size(&mut s), (across, 40.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    // On one line across the flat: the right leg's hole, the web's two, 40 apart, and the slot.
    // From a leg's to the web's nearer one: 18 + 30 along the outside to the sharp, less the BD.
    let (circles, slots) = (flat_circles(&mut s), flat_slots(&mut s));
    assert!(circles.len() == 3 && circles.iter().all(|(radius, _)| (radius - 3.0).abs() < 1e-9) && slots.len() == 1, "{circles:?} {slots:?}");
    let mut centres: Vec<[f64; 2]> = circles.iter().map(|c| c.1).chain(slots).collect();
    centres.sort_by(|a, b| a[0].total_cmp(&b[0]));
    let gaps: Vec<f64> = centres.windows(2).map(|w| w[1][0] - w[0][0]).collect();
    assert!(centres.iter().all(|c| (c[1] - centres[0][1]).abs() < 1e-6), "{centres:?}");
    assert!(gaps.len() == 3 && gaps.iter().zip([48.0 - bd, 40.0, 48.0 - bd]).all(|(g, want)| (g - want).abs() < 1e-6), "{gaps:?}");
    // Folded, flat and folded again, less three holes of radius 3 and the slot (14 x 6 and its
    // round ends).
    let cut = 3.0 * PI * 9.0 + 14.0 * 6.0 + PI * 9.0;
    let v = volume(&mut s);
    let want = channel_volume(t, r, cut);
    assert!((v - want).abs() < 1e-4 * want, "{v} vs {want}");
    run(&mut s, "sheet.unfold", json!({}));
    let want = t * (across * 40.0 - cut);
    assert!((volume(&mut s) - want).abs() < 1e-4 * want, "{} vs {want}", volume(&mut s));
    run(&mut s, "sheet.refold", json!({}));
    assert!((volume(&mut s) - v).abs() < 1e-6 * v);
    // The DXF: a CIRCLE per hole, and the slot's round ends as ARCs.
    let (_, arcs, holes) = dxf_entities(&mut s);
    assert_eq!((arcs, holes), (2, 3));
}

/// Round edges of a bent face stay arcs: the legs' free corners rounded by 5, and a notch of
/// radius 4 in one leg's free edge. They were refused too.
#[test]
fn rounded_corners_and_a_notch_on_a_leg_stay_arcs_in_the_flat() {
    let (t, k, r) = (2.0, 0.4, 2.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    let bends = channel(&mut s, t);
    run(&mut s, "solid.fillet", json!({"edges": [[1, 30, 0], [1, 30, 40], [99, 30, 0], [99, 30, 40]], "radius": 5}));
    run(&mut s, "sketch.create", json!({"plane": "YZ", "name": "Notch"}));
    run(&mut s, "sketch.circle.center", json!({"center": [30, 20], "radius": 4}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "Notch", "distance": 3, "operation": "cut"}));
    run(&mut s, "sheet.convert", json!({"body": "Section", "face": [50, 0, 5], "bends": bends}));
    let across = 160.0 - 2.0 * deduction(FRAC_PI_2, r, t, k);
    assert!(same_size(flat_size(&mut s), (across, 40.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    // Each corner takes (1 - π/4) 5², the notch half a disc of radius 4.
    let cut = 4.0 * (1.0 - PI / 4.0) * 25.0 + PI * 16.0 / 2.0;
    let v = volume(&mut s);
    let want = channel_volume(t, r, cut);
    assert!((v - want).abs() < 1e-4 * want, "{v} vs {want}");
    run(&mut s, "sheet.unfold", json!({}));
    let want = t * (across * 40.0 - cut);
    assert!((volume(&mut s) - want).abs() < 1e-4 * want, "{} vs {want}", volume(&mut s));
    run(&mut s, "sheet.refold", json!({}));
    assert!((volume(&mut s) - v).abs() < 1e-6 * v);
    // The DXF: a quarter ARC at each corner and a half one at the notch, no cut-outs.
    let (_, arcs, holes) = dxf_entities(&mut s);
    assert_eq!((arcs, holes), (5, 0));
}

/// A hole that reaches into a bend has no one place in the flat, and a pocket deeper than half
/// the sheet is no engraving: both are refused, by their places. (The web's flat panel starts
/// R + T = 4 from the sharp; the hole reaches from 2 to 8. The pocket is 1.5 deep in the 2 thick
/// web.)
#[test]
fn a_hole_reaching_into_a_bend_and_a_pocket_are_refused_by_their_places() {
    let convert = |cut: &[(&str, Value)]| {
        let mut s = Session::default();
        rule(&mut s, "Test", 2.0, 0.4, 2.0, 0.5);
        let bends = channel(&mut s, 2.0);
        for (id, p) in cut {
            run(&mut s, id, p.clone());
        }
        let e = s.execute("sheet.convert", &json!({"body": "Section", "face": [50, 0, 5], "bends": bends})).err();
        assert!(s.model.state().sheets.is_empty());
        e.map(|e| e.to_string()).unwrap_or_default()
    };
    let e = convert(&[("solid.hole", json!({"position": [5, 0, 20], "diameter": 6}))]);
    assert!(e.contains("the hole at (5.000, 0.000, 20.000) reaches into a bend"), "{e}");
    let e = convert(&[
        ("sketch.create", json!({"plane": "XZ", "name": "Pocket"})),
        ("sketch.rectangle.two_point", json!({"p0": [40, -15], "p1": [60, -25]})),
        ("sketch.finish", json!({})),
        ("solid.extrude", json!({"sketch": "Pocket", "distance": 1.5, "operation": "cut"})),
    ]);
    assert!(e.contains("the pocket at (50.000, 0.000, 20.000) in a face of the sheet ends 1.500 deep, more than half the sheet's 2.000"), "{e}");
}

/// The bounding box (low corner, high corner) of a flat pattern pocket's outline.
fn pocket_box(p: &Value) -> ([f64; 2], [f64; 2]) {
    let pts: Vec<[f64; 2]> = p["outline"].as_array().into_iter().flatten().filter_map(|q| Some([q[0].as_f64()?, q[1].as_f64()?])).collect();
    let lo = [pts.iter().map(|q| q[0]).fold(f64::MAX, f64::min), pts.iter().map(|q| q[1]).fold(f64::MAX, f64::min)];
    let hi = [pts.iter().map(|q| q[0]).fold(f64::MIN, f64::max), pts.iter().map(|q| q[1]).fold(f64::MIN, f64::max)];
    (lo, hi)
}

/// A bent part as another system models it, its bends with their radius, with what its faces
/// carry: a channel 80 wide with legs 30 high (outside, to the sharp corners), 2 thick, 60 long,
/// bent R 2 inside and R 4 outside, with a 6 mm hole 18 up its right leg, a label 20 x 10
/// engraved 0.5 deep into the outside of its web and one 10 x 20 into the inside of its left leg.
/// Converted from the outside of the web by its outer cylinders under a rule of the model's
/// radius, the sheet is the model again: the hole is a cut-out where the bend allowance puts it,
/// and each label is a pocket on its own skin of the sheet.
#[test]
fn a_channel_with_its_bends_modelled_keeps_its_hole_and_engravings_on_either_skin() {
    let (t, k, r) = (2.0, 0.4, 2.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    let corners = bent_section(&mut s, &[(0.0, 30.0), (0.0, 0.0), (80.0, 0.0), (80.0, 30.0)], t, r, 60.0);
    run(&mut s, "solid.hole", json!({"position": [80, 18, 20], "diameter": 6, "depth": 3}));
    // The web's label from its outside (y = 0) in, the leg's from its inside (x = 2) out.
    run(&mut s, "sketch.create", json!({"plane": "XZ", "name": "WebLabel"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [30, -35], "p1": [50, -45]}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "WebLabel", "distance": 0.5, "operation": "cut"}));
    run(&mut s, "sketch.create", json!({"plane": "YZ", "offset": 2, "name": "LegLabel"}));
    run(&mut s, "sketch.rectangle.two_point", json!({"p0": [12, 10], "p1": [22, 30]}));
    run(&mut s, "sketch.finish", json!({}));
    run(&mut s, "solid.extrude", json!({"sketch": "LegLabel", "distance": 0.5, "direction": "negative", "operation": "cut"}));
    // Two flat legs, the web and two quarter rounds on the neutral radius R + T/2, less the hole
    // and the labels.
    let cut = 9.0 * PI * t + 2.0 * 200.0 * 0.5;
    let solid = volume(&mut s);
    let model = t * 60.0 * (2.0 * (30.0 - (r + t)) + (80.0 - 2.0 * (r + t)) + PI * (r + t / 2.0)) - cut;
    assert!((solid - model).abs() < 2e-3 * model, "{solid} vs {model}");
    run(&mut s, "sheet.convert", json!({"body": "Section", "face": [65, 0, 10], "bends": [corners[0].0, corners[1].0]}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 2 && rows.iter().all(|row| row.0 == 90 && row.1 == "up" && (row.2 - 60.0).abs() < 1e-6), "{rows:?}");
    // 30 + 80 + 30 less two deductions; the sheet is the solid again.
    let bd = deduction(FRAC_PI_2, r, t, k);
    let across = 140.0 - 2.0 * bd;
    assert!(same_size(flat_size(&mut s), (across, 60.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    let v = volume(&mut s);
    assert!((v - solid).abs() < 1e-3 * solid, "{v} vs {solid}");
    // The labels stay in their skins: the web's in its outside, the leg's in its inside.
    assert!(!contains(&s, [40.0, 0.25, 40.0]) && contains(&s, [40.0, 0.75, 40.0]));
    assert!(!contains(&s, [1.75, 17.0, 20.0]) && contains(&s, [1.25, 17.0, 20.0]));
    // The flat: the hole, and a pocket per label, 0.5 deep from the web's skin (z 0) and from the
    // other one (z T). Along the outside from the web label's middle (40 in, 40 along) to the
    // hole's: 40 to the sharp and 18 up the leg, less a deduction, and 20 back along; to the leg
    // label's middle, 40 and 17 the other way.
    let circles = flat_circles(&mut s);
    assert!(circles.len() == 1 && (circles[0].0 - 3.0).abs() < 1e-9, "{circles:?}");
    let f = flat(&mut s);
    let pockets = f["pockets"].as_array().cloned().unwrap_or_default();
    assert_eq!(pockets.len(), 2, "{f}");
    let from = |p: &Value, z0: f64, z1: f64| {
        (p["z0_mm"].as_f64().unwrap_or(f64::NAN) - z0).abs() < 1e-9 && (p["z1_mm"].as_f64().unwrap_or(f64::NAN) - z1).abs() < 1e-9
    };
    let web = pockets.iter().find(|p| from(p, 0.0, 0.5)).expect("the web's label, from z 0");
    let leg = pockets.iter().find(|p| from(p, 1.5, 2.0)).expect("the leg's label, from z T");
    let middle = |p: &Value| {
        let (lo, hi) = pocket_box(p);
        ([(lo[0] + hi[0]) / 2.0, (lo[1] + hi[1]) / 2.0], (hi[0] - lo[0], hi[1] - lo[1]))
    };
    let ((w, w_size), (l, l_size), h) = (middle(web), middle(leg), circles[0].1);
    assert!(same_size(w_size, (20.0, 10.0), 1e-6) && same_size(l_size, (10.0, 20.0), 1e-6), "{w_size:?} {l_size:?}");
    let (to_hole, to_leg) = ([h[0] - w[0], h[1] - w[1]], [l[0] - w[0], l[1] - w[1]]);
    assert!(same_size((to_hole[0].abs(), to_hole[1].abs()), (58.0 - bd, 20.0), 1e-6), "{to_hole:?}");
    assert!(same_size((to_leg[0].abs(), to_leg[1].abs()), (57.0 - bd, 20.0), 1e-6), "{to_leg:?}");
    assert!(to_hole[0] * to_leg[0] + to_hole[1] * to_leg[1] < 0.0, "{to_hole:?} {to_leg:?}");
    // The DXF: the hole a CIRCLE, each label on the pocket layer of its depth.
    assert_eq!(dxf_entities(&mut s).2, 1);
    let dxf = run(&mut s, "sheet.export_dxf", json!({}))["dxf"].as_str().unwrap_or_default().to_string();
    assert_eq!((lines_on(&dxf, "POCKET_BOTTOM_Z0.000000_TO_0.500000_MM"), lines_on(&dxf, "POCKET_TOP_Z1.500000_TO_2.000000_MM")), (4, 4));
    // Unfolded and folded again it keeps them.
    run(&mut s, "sheet.unfold", json!({}));
    let want = t * across * 60.0 - cut;
    assert!((volume(&mut s) - want).abs() < 1e-4 * want, "{} vs {want}", volume(&mut s));
    run(&mut s, "sheet.refold", json!({}));
    assert!((volume(&mut s) - v).abs() < 1e-6 * v);
}

/// Chamfer bends beside holes: [`chamfered_channel`] with a 6 mm hole in its web 20 from the
/// left sharp corner and one 18 up its right leg, the chamfers picked in their middles. The holes
/// land from the virtual sharps, where the faces were taken out to.
#[test]
fn holes_beside_chamfer_bends_land_from_the_virtual_sharps() {
    let (t, k, r) = (2.0, 0.5, 3.0);
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    chamfered_channel(&mut s);
    run(&mut s, "solid.hole", json!({"position": [20, 0, 30], "diameter": 6}));
    run(&mut s, "solid.hole", json!({"position": [40, 18, 70], "diameter": 6, "depth": 3}));
    run(&mut s, "sheet.convert", json!({"body": "Channel", "face": [20, 0, 80], "bends": [[2, 2, 50], [38, 2, 50]]}));
    let bd = deduction(FRAC_PI_2, r, t, k);
    let across = 100.0 - 2.0 * bd;
    assert!(same_size(flat_size(&mut s), (across, 100.0), 1e-6), "{:?} vs {across}", flat_size(&mut s));
    // From the web's hole: 20 to the right sharp, 18 up the leg, less a deduction; 40 along.
    let circles = flat_circles(&mut s);
    assert!(circles.len() == 2 && circles.iter().all(|(radius, _)| (radius - 3.0).abs() < 1e-9), "{circles:?}");
    let d = [circles[1].1[0] - circles[0].1[0], circles[1].1[1] - circles[0].1[1]];
    assert!(same_size((d[0].abs(), d[1].abs()), (38.0 - bd, 40.0), 1e-6), "{d:?}");
    // Three flat strips and two quarter rounds on the neutral radius, less the holes.
    let expect = t * 100.0 * (2.0 * (30.0 - (r + t)) + (40.0 - 2.0 * (r + t)) + PI * (r + t / 2.0)) - 2.0 * t * 9.0 * PI;
    assert!((volume(&mut s) - expect).abs() < 2e-3 * expect, "{} vs {expect}", volume(&mut s));
}

/// The rule of [`rule`] with its corner relief: `shape` 8 mm across.
fn relief_rule(s: &mut Session, shape: &str) {
    rule(s, "Test", 2.0, 0.44, 2.0, 0.5);
    run(s, "sheet.manage_rules", json!({"name": "Test", "corner_relief_shape": shape, "corner_relief": "8 mm"}));
}

/// The flat outline's corners, from the low corner of their box.
fn outline_corners(s: &mut Session) -> Vec<[f64; 2]> {
    let f = flat(s);
    let loops = f["outline"].as_array().cloned().unwrap_or_default();
    let pts: Vec<[f64; 2]> =
        loops.iter().flat_map(|l| l.as_array().cloned().unwrap_or_default()).filter_map(|q| Some([q[0].as_f64()?, q[1].as_f64()?])).collect();
    let lo = [pts.iter().map(|q| q[0]).fold(f64::MAX, f64::min), pts.iter().map(|q| q[1]).fold(f64::MAX, f64::min)];
    pts.iter().map(|q| [q[0] - lo[0], q[1] - lo[1]]).collect()
}

/// Whether the flat outline has a corner at each of `want` (from the low corner of its box), the
/// flat as it lies or turned in its box: half round, or seen from its other face. (The flat frame
/// runs along a longest edge of the fixed face, which may be either of two, and from a shell's
/// inner skin it is seen from the other side.)
fn outline_has(s: &mut Session, want: &[[f64; 2]]) -> bool {
    let pts = outline_corners(s);
    let hi = [pts.iter().map(|q| q[0]).fold(0.0, f64::max), pts.iter().map(|q| q[1]).fold(0.0, f64::max)];
    let turned = |q: [f64; 2], (fx, fy): (bool, bool)| [if fx { hi[0] - q[0] } else { q[0] }, if fy { hi[1] - q[1] } else { q[1] }];
    [(false, false), (true, true), (true, false), (false, true)].iter().any(|&turn| {
        want.iter().all(|w| {
            pts.iter().any(|q| {
                let p = turned(*q, turn);
                (p[0] - w[0]).abs() < 1e-6 && (p[1] - w[1]).abs() < 1e-6
            })
        })
    })
}

/// The corners of a converted tray are a flanged tray's: closed with the rule's gap and given the
/// rule's corner relief, in the folded part and the flat pattern. The shelled tray of [`tray`] and
/// the same tray made from a base and four 30 mm edge flanges, T 2, R 2, K 0.44, gap 0.5, a relief
/// 8 mm across: the bends meet at the base's corners, R + T = 4 in from the sharps, and are
/// BA = π/2 (R + K T) = 1.44 π wide in the flat. A notch leaves them there (92 and 52 long); a
/// round or a square relief takes 4 off each bend at each corner and r²·π/4 or r² (r = 4) of the
/// base; a tear runs each bend on to its corner and cuts its end from there to where its wall's
/// closed end starts, g/√2 + T from the sharp: R − g/√2 longer. The conversion used to bend every
/// corner as a notch, whatever the rule said.
#[test]
fn a_converted_trays_corners_are_closed_and_relieved_as_a_flanged_trays_are() {
    let (t, r, k, gap) = (2.0, 2.0, 0.44, 0.5);
    let ba = FRAC_PI_2 * (r + k * t);
    let grow = r - gap / SQRT_2;
    // (bend lengths, flat area taken off the notch's at each corner)
    let cases = [
        ("notch", (92.0, 52.0), 0.0),
        ("round", (84.0, 44.0), 4.0 * PI + 8.0 * ba),
        ("rectangular", (84.0, 44.0), 16.0 + 8.0 * ba),
        ("tear", (92.0 + grow, 52.0 + grow), -grow * ba),
    ];
    let cut = t + gap / SQRT_2;
    let walls = 26.0 * 2.0 * ((100.0 - 2.0 * cut) + (60.0 - 2.0 * cut));
    let flat_notch = t * (92.0 * 52.0 + ba * 2.0 * (92.0 + 52.0) + walls);
    for (shape, (long, short), taken) in cases {
        let mut s = Session::default();
        relief_rule(&mut s, shape);
        tray(&mut s, t);
        let out = run(&mut s, "sheet.convert", json!({"body": "Tray", "face": [50, 30, 0], "bends": BOTTOM_EDGES}));
        assert!(out["warning"].is_null(), "{shape}: {out}");
        let mut lengths: Vec<f64> = bend_rows(&mut s).iter().map(|row| row.2).collect();
        lengths.sort_by(f64::total_cmp);
        let want = [short, short, long, long];
        assert!(lengths.len() == 4 && lengths.iter().zip(want).all(|(l, w)| (l - w).abs() < 1e-6), "{shape}: {lengths:?}");
        // The same tray made from flanges.
        let mut f = Session::default();
        relief_rule(&mut f, shape);
        run(&mut f, "sketch.create", json!({"plane": "XY", "name": "Base"}));
        run(&mut f, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [100, 60]}));
        run(&mut f, "sketch.finish", json!({}));
        run(&mut f, "sheet.flange", json!({"sketch": "Base"}));
        run(&mut f, "sheet.flange", json!({"edges": [[50, 0, 2], [100, 30, 2], [50, 60, 2], [0, 30, 2]], "height": 30}));
        let mut flanged: Vec<f64> = bend_rows(&mut f).iter().map(|row| row.2).collect();
        flanged.sort_by(f64::total_cmp);
        assert!(lengths.iter().zip(&flanged).all(|(a, b)| (a - b).abs() < 1e-9), "{shape}: {lengths:?} vs {flanged:?}");
        // The flat patterns are congruent, corner for corner.
        let corners = outline_corners(&mut f);
        assert!(
            outline_corners(&mut s).len() == corners.len() && outline_has(&mut s, &corners),
            "{shape}: {:?} vs {corners:?}",
            outline_corners(&mut s)
        );
        let (v, vf) = (volume(&mut s), volume(&mut f));
        assert!((v - vf).abs() < 1e-6 * vf, "{shape}: {v} vs {vf}");
        run(&mut s, "sheet.unfold", json!({}));
        run(&mut f, "sheet.unfold", json!({}));
        let (flat_v, flat_f) = (volume(&mut s), volume(&mut f));
        assert!((flat_v - flat_f).abs() < 1e-6 * flat_f, "{shape}: {flat_v} vs {flat_f}");
        // The flat takes the relief off the notch's (whose walls end g/√2 + T from the sharps).
        let want = flat_notch - 4.0 * t * taken;
        assert!((flat_v - want).abs() < 0.1, "{shape}: flat {flat_v} vs {want}");
        run(&mut s, "sheet.refold", json!({}));
        assert!((volume(&mut s) - v).abs() < 1e-6 * v, "{shape}");
        // A round relief is an arc of radius 4 about each point where two bends meet: the base's
        // corners R + T in from the sharps, 92 and 52 apart.
        if shape == "round" {
            let dxf = run(&mut s, "sheet.export_dxf", json!({}))["dxf"].as_str().unwrap_or_default().to_string();
            let arcs: Vec<(solidcraft_geom::Vec2, f64)> = solidcraft_io::read_dxf(&dxf)
                .unwrap_or_default()
                .iter()
                .filter_map(|g| if let solidcraft_io::Geom2::Arc { c, a, .. } = g { Some((*c, a.dist(*c))) } else { None })
                .collect();
            assert_eq!(arcs.len(), 4, "{arcs:?}");
            let lo = solidcraft_geom::Vec2::new(
                arcs.iter().map(|(c, _)| c.x).fold(f64::MAX, f64::min),
                arcs.iter().map(|(c, _)| c.y).fold(f64::MAX, f64::min),
            );
            for (x, y) in [(0.0, 0.0), (92.0, 0.0), (92.0, 52.0), (0.0, 52.0)] {
                let at = lo + solidcraft_geom::Vec2::new(x, y);
                assert!(arcs.iter().any(|(c, r)| c.dist(at) < 1e-6 && (r - 4.0).abs() < 1e-6), "({x}, {y}): {arcs:?}");
            }
        }
    }
}

/// A plate 80 x 50, `plate` thick, with a wall 2 thick and 30 high standing on its edge y = 0
/// from `x0` to `x1`, joined (with a 2 mm plate, a shell).
fn bracket(s: &mut Session, x0: f64, x1: f64, plate: f64) {
    run(s, "solid.box", json!({"length": 80, "width": 50, "height": plate, "body_name": "Bracket"}));
    run(s, "solid.box", json!({"length": x1 - x0, "width": 2, "height": 30, "corner": [x0, 0, 0], "operation": "join", "targets": ["Bracket"]}));
}

/// A wall standing on part of an edge (an L-bracket whose flange covers part of the plate's edge,
/// a tab): the plate's edge face and the wall's outside are one face, the plate's edge running on
/// past the wall a strip T high. Its bend ends where the wall does, and the rule's bend relief
/// (2 wide, from 1 past the bend line through the plate's edge) is cut into the plate beside each
/// end of the bend that has more plate beside it, as for an edge flange. The strip, lower than the
/// bend's setback R + T = 4, was used up by it and the conversion refused; from the inner skin the
/// bend ended against the plate without a relief. T 2, R 2, K 0.44: BA = 1.44 π, BD = 8 − BA.
#[test]
fn a_bend_ends_where_its_wall_ends_with_the_rules_bend_relief_beside_it() {
    let (t, r, k) = (2.0, 2.0, 0.44);
    let ba = FRAC_PI_2 * (r + k * t);
    let bd = deduction(FRAC_PI_2, r, t, k);
    // Folded and flat: the plate less the bend's setback under the wall and the reliefs (2 x 5
    // each), the wall past the bend (30 − 4 high), and the bend on its neutral radius or as its
    // allowance.
    let parts = |wall: f64, reliefs: f64| {
        let flat = 80.0 * 50.0 - 4.0 * wall - 10.0 * reliefs + 26.0 * wall;
        (t * flat + FRAC_PI_2 * t * (r + t / 2.0) * wall, t * (flat + ba * wall))
    };
    // From the flat's low corner (the wall's far edge, 26 + BA − 4 past the plate's edge).
    let edge = 26.0 + ba - 4.0;
    // The wall in the middle, picked from the outside or the inside: the same sheet, the reliefs
    // x 18 … 20 and 60 … 62, through the plate's edge to 1 past the bend line.
    for (face, bend, way) in [([40.0, 25.0, 0.0], [40.0, 0.0, 0.0], "up"), ([40.0, 25.0, 2.0], [40.0, 2.0, 2.0], "down")] {
        let mut s = Session::default();
        rule(&mut s, "Test", t, k, r, 0.5);
        bracket(&mut s, 20.0, 60.0, 2.0);
        let out = run(&mut s, "sheet.convert", json!({"body": "Bracket", "face": face, "bends": [bend]}));
        assert!(out["warning"].is_null(), "{way}: {out}");
        let rows = bend_rows(&mut s);
        assert!(rows.len() == 1 && rows[0].0 == 90 && rows[0].1 == way && (rows[0].2 - 40.0).abs() < 1e-6, "{way}: {rows:?}");
        assert!(same_size(flat_size(&mut s), (80.0, 80.0 - bd), 1e-6), "{way}: {:?}", flat_size(&mut s));
        let reliefs = [[18.0, edge], [18.0, edge + 5.0], [20.0, edge + 5.0], [60.0, edge + 5.0], [62.0, edge + 5.0], [62.0, edge]];
        assert!(outline_has(&mut s, &reliefs), "{way}: {:?}", outline_corners(&mut s));
        let (folded, flat) = parts(40.0, 2.0);
        let v = volume(&mut s);
        assert!((v - folded).abs() < 1e-4 * folded, "{way}: {v} vs {folded}");
        run(&mut s, "sheet.unfold", json!({}));
        assert!((volume(&mut s) - flat).abs() < 1e-6 * flat, "{way}: {} vs {flat}", volume(&mut s));
        run(&mut s, "sheet.refold", json!({}));
        assert!((volume(&mut s) - v).abs() < 1e-6 * v, "{way}");
    }
    // A wall at the plate's end: its bend runs from the plate's corner, one relief at its end.
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    bracket(&mut s, 0.0, 40.0, 2.0);
    run(&mut s, "sheet.convert", json!({"body": "Bracket", "face": [40, 25, 0], "bends": [[20, 0, 0]]}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 1 && (rows[0].2 - 40.0).abs() < 1e-6, "{rows:?}");
    assert!(outline_has(&mut s, &[[0.0, 0.0], [40.0, 0.0], [40.0, edge + 5.0], [42.0, edge + 5.0], [42.0, edge]]), "{:?}", outline_corners(&mut s));
    let (folded, _) = parts(40.0, 1.0);
    assert!((volume(&mut s) - folded).abs() < 1e-4 * folded, "{} vs {folded}", volume(&mut s));
    // A strip taller than the setback (a 5 mm plate, the rule's T 2 taken into the block) stays a
    // low wall of the sheet beside the wall, as before: one bend the plate's length, no relief.
    let mut s = Session::default();
    rule(&mut s, "Test", t, k, r, 0.5);
    bracket(&mut s, 20.0, 60.0, 5.0);
    run(&mut s, "sheet.convert", json!({"body": "Bracket", "face": [40, 25, 0], "bends": [[40, 0, 0]]}));
    let rows = bend_rows(&mut s);
    assert!(rows.len() == 1 && (rows[0].2 - 80.0).abs() < 1e-6, "{rows:?}");
    let low = t * (80.0 * 46.0 + 80.0 * 1.0 + 40.0 * 25.0) + FRAC_PI_2 * t * (r + t / 2.0) * 80.0;
    assert!((volume(&mut s) - low).abs() < 1e-4 * low, "{} vs {low}", volume(&mut s));
}

/// Both together: a plate 100 x 60 x 2 with a wall along its whole edge y = 0 and one on its edge
/// x = 100 from y = 0 to 30 only, a round corner relief 8 across. The walls meet at the corner,
/// closed with the gap (each ends g/√2 + T from the other's outside) and relieved there; the
/// shorter one's bend ends at y = 30 with a bend relief beside it. In the flat from the plate's
/// corner: the plate from y = 4 and up to x = 96 beside the short wall, 100 past it; bends 96 − 4
/// and 26 − 4 long; the bend relief x 95 … 100, y 30 … 32.
#[test]
fn a_wall_on_part_of_an_edge_meets_a_wall_at_a_relieved_corner_and_is_relieved_at_its_end() {
    let (t, r, k, gap) = (2.0, 2.0, 0.44, 0.5);
    let ba = FRAC_PI_2 * (r + k * t);
    let mut s = Session::default();
    relief_rule(&mut s, "round");
    run(&mut s, "solid.box", json!({"length": 100, "width": 60, "height": 2, "body_name": "Part"}));
    run(&mut s, "solid.box", json!({"length": 100, "width": 2, "height": 30, "operation": "join", "targets": ["Part"]}));
    run(&mut s, "solid.box", json!({"length": 2, "width": 30, "height": 30, "corner": [98, 0, 0], "operation": "join", "targets": ["Part"]}));
    let out = run(&mut s, "sheet.convert", json!({"body": "Part", "face": [50, 30, 0], "bends": [[50, 0, 0], [100, 15, 0]]}));
    assert!(out["warning"].is_null(), "{out}");
    let mut lengths: Vec<f64> = bend_rows(&mut s).iter().map(|row| row.2).collect();
    lengths.sort_by(f64::total_cmp);
    assert!(lengths.len() == 2 && (lengths[0] - 22.0).abs() < 1e-6 && (lengths[1] - 92.0).abs() < 1e-6, "{lengths:?}");
    // The plate less the setbacks, the round relief and the bend relief; the walls 26 high, each
    // from the corner's closed end to its own end.
    let cut = t + gap / SQRT_2;
    let base = 100.0 * 56.0 - 4.0 * 26.0 - 4.0 * PI - 10.0;
    let walls = 26.0 * ((100.0 - cut) + (30.0 - cut));
    let folded = t * (base + walls) + FRAC_PI_2 * t * (r + t / 2.0) * 114.0;
    let v = volume(&mut s);
    assert!((v - folded).abs() < 1e-4 * folded, "{v} vs {folded}");
    // From the flat's low corner (the long wall's far edge, 26 + BA − 4 past y = 0): the bend
    // relief's corners.
    let edge = 26.0 + ba - 4.0;
    assert!(outline_has(&mut s, &[[95.0, edge + 30.0], [95.0, edge + 32.0], [100.0, edge + 32.0]]), "{:?}", outline_corners(&mut s));
    run(&mut s, "sheet.unfold", json!({}));
    let flat = t * (base + walls + ba * 114.0);
    assert!((volume(&mut s) - flat).abs() < 0.1, "{} vs {flat}", volume(&mut s));
    run(&mut s, "sheet.refold", json!({}));
    assert!((volume(&mut s) - v).abs() < 1e-6 * v);
}