write_snag_list.py

"""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 Python twin of the `write_snag_list` example in Rust: the same sheet, through the
binding rather than through the library directly.

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: python examples/write_snag_list.py [out.pdf] [font.ttf]
       HQF_PDF_LANG=fr python examples/write_snag_list.py [out.pdf]
"""

from __future__ import annotations

from dataclasses import dataclass
from datetime import date, timedelta
from pathlib import Path

import _language
import _licence
import _out

import hqf_pdf

# The space that holds a figure and the sign beside it together.
NO_BREAK = " "

# The sheet, in points: A4 upright.
PAGE_WIDTH = 595.276
PAGE_HEIGHT = 841.890

# The margins every page keeps clear.
LEFT = 56.0
RIGHT = PAGE_WIDTH - LEFT

# Where the first baseline of a page sits, and where its foot is written.
HEAD_TOP = 786.0
FOOT = 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.
LINE = 12.0
BLOCK = 22.0
GAP = BLOCK * 2.0
ROW = 21.0

# The sizes the sheet is set at.
FIRM_SIZE = 15.0
TITLE_SIZE = 19.0
HEADING_SIZE = 11.0
BODY = 9.0
SMALL = 8.0
TINY = 6.5

# The near-black the sheet is set in, the grey its labels take, and the rule that parts
# two blocks.
INK = hqf_pdf.Rgb(0.11, 0.12, 0.14)
MUTED = hqf_pdf.Rgb(0.42, 0.44, 0.48)
RULE = hqf_pdf.Rgb(0.78, 0.79, 0.82)

# The grey a table's head band and its every other row are filled with.
HEAD_BAND = hqf_pdf.Rgb(0.90, 0.91, 0.93)
ROW_BAND = hqf_pdf.Rgb(0.965, 0.968, 0.972)

# The floor of a room, the wall round the premises, and the partition between two rooms.
FLOOR = hqf_pdf.Rgb(0.965, 0.960, 0.945)
SHELL_INK = hqf_pdf.Rgb(0.20, 0.22, 0.26)
PARTITION_INK = hqf_pdf.Rgb(0.52, 0.54, 0.58)

# The tint the outline of a spreading defect is filled with.
FOOTPRINT_TINT = hqf_pdf.Rgb(0.98, 0.93, 0.86)

# The colour every mark of a degree is drawn in.
MINOR_INK = hqf_pdf.Rgb(0.83, 0.60, 0.05)
MAJOR_INK = hqf_pdf.Rgb(0.87, 0.35, 0.05)
BLOCKING_INK = hqf_pdf.Rgb(0.76, 0.09, 0.14)

# The width a wall, a partition and a mark are stroked with, in points.
SHELL_WIDTH_PT = 1.6
PARTITION_WIDTH = 0.9
MARK_WIDTH = 1.2

# How far the arcs of a cloud bulge, from 0 to 2.
CLOUD_BULGE = 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.
FIRM = "Vaugelade & Ferrand"
SITE = "Îlot Cassiopée, 42 quai de la Fonderie, 44200 Nantes"
INSPECTOR = "M. Ravel, Y. Sombath"
REFERENCE = "RS-2026-0914-03"

# The day the premises were handed over, as a year, a month and a day.
HANDOVER = (2026, 9, 14)

# Who answers for the electrical snags, the same whichever language the sheet is printed
# in.
ELECTRICIAN = "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.
MARKED_AT = "09:30:00+02:00"
ANSWERED_AT = "14:00:00+02:00"
ANSWERED_AFTER = 4

# 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.
SCALE_DENOMINATOR = 300.0
POINTS_PER_INCH = 72.0
MILLIMETRES_PER_INCH = 25.4
PLAN_SCALE = 10.0 * POINTS_PER_INCH / (SCALE_DENOMINATOR * MILLIMETRES_PER_INCH)

