#!/usr/bin/env python3
"""Generate the printable suburb posters from one template.

Two orientations per suburb — A4 landscape and A4 portrait (vertical) — each
carrying that suburb's reserved house referral code as a plaque, on two QR codes
(one per audience), and across the tear-off tabs along the bottom. That code is
the same one the weekly summary email tabulates.

The generated .html files are fully self-contained (QR codes are inlined as SVG
paths, the logo is inline SVG, fonts are web-safe), so they need nothing at view
time. Print from a browser at A4 in the matching orientation, "Background
graphics" ON, margins "None" — the page box already carries its own margin.

Regenerating needs `segno` (QR encoding), which is NOT a project dependency:

    python3 -m pip install --target /tmp/pylibs segno
    PYTHONPATH=/tmp/pylibs python3 docs/posters/build_posters.py

Adding a suburb: reserve its code (payments/migrations/0017_reserve_campaign_codes.py),
add an entry to POSTERS below, and re-run.
"""
import pathlib
from string import Template

import segno

BASE = "https://tutorsfirst.com.au"
OUT_DIR = pathlib.Path(__file__).resolve().parent
FEE = "9.90"

# Site palette (templates/base.html :root) plus the lockup's lighter cell navy.
# Three roles, kept strictly separate so the poster reads at a glance:
#   navy  = structure (edge, masthead rule, the families card)
#   green = the tutor side, and the brand's "free/go" positives
#   red   = the code, and only the code (plaque + tear-off tabs)
NAVY = "#1f3a60"
GREEN = "#1f7a44"
SLATE = "#33507a"      # the mark's non-TF cells, as in static/tf-lockup-og
RED = "#c0392b"        # the site's map-slider red
INK = "#1a1a1a"
GREY = "#6b7280"       # the muted "(done fairly)" subtitle
CREAM = "#f7efe1"      # warm paper, carried over from the original poster
RULE = "#d9cbb4"

POSTERS = [
    {"slug": "west-ryde-poster", "suburb": "West Ryde", "code": "WR2114"},
    {"slug": "meadowbank-poster", "suburb": "Meadowbank", "code": "MB2114"},
]

# The 2x2 "confusion matrix" mark, in the same colours as static/tf-lockup-og:
# a navy plate with three slate cells and the TF cell picked out in green. The
# cell labels are dropped — at 14mm they'd be sub-millimetre and print as mud.
LOGO_SVG = f"""<svg viewBox="0 0 120 120" role="img" aria-label="tutorsfirst" class="logo">
  <rect width="120" height="120" fill="{NAVY}"/>
  <rect x="14" y="14" width="42" height="42" fill="{SLATE}"/>
  <rect x="64" y="14" width="42" height="42" fill="{GREEN}"/>
  <rect x="14" y="64" width="42" height="42" fill="{SLATE}"/>
  <rect x="64" y="64" width="42" height="42" fill="{SLATE}"/>
</svg>"""

FAMILY_BULLETS = f"""
        <li><b>Search &amp; message tutors for free.</b> Primary, NAPLAN, OC,
          Selective, HSC; by subject, level and suburb.</li>
        <li><b>One ${FEE} connection fee</b>, only when you want a tutor's contact
          details. No subscription.</li>
        <li><b>Tutors are all ID and Qualification verified</b>, with WWCC where
          appropriate.</li>
        <li><b>One free connection on us</b> with the code below, plus one more for
          every friend you refer. They stack.</li>"""

TUTOR_BULLETS = """
        <li><b>List your ad free</b> and keep <b>100%</b> of your lesson fees. We
          never take a cut of what you teach.</li>
        <li><b>Get found</b> by families near you — search, map and suburb pages.</li>
        <li><b>Earn trust</b> with verified marks, ID and WWCC badges on your ad.</li>
        <li><b>Refer a tutor</b> and you both get a free week of <b>Featured</b>
          placement. Weeks stack.</li>"""


