One hatch, laid down in as many colours as the page asks for

"""One hatch, drawn once, laid down in as many colours as the page asks for.

The Python twin of the `write_stencil_pattern` example in Rust. 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 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: python examples/write_stencil_pattern.py [out.pdf] [font.ttf]
       HQF_PDF_LANG=fr python examples/write_stencil_pattern.py
"""

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path

import _language
import _licence
import _out

import hqf_pdf

# The left edge of everything.
LEFT = 70.0

# The side of one cell of the hatch.
CELL = 10.0

# Half the height of one band of the hatch, measured up the page.
BAND = 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.
BEHIND = -CELL
BEYOND = 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.
COLORS = [
    ([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.
TINTS = [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.
OWN = [
    [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.
INK = "Corporate Blue"


@dataclass(frozen=True)
class Words:
    """Every word the page draws, in one language."""

    # The title over the page.
    title: str
    # The two lines under the title.
    intro: tuple[str, str]
    # The heading of each of the three panels, and the line under it.
    panels: tuple[tuple[str, str], tuple[str, str], tuple[str, str]]
    # What stands in front of the strength on the label of a tinted swatch.
    tint_label: str
    # What is written under each of the three swatches whose pattern carries its own
    # colour.
    own: tuple[str, str, str]
    # The three lines of the closing note.
    closing: tuple[str, str, str]

    def tint(self, tint: float) -> str:
        """What is written under the swatch laid down at `tint`."""
        return f"{self.tint_label}{tint:g}"


# The page in English.
ENGLISH = 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.
FRENCH = 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.
WORDS = {_language.ENGLISH: ENGLISH, _language.FRENCH: FRENCH}

# The size of one swatch of the first two rows, and the gap to the next.
SWATCH = (83.0, 105.0)
SWATCH_GAP = 10.0

# The width of one swatch of the last row, which holds three rather than five.
WIDE = 145.0


def hatch(cell):
    """Lay 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.
    """
    for offset in (-CELL, 0.0, CELL):
        near = BEHIND + offset
        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()
        cell.fill()


def stencil():
    """The hatch as a cell that states no colour of its own."""
    cell = hqf_pdf.Content()
    hatch(cell)
    box = hqf_pdf.Rect(0.0, 0.0, CELL, CELL)
    return hqf_pdf.TilingPattern(cell, box, (CELL, CELL)).uncolored()


def carried(color):
    """The same hatch as a cell that carries `color`."""
    cell = hqf_pdf.Content()
    cell.set_fill(hqf_pdf.Rgb(color[0], color[1], color[2]))
    hatch(cell)
    box = hqf_pdf.Rect(0.0, 0.0, CELL, CELL)
    return hqf_pdf.TilingPattern(cell, box, (CELL, CELL))


def paper(content, x, y, width):
    """Lay the paper of a swatch down."""
    content.save_state()
    content.set_fill(hqf_pdf.Color.gray(0.97))
    content.rect(x, y, width, SWATCH[1])
    content.fill()
    content.restore_state()


def frame(content, font, corner, width, label):
    """Frame a swatch and write what is under it."""
    x, y = corner
    content.save_state()
    content.set_stroke(hqf_pdf.Color.gray(0.55))
    content.set_line_width(0.6)
    content.rect(x, y, width, SWATCH[1])
    content.stroke()
    content.set_fill(hqf_pdf.Color.gray(0.45))
    content.draw_text(font, 8.0, x, y - 12.0, label)
    content.restore_state()


def panel_heading(content, font, y, title, under):
    """Draw one panel's heading, with the line under it."""
    content.save_state()
    content.set_fill(hqf_pdf.Color.gray(0.2))
    content.draw_text(font, 11.0, LEFT, y, title)
    content.set_fill(hqf_pdf.Color.gray(0.45))
    content.draw_text(font, 8.0, LEFT, y - 15.0, under)
    content.restore_state()


def in_colors(content, font, space, pattern):
    """Lay the one stencil down five times across, each in the colour beside it."""
    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, pattern)
        content.rect(x, 570.0, SWATCH[0], SWATCH[1])
        content.fill()
        content.restore_state()
        frame(content, font, (x, 570.0), SWATCH[0], label)
        x += SWATCH[0] + SWATCH_GAP


def in_tints(content, font, words, space, pattern):
    """Lay the same stencil down five times, each a strength of the one ink."""
    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], pattern)
        content.rect(x, 379.0, SWATCH[0], SWATCH[1])
        content.fill()
        content.restore_state()
        frame(content, font, (x, 379.0), SWATCH[0], words.tint(tint))
        x += SWATCH[0] + SWATCH_GAP


def in_their_own(content, font, words, patterns):
    """Lay down three patterns that carry their own colours, one swatch each."""
    x = LEFT
    for pattern, label in zip(patterns, words.own):
        paper(content, x, 188.0, WIDE)
        content.save_state()
        content.set_fill_pattern(pattern)
        content.rect(x, 188.0, WIDE, SWATCH[1])
        content.fill()
        content.restore_state()
        frame(content, font, (x, 188.0), WIDE, label)
        x += WIDE + SWATCH_GAP


def heading(content, font, words):
    """Draw the title and the two lines saying what the page is showing."""
    content.draw_text(font, 15.0, LEFT, 780.0, words.title)
    content.save_state()
    content.set_fill(hqf_pdf.Color.gray(0.35))
    content.draw_text(font, 10.0, LEFT, 762.0, words.intro[0])
    content.draw_text(font, 10.0, LEFT, 748.0, words.intro[1])
    content.restore_state()


def closing(content, font, words):
    """Draw the closing note."""
    content.save_state()
    content.set_fill(hqf_pdf.Color.gray(0.35))
    for y, line in zip((130.0, 116.0, 102.0), words.closing):
        content.draw_text(font, 9.0, LEFT, y, line)
    content.restore_state()


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

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

    document = hqf_pdf.Document()
    document.set_license(_licence.licensed())
    font = document.add_font(hqf_pdf.Font.from_path(_out.font_path()))

    pattern = document.add_tiling_pattern(stencil())
    in_rgb = document.add_color_space(hqf_pdf.PatternSpace(hqf_pdf.DeviceSpace.Rgb))
    ink = hqf_pdf.Separation.ink(INK, hqf_pdf.Cmyk(0.9, 0.55, 0.0, 0.05))
    in_ink = document.add_color_space(hqf_pdf.PatternSpace(ink))
    own = [document.add_tiling_pattern(carried(color)) for color in OWN]

    content = hqf_pdf.Content()
    heading(content, font, words)

    colors, tints, their_own = words.panels
    panel_heading(content, font, 706.0, colors[0], colors[1])
    in_colors(content, font, in_rgb, pattern)

    panel_heading(content, font, 515.0, tints[0], tints[1])
    in_tints(content, font, words, in_ink, pattern)

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

    page = hqf_pdf.Page.a4()
    page.set_content(content)
    document.add_page(page)

    written = document.write(out)
    print(
        f"wrote {out}: {written} bytes, "
        f"{len(COLORS) + len(TINTS) + len(OWN)} swatches from {len(own) + 1} cells"
    )


if __name__ == "__main__":
    main()