Une seule hachure, posée dans autant de couleurs que la page demande

//! One hatch, drawn once, laid down in as many colours as the page asks for.
//!
//! A tiling pattern usually states its own colours, so a hatch in five colours
//! is five patterns. A pattern built with `uncolored` states none: the cell
//! says only what shape is laid down, and the colour comes from the fill. The
//! page below lays one such cell down in five colours and in five strengths of
//! one ink, and then shows what the ordinary kind costs beside it.
//!
//! The words are held in `Words`, once per language, and `HQF_PDF_LANG` picks
//! which set the page is written in. What a swatch is painted with is not
//! language: the numbers under the first row are the ones the stream states,
//! and the ink of the second row travels under the name a press knows it by.
//!
//! Usage: `cargo run --example write_stencil_pattern -- tmp/stencil.pdf
//! [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_stencil_pattern --
//! tmp/pochoir.pdf`

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

use hqf_pdf::content::Content;
use hqf_pdf::{
    Cmyk, Color, ColorSpaceHandle, DeviceSpace, Document, Error, Font, FontHandle, Page,
    PatternHandle, PatternSpace, Rect, Rgb, Separation, TilingPattern,
};

#[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 left edge of everything.
const LEFT: f64 = 70.0;

/// The side of one cell of the hatch.
const CELL: f64 = 10.0;

/// Half the height of one band of the hatch, measured up the page.
const BAND: f64 = 1.6;

/// How far behind the cell's box a band starts, and how far past it it runs:
/// the box is what cuts them, so the ends fall outside it.
const BEHIND: f64 = -CELL;
/// See [`BEHIND`].
const BEYOND: f64 = CELL + CELL;

/// The five colours the one stencil is laid down in, each under the numbers the
/// fill states it as: what is written under a swatch is what the stream says.
const COLORS: &[([f64; 3], &str)] = &[
    ([0.12, 0.28, 0.52], "0.12 0.28 0.52"),
    ([0.16, 0.45, 0.35], "0.16 0.45 0.35"),
    ([0.78, 0.30, 0.24], "0.78 0.3 0.24"),
    ([0.55, 0.35, 0.62], "0.55 0.35 0.62"),
    ([0.20, 0.20, 0.20], "0.2 0.2 0.2"),
];

/// The five strengths the one stencil is laid down in as an ink.
const TINTS: &[f64] = &[0.15, 0.35, 0.55, 0.75, 1.0];

/// The three colours the ordinary kind of pattern needs a cell of its own for.
const OWN: &[[f64; 3]] = &[[0.12, 0.28, 0.52], [0.78, 0.30, 0.24], [0.16, 0.45, 0.35]];

/// The ink the strengths of the second row are laid down in, which is a name a
/// press knows the ink by rather than a word a language writes.
const INK: &str = "Corporate Blue";

