write_snag_list.rs

//! Creates the snag list drawn up when premises are handed over: a plan of the
//! floor with every defect marked on it, the list of those defects one to a
//! line, and a summary of what they come to.
//!
//! The marks on the plan are annotations, which is what sets this sheet apart
//! from every other example here. An annotation sits above the page rather than
//! inside what the page draws: reading software lists it, filters it, shows it,
//! hides it or leaves it off the paper, and the plan underneath is untouched
//! either way. The plan is drawn once; the reserves come and go over it.
//!
//! Five kinds of mark are used, one per shape the standard offers for this: a
//! cloud round a patch that is wholly under reserve, a ring on a defect that
//! sits at one point, an arrow whose closed head rests on what the note is
//! about, the outline of a defect that spreads over an area, and a run along a
//! defect that follows a line. Every one of them carries the words of its line
//! in the list, so what a screen reader speaks and what the list prints are the
//! same sentence.
//!
//! Every mark also says who made it, when, and which trade it is put to, which
//! a reader shows in the title bar of the window it opens the words in. The two
//! blocking snags each carry such a window, and the first of them opens it as
//! soon as the file is opened, beside the key to the colours. The electrician's
//! answer to that snag is a note replying to it, and the inspectors close the
//! snag with a second note setting it to completed, both gathered under the
//! snag by a reader that threads replies.
//!
//! Every figure on the sheet is worked out rather than written down. A room's
//! area comes from the rectangle the plan draws it as, at the scale the plan is
//! set to. A degree's count is the number of snags carrying it, its share is
//! that count against the total, and the date each snag is to be made good by
//! is the handover plus the days its degree allows. The last of those dates is
//! the greatest of them.
//!
//! Every word the sheet prints is held in `Words`, once per language, and
//! `HQF_PDF_LANG` picks which one it is printed in. What is not language stays
//! out of it: the firm, the site, the handover, the reference, the room
//! rectangles, the counts, the areas, the shares and the dates read the same
//! whichever set of words is drawn.
//!
//! Usage: `cargo run --example write_snag_list -- tmp/snags.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_snag_list --
//! tmp/reserves.pdf`

use std::env;
use std::error::Error;
use std::fs;
use std::path::{Path, PathBuf};

use chrono::{Datelike, Days, NaiveDate};

use hqf_pdf::annotation::{
    Annotation, AnnotationBorder, AnnotationState, BorderEffect, Circle, Line, LineEnding,
    NoteIcon, PolyLine, Polygon, Popup, Square, StickyNote,
};
use hqf_pdf::content::Content;
use hqf_pdf::cos::Name;
use hqf_pdf::{Document, Font, FontHandle, Page, Rgb};

#[path = "shared/out.rs"]
mod out;

#[path = "shared/licence.rs"]
mod licence;

#[path = "shared/language.rs"]
mod language;

#[path = "shared/failure.rs"]
mod failure;

use language::Language;

/// The font the example draws with when none is given on the command line.
fn default_font() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("tests")
        .join("fonts")
        .join("DejaVuSans.ttf")
}

/// The sheet, in points: A4 upright.
const PAGE_WIDTH: f64 = 595.276;
const PAGE_HEIGHT: f64 = 841.890;

/// The margins every page keeps clear.
const LEFT: f64 = 56.0;
const RIGHT: f64 = PAGE_WIDTH - LEFT;

/// Where the first baseline of a page sits, and where its foot is written.
const HEAD_TOP: f64 = 786.0;
const FOOT: f64 = 54.0;

/// The steps a page comes down by: between two lines of a block, between two
/// blocks, between two blocks that stand apart, and between two rows of a
/// table.
const LINE: f64 = 12.0;
const BLOCK: f64 = 22.0;
const GAP: f64 = BLOCK * 2.0;
const ROW: f64 = 21.0;

/// The sizes the sheet is set at.
const FIRM_SIZE: f64 = 15.0;
const TITLE_SIZE: f64 = 19.0;
const HEADING_SIZE: f64 = 11.0;
const BODY: f64 = 9.0;
const SMALL: f64 = 8.0;
const TINY: f64 = 6.5;

/// The near-black the sheet is set in, the grey its labels take, and the rule
/// that parts two blocks.
const INK: Rgb = Rgb {
    r: 0.11,
    g: 0.12,
    b: 0.14,
};
const MUTED: Rgb = Rgb {
    r: 0.42,
    g: 0.44,
    b: 0.48,
};
const RULE: Rgb = Rgb {
    r: 0.78,
    g: 0.79,
    b: 0.82,
};

/// The grey a table's head band and its every other row are filled with.
const HEAD_BAND: Rgb = Rgb {
    r: 0.90,
    g: 0.91,
    b: 0.93,
};
const ROW_BAND: Rgb = Rgb {
    r: 0.965,
    g: 0.968,
    b: 0.972,
};

/// The floor of a room, the wall round the premises, and the partition between
/// two rooms.
const FLOOR: Rgb = Rgb {
    r: 0.965,
    g: 0.960,
    b: 0.945,
};
const SHELL_INK: Rgb = Rgb {
    r: 0.20,
    g: 0.22,
    b: 0.26,
};
const PARTITION_INK: Rgb = Rgb {
    r: 0.52,
    g: 0.54,
    b: 0.58,
};

/// The tint the outline of a spreading defect is filled with.
const FOOTPRINT_TINT: Rgb = Rgb {
    r: 0.98,
    g: 0.93,
    b: 0.86,
};

/// The colour every mark of a degree is drawn in.
const MINOR_INK: Rgb = Rgb {
    r: 0.83,
    g: 0.60,
    b: 0.05,
};
const MAJOR_INK: Rgb = Rgb {
    r: 0.87,
    g: 0.35,
    b: 0.05,
};
const BLOCKING_INK: Rgb = Rgb {
    r: 0.76,
    g: 0.09,
    b: 0.14,
};

/// The width a wall, a partition and a mark are stroked with, in points.
const SHELL_WIDTH_PT: f64 = 1.6;
const PARTITION_WIDTH: f64 = 0.9;
const MARK_WIDTH: f64 = 1.2;

/// How far the arcs of a cloud bulge, from 0 to 2.
const CLOUD_BULGE: f64 = 1.0;

/// The firm that inspected the premises, the premises themselves, and the
/// reference the sheet is filed under. The same whichever language the sheet is
/// printed in.
const FIRM: &str = "Vaugelade & Ferrand";
const SITE: &str = "Îlot Cassiopée, 42 quai de la Fonderie, 44200 Nantes";
const INSPECTOR: &str = "M. Ravel, Y. Sombath";
const REFERENCE: &str = "RS-2026-0914-03";

/// The day the premises were handed over, as a year, a month and a day.
const HANDOVER: (i32, u32, u32) = (2026, 9, 14);

/// Who answers for the electrical snags, the same whichever language the sheet
/// is printed in.
const ELECTRICIAN: &str = "J. Morel";

/// The hour on the day of the handover the marks were made at, the hour the
/// electrician answered at, and the days after the handover the answer came.
const MARKED_AT: &str = "09:30:00+02:00";
const ANSWERED_AT: &str = "14:00:00+02:00";
const ANSWERED_AFTER: u64 = 4;

/// Where the window of a blocking snag opens, in points: its left edge, its
/// foot, its width and its height, to the right of the key to the colours.
const WINDOW: (f64, f64, f64, f64) = (RIGHT - 170.0, 166.0, 170.0, 54.0);

/// How far the electrician's answer, and below it the note closing the snag,
/// sit from the anchor of the snag they answer, in points.
const ANSWER_OFFSET: (f64, f64) = (18.0, -14.0);
const CLOSING_OFFSET: (f64, f64) = (18.0, -38.0);

/// The scale the plan is set to, and what turns a length on the premises into a
/// length on the paper: a millimetre is 72/25.4 points, so a centimetre of the
/// premises is a tenth of that, divided again by the scale.
const SCALE_DENOMINATOR: f64 = 300.0;
const POINTS_PER_INCH: f64 = 72.0;
const MILLIMETRES_PER_INCH: f64 = 25.4;
const PLAN_SCALE: f64 = 10.0 * POINTS_PER_INCH / (SCALE_DENOMINATOR * MILLIMETRES_PER_INCH);

/// The premises, in centimetres: how far the shell runs across and up.
const SHELL_WIDTH: f64 = 4800.0;
const SHELL_HEIGHT: f64 = 2600.0;

/// Where the plan's own origin — the inner corner of the shell nearest the
/// bottom left — sits on the page, in points. It is set across the middle of
/// the text.
const PLAN_LEFT: f64 = LEFT + ((RIGHT - LEFT) - SHELL_WIDTH * PLAN_SCALE) / 2.0;
const PLAN_BOTTOM: f64 = 370.0;

/// How far a room's name sits in from its own corner, in points.
const PLAN_PAD: f64 = 5.0;

/// How far the code of a snag sits from the mark it names, in points.
const CODE_OFFSET: f64 = 3.0;

/// One room of the premises: the corner nearest the plan's origin and how far
/// it runs, in centimetres. What the room is called is a word, and is held in
/// `Words` at the place the room has here.
#[derive(Debug)]
struct Room {
    /// The corner nearest the plan's origin.
    x: f64,
    /// See [`Self::x`].
    y: f64,
    /// How far the room runs across.
    width: f64,
    /// How far it runs up.
    height: f64,
}

/// The rooms, in the order the plan lays them out.
const ROOMS: [Room; 4] = [
    Room {
        x: 0.0,
        y: 0.0,
        width: 1800.0,
        height: 1100.0,
    },
    Room {
        x: 0.0,
        y: 1100.0,
        width: 1800.0,
        height: 1500.0,
    },
    Room {
        x: 1800.0,
        y: 0.0,
        width: 3000.0,
        height: 1700.0,
    },
    Room {
        x: 1800.0,
        y: 1700.0,
        width: 3000.0,
        height: 900.0,
    },
];

