write_imported_pages.rs

//! Assembles a document onto three PDFs somebody else made: one behind its
//! first page, one behind every page in the middle, and one that goes in whole
//! as its last page.
//!
//! This is what a document server is asked for most often. The customer sends
//! stationery — a headed sheet, a plain continuation sheet, a page of standing
//! conditions — and the document has to be laid on it without any of it being
//! redrawn. Each sheet is read, brought in as a form, and stamped under what
//! this example draws. The conditions sheet carries nothing of its own but the
//! page number, and is a counted page like the rest.
//!
//! The page the schedule needs is decided by the schedule: the table is handed
//! over whole and says how many pages it takes, so the continuation sheet backs
//! as many pages as there turn out to be.
//!
//! What the pack says is written in the language `HQF_PDF_LANG` names. What it
//! is about is not: the reference, the two parties, their addresses and their
//! tax numbers, the quantities and the prices are the same pack whichever
//! language reads it.
//!
//! The three sheets may be handed over on the command line. With none given,
//! the example writes them itself, so it runs on any machine.
//!
//! Usage: `cargo run --example write_imported_pages -- tmp/pack.pdf [headed.pdf
//! continuation.pdf conditions.pdf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_imported_pages`

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

use hqf_pdf::content::Content;
use hqf_pdf::layout::{
    Area, Cell, ColumnWidth, Columns, Margin, Padding, Row, Rule, Stroke, Table, TableFrame, VAlign,
};
use hqf_pdf::read::{ImportedPage, Reader};
use hqf_pdf::{Align, 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 every sheet and the pack itself are drawn with.
fn default_font() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("tests")
        .join("fonts")
        .join("DejaVuSans.ttf")
}

/// A4, in points.
const PAGE_WIDTH: f64 = 595.276;
/// The page's left edge and, mirrored, its right.
const LEFT: f64 = 56.0;
const RIGHT: f64 = PAGE_WIDTH - LEFT;
/// The width the table is fitted across.
const TABLE_WIDTH: f64 = PAGE_WIDTH - 2.0 * LEFT;
/// Where the second column of the two address blocks begins.
const SECOND_COLUMN: f64 = 320.0;

/// The ink the headings and rules are drawn in, and the grey of the small
/// print.
const ACCENT: Rgb = Rgb {
    r: 0.11,
    g: 0.33,
    b: 0.55,
};
const MUTED: Rgb = Rgb {
    r: 0.42,
    g: 0.42,
    b: 0.45,
};
const INK: Rgb = Rgb {
    r: 0.1,
    g: 0.1,
    b: 0.12,
};

/// The agreement this pack schedules, which no language renumbers.
const REFERENCE: &str = "SA-2027-0088";

/// The supplier and the customer: what they are called, where they are, and the
/// tax number each answers to. None of it is language.
const SUPPLIER: &str = "HQF Development";
const SUPPLIER_STREET: &str = "42 lot les Genêts";
const SUPPLIER_TOWN: &str = "13480 Calas, France";
const SUPPLIER_VAT: &str = "FR59 752 492 777";
const CUSTOMER: &str = "Meridian Optics SAS";
const CUSTOMER_STREET: &str = "18 avenue des Peupliers";
const CUSTOMER_TOWN: &str = "69100 Villeurbanne, France";
const CUSTOMER_VAT: &str = "FR41 512 336 908";

/// The box the schedule is fitted into, on whichever page it lands.
const TABLE_TOP: f64 = 780.0;
const TABLE_BOTTOM: f64 = 80.0;