/// The words the page is written in, one set per language.
#[derive(Debug)]
struct Words {
    /// The title over the page.
    title: &'static str,
    /// The two lines under the title.
    intro: [&'static str; 2],
    /// The heading of each of the three panels, and the line under it.
    panels: [[&'static str; 2]; 3],
    /// What stands in front of the strength on the label of a tinted swatch.
    tint_label: &'static str,
    /// What is written under each of the three swatches whose pattern carries
    /// its own colour.
    own: [&'static str; 3],
    /// The three lines of the closing note.
    closing: [&'static str; 3],
}

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

    /// What is written under the swatch laid down at `tint`.
    fn tint(&self, tint: f64) -> String {
        format!("{}{tint}", self.tint_label)
    }
}

/// The page in English.
const ENGLISH: Words = Words {
    title: "One hatch, laid down in as many colours as the page asks for",
    intro: [
        "The first ten swatches below are one cell. It states no colour: the fill says what colour \
         to lay",
        "it down in, and the space the fill is stated in says what those numbers mean.",
    ],
    panels: [
        [
            "Five colours, one cell",
            "The colour is three numbers in DeviceRGB, and the pattern is named beside them.",
        ],
        [
            "The same cell, through one ink",
            "The same pattern, through a space whose one number is how much ink the press lays \
             down.",
        ],
        [
            "What a cell that carries its own colours costs",
            "Nothing is said at the fill, so each colour of the hatch is a cell of its own in the \
             file.",
        ],
    ],
    tint_label: "tint ",
    own: ["one cell", "a second cell", "a third cell"],
    closing: [
        "Thirteen swatches, four cells: one for the ten above, and one apiece for the three that \
         carry",
        "their own colours. Changing the hatch itself is changing one cell in the first two rows \
         and",
        "three in the last.",
    ],
};

/// The page in French.
const FRENCH: Words = Words {
    title: "Une hachure, dans autant de couleurs que la page en demande",
    intro: [
        "Les dix premières pastilles sont une seule case. Elle ne dit aucune couleur : le \
         remplissage dit",
        "dans quelle couleur la poser, et l'espace où il est dit donne le sens de ces nombres.",
    ],
    panels: [
        [
            "Cinq couleurs, une seule case",
            "La couleur est trois nombres en DeviceRGB, et le motif est nommé à côté d'eux.",
        ],
        [
            "La même case, à travers une encre",
            "Le même motif, dans un espace dont l'unique nombre est la quantité d'encre que pose \
             la presse.",
        ],
        [
            "Ce que coûte une case qui porte ses propres couleurs",
            "Rien n'est dit au remplissage, donc chaque couleur de la hachure est une case à part \
             dans le fichier.",
        ],
    ],
    tint_label: "teinte ",
    own: ["une case", "une deuxième case", "une troisième case"],
    closing: [
        "Treize pastilles, quatre cases : une pour les dix du haut, et une chacune pour les trois \
         qui",
        "portent leurs propres couleurs. Changer la hachure, c'est changer une case dans les deux \
         premières",
        "rangées et trois dans la dernière.",
    ],
};

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

/// The size of one swatch of the first two rows, and the gap to the next.
const SWATCH: (f64, f64) = (83.0, 105.0);
/// See [`SWATCH`].
const SWATCH_GAP: f64 = 10.0;

/// The width of one swatch of the last row, which holds three rather than five.
const WIDE: f64 = 145.0;

/// 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<(), 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(())
}

/// Lays the bands of the hatch into `cell`, three of them so that the corners
/// carry the halves the middle band leaves out and the plane runs unbroken.
fn hatch(cell: &mut Content) -> Result<(), Error> {
    for offset in [-CELL, 0.0, CELL] {
        let near = BEHIND + offset;
        let far = BEYOND + offset;
        cell.move_to(BEHIND, near - BAND)?;
        cell.line_to(BEYOND, far - BAND)?;
        cell.line_to(BEYOND, far + BAND)?;
        cell.line_to(BEHIND, near + BAND)?;
        cell.close_path().fill();
    }
    Ok(())
}

/// The hatch as a cell that states no colour of its own.
fn stencil() -> Result<TilingPattern, Error> {
    let mut cell = Content::new();
    hatch(&mut cell)?;
    Ok(TilingPattern::new(cell, Rect::new(0.0, 0.0, CELL, CELL), (CELL, CELL)).uncolored())
}

/// The same hatch as a cell that carries `color`.
fn carried(color: [f64; 3]) -> Result<TilingPattern, Error> {
    let mut cell = Content::new();
    cell.set_fill(Rgb::new(color[0], color[1], color[2]))?;
    hatch(&mut cell)?;
    Ok(TilingPattern::new(
        cell,
        Rect::new(0.0, 0.0, CELL, CELL),
        (CELL, CELL),
    ))
}

/// Lays the paper of a swatch down and frames it once whatever fills it has
/// been painted.
fn paper(content: &mut Content, x: f64, y: f64, width: f64) -> Result<(), Error> {
    content.save_state();
    content.set_fill(Color::Gray(0.97))?;
    content.rect(x, y, width, SWATCH.1)?.fill();
    content.restore_state();
    Ok(())
}

/// Frames a swatch and writes what is under it.
fn frame(
    content: &mut Content,
    font: &FontHandle,
    corner: (f64, f64),
    width: f64,
    label: &str,
) -> Result<(), Error> {
    let (x, y) = corner;
    content.save_state();
    content.set_stroke(Color::Gray(0.55))?;
    content.set_line_width(0.6)?;
    content.rect(x, y, width, SWATCH.1)?.stroke();
    content.set_fill(Color::Gray(0.45))?;
    text(content, font, 8.0, x, y - 12.0, label)?;
    content.restore_state();
    Ok(())
}

/// Draws one panel's heading, with the line under it.
fn panel_heading(
    content: &mut Content,
    font: &FontHandle,
    y: f64,
    title: &str,
    under: &str,
) -> Result<(), Error> {
    content.save_state();
    content.set_fill(Color::Gray(0.2))?;
    text(content, font, 11.0, LEFT, y, title)?;
    content.set_fill(Color::Gray(0.45))?;
    text(content, font, 8.0, LEFT, y - 15.0, under)?;
    content.restore_state();
    Ok(())
}

/// Lays the one stencil down five times across, each swatch in the colour
/// beside it.
fn in_colors(
    content: &mut Content,
    font: &FontHandle,
    space: &ColorSpaceHandle,
    stencil: &PatternHandle,
) -> Result<(), Error> {
    let mut x = LEFT;
    for (color, label) in COLORS {
        paper(content, x, 570.0, SWATCH.0)?;
        content.save_state();
        content.set_fill_space(space);
        content.set_fill_pattern_components(color, stencil)?;
        content.rect(x, 570.0, SWATCH.0, SWATCH.1)?.fill();
        content.restore_state();
        frame(content, font, (x, 570.0), SWATCH.0, label)?;
        x += SWATCH.0 + SWATCH_GAP;
    }
    Ok(())
}

/// Lays the same stencil down five times across, each swatch a strength of the
/// one ink.
fn in_tints(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    space: &ColorSpaceHandle,
    stencil: &PatternHandle,
) -> Result<(), Error> {
    let mut x = LEFT;
    for tint in TINTS {
        paper(content, x, 379.0, SWATCH.0)?;
        content.save_state();
        content.set_fill_space(space);
        content.set_fill_pattern_components(&[*tint], stencil)?;
        content.rect(x, 379.0, SWATCH.0, SWATCH.1)?.fill();
        content.restore_state();
        frame(content, font, (x, 379.0), SWATCH.0, &words.tint(*tint))?;
        x += SWATCH.0 + SWATCH_GAP;
    }
    Ok(())
}

/// Lays down three patterns that carry their own colours, one swatch each.
fn in_their_own(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    patterns: &[PatternHandle],
) -> Result<(), Error> {
    let mut x = LEFT;
    for (pattern, label) in patterns.iter().zip(words.own) {
        paper(content, x, 188.0, WIDE)?;
        content.save_state();
        content.set_fill_pattern(pattern);
        content.rect(x, 188.0, WIDE, SWATCH.1)?.fill();
        content.restore_state();
        frame(content, font, (x, 188.0), WIDE, label)?;
        x += WIDE + SWATCH_GAP;
    }
    Ok(())
}

/// Draws the title and the two lines saying what the page is showing.
fn heading(content: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    text(content, font, 15.0, LEFT, 780.0, words.title)?;
    content.save_state();
    content.set_fill(Color::Gray(0.35))?;
    text(content, font, 10.0, LEFT, 762.0, words.intro[0])?;
    text(content, font, 10.0, LEFT, 748.0, words.intro[1])?;
    content.restore_state();
    Ok(())
}

/// Draws the closing note.
fn closing(content: &mut Content, font: &FontHandle, words: &Words) -> Result<(), Error> {
    content.save_state();
    content.set_fill(Color::Gray(0.35))?;
    for (y, line) in [130.0, 116.0, 102.0].iter().zip(words.closing) {
        text(content, font, 9.0, LEFT, *y, line)?;
    }
    content.restore_state();
    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 out = args
        .next()
        .unwrap_or_else(|| language.file_name(&out::default_path("stencil")));
    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 stencil = doc.add_tiling_pattern(stencil()?);
    let in_rgb = doc.add_color_space(PatternSpace::new(DeviceSpace::Rgb)?);
    let in_ink = doc.add_color_space(PatternSpace::new(Separation::ink(
        INK,
        Cmyk::new(0.9, 0.55, 0.0, 0.05),
    ))?);
    let own: Vec<PatternHandle> = OWN
        .iter()
        .map(|color| carried(*color).map(|pattern| doc.add_tiling_pattern(pattern)))
        .collect::<Result<_, _>>()?;

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

    let [colors, tints, their_own] = words.panels;
    panel_heading(&mut content, &font, 706.0, colors[0], colors[1])?;
    in_colors(&mut content, &font, &in_rgb, &stencil)?;

    panel_heading(&mut content, &font, 515.0, tints[0], tints[1])?;
    in_tints(&mut content, &font, words, &in_ink, &stencil)?;

    panel_heading(&mut content, &font, 324.0, their_own[0], their_own[1])?;
    in_their_own(&mut content, &font, words, &own)?;
    closing(&mut content, &font, words)?;

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

    let written = doc.to_bytes()?;
    if let Some(parent) = Path::new(&out).parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(&out, &written)?;
    println!(
        "wrote {out}: {} bytes, {} swatches from {} cells",
        written.len(),
        COLORS.len() + TINTS.len() + OWN.len(),
        own.len() + 1
    );
    Ok(())
}

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

    use super::{
        COLORS, LEFT, OWN, SWATCH, SWATCH_GAP, TINTS, WIDE, WORDS, default_font, language,
    };

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

    /// A4's width, and the room a line that stands over the whole page has.
    const PAGE_WIDTH: f64 = 595.276;
    /// See [`PAGE_WIDTH`].
    const PAPER: f64 = PAGE_WIDTH - LEFT;

    /// The room a caption under one of the narrow swatches has: the swatch, and
    /// the gap to the one beside it.
    const NARROW_ROOM: f64 = SWATCH.0 + SWATCH_GAP;
    /// The same, under one of the wide swatches of the last row.
    const WIDE_ROOM: f64 = WIDE + SWATCH_GAP;

    /// How many swatches the page lays down, and out of how many cells: the
    /// closing note spells both out in words, and no language can work them out
    /// from the page.
    const SWATCHES: usize = 13;
    /// See [`SWATCHES`].
    const CELLS: usize = 4;

    #[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 caption longer than the
    /// swatch it stands under runs into the one beside it, and a line that
    /// stands over nothing runs off the sheet.
    #[test]
    fn every_language_writes_lines_no_wider_than_the_room_they_are_given() {
        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);

        for (named, words) in WORDS {
            let code = named.code();
            let lines = std::iter::once((15.0, words.title.to_owned(), PAPER))
                .chain(words.intro.map(|line| (10.0, line.to_owned(), PAPER)))
                .chain(words.panels.map(|panel| (11.0, panel[0].to_owned(), PAPER)))
                .chain(words.panels.map(|panel| (8.0, panel[1].to_owned(), PAPER)))
                .chain(words.closing.map(|line| (9.0, line.to_owned(), PAPER)))
                .chain(
                    TINTS
                        .iter()
                        .map(|tint| (8.0, words.tint(*tint), NARROW_ROOM)),
                )
                .chain(words.own.map(|line| (8.0, line.to_owned(), WIDE_ROOM)));

            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}"
                );
            }
        }
    }

    /// The closing note counts the swatches and the cells in words, which no
    /// language reads off the page: a row added or dropped leaves every one of
    /// them saying a number the page no longer shows.
    #[test]
    fn the_page_lays_down_the_swatches_its_closing_note_counts() {
        assert_eq!(COLORS.len() + TINTS.len() + OWN.len(), SWATCHES);
        assert_eq!(OWN.len() + 1, CELLS);
    }
}