/// One run of wall the plan draws, in centimetres, and whether it holds the
/// premises in or only parts two rooms.
#[derive(Debug)]
struct Wall {
    /// Where the run begins.
    from: (f64, f64),
    /// Where it ends.
    to: (f64, f64),
    /// Whether it is the shell rather than a partition.
    shell: bool,
}

/// Every run of wall, cut short at each doorway so the openings show.
const WALLS: [Wall; 12] = [
    Wall {
        from: (0.0, 0.0),
        to: (200.0, 0.0),
        shell: true,
    },
    Wall {
        from: (320.0, 0.0),
        to: (4800.0, 0.0),
        shell: true,
    },
    Wall {
        from: (4800.0, 0.0),
        to: (4800.0, 2600.0),
        shell: true,
    },
    Wall {
        from: (4800.0, 2600.0),
        to: (0.0, 2600.0),
        shell: true,
    },
    Wall {
        from: (0.0, 2600.0),
        to: (0.0, 0.0),
        shell: true,
    },
    Wall {
        from: (1800.0, 0.0),
        to: (1800.0, 300.0),
        shell: false,
    },
    Wall {
        from: (1800.0, 390.0),
        to: (1800.0, 1750.0),
        shell: false,
    },
    Wall {
        from: (1800.0, 1840.0),
        to: (1800.0, 2600.0),
        shell: false,
    },
    Wall {
        from: (0.0, 1100.0),
        to: (700.0, 1100.0),
        shell: false,
    },
    Wall {
        from: (790.0, 1100.0),
        to: (1800.0, 1100.0),
        shell: false,
    },
    Wall {
        from: (1800.0, 1700.0),
        to: (2600.0, 1700.0),
        shell: false,
    },
    Wall {
        from: (2690.0, 1700.0),
        to: (4800.0, 1700.0),
        shell: false,
    },
];

/// How badly a snag stands in the way of the premises being used.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Degree {
    /// It is to be made good, and nothing waits on it.
    Minor,
    /// It keeps part of the premises from being used as they are meant to be.
    Major,
    /// Nothing else proceeds until it is made good.
    Blocking,
}

impl Degree {
    /// The days the trade is given to make it good, counted from the handover.
    const fn days(self) -> u32 {
        match self {
            Self::Minor => 30,
            Self::Major => 21,
            Self::Blocking => 7,
        }
    }

    /// The colour every mark of this degree is drawn in.
    const fn ink(self) -> Rgb {
        match self {
            Self::Minor => MINOR_INK,
            Self::Major => MAJOR_INK,
            Self::Blocking => BLOCKING_INK,
        }
    }

    /// Its place in the table of words.
    const fn place(self) -> usize {
        match self {
            Self::Minor => 0,
            Self::Major => 1,
            Self::Blocking => 2,
        }
    }
}

/// Every degree, in the order the summary sets them out: the one that holds
/// everything up first.
const DEGREES: [Degree; 3] = [Degree::Blocking, Degree::Major, Degree::Minor];

/// How a snag is marked on the plan, in centimetres of the premises.
#[derive(Debug)]
enum Mark {
    /// A cloud round a patch the whole of which is under reserve.
    Cloud {
        /// The corner of the patch nearest the plan's origin.
        x: f64,
        /// See [`Self::Cloud::x`].
        y: f64,
        /// How far the patch runs across.
        width: f64,
        /// How far it runs up.
        height: f64,
    },
    /// A ring round a defect that sits at one point.
    Ring {
        /// Where the defect sits.
        x: f64,
        /// See [`Self::Ring::x`].
        y: f64,
        /// How far the ring stands off it.
        radius: f64,
    },
    /// An arrow whose head rests on what the note is about.
    Arrow {
        /// The tail, where the code of the snag is written.
        from: (f64, f64),
        /// The head.
        to: (f64, f64),
    },
    /// The outline of a defect that spreads over an area.
    Footprint {
        /// Its corners, in the order they are joined.
        corners: &'static [(f64, f64)],
    },
    /// A run along a defect that follows a line.
    Run {
        /// The points it passes through, in order.
        along: &'static [(f64, f64)],
    },
}

impl Mark {
    /// Where the code of the snag is written, in centimetres.
    const fn anchor(&self) -> (f64, f64) {
        match *self {
            Self::Cloud { x, y, height, .. } => (x, y + height),
            Self::Ring { x, y, radius } => (x + radius, y + radius),
            Self::Arrow { from, .. } => from,
            Self::Footprint { corners } => corners[0],
            Self::Run { along } => along[0],
        }
    }
}

/// One snag: where it was found, how badly it stands in the way, who answers
/// for it, and how it is marked on the plan. What the defect is is a word, and
/// is held in `Words` at the place the snag has here.
#[derive(Debug)]
struct Snag {
    /// The room it was found in, as its place in the table of rooms.
    room: usize,
    /// How badly it stands in the way.
    degree: Degree,
    /// The trade that answers for it, as its place in the table of trades.
    trade: usize,
    /// How it is marked on the plan.
    mark: Mark,
}

/// The corners of the one defect that spreads over an area, and the points the
/// one that follows a line passes through.
const SPREAD: [(f64, f64); 5] = [
    (2200.0, 300.0),
    (3400.0, 300.0),
    (3400.0, 900.0),
    (2900.0, 1120.0),
    (2200.0, 900.0),
];
const ALONG: [(f64, f64); 3] = [(1810.0, 1880.0), (1810.0, 2220.0), (1810.0, 2560.0)];

/// The snags, in the order they were found.
const SNAGS: [Snag; 9] = [
    Snag {
        room: 0,
        degree: Degree::Major,
        trade: 0,
        mark: Mark::Ring {
            x: 260.0,
            y: 150.0,
            radius: 130.0,
        },
    },
    Snag {
        room: 0,
        degree: Degree::Minor,
        trade: 1,
        mark: Mark::Cloud {
            x: 900.0,
            y: 780.0,
            width: 780.0,
            height: 240.0,
        },
    },
    Snag {
        room: 1,
        degree: Degree::Minor,
        trade: 2,
        mark: Mark::Ring {
            x: 900.0,
            y: 1850.0,
            radius: 170.0,
        },
    },
    Snag {
        room: 1,
        degree: Degree::Major,
        trade: 3,
        mark: Mark::Run { along: &ALONG },
    },
    Snag {
        room: 2,
        degree: Degree::Major,
        trade: 4,
        mark: Mark::Footprint { corners: &SPREAD },
    },
    Snag {
        room: 2,
        degree: Degree::Blocking,
        trade: 5,
        mark: Mark::Arrow {
            from: (4260.0, 980.0),
            to: (3620.0, 130.0),
        },
    },
    Snag {
        room: 2,
        degree: Degree::Minor,
        trade: 5,
        mark: Mark::Ring {
            x: 4380.0,
            y: 1360.0,
            radius: 160.0,
        },
    },
    Snag {
        room: 3,
        degree: Degree::Blocking,
        trade: 6,
        mark: Mark::Cloud {
            x: 2250.0,
            y: 1780.0,
            width: 520.0,
            height: 520.0,
        },
    },
    Snag {
        room: 3,
        degree: Degree::Major,
        trade: 7,
        mark: Mark::Arrow {
            from: (3540.0, 1840.0),
            to: (4280.0, 2400.0),
        },
    },
];

/// The right edge of each of the six columns of the list, measured from the
/// left margin, in points.
const LIST_COLUMNS: [f64; 6] = [28.0, 124.0, 282.0, 340.0, 408.0, 483.276];

/// The right edge of each of the three columns the summary counts a degree or a
/// trade in, and of the four it counts a room in.
const COUNT_COLUMNS: [f64; 3] = [190.0, 260.0, 330.0];
const ROOM_COLUMNS: [f64; 4] = [190.0, 275.0, 345.0, 415.0];