/// What the pack says, in one language.
///
/// What it is about is held outside: the reference, the parties, their
/// addresses, their tax numbers, the days, the quantities and the prices are
/// the same pack in every language.
#[derive(Debug)]
struct Words {
    /// What the pack is called, at the head of its front page.
    title: &'static str,
    /// What stands between the reference and the day the pack was drawn up.
    drawn_up: &'static str,
    /// The day it was drawn up.
    drawn_up_on: &'static str,
    /// What heads each of the two address blocks.
    supplier: &'static str,
    customer: &'static str,
    /// What stands before a tax number.
    vat: &'static str,
    /// What heads the lines that say what the pack stands on.
    made_of: &'static str,
    /// Those lines, broken where the page breaks them: what the pack stands on,
    /// then what is done with it.
    stands_on: [&'static str; 3],
    /// What is done with it.
    stamped: [&'static str; 3],
    /// What heads the list of the pack's own pages.
    in_it: &'static str,
    /// What one page of the pack is called, and what several are.
    page: &'static str,
    pages: &'static str,
    /// What runs between the first page of a span and its last.
    to: &'static str,
    /// What runs between a page's number and how many there are.
    of: &'static str,
    /// What each of the three entries of the list says.
    front_sheet: &'static str,
    schedule_before: &'static str,
    schedule_after: &'static str,
    conditions_entry: &'static str,
    /// What heads the two places the parties sign, and the line under it.
    signed: &'static str,
    signed_note: &'static str,
    /// What stands before the name of a party over the rule it signs on.
    for_party: &'static str,
    /// What is asked for under the second rule.
    name_and_date: &'static str,
    /// The four headings of the schedule.
    headings: [&'static str; 4],
    /// What each batch delivers, in the order [`BATCHES`] schedules them.
    batches: [&'static str; 11],
    /// The month each quarter's batches are due in, in the order [`YEARS`] runs
    /// them.
    months: [&'static str; 4],
    /// What the last row of the schedule adds up.
    total: &'static str,
    /// What the conditions sheet is headed, and the line at its foot.
    conditions_title: &'static str,
    conditions_edition: &'static str,
    /// The standing clauses, one to a line.
    clauses: [&'static str; 16],
}

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

/// The pack in English.
const ENGLISH: Words = Words {
    title: "Supply agreement",
    drawn_up: "drawn up",
    drawn_up_on: "12 March 2027",
    supplier: "Supplier",
    customer: "Customer",
    vat: "VAT",
    made_of: "What this pack is made of",
    stands_on: [
        "This pack stands on three sheets the customer sent as PDF files. The headed sheet is under",
        "this page. A plain continuation sheet is under every page the schedule runs to. The page of",
        "standing conditions at the back is the third sheet, taken in whole and counted like the rest.",
    ],
    stamped: [
        "None of the three is redrawn. The team reads each file, brings its page in as a drawing, and",
        "stamps it under the text — so a letterhead comes out of the printer as its owner made it, and",
        "the conditions on the last page are the ones on file, to the letter.",
    ],
    in_it: "What is in it",
    page: "Page",
    pages: "Pages",
    to: "to",
    of: "of",
    front_sheet: "This page, on the headed sheet.",
    schedule_before: "The delivery schedule, ",
    schedule_after: " rows, on the continuation sheet.",
    conditions_entry: "The conditions of supply, as the customer supplied them.",
    signed: "Signed",
    signed_note: "Each party signs one copy. The schedule and the conditions of supply are part of it.",
    for_party: "For",
    name_and_date: "Name and date",
    headings: ["Batch", "Due", "Quantity", "Value"],
    batches: [
        "Lens blanks, 62 mm, coated",
        "Lens blanks, 68 mm, coated",
        "Lens blanks, 74 mm, uncoated",
        "Frame fronts, acetate, assorted",
        "Frame temples, acetate, pairs",
        "Hinges, sprung, stainless",
        "Nose pads, silicone",
        "Screws, M1.4, boxed by hundred",
        "Cases, hard, printed",
        "Cloths, microfibre, printed",
        "Cartons, shipping, printed",
    ],
    months: ["April", "July", "October", "January"],
    total: "Total, before tax",
    conditions_title: "Conditions of supply",
    conditions_edition: "conditions of supply, edition of 1 January 2027",
    clauses: [
        "Prices are firm for the term of this agreement, in euros, exclusive of value added tax.",
        "A batch is due on the day named in the schedule, at the address the schedule was sent to.",
        "Quantities are counted on arrival. A count that differs is settled within five working days.",
        "Payment falls thirty days after the batch arrives, by transfer to the account on the invoice.",
        "Title to a batch passes on payment. Risk passes on arrival.",
        "A batch refused on arrival is collected within ten working days, at the supplier's cost.",
        "Either party may end this agreement on ninety days' notice, in writing.",
        "Batches already scheduled at the end of the notice are supplied and paid for as scheduled.",
        "Neither party is answerable for a delay caused by an event outside its reasonable control.",
        "This agreement is governed by French law, and the courts of Aix-en-Provence hear disputes.",
        "A change to a scheduled batch takes effect only when both parties agree it in writing.",
        "The supplier keeps a certificate of conformity for each batch three years after it arrives.",
        "The customer's marks may go on cartons and cases for the term, and to no other purpose.",
        "Neither party may hand this agreement to anyone else without the other's written consent.",
        "Notices are given in writing, to the addresses printed on the first page of this pack.",
        "This pack, its schedule and these conditions are the whole of what the parties agreed.",
    ],
};

/// The pack in French.
const FRENCH: Words = Words {
    title: "Contrat d'approvisionnement",
    drawn_up: "établi le",
    drawn_up_on: "12 mars 2027",
    supplier: "Fournisseur",
    customer: "Client",
    vat: "TVA",
    made_of: "De quoi ce dossier est fait",
    stands_on: [
        "Ce dossier repose sur trois feuilles que le client a envoyées en PDF. La feuille à en-tête",
        "est sous cette page. Une feuille de suite nue est sous chaque page du calendrier. Les",
        "conditions du dos sont la troisième feuille, prise entière et comptée comme les autres.",
    ],
    stamped: [
        "Aucune des trois n'est redessinée. L'équipe lit chaque fichier, entre sa page comme un",
        "dessin, et la tamponne sous le texte — un papier à en-tête sort donc de l'imprimante tel",
        "que son propriétaire l'a fait, et les conditions du dos sont celles du fichier, à la lettre.",
    ],
    in_it: "Ce qu'il contient",
    page: "Page",
    pages: "Pages",
    to: "à",
    of: "sur",
    front_sheet: "Cette page, sur la feuille à en-tête.",
    schedule_before: "Le calendrier de livraison, ",
    schedule_after: " lignes, sur la feuille de suite.",
    conditions_entry: "Les conditions de fourniture, telles que le client les a fournies.",
    signed: "Signatures",
    signed_note: "Chaque partie signe un exemplaire. Le calendrier et les conditions de fourniture en font partie.",
    for_party: "Pour",
    name_and_date: "Nom et date",
    headings: ["Lot", "Échéance", "Quantité", "Montant"],
    batches: [
        "Ébauches de verres, 62 mm, traitées",
        "Ébauches de verres, 68 mm, traitées",
        "Ébauches de verres, 74 mm, non traitées",
        "Faces de montures, acétate, assorties",
        "Branches de montures, acétate, paires",
        "Charnières à ressort, inox",
        "Plaquettes de nez, silicone",
        "Vis M1.4, boîtes de cent",
        "Étuis rigides, imprimés",
        "Chiffonnettes microfibre, imprimées",
        "Cartons d'expédition, imprimés",
    ],
    months: ["avril", "juillet", "octobre", "janvier"],
    total: "Total hors taxes",
    conditions_title: "Conditions de fourniture",
    conditions_edition: "conditions de fourniture, édition du 1er janvier 2027",
    clauses: [
        "Les prix sont fermes pour la durée du contrat, en euros, hors taxe sur la valeur ajoutée.",
        "Un lot est dû le jour nommé au calendrier, à l'adresse à laquelle le calendrier a été envoyé.",
        "Les quantités sont comptées à l'arrivée. Un écart de comptage se règle sous cinq jours ouvrés.",
        "Le paiement échoit trente jours après l'arrivée du lot, par virement au compte porté sur la facture.",
        "La propriété d'un lot passe au paiement. Le risque passe à l'arrivée.",
        "Un lot refusé à l'arrivée est repris sous dix jours ouvrés, aux frais du fournisseur.",
        "Chaque partie peut mettre fin au contrat avec un préavis de quatre-vingt-dix jours, par écrit.",
        "Les lots déjà inscrits au calendrier à la fin du préavis sont livrés et payés comme prévu.",
        "Aucune partie ne répond d'un retard causé par un événement échappant à son contrôle raisonnable.",
        "Le contrat est régi par le droit français, et les tribunaux d'Aix-en-Provence tranchent les litiges.",
        "Une modification d'un lot au calendrier ne prend effet que si les deux parties l'acceptent par écrit.",
        "Le fournisseur conserve un certificat de conformité par lot pendant trois ans après son arrivée.",
        "Les marques du client vont sur les cartons et les étuis pendant la durée, et à aucun autre usage.",
        "Aucune partie ne peut céder le contrat à un tiers sans l'accord écrit de l'autre.",
        "Les avis sont donnés par écrit, aux adresses imprimées sur la première page de ce dossier.",
        "Ce dossier, son calendrier et ces conditions sont l'intégralité de ce que les parties ont convenu.",
    ],
};

/// Every language the pack is written in. A language is added by writing its
/// own set of words and naming it here.
static WORDS: [(Language, &Words); 2] =
    [(Language::English, &ENGLISH), (Language::French, &FRENCH)];

/// Draws a line of text with its left edge at `x` and its baseline at `y`.
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,
    );
}

/// A horizontal rule from `x1` to `x2` at height `y`.
fn rule(
    content: &mut Content,
    x1: f64,
    x2: f64,
    y: f64,
    width: f64,
    color: Rgb,
) -> Result<(), hqf_pdf::Error> {
    content.set_stroke(color)?;
    content.set_line_width(width)?;
    content.move_to(x1, y)?;
    content.line_to(x2, y)?;
    content.stroke();
    Ok(())
}

/// A rule across the whole text width, at height `y`.
fn full_rule(content: &mut Content, y: f64, width: f64, color: Rgb) -> Result<(), hqf_pdf::Error> {
    rule(content, LEFT, RIGHT, y, width, color)
}

/// The line of small print under the firm's name on the headed sheet.
fn letterhead_address(words: &Words) -> String {
    format!(
        "{SUPPLIER_STREET} — {SUPPLIER_TOWN} — {} {SUPPLIER_VAT}",
        words.vat
    )
}

/// The one line the continuation sheet carries, which is the firm and where it
/// is.
fn continuation_address() -> String {
    format!("{SUPPLIER} — {SUPPLIER_STREET}, {SUPPLIER_TOWN}")
}

/// A tax number as an address block writes it.
fn vat_line(words: &Words, number: &str) -> String {
    format!("{} {number}", words.vat)
}

/// Puts a one-page document together from what a caller draws on it.
fn one_page_sheet(
    font_path: &Path,
    draw: impl FnOnce(&mut Content, &FontHandle) -> Result<(), hqf_pdf::Error>,
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    let mut doc = Document::new();
    doc.set_license(licence::licensed());
    let font = doc.add_font(Font::parse(fs::read(font_path)?)?);

    let mut content = Content::new();
    draw(&mut content, &font)?;

    let mut page = Page::a4();
    page.content = content.into_bytes();
    doc.add_page(page)?;

    Ok(doc.to_bytes()?)
}

/// The headed sheet: a band across the top with the firm's name and address in
/// it.
fn a_headed_sheet(font_path: &Path, words: &Words) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    one_page_sheet(font_path, |content, font| {
        content.save_state();
        content.set_fill_rgb(0.91, 0.94, 0.98)?;
        content.rect(0.0, 742.0, PAGE_WIDTH, 100.0)?;
        content.fill();
        content.set_fill(ACCENT)?;
        content.rect(0.0, 738.0, PAGE_WIDTH, 4.0)?;
        content.fill();
        content.restore_state();

        text(content, font, 22.0, LEFT, 786.0, INK, SUPPLIER);
        text(
            content,
            font,
            9.0,
            LEFT,
            764.0,
            MUTED,
            &letterhead_address(words),
        );
        Ok(())
    })
}

/// The continuation sheet: the firm's name small at the top, between two
/// hairlines.
fn a_continuation_sheet(font_path: &Path) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    one_page_sheet(font_path, |content, font| {
        text(
            content,
            font,
            8.0,
            LEFT,
            806.0,
            MUTED,
            &continuation_address(),
        );
        full_rule(content, 800.0, 0.5, ACCENT)?;
        full_rule(content, 64.0, 0.5, Rgb::gray(0.78))
    })
}

/// One clause as the conditions sheet numbers it.
fn clause(words: &Words, index: usize) -> String {
    format!("{}. {}", index + 1, words.clauses[index])
}

/// The line at the foot of the conditions sheet, which says whose conditions
/// they are and which edition.
fn conditions_foot(words: &Words) -> String {
    format!("{SUPPLIER} — {}", words.conditions_edition)
}

/// The conditions sheet: a heading and the standing clauses, one to a line.
fn a_conditions_sheet(
    font_path: &Path,
    words: &Words,
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    one_page_sheet(font_path, |content, font| {
        text(
            content,
            font,
            14.0,
            LEFT,
            780.0,
            INK,
            words.conditions_title,
        );
        full_rule(content, 770.0, 0.8, ACCENT)?;

        let mut y = 744.0;
        for index in 0..words.clauses.len() {
            text(content, font, 8.5, LEFT, y, INK, &clause(words, index));
            y -= 26.0;
        }

        text(
            content,
            font,
            8.0,
            LEFT,
            96.0,
            MUTED,
            &conditions_foot(words),
        );
        Ok(())
    })
}

/// One line of the schedule: on which day of the quarter it is due, how many,
/// and the price of one.
///
/// What is delivered is not here: it is a word, and it lives with the other
/// words of its language.
struct Batch {
    /// The day of the quarter's first month it is due on.
    day: u32,
    /// How many.
    quantity: u32,
    /// The price of one, before tax.
    unit_price: f64,
}

/// The batches a quarter delivers.
const BATCHES: &[Batch] = &[
    Batch {
        day: 6,
        quantity: 1200,
        unit_price: 7.20,
    },
    Batch {
        day: 6,
        quantity: 900,
        unit_price: 8.40,
    },
    Batch {
        day: 9,
        quantity: 640,
        unit_price: 6.15,
    },
    Batch {
        day: 13,
        quantity: 480,
        unit_price: 11.90,
    },
    Batch {
        day: 13,
        quantity: 480,
        unit_price: 4.35,
    },
    Batch {
        day: 17,
        quantity: 2400,
        unit_price: 0.95,
    },
    Batch {
        day: 17,
        quantity: 3600,
        unit_price: 0.22,
    },
    Batch {
        day: 20,
        quantity: 120,
        unit_price: 3.10,
    },
    Batch {
        day: 24,
        quantity: 1500,
        unit_price: 2.65,
    },
    Batch {
        day: 24,
        quantity: 3000,
        unit_price: 0.48,
    },
    Batch {
        day: 27,
        quantity: 300,
        unit_price: 1.75,
    },
];

/// The year each quarter's batches are due in, in the order the schedule runs
/// them. Which month it is is a word, and it lives with the words.
const YEARS: [u32; 4] = [2027, 2027, 2027, 2028];

/// The day a batch is due, as the schedule writes it.
fn due(words: &Words, batch: &Batch, quarter: usize) -> String {
    format!("{} {} {}", batch.day, words.months[quarter], YEARS[quarter])
}

/// An amount, as a schedule writes it: "8 640.00".
fn amount(value: f64) -> String {
    let fixed = format!("{value:.2}");
    let (units, hundredths) = fixed.split_once('.').unwrap_or((fixed.as_str(), "00"));

    let mut grouped = String::new();
    for (index, digit) in units.chars().enumerate() {
        if index > 0 && (units.len() - index) % 3 == 0 {
            grouped.push(' ');
        }
        grouped.push(digit);
    }
    format!("{grouped}.{hundredths}")
}

/// The width of each column of the schedule, in points, the first taking
/// whatever the other three leave.
const DUE_COLUMN: f64 = 92.0;
const QUANTITY_COLUMN: f64 = 58.0;
const VALUE_COLUMN: f64 = 78.0;

/// How much of a cell its text leaves free on each side, and above and below.
const CELL_PAD: (f64, f64) = (6.0, 5.0);

/// The schedule, as one table: a heading drawn again on every page, every batch
/// of every quarter, and the total of the lot.
fn schedule<'a>(font: &'a FontHandle, words: &Words) -> Result<Table<'a>, hqf_pdf::Error> {
    let columns = Columns::new(
        vec![
            ColumnWidth::Fraction(1.0),
            ColumnWidth::Points(DUE_COLUMN),
            ColumnWidth::Points(QUANTITY_COLUMN),
            ColumnWidth::Points(VALUE_COLUMN),
        ],
        TABLE_WIDTH,
    )?;

