Un bulletin de paie

//! Draws a monthly payslip: a letterhead, the employee it names, an earnings
//! table, a dense table of contributions, and the cumulative figures a payslip
//! carries.
//!
//! The document is a table before it is anything else. Every contribution line
//! is a base, a rate for the employee and a rate for the employer, and the
//! amount each rate comes to; the section headings are rows that span the whole
//! grid; and the totals are boxed off it. Every figure on the page is worked
//! out from the earnings above it, so the sums can be checked with a pencil.
//!
//! Every word the page draws is held in `Words`, once per language, and
//! `HQF_PDF_LANG` picks which one is drawn. The figures, the rates, the ceiling
//! and the employee's name and staff number are the same in both.
//!
//! Usage: `cargo run --example write_payslip -- tmp/payslip.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_payslip -- tmp/bulletin.pdf`

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

use hqf_pdf::content::Content;
use hqf_pdf::cos::Name;
use hqf_pdf::layout::{
    Border, Cell, ColumnWidth, Columns, Margin, Padding, Row, Rule, Stroke, Table, VAlign,
};
use hqf_pdf::{Align, Document, Font, FontHandle, Image, ImageHandle, Page, Rgb};

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

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

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

use language::Language;

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

/// The logo the letterhead carries: the committed fixture, so the example runs
/// on any machine. It stands in for the employer's mark.
fn logo_path() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("tests")
        .join("images")
        .join("hqf_development.png")
}

/// A4, in points.
const PAGE_WIDTH: f64 = 595.276;
const PAGE_HEIGHT: f64 = 841.89;
/// The page's left edge and, mirrored, its right.
const LEFT: f64 = 56.0;
const RIGHT: f64 = PAGE_WIDTH - LEFT;
/// The width the tables are fitted across.
const TABLE_WIDTH: f64 = PAGE_WIDTH - 2.0 * LEFT;

/// 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,
};

/// Who the payslip is for.
const EMPLOYEE_NAME: &str = "Marion Delacroix";
const EMPLOYEE_ID: &str = "EMP-0231";

/// How many lines of pay the month has, and how many rows the contributions
/// table sets, headings included.
const EARNING_COUNT: usize = 4;
const LINE_COUNT: usize = 23;

/// What a quantity of one is counted in.
#[derive(Clone, Copy)]
enum Unit {
    /// Hours.
    Hour,
    /// Days.
    Day,
    /// Nothing: the quantity stands on its own.
    Bare,
}

/// One line of pay, apart from what it is called: a quantity of `unit`, each
/// worth `unit_rate`. The figures read the same whatever language the page is
/// set in.
struct Earning {
    /// How much of it.
    quantity: f64,
    /// What a quantity of one is counted in.
    unit: Unit,
    /// What one is worth.
    unit_rate: f64,
}

/// What the month pays, before anything is taken off it, in the order
/// `Words::earnings` names them.
const EARNINGS: [Earning; EARNING_COUNT] = [
    Earning {
        quantity: 151.67,
        unit: Unit::Hour,
        unit_rate: 27.0,
    },
    Earning {
        quantity: 6.0,
        unit: Unit::Hour,
        unit_rate: 33.75,
    },
    Earning {
        quantity: 5.0,
        unit: Unit::Day,
        unit_rate: 40.0,
    },
    Earning {
        quantity: 1.0,
        unit: Unit::Bare,
        unit_rate: 150.0,
    },
];

/// Which figure a contribution is worked out from.
#[derive(Clone, Copy)]
enum Base {
    /// The whole of the gross pay.
    Gross,
    /// Gross pay as far as the monthly social security ceiling.
    Capped,
    /// The part of gross pay above that ceiling.
    UpperBand,
    /// The part of gross pay social surcharges are levied on.
    Surcharge,
}

/// One row of the contributions table, apart from what it is called: either a
/// heading that spans the grid, or a contribution with a base and two rates.
enum Line {
    /// A heading over the contributions that follow it.
    Section,
    /// A contribution, in percent of its base.
    Charge {
        /// Which figure the rates apply to.
        base: Base,
        /// The rate taken out of the employee's pay.
        deducted: f64,
        /// The rate the employer pays on top.
        charged: f64,
        /// Whether the employee's share stays inside taxable pay.
        non_deductible: bool,
    },
}