/// Every word the sheet prints, in one language.
///
/// What is not language stays out of it: the firm, the site, the inspectors,
/// the reference, the handover, the room rectangles, the counts, the areas, the
/// shares and the dates are drawn from data of their own and read the same in
/// every language.
#[derive(Debug)]
struct Words {
    /// What the file says it is, and the line under the firm's name.
    title: &'static str,
    tagline: &'static str,
    /// The four marks at the head of the first page.
    site: &'static str,
    handover: &'static str,
    reference: &'static str,
    inspected: &'static str,
    /// What the plan is headed, and what its scale stands under.
    plan: &'static str,
    scale: &'static str,
    /// The legend under the plan, and one line for each kind of mark.
    legend: &'static str,
    cloud: &'static str,
    ring: &'static str,
    arrow: &'static str,
    footprint: &'static str,
    run: &'static str,
    /// The key to the colours, and how long a degree is given, worded round the
    /// number of days.
    key: &'static str,
    within: &'static str,
    /// What the reader is told about the marks, over two lines.
    note: [&'static str; 2],
    /// The three degrees, in the order [`Degree::place`] gives them.
    degrees: [&'static str; 3],
    /// The rooms, in the order the plan lays them out.
    rooms: [&'static str; 4],
    /// The trades that answer for the snags.
    trades: [&'static str; 8],
    /// The nine snags, in the order the list holds them.
    natures: [&'static str; 9],
    /// The heads of the six columns of the list.
    number: &'static str,
    room: &'static str,
    nature: &'static str,
    degree: &'static str,
    due: &'static str,
    trade: &'static str,
    /// What the date a snag is to be made good by stands under, in a sentence
    /// rather than at the head of a column.
    repair: &'static str,
    /// What the list and the summary are headed.
    list: &'static str,
    summary: &'static str,
    /// The heads of the two tables of the summary and of their own columns.
    by_degree: &'static str,
    by_room: &'static str,
    by_trade: &'static str,
    counted: &'static str,
    share: &'static str,
    area: &'static str,
    total: &'static str,
    /// The last line of the summary.
    latest: &'static str,
    /// The two words the foot of every page numbers it with.
    page: &'static str,
    of: &'static str,
    /// What the electrician answers the first blocking snag with, in the note
    /// replying to it.
    answer: &'static str,
}

impl Words {
    /// The words the sheet is printed in, in `language`.
    fn of(language: Language) -> &'static Self {
        language::pick(&WORDS, language)
    }
}

/// The sheet in English.
const ENGLISH: Words = Words {
    title: "Snag list",
    tagline: "Building surveyors",
    site: "SITE",
    handover: "HANDOVER",
    reference: "REFERENCE",
    inspected: "INSPECTED BY",
    plan: "The floor, and where each snag sits",
    scale: "Scale",
    legend: "What each mark means",
    cloud: "Cloud — the whole of the patch it runs round is under reserve.",
    ring: "Ring — a defect that sits at one point.",
    arrow: "Arrow — the head rests on what the note is about.",
    footprint: "Outline — a defect that spreads over an area of its own.",
    run: "Run — a defect that follows a line, a crack, a joint or a skirting.",
    key: "What each colour means",
    within: "made good within {days} days of the handover",
    note: [
        "Every mark on the plan says the same words as its line in the list.",
        "Reading software shows them, hides them or leaves them off the paper.",
    ],
    degrees: ["Minor", "Major", "Blocking"],
    rooms: ["Reception", "Meeting room", "Open office", "Service core"],
    trades: [
        "Joinery",
        "Painting",
        "Plastering",
        "Glazing",
        "Floor covering",
        "Electrics",
        "Plumbing",
        "Air handling",
    ],
    natures: [
        "Entrance door rubs on the floor",
        "Paint runs on the end partition",
        "Ceiling tile cracked over table",
        "Glazed partition scratched",
        "Floor covering lifting at joints",
        "Three sockets dead on south run",
        "Luminaire missing over copier",
        "Water at the foot of the riser",
        "Extract grille not connected",
    ],
    number: "NO.",
    room: "ROOM",
    nature: "WHAT WAS FOUND",
    degree: "DEGREE",
    due: "MAKE GOOD BY",
    trade: "TRADE",
    repair: "to be made good by",
    list: "The snags, one to a line",
    summary: "What the snags come to",
    by_degree: "Gathered by degree",
    by_room: "Gathered by room",
    by_trade: "Gathered by trade",
    counted: "SNAGS",
    share: "SHARE",
    area: "AREA",
    total: "TOTAL",
    latest: "The last of the dates the work is to be made good by",
    page: "Page",
    of: "of",
    answer: "South run rewired: the three sockets are live again.",
};

/// The sheet in French.
const FRENCH: Words = Words {
    title: "Liste de réserves",
    tagline: "Cabinet d’expertise du bâtiment",
    site: "CHANTIER",
    handover: "RÉCEPTION",
    reference: "RÉFÉRENCE",
    inspected: "VISITE FAITE PAR",
    plan: "Le plateau et l’emplacement des réserves",
    scale: "Échelle",
    legend: "Ce que dit chaque marque",
    cloud: "Nuage — toute la surface qu’il entoure est sous réserve.",
    ring: "Cercle — un défaut localisé en un point.",
    arrow: "Flèche — la pointe se pose sur ce qui est en cause.",
    footprint: "Contour — un défaut qui s’étend sur une surface.",
    run: "Filet — un défaut qui suit une ligne : fissure, joint ou plinthe.",
    key: "Ce que dit chaque couleur",
    within: "à lever dans les {days} jours suivant la réception",
    note: [
        "Chaque marque du plan reprend les mots de sa ligne dans la liste.",
        "Le logiciel de lecture les affiche, les masque ou ne les imprime pas.",
    ],
    degrees: ["Mineure", "Majeure", "Bloquante"],
    rooms: [
        "Accueil",
        "Salle de réunion",
        "Plateau ouvert",
        "Locaux techniques",
    ],
    trades: [
        "Menuiserie",
        "Peinture",
        "Plâtrerie",
        "Vitrerie",
        "Sols souples",
        "Électricité",
        "Plomberie",
        "Ventilation",
    ],
    natures: [
        "Porte d’entrée qui frotte au sol",
        "Peinture coulée, cloison du fond",
        "Dalle fendue au-dessus de la table",
        "Cloison vitrée rayée",
        "Sol souple décollé aux joints",
        "Trois prises hors tension côté sud",
        "Luminaire absent côté copieur",
        "Eau au pied de la colonne",
        "Grille d’extraction non raccordée",
    ],
    number: "N°",
    room: "LOCAL",
    nature: "CE QUI A ÉTÉ RELEVÉ",
    degree: "DEGRÉ",
    due: "LEVÉE AVANT LE",
    trade: "CORPS D’ÉTAT",
    repair: "à lever avant le",
    list: "Les réserves, une par ligne",
    summary: "Bilan des réserves",
    by_degree: "Par degré",
    by_room: "Par local",
    by_trade: "Par corps d’état",
    counted: "RÉSERVES",
    share: "PART",
    area: "SURFACE",
    total: "TOTAL",
    latest: "La dernière des dates de levée",
    page: "Page",
    of: "sur",
    answer: "Ligne sud recâblée : les trois prises sont de nouveau sous tension.",
};

/// The sheet in Dutch.
const DUTCH: Words = Words {
    title: "Opleverlijst",
    tagline: "Bouwkundig adviseurs",
    site: "LOCATIE",
    handover: "OPLEVERING",
    reference: "REFERENTIE",
    inspected: "GEÏNSPECTEERD DOOR",
    plan: "De verdieping, en waar elk gebrek zit",
    scale: "Schaal",
    legend: "Wat elke markering betekent",
    cloud: "Wolk: het hele vlak dat ze omsluit, staat onder voorbehoud.",
    ring: "Ring: een gebrek op één punt.",
    arrow: "Pijl: de punt wijst naar waar de notitie over gaat.",
    footprint: "Omtrek: een gebrek dat zich over een eigen vlak uitstrekt.",
    run: "Lijn: een gebrek dat een lijn volgt, een scheur, een voeg of een plint.",
    key: "Wat elke kleur betekent",
    within: "hersteld binnen {days} dagen na oplevering",
    note: [
        "Elke markering op de plattegrond zegt dezelfde woorden als haar regel in de lijst.",
        "Leessoftware toont ze, verbergt ze of laat ze van het papier weg.",
    ],
    degrees: ["Klein", "Groot", "Blokkerend"],
    rooms: [
        "Receptie",
        "Vergaderruimte",
        "Kantoortuin",
        "Technische kern",
    ],
    trades: [
        "Timmerwerk",
        "Schilderwerk",
        "Stucwerk",
        "Beglazing",
        "Vloerbedekking",
        "Elektra",
        "Sanitair",
        "Ventilatie",
    ],
    natures: [
        "Toegangsdeur sleept over de vloer",
        "Verflopers op de achterwand",
        "Plafondplaat gebarsten boven tafel",
        "Glazen wand bekrast",
        "Vloer komt los bij de naden",
        "Drie stopcontacten zonder stroom",
        "Geen lamp boven de kopieerder",
        "Water onder aan de stijgleiding",
        "Afzuigrooster niet aangesloten",
    ],
    number: "NR.",
    room: "RUIMTE",
    nature: "WAT ER GEVONDEN IS",
    degree: "ERNST",
    due: "GEREED OP",
    trade: "VAKGEBIED",
    repair: "te herstellen vóór",
    list: "De gebreken, één per regel",
    summary: "Waar de gebreken op neerkomen",
    by_degree: "Gegroepeerd per ernst",
    by_room: "Gegroepeerd per ruimte",
    by_trade: "Gegroepeerd per vakgebied",
    counted: "GEBREKEN",
    share: "AANDEEL",
    area: "GEBIED",
    total: "TOTAAL",
    latest: "De laatste van de data waarop het werk hersteld moet zijn",
    page: "Pagina",
    of: "van",
    answer: "Zuidgroep opnieuw bedraad: de drie stopcontacten staan weer onder spanning.",
};

/// The sheet in Portuguese.
const PORTUGUESE: Words = Words {
    title: "Lista de reservas",
    tagline: "Peritos de construção",
    site: "OBRA",
    handover: "ENTREGA",
    reference: "REFERÊNCIA",
    inspected: "INSPECIONADO POR",
    plan: "O piso, e onde fica cada reserva",
    scale: "Escala",
    legend: "O que significa cada marca",
    cloud: "Nuvem: toda a zona que contorna está sob reserva.",
    ring: "Anel: um defeito situado num ponto.",
    arrow: "Seta: a ponta assenta naquilo de que a nota fala.",
    footprint: "Contorno: um defeito que se estende por uma zona própria.",
    run: "Percurso: um defeito que segue uma linha, uma fissura, uma junta ou um rodapé.",
    key: "O que significa cada cor",
    within: "corrigido nos {days} dias seguintes à entrega",
    note: [
        "Cada marca na planta diz as mesmas palavras que a sua linha na lista.",
        "O programa de leitura mostra-as, oculta-as ou deixa-as fora do papel.",
    ],
    degrees: ["Ligeira", "Grave", "Bloqueante"],
    rooms: [
        "Receção",
        "Sala de reuniões",
        "Open space",
        "Núcleo técnico",
    ],
    trades: [
        "Carpintaria",
        "Pintura",
        "Estuque",
        "Vidros",
        "Piso",
        "Eletricidade",
        "Canalização",
        "Climatização",
    ],
    natures: [
        "A porta de entrada roça no chão",
        "Escorridos na divisória do fundo",
        "Placa de teto rachada sobre a mesa",
        "Divisória envidraçada riscada",
        "Piso a levantar nas juntas",
        "Três tomadas sem corrente (sul)",
        "Falta a luz sobre a fotocopiadora",
        "Água na base da coluna montante",
        "Grelha de extração por ligar",
    ],
    number: "N.º",
    room: "DIVISÃO",
    nature: "O QUE FOI ENCONTRADO",
    degree: "GRAU",
    due: "CORRIGIR ATÉ",
    trade: "ESPECIALIDADE",
    repair: "a corrigir até",
    list: "As reservas, uma por linha",
    summary: "A que somam as reservas",
    by_degree: "Agrupadas por grau",
    by_room: "Agrupadas por divisão",
    by_trade: "Agrupadas por especialidade",
    counted: "RESERVAS",
    share: "PARTE",
    area: "ZONA",
    total: "TOTAL",
    latest: "A última das datas até às quais o trabalho deve ser corrigido",
    page: "Página",
    of: "de",
    answer: "Troço sul reinstalado: as três tomadas voltaram a ter corrente.",
};

/// The sheet in Italian.
const ITALIAN: Words = Words {
    title: "Elenco delle riserve",
    tagline: "Periti edili",
    site: "CANTIERE",
    handover: "CONSEGNA",
    reference: "RIFERIMENTO",
    inspected: "ISPEZIONATO DA",
    plan: "La pianta, e dove sta ogni riserva",
    scale: "Scala",
    legend: "Cosa significa ogni segno",
    cloud: "Nuvola: tutta l’area che circonda è sotto riserva.",
    ring: "Anello: un difetto in un punto.",
    arrow: "Freccia: la punta indica ciò di cui parla la nota.",
    footprint: "Contorno: un difetto che si estende su un’area propria.",
    run: "Percorso: un difetto che segue una linea, una crepa, un giunto o un battiscopa.",
    key: "Cosa significa ogni colore",
    within: "da sistemare entro {days} giorni dalla consegna",
    note: [
        "Ogni segno sulla pianta dice le stesse parole della sua riga nell’elenco.",
        "Il programma di lettura li mostra, li nasconde o li lascia fuori dalla carta.",
    ],
    degrees: ["Lieve", "Grave", "Bloccante"],
    rooms: ["Reception", "Sala riunioni", "Open space", "Nucleo tecnico"],
    trades: [
        "Falegnameria",
        "Tinteggiatura",
        "Intonaco",
        "Vetrate",
        "Pavimento",
        "Elettrico",
        "Idraulica",
        "Climatizzazione",
    ],
    natures: [
        "La porta d’ingresso sfrega a terra",
        "Colature sulla parete di fondo",
        "Pannello incrinato sopra il tavolo",
        "Parete vetrata graffiata",
        "Pavimento che si solleva ai giunti",
        "Tre prese senza corrente, linea sud",
        "Manca la luce sulla fotocopiatrice",
        "Acqua alla base del montante",
        "Griglia di estrazione non collegata",
    ],
    number: "N.",
    room: "LOCALE",
    nature: "COSA SI È TROVATO",
    degree: "GRADO",
    due: "SCADENZA",
    trade: "IMPRESA",
    repair: "da sistemare entro il",
    list: "Le riserve, una per riga",
    summary: "A cosa ammontano le riserve",
    by_degree: "Raggruppate per grado",
    by_room: "Raggruppate per locale",
    by_trade: "Raggruppate per impresa",
    counted: "RISERVE",
    share: "QUOTA",
    area: "ZONA",
    total: "TOTALE",
    latest: "L’ultima delle date entro cui il lavoro va sistemato",
    page: "Pagina",
    of: "di",
    answer: "Linea sud ricablata: le tre prese sono di nuovo sotto tensione.",
};

/// The sheet in Spanish.
const SPANISH: Words = Words {
    title: "Lista de reservas",
    tagline: "Peritos de edificación",
    site: "OBRA",
    handover: "ENTREGA",
    reference: "REFERENCIA",
    inspected: "INSPECCIONADO POR",
    plan: "La planta, y dónde está cada reserva",
    scale: "Escala",
    legend: "Qué significa cada marca",
    cloud: "Nube: todo el recinto que rodea está bajo reserva.",
    ring: "Anillo: un defecto situado en un punto.",
    arrow: "Flecha: la punta señala aquello de lo que habla la nota.",
    footprint: "Contorno: un defecto que se extiende por una zona propia.",
    run: "Recorrido: un defecto que sigue una línea, una grieta, una junta o un rodapié.",
    key: "Qué significa cada color",
    within: "subsanado en los {days} días siguientes a la entrega",
    note: [
        "Cada marca del plano dice lo mismo que su línea de la lista.",
        "El programa de lectura las muestra, las oculta o las deja fuera del papel.",
    ],
    degrees: ["Leve", "Grave", "Bloqueante"],
    rooms: [
        "Recepción",
        "Sala de reuniones",
        "Oficina diáfana",
        "Núcleo técnico",
    ],
    trades: [
        "Carpintería",
        "Pintura",
        "Yesería",
        "Acristalamiento",
        "Suelo",
        "Electricidad",
        "Fontanería",
        "Climatización",
    ],
    natures: [
        "La puerta de entrada roza el suelo",
        "Chorretones en el tabique del fondo",
        "Placa de techo rajada sobre la mesa",
        "Mampara acristalada rayada",
        "Suelo levantado en las juntas",
        "Tres enchufes sin corriente (sur)",
        "Sin lámpara sobre la fotocopiadora",
        "Agua al pie del montante",
        "Rejilla de extracción sin conectar",
    ],
    number: "N.º",
    room: "ESTANCIA",
    nature: "QUÉ SE ENCONTRÓ",
    degree: "GRADO",
    due: "FECHA LÍMITE",
    trade: "GREMIO",
    repair: "a subsanar antes del",
    list: "Las reservas, una por línea",
    summary: "Lo que suman las reservas",
    by_degree: "Agrupadas por grado",
    by_room: "Agrupadas por estancia",
    by_trade: "Agrupadas por gremio",
    counted: "RESERVAS",
    share: "PARTE",
    area: "ZONA",
    total: "TOTAL",
    latest: "La última de las fechas en que debe subsanarse el trabajo",
    page: "Página",
    of: "de",
    answer: "Tramo sur recableado: los tres enchufes vuelven a tener corriente.",
};

/// The sheet in German.
const GERMAN: Words = Words {
    title: "Mängelliste",
    tagline: "Bausachverständige",
    site: "BAUSTELLE",
    handover: "ÜBERGABE",
    reference: "REFERENZ",
    inspected: "GEPRÜFT VON",
    plan: "Das Geschoss, und wo jeder Mangel liegt",
    scale: "Maßstab",
    legend: "Was jede Markierung bedeutet",
    cloud: "Wolke — die ganze umrandete Fläche steht unter Vorbehalt.",
    ring: "Kreis — ein Mangel an einem Punkt.",
    arrow: "Pfeil — die Spitze zeigt auf das, worum es in der Notiz geht.",
    footprint: "Umriss — ein Mangel, der sich über eine eigene Fläche erstreckt.",
    run: "Linienzug — ein Mangel entlang einer Linie, eines Risses, einer Fuge oder einer Sockelleiste.",
    key: "Was jede Farbe bedeutet",
    within: "binnen {days} Tagen nach der Übergabe zu beheben",
    note: [
        "Jede Markierung im Plan sagt dieselben Worte wie ihre Zeile in der Liste.",
        "Eine Lesesoftware zeigt sie, verbirgt sie oder lässt sie auf dem Papier weg.",
    ],
    degrees: ["Gering", "Erheblich", "Sperrend"],
    rooms: ["Empfang", "Besprechung", "Großraumbüro", "Technik"],
    trades: [
        "Tischler",
        "Maler",
        "Putz",
        "Verglasung",
        "Bodenbelag",
        "Elektro",
        "Sanitär",
        "Lüftung",
    ],
    natures: [
        "Eingangstür schleift am Boden",
        "Farbläufer an Endtrennwand",
        "Deckenplatte über Tisch gerissen",
        "Glastrennwand zerkratzt",
        "Bodenbelag hebt sich an Fugen",
        "Drei Steckdosen Süd ohne Strom",
        "Leuchte über Kopierer fehlt",
        "Wasser am Fuß des Schachts",
        "Abluftgitter nicht angeschlossen",
    ],
    number: "NR.",
    room: "RAUM",
    nature: "BEFUND",
    degree: "GRAD",
    due: "BEHEBEN BIS",
    trade: "GEWERK",
    repair: "zu beheben bis",
    list: "Die Mängel, einer je Zeile",
    summary: "Was die Mängel ergeben",
    by_degree: "Nach Grad",
    by_room: "Nach Raum",
    by_trade: "Nach Gewerk",
    counted: "MÄNGEL",
    share: "ANTEIL",
    area: "BEREICH",
    total: "SUMME",
    latest: "Der letzte der Termine, bis zu denen die Mängel zu beheben sind",
    page: "Seite",
    of: "von",
    answer: "Südstrang neu verdrahtet: Die drei Steckdosen sind wieder unter Strom.",
};

/// Every language the example is written in. A language is added by writing its
/// own set of words and naming it here.
static WORDS: [(Language, &Words); 7] = [
    (Language::English, &ENGLISH),
    (Language::French, &FRENCH),
    (Language::German, &GERMAN),
    (Language::Spanish, &SPANISH),
    (Language::Italian, &ITALIAN),
    (Language::Portuguese, &PORTUGUESE),
    (Language::Dutch, &DUTCH),
];

/// `digits`, its thousands parted by a no-break space, which is how every
/// language this example is written in parts them.
fn grouped(digits: &str) -> String {
    let mut out = String::with_capacity(digits.len() + 4);
    for (index, digit) in digits.chars().enumerate() {
        if index > 0 && (digits.len() - index).is_multiple_of(3) {
            out.push('\u{00A0}');
        }
        out.push(digit);
    }
    out
}

/// A count, written as the sheet writes one.
fn counted(value: usize) -> String {
    grouped(&value.to_string())
}

/// A measurement, written with one decimal, its thousands parted by a no-break
/// space and its decimal by a point.
fn measured(value: f64) -> String {
    let written = format!("{value:.1}");
    let (whole, fraction) = written.split_once('.').unwrap_or((written.as_str(), "0"));
    format!("{}.{fraction}", grouped(whole))
}

/// What `count` out of `total` comes to, as a share of a hundred rounded to the
/// nearest tenth.
fn share(count: usize, total: usize) -> String {
    let tenths = (count * 1000 + total / 2) / total;
    format!(
        "{}.{}\u{00A0}%",
        grouped(&(tenths / 10).to_string()),
        tenths % 10
    )
}

/// The code the sheet knows the snag at `place` by.
fn code(place: usize) -> String {
    format!("S-{:02}", place + 1)
}

/// The floor area of `room`, in square metres.
fn area(room: &Room) -> f64 {
    room.width * room.height / 10_000.0
}

/// The floor area of the whole premises, in square metres.
fn total_area() -> f64 {
    ROOMS.iter().map(area).sum()
}

/// How many snags were found in the room at `place`.
fn found_in(place: usize) -> usize {
    SNAGS.iter().filter(|snag| snag.room == place).count()
}

/// How many snags the trade at `place` answers for.
fn answered_for(place: usize) -> usize {
    SNAGS.iter().filter(|snag| snag.trade == place).count()
}

/// How many snags carry `degree`.
fn found_at(degree: Degree) -> usize {
    SNAGS.iter().filter(|snag| snag.degree == degree).count()
}

/// The day the premises were handed over.
#[allow(
    clippy::expect_used,
    reason = "the handover falls on a day of the calendar"
)]
const fn handover() -> NaiveDate {
    NaiveDate::from_ymd_opt(HANDOVER.0, HANDOVER.1, HANDOVER.2)
        .expect("the handover falls on a day of the calendar")
}

/// The day a snag of `degree` is to be made good by: the handover plus the days
/// that degree allows.
#[allow(
    clippy::expect_used,
    reason = "a month after the handover falls on a day of the calendar"
)]
fn due(degree: Degree) -> NaiveDate {
    handover()
        .checked_add_days(Days::new(u64::from(degree.days())))
        .expect("a month after the handover falls on a day of the calendar")
}