    let mut table = Table::new(columns);
    table.header(1);
    table
        .rule(Rule::Frame, Stroke::new(0.8, ACCENT))
        .rule(Rule::HorizontalOther, Stroke::new(0.25, Rgb::gray(0.78)))
        .rule(Rule::Horizontal(1), Stroke::new(0.8, ACCENT));
    table
        .fill(Area::EvenRows, Rgb::gray(0.97))
        .fill(Area::Header, ACCENT);

    let pad = Padding::symmetric(CELL_PAD.0, CELL_PAD.1);
    let heading = |label: &str, align| {
        Cell::new(font, 9.0, label)
            .padding(pad)
            .align(align)
            .color(Rgb::gray(1.0))
            .valign(VAlign::Middle)
    };
    table.push(
        Row::new()
            .cell(heading(words.headings[0], Align::Left))
            .cell(heading(words.headings[1], Align::Left))
            .cell(heading(words.headings[2], Align::Right))
            .cell(heading(words.headings[3], Align::Right))
            .min_height(20.0),
    );

    let mut total = 0.0;
    for quarter in 0..YEARS.len() {
        for (index, batch) in BATCHES.iter().enumerate() {
            let value = f64::from(batch.quantity) * batch.unit_price;
            total += value;
            table.push(
                Row::new()
                    .cell(Cell::new(font, 9.0, words.batches[index]).padding(pad))
                    .cell(Cell::new(font, 9.0, due(words, batch, quarter)).padding(pad))
                    .cell(
                        Cell::new(font, 9.0, batch.quantity.to_string())
                            .padding(pad)
                            .align(Align::Right),
                    )
                    .cell(
                        Cell::new(font, 9.0, amount(value))
                            .padding(pad)
                            .align(Align::Right),
                    )
                    .min_height(16.0),
            );
        }
    }