/// Builds a contribution line, with the two rates and a deductible share.
const fn charge(base: Base, deducted: f64, charged: f64) -> Line {
    Line::Charge {
        base,
        deducted,
        charged,
        non_deductible: false,
    }
}

/// The contributions the month is charged, in the order `Words::lines` names
/// them.
const LINES: [Line; LINE_COUNT] = [
    Line::Section,
    charge(Base::Gross, 0.0, 7.0),
    charge(Base::Gross, 0.75, 1.25),
    charge(Base::Gross, 0.5, 0.0),
    Line::Section,
    charge(Base::Capped, 6.9, 8.55),
    charge(Base::Gross, 0.4, 1.9),
    charge(Base::Capped, 3.15, 4.72),
    charge(Base::UpperBand, 8.64, 12.95),
    charge(Base::Capped, 0.86, 1.29),
    charge(Base::UpperBand, 1.08, 1.62),
    Line::Section,
    charge(Base::Gross, 0.0, 5.25),
    charge(Base::Gross, 0.0, 4.05),
    charge(Base::Gross, 0.0, 0.15),
    Line::Section,
    charge(Base::Gross, 0.0, 1.1),
    charge(Base::Gross, 0.0, 0.3),
    charge(Base::Gross, 0.0, 0.68),
    charge(Base::Gross, 0.0, 1.0),
    Line::Section,
    charge(Base::Surcharge, 6.8, 0.0),
    Line::Charge {
        base: Base::Surcharge,
        deducted: 2.9,
        charged: 0.0,
        non_deductible: true,
    },
];

/// The monthly social security ceiling the capped and upper bands are cut at.
const CEILING: f64 = 3925.0;
/// The share of gross pay the social surcharges are levied on.
const SURCHARGE_SHARE: f64 = 0.9825;
/// The rate income tax is withheld at, as told to the employer by the revenue.
const TAX_RATE: f64 = 11.2;
/// How many months of the year the cumulative column adds up, this one
/// included. Every month of the year runs to the same figures.
const MONTHS: f64 = 7.0;

/// The paid leave the employee stands at, in days.
const LEAVE_EARNED: f64 = 27.5;
const LEAVE_TAKEN: f64 = 12.0;