/// The last of the days the snags are to be made good by.
fn latest() -> NaiveDate {
    SNAGS
        .iter()
        .fold(handover(), |last, snag| last.max(due(snag.degree)))
}

/// The moment the marks were made: the handover, at the hour they were made.
fn marked_at() -> String {
    format!("{}T{MARKED_AT}", written(handover()))
}

/// The moment the electrician answered, some days after the handover.
#[allow(
    clippy::expect_used,
    reason = "days after the handover fall on a day of the calendar"
)]
fn answered_at() -> String {
    let day = handover()
        .checked_add_days(Days::new(ANSWERED_AFTER))
        .expect("days after the handover fall on a day of the calendar");
    format!("{}T{ANSWERED_AT}", written(day))
}

/// The place of the first blocking snag in the list: the one whose window opens
/// with the file, and the one the electrician answers.
#[allow(clippy::expect_used, reason = "the list holds a blocking snag")]
fn first_blocking() -> usize {
    SNAGS
        .iter()
        .position(|snag| snag.degree == Degree::Blocking)
        .expect("the list holds a blocking snag")
}

/// The window a snag's words open in, for a blocking snag: open with the file
/// for the first of them, closed for the others. Any other snag has none.
fn window(place: usize, snag: &Snag) -> Option<Popup> {
    if snag.degree != Degree::Blocking {
        return None;
    }
    let (x, y, width, height) = WINDOW;
    let popup = Popup::new(x, y, width, height);
    Some(if place == first_blocking() {
        popup.open()
    } else {
        popup
    })
}

