#!/usr/bin/env python3
"""tools/anki-deck-periodic.py — Generate periodic table Anki decks (.apkg)
with Anki's built-in type-the-answer input and Piper (offline, local
neural TTS) audio on both sides. See tools/anki-deck-math.py's docstring
for one-time setup (venv, genanki + piper-tts, downloading a voice) — same
steps apply here, this is a standalone, self-contained script otherwise.

Decks:
    prehs       symbol<->name, elements 1-36 (H through Kr)
    hs          symbol<->name plus number->symbol, all 118 elements
    category    element category as multiple choice (A/B/C/D shown as
                plain text options — not a clickable UI, since that needs
                a desktop-only Anki add-on and would break on
                AnkiDroid/AnkiMobile), type the letter — only elements
                with a confirmed category (excludes 8 very recent
                superheavy elements whose category is still officially
                unconfirmed)

Element photos on prehs/hs: every card (symbol->name, name->symbol,
number->symbol alike) also shows a real photo of the element, fetched
once from Wikipedia's own MediaWiki API (the same "pageimage" shown in
that element's infobox — the well-documented, standard
`action=query&prop=pageimages` endpoint on en.wikipedia.org, not a
guessed URL) and cached locally under tools/periodic_images/ so reruns
don't re-download. This is the one part of this repo's Anki tooling that
needs internet access at generation time — every other deck (math,
shapes/clocks/currency, TTS audio) is fully offline. Pass --no-images to
skip this and get the old text-only prehs/hs cards back.

Elements 100 (Fermium) through 118 (Oganesson) are hard-excluded from
this — every atom of these ever made has been produced (or claimed) one
at a time in a particle accelerator and never existed in macroscopic,
visible quantity, so no real sample photo exists to fetch; anything
Wikipedia's pageimage API returned for them would be a diagram or a
scientist's portrait, not the element. A couple of element names collide
with a more famous Wikipedia topic under the same plain title (Mercury
the planet, for one) — TITLE_OVERRIDES below is the fix-up list; if a
generated card shows an obviously wrong photo for some element, that's
almost certainly another one of these collisions — add it there.

Batched and rate-limited on purpose: metadata lookups (which element has
which photo) go out up to 50 titles per request, not one request per
element, and every HTTP call retries with backoff on a 429 (honoring
Wikipedia's own Retry-After header when it sends one). The first version
of this fetched one element at a time with no delay between requests and
got rate-limited by Wikimedia on a real run — this replaced it.

Caveat: this was written and tested without live access to Wikipedia
(sandboxed here with no route to en.wikipedia.org) — exercised
structurally (see --dry-run-tts), the redirect/normalization-chain
resolution logic and the 429-retry path both unit-tested against
simulated responses, but never against the real API's actual response
shape or real image content. Skips are per-element and non-fatal — one
bad/missing photo won't abort the rest of the deck — and every fetch
attempt prints what it did, so check that output the first time you
actually run this deck for real.

Element data: Bowserinator/Periodic-Table-JSON (a widely used, actively
maintained public dataset), fetched and spot-checked against known facts
before being embedded below — not typed from memory.

Usage (run with the venv from anki-deck-math.py's docstring activated;
also needs `pip install pillow` for resizing fetched photos):
    python3 anki-deck-periodic.py --deck prehs
    python3 anki-deck-periodic.py --deck hs
    python3 anki-deck-periodic.py --deck hs --no-images
    python3 anki-deck-periodic.py --deck category
(add --voice en_US-amy-medium etc.; --model-path if a voice isn't found
automatically; --dry-run-tts to test the deck-building logic without any
voice model OR network access at all, using silent placeholder audio and
a placeholder image)
"""
import argparse
import hashlib
import io
import genanki
import json
import os
import random
import subprocess
import time
import urllib.error
import urllib.parse
import urllib.request

from PIL import Image

parser = argparse.ArgumentParser()
parser.add_argument("--deck", required=True, choices=["prehs", "hs", "category"])
parser.add_argument("--voice", default="en_US-lessac-medium")
parser.add_argument("--model-path", default=None)
parser.add_argument("--dry-run-tts", action="store_true")
parser.add_argument("--no-images", action="store_true",
                     help="prehs/hs only: skip fetching element photos, keep the old text-only cards")