/// Every word the page draws, in one language.
///
/// What is not language stays out of it: the figures, the rates, the ceiling
/// and the employee's name and staff number are drawn from constants of their
/// own and read the same in every language.
#[derive(Debug)]
struct Words {
    /// The words the document's title is built from, and the month it covers.
    payslip: &'static str,
    month: &'static str,
    /// The word set large at the head of the page.
    heading: &'static str,
    /// What stands before the month the page covers, and that month written out
    /// as this language writes a span of days.
    period_label: &'static str,
    period: &'static str,
    /// What stands before the day the pay was transferred, and that day.
    paid_label: &'static str,
    pay_date: &'static str,
    /// The heading over the employee, what the employee does, and what stands
    /// before the staff number and before the day they joined.
    employee: &'static str,
    role: &'static str,
    staff_label: &'static str,
    joined_label: &'static str,
    joined_date: &'static str,
    /// The heading over what is paid, and the line under the figure.
    net_paid: &'static str,
    transferred: &'static str,
    /// What an hour and a day are written as after a quantity.
    hour: &'static str,
    day: &'static str,
    /// The four column headings of the earnings table.
    earnings_heading: &'static str,
    quantity: &'static str,
    unit_rate: &'static str,
    earnings_amount: &'static str,
    /// What each line of pay is called, in the order `EARNINGS` pays them, and
    /// the total under them.
    earnings: [&'static str; EARNING_COUNT],
    gross_pay: &'static str,
    /// The two tiers of headings of the contributions table.
    employee_share: &'static str,
    employer_share: &'static str,
    contribution: &'static str,
    base: &'static str,
    rate: &'static str,
    amount: &'static str,
    /// What each row of the contributions table is called, in the order `LINES`
    /// sets them, headings included.
    lines: [&'static str; LINE_COUNT],
    /// The three totals under the contributions.
    total_contributions: &'static str,
    net_before_tax: &'static str,
    total_cost: &'static str,
    /// The three column headings of the cumulative table, the five lines it
    /// carries, and what is paid over at the foot of it.
    summary: &'static str,
    this_month: &'static str,
    year_to_date: &'static str,
    summary_lines: [&'static str; 5],
    net_paid_row: &'static str,
    /// The heading over the leave, and the three counts under it.
    leave: &'static str,
    leave_earned: &'static str,
    leave_taken: &'static str,
    leave_remaining: &'static str,
    /// The working week, and the small print at the foot of the page.
    working_time: &'static str,
    mentions: &'static str,
}

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

    /// What a quantity is counted in, in this language.
    const fn unit(&self, unit: Unit) -> &'static str {
        match unit {
            Unit::Hour => self.hour,
            Unit::Day => self.day,
            Unit::Bare => "",
        }
    }
}

/// The payslip in English.
const ENGLISH: Words = Words {
    payslip: "Payslip",
    month: "July 2026",
    heading: "PAYSLIP",
    period_label: "Period",
    period: "1 – 31 July 2026",
    paid_label: "Paid on",
    pay_date: "31 July 2026",
    employee: "EMPLOYEE",
    role: "Senior software engineer — grade 3.2",
    staff_label: "Staff No.",
    joined_label: "Joined",
    joined_date: "4 September 2023",
    net_paid: "NET PAID",
    transferred: "Transferred to the account on file",
    hour: "h",
    day: "d",
    earnings_heading: "Earnings",
    quantity: "Quantity",
    unit_rate: "Unit rate",
    earnings_amount: "Amount",
    earnings: [
        "Monthly base salary",
        "Overtime, first eight hours (125 %)",
        "On-call cover, weekend",
        "Seniority bonus",
    ],
    gross_pay: "GROSS PAY",
    employee_share: "Employee share",
    employer_share: "Employer share",
    contribution: "Contribution",
    base: "Base",
    rate: "Rate",
    amount: "Amount",
    lines: [
        "HEALTH, MATERNITY, DISABILITY, DEATH",
        "Health and maternity insurance",
        "Supplementary health cover",
        "Daily sickness allowance",
        "RETIREMENT",
        "State pension, capped",
        "State pension, uncapped",
        "Supplementary pension, band 1",
        "Supplementary pension, band 2",
        "Balancing contribution, band 1",
        "Balancing contribution, band 2",
        "FAMILY AND UNEMPLOYMENT",
        "Family allowances",
        "Unemployment insurance",
        "Wage guarantee scheme",
        "OTHER EMPLOYER CONTRIBUTIONS",
        "Workplace accident cover",
        "Autonomy solidarity contribution",
        "Apprenticeship levy",
        "Continuing training levy",
        "SOCIAL SURCHARGES",
        "Social surcharge, deductible",
        "Social surcharge and debt levy, non-deductible",
    ],
    total_contributions: "TOTAL CONTRIBUTIONS",
    net_before_tax: "NET PAY BEFORE INCOME TAX",
    total_cost: "TOTAL COST OF THE MONTH TO THE EMPLOYER",
    summary: "Summary",
    this_month: "This month",
    year_to_date: "Year to date",
    summary_lines: [
        "Gross pay",
        "Employee contributions",
        "Employer contributions",
        "Taxable pay",
        "Income tax withheld at 11.20 %",
    ],
    net_paid_row: "NET PAID",
    leave: "PAID LEAVE",
    leave_earned: "Earned this year",
    leave_taken: "taken",
    leave_remaining: "remaining",
    working_time: "Working time: 35 h a week",
    mentions: "Keep this payslip without limit of time · \
        HQF Development · 42 lot les Genêts, 13480 Calas, France · \
        SIRET 752 492 777 00012 · APE 6202A",
};

/// The payslip in French.
const FRENCH: Words = Words {
    payslip: "Bulletin de paie",
    month: "juillet 2026",
    heading: "BULLETIN DE PAIE",
    period_label: "Période",
    period: "1er – 31 juillet 2026",
    paid_label: "Payé le",
    pay_date: "31 juillet 2026",
    employee: "SALARIÉE",
    role: "Ingénieure logiciel confirmée — niveau 3.2",
    staff_label: "Matricule",
    joined_label: "Entrée le",
    joined_date: "4 septembre 2023",
    net_paid: "NET À PAYER",
    transferred: "Virement sur le compte enregistré",
    hour: "h",
    day: "j",
    earnings_heading: "Éléments de paie",
    quantity: "Nombre",
    unit_rate: "Taux unitaire",
    earnings_amount: "Montant",
    earnings: [
        "Salaire de base mensuel",
        "Heures supplémentaires, 8 premières (125 %)",
        "Astreinte de week-end",
        "Prime d'ancienneté",
    ],
    gross_pay: "SALAIRE BRUT",
    employee_share: "Part salariale",
    employer_share: "Part patronale",
    contribution: "Cotisation",
    base: "Base",
    rate: "Taux",
    amount: "Montant",
    lines: [
        "SANTÉ, MATERNITÉ, INVALIDITÉ, DÉCÈS",
        "Assurance maladie et maternité",
        "Complémentaire santé",
        "Indemnités journalières",
        "RETRAITE",
        "Assurance vieillesse plafonnée",
        "Assurance vieillesse déplafonnée",
        "Retraite complémentaire, tranche 1",
        "Retraite complémentaire, tranche 2",
        "Contribution d'équilibre, tranche 1",
        "Contribution d'équilibre, tranche 2",
        "FAMILLE ET CHÔMAGE",
        "Allocations familiales",
        "Assurance chômage",
        "Garantie des salaires",
        "AUTRES COTISATIONS PATRONALES",
        "Accidents du travail",
        "Contribution solidarité autonomie",
        "Taxe d'apprentissage",
        "Formation professionnelle",
        "CSG ET CRDS",
        "CSG déductible",
        "CSG et CRDS non déductibles",
    ],
    total_contributions: "TOTAL DES COTISATIONS",
    net_before_tax: "NET À PAYER AVANT IMPÔT",
    total_cost: "COÛT TOTAL DU MOIS POUR L'EMPLOYEUR",
    summary: "Récapitulatif",
    this_month: "Ce mois",
    year_to_date: "Cumul annuel",
    summary_lines: [
        "Salaire brut",
        "Cotisations salariales",
        "Cotisations patronales",
        "Net imposable",
        "Prélèvement à la source, 11.20 %",
    ],
    net_paid_row: "NET À PAYER",
    leave: "CONGÉS PAYÉS",
    leave_earned: "Acquis cette année",
    leave_taken: "pris",
    leave_remaining: "solde",
    working_time: "Temps de travail : 35 h par semaine",
    mentions: "Bulletin à conserver sans limitation de durée · \
        HQF Development · 42 lot les Genêts, 13480 Calas, France · \
        SIRET 752 492 777 00012 · APE 6202A",
};

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

/// A value rounded to the hundredth, the way every figure on a payslip is
/// carried: each line is rounded before it is added, so the totals are the sum
/// of what is printed.
fn round2(value: f64) -> f64 {
    let hundredths = value * 100.0;
    (hundredths + 0.5).floor() / 100.0
}

/// An amount, as a payslip writes it: "4 647.59".
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}")
}