    table.push(
        Row::new()
            .cell(
                Cell::new(font, 10.0, words.total)
                    .padding(pad)
                    .align(Align::Right)
                    .span(3)
                    .margin(Margin::symmetric(0.0, 2.0)),
            )
            .cell(
                Cell::new(font, 10.0, amount(total))
                    .padding(pad)
                    .align(Align::Right)
                    .margin(Margin::symmetric(0.0, 2.0)),
            )
            .min_height(20.0),
    );

    Ok(table)
}

/// What the front page can say about the pack once the schedule has said how
/// many pages it takes.
struct Contents {
    /// How many pages the pack has in all.
    pages: usize,
    /// The first page of the schedule, and its last.
    schedule: (usize, usize),
    /// How many rows the schedule carries.
    rows: usize,
}

impl Contents {
    /// The three lines the front page lists the pack by: which pages, and what
    /// is on them.
    fn lines(&self, words: &Words) -> [(String, String); 3] {
        let (first, last) = self.schedule;
        [
            (format!("{} 1", words.page), words.front_sheet.to_owned()),
            (
                format!("{} {first} {} {last}", words.pages, words.to),
                format!(
                    "{}{}{}",
                    words.schedule_before, self.rows, words.schedule_after
                ),
            ),
            (
                format!("{} {}", words.page, self.pages),
                words.conditions_entry.to_owned(),
            ),
        ]
    }
}