def qr_svg(data, colour=NAVY, label=""):
    """A QR code as a compact, scalable inline SVG (one path, runs of dark modules
    merged per row). No border — the surrounding CSS supplies the quiet zone."""
    qr = segno.make(data, error="m")
    matrix = list(qr.matrix)
    n = len(matrix)
    parts = []
    for y, row in enumerate(matrix):
        x = 0
        while x < n:
            if row[x]:
                run = 0
                while x + run < n and row[x + run]:
                    run += 1
                parts.append(f"M{x} {y}h{run}v1h-{run}z")
                x += run
            else:
                x += 1
    aria = f' role="img" aria-label="{label}"' if label else ' aria-hidden="true"'
    return (f'<svg viewBox="0 0 {n} {n}"{aria} class="qr">'
            f'<path d="{"".join(parts)}" fill="{colour}"/></svg>')


TEMPLATE = Template("""<!doctype html>
<html lang="en-au">
<head>
<meta charset="utf-8">
<title>tutorsfirst — $suburb poster ($code, $orient_name)</title>
<style>
  /* ---- Print geometry: A4 $orient_name, edge-to-edge colour --------------- */
  @page { size: A4 $orient_css; margin: 0; }
  * { box-sizing: border-box; }
  html, body { margin: 0; padding: 0; }
  body {
    font-family: -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
    color: $ink; background: #888;
  }
  .sheet {
    width: $sheet_w; height: $sheet_h; background: $cream;
    margin: 0 auto; padding: 0; overflow: hidden;
    display: flex; flex-direction: column;
    -webkit-print-color-adjust: exact; print-color-adjust: exact;
  }
  @media print { body { background: none; } .sheet { margin: 0; } }
  @media screen { .sheet { margin: 12px auto; box-shadow: 0 4px 22px rgba(0,0,0,.35); } }

  /* ---- Masthead ----------------------------------------------------------- */
  /* A solid navy edge carries the poster across a room; the lockup itself sits on
     the page in its own colours (green t/f, navy body) rather than knocked out
     white, so it matches static/tf-lockup-og. */
  .edge { height: 6mm; background: $navy; flex: 0 0 auto; }
  .top {
    padding: 4mm $pad 3.5mm; border-bottom: 2.5pt solid $navy;
    display: flex; align-items: center; gap: 6mm; flex: 0 0 auto;
  }
  .logo { width: 14mm; height: 14mm; flex: none; }
  .wordmark { font-family: Georgia, "Times New Roman", serif; font-size: $wordmark_fs;
              font-weight: 700; letter-spacing: -.3pt; line-height: 1; color: $navy; }
  .wordmark .t, .wordmark .f { color: $green; }
  .tagline { margin-left: auto; text-align: right; font-size: 12pt;
             line-height: 1.25; color: $grey; }
  .tagline strong { color: $navy; display: block; font-size: 14.5pt; }

  /* ---- Headline: suburb flush left, "done fairly" flush right ------------- */
  .head { padding: 4mm $pad 2mm; flex: 0 0 auto; }
  .head h1 { font-family: Georgia, "Times New Roman", serif; margin: 0;
             font-size: $h1_fs; line-height: 1.04; color: $navy;
             letter-spacing: -.5pt;
             display: flex; $h1_flow gap: 2mm 8mm; }
  .head h1 em { font-style: normal; color: $green; }
  /* A quiet parenthetical aside, not a second headline — small and grey, so the
     suburb keeps the whole of the eye. */
  .head h1 .kicker { $kicker_align white-space: nowrap; font-size: $kicker_fs;
                     color: $grey; font-weight: 400; letter-spacing: 0; }
  .head h1 .kicker i { font-style: italic; }
  .head p { margin: 2mm 0 0; font-size: 12pt; color: #4a4a4a; }

  /* ---- The two audiences, equal billing ----------------------------------- */
  /* The cards grow to fill the page's free space; the fixed .gap after them then
     stays exactly its own height, opening a clear, constant band between the cards
     and the dashed code plaque (a plain margin gets absorbed by the growing cards).
     min-height:0 lets it all shrink gracefully if a suburb name ever runs long. */
  .cols { display: grid; grid-template-columns: $cols_tpl; gap: $cols_gap;
          padding: 0 $pad; flex: 1 1 auto; min-height: 0; }
  .gap { flex: 0 0 auto; height: 4.5mm; }
  .card { border: 1.4pt solid $navy; background: #fff; padding: 3.5mm 4.5mm;
          display: flex; flex-direction: column; min-height: 0; overflow: hidden; }
  .card.green { border-color: $green; }
  .card h2 { font-size: 11.5pt; letter-spacing: 1.4pt; text-transform: uppercase;
             color: #fff; background: $navy; padding: 1.8mm 3mm;
             margin: -4mm -4.5mm 3mm; }
  .card.green h2 { background: $green; }
  .card ul { margin: 0; padding-left: 5mm; font-size: $li_fs; line-height: 1.4; }
  .card li { margin: 0 0 1mm; }
  .card li b { color: $navy; }
  .card.green li b { color: $green; }
  .cta { margin-top: auto; display: flex; align-items: center; gap: 3.5mm;
         padding-top: 2mm; }
  .qr { width: $qr_size; height: $qr_size; flex: none; background: #fff; }
  .cta-txt { font-size: 11pt; line-height: 1.3; }
  .cta-txt strong { display: block; font-size: 13pt; color: $navy; }
  .card.green .cta-txt strong { color: $green; }

  /* ---- Code plaque -------------------------------------------------------- */
  /* Red is reserved for the code — the plaque and the tabs that carry it away. */
  .codebar { display: flex; align-items: center; gap: 5mm; margin: 0 $pad 2.5mm;
             padding: 3mm 5mm; border: 1.8pt dashed $red; background: #fff;
             flex: 0 0 auto; }
  .codebar .lbl { font-size: 11pt; text-transform: uppercase; letter-spacing: 1.6pt;
                  color: $grey; line-height: 1.2; }
  .codebar .code { font-size: $code_fs; font-weight: 700; letter-spacing: 4pt;
                   color: $red; line-height: 1; white-space: nowrap; }
  .codebar .perk { font-size: 11pt; line-height: 1.35; border-left: 1pt solid $rule;
                   padding-left: 4.5mm; }
  .codebar .perk b { color: $navy; }

  /* ---- Tear-off tabs ------------------------------------------------------ */
  /* Two vertical runs per tab (code + domain) so neither is long enough to spill
     past the strip; overflow:hidden is the backstop if a font renders wider. */
  .tabs { display: flex; height: $tabs_h; margin: 0 8mm 5mm; flex: 0 0 auto;
          overflow: hidden; }
  .tab { flex: 1; border-left: 1pt dashed #999; display: flex; align-items: center;
         justify-content: center; gap: 1mm; overflow: hidden; }
  .tab:last-child { border-right: 1pt dashed #999; }
  .tab span { writing-mode: vertical-rl; transform: rotate(180deg);
              white-space: nowrap; }
  .tab .c { font-size: 15pt; font-weight: 700; letter-spacing: 2.2pt; color: $red; }
  .tab .d { font-size: 8.5pt; letter-spacing: .6pt; color: $navy; }
</style>
</head>
<body>
<div class="sheet">

  <div class="edge"></div>
  <div class="top">
    $logo
    <div class="wordmark"><span class="t">t</span>utors<span class="f">f</span>irst</div>
    <div class="tagline"><strong>An efficient &amp; fair marketplace</strong>
      tutorsfirst.com.au</div>
  </div>

  <div class="head">
    <h1><span class="lead">Tutoring in <em>$suburb</em></span><span class="kicker">(done <i>fairly</i>)</span></h1>
    <p>Browse local, verified tutors for free. Tutors keep 100% of what they earn.
      No subscriptions, no lesson commissions.</p>
  </div>

  <div class="cols">
    <div class="card">
      <h2>Looking for a tutor</h2>
      <ul>$family_bullets
      </ul>
      <div class="cta">
        $qr_family
        <div class="cta-txt"><strong>Scan to register</strong>
          as a student or parent — the code is applied for you.</div>
      </div>
    </div>

    <div class="card green">
      <h2>Are you a tutor?</h2>
      <ul>$tutor_bullets
      </ul>
      <div class="cta">
        $qr_tutor
        <div class="cta-txt"><strong>Scan to list</strong>
          your tutoring — free, reviewed within a business day.</div>
      </div>
    </div>
  </div>

  <div class="gap"></div>

  <div class="codebar">
    <div class="lbl">Use<br>code</div>
    <div class="code">$code</div>
    <div class="perk"><b>Students &amp; parents:</b> your first connection is free.<br>
      <b>Tutors:</b> a free week of Featured placement once you're approved.</div>
  </div>

  <div class="tabs">
    $tabs
  </div>

</div>
</body>
</html>
""")