/// A day, written from its largest unit to its smallest, which is how every
/// language this example is written in writes one on a sheet like this.
fn written(day: NaiveDate) -> String {
    format!("{:04}-{:02}-{:02}", day.year(), day.month(), day.day())
}

/// How long a degree is given, in that language's words.
fn allowed(degree: Degree, words: &Words) -> String {
    words
        .within
        .replace("{days}", &grouped(&degree.days().to_string()))
}

/// How far a length on the premises runs on the page.
fn across(centimetres: f64) -> f64 {
    centimetres * PLAN_SCALE
}

/// Where a length on the premises falls on the page, across and up.
fn at_x(centimetres: f64) -> f64 {
    PLAN_LEFT + across(centimetres)
}

fn at_y(centimetres: f64) -> f64 {
    PLAN_BOTTOM + across(centimetres)
}

/// The corners of a mark, as they fall on the page.
fn plotted(corners: &[(f64, f64)]) -> Vec<(f64, f64)> {
    corners.iter().map(|&(x, y)| (at_x(x), at_y(y))).collect()
}

/// Draws a line of text, left-aligned, in a colour of its own.
fn text(content: &mut Content, font: &FontHandle, size: f64, x: f64, y: f64, color: Rgb, s: &str) {
    let _ = content.set_fill(color);
    content.begin_text();
    let _ = content.set_font(font, size);
    let _ = content.text_origin(x, y);
    content.show_glyphs(&font.glyphs(s));
    content.end_text();
}

/// Draws a line of text whose right edge sits at `right`.
fn text_right(
    content: &mut Content,
    font: &FontHandle,
    size: f64,
    right: f64,
    y: f64,
    color: Rgb,
    s: &str,
) {
    text(
        content,
        font,
        size,
        right - font.measure(s, size),
        y,
        color,
        s,
    );
}

/// Draws a rule across the width of the text.
fn rule(content: &mut Content, y: f64) -> Result<(), hqf_pdf::Error> {
    content.set_stroke(RULE)?;
    content.set_line_width(0.6)?;
    content.move_to(LEFT, y)?;
    content.line_to(RIGHT, y)?;
    content.stroke();
    Ok(())
}

/// Fills a band the width of the text, from `y` up by `height`.
fn band(content: &mut Content, y: f64, height: f64, color: Rgb) -> Result<(), hqf_pdf::Error> {
    content.set_fill(color)?;
    content.rect(LEFT, y, RIGHT - LEFT, height)?;
    content.fill();
    Ok(())
}

/// Draws the firm and what the sheet is, and hands back the baseline it ends
/// on.
fn head(content: &mut Content, font: &FontHandle, words: &Words, top: f64) -> f64 {
    let mut y = top;
    text(content, font, FIRM_SIZE, LEFT, y, INK, FIRM);
    text_right(content, font, SMALL, RIGHT, y, MUTED, REFERENCE);
    y -= LINE;
    text(content, font, SMALL, LEFT, y, MUTED, words.tagline);
    y -= BLOCK + LINE;
    text(content, font, TITLE_SIZE, LEFT, y, INK, words.title);
    y
}

/// Draws the four marks that say which premises the sheet is about, and hands
/// back the baseline it ends on.
fn marks(content: &mut Content, font: &FontHandle, words: &Words, top: f64) -> f64 {
    let mut y = top;
    for (label, value) in [
        (words.site, SITE.to_owned()),
        (words.handover, written(handover())),
        (words.inspected, INSPECTOR.to_owned()),
        (words.reference, REFERENCE.to_owned()),
    ] {
        text(content, font, TINY, LEFT, y, MUTED, label);
        text(content, font, BODY, LEFT + 96.0, y, INK, &value);
        y -= LINE + 2.0;
    }
    y
}

/// Draws the floor: the room it is cut into, the wall round it, and what each
/// room is called and comes to.
fn floor(content: &mut Content, font: &FontHandle, words: &Words) -> Result<(), hqf_pdf::Error> {
    for room in &ROOMS {
        content.set_fill(FLOOR)?;
        content.rect(
            at_x(room.x),
            at_y(room.y),
            across(room.width),
            across(room.height),
        )?;
        content.fill();
    }

    for wall in &WALLS {
        let (color, width) = if wall.shell {
            (SHELL_INK, SHELL_WIDTH_PT)
        } else {
            (PARTITION_INK, PARTITION_WIDTH)
        };
        content.set_stroke(color)?;
        content.set_line_width(width)?;
        content.move_to(at_x(wall.from.0), at_y(wall.from.1))?;
        content.line_to(at_x(wall.to.0), at_y(wall.to.1))?;
        content.stroke();
    }

    for (room, name) in ROOMS.iter().zip(words.rooms) {
        let top = at_y(room.y + room.height) - PLAN_PAD - SMALL;
        text(
            content,
            font,
            SMALL,
            at_x(room.x) + PLAN_PAD,
            top,
            INK,
            name,
        );
        let measure = format!("{} m²", measured(area(room)));
        text(
            content,
            font,
            TINY,
            at_x(room.x) + PLAN_PAD,
            top - LINE,
            MUTED,
            &measure,
        );
    }
    Ok(())
}

/// Draws the code of every snag beside the mark that stands for it.
fn codes(content: &mut Content, font: &FontHandle) {
    for (place, snag) in SNAGS.iter().enumerate() {
        let (x, y) = snag.mark.anchor();
        text(
            content,
            font,
            TINY,
            at_x(x) + CODE_OFFSET,
            at_y(y) + CODE_OFFSET,
            snag.degree.ink(),
            &code(place),
        );
    }
}

/// The words reading software speaks in place of a mark: the same line the list
/// prints, run together.
fn spoken(place: usize, snag: &Snag, words: &Words) -> String {
    format!(
        "{} — {} — {} — {} — {} {}",
        code(place),
        words.rooms[snag.room],
        words.natures[place],
        words.degrees[snag.degree.place()],
        words.repair,
        written(due(snag.degree))
    )
}