/// How far the second column of the list of pages stands from the first.
const ENTRY_COLUMN: f64 = 96.0;

/// How long the rule each party signs on is, in points.
const SIGNATURE_RULE: f64 = 210.0;

/// What stands over the rule a party signs on.
fn party(words: &Words, name: &str) -> String {
    format!("{} {name}", words.for_party)
}

/// Draws the two places the parties sign, each a rule with a label under it.
fn signatures(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
) -> Result<(), hqf_pdf::Error> {
    text(content, font, 11.0, LEFT, 330.0, ACCENT, words.signed);
    text(content, font, 9.0, LEFT, 312.0, INK, words.signed_note);

    let hair = Rgb::gray(0.6);
    for (x, name) in [(LEFT, SUPPLIER), (SECOND_COLUMN, CUSTOMER)] {
        rule(content, x, x + SIGNATURE_RULE, 262.0, 0.5, hair)?;
        text(content, font, 8.0, x, 250.0, MUTED, &party(words, name));
        rule(content, x, x + SIGNATURE_RULE, 210.0, 0.5, hair)?;
        text(content, font, 8.0, x, 198.0, MUTED, words.name_and_date);
    }
    Ok(())
}

/// The line under the title: what the pack is filed as, and the day it was
/// drawn up.
fn reference_line(words: &Words) -> String {
    format!("{REFERENCE} — {} {}", words.drawn_up, words.drawn_up_on)
}