# The premises, in centimetres: how far the shell runs across and up.
SHELL_WIDTH = 4800.0
SHELL_HEIGHT = 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.
PLAN_LEFT = LEFT + ((RIGHT - LEFT) - SHELL_WIDTH * PLAN_SCALE) / 2.0
PLAN_BOTTOM = 370.0

# How far a room's name sits in from its own corner, in points.
PLAN_PAD = 5.0

# How far the code of a snag sits from the mark it names, in points.
CODE_OFFSET = 3.0

# 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.
WINDOW = (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.
ANSWER_OFFSET = (18.0, -14.0)
CLOSING_OFFSET = (18.0, -38.0)


@dataclass(frozen=True)
class Room:
    """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.
    """

    # The corner nearest the plan's origin.
    x: float
    y: float
    # How far the room runs across, and how far it runs up.
    width: float
    height: float


# The rooms, in the order the plan lays them out.
ROOMS = (
    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),
)


@dataclass(frozen=True)
class Wall:
    """One run of wall the plan draws, in centimetres, and whether it holds the premises
    in or only parts two rooms.
    """

    # Where the run begins, and where it ends.
    start: tuple[float, float]
    stop: tuple[float, float]
    # Whether it is the shell rather than a partition.
    shell: bool


# Every run of wall, cut short at each doorway so the openings show.
WALLS = (
    Wall(start=(0.0, 0.0), stop=(200.0, 0.0), shell=True),
    Wall(start=(320.0, 0.0), stop=(4800.0, 0.0), shell=True),
    Wall(start=(4800.0, 0.0), stop=(4800.0, 2600.0), shell=True),
    Wall(start=(4800.0, 2600.0), stop=(0.0, 2600.0), shell=True),
    Wall(start=(0.0, 2600.0), stop=(0.0, 0.0), shell=True),
    Wall(start=(1800.0, 0.0), stop=(1800.0, 300.0), shell=False),
    Wall(start=(1800.0, 390.0), stop=(1800.0, 1750.0), shell=False),
    Wall(start=(1800.0, 1840.0), stop=(1800.0, 2600.0), shell=False),
    Wall(start=(0.0, 1100.0), stop=(700.0, 1100.0), shell=False),
    Wall(start=(790.0, 1100.0), stop=(1800.0, 1100.0), shell=False),
    Wall(start=(1800.0, 1700.0), stop=(2600.0, 1700.0), shell=False),
    Wall(start=(2690.0, 1700.0), stop=(4800.0, 1700.0), shell=False),
)


@dataclass(frozen=True)
class Degree:
    """How badly a snag stands in the way of the premises being used."""

    # The days the trade is given to make it good, counted from the handover.
    days: int
    # Its place in the table of words.
    place: int
    # The colour every mark of this degree is drawn in.
    ink: hqf_pdf.Rgb


MINOR = Degree(days=30, place=0, ink=MINOR_INK)
MAJOR = Degree(days=21, place=1, ink=MAJOR_INK)
BLOCKING = Degree(days=7, place=2, ink=BLOCKING_INK)

# Every degree, in the order the summary sets them out: the one that holds everything up
# first.
DEGREES = (BLOCKING, MAJOR, MINOR)


@dataclass(frozen=True)
class Cloud:
    """A cloud round a patch the whole of which is under reserve, in centimetres."""

    # The corner of the patch nearest the plan's origin.
    x: float
    y: float
    # How far the patch runs across, and how far it runs up.
    width: float
    height: float


@dataclass(frozen=True)
class Ring:
    """A ring round a defect that sits at one point, in centimetres."""

    # Where the defect sits.
    x: float
    y: float
    # How far the ring stands off it.
    radius: float


@dataclass(frozen=True)
class Arrow:
    """An arrow whose head rests on what the note is about, in centimetres."""

    # The tail, where the code of the snag is written, and the head.
    start: tuple[float, float]
    stop: tuple[float, float]