/// A rate, as a payslip writes it: "6.90 %". A rate of nothing is a dash, so
/// that a column of rates reads as a column.
fn percent(rate: f64) -> String {
    if rate == 0.0 {
        return "—".to_string();
    }
    format!("{rate:.2} %")
}

/// What the month comes to: the gross pay, the two sides of the contributions,
/// and the surcharge that taxable pay takes back.
struct Payroll {
    /// The pay the contributions are worked out from.
    gross: f64,
    /// What the employee's shares add up to.
    employee: f64,
    /// What the employer's shares add up to.
    employer: f64,
    /// The employee's share that taxable pay adds back.
    non_deductible: f64,
}

impl Payroll {
    /// Adds the earnings up, then charges every contribution against them.
    fn compute() -> Self {
        let gross = EARNINGS
            .iter()
            .map(|earning| round2(earning.quantity * earning.unit_rate))
            .sum::<f64>();

        let mut payroll = Self {
            gross,
            employee: 0.0,
            employer: 0.0,
            non_deductible: 0.0,
        };

        for line in &LINES {
            let Line::Charge {
                base,
                deducted,
                charged,
                non_deductible,
            } = line
            else {
                continue;
            };

            let base = payroll.base(*base);
            let share = round2(base * deducted / 100.0);
            payroll.employee += share;
            payroll.employer += round2(base * charged / 100.0);
            if *non_deductible {
                payroll.non_deductible += share;
            }
        }

        payroll
    }

    /// The figure a contribution's rates are applied to.
    fn base(&self, base: Base) -> f64 {
        match base {
            Base::Gross => self.gross,
            Base::Capped => CEILING,
            Base::UpperBand => self.gross - CEILING,
            Base::Surcharge => round2(self.gross * SURCHARGE_SHARE),
        }
    }

    /// Gross pay less everything the employee contributes.
    fn net_before_tax(&self) -> f64 {
        round2(self.gross - self.employee)
    }