/// The pack's front page: what it is, who it is between, what it is made of,
/// what is in it, and where it is signed.
fn front_page(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    contents: &Contents,
) -> Result<(), hqf_pdf::Error> {
    text(content, font, 20.0, LEFT, 700.0, ACCENT, words.title);
    text(
        content,
        font,
        9.5,
        LEFT,
        682.0,
        MUTED,
        &reference_line(words),
    );
    full_rule(content, 672.0, 0.8, ACCENT)?;

    text(content, font, 8.0, LEFT, 652.0, MUTED, words.supplier);
    text(
        content,
        font,
        8.0,
        SECOND_COLUMN,
        652.0,
        MUTED,
        words.customer,
    );

    let supplier = [
        SUPPLIER_STREET.to_owned(),
        SUPPLIER_TOWN.to_owned(),
        vat_line(words, SUPPLIER_VAT),
    ];
    let customer = [
        CUSTOMER_STREET.to_owned(),
        CUSTOMER_TOWN.to_owned(),
        vat_line(words, CUSTOMER_VAT),
    ];
    text(content, font, 10.0, LEFT, 637.0, INK, SUPPLIER);
    text(content, font, 10.0, SECOND_COLUMN, 637.0, INK, CUSTOMER);
    let mut y = 624.0;
    for (theirs, ours) in supplier.iter().zip(customer.iter()) {
        text(content, font, 9.0, LEFT, y, MUTED, theirs);
        text(content, font, 9.0, SECOND_COLUMN, y, MUTED, ours);
        y -= 12.0;
    }

    text(content, font, 11.0, LEFT, 566.0, ACCENT, words.made_of);
    let mut y = 548.0;
    for line in words.stands_on {
        text(content, font, 9.0, LEFT, y, INK, line);
        y -= 13.0;
    }
    y -= 13.0;
    for line in words.stamped {
        text(content, font, 9.0, LEFT, y, INK, line);
        y -= 13.0;
    }

    text(content, font, 11.0, LEFT, 430.0, ACCENT, words.in_it);
    let mut y = 412.0;
    for (pages, what) in contents.lines(words) {
        text(content, font, 9.0, LEFT, y, INK, &pages);
        text(content, font, 9.0, LEFT + ENTRY_COLUMN, y, MUTED, &what);
        y -= 16.0;
    }

    signatures(content, font, words)
}

/// What every page of the pack carries at its foot.
fn page_number(words: &Words, number: usize, pages: usize) -> String {
    format!("{} {number} {} {pages}", words.page, words.of)
}

/// Adds one page to the pack: what the pack drew over its sheet, and the page
/// number, which every page carries.
fn add_page(
    doc: &mut Document,
    sheet: &ImportedPage,
    mut content: Content,
    font: &FontHandle,
    words: &Words,
    number: usize,
    pages: usize,
) -> Result<(), hqf_pdf::Error> {
    text_right(
        &mut content,
        font,
        8.0,
        RIGHT,
        48.0,
        MUTED,
        &page_number(words, number, pages),
    );

    let mut leaf = Page::a4();
    leaf.content = content.into_bytes();
    // A page may only draw what its resources name.
    sheet.add_to(&mut leaf);
    doc.add_page(leaf)?;
    Ok(())
}