/// The mark one snag wears on the plan.
///
/// # Errors
///
/// If a footprint or a run names too few points to enclose or to join anything.
fn marked(place: usize, snag: &Snag, words: &Words) -> Result<Annotation, hqf_pdf::Error> {
    let ink = snag.degree.ink();
    let border = AnnotationBorder::solid(MARK_WIDTH);
    let says = spoken(place, snag, words);
    let named = code(place);
    let opens = window(place, snag);

    // Who made the mark, when, the trade it is put to, and the window its words
    // open in, the same on every kind of mark.
    macro_rules! signed {
        ($mark:expr) => {{
            let mark = $mark
                .author(INSPECTOR)
                .subject(words.trades[snag.trade])
                .created(marked_at());
            match opens {
                Some(popup) => mark.popup(popup).into(),
                None => mark.into(),
            }
        }};
    }

    Ok(match snag.mark {
        Mark::Cloud {
            x,
            y,
            width,
            height,
        } => signed!(
            Square::new(at_x(x), at_y(y), across(width), across(height))
                .effect(BorderEffect::Cloudy {
                    intensity: CLOUD_BULGE,
                })
                .color(ink)
                .border(border)
                .name(named)
                .contents(says)
        ),
        Mark::Ring { x, y, radius } => signed!(
            Circle::new(
                at_x(x - radius),
                at_y(y - radius),
                across(radius * 2.0),
                across(radius * 2.0),
            )
            .color(ink)
            .border(border)
            .name(named)
            .contents(says)
        ),
        Mark::Arrow { from, to } => signed!(
            Line::new(at_x(from.0), at_y(from.1), at_x(to.0), at_y(to.1))
                .endings(LineEnding::None, LineEnding::ClosedArrow)
                .interior(ink)
                .color(ink)
                .border(border)
                .name(named)
                .contents(says)
        ),
        Mark::Footprint { corners } => signed!(
            Polygon::new(plotted(corners))?
                .interior(FOOTPRINT_TINT)
                .color(ink)
                .border(border)
                .name(named)
                .contents(says)
        ),
        Mark::Run { along } => signed!(
            PolyLine::new(plotted(along))?
                .endings(LineEnding::Butt, LineEnding::Butt)
                .color(ink)
                .border(border)
                .name(named)
                .contents(says)
        ),
    })
}

/// The two notes answering the first blocking snag: the electrician's answer,
/// and below it the inspectors' note setting the snag to completed.
fn answers(words: &Words) -> [Annotation; 2] {
    let answered = first_blocking();
    let (x, y) = SNAGS[answered].mark.anchor();
    let (x, y) = (at_x(x), at_y(y));
    [
        StickyNote::new(x + ANSWER_OFFSET.0, y + ANSWER_OFFSET.1, words.answer)
            .icon(NoteIcon::Check)
            .author(ELECTRICIAN)
            .created(answered_at())
            .in_reply_to(code(answered))
            .into(),
        StickyNote::state_change(
            x + CLOSING_OFFSET.0,
            y + CLOSING_OFFSET.1,
            code(answered),
            AnnotationState::Completed,
            INSPECTOR,
        )
        .into(),
    ]
}

/// Draws what each kind of mark means and what each colour means, and hands
/// back the baseline it ends on.
fn legend(content: &mut Content, font: &FontHandle, words: &Words, top: f64) -> f64 {
    let mut y = top;
    text(content, font, HEADING_SIZE, LEFT, y, INK, words.legend);
    y -= BLOCK;
    for line in [
        words.cloud,
        words.ring,
        words.arrow,
        words.footprint,
        words.run,
    ] {
        text(content, font, SMALL, LEFT, y, INK, line);
        y -= LINE + 2.0;
    }

    y -= BLOCK - LINE;
    text(content, font, HEADING_SIZE, LEFT, y, INK, words.key);
    y -= BLOCK;
    for degree in DEGREES {
        let _ = content.set_fill(degree.ink());
        let _ = content.rect(LEFT, y - 0.5, SMALL, SMALL);
        content.fill();
        let named = format!(
            "{} — {}",
            words.degrees[degree.place()],
            allowed(degree, words)
        );
        text(content, font, SMALL, LEFT + SMALL + 6.0, y, INK, &named);
        y -= LINE + 2.0;
    }

    y -= BLOCK - LINE;
    for line in words.note {
        text(content, font, SMALL, LEFT, y, MUTED, line);
        y -= LINE;
    }
    y
}

/// Draws the rule and the numbering every page ends on.
fn foot(content: &mut Content, font: &FontHandle, words: &Words, sheet: usize) {
    let _ = rule(content, FOOT + LINE);
    let named = format!("{} · {REFERENCE}", words.title);
    text(content, font, TINY, LEFT, FOOT, MUTED, &named);
    let numbered = format!(
        "{} {} {} {}",
        words.page,
        counted(sheet + 1),
        words.of,
        counted(SHEETS.len())
    );
    text_right(content, font, TINY, RIGHT, FOOT, MUTED, &numbered);
}

/// Draws the short head the pages after the first carry, and hands back the
/// baseline it ends on.
fn banner(content: &mut Content, font: &FontHandle, heading: &str) -> f64 {
    text(content, font, SMALL, LEFT, HEAD_TOP, MUTED, FIRM);
    text_right(content, font, SMALL, RIGHT, HEAD_TOP, MUTED, REFERENCE);
    let _ = rule(content, HEAD_TOP - 8.0);
    let y = HEAD_TOP - BLOCK - LINE;
    text(content, font, TITLE_SIZE, LEFT, y, INK, heading);
    y - GAP
}

/// Draws one row of a table, each cell against the right edge of its column,
/// save the first two, which are set from the left.
fn list_row(
    content: &mut Content,
    font: &FontHandle,
    y: f64,
    size: f64,
    color: Rgb,
    cells: &[String; 6],
) {
    let mut left = LEFT;
    for (place, cell) in cells.iter().enumerate() {
        let right = LEFT + LIST_COLUMNS[place];
        if place == 3 || place == 4 {
            text_right(content, font, size, right - 6.0, y, color, cell);
        } else {
            text(content, font, size, left, y, color, cell);
        }
        left = right + 6.0;
    }
}

/// What the plan is headed: what it shows, the scale it is set to, and how far
/// the premises run.
fn plan_heading(words: &Words) -> String {
    format!(
        "{} — {} 1:{SCALE_DENOMINATOR:.0} — {} m × {} m",
        words.plan,
        words.scale,
        measured(SHELL_WIDTH / 100.0),
        measured(SHELL_HEIGHT / 100.0)
    )
}

/// Draws the plan, the marks over it and what they mean.
///
/// # Errors
///
/// If a mark names too few points, or a shape cannot be drawn.
fn plan_sheet(font: &FontHandle, words: &Words, sheet: usize) -> Result<Page, Box<dyn Error>> {
    let mut content = Content::new();
    let mut page = Page::new(PAGE_WIDTH, PAGE_HEIGHT);

    let y = head(&mut content, font, words, HEAD_TOP);
    let y = marks(&mut content, font, words, y - BLOCK - LINE);

    rule(&mut content, y - 6.0)?;
    let heading = plan_heading(words);
    text(
        &mut content,
        font,
        HEADING_SIZE,
        LEFT,
        y - BLOCK,
        INK,
        &heading,
    );

    floor(&mut content, font, words)?;
    codes(&mut content, font);

    rule(&mut content, PLAN_BOTTOM - BLOCK)?;
    legend(&mut content, font, words, PLAN_BOTTOM - GAP);
    foot(&mut content, font, words, sheet);

    for (place, snag) in SNAGS.iter().enumerate() {
        page.annotations.push(marked(place, snag, words)?);
    }
    page.annotations.extend(answers(words));

    page.content = content.into_bytes();
    Ok(page)
}

/// Draws the snags, one to a line.
///
/// # Errors
///
/// If a band or a rule cannot be drawn.
fn list_sheet(font: &FontHandle, words: &Words, sheet: usize) -> Result<Page, Box<dyn Error>> {
    let mut content = Content::new();
    let mut page = Page::new(PAGE_WIDTH, PAGE_HEIGHT);

    let top = banner(&mut content, font, words.list);

    band(&mut content, top - 6.0, ROW, HEAD_BAND)?;
    let heads = [
        words.number.to_owned(),
        words.room.to_owned(),
        words.nature.to_owned(),
        words.degree.to_owned(),
        words.due.to_owned(),
        words.trade.to_owned(),
    ];
    list_row(&mut content, font, top, TINY, MUTED, &heads);

    let mut y = top - ROW;
    for (place, snag) in SNAGS.iter().enumerate() {
        if place % 2 == 1 {
            band(&mut content, y - 6.0, ROW, ROW_BAND)?;
        }
        let cells = [
            code(place),
            words.rooms[snag.room].to_owned(),
            words.natures[place].to_owned(),
            words.degrees[snag.degree.place()].to_owned(),
            written(due(snag.degree)),
            words.trades[snag.trade].to_owned(),
        ];
        list_row(&mut content, font, y, SMALL, INK, &cells);
        y -= ROW;
    }

    rule(&mut content, y + ROW - 8.0)?;
    let counted_all = format!("{} — {}", words.total, counted(SNAGS.len()));
    text(&mut content, font, BODY, LEFT, y - 6.0, INK, &counted_all);

    y -= GAP;
    for line in words.note {
        text(&mut content, font, SMALL, LEFT, y, MUTED, line);
        y -= LINE;
    }

    foot(&mut content, font, words, sheet);
    page.content = content.into_bytes();
    Ok(page)
}