@dataclass(frozen=True)
class Footprint:
    """The outline of a defect that spreads over an area, in centimetres."""

    # Its corners, in the order they are joined.
    corners: tuple[tuple[float, float], ...]


@dataclass(frozen=True)
class Run:
    """A run along a defect that follows a line, in centimetres."""

    # The points it passes through, in order.
    along: tuple[tuple[float, float], ...]


@dataclass(frozen=True)
class Snag:
    """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.
    """

    # The room it was found in, as its place in the table of rooms.
    room: int
    # How badly it stands in the way.
    degree: Degree
    # The trade that answers for it, as its place in the table of trades.
    trade: int
    # How it is marked on the plan.
    mark: Cloud | Ring | Arrow | Footprint | Run


# The corners of the one defect that spreads over an area, and the points the one that
# follows a line passes through.
SPREAD = (
    (2200.0, 300.0),
    (3400.0, 300.0),
    (3400.0, 900.0),
    (2900.0, 1120.0),
    (2200.0, 900.0),
)
ALONG = ((1810.0, 1880.0), (1810.0, 2220.0), (1810.0, 2560.0))

# The snags, in the order they were found.
SNAGS = (
    Snag(room=0, degree=MAJOR, trade=0, mark=Ring(x=260.0, y=150.0, radius=130.0)),
    Snag(
        room=0,
        degree=MINOR,
        trade=1,
        mark=Cloud(x=900.0, y=780.0, width=780.0, height=240.0),
    ),
    Snag(room=1, degree=MINOR, trade=2, mark=Ring(x=900.0, y=1850.0, radius=170.0)),
    Snag(room=1, degree=MAJOR, trade=3, mark=Run(along=ALONG)),
    Snag(room=2, degree=MAJOR, trade=4, mark=Footprint(corners=SPREAD)),
    Snag(
        room=2,
        degree=BLOCKING,
        trade=5,
        mark=Arrow(start=(4260.0, 980.0), stop=(3620.0, 130.0)),
    ),
    Snag(room=2, degree=MINOR, trade=5, mark=Ring(x=4380.0, y=1360.0, radius=160.0)),
    Snag(
        room=3,
        degree=BLOCKING,
        trade=6,
        mark=Cloud(x=2250.0, y=1780.0, width=520.0, height=520.0),
    ),
    Snag(
        room=3,
        degree=MAJOR,
        trade=7,
        mark=Arrow(start=(3540.0, 1840.0), stop=(4280.0, 2400.0)),
    ),
)