/// Reads a sheet named on the command line, or the one made here when none is
/// named.
fn sheet(
    given: Option<String>,
    make: impl FnOnce() -> Result<Vec<u8>, Box<dyn std::error::Error>>,
) -> Result<Reader, Box<dyn std::error::Error>> {
    let bytes = match given {
        Some(path) => fs::read(path)?,
        None => make()?,
    };
    Ok(Reader::new(bytes)?)
}

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

fn run() -> Result<(), Box<dyn std::error::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 out = args
        .next()
        .unwrap_or_else(|| language.file_name(&out::default_path("pack")));
    let font_path = default_font();

    let headed = sheet(args.next(), || a_headed_sheet(&font_path, words))?;
    let continuation = sheet(args.next(), || a_continuation_sheet(&font_path))?;
    let conditions = sheet(args.next(), || a_conditions_sheet(&font_path, words))?;

    let mut doc = Document::new();
    doc.set_license(licence::licensed());

    // Each sheet comes in as a form: the same page, now a drawing this document
    // can stamp wherever it likes, as many times as it likes.
    let headed = doc.import_page(&headed, 0)?;
    let continuation = doc.import_page(&continuation, 0)?;
    let conditions = doc.import_page(&conditions, 0)?;

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

    // The schedule says how many pages it needs, so the pack's length is known
    // before a page of it is made: the front page, the schedule's pages, and
    // the conditions.
    let box_of = TableFrame::new(LEFT, TABLE_TOP, TABLE_TOP - TABLE_BOTTOM);
    let placed = table.paginate(box_of, box_of)?;
    let pages = placed.len() + 2;

    // Each page: its sheet goes down first, and what the pack draws goes on top
    // of it.
    let contents = Contents {
        pages,
        schedule: (2, placed.len() + 1),
        rows: table.row_count(),
    };

    let mut content = Content::new();
    content.draw_form(headed.name(), 0.0, 0.0, 1.0)?;
    front_page(&mut content, &font, words, &contents)?;
    add_page(&mut doc, &headed, content, &font, words, 1, pages)?;

    for (index, placement) in placed.iter().enumerate() {
        let mut content = Content::new();
        content.draw_form(continuation.name(), 0.0, 0.0, 1.0)?;
        placement.draw(&mut content)?;
        add_page(
            &mut doc,
            &continuation,
            content,
            &font,
            words,
            index + 2,
            pages,
        )?;
    }

    // The conditions sheet carries nothing of the pack's but its page number:
    // it is a page of the pack, not an attachment to it.
    let mut content = Content::new();
    content.draw_form(conditions.name(), 0.0, 0.0, 1.0)?;
    add_page(&mut doc, &conditions, content, &font, words, pages, pages)?;

    let bytes = doc.to_bytes()?;
    if let Some(parent) = Path::new(&out).parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(&out, &bytes)?;
    println!(
        "wrote {out}: {} bytes, {pages} pages, {} rows over {} of them",
        bytes.len(),
        table.row_count(),
        placed.len()
    );
    Ok(())
}

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

    use super::{
        BATCHES, CELL_PAD, CUSTOMER, CUSTOMER_VAT, Contents, DUE_COLUMN, ENTRY_COLUMN, LEFT,
        QUANTITY_COLUMN, RIGHT, SECOND_COLUMN, SIGNATURE_RULE, SUPPLIER, SUPPLIER_VAT,
        TABLE_BOTTOM, TABLE_TOP, TABLE_WIDTH, VALUE_COLUMN, WORDS, Words, YEARS, clause,
        conditions_foot, continuation_address, default_font, due, language, letterhead_address,
        page_number, party, reference_line, schedule, vat_line,
    };

    /// The lines two languages are allowed to write the same way. Both call a
    /// page a page and several of them pages: the word is the same word, not a
    /// translation that was forgotten.
    const SPARED: [&str; 2] = ["page: \"Page\"", "pages: \"Pages\""];

    /// The font every measurement here is taken in, which is the one the
    /// example draws with.
    fn font(document: &mut Document) -> FontHandle {
        document.add_font(
            Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                .expect("the committed font parses"),
        )
    }

    /// What the front page says of the pack, worked out the way the example
    /// works it out: by laying the schedule down and counting the pages it
    /// takes.
    fn pack(font: &FontHandle, words: &Words) -> Contents {
        let table = schedule(font, words).expect("the schedule's columns fit its width");
        let box_of = TableFrame::new(LEFT, TABLE_TOP, TABLE_TOP - TABLE_BOTTOM);
        let placed = table
            .paginate(box_of, box_of)
            .expect("the schedule lays out in the room it is given");

        Contents {
            pages: placed.len() + 2,
            schedule: (2, placed.len() + 1),
            rows: table.row_count(),
        }
    }

    /// Every line the pack draws outside its table, at the size it is drawn at
    /// and with the room it has to itself.
    fn drawn_lines(words: &Words, contents: &Contents) -> Vec<(String, f64, f64)> {
        let first_block = SECOND_COLUMN - LEFT;
        let second_block = RIGHT - SECOND_COLUMN;

        let mut lines = vec![
            (letterhead_address(words), 9.0, TABLE_WIDTH),
            (continuation_address(), 8.0, TABLE_WIDTH),
            (words.conditions_title.to_owned(), 14.0, TABLE_WIDTH),
            (conditions_foot(words), 8.0, TABLE_WIDTH),
            (words.title.to_owned(), 20.0, TABLE_WIDTH),
            (reference_line(words), 9.5, TABLE_WIDTH),
            (words.supplier.to_owned(), 8.0, first_block),
            (words.customer.to_owned(), 8.0, second_block),
            (vat_line(words, SUPPLIER_VAT), 9.0, first_block),
            (vat_line(words, CUSTOMER_VAT), 9.0, second_block),
            (words.made_of.to_owned(), 11.0, TABLE_WIDTH),
            (words.in_it.to_owned(), 11.0, TABLE_WIDTH),
            (words.signed.to_owned(), 11.0, TABLE_WIDTH),
            (words.signed_note.to_owned(), 9.0, TABLE_WIDTH),
            (party(words, SUPPLIER), 8.0, SIGNATURE_RULE),
            (party(words, CUSTOMER), 8.0, SIGNATURE_RULE),
            (words.name_and_date.to_owned(), 8.0, SIGNATURE_RULE),
        ];

        for number in 1..=contents.pages {
            lines.push((page_number(words, number, contents.pages), 8.0, TABLE_WIDTH));
        }
        for index in 0..words.clauses.len() {
            lines.push((clause(words, index), 8.5, TABLE_WIDTH));
        }
        for line in words.stands_on.iter().chain(words.stamped.iter()) {
            lines.push(((*line).to_owned(), 9.0, TABLE_WIDTH));
        }
        for (pages, what) in contents.lines(words) {
            lines.push((pages, 9.0, ENTRY_COLUMN));
            lines.push((what, 9.0, TABLE_WIDTH - ENTRY_COLUMN));
        }
        lines
    }

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

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

    /// Nothing on these pages is flowed: every line is drawn where it is put,
    /// and a line that runs past its room writes over what stands beside it, or
    /// off the sheet.
    #[test]
    fn every_language_keeps_each_line_within_the_room_it_has() {
        let mut document = Document::new();
        let font = font(&mut document);

        for (named, words) in WORDS {
            let contents = pack(&font, words);

            for (line, size, room) in drawn_lines(words, &contents) {
                let measured = font.measure(&line, size);

                assert!(
                    measured <= room,
                    "the {} pack draws {line:?} over {measured:.1} points, and it \
                     has {room:.1}",
                    named.code()
                );
            }
        }
    }

    /// A cell that runs past its column wraps, and its row grows taller than
    /// the sixteen points the rows around it keep: the schedule then runs on to
    /// a page the front page has already counted out.
    #[test]
    fn every_language_fits_each_cell_of_the_schedule_on_one_line() {
        let mut document = Document::new();
        let font = font(&mut document);

        let batch_column = TABLE_WIDTH - DUE_COLUMN - QUANTITY_COLUMN - VALUE_COLUMN;
        let inside = |column: f64| CELL_PAD.0.mul_add(-2.0, column);

        for (named, words) in WORDS {
            let mut cells = vec![
                (words.headings[0].to_owned(), 9.0, batch_column),
                (words.headings[1].to_owned(), 9.0, DUE_COLUMN),
                (words.headings[2].to_owned(), 9.0, QUANTITY_COLUMN),
                (words.headings[3].to_owned(), 9.0, VALUE_COLUMN),
            ];
            for (index, batch) in BATCHES.iter().enumerate() {
                cells.push((words.batches[index].to_owned(), 9.0, batch_column));
                for quarter in 0..YEARS.len() {
                    cells.push((due(words, batch, quarter), 9.0, DUE_COLUMN));
                }
            }

            for (cell, size, column) in cells {
                let measured = font.measure(&cell, size);
                let room = inside(column);

                assert!(
                    measured <= room,
                    "the {} schedule sets {cell:?} over {measured:.1} points, and \
                     its column holds {room:.1}",
                    named.code()
                );
            }
        }
    }
}