    /// What income tax is charged on: net pay before tax, plus the share of the
    /// social surcharges that tax does not let through.
    fn taxable(&self) -> f64 {
        round2(self.net_before_tax() + self.non_deductible)
    }

    /// The tax the employer withholds and pays over.
    fn tax(&self) -> f64 {
        round2(self.taxable() * TAX_RATE / 100.0)
    }

    /// What lands in the employee's account.
    fn net_paid(&self) -> f64 {
        round2(self.net_before_tax() - self.tax())
    }
}

/// Draws a line of text, left-aligned, in a colour of its own.
fn text(content: &mut Content, font: &FontHandle, size: f64, x: f64, y: f64, color: Rgb, s: &str) {
    let _ = content.set_fill(color);
    content.begin_text();
    let _ = content.set_font(font.name(), 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 `LEFT` to `RIGHT` at height `y`.
fn rule(content: &mut Content, y: f64, width: f64, color: Rgb) -> Result<(), hqf_pdf::Error> {
    content.set_stroke(color)?;
    content.set_line_width(width)?;
    content.move_to(LEFT, y)?;
    content.line_to(RIGHT, y)?;
    content.stroke();
    Ok(())
}

/// The padding every cell of every table on this page is set in.
const fn pad() -> Padding {
    Padding::symmetric(4.0, 1.5)
}

/// A cell holding a figure: small, right-aligned, centred in its row.
fn figure(font: &FontHandle, size: f64, value: String) -> Cell<'_> {
    Cell::new(font, size, value)
        .padding(pad())
        .align(Align::Right)
        .valign(VAlign::Middle)
}

/// A heading cell: white on the accent, centred in its row.
fn heading<'a>(font: &'a FontHandle, label: &str) -> Cell<'a> {
    Cell::new(font, 7.0, label)
        .padding(pad())
        .fill(ACCENT)
        .color(Rgb::gray(1.0))
        .valign(VAlign::Middle)
}

/// The earnings table: what the month pays, line by line, and the gross it
/// comes to.
fn earnings_table<'a>(
    font: &'a FontHandle,
    words: &'static Words,
    payroll: &Payroll,
) -> Result<Table<'a>, hqf_pdf::Error> {
    // The description takes whatever the three figure columns leave it.
    let columns = Columns::new(
        vec![
            ColumnWidth::Fraction(1.0),
            ColumnWidth::Points(70.0),
            ColumnWidth::Points(70.0),
            ColumnWidth::Points(80.0),
        ],
        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.82)))
        .rule(Rule::Horizontal(1), Stroke::new(0.8, ACCENT))
        .rule(Rule::HorizontalFromEnd(1), Stroke::new(0.8, ACCENT));

    table.push(
        Row::new()
            .cell(heading(font, words.earnings_heading))
            .cell(heading(font, words.quantity).align(Align::Right))
            .cell(heading(font, words.unit_rate).align(Align::Right))
            .cell(heading(font, words.earnings_amount).align(Align::Right))
            .min_height(15.0),
    );

    for (index, (earning, label)) in EARNINGS.iter().zip(words.earnings).enumerate() {
        let unit = words.unit(earning.unit);
        let quantity = if unit.is_empty() {
            format!("{:.2}", earning.quantity)
        } else {
            format!("{:.2} {unit}", earning.quantity)
        };

        let mut row = Row::new()
            .cell(
                Cell::new(font, 7.5, label)
                    .padding(pad())
                    .valign(VAlign::Middle),
            )
            .cell(figure(font, 7.5, quantity))
            .cell(figure(font, 7.5, format!("{:.4}", earning.unit_rate)))
            .cell(figure(
                font,
                7.5,
                amount(round2(earning.quantity * earning.unit_rate)),
            ))
            .min_height(13.0);

        if index % 2 == 1 {
            row = row.fill(Rgb::gray(0.96));
        }
        table.push(row);
    }

    table.push(
        Row::new()
            .cell(
                Cell::new(font, 8.0, words.gross_pay)
                    .span(3)
                    .align(Align::Right)
                    .padding(pad())
                    .valign(VAlign::Middle),
            )
            .cell(figure(font, 8.0, amount(payroll.gross)))
            .min_height(15.0),
    );

    Ok(table)
}