# The right edge of each of the six columns of the list, measured from the left margin,
# in points.
LIST_COLUMNS = (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.
COUNT_COLUMNS = (190.0, 260.0, 330.0)
ROOM_COLUMNS = (190.0, 275.0, 345.0, 415.0)


@dataclass(frozen=True)
class Words:
    """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.
    """

    # What the file says it is, and the line under the firm's name.
    title: str
    tagline: str
    # The four marks at the head of the first page.
    site: str
    handover: str
    reference: str
    inspected: str
    # What the plan is headed, and what its scale stands under.
    plan: str
    scale: str
    # The legend under the plan, and one line for each kind of mark.
    legend: str
    cloud: str
    ring: str
    arrow: str
    footprint: str
    run: str
    # The key to the colours, and how long a degree is given, worded round the number of
    # days.
    key: str
    within: str
    # What the reader is told about the marks, over two lines.
    note: tuple[str, str]
    # The three degrees, in the order their place gives them.
    degrees: tuple[str, str, str]
    # The rooms, in the order the plan lays them out.
    rooms: tuple[str, str, str, str]
    # The trades that answer for the snags.
    trades: tuple[str, str, str, str, str, str, str, str]
    # The nine snags, in the order the list holds them.
    natures: tuple[str, str, str, str, str, str, str, str, str]
    # The heads of the six columns of the list.
    number: str
    room: str
    nature: str
    degree: str
    due: str
    trade: 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: str
    # What the list and the summary are headed.
    list: str
    summary: str
    # The heads of the three tables of the summary and of their own columns.
    by_degree: str
    by_room: str
    by_trade: str
    counted: str
    share: str
    area: str
    total: str
    # The last line of the summary.
    latest: str
    # The two words the foot of every page numbers it with.
    page: str
    of: str
    # What the electrician answers the first blocking snag with, in the note replying to
    # it.
    answer: str


# The sheet in English.
ENGLISH = 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.
FRENCH = 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.
DUTCH = 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.
PORTUGUESE = 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.
ITALIAN = 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.
SPANISH = 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.
GERMAN = 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.
WORDS = {_language.ENGLISH: ENGLISH, _language.FRENCH: FRENCH, _language.GERMAN: GERMAN, _language.SPANISH: SPANISH, _language.ITALIAN: ITALIAN, _language.PORTUGUESE: PORTUGUESE, _language.DUTCH: DUTCH}


def grouped(digits: str) -> str:
    """``digits``, its thousands parted by a no-break space, which is how every language
    this example is written in parts them.
    """
    out = []
    for index, digit in enumerate(digits):
        if index > 0 and (len(digits) - index) % 3 == 0:
            out.append(NO_BREAK)
        out.append(digit)
    return "".join(out)


def counted(value: int) -> str:
    """A count, written as the sheet writes one."""
    return grouped(str(value))


def measured(value: float) -> str:
    """A measurement, written with one decimal, its thousands parted by a no-break space
    and its decimal by a point.
    """
    written_out = f"{value:.1f}"
    whole, _, fraction = written_out.partition(".")
    return f"{grouped(whole)}.{fraction}"


def share(count: int, total: int) -> str:
    """What ``count`` out of ``total`` comes to, as a share of a hundred rounded to the
    nearest tenth.
    """
    tenths = (count * 1000 + total // 2) // total
    return f"{grouped(str(tenths // 10))}.{tenths % 10}{NO_BREAK}%"


def code(place: int) -> str:
    """The code the sheet knows the snag at ``place`` by."""
    return f"S-{place + 1:02d}"


def area(room: Room) -> float:
    """The floor area of ``room``, in square metres."""
    return room.width * room.height / 10_000.0


def total_area() -> float:
    """The floor area of the whole premises, in square metres."""
    return sum(area(room) for room in ROOMS)


def found_in(place: int) -> int:
    """How many snags were found in the room at ``place``."""
    return sum(1 for snag in SNAGS if snag.room == place)


def answered_for(place: int) -> int:
    """How many snags the trade at ``place`` answers for."""
    return sum(1 for snag in SNAGS if snag.trade == place)


def found_at(degree: Degree) -> int:
    """How many snags carry ``degree``."""
    return sum(1 for snag in SNAGS if snag.degree == degree)


def handover() -> date:
    """The day the premises were handed over."""
    return date(HANDOVER[0], HANDOVER[1], HANDOVER[2])


def due(degree: Degree) -> date:
    """The day a snag of ``degree`` is to be made good by: the handover plus the days
    that degree allows.
    """
    return handover() + timedelta(days=degree.days)


def latest() -> date:
    """The last of the days the snags are to be made good by."""
    last = handover()
    for snag in SNAGS:
        last = max(last, due(snag.degree))
    return last


def marked_at() -> str:
    """The moment the marks were made: the handover, at the hour they were made."""
    return f"{written(handover())}T{MARKED_AT}"


def answered_at() -> str:
    """The moment the electrician answered, some days after the handover."""
    return f"{written(handover() + timedelta(days=ANSWERED_AFTER))}T{ANSWERED_AT}"


def first_blocking() -> int:
    """The place of the first blocking snag in the list: the one whose window opens with
    the file, and the one the electrician answers.
    """
    return next(place for place, snag in enumerate(SNAGS) if snag.degree == BLOCKING)


def window(place: int, snag: Snag) -> hqf_pdf.Popup | None:
    """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.
    """
    if snag.degree != BLOCKING:
        return None
    x, y, width, height = WINDOW
    popup = hqf_pdf.Popup(x, y, width, height)
    return popup.open() if place == first_blocking() else popup


def written(day: date) -> str:
    """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.
    """
    return f"{day.year:04d}-{day.month:02d}-{day.day:02d}"


def allowed(degree: Degree, words: Words) -> str:
    """How long a degree is given, in that language's words."""
    return words.within.replace("{days}", grouped(str(degree.days)))


def across(centimetres: float) -> float:
    """How far a length on the premises runs on the page."""
    return centimetres * PLAN_SCALE


def at_x(centimetres: float) -> float:
    """Where a length on the premises falls on the page, across."""
    return PLAN_LEFT + across(centimetres)


def at_y(centimetres: float) -> float:
    """Where a length on the premises falls on the page, up."""
    return PLAN_BOTTOM + across(centimetres)


def plotted(corners: tuple[tuple[float, float], ...]) -> list[tuple[float, float]]:
    """The corners of a mark, as they fall on the page."""
    return [(at_x(x), at_y(y)) for x, y in corners]


def anchor(mark: Cloud | Ring | Arrow | Footprint | Run) -> tuple[float, float]:
    """Where the code of the snag is written, in centimetres."""
    if isinstance(mark, Cloud):
        return (mark.x, mark.y + mark.height)
    if isinstance(mark, Ring):
        return (mark.x + mark.radius, mark.y + mark.radius)
    if isinstance(mark, Arrow):
        return mark.start
    if isinstance(mark, Footprint):
        return mark.corners[0]
    return mark.along[0]


def text(
    content: hqf_pdf.Content,
    font: hqf_pdf.FontHandle,
    size: float,
    x: float,
    y: float,
    color: hqf_pdf.Rgb,
    s: str,
) -> None:
    """Draws a line of text, left-aligned, in a colour of its own."""
    content.set_fill(color)
    content.draw_text(font, size, x, y, s)


def text_right(
    content: hqf_pdf.Content,
    font: hqf_pdf.FontHandle,
    size: float,
    right: float,
    y: float,
    color: hqf_pdf.Rgb,
    s: str,
) -> None:
    """Draws a line of text whose right edge sits at ``right``."""
    text(content, font, size, right - font.measure(s, size), y, color, s)


def rule(content: hqf_pdf.Content, y: float) -> None:
    """Draws a rule across the width of the text."""
    content.set_stroke(RULE)
    content.set_line_width(0.6)
    content.move_to(LEFT, y)
    content.line_to(RIGHT, y)
    content.stroke()


def band(content: hqf_pdf.Content, y: float, height: float, color: hqf_pdf.Rgb) -> None:
    """Fills a band the width of the text, from ``y`` up by ``height``."""
    content.set_fill(color)
    content.rect(LEFT, y, RIGHT - LEFT, height)
    content.fill()


def head(
    content: hqf_pdf.Content, font: hqf_pdf.FontHandle, words: Words, top: float
) -> float:
    """Draws the firm and what the sheet is, and hands back the baseline it ends on."""
    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)
    return y


def marks(
    content: hqf_pdf.Content, font: hqf_pdf.FontHandle, words: Words, top: float
) -> float:
    """Draws the four marks that say which premises the sheet is about, and hands back
    the baseline it ends on.
    """
    y = top
    for label, value in (
        (words.site, SITE),
        (words.handover, written(handover())),
        (words.inspected, INSPECTOR),
        (words.reference, REFERENCE),
    ):
        text(content, font, TINY, LEFT, y, MUTED, label)
        text(content, font, BODY, LEFT + 96.0, y, INK, value)
        y -= LINE + 2.0
    return y


def floor(content: hqf_pdf.Content, font: hqf_pdf.FontHandle, words: Words) -> None:
    """Draws the floor: the rooms it is cut into, the wall round it, and what each room
    is called and comes to.
    """
    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:
        color = SHELL_INK if wall.shell else PARTITION_INK
        width = SHELL_WIDTH_PT if wall.shell else PARTITION_WIDTH
        content.set_stroke(color)
        content.set_line_width(width)
        content.move_to(at_x(wall.start[0]), at_y(wall.start[1]))
        content.line_to(at_x(wall.stop[0]), at_y(wall.stop[1]))
        content.stroke()

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


def codes(content: hqf_pdf.Content, font: hqf_pdf.FontHandle) -> None:
    """Draws the code of every snag beside the mark that stands for it."""
    for place, snag in enumerate(SNAGS):
        x, y = anchor(snag.mark)
        text(
            content,
            font,
            TINY,
            at_x(x) + CODE_OFFSET,
            at_y(y) + CODE_OFFSET,
            snag.degree.ink,
            code(place),
        )


def spoken(place: int, snag: Snag, words: Words) -> str:
    """The words reading software speaks in place of a mark: the same line the list
    prints, run together.
    """
    return (
        f"{code(place)} — {words.rooms[snag.room]} — {words.natures[place]} — "
        f"{words.degrees[snag.degree.place]} — {words.repair} "
        f"{written(due(snag.degree))}"
    )


def marked(place: int, snag: Snag, words: Words):
    """The mark one snag wears on the plan, with who made it, when, the trade it is put
    to, and the window its words open in.
    """
    mark = (
        shaped(place, snag, words)
        .author(INSPECTOR)
        .subject(words.trades[snag.trade])
        .created(marked_at())
    )
    opens = window(place, snag)
    return mark if opens is None else mark.popup(opens)


def answers(words: Words) -> list[hqf_pdf.StickyNoteAnnotation]:
    """The two notes answering the first blocking snag: the electrician's answer, and
    below it the inspectors' note setting the snag to completed.
    """
    answered = first_blocking()
    x, y = anchor(SNAGS[answered].mark)
    x, y = at_x(x), at_y(y)
    return [
        hqf_pdf.StickyNoteAnnotation(
            x + ANSWER_OFFSET[0], y + ANSWER_OFFSET[1], words.answer
        )
        .icon(hqf_pdf.NoteIcon.Check)
        .author(ELECTRICIAN)
        .created(answered_at())
        .in_reply_to(code(answered)),
        hqf_pdf.StickyNoteAnnotation.state_change(
            x + CLOSING_OFFSET[0],
            y + CLOSING_OFFSET[1],
            code(answered),
            hqf_pdf.AnnotationState.Completed,
            INSPECTOR,
        ),
    ]


def shaped(place: int, snag: Snag, words: Words):
    """The shape one snag is marked by on the plan."""
    ink = snag.degree.ink
    border = hqf_pdf.AnnotationBorder.solid(MARK_WIDTH)
    says = spoken(place, snag, words)
    named = code(place)
    mark = snag.mark

    if isinstance(mark, Cloud):
        return (
            hqf_pdf.SquareAnnotation(
                at_x(mark.x), at_y(mark.y), across(mark.width), across(mark.height)
            )
            .effect(hqf_pdf.BorderEffect.cloudy(CLOUD_BULGE))
            .color(ink)
            .border(border)
            .name(named)
            .contents(says)
        )
    if isinstance(mark, Ring):
        return (
            hqf_pdf.CircleAnnotation(
                at_x(mark.x - mark.radius),
                at_y(mark.y - mark.radius),
                across(mark.radius * 2.0),
                across(mark.radius * 2.0),
            )
            .color(ink)
            .border(border)
            .name(named)
            .contents(says)
        )
    if isinstance(mark, Arrow):
        return (
            hqf_pdf.LineAnnotation(
                at_x(mark.start[0]),
                at_y(mark.start[1]),
                at_x(mark.stop[0]),
                at_y(mark.stop[1]),
            )
            .endings(hqf_pdf.LineEnding.None_, hqf_pdf.LineEnding.ClosedArrow)
            .interior(ink)
            .color(ink)
            .border(border)
            .name(named)
            .contents(says)
        )
    if isinstance(mark, Footprint):
        return (
            hqf_pdf.PolygonAnnotation(plotted(mark.corners))
            .interior(FOOTPRINT_TINT)
            .color(ink)
            .border(border)
            .name(named)
            .contents(says)
        )
    return (
        hqf_pdf.PolyLineAnnotation(plotted(mark.along))
        .endings(hqf_pdf.LineEnding.Butt, hqf_pdf.LineEnding.Butt)
        .color(ink)
        .border(border)
        .name(named)
        .contents(says)
    )


def legend(
    content: hqf_pdf.Content, font: hqf_pdf.FontHandle, words: Words, top: float
) -> float:
    """Draws what each kind of mark means and what each colour means, and hands back the
    baseline it ends on.
    """
    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:
        content.set_fill(degree.ink)
        content.rect(LEFT, y - 0.5, SMALL, SMALL)
        content.fill()
        named = f"{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
    return y


def foot(
    content: hqf_pdf.Content, font: hqf_pdf.FontHandle, words: Words, sheet: int
) -> None:
    """Draws the rule and the numbering every page ends on."""
    rule(content, FOOT + LINE)
    named = f"{words.title} · {REFERENCE}"
    text(content, font, TINY, LEFT, FOOT, MUTED, named)
    numbered = f"{words.page} {counted(sheet + 1)} {words.of} {counted(len(SHEETS))}"
    text_right(content, font, TINY, RIGHT, FOOT, MUTED, numbered)


def banner(content: hqf_pdf.Content, font: hqf_pdf.FontHandle, heading: str) -> float:
    """Draws the short head the pages after the first carry, and hands back the baseline
    it ends on.
    """
    text(content, font, SMALL, LEFT, HEAD_TOP, MUTED, FIRM)
    text_right(content, font, SMALL, RIGHT, HEAD_TOP, MUTED, REFERENCE)
    rule(content, HEAD_TOP - 8.0)
    y = HEAD_TOP - BLOCK - LINE
    text(content, font, TITLE_SIZE, LEFT, y, INK, heading)
    return y - GAP


def list_row(
    content: hqf_pdf.Content,
    font: hqf_pdf.FontHandle,
    y: float,
    size: float,
    color: hqf_pdf.Rgb,
    cells: tuple[str, ...],
) -> None:
    """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.
    """
    left = LEFT
    for place, cell in enumerate(cells):
        right = LEFT + LIST_COLUMNS[place]
        if place in (3, 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


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


def plan_sheet(font: hqf_pdf.FontHandle, words: Words, sheet: int) -> hqf_pdf.Page:
    """Draws the plan, the marks over it and what they mean."""
    content = hqf_pdf.Content()
    page = hqf_pdf.Page(PAGE_WIDTH, PAGE_HEIGHT)

    y = head(content, font, words, HEAD_TOP)
    y = marks(content, font, words, y - BLOCK - LINE)

    rule(content, y - 6.0)
    text(content, font, HEADING_SIZE, LEFT, y - BLOCK, INK, plan_heading(words))

    floor(content, font, words)
    codes(content, font)

    rule(content, PLAN_BOTTOM - BLOCK)
    legend(content, font, words, PLAN_BOTTOM - GAP)
    foot(content, font, words, sheet)

    for place, snag in enumerate(SNAGS):
        page.add_annotation(marked(place, snag, words))
    for note in answers(words):
        page.add_annotation(note)

    page.set_content(content)
    return page


def list_sheet(font: hqf_pdf.FontHandle, words: Words, sheet: int) -> hqf_pdf.Page:
    """Draws the snags, one to a line."""
    content = hqf_pdf.Content()
    page = hqf_pdf.Page(PAGE_WIDTH, PAGE_HEIGHT)

    top = banner(content, font, words.list)

    band(content, top - 6.0, ROW, HEAD_BAND)
    heads = (
        words.number,
        words.room,
        words.nature,
        words.degree,
        words.due,
        words.trade,
    )
    list_row(content, font, top, TINY, MUTED, heads)

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

    rule(content, y + ROW - 8.0)
    text(
        content,
        font,
        BODY,
        LEFT,
        y - 6.0,
        INK,
        f"{words.total} — {counted(len(SNAGS))}",
    )

    y -= GAP
    for line in words.note:
        text(content, font, SMALL, LEFT, y, MUTED, line)
        y -= LINE

    foot(content, font, words, sheet)
    page.set_content(content)
    return page


def gathered(
    content: hqf_pdf.Content,
    font: hqf_pdf.FontHandle,
    words: Words,
    top: float,
    heading: str,
    column: str,
    rows: tuple[tuple[str, int, hqf_pdf.Rgb | None], ...],
) -> float:
    """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.
    """
    all_snags = len(SNAGS)
    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)
    counts = LEFT + COUNT_COLUMNS[1]
    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:
        left = LEFT + 6.0
        if swatch is not None:
            content.set_fill(swatch)
            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_snags))
        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_snags))
    return y