/// Draws a table that gathers the snags under a name, one row to a name, and
/// hands back the baseline it ends on. A row that carries a colour is set
/// behind a swatch of it.
///
/// # Errors
///
/// If a band or a rule cannot be drawn.
fn gathered(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    top: f64,
    heading: &str,
    column: &str,
    rows: &[(&str, usize, Option<Rgb>)],
) -> Result<f64, hqf_pdf::Error> {
    let all = SNAGS.len();
    let mut y = top;
    text(content, font, HEADING_SIZE, LEFT, y, INK, heading);

    y -= BLOCK;
    band(content, y - 6.0, ROW, HEAD_BAND)?;
    text(content, font, TINY, LEFT + 6.0, y, MUTED, column);
    let counts = LEFT + COUNT_COLUMNS[1];
    let shares = LEFT + COUNT_COLUMNS[2];
    text_right(content, font, TINY, counts, y, MUTED, words.counted);
    text_right(content, font, TINY, shares, y, MUTED, words.share);

    y -= ROW;
    for &(name, found, swatch) in rows {
        let mut left = LEFT + 6.0;
        if let Some(color) = swatch {
            content.set_fill(color)?;
            content.rect(left, y - 0.5, SMALL, SMALL)?;
            content.fill();
            left += SMALL + 6.0;
        }
        text(content, font, BODY, left, y, INK, name);
        text_right(content, font, BODY, counts, y, INK, &counted(found));
        text_right(content, font, BODY, shares, y, INK, &share(found, all));
        y -= ROW;
    }

    rule(content, y + ROW - 8.0)?;
    text(content, font, BODY, LEFT + 6.0, y, INK, words.total);
    text_right(content, font, BODY, counts, y, INK, &counted(all));
    Ok(y)
}

/// Draws the table that gathers the snags room by room, with what each room
/// covers, and hands back the baseline it ends on.
///
/// # Errors
///
/// If a band or a rule cannot be drawn.
fn by_room(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    top: f64,
) -> Result<f64, hqf_pdf::Error> {
    let all = SNAGS.len();
    let mut y = top;
    text(content, font, HEADING_SIZE, LEFT, y, INK, words.by_room);

    y -= BLOCK;
    band(content, y - 6.0, ROW, HEAD_BAND)?;
    text(content, font, TINY, LEFT + 6.0, y, MUTED, words.room);
    for (place, column) in [words.area, words.counted, words.share].iter().enumerate() {
        let right = LEFT + ROOM_COLUMNS[place + 1];
        text_right(content, font, TINY, right, y, MUTED, column);
    }

    y -= ROW;
    for (place, name) in words.rooms.iter().enumerate() {
        let found = found_in(place);
        let covered = format!("{} m²", measured(area(&ROOMS[place])));
        text(content, font, BODY, LEFT + 6.0, y, INK, name);
        text_right(
            content,
            font,
            BODY,
            LEFT + ROOM_COLUMNS[1],
            y,
            INK,
            &covered,
        );
        let counted_here = counted(found);
        text_right(
            content,
            font,
            BODY,
            LEFT + ROOM_COLUMNS[2],
            y,
            INK,
            &counted_here,
        );
        let shared = share(found, all);
        text_right(content, font, BODY, LEFT + ROOM_COLUMNS[3], y, INK, &shared);
        y -= ROW;
    }

    rule(content, y + ROW - 8.0)?;
    let covered = format!("{} m²", measured(total_area()));
    text(content, font, BODY, LEFT + 6.0, y, INK, words.total);
    text_right(
        content,
        font,
        BODY,
        LEFT + ROOM_COLUMNS[1],
        y,
        INK,
        &covered,
    );
    text_right(
        content,
        font,
        BODY,
        LEFT + ROOM_COLUMNS[2],
        y,
        INK,
        &counted(all),
    );
    Ok(y)
}

/// Draws what the snags come to: the count and the share of each degree, then
/// of each room, then of each trade, then the last of the dates.
///
/// # Errors
///
/// If a band or a rule cannot be drawn.
fn summary_sheet(font: &FontHandle, words: &Words, sheet: usize) -> Result<Page, Box<dyn Error>> {
    let mut content = Content::new();
    let mut page = Page::new(PAGE_WIDTH, PAGE_HEIGHT);

    let mut y = banner(&mut content, font, words.summary);

    let degrees: Vec<(&str, usize, Option<Rgb>)> = DEGREES
        .iter()
        .map(|&degree| {
            (
                words.degrees[degree.place()],
                found_at(degree),
                Some(degree.ink()),
            )
        })
        .collect();
    y = gathered(
        &mut content,
        font,
        words,
        y,
        words.by_degree,
        words.degree,
        &degrees,
    )?;

    y -= GAP;
    y = by_room(&mut content, font, words, y)?;

    let trades: Vec<(&str, usize, Option<Rgb>)> = words
        .trades
        .iter()
        .enumerate()
        .map(|(place, &name)| (name, answered_for(place), None))
        .collect();
    y -= GAP;
    y = gathered(
        &mut content,
        font,
        words,
        y,
        words.by_trade,
        words.trade,
        &trades,
    )?;

    y -= GAP;
    band(&mut content, y - 8.0, ROW + 6.0, HEAD_BAND)?;
    text(&mut content, font, BODY, LEFT + 6.0, y, INK, words.latest);
    let last = written(latest());
    text_right(
        &mut content,
        font,
        HEADING_SIZE,
        RIGHT - 6.0,
        y - 1.0,
        INK,
        &last,
    );

    foot(&mut content, font, words, sheet);
    page.content = content.into_bytes();
    Ok(page)
}

/// What draws one page of the sheet, given the place that page has in it.
type Sheet = fn(&FontHandle, &Words, usize) -> Result<Page, Box<dyn Error>>;

/// The pages the sheet runs to, in order. The foot of each reads its own place
/// and this table's length, so a page added here numbers itself.
const SHEETS: [Sheet; 3] = [plan_sheet, list_sheet, summary_sheet];

fn main() -> std::process::ExitCode {
    failure::reported(run())
}

fn run() -> Result<(), Box<dyn Error>> {
    let language = Language::from_environment()?;
    let words = Words::of(language);

    let mut args = env::args().skip(1);
    // A named file is written as named; the default one carries the language,
    // so the two languages do not overwrite each other in `tmp/`.
    let path = args
        .next()
        .unwrap_or_else(|| language.file_name(&out::default_path("snag_list")));
    let font_path = args.next().map_or_else(default_font, PathBuf::from);

    let mut doc = Document::new();
    doc.set_license(licence::licensed());
    doc.set_info(Name::new("Title"), &format!("{} {REFERENCE}", words.title));

    let font = doc.add_font(Font::parse(fs::read(&font_path)?)?);

    for (sheet, draw) in SHEETS.iter().enumerate() {
        doc.add_page(draw(&font, words, sheet)?)?;
    }

    let bytes = doc.to_bytes()?;
    if let Some(parent) = Path::new(&path).parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(&path, &bytes)?;

    println!(
        "wrote {path}: {} bytes, {} snags marked on {} m², last date {}",
        bytes.len(),
        counted(SNAGS.len()),
        measured(total_area()),
        written(latest())
    );
    Ok(())
}

#[cfg(test)]
mod tests {
    use hqf_pdf::read::Reader;
    use hqf_pdf::{Document, Font, FontHandle};

    use super::language::Language;
    use super::{
        BODY, DEGREES, Degree, ELECTRICIAN, ENGLISH, HEADING_SIZE, INSPECTOR, LEFT, LIST_COLUMNS,
        Mark, RIGHT, ROOMS, SHEETS, SHELL_HEIGHT, SHELL_WIDTH, SMALL, SNAGS, TINY, WORDS,
        answered_at, answered_for, area, code, counted, default_font, due, first_blocking,
        found_at, found_in, grouped, handover, language, latest, marked_at, measured, plan_heading,
        share, total_area, written,
    };

    /// The lines two languages are allowed to write the same way, each with
    /// what makes the two the same word.
    const SPARED: [&str; 21] = [
        // The line a table ends on is headed by the same word in French as in
        // English.
        r#"total: "TOTAL""#,
        // So is a page of a document.
        r#"page: "Page""#,
        // Written the same way in Italian.
        r#""Grave""#,
        r#""Reception""#,
        r#"area: "ZONA""#,
        r#"degree: "GRADO""#,
        // Written the same way in Portuguese.
        r#""Bloqueante""#,
        r#""Núcleo técnico""#,
        r#""Open space""#,
        r#""Pintura""#,
        r#"counted: "RESERVAS""#,
        r#"handover: "ENTREGA""#,
        r#"number: "N.º""#,
        r#"of: "de""#,
        r#"page: "Página""#,
        r#"scale: "Escala""#,
        r#"share: "PARTE""#,
        r#"site: "OBRA""#,
        r#"title: "Lista de reservas""#,
        // Written the same way in Dutch.
        r#"number: "NR.""#,
        r#"page: "Pagina""#,
    ];

    #[test]
    fn every_language_writes_the_sheet_in_its_own_words() {
        let untranslated = language::untranslated_lines(&WORDS, &SPARED);

        assert!(
            untranslated.is_empty(),
            "the sheet says these in more than one language: {untranslated:?}"
        );
    }

    /// A number over a thousand holds its thousands apart, a measurement puts a
    /// point before its tenth, and a share is rounded to the nearer tenth.
    #[test]
    fn a_number_is_written_with_a_space_between_its_thousands() {
        assert_eq!(grouped("1234567"), "1\u{00A0}234\u{00A0}567");
        assert_eq!(counted(9), "9");
        assert_eq!(measured(1248.0), "1\u{00A0}248.0");
        assert_eq!(measured(198.0), "198.0");
        assert_eq!(share(1, 3), "33.3\u{00A0}%");
        assert_eq!(share(2, 9), "22.2\u{00A0}%");
    }

    /// Every snag is gathered once under a degree and once under a room, and
    /// the shares of a whole come to a hundred but for what rounding takes.
    #[test]
    fn the_summary_counts_every_snag_once() {
        let all = SNAGS.len();
        let by_degree: usize = DEGREES.iter().map(|&degree| found_at(degree)).sum();
        let by_room: usize = (0..ROOMS.len()).map(found_in).sum();

        assert_eq!(by_degree, all, "the degrees gather {by_degree} of {all}");
        assert_eq!(by_room, all, "the rooms gather {by_room} of {all}");

        for degree in DEGREES {
            assert!(
                found_at(degree) > 0,
                "no snag is {degree:?}, and the summary would print a share of nothing"
            );
        }

        // Every share is rounded to the nearer tenth, so the three of them come
        // to a hundred give or take half a tenth apiece.
        let tenths: usize = DEGREES
            .iter()
            .map(|&degree| (found_at(degree) * 1000 + all / 2) / all)
            .sum();
        let apart = tenths.abs_diff(1000);
        assert!(
            apart <= DEGREES.len(),
            "the shares come to {tenths} tenths of a hundred rather than 1000"
        );
    }