/// The contributions table: two tiers of headings, a heading row for each
/// family of contributions, one row per contribution, and the three totals.
fn contributions_table<'a>(
    font: &'a FontHandle,
    words: &'static Words,
    payroll: &Payroll,
) -> Result<Table<'a>, hqf_pdf::Error> {
    // Four figure columns for the two shares, one for the base, and whatever is
    // left over for the wording.
    let columns = Columns::new(
        vec![
            ColumnWidth::Fraction(1.0),
            ColumnWidth::Points(62.0),
            ColumnWidth::Points(42.0),
            ColumnWidth::Points(62.0),
            ColumnWidth::Points(42.0),
            ColumnWidth::Points(62.0),
        ],
        TABLE_WIDTH,
    )?;

    let mut table = Table::new(columns);
    // Both tiers of the heading repeat if the table ever continues on a second
    // page.
    table.header(2);
    table
        .rule(Rule::Frame, Stroke::new(0.8, ACCENT))
        .rule(Rule::HorizontalOther, Stroke::new(0.25, Rgb::gray(0.85)))
        .rule(Rule::Horizontal(1), Stroke::new(0.4, Rgb::gray(1.0)))
        .rule(Rule::Horizontal(2), Stroke::new(0.8, ACCENT))
        .rule(Rule::HorizontalFromEnd(3), Stroke::new(0.8, ACCENT))
        .rule(Rule::Vertical(2), Stroke::new(0.4, Rgb::gray(0.72)))
        .rule(Rule::Vertical(4), Stroke::new(0.4, Rgb::gray(0.72)));

    table.push(
        Row::new()
            .cell(heading(font, "").span(2))
            .cell(
                heading(font, words.employee_share)
                    .span(2)
                    .align(Align::Center),
            )
            .cell(
                heading(font, words.employer_share)
                    .span(2)
                    .align(Align::Center),
            )
            .min_height(13.0),
    );
    table.push(
        Row::new()
            .cell(heading(font, words.contribution))
            .cell(heading(font, words.base).align(Align::Right))
            .cell(heading(font, words.rate).align(Align::Right))
            .cell(heading(font, words.amount).align(Align::Right))
            .cell(heading(font, words.rate).align(Align::Right))
            .cell(heading(font, words.amount).align(Align::Right))
            .min_height(13.0),
    );

    for (line, label) in LINES.iter().zip(words.lines) {
        match line {
            Line::Section => table.push(
                Row::new()
                    .cell(
                        Cell::new(font, 7.0, label)
                            .span(6)
                            .padding(pad())
                            .color(ACCENT)
                            .valign(VAlign::Middle),
                    )
                    .fill(Rgb::gray(0.91))
                    .min_height(12.0),
            ),
            Line::Charge {
                base,
                deducted,
                charged,
                ..
            } => {
                let base = payroll.base(*base);
                let share = |rate: f64| {
                    if rate == 0.0 {
                        String::new()
                    } else {
                        amount(round2(base * rate / 100.0))
                    }
                };

                table.push(
                    Row::new()
                        .cell(
                            Cell::new(font, 7.0, label)
                                .padding(pad())
                                .valign(VAlign::Middle),
                        )
                        .cell(figure(font, 7.0, amount(base)))
                        .cell(figure(font, 7.0, percent(*deducted)))
                        .cell(figure(font, 7.0, share(*deducted)))
                        .cell(figure(font, 7.0, percent(*charged)))
                        .cell(figure(font, 7.0, share(*charged)))
                        .min_height(11.5),
                )
            }
        };
    }

    contribution_totals(&mut table, font, words, payroll);

    Ok(table)
}