# Per-orientation geometry. Landscape sits the two audience cards side by side;
# portrait stacks them and drops the headline kicker onto its own flush-right line.
ORIENTATIONS = {
    "landscape": dict(
        suffix="", orient_css="landscape", orient_name="landscape",
        sheet_w="297mm", sheet_h="210mm", pad="10mm",
        wordmark_fs="30pt", h1_fs="33pt", li_fs="11.5pt", qr_size="23mm",
        code_fs="30pt", cols_tpl="1fr 1fr", cols_gap="5mm", n_tabs=14,
        kicker_fs="15pt",
        tabs_h="30mm",
        h1_flow="align-items: baseline; justify-content: space-between;",
        kicker_align="",
    ),
    "portrait": dict(
        suffix="-portrait", orient_css="portrait", orient_name="portrait (vertical)",
        sheet_w="210mm", sheet_h="297mm", pad="12mm",
        wordmark_fs="27pt", h1_fs="31pt", li_fs="11.5pt", qr_size="23mm",
        code_fs="32pt", cols_tpl="1fr", cols_gap="5mm", n_tabs=10,
        kicker_fs="15pt",
        tabs_h="28mm",
        # Portrait is too narrow to sit the aside beside the suburb, so it drops to
        # its own line, flush right. (Landscape shares the headline's baseline.)
        h1_flow="flex-direction: column;",
        kicker_align="align-self: flex-end;",
    ),
}


def build(poster, orient):
    o = ORIENTATIONS[orient]
    code, suburb = poster["code"], poster["suburb"]
    tab = (f'<div class="tab"><span class="c">{code}</span>'
           f'<span class="d">tutorsfirst.com.au</span></div>')
    html = TEMPLATE.substitute(
        suburb=suburb, code=code, logo=LOGO_SVG,
        navy=NAVY, green=GREEN, ink=INK, cream=CREAM, rule=RULE,
        red=RED, grey=GREY, slate=SLATE,
        family_bullets=FAMILY_BULLETS, tutor_bullets=TUTOR_BULLETS,
        qr_family=qr_svg(f"{BASE}/accounts/signup/student/?ref={code}",
                         label=f"Register as a student or parent with code {code}"),
        qr_tutor=qr_svg(f"{BASE}/accounts/signup/tutor/?ref={code}",
                        label=f"List as a tutor with code {code}"),
        tabs="\n    ".join([tab] * o["n_tabs"]),
        **{k: v for k, v in o.items() if k not in ("suffix", "n_tabs")},
    )
    path = OUT_DIR / f"{poster['slug']}{o['suffix']}.html"
    path.write_text(html, encoding="utf-8")
    return path


# Headless Chrome is the only renderer here that honours @page + print colours,
# so the PDFs are produced from the very same HTML rather than a parallel layout.
CHROME_CANDIDATES = [
    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
    "/Applications/Chromium.app/Contents/MacOS/Chromium",
    "/usr/bin/google-chrome", "/usr/bin/chromium", "/usr/bin/chromium-browser",
]


def _chrome():
    import shutil
    for c in CHROME_CANDIDATES:
        if pathlib.Path(c).exists():
            return c
    return shutil.which("google-chrome") or shutil.which("chromium")


def to_pdf(html_path):
    """Print a poster to PDF beside its HTML. Returns None if Chrome isn't around."""
    import subprocess
    chrome = _chrome()
    if chrome is None:
        return None
    pdf_path = html_path.with_suffix(".pdf")
    subprocess.run(
        [chrome, "--headless", "--disable-gpu", "--no-sandbox",
         "--no-pdf-header-footer", f"--print-to-pdf={pdf_path}",
         html_path.as_uri()],
        check=True, capture_output=True)
    return pdf_path


if __name__ == "__main__":
    import sys
    want_pdf = "--no-pdf" not in sys.argv
    for p in POSTERS:
        for orient in ORIENTATIONS:
            path = build(p, orient)
            print("wrote", path)
            if want_pdf:
                pdf = to_pdf(path)
                print("wrote", pdf) if pdf else print(
                    "  (skipped PDF — no Chrome/Chromium found)")