def by_room(
    content: hqf_pdf.Content, font: hqf_pdf.FontHandle, words: Words, top: float
) -> float:
    """Draws the table that gathers the snags room by room, with what each room covers,
    and hands back the baseline it ends on.
    """
    all_snags = len(SNAGS)
    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 enumerate((words.area, words.counted, words.share)):
        right = LEFT + ROOM_COLUMNS[place + 1]
        text_right(content, font, TINY, right, y, MUTED, column)

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

    rule(content, y + ROW - 8.0)
    covered = f"{measured(total_area())} m²"
    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_snags))
    return y


def summary_sheet(font: hqf_pdf.FontHandle, words: Words, sheet: int) -> hqf_pdf.Page:
    """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.
    """
    content = hqf_pdf.Content()
    page = hqf_pdf.Page(PAGE_WIDTH, PAGE_HEIGHT)

    y = banner(content, font, words.summary)

    degrees = tuple(
        (words.degrees[degree.place], found_at(degree), degree.ink)
        for degree in DEGREES
    )
    y = gathered(
        content, font, words, y, words.by_degree, words.degree, degrees
    )

    y -= GAP
    y = by_room(content, font, words, y)

    trades = tuple(
        (name, answered_for(place), None) for place, name in enumerate(words.trades)
    )
    y -= GAP
    y = gathered(content, font, words, y, words.by_trade, words.trade, trades)

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

    foot(content, font, words, sheet)
    page.set_content(content)
    return page


# 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.
SHEETS = (plan_sheet, list_sheet, summary_sheet)


def main() -> None:
    language = _language.from_environment()
    words = _language.words_of(WORDS, language)

    # A named file is written as named; the default one carries the language, so the two
    # languages do not overwrite each other in `tmp/`.
    out = _out.output_path(Path(_language.file_name("snag_list.pdf", language)).stem)

    document = hqf_pdf.Document()
    document.set_license(_licence.licensed())
    document.set_info("Title", f"{words.title} {REFERENCE}")

    font = document.add_font(hqf_pdf.Font.from_path(_out.font_path()))

    for sheet, draw in enumerate(SHEETS):
        document.add_page(draw(font, words, sheet))

    size = document.write(out)
    print(
        f"wrote {out}: {size} bytes, {counted(len(SNAGS))} snags marked on "
        f"{measured(total_area())} m², last date {written(latest())}"
    )


if __name__ == "__main__":
    main()