/// Closes the contributions table off: the two columns of shares added up under
/// their own heads, then the net pay and the cost of the month.
fn contribution_totals<'a>(
    table: &mut Table<'a>,
    font: &'a FontHandle,
    words: &'static Words,
    payroll: &Payroll,
) {
    table.push(
        Row::new()
            .cell(
                Cell::new(font, 8.0, words.total_contributions)
                    .span(3)
                    .align(Align::Right)
                    .padding(pad())
                    .valign(VAlign::Middle),
            )
            .cell(figure(font, 8.0, amount(payroll.employee)))
            .cell(Cell::new(font, 8.0, "").padding(pad()))
            .cell(figure(font, 8.0, amount(payroll.employer)))
            .min_height(15.0),
    );

    // The last two lines are boxed off the grid so that they read as totals
    // rather than as more lines of it: the label carries the box's left edge
    // and the figure its right, so the two trace one box between them.
    let stroke = Stroke::new(0.8, ACCENT);
    let box_margin = Margin::symmetric(0.0, 2.0);
    let label_border = Border::none().top(&stroke).bottom(&stroke).left(&stroke);
    let value_border = Border::none().top(&stroke).bottom(&stroke).right(&stroke);

    table.push(
        Row::new()
            .cell(
                Cell::new(font, 8.0, words.net_before_tax)
                    .span(3)
                    .align(Align::Right)
                    .padding(pad())
                    .margin(box_margin)
                    .border(&label_border)
                    .valign(VAlign::Middle),
            )
            .cell(
                Cell::new(font, 8.0, amount(payroll.net_before_tax()))
                    .align(Align::Right)
                    .padding(pad())
                    .margin(box_margin)
                    .border(&value_border)
                    .valign(VAlign::Middle),
            )
            .cell(Cell::new(font, 8.0, "").span(2).padding(pad()))
            .min_height(15.0),
    );

    table.push(
        Row::new()
            .cell(
                Cell::new(font, 7.5, words.total_cost)
                    .span(5)
                    .align(Align::Right)
                    .padding(pad())
                    .margin(box_margin)
                    .border(&label_border)
                    .valign(VAlign::Middle),
            )
            .cell(
                Cell::new(font, 7.5, amount(round2(payroll.gross + payroll.employer)))
                    .align(Align::Right)
                    .padding(pad())
                    .margin(box_margin)
                    .border(&value_border)
                    .valign(VAlign::Middle),
            )
            .min_height(14.0),
    );
}

/// The cumulative table: what the month came to beside what the year has come
/// to, the income tax withheld, and the net that is paid over.
fn cumulative_table<'a>(
    font: &'a FontHandle,
    words: &'static Words,
    payroll: &Payroll,
) -> Result<Table<'a>, hqf_pdf::Error> {
    let columns = Columns::new(
        vec![
            ColumnWidth::Fraction(1.0),
            ColumnWidth::Points(96.0),
            ColumnWidth::Points(96.0),
        ],
        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.82)))
        .rule(Rule::Horizontal(1), Stroke::new(0.8, ACCENT))
        .rule(Rule::HorizontalFromEnd(1), Stroke::new(0.8, ACCENT));

    table.push(
        Row::new()
            .cell(heading(font, words.summary))
            .cell(heading(font, words.this_month).align(Align::Right))
            .cell(heading(font, words.year_to_date).align(Align::Right))
            .min_height(15.0),
    );

    let values = [
        payroll.gross,
        payroll.employee,
        payroll.employer,
        payroll.taxable(),
        payroll.tax(),
    ];

    for (index, (label, value)) in words.summary_lines.into_iter().zip(values).enumerate() {
        let mut row = Row::new()
            .cell(
                Cell::new(font, 7.5, label)
                    .padding(pad())
                    .valign(VAlign::Middle),
            )
            .cell(figure(font, 7.5, amount(value)))
            .cell(figure(font, 7.5, amount(round2(value * MONTHS))))
            .min_height(13.0);

        if index % 2 == 1 {
            row = row.fill(Rgb::gray(0.96));
        }
        table.push(row);
    }

    table.push(
        Row::new()
            .cell(
                Cell::new(font, 8.5, words.net_paid_row)
                    .padding(pad())
                    .color(ACCENT)
                    .valign(VAlign::Middle),
            )
            .cell(figure(font, 8.5, amount(payroll.net_paid())).color(ACCENT))
            .cell(figure(
                font,
                8.5,
                amount(round2(payroll.net_paid() * MONTHS)),
            ))
            .min_height(17.0),
    );

    Ok(table)
}

/// Draws the letterhead: the mark, the employer, the word the page is, and the
/// month it covers, closed off by a rule.
fn letterhead(
    content: &mut Content,
    font: &FontHandle,
    logo: &ImageHandle,
    words: &Words,
) -> Result<(), hqf_pdf::Error> {
    let (logo_w, logo_h) = logo.fit_within(62.25, 62.25)?;
    content.draw_image(logo, LEFT, 826.5 - logo_h, logo_w, logo_h)?;

    text(
        content,
        font,
        8.5,
        LEFT,
        782.0,
        MUTED,
        "42 lot les Genêts, 13480 Calas, France",
    );
    text(
        content,
        font,
        8.5,
        LEFT,
        771.0,
        MUTED,
        "SIRET 752 492 777 00012 · APE 6202A · www.hqf.fr",
    );

    text_right(content, font, 26.0, RIGHT, 802.0, ACCENT, words.heading);
    text_right(
        content,
        font,
        9.0,
        RIGHT,
        783.0,
        INK,
        &format!("{} {}", words.period_label, words.period),
    );
    text_right(
        content,
        font,
        9.0,
        RIGHT,
        771.0,
        MUTED,
        &format!("{} {}", words.paid_label, words.pay_date),
    );

    rule(content, 758.0, 1.2, ACCENT)
}

/// Draws who is being paid and — set apart on the right — what they are paid.
fn employee(content: &mut Content, font: &FontHandle, words: &Words, payroll: &Payroll) {
    text(content, font, 7.5, LEFT, 742.0, MUTED, words.employee);
    text(content, font, 11.0, LEFT, 728.0, INK, EMPLOYEE_NAME);
    text(content, font, 8.0, LEFT, 715.0, MUTED, words.role);
    text(
        content,
        font,
        8.0,
        LEFT,
        704.0,
        MUTED,
        &format!(
            "{} {EMPLOYEE_ID} · {} {}",
            words.staff_label, words.joined_label, words.joined_date
        ),
    );

    text_right(content, font, 7.5, RIGHT, 742.0, MUTED, words.net_paid);
    text_right(
        content,
        font,
        18.0,
        RIGHT,
        724.0,
        ACCENT,
        &format!("{} EUR", amount(payroll.net_paid())),
    );
    text_right(content, font, 8.0, RIGHT, 708.0, MUTED, words.transferred);
}

/// Draws the leave the employee stands at, and the small print the foot of the
/// page carries.
fn footer(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    top: f64,
) -> Result<(), hqf_pdf::Error> {
    text(content, font, 7.5, LEFT, top, ACCENT, words.leave);
    let day = words.day;
    let leave = format!(
        "{} {LEAVE_EARNED:.2} {day} · {} {LEAVE_TAKEN:.2} {day} · {} {:.2} {day}",
        words.leave_earned,
        words.leave_taken,
        words.leave_remaining,
        LEAVE_EARNED - LEAVE_TAKEN
    );
    text(content, font, 8.0, LEFT, top - 13.0, INK, &leave);
    text_right(
        content,
        font,
        8.0,
        RIGHT,
        top - 13.0,
        MUTED,
        words.working_time,
    );

    rule(content, 74.0, 0.5, Rgb::gray(0.8))?;
    let mentions_x = LEFT + (TABLE_WIDTH - font.measure(words.mentions, 6.5)) / 2.0;
    text(content, font, 6.5, mentions_x, 62.0, MUTED, words.mentions);

    Ok(())
}

fn main() -> 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 path = args
        .next()
        .unwrap_or_else(|| language.file_name(&out::default_path("payslip")));
    let font_path = args.next().map_or_else(default_font, PathBuf::from);

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

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

    let payroll = Payroll::compute();

    let mut content = Content::new();
    letterhead(&mut content, &font, &logo, words)?;
    employee(&mut content, &font, words, &payroll);

    // The three tables are stacked down the page, each one starting a fixed gap
    // below where the one above it stopped.
    let mut top = 686.0;
    for table in [
        earnings_table(&font, words, &payroll)?,
        contributions_table(&font, words, &payroll)?,
        cumulative_table(&font, words, &payroll)?,
    ] {
        let placed = table.fit(LEFT, top, top - 80.0, 0)?;
        placed.draw(&mut content)?;
        top -= placed.height() + 18.0;
    }

    footer(&mut content, &font, words, top - 4.0)?;

    let mut page = Page::new(PAGE_WIDTH, PAGE_HEIGHT);
    page.content = content.into_bytes();
    doc.add_page(page)?;

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

    println!(
        "wrote {path}: {} bytes, {} gross, {} net",
        bytes.len(),
        amount(payroll.gross),
        amount(payroll.net_paid())
    );
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::{WORDS, language};

    /// The lines two languages are allowed to write the same way, each with
    /// what makes the two the same word.
    const SPARED: [&str; 2] = [
        // An hour is written `h` after a quantity in French as in English.
        r#"hour: "h""#,
        // A contribution is headed by the base it is worked out from, and the
        // word is the same in both.
        r#"base: "Base""#,
    ];

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

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