    /// Every trade the sheet names answers for at least one snag, so the table
    /// that gathers them prints no empty row, and the three tables gather the
    /// same nine snags.
    #[test]
    fn every_trade_answers_for_at_least_one_snag() {
        let all = SNAGS.len();
        let by_trade: usize = (0..ENGLISH.trades.len()).map(answered_for).sum();

        assert_eq!(by_trade, all, "the trades answer for {by_trade} of {all}");
        for place in 0..ENGLISH.trades.len() {
            assert!(
                answered_for(place) > 0,
                "no snag is answered for by trade {place}"
            );
        }
    }

    /// The area of the premises is what the rooms of the plan come to, and each
    /// room's is what its own rectangle covers at a hundred square centimetres
    /// to the square metre.
    #[test]
    fn the_area_is_what_the_plan_draws() {
        let summed: f64 = ROOMS.iter().map(area).sum();

        assert!(
            (total_area() - summed).abs() < f64::EPSILON,
            "the premises come to {} and the rooms to {summed}",
            total_area()
        );
        assert_eq!(measured(area(&ROOMS[0])), "198.0");
        assert_eq!(measured(total_area()), "1\u{00A0}248.0");

        let shell = SHELL_WIDTH * SHELL_HEIGHT / 10_000.0;
        assert!(
            summed <= shell,
            "the rooms come to {summed} m² inside a shell of {shell} m²"
        );
    }

    /// A snag is to be made good by the handover plus the days its degree
    /// allows, and the last of those dates is the greatest of them.
    #[test]
    fn a_date_is_the_handover_plus_the_days_the_degree_allows() {
        assert_eq!(written(handover()), "2026-09-14");
        assert_eq!(written(due(Degree::Blocking)), "2026-09-21");
        assert_eq!(written(due(Degree::Major)), "2026-10-05");
        assert_eq!(written(due(Degree::Minor)), "2026-10-14");

        let last = SNAGS
            .iter()
            .map(|snag| due(snag.degree))
            .max()
            .expect("the list holds at least one snag");
        assert_eq!(latest(), last);
    }

    /// Every snag names a room, a trade and a defect the words of every
    /// language hold.
    #[test]
    fn every_snag_names_words_every_language_holds() {
        for (named, words) in WORDS {
            for (place, snag) in SNAGS.iter().enumerate() {
                assert!(
                    snag.room < words.rooms.len(),
                    "{} names room {} of {}",
                    named.code(),
                    snag.room,
                    words.rooms.len()
                );
                assert!(
                    snag.trade < words.trades.len(),
                    "{} names trade {} of {}",
                    named.code(),
                    snag.trade,
                    words.trades.len()
                );
                assert!(
                    !words.natures[place].is_empty(),
                    "{} says nothing of {}",
                    named.code(),
                    code(place)
                );
            }
        }
    }

    /// A mark that falls outside the premises marks nothing: every point of
    /// every mark lies within the shell the plan draws.
    #[test]
    fn every_mark_falls_inside_the_premises() {
        let inside = |x: f64, y: f64, what: &str| {
            assert!(
                (0.0..=SHELL_WIDTH).contains(&x) && (0.0..=SHELL_HEIGHT).contains(&y),
                "{what} stands at ({x}, {y}), outside a shell of {SHELL_WIDTH} by {SHELL_HEIGHT}"
            );
        };

        for (place, snag) in SNAGS.iter().enumerate() {
            let named = code(place);
            match snag.mark {
                Mark::Cloud {
                    x,
                    y,
                    width,
                    height,
                } => {
                    inside(x, y, &named);
                    inside(x + width, y + height, &named);
                }
                Mark::Ring { x, y, radius } => {
                    inside(x - radius, y - radius, &named);
                    inside(x + radius, y + radius, &named);
                }
                Mark::Arrow { from, to } => {
                    inside(from.0, from.1, &named);
                    inside(to.0, to.1, &named);
                }
                Mark::Footprint { corners } => {
                    for &(x, y) in corners {
                        inside(x, y, &named);
                    }
                }
                Mark::Run { along } => {
                    for &(x, y) in along {
                        inside(x, y, &named);
                    }
                }
            }
        }
    }

    /// The plan carries one mark per snag and the two notes answering the first
    /// blocking snag, each kind of mark is used, and every one of them is an
    /// annotation the page holds above what it draws.
    #[test]
    fn every_snag_is_marked_above_the_page() {
        let mut doc = Document::new();
        let font = doc.add_font(
            Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                .expect("the committed font parses"),
        );

        for (named, words) in WORDS {
            let page = SHEETS[0](&font, words, 0).expect("the plan draws");
            assert_eq!(
                page.annotations.len(),
                SNAGS.len() + 2,
                "the {} plan carries {} annotations for {} snags and two notes",
                named.code(),
                page.annotations.len(),
                SNAGS.len()
            );
        }

        for kind in ["Cloud", "Ring", "Arrow", "Footprint", "Run"] {
            let drawn = SNAGS
                .iter()
                .filter(|snag| format!("{:?}", snag.mark).starts_with(kind))
                .count();
            assert!(drawn > 0, "no snag is marked by a {kind}");
        }
    }

    /// Read back, every mark names the inspectors, the moment of the handover
    /// and its trade; the blocking snags open a window and no other snag does;
    /// and the first blocking snag is answered by the electrician and closed by
    /// the inspectors.
    #[test]
    fn the_first_blocking_snag_is_answered_and_closed_under_its_own_window() {
        for (named, words) in WORDS {
            let mut doc = Document::new();
            doc.set_license(super::licence::licensed());
            let font = doc.add_font(
                Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                    .expect("the committed font parses"),
            );
            doc.add_page(SHEETS[0](&font, words, 0).expect("the plan draws"))
                .expect("the page is added");
            let read = Reader::new(doc.to_bytes().expect("the plan writes"))
                .expect("the plan reads back")
                .annotations(0)
                .expect("the annotations read");

            let marks: Vec<_> = read
                .iter()
                .filter(|annotation| !matches!(annotation.kind.as_str(), "Popup" | "Text"))
                .collect();
            assert_eq!(marks.len(), SNAGS.len(), "{}", named.code());
            for (mark, snag) in marks.iter().zip(&SNAGS) {
                assert_eq!(mark.author.as_deref(), Some(INSPECTOR));
                assert_eq!(mark.subject.as_deref(), Some(words.trades[snag.trade]));
                assert_eq!(mark.created, Some(marked_at()));
                assert_eq!(
                    mark.popup.is_some(),
                    snag.degree == Degree::Blocking,
                    "{mark:?}"
                );
            }
            let answered = read
                .iter()
                .position(|annotation| annotation.name == Some(code(first_blocking())))
                .expect("the first blocking snag reads back");
            let notes: Vec<_> = read
                .iter()
                .filter(|annotation| annotation.kind == "Text")
                .collect();
            assert_eq!(notes.len(), 2, "{}", named.code());
            assert!(notes.iter().all(|note| note.in_reply_to == Some(answered)));
            assert_eq!(notes[0].author.as_deref(), Some(ELECTRICIAN));
            assert_eq!(notes[0].contents.as_deref(), Some(words.answer));
            assert_eq!(notes[0].created, Some(answered_at()));
            assert_eq!(notes[1].author.as_deref(), Some(INSPECTOR));
            assert_eq!(notes[1].state.as_deref(), Some("Completed"));
        }
    }

    /// Weighs one row of the list against the columns it is set in.
    fn fits(font: &FontHandle, named: Language, size: f64, cells: &[String; 6]) {
        let mut left = 0.0;
        for (column, cell) in cells.iter().enumerate() {
            let room = LIST_COLUMNS[column] - left - 6.0;
            let measure = font.measure(cell, size);
            assert!(
                measure <= room,
                "the {} list sets {cell:?} over {measure:.1} points, and its column \
                 has {room:.1}",
                named.code()
            );
            left = LIST_COLUMNS[column] + 6.0;
        }
    }

    /// A cell wider than its column runs into the next one: every cell of the
    /// list, in every language, is set inside the column it belongs to.
    #[test]
    fn every_language_fits_its_cells_in_the_columns() {
        let mut doc = Document::new();
        let font = doc.add_font(
            Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                .expect("the committed font parses"),
        );

        for (named, words) in WORDS {
            let heads = [
                words.number.to_owned(),
                words.room.to_owned(),
                words.nature.to_owned(),
                words.degree.to_owned(),
                words.due.to_owned(),
                words.trade.to_owned(),
            ];
            fits(&font, named, TINY, &heads);

            for (place, snag) in SNAGS.iter().enumerate() {
                let cells = [
                    code(place),
                    words.rooms[snag.room].to_owned(),
                    words.natures[place].to_owned(),
                    words.degrees[snag.degree.place()].to_owned(),
                    written(due(snag.degree)),
                    words.trades[snag.trade].to_owned(),
                ];
                fits(&font, named, SMALL, &cells);
            }

            for line in [
                words.cloud,
                words.ring,
                words.arrow,
                words.footprint,
                words.run,
            ]
            .into_iter()
            .chain(words.note)
            {
                let measure = font.measure(line, BODY);
                let room = RIGHT - LEFT;
                assert!(
                    measure <= room,
                    "the {} legend sets {line:?} over {measure:.1} points, and the \
                     page has {room:.1}",
                    named.code()
                );
            }

            let heading = plan_heading(words);
            let measure = font.measure(&heading, HEADING_SIZE);
            let room = RIGHT - LEFT;
            assert!(
                measure <= room,
                "the {} plan is headed {heading:?} over {measure:.1} points, and the \
                 page has {room:.1}",
                named.code()
            );
        }
    }
}