One drawing, placed many times

//! Draws one badge, and places it eight times.
//!
//! The badge — its frame, its coloured head, its mark — is built once as a
//! drawing, and the file holds its operators once however many times it is
//! placed. Each placing costs a name and a matrix. The names on the badges are
//! drawn by the page, over the drawing, because they are what differs.
//!
//! What the page reads is held in `Words`, once per language, and
//! `HQF_PDF_LANG` picks which set is drawn. The guests' names are not language,
//! and neither is the company's: a name is written the way its owner writes it.
//!
//! Usage: `cargo run --example write_drawing -- tmp/drawing.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_drawing -- tmp/badges.pdf`

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

use hqf_pdf::content::Content;
use hqf_pdf::{Document, Drawing, Font, FontHandle, Page, Rect, 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 size of one badge, in points.
const BADGE: (f64, f64) = (220.0, 96.0);

/// The left edge of everything the page draws.
const LEFT: f64 = 70.0;

/// How many badges the page places.
const BADGES: usize = 8;

/// Who the badges are for. A name is not language.
const GUESTS: [&str; BADGES] = [
    "Amélie Roussel",
    "Bertrand Colin",
    "Chloé Marchand",
    "Damien Leclerc",
    "Élise Fontaine",
    "Fabien Deschamps",
    "Gabrielle Vidal",
    "Hugo Mercier",
];

/// The company the badges are issued by, drawn in the badge itself. A company
/// writes its name one way.
const COMPANY: &str = "HQF Development";

/// The words the page is written in, one set per language.
#[derive(Debug)]
struct Words {
    /// The line at the head of the page.
    title: &'static str,
    /// The line under it, saying what a drawing costs.
    intro: &'static str,
    /// What the badge itself says under the company's name, drawn once for all
    /// eight.
    occasion: &'static str,
    /// What each guest does, in the order the badges are placed.
    roles: [&'static str; BADGES],
    /// The line under the badge placed at half size.
    half: &'static str,
}

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

/// The page in English.
const ENGLISH: Words = Words {
    title: "One badge, placed eight times",
    intro: "The badge is drawn once; the file holds its operators once, whatever it costs to place.",
    occasion: "Open house — visitor",
    roles: [
        "Bindery",
        "Typesetting",
        "Prepress",
        "Colour",
        "Plates",
        "Press",
        "Finishing",
        "Despatch",
    ],
    half: "The same drawing, placed at half size.",
};

/// The page in French.
const FRENCH: Words = Words {
    title: "Un badge, posé huit fois",
    intro: "Dessiné une fois, le badge n'a qu'un jeu d'instructions dans le fichier, \
            où qu'il soit posé.",
    occasion: "Portes ouvertes — visiteur",
    roles: [
        "Reliure",
        "Composition",
        "Prépresse",
        "Couleur",
        "Plaques",
        "Impression",
        "Façonnage",
        "Expédition",
    ],
    half: "Le même dessin, posé à la moitié de sa taille.",
};

/// 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)];

/// Draws one line of text with its baseline at `(x, y)`.
fn text(
    content: &mut Content,
    font: &FontHandle,
    size: f64,
    x: f64,
    y: f64,
    line: &str,
) -> Result<(), hqf_pdf::Error> {
    content.begin_text();
    content.set_font(font.name(), size)?;
    content.text_origin(x, y)?;
    content.show_glyphs(&font.glyphs(line));
    content.end_text();
    Ok(())
}

/// The badge itself: everything every badge has, drawn from the origin.
fn badge(font: &FontHandle, words: &Words) -> Result<Drawing, hqf_pdf::Error> {
    let (width, height) = BADGE;
    let mut content = Content::new();

    content.set_fill(Rgb::new(0.96, 0.97, 0.99))?;
    content.rect(0.0, 0.0, width, height)?.fill();

    content.set_fill(Rgb::new(0.12, 0.28, 0.52))?;
    content.rect(0.0, height - 24.0, width, 24.0)?.fill();

    content.set_stroke(Rgb::new(0.12, 0.28, 0.52))?;
    content.set_line_width(1.0)?;
    content.rect(0.0, 0.0, width, height)?.stroke();

    content.set_fill(Rgb::new(1.0, 1.0, 1.0))?;
    text(&mut content, font, 11.0, 12.0, height - 17.0, COMPANY)?;

    content.set_fill(Rgb::gray(0.45))?;
    text(&mut content, font, 8.0, 12.0, 12.0, words.occasion)?;

    Ok(Drawing::new(content, Rect::new(0.0, 0.0, width, height)))
}

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

    let mut doc = Document::new();
    doc.set_license(licence::licensed());
    let font = doc.add_font(Font::parse(fs::read(&font_path)?)?);
    let handle = doc.add_drawing(badge(&font, words)?);

    let (width, height) = BADGE;
    let mut content = Content::new();
    text(&mut content, &font, 15.0, LEFT, 780.0, words.title)?;
    content.save_state();
    content.set_fill(Rgb::gray(0.35))?;
    text(&mut content, &font, 10.0, LEFT, 762.0, words.intro)?;
    content.restore_state();

    let badges: [(&str, &str); BADGES] =
        std::array::from_fn(|badge| (GUESTS[badge], words.roles[badge]));
    let mut y = 600.0;
    for pair in badges.chunks(2) {
        let mut x = LEFT;
        for (name, role) in pair {
            content.draw_form(handle.name(), x, y, 1.0)?;
            text(&mut content, &font, 14.0, x + 12.0, y + 48.0, name)?;
            content.save_state();
            content.set_fill(Rgb::gray(0.4))?;
            text(&mut content, &font, 10.0, x + 12.0, y + 32.0, role)?;
            content.restore_state();
            x += width + 20.0;
        }
        y -= height + 20.0;
    }

    // The same drawing again, at half size: a placing carries its own scale.
    content.draw_form(handle.name(), LEFT, 150.0, 0.5)?;
    content.save_state();
    content.set_fill(Rgb::gray(0.35))?;
    text(&mut content, &font, 10.0, LEFT, 134.0, words.half)?;
    content.restore_state();

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

    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, {} placings of one drawing",
        bytes.len(),
        GUESTS.len() + 1
    );
    Ok(())
}

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

    use super::{BADGE, COMPANY, LEFT, WORDS, default_font, language};

    /// The lines two languages are allowed to write the same way. Every line
    /// here is a heading, a caption or a trade, and no two languages write one
    /// alike.
    const SPARED: [&str; 0] = [];

    /// How far in from the badge's left edge everything inside it is drawn.
    const INSET: f64 = 12.0;

    /// A4's width, and the room a line of the page has between the margins.
    const PAGE_WIDTH: f64 = 595.276;
    /// See [`PAGE_WIDTH`].
    const MEASURE: f64 = PAGE_WIDTH - 2.0 * LEFT;

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

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

    /// Nothing on the page is broken to a width: a line longer than the room it
    /// is drawn in runs off the badge and over the one beside it, or off the
    /// margin and towards the edge of the paper.
    #[test]
    fn every_language_writes_lines_that_stay_in_the_room_they_are_drawn_in() {
        let mut doc = Document::new();
        let font = Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
            .expect("the committed font parses");
        let text = doc.add_font(font);
        let card = BADGE.0 - INSET - INSET;

        for (named, words) in WORDS {
            let code = named.code();
            let lines = [
                (15.0, words.title, MEASURE),
                (10.0, words.intro, MEASURE),
                (10.0, words.half, MEASURE),
                (11.0, COMPANY, card),
                (8.0, words.occasion, card),
            ]
            .into_iter()
            .chain(words.roles.map(|role| (10.0, role, card)));

            for (size, line, room) in lines {
                let measured = text.measure(line, size);
                assert!(
                    measured <= room,
                    "the {code} page draws {line:?} over {measured:.1} points, \
                     and it is given {room:.1}"
                );
            }
        }
    }
}