args = parser.parse_args()

SCRATCH = os.path.dirname(os.path.abspath(__file__))
IMAGE_CACHE = os.path.join(SCRATCH, "periodic_images")
os.makedirs(IMAGE_CACHE, exist_ok=True)

# Elements with no macroscopic sample ever produced — see the docstring.
NO_PHOTO_NUMBERS = set(range(100, 119))

# Element names whose plain Wikipedia article title is a different, more
# famous topic — see the docstring. Add to this if a generated card shows
# an obviously wrong photo for some element.
TITLE_OVERRIDES = {"Hg": "Mercury (element)"}


USER_AGENT = "anki-deck-periodic.py/1.0 (personal Anki deck generator, run locally by its owner)"


def http_get_with_retry(url, max_retries=5):
    """GET with retry-on-429: honors a numeric Retry-After header if
    Wikipedia sends one, otherwise backs off 5s * attempt. Returns the raw
    response bytes, or None if every attempt failed — never raises, since
    one element's fetch failing must not abort the whole deck build."""
    headers = {"User-Agent": USER_AGENT}
    for attempt in range(1, max_retries + 1):
        try:
            req = urllib.request.Request(url, headers=headers)
            with urllib.request.urlopen(req, timeout=20) as resp:
                return resp.read()
        except urllib.error.HTTPError as e:
            if e.code == 429 and attempt < max_retries:
                wait = 5 * attempt
                retry_after = e.headers.get("Retry-After") if e.headers else None
                if retry_after and retry_after.isdigit():
                    wait = int(retry_after)
                print(f"  (rate limited, waiting {wait}s before retry {attempt}/{max_retries})")
                time.sleep(wait)
                continue
            print(f"  (request failed: {e})")
            return None
        except (urllib.error.URLError, OSError, ValueError) as e:
            print(f"  (request failed: {e})")
            return None
    return None


def resolve_pageimage_urls(pairs):
    """pairs: list of (symbol, wikipedia_title). Batches lookups — up to
    50 titles per MediaWiki query, the documented anonymous-access limit —
    instead of one API call per element; a tight one-request-per-element
    loop is exactly what triggered Wikipedia's rate limiting on a real
    run. Requests thumbnails (piprop=thumbnail), not full-resolution
    originals, per Wikimedia's own guidance on their 429 response. Returns
    {symbol: thumbnail_url} for whichever elements actually have one."""
    result = {}
    CHUNK = 50
    for i in range(0, len(pairs), CHUNK):
        chunk = pairs[i:i + CHUNK]
        symbol_by_title = {title: symbol for symbol, title in chunk}
        titles_param = "|".join(title for _, title in chunk)
        api_url = ("https://en.wikipedia.org/w/api.php?action=query&format=json"
                   "&prop=pageimages&piprop=thumbnail&pithumbsize=300&redirects=1&titles="
                   + urllib.parse.quote(titles_param))
        raw = http_get_with_retry(api_url)
        if raw is None:
            continue
        data = json.loads(raw)
        query = data.get("query", {})

        # "pages" below is keyed by pageid with only the *final* resolved
        # title on it, so build a title-at-this-point -> original-input-
        # title map and walk it forward through each normalized/redirect
        # step, re-keying as the title changes, to reach the same result.
        input_of_title = {title: title for _, title in chunk}
        for step in query.get("normalized", []) + query.get("redirects", []):
            frm, to = step["from"], step["to"]
            if frm in input_of_title:
                input_of_title[to] = input_of_title.pop(frm)

        for page in query.get("pages", {}).values():
            final_title = page.get("title")
            input_title = input_of_title.get(final_title, final_title)
            symbol = symbol_by_title.get(input_title)
            if symbol is None:
                continue
            thumb_url = page.get("thumbnail", {}).get("source")
            if thumb_url:
                result[symbol] = thumb_url
        if i + CHUNK < len(pairs):
            time.sleep(1)  # be polite between batches
    return result


def download_element_photos(url_map):
    """url_map: {symbol: thumbnail_url}. Downloads each into
    periodic_images/, one request at a time with a short gap between —
    the metadata lookups above are batched, but the actual image bytes
    still need one HTTP request per element, and Wikimedia's upload
    servers rate-limit that too if hit back-to-back with no gap."""
    for symbol, url in url_map.items():
        cache_path = os.path.join(IMAGE_CACHE, f"{symbol}.jpg")
        if os.path.isfile(cache_path):
            continue
        raw = http_get_with_retry(url)
        if raw is None:
            print(f"  (photo download failed for {symbol})")
            continue
        try:
            img = Image.open(io.BytesIO(raw)).convert("RGB")
            img.thumbnail((300, 300))
            img.save(cache_path, "JPEG", quality=85)
            print(f"  fetched photo for {symbol}")
        except OSError as e:
            print(f"  (photo decode failed for {symbol}: {e})")
        time.sleep(0.5)


def ensure_element_photos(elements):
    """Call once per deck, before building any notes: makes sure every
    eligible element (not --no-images, not NO_PHOTO_NUMBERS, not already
    cached) has its photo downloaded into periodic_images/ up front —
    batched and rate-limited, rather than the old one-request-per-card
    approach that got 429'd on a real run. element_image_html() below then
    only ever reads the cache; it makes no network calls itself."""
    if args.no_images:
        return
    needed = [(symbol, name) for number, symbol, name, _cat in elements
              if number not in NO_PHOTO_NUMBERS
              and not os.path.isfile(os.path.join(IMAGE_CACHE, f"{symbol}.jpg"))]
    if not needed:
        return

    if args.dry_run_tts:
        # No real network call in dry-run mode — a flat placeholder lets the
        # rest of the pipeline (HTML wiring, media_files list, .apkg
        # packaging) still be exercised end-to-end without it.
        for symbol, _name in needed:
            cache_path = os.path.join(IMAGE_CACHE, f"{symbol}.jpg")
            Image.new("RGB", (100, 100), (190, 190, 190)).save(cache_path, "JPEG")
        return

    pairs = [(symbol, TITLE_OVERRIDES.get(symbol, name)) for symbol, name in needed]
    print(f"Fetching {len(pairs)} element photo(s) from Wikipedia (batched, rate-limited)...")
    url_map = resolve_pageimage_urls(pairs)
    for symbol, _title in pairs:
        if symbol not in url_map:
            print(f"  (no photo found for {symbol})")
    download_element_photos(url_map)

_CANDIDATES = [
    args.model_path,
    f"{args.voice}.onnx",
    os.path.join(SCRATCH, f"{args.voice}.onnx"),
    os.path.expanduser(f"~/{args.voice}.onnx"),
    os.path.expanduser(f"~/.local/share/piper/voices/{args.voice}.onnx"),
]
VOICE_MODEL = next((p for p in _CANDIDATES if p and os.path.isfile(p)), None)

if VOICE_MODEL is None and not args.dry_run_tts:
    raise SystemExit(
        f"Voice model for '{args.voice}' not found. Checked:\n"
        + "\n".join(f"  {p}" for p in _CANDIDATES if p)
        + f"\n\nFind it with: find / -iname '{args.voice}.onnx' 2>/dev/null"
        + "\nThen pass its exact path with --model-path /the/real/path.onnx"
        + "\n(or pass --dry-run-tts to test deck-building without any voice at all)"
    )


def piper_tts(text: str, out_path: str) -> None:
    if args.dry_run_tts:
        with open(out_path, "wb") as f:
            f.write(
                b"RIFF$\x00\x00\x00WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00"
                b"\x22\x56\x00\x00\x44\xac\x00\x00\x02\x00\x10\x00data\x00\x00\x00\x00"
            )
        return
    subprocess.run(
        ["python3", "-m", "piper", "-m", VOICE_MODEL, "-f", out_path],
        input=text.encode("utf-8"),
        check=True,
        capture_output=True,
    )


ONES = ["zero", "one", "two", "three", "four", "five", "six", "seven",
        "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",
        "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
        "eighty", "ninety"]


def num2words(n):
    if n < 20:
        return ONES[n]
    if n < 100:
        t, o = divmod(n, 10)
        return TENS[t] + ("-" + ONES[o] if o else "")
    h, rem = divmod(n, 100)
    return ONES[h] + " hundred" + (" " + num2words(rem) if rem else "")


assert num2words(1) == "one"
assert num2words(26) == "twenty-six"
assert num2words(118) == "one hundred eighteen"

# ─── Element data: (atomic_number, symbol, name, category-or-None) ─────────
# category is None for the 8 most recently synthesized superheavy elements
# whose chemical category is still officially unconfirmed (excluded from
# the category deck below, still included in prehs/hs symbol/name/number).
ELEMENTS = [
    (1, 'H', 'Hydrogen', 'diatomic nonmetal'),
    (2, 'He', 'Helium', 'noble gas'),
    (3, 'Li', 'Lithium', 'alkali metal'),
    (4, 'Be', 'Beryllium', 'alkaline earth metal'),
    (5, 'B', 'Boron', 'metalloid'),
    (6, 'C', 'Carbon', 'polyatomic nonmetal'),
    (7, 'N', 'Nitrogen', 'diatomic nonmetal'),
    (8, 'O', 'Oxygen', 'diatomic nonmetal'),
    (9, 'F', 'Fluorine', 'diatomic nonmetal'),
    (10, 'Ne', 'Neon', 'noble gas'),
    (11, 'Na', 'Sodium', 'alkali metal'),
    (12, 'Mg', 'Magnesium', 'alkaline earth metal'),
    (13, 'Al', 'Aluminium', 'post-transition metal'),
    (14, 'Si', 'Silicon', 'metalloid'),
    (15, 'P', 'Phosphorus', 'polyatomic nonmetal'),
    (16, 'S', 'Sulfur', 'polyatomic nonmetal'),
    (17, 'Cl', 'Chlorine', 'diatomic nonmetal'),
    (18, 'Ar', 'Argon', 'noble gas'),
    (19, 'K', 'Potassium', 'alkali metal'),
    (20, 'Ca', 'Calcium', 'alkaline earth metal'),
    (21, 'Sc', 'Scandium', 'transition metal'),
    (22, 'Ti', 'Titanium', 'transition metal'),
    (23, 'V', 'Vanadium', 'transition metal'),
    (24, 'Cr', 'Chromium', 'transition metal'),
    (25, 'Mn', 'Manganese', 'transition metal'),
    (26, 'Fe', 'Iron', 'transition metal'),
    (27, 'Co', 'Cobalt', 'transition metal'),
    (28, 'Ni', 'Nickel', 'transition metal'),
    (29, 'Cu', 'Copper', 'transition metal'),
    (30, 'Zn', 'Zinc', 'transition metal'),
    (31, 'Ga', 'Gallium', 'post-transition metal'),
    (32, 'Ge', 'Germanium', 'metalloid'),
    (33, 'As', 'Arsenic', 'metalloid'),
    (34, 'Se', 'Selenium', 'polyatomic nonmetal'),
    (35, 'Br', 'Bromine', 'diatomic nonmetal'),
    (36, 'Kr', 'Krypton', 'noble gas'),
    (37, 'Rb', 'Rubidium', 'alkali metal'),
    (38, 'Sr', 'Strontium', 'alkaline earth metal'),
    (39, 'Y', 'Yttrium', 'transition metal'),
    (40, 'Zr', 'Zirconium', 'transition metal'),
    (41, 'Nb', 'Niobium', 'transition metal'),
    (42, 'Mo', 'Molybdenum', 'transition metal'),
    (43, 'Tc', 'Technetium', 'transition metal'),
    (44, 'Ru', 'Ruthenium', 'transition metal'),
    (45, 'Rh', 'Rhodium', 'transition metal'),
    (46, 'Pd', 'Palladium', 'transition metal'),
    (47, 'Ag', 'Silver', 'transition metal'),
    (48, 'Cd', 'Cadmium', 'transition metal'),
    (49, 'In', 'Indium', 'post-transition metal'),
    (50, 'Sn', 'Tin', 'post-transition metal'),
    (51, 'Sb', 'Antimony', 'metalloid'),
    (52, 'Te', 'Tellurium', 'metalloid'),
    (53, 'I', 'Iodine', 'diatomic nonmetal'),
    (54, 'Xe', 'Xenon', 'noble gas'),
    (55, 'Cs', 'Cesium', 'alkali metal'),
    (56, 'Ba', 'Barium', 'alkaline earth metal'),
    (57, 'La', 'Lanthanum', 'lanthanide'),
    (58, 'Ce', 'Cerium', 'lanthanide'),
    (59, 'Pr', 'Praseodymium', 'lanthanide'),
    (60, 'Nd', 'Neodymium', 'lanthanide'),
    (61, 'Pm', 'Promethium', 'lanthanide'),
    (62, 'Sm', 'Samarium', 'lanthanide'),
    (63, 'Eu', 'Europium', 'lanthanide'),
    (64, 'Gd', 'Gadolinium', 'lanthanide'),
    (65, 'Tb', 'Terbium', 'lanthanide'),
    (66, 'Dy', 'Dysprosium', 'lanthanide'),
    (67, 'Ho', 'Holmium', 'lanthanide'),
    (68, 'Er', 'Erbium', 'lanthanide'),
    (69, 'Tm', 'Thulium', 'lanthanide'),
    (70, 'Yb', 'Ytterbium', 'lanthanide'),
    (71, 'Lu', 'Lutetium', 'lanthanide'),
    (72, 'Hf', 'Hafnium', 'transition metal'),
    (73, 'Ta', 'Tantalum', 'transition metal'),
    (74, 'W', 'Tungsten', 'transition metal'),
    (75, 'Re', 'Rhenium', 'transition metal'),
    (76, 'Os', 'Osmium', 'transition metal'),
    (77, 'Ir', 'Iridium', 'transition metal'),
    (78, 'Pt', 'Platinum', 'transition metal'),
    (79, 'Au', 'Gold', 'transition metal'),
    (80, 'Hg', 'Mercury', 'transition metal'),
    (81, 'Tl', 'Thallium', 'post-transition metal'),
    (82, 'Pb', 'Lead', 'post-transition metal'),
    (83, 'Bi', 'Bismuth', 'post-transition metal'),
    (84, 'Po', 'Polonium', 'post-transition metal'),
    (85, 'At', 'Astatine', 'diatomic nonmetal'),
    (86, 'Rn', 'Radon', 'noble gas'),
    (87, 'Fr', 'Francium', 'alkali metal'),
    (88, 'Ra', 'Radium', 'alkaline earth metal'),
    (89, 'Ac', 'Actinium', 'actinide'),
    (90, 'Th', 'Thorium', 'actinide'),
    (91, 'Pa', 'Protactinium', 'actinide'),
    (92, 'U', 'Uranium', 'actinide'),
    (93, 'Np', 'Neptunium', 'actinide'),
    (94, 'Pu', 'Plutonium', 'actinide'),
    (95, 'Am', 'Americium', 'actinide'),
    (96, 'Cm', 'Curium', 'actinide'),
    (97, 'Bk', 'Berkelium', 'actinide'),
    (98, 'Cf', 'Californium', 'actinide'),
    (99, 'Es', 'Einsteinium', 'actinide'),
    (100, 'Fm', 'Fermium', 'actinide'),
    (101, 'Md', 'Mendelevium', 'actinide'),
    (102, 'No', 'Nobelium', 'actinide'),
    (103, 'Lr', 'Lawrencium', 'actinide'),
    (104, 'Rf', 'Rutherfordium', 'transition metal'),
    (105, 'Db', 'Dubnium', 'transition metal'),
    (106, 'Sg', 'Seaborgium', 'transition metal'),
    (107, 'Bh', 'Bohrium', 'transition metal'),
    (108, 'Hs', 'Hassium', 'transition metal'),
    (109, 'Mt', 'Meitnerium', None),
    (110, 'Ds', 'Darmstadtium', None),
    (111, 'Rg', 'Roentgenium', None),
    (112, 'Cn', 'Copernicium', None),
    (113, 'Nh', 'Nihonium', 'post-transition metal'),
    (114, 'Fl', 'Flerovium', 'post-transition metal'),
    (115, 'Mc', 'Moscovium', None),
    (116, 'Lv', 'Livermorium', None),
    (117, 'Ts', 'Tennessine', None),
    (118, 'Og', 'Oganesson', None),
]
assert len(ELEMENTS) == 118
assert [e[0] for e in ELEMENTS] == list(range(1, 119))
assert ELEMENTS[0] == (1, 'H', 'Hydrogen', 'diatomic nonmetal')
assert ELEMENTS[25] == (26, 'Fe', 'Iron', 'transition metal')
assert ELEMENTS[-1] == (118, 'Og', 'Oganesson', None)

ALL_CATEGORIES = sorted({e[3] for e in ELEMENTS if e[3] is not None})


def build_model(deck_key):
    voice_hash = int(hashlib.sha256(f"{deck_key}:{args.voice}".encode()).hexdigest(), 16)
    model_id = 1_700_000_000 + (voice_hash % 90_000_000)
    return model_id, genanki.Model(
        model_id,
        f"Periodic Table ({deck_key}, {args.voice})",
        fields=[{"name": "Prompt"}, {"name": "Answer"}, {"name": "QSound"}, {"name": "ASound"}],
        templates=[{
            "name": "Card",
            "qfmt": """
<div class="prompt">{{Prompt}}</div>
{{QSound}}
{{type:Answer}}
""",
            "afmt": """
<div class="prompt">{{Prompt}}</div>
<hr id="answer">
{{type:Answer}}
{{ASound}}
""",
        }],
        css="""
.card { font-family: Arial, sans-serif; font-size: 26px; text-align: center; }
.prompt { font-size: 40px; margin: 20px auto; white-space: pre-line; }
.elem-img { max-width: 220px; max-height: 220px; display: block; margin: 0 auto 10px; }
""",
    )


def build_deck(deck_key, deck_title):
    voice_hash = int(hashlib.sha256(f"{deck_key}:{args.voice}".encode()).hexdigest(), 16)
    deck_id = 2_100_000_000 + (voice_hash % 90_000_000)
    return genanki.Deck(deck_id, deck_title)


def element_image_html(number, symbol, media_files):
    """Returns an <img> tag for this element's cached photo, or "" if
    --no-images was passed, the element is in NO_PHOTO_NUMBERS, or no
    photo was found/downloaded for it. Reads the cache only — every
    network call happens up front in ensure_element_photos(), once per
    deck, not per card."""
    if args.no_images or number in NO_PHOTO_NUMBERS:
        return ""
    cache_path = os.path.join(IMAGE_CACHE, f"{symbol}.jpg")
    if not os.path.isfile(cache_path):
        return ""
    if cache_path not in media_files:
        media_files.append(cache_path)
    return f'<img class="elem-img" src="{os.path.basename(cache_path)}">'


def add_note(deck, model, prompt, answer, qtext, atext, media_files, tag):
    qfile = f"q_{tag}.wav"
    afile = f"a_{tag}.wav"
    qpath = os.path.join(MEDIA_DIR, qfile)
    apath = os.path.join(MEDIA_DIR, afile)
    piper_tts(qtext, qpath)
    piper_tts(atext, apath)
    media_files += [qpath, apath]
    deck.add_note(genanki.Note(
        model=model,
        fields=[prompt, answer, f"[sound:{qfile}]", f"[sound:{afile}]"],
    ))


def gen_prehs():
    deck_key = "periodic_prehs"
    model_id, model = build_model(deck_key)
    deck = build_deck(deck_key, "Periodic Table: Symbols & Names (1-36)")
    media_files = []
    subset = [e for e in ELEMENTS if e[0] <= 36]
    ensure_element_photos(subset)
    cards = []
    for number, symbol, name, category in subset:
        cards.append(("symbol_to_name", number, symbol, name))
        cards.append(("name_to_symbol", number, symbol, name))
    random.seed(50)
    random.shuffle(cards)
    for kind, number, symbol, name in cards:
        img = element_image_html(number, symbol, media_files)
        if kind == "symbol_to_name":
            add_note(deck, model, img + symbol, name,
                      f"What element has the symbol {symbol}?", name,
                      media_files, f"prehs_s2n_{number}")
        else:
            add_note(deck, model, img + name, symbol,
                      f"What is the symbol for {name}?", symbol,
                      media_files, f"prehs_n2s_{number}")
    return deck, media_files, len(cards)


def gen_hs():
    deck_key = "periodic_hs"
    model_id, model = build_model(deck_key)
    deck = build_deck(deck_key, "Periodic Table: Symbols, Names & Numbers (1-118)")
    media_files = []
    ensure_element_photos(ELEMENTS)
    cards = []
    for number, symbol, name, category in ELEMENTS:
        cards.append(("symbol_to_name", number, symbol, name))
        cards.append(("name_to_symbol", number, symbol, name))
        cards.append(("number_to_symbol", number, symbol, name))
    random.seed(51)
    random.shuffle(cards)
    for kind, number, symbol, name in cards:
        img = element_image_html(number, symbol, media_files)
        if kind == "symbol_to_name":
            add_note(deck, model, img + symbol, name,
                      f"What element has the symbol {symbol}?", name,
                      media_files, f"hs_s2n_{number}")
        elif kind == "name_to_symbol":
            add_note(deck, model, img + name, symbol,
                      f"What is the symbol for {name}?", symbol,
                      media_files, f"hs_n2s_{number}")
        else:
            add_note(deck, model, img + f"Element #{number}", symbol,
                      f"What is the symbol for element number {num2words(number)}?", symbol,
                      media_files, f"hs_num2s_{number}")
    return deck, media_files, len(cards)


def gen_category():
    deck_key = "periodic_category"
    model_id, model = build_model(deck_key)
    deck = build_deck(deck_key, "Periodic Table: Element Categories (multiple choice)")
    media_files = []
    subset = [e for e in ELEMENTS if e[3] is not None]
    random.seed(52)
    shuffled = subset[:]
    random.shuffle(shuffled)

    letters = ["A", "B", "C", "D"]
    for number, symbol, name, category in shuffled:
        distractor_pool = [c for c in ALL_CATEGORIES if c != category]
        distractors = random.sample(distractor_pool, 3)
        choices = distractors + [category]
        random.shuffle(choices)
        correct_letter = letters[choices.index(category)]

        prompt_lines = [f"{name} ({symbol})", ""]
        for letter, choice in zip(letters, choices):
            prompt_lines.append(f"{letter}) {choice}")
        prompt = "\n".join(prompt_lines)

        qtext = f"What category is {name}?"
        atext = f"{category}"
        add_note(deck, model, prompt, correct_letter, qtext, atext,
                  media_files, f"cat_{number}")
    return deck, media_files, len(subset)


if args.deck == "prehs":
    deck_key = "periodic_prehs"
elif args.deck == "hs":
    deck_key = "periodic_hs"
else:
    deck_key = "periodic_category"

MEDIA_DIR = os.path.join(SCRATCH, f"media_{deck_key}_{args.voice}")
os.makedirs(MEDIA_DIR, exist_ok=True)

GENERATORS = {"prehs": gen_prehs, "hs": gen_hs, "category": gen_category}
deck, media_files, count = GENERATORS[args.deck]()

package = genanki.Package(deck)
package.media_files = media_files
out_path = os.path.join(SCRATCH, f"{deck_key}_{args.voice}.apkg")
package.write_to_file(out_path)

size_mb = os.path.getsize(out_path) / (1024 * 1024)
print(f"\nDone: {out_path} ({size_mb:.1f} MB, {count} cards, {len(media_files)} media files)")