logos.py

#!/usr/bin/env python3
# logos - a minimalist terminal Bible reader
"""
Built on public domain scripture texts. Zero dependencies beyond Python stdlib.
Works on Linux, BSD, macOS, and Windows.
"""

import curses
import curses.ascii
import json
import os
import sys
import textwrap
import platform
import subprocess
import configparser
from pathlib import Path
from typing import Optional

# VERSION & METADATA

VERSION = "1.2.0"
PROGRAM_NAME = "logos"

# OS DETECTION
# Centralised so debug menu can override it for testing.

def _detect_os() -> str:
    """Return a canonical OS string: 'windows', 'macos', 'linux', 'freebsd',
    'openbsd', 'netbsd', or 'unknown'."""
    s = platform.system().lower()
    if s == "windows":
        return "windows"
    if s == "darwin":
        return "macos"
    if s == "linux":
        return "linux"
    if "bsd" in s:
        return s  # freebsd / openbsd / netbsd
    return "unknown"

# Global that debug menu can override
_OS_OVERRIDE: Optional[str] = None

def get_os() -> str:
    """Return the effective OS string (may be overridden by debug menu)."""
    return _OS_OVERRIDE if _OS_OVERRIDE else _detect_os()

# CONFIGURATION PATHS  (XDG-compliant on Linux/BSD, native on macOS/Windows)

def get_config_dir() -> Path:
    os_name = get_os()
    if os_name == "windows":
        base = Path(os.environ.get("APPDATA", Path.home()))
    elif os_name == "macos":
        base = Path.home() / "Library" / "Application Support"
    else:
        # Linux, FreeBSD, OpenBSD, NetBSD, unknown → XDG
        base = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
    d = base / PROGRAM_NAME
    d.mkdir(parents=True, exist_ok=True)
    return d

def get_data_dir() -> Path:
    os_name = get_os()
    if os_name == "windows":
        base = Path(os.environ.get("LOCALAPPDATA", Path.home()))
    elif os_name == "macos":
        base = Path.home() / "Library" / "Application Support"
    else:
        # Linux, BSD, unknown → XDG
        base = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
    d = base / PROGRAM_NAME
    d.mkdir(parents=True, exist_ok=True)
    return d

def get_default_save_dir() -> Path:
    """Platform-appropriate default directory for saved passages."""
    os_name = get_os()
    if os_name == "windows":
        docs = Path(os.environ.get("USERPROFILE", Path.home())) / "Documents"
        return docs / "logos_passages"
    elif os_name == "macos":
        return Path.home() / "Documents" / "logos_passages"
    else:
        return Path.home() / "logos_passages"

CONFIG_FILE = get_config_dir() / "config.ini"
DATA_DIR    = get_data_dir()

# SCRIPTURE DATA
# The full KJV, WEB, and ASV are public domain. We ship them embedded.
# Deuterocanonical books (Catholic/Orthodox) come from public domain sources.
# Structure: BIBLE[translation][book_abbrev] = {name, chapters: {num: [verses]}}

# Book order definitions per canon
PROTESTANT_CANON = [
    "Gen","Exod","Lev","Num","Deut","Josh","Judg","Ruth",
    "1Sam","2Sam","1Kgs","2Kgs","1Chr","2Chr","Ezra","Neh",
    "Esth","Job","Ps","Prov","Eccl","Song","Isa","Jer","Lam",
    "Ezek","Dan","Hos","Joel","Amos","Obad","Jonah","Mic",
    "Nah","Hab","Zeph","Hag","Zech","Mal",
    "Matt","Mark","Luke","John","Acts","Rom","1Cor","2Cor",
    "Gal","Eph","Phil","Col","1Thess","2Thess","1Tim","2Tim",
    "Titus","Phlm","Heb","Jas","1Pet","2Pet","1John","2John",
    "3John","Jude","Rev"
]

DEUTEROCANON = [
    "Tob","Jdt","1Macc","2Macc","Wis","Sir","Bar","PrAzar",
    "Sus","Bel","1Esd","PrMan","Ps151","3Macc","2Esd","4Macc"
]

CATHOLIC_CANON = (
    PROTESTANT_CANON[:39] +
    ["Tob","Jdt","1Macc","2Macc","Wis","Sir","Bar"] +
    PROTESTANT_CANON[39:]
)

ORTHODOX_CANON = (
    PROTESTANT_CANON[:39] +
    ["Tob","Jdt","1Macc","2Macc","3Macc","4Macc","Wis","Sir","Bar",
     "PrAzar","Sus","Bel","1Esd","PrMan","Ps151"] +
    PROTESTANT_CANON[39:]
)

# Full human-readable book names
BOOK_NAMES = {
    "Gen":    "Genesis",         "Exod":   "Exodus",
    "Lev":    "Leviticus",       "Num":    "Numbers",
    "Deut":   "Deuteronomy",     "Josh":   "Joshua",
    "Judg":   "Judges",          "Ruth":   "Ruth",
    "1Sam":   "1 Samuel",        "2Sam":   "2 Samuel",
    "1Kgs":   "1 Kings",         "2Kgs":   "2 Kings",
    "1Chr":   "1 Chronicles",    "2Chr":   "2 Chronicles",
    "Ezra":   "Ezra",            "Neh":    "Nehemiah",
    "Esth":   "Esther",          "Job":    "Job",
    "Ps":     "Psalms",          "Prov":   "Proverbs",
    "Eccl":   "Ecclesiastes",    "Song":   "Song of Solomon",
    "Isa":    "Isaiah",          "Jer":    "Jeremiah",
    "Lam":    "Lamentations",    "Ezek":   "Ezekiel",
    "Dan":    "Daniel",          "Hos":    "Hosea",
    "Joel":   "Joel",            "Amos":   "Amos",
    "Obad":   "Obadiah",         "Jonah":  "Jonah",
    "Mic":    "Micah",           "Nah":    "Nahum",
    "Hab":    "Habakkuk",        "Zeph":   "Zephaniah",
    "Hag":    "Haggai",          "Zech":   "Zechariah",
    "Mal":    "Malachi",
    "Matt":   "Matthew",         "Mark":   "Mark",
    "Luke":   "Luke",            "John":   "John",
    "Acts":   "Acts",            "Rom":    "Romans",
    "1Cor":   "1 Corinthians",   "2Cor":   "2 Corinthians",
    "Gal":    "Galatians",       "Eph":    "Ephesians",
    "Phil":   "Philippians",     "Col":    "Colossians",
    "1Thess": "1 Thessalonians", "2Thess": "2 Thessalonians",
    "1Tim":   "1 Timothy",       "2Tim":   "2 Timothy",
    "Titus":  "Titus",           "Phlm":   "Philemon",
    "Heb":    "Hebrews",         "Jas":    "James",
    "1Pet":   "1 Peter",         "2Pet":   "2 Peter",
    "1John":  "1 John",          "2John":  "2 John",
    "3John":  "3 John",          "Jude":   "Jude",
    "Rev":    "Revelation",
    # Deuterocanon
    "Tob":    "Tobit",           "Jdt":    "Judith",
    "1Macc":  "1 Maccabees",     "2Macc":  "2 Maccabees",
    "3Macc":  "3 Maccabees",     "4Macc":  "4 Maccabees",
    "Wis":    "Wisdom",          "Sir":    "Sirach",
    "Bar":    "Baruch",          "PrAzar": "Prayer of Azariah",
    "Sus":    "Susanna",         "Bel":    "Bel and the Dragon",
    "1Esd":   "1 Esdras",        "PrMan":  "Prayer of Manasseh",
    "Ps151":  "Psalm 151",       "2Esd":   "2 Esdras",
}

# Alternate search names → canonical abbreviations
BOOK_ALIASES = {
    "genesis": "Gen",           "gen": "Gen",
    "exodus": "Exod",           "exod": "Exod",          "ex": "Exod",
    "leviticus": "Lev",         "lev": "Lev",
    "numbers": "Num",           "num": "Num",
    "deuteronomy": "Deut",      "deut": "Deut",          "dt": "Deut",
    "joshua": "Josh",           "josh": "Josh",
    "judges": "Judg",           "judg": "Judg",          "jdg": "Judg",
    "ruth": "Ruth",
    "1samuel": "1Sam",          "1sam": "1Sam",          "1s": "1Sam",
    "2samuel": "2Sam",          "2sam": "2Sam",          "2s": "2Sam",
    "1kings": "1Kgs",           "1kgs": "1Kgs",          "1k": "1Kgs",
    "2kings": "2Kgs",           "2kgs": "2Kgs",          "2k": "2Kgs",
    "1chronicles": "1Chr",      "1chr": "1Chr",          "1ch": "1Chr",
    "2chronicles": "2Chr",      "2chr": "2Chr",          "2ch": "2Chr",
    "ezra": "Ezra",
    "nehemiah": "Neh",          "neh": "Neh",
    "esther": "Esth",           "esth": "Esth",          "est": "Esth",
    "job": "Job",
    "psalms": "Ps",             "psalm": "Ps",           "ps": "Ps",
    "proverbs": "Prov",         "prov": "Prov",          "pr": "Prov",
    "ecclesiastes": "Eccl",     "eccl": "Eccl",          "ecc": "Eccl",
    "songofsongs": "Song",      "song": "Song",          "sos": "Song",
    "isaiah": "Isa",            "isa": "Isa",
    "jeremiah": "Jer",          "jer": "Jer",
    "lamentations": "Lam",      "lam": "Lam",
    "ezekiel": "Ezek",          "ezek": "Ezek",          "ezk": "Ezek",
    "daniel": "Dan",            "dan": "Dan",
    "hosea": "Hos",             "hos": "Hos",
    "joel": "Joel",
    "amos": "Amos",
    "obadiah": "Obad",          "obad": "Obad",          "ob": "Obad",
    "jonah": "Jonah",           "jon": "Jonah",
    "micah": "Mic",             "mic": "Mic",
    "nahum": "Nah",             "nah": "Nah",
    "habakkuk": "Hab",          "hab": "Hab",
    "zephaniah": "Zeph",        "zeph": "Zeph",          "zep": "Zeph",
    "haggai": "Hag",            "hag": "Hag",
    "zechariah": "Zech",        "zech": "Zech",          "zec": "Zech",
    "malachi": "Mal",           "mal": "Mal",
    "matthew": "Matt",          "matt": "Matt",          "mt": "Matt",
    "mark": "Mark",             "mk": "Mark",
    "luke": "Luke",             "lk": "Luke",
    "john": "John",             "jn": "John",
    "acts": "Acts",
    "romans": "Rom",            "rom": "Rom",
    "1corinthians": "1Cor",     "1cor": "1Cor",
    "2corinthians": "2Cor",     "2cor": "2Cor",
    "galatians": "Gal",         "gal": "Gal",
    "ephesians": "Eph",         "eph": "Eph",
    "philippians": "Phil",      "phil": "Phil",
    "colossians": "Col",        "col": "Col",
    "1thessalonians": "1Thess", "1thess": "1Thess",      "1th": "1Thess",
    "2thessalonians": "2Thess", "2thess": "2Thess",      "2th": "2Thess",
    "1timothy": "1Tim",         "1tim": "1Tim",
    "2timothy": "2Tim",         "2tim": "2Tim",
    "titus": "Titus",           "tit": "Titus",
    "philemon": "Phlm",         "phlm": "Phlm",          "phm": "Phlm",
    "hebrews": "Heb",           "heb": "Heb",
    "james": "Jas",             "jas": "Jas",
    "1peter": "1Pet",           "1pet": "1Pet",          "1pe": "1Pet",
    "2peter": "2Pet",           "2pet": "2Pet",          "2pe": "2Pet",
    "1john": "1John",           "1jn": "1John",
    "2john": "2John",           "2jn": "2John",
    "3john": "3John",           "3jn": "3John",
    "jude": "Jude",             "jud": "Jude",
    "revelation": "Rev",        "rev": "Rev",            "ap": "Rev",
    # Deuterocanon aliases
    "tobit": "Tob",             "tob": "Tob",
    "judith": "Jdt",            "jdt": "Jdt",
    "1maccabees": "1Macc",      "1macc": "1Macc",
    "2maccabees": "2Macc",      "2macc": "2Macc",
    "3maccabees": "3Macc",      "3macc": "3Macc",
    "4maccabees": "4Macc",      "4macc": "4Macc",
    "wisdom": "Wis",            "wis": "Wis",
    "sirach": "Sir",            "sir": "Sir",            "ecclesiasticus": "Sir",
    "baruch": "Bar",            "bar": "Bar",
}

# TRANSLATIONS & DENOMINATIONS

TRANSLATIONS = {
    "KJV": {
        "name": "King James Version (1769)",
        "lang": "English",
        "tradition": "Protestant / Anglican",
        "canon": "protestant",
        "file": "kjv.json",
    },
    "WEB": {
        "name": "World English Bible",
        "lang": "English",
        "tradition": "Interdenominational",
        "canon": "protestant",
        "file": "web.json",
    },
    "ASV": {
        "name": "American Standard Version (1901)",
        "lang": "English",
        "tradition": "Protestant",
        "canon": "protestant",
        "file": "asv.json",
    },
    "DOUAY": {
        "name": "Douay-Rheims (Challoner 1899)",
        "lang": "English",
        "tradition": "Roman Catholic",
        "canon": "catholic",
        "file": "douay.json",
    },
    "RUS_SYNODAL": {
        "name": "Synodal Bible (Russian, 1876)",
        "lang": "Russian",
        "tradition": "Russian / Serbian / Bulgarian / Georgian Orthodox",
        "canon": "orthodox",
        "file": "rus_synodal.json",
    },
    "UKR": {
        "name": "Ogienko Bible (Ukrainian, 1962)",
        "lang": "Ukrainian",
        "tradition": "Ukrainian Orthodox / Protestant",
        "canon": "orthodox",
        "file": "ukr.json",
    },
    "ROM": {
        "name": "Cornilescu Bible (Romanian, 1921)",
        "lang": "Romanian",
        "tradition": "Romanian Orthodox / Protestant",
        "canon": "protestant",
        "file": "rom.json",
    },
    "LXX": {
        "name": "Brenton Septuagint in English (LXX, 1851)",
        "lang": "English",
        "tradition": "Eastern Orthodox Old Testament",
        "canon": "orthodox",
        "file": "lxx.json",
    },
    "CHURCH_SLAVONIC": {
        "name": "Church Slavonic Bible (1900)",
        "lang": "Church Slavonic",
        "tradition": "Serbian / Bulgarian / Macedonian Orthodox",
        "canon": "orthodox",
        "file": "church_slavonic.json",
    },
    "GREEK_LXX": {
        "name": "Septuagint in Greek (LXX)",
        "lang": "Greek",
        "tradition": "Eastern Orthodox (Greek)",
        "canon": "orthodox",
        "file": "greek_lxx.json",
    },
    "VULGATE": {
        "name": "Clementine Vulgate (Latin)",
        "lang": "Latin",
        "tradition": "Roman Catholic / Orthodox",
        "canon": "catholic",
        "file": "vulgate.json",
    },
    "GERMAN": {
        "name": "Luther Bible (German, 1912)",
        "lang": "German",
        "tradition": "Lutheran / Protestant",
        "canon": "protestant",
        "file": "german.json",
    },
    "FRENCH": {
        "name": "Segond Bible (French, 1910)",
        "lang": "French",
        "tradition": "Protestant",
        "canon": "protestant",
        "file": "french.json",
    },
    "SPANISH": {
        "name": "Reina-Valera (Spanish, 1909)",
        "lang": "Spanish",
        "tradition": "Protestant / Catholic",
        "canon": "protestant",
        "file": "spanish.json",
    },
}

DENOMINATION_GROUPS = [
    ("English", [
        ("King James Version (KJV)",       "KJV"),
        ("World English Bible (WEB)",      "WEB"),
        ("American Standard (ASV, 1901)",  "ASV"),
        ("Douay-Rheims (Roman Catholic)",  "DOUAY"),
    ]),
    ("Orthodox", [
        ("Synodal - Russian / Serbian / Bulgarian / Georgian", "RUS_SYNODAL"),
        ("Church Slavonic (1900)",                             "CHURCH_SLAVONIC"),
        ("Brenton Septuagint in English (LXX)",               "LXX"),
        ("Septuagint in Greek (LXX)",                         "GREEK_LXX"),
        ("Ukrainian - Ogienko (1962)",                        "UKR"),
        ("Romanian - Cornilescu (1921)",                      "ROM"),
    ]),
    ("Latin", [
        ("Clementine Vulgate",             "VULGATE"),
    ]),
    ("Other languages", [
        ("Luther Bible (German)",          "GERMAN"),
        ("Segond Bible (French)",          "FRENCH"),
        ("Reina-Valera (Spanish)",         "SPANISH"),
    ]),
]

DENOMINATIONS = [
    ("KJV - King James Version",                        "KJV"),
    ("WEB - World English Bible",                       "WEB"),
    ("ASV - American Standard (1901)",                  "ASV"),
    ("Douay-Rheims (Roman Catholic)",                   "DOUAY"),
    ("Synodal - Russian / Serbian / Bulgarian Orthodox","RUS_SYNODAL"),
    ("Church Slavonic (1900)",                          "CHURCH_SLAVONIC"),
    ("LXX - Brenton Septuagint (English)",              "LXX"),
    ("Greek Septuagint (LXX, Greek)",                   "GREEK_LXX"),
    ("Ukrainian - Ogienko (1962)",                      "UKR"),
    ("Romanian - Cornilescu (1921)",                    "ROM"),
    ("Clementine Vulgate (Latin)",                      "VULGATE"),
    ("Luther Bible (German)",                           "GERMAN"),
    ("Segond Bible (French)",                           "FRENCH"),
    ("Reina-Valera (Spanish)",                          "SPANISH"),
]

# CONFIGURATION

DEFAULT_CONFIG = {
    "translation": "KJV",
    "verse_numbers": "true",
    "wrap_width": "0",          # 0 = auto (terminal width)
    "theme": "default",
    "setup_done": "false",
    "last_book": "",
    "last_chapter": "",
    "last_scroll": "",
}

def load_config() -> dict:
    cfg = configparser.ConfigParser()
    if CONFIG_FILE.exists():
        cfg.read(CONFIG_FILE)
    result = dict(DEFAULT_CONFIG)
    if "logos" in cfg:
        result.update(dict(cfg["logos"]))
    return result

def save_config(conf: dict):
    cfg = configparser.ConfigParser()
    cfg["logos"] = conf
    with open(CONFIG_FILE, "w") as f:
        cfg.write(f)

# BOOKMARKS — stored as JSON in data dir

BOOKMARKS_FILE = DATA_DIR / "bookmarks.json"

def load_bookmarks() -> list:
    """Returns list of {book, chapter, verse, label} dicts."""
    if BOOKMARKS_FILE.exists():
        try:
            with open(BOOKMARKS_FILE, "r", encoding="utf-8") as f:
                return json.load(f)
        except Exception:
            pass
    return []

def save_bookmarks(bmarks: list):
    with open(BOOKMARKS_FILE, "w", encoding="utf-8") as f:
        json.dump(bmarks, f, ensure_ascii=False, indent=2)

def add_bookmark(book: str, chapter: int, verse: Optional[int], label: str):
    bmarks = load_bookmarks()
    # Avoid exact duplicate
    for b in bmarks:
        if b["book"] == book and b["chapter"] == chapter and b.get("verse") == verse:
            return
    bmarks.insert(0, {"book": book, "chapter": chapter, "verse": verse, "label": label})
    bmarks = bmarks[:50]  # cap at 50
    save_bookmarks(bmarks)

# DATA LOADING
# We use the Scrollmapper/bible-json public domain dataset format.
# Data files live alongside this script or in DATA_DIR.

_cache: dict = {}

def get_data_paths(filename: str) -> list[Path]:
    """Search order: script dir, data dir, current dir."""
    script_dir = Path(__file__).parent
    return [
        script_dir / "data" / filename,
        DATA_DIR / filename,
        Path.cwd() / "data" / filename,
    ]

def load_translation(translation_key: str) -> Optional[dict]:
    """Load a translation JSON. Returns None if not found."""
    if translation_key in _cache:
        return _cache[translation_key]
    info = TRANSLATIONS.get(translation_key)
    if not info:
        return None
    for path in get_data_paths(info["file"]):
        if path.exists():
            with open(path, "r", encoding="utf-8") as f:
                data = json.load(f)
            _cache[translation_key] = data
            return data
    return None

def get_verse(translation_key: str, book: str, chapter: int, verse: int) -> Optional[str]:
    data = load_translation(translation_key)
    if not data:
        return None
    try:
        return data[book][str(chapter)][str(verse)]
    except (KeyError, TypeError):
        return None

def get_chapter(translation_key: str, book: str, chapter: int) -> Optional[dict]:
    data = load_translation(translation_key)
    if not data:
        return None
    try:
        return data[book][str(chapter)]
    except (KeyError, TypeError):
        return None

def get_passage(translation_key: str, book: str, chapter: int,
                verse_start: int, verse_end: Optional[int] = None) -> list[tuple[int, str]]:
    ch = get_chapter(translation_key, book, chapter)
    if not ch:
        return []
    results = []
    v = verse_start
    max_v = max(int(k) for k in ch.keys()) if ch else 0
    end = verse_end if verse_end else max_v
    while v <= end:
        text = ch.get(str(v))
        if text:
            results.append((v, text))
        v += 1
    return results

def get_book_chapters(translation_key: str, book: str) -> int:
    data = load_translation(translation_key)
    if not data or book not in data:
        return 0
    return len(data[book])

def get_chapter_verses(translation_key: str, book: str, chapter: int) -> int:
    ch = get_chapter(translation_key, book, chapter)
    return len(ch) if ch else 0

def available_books(translation_key: str) -> list[str]:
    data = load_translation(translation_key)
    if not data:
        return []
    canon = TRANSLATIONS[translation_key]["canon"]
    if canon == "catholic":
        order = CATHOLIC_CANON
    elif canon == "orthodox":
        order = ORTHODOX_CANON
    else:
        order = PROTESTANT_CANON
    return [b for b in order if b in data]

# REFERENCE PARSING
# Accepts: "John 3:16", "Jn 3:16", "john 3:16-18", "Gen 1"

def parse_reference(ref: str) -> Optional[tuple]:
    """
    Returns (book_abbrev, chapter, verse_start, verse_end) or None.
    verse_start/verse_end are None if not specified.
    """
    import re
    ref = ref.strip()
    # Match: Book [chapter[:verse[-verse_end]]]
    pat = re.compile(
        r'^([1-4]?\s*[A-Za-z]+(?:\s+[A-Za-z]+)?)'   # book (with optional num prefix)
        r'(?:\s+(\d+)'                                 # chapter
        r'(?::(\d+)'                                   # :verse_start
        r'(?:-(\d+))?)?)?$'                            # -verse_end
    )
    m = pat.match(ref)
    if not m:
        return None
    book_raw, chap, vs, ve = m.groups()
    # Normalize book
    key = book_raw.strip().lower().replace(" ", "").replace(".", "")
    abbrev = BOOK_ALIASES.get(key)
    if not abbrev:
        # Try fuzzy: first 3 chars
        for alias, ab in BOOK_ALIASES.items():
            if alias.startswith(key[:3]) or key.startswith(alias[:3]):
                abbrev = ab
                break
    if not abbrev:
        return None
    chapter = int(chap) if chap else None
    verse_start = int(vs) if vs else None
    verse_end = int(ve) if ve else None
    return (abbrev, chapter, verse_start, verse_end)

# COPY / SAVE UTILITIES (no external tools required)

def copy_to_clipboard(text: str) -> bool:
    """Try platform clipboard. Returns True on success."""
    os_name = get_os()
    try:
        if os_name == "linux":
            for cmd in [["xclip", "-selection", "clipboard"],
                        ["xsel", "--clipboard", "--input"],
                        ["wl-copy"]]:
                try:
                    proc = subprocess.run(cmd, input=text.encode(),
                                          capture_output=True, timeout=3)
                    if proc.returncode == 0:
                        return True
                except (FileNotFoundError, subprocess.TimeoutExpired):
                    continue
        elif os_name in ("freebsd", "openbsd", "netbsd"):
            # xclip/xsel work on BSD under X11; xdotool also common
            for cmd in [["xclip", "-selection", "clipboard"],
                        ["xsel", "--clipboard", "--input"]]:
                try:
                    proc = subprocess.run(cmd, input=text.encode(),
                                          capture_output=True, timeout=3)
                    if proc.returncode == 0:
                        return True
                except (FileNotFoundError, subprocess.TimeoutExpired):
                    continue
        elif os_name == "macos":
            proc = subprocess.run(["pbcopy"], input=text.encode(),
                                  capture_output=True, timeout=3)
            return proc.returncode == 0
        elif os_name == "windows":
            proc = subprocess.run(["clip"], input=text.encode("utf-16-le"),
                                  capture_output=True, timeout=3)
            return proc.returncode == 0
    except Exception:
        pass
    return False

def save_passage_to_file(text: str, ref: str, out_dir: Optional[Path] = None) -> str:
    """Save text to out_dir (defaults to platform save dir) with a descriptive filename."""
    if out_dir is None:
        out_dir = get_default_save_dir()
    try:
        out_dir.mkdir(parents=True, exist_ok=True)
    except OSError as e:
        return f"[error creating dir: {e}]"
    safe_ref = ref.replace(" ", "_").replace(":", "-").replace("/", "-")
    filename = out_dir / f"{safe_ref}.txt"
    i = 1
    while filename.exists():
        filename = out_dir / f"{safe_ref}_{i}.txt"
        i += 1
    try:
        with open(filename, "w", encoding="utf-8") as f:
            f.write(text)
        return str(filename)
    except OSError as e:
        return f"[error writing file: {e}]"

def run_save_dir_input(stdscr, default_dir: Path) -> Optional[Path]:
    """Show a small dialog to let the user choose a save directory.
    Returns a Path, or None to cancel (keep default)."""
    curses.curs_set(1)
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    box_w = min(60, w - 6)
    box_h = 6
    box_y = h // 2 - box_h // 2
    box_x = w // 2 - box_w // 2
    input_str = str(default_dir)
    error = ""

    while True:
        bg = curses.color_pair(3)
        for i in range(box_h):
            tc.safe_addstr(stdscr, box_y + i, box_x, " " * box_w, bg)
        tc.safe_addstr(stdscr, box_y,     box_x + 2, "Save to directory:", bg | curses.A_BOLD)
        tc.safe_addstr(stdscr, box_y + 1, box_x + 2, "-" * (box_w - 4), bg)
        # Show last (box_w-4) chars of path so it doesn't overflow
        display = input_str[-(box_w - 5):] if len(input_str) > box_w - 5 else input_str
        tc.safe_addstr(stdscr, box_y + 2, box_x + 2, display + "_", bg | curses.A_BOLD)
        if error:
            tc.safe_addstr(stdscr, box_y + 3, box_x + 2, error[:box_w - 4], bg)
        else:
            tc.safe_addstr(stdscr, box_y + 3, box_x + 2,
                "Enter confirm   Esc keep default   Ctrl+U clear", bg)
        tc.safe_addstr(stdscr, box_y + 4, box_x + 2,
            "Tab = autocomplete first match", bg)
        stdscr.refresh()

        key = stdscr.getch()
        if key in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            p = Path(os.path.expanduser(input_str.strip()))
            curses.curs_set(0)
            return p
        elif key == 27:
            curses.curs_set(0)
            return None
        elif key in (curses.KEY_BACKSPACE, 127, 8):
            input_str = input_str[:-1]
            error = ""
        elif key == 21:  # Ctrl+U — clear line
            input_str = ""
            error = ""
        elif key == ord('\t'):  # Tab — basic path autocomplete
            partial = os.path.expanduser(input_str)
            parent  = os.path.dirname(partial) or "/"
            base    = os.path.basename(partial)
            try:
                matches = sorted([
                    os.path.join(parent, e)
                    for e in os.listdir(parent)
                    if e.startswith(base) and os.path.isdir(os.path.join(parent, e))
                ])
                if matches:
                    input_str = matches[0]
                    error = ""
            except OSError:
                pass
        elif 32 <= key <= 126:
            input_str += chr(key)
            error = ""

# TERMINAL COMPATIBILITY LAYER
# Handles differences between Linux/macOS/Windows terminals gracefully.

class TermCompat:
    """Safe wrappers around curses for cross-platform use."""

    @staticmethod
    def init_colors():
        try:
            curses.start_color()
            curses.use_default_colors()
            # Pair 1: header/title    (white on dark blue or bold)
            # Pair 2: verse numbers   (dim/yellow)
            # Pair 3: selected text   (reverse)
            # Pair 4: status bar      (reverse)
            # Pair 5: dim/comment     (dim)
            # Pair 6: highlight       (bold)
            if curses.can_change_color() and curses.COLORS >= 8:
                curses.init_pair(1, curses.COLOR_CYAN,    -1)
                curses.init_pair(2, curses.COLOR_YELLOW,  -1)
                curses.init_pair(3, curses.COLOR_BLACK,   curses.COLOR_WHITE)
                curses.init_pair(4, curses.COLOR_BLACK,   curses.COLOR_WHITE)
                curses.init_pair(5, curses.COLOR_WHITE,   -1)
                curses.init_pair(6, curses.COLOR_WHITE,   -1)
            else:
                for i in range(1, 7):
                    curses.init_pair(i, -1, -1)
        except Exception:
            pass

    @staticmethod
    def safe_addstr(win, y: int, x: int, text: str, attr: int = 0):
        try:
            h, w = win.getmaxyx()
            if y < 0 or y >= h or x < 0:
                return
            available = w - x - 1
            if available <= 0:
                return
            win.addstr(y, x, text[:available], attr)
        except curses.error:
            pass

    @staticmethod
    def safe_addch(win, y: int, x: int, ch: str, attr: int = 0):
        try:
            h, w = win.getmaxyx()
            if 0 <= y < h and 0 <= x < w - 1:
                win.addch(y, x, ch, attr)
        except curses.error:
            pass

    @staticmethod
    def hline(win, y: int, x: int, width: int, attr: int = 0):
        try:
            h, w = win.getmaxyx()
            actual = min(width, w - x - 1)
            if actual > 0 and 0 <= y < h:
                win.addstr(y, x, "-" * actual, attr)
        except curses.error:
            try:
                win.hline(y, x, curses.ACS_HLINE, min(width, win.getmaxyx()[1] - x - 1))
            except curses.error:
                pass

# SETUP WIZARD

def run_setup(stdscr, conf: dict) -> dict:
    """First-run setup wizard. Returns updated config."""
    curses.curs_set(0)
    h, w = stdscr.getmaxyx()
    tc = TermCompat

    stdscr.clear()
    tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
    tc.safe_addstr(stdscr, 0, 2, "logos - first run setup", curses.color_pair(4))
    tc.hline(stdscr, 1, 0, w - 1)
    tc.safe_addstr(stdscr, 3, 2, "Welcome. Choose your preferred translation.", 0)
    tc.safe_addstr(stdscr, 4, 2, "Translations marked [run logos-fetch-data] need to be", curses.color_pair(5))
    tc.safe_addstr(stdscr, 5, 2, "downloaded first. Press any key to continue.", curses.color_pair(5))
    stdscr.refresh()
    stdscr.getch()

    conf = run_translation_picker(stdscr, conf)
    if not conf.get("translation"):
        conf["translation"] = "KJV"
    conf["setup_done"] = "true"
    save_config(conf)
    return conf

# TRANSLATION SWITCHER

def run_translation_picker(stdscr, conf: dict) -> dict:
    curses.curs_set(0)
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    current = conf.get("translation", "KJV")

    # Build a flat selectable list, checking which files are present
    # Items are (label, key_or_None) - None key means group header
    def data_present(key):
        info = TRANSLATIONS.get(key, {})
        fname = info.get("file", "")
        return any(p.exists() for p in get_data_paths(fname))

    items = []  # (display_label, translation_key or None, is_header)
    for group_name, entries in DENOMINATION_GROUPS:
        items.append((group_name, None, True))
        seen = set()
        for label, key in entries:
            if key in seen:
                continue
            seen.add(key)
            present = data_present(key)
            status = "" if present else "  [run logos-fetch-data]"
            items.append((label + status, key, False))

    # Build selectable indices (non-headers only)
    selectable = [i for i, (_, k, hdr) in enumerate(items) if not hdr]
    # Start selection at current translation
    cur_idx = next((selectable.index(i) for i, (_, k, hdr) in enumerate(items)
                    if k == current), 0)
    sel = cur_idx  # index into selectable list
    scroll = 0
    list_h = h - 5

    while True:
        stdscr.clear()
        tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
        tc.safe_addstr(stdscr, 0, 2, "Select Translation", curses.color_pair(4))
        tc.hline(stdscr, 1, 0, w - 1)

        for row in range(list_h):
            li = scroll + row
            if li >= len(items):
                break
            label, key, is_hdr = items[li]
            y = 2 + row
            if is_hdr:
                tc.safe_addstr(stdscr, y, 2, label, curses.color_pair(1) | curses.A_BOLD)
            else:
                item_sel_idx = selectable.index(li) if li in selectable else -1
                is_sel = (item_sel_idx == sel)
                is_cur = (key == current)
                prefix = " > " if is_sel else "   "
                attr = curses.A_BOLD if is_sel else (curses.color_pair(5) if not data_present(key) else 0)
                suffix = " [active]" if is_cur else ""
                tc.safe_addstr(stdscr, y, 2, prefix + label + suffix, attr)

        tc.hline(stdscr, h - 2, 0, w - 1)
        tc.safe_addstr(stdscr, h - 1, 2,
            "j/k or arrows   Enter select   Esc cancel", curses.color_pair(5))
        stdscr.refresh()

        key_press = stdscr.getch()
        if key_press in (curses.KEY_UP, ord('k')) and sel > 0:
            sel -= 1
            # Scroll up if needed
            item_li = selectable[sel]
            if item_li < scroll:
                scroll = max(0, item_li)
        elif key_press in (curses.KEY_DOWN, ord('j')) and sel < len(selectable) - 1:
            sel += 1
            item_li = selectable[sel]
            if item_li >= scroll + list_h:
                scroll = item_li - list_h + 1
        elif key_press in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            chosen_li = selectable[sel]
            chosen_key = items[chosen_li][1]
            if chosen_key and data_present(chosen_key):
                conf["translation"] = chosen_key
                save_config(conf)
            elif chosen_key:
                # Show "not downloaded" briefly
                tc.safe_addstr(stdscr, h - 1, 2,
                    "Not downloaded. Run: python logos-fetch-data.py " + chosen_key + "   ",
                    curses.color_pair(5))
                stdscr.refresh()
                stdscr.getch()
                continue
            break
        elif key_press in (27, ord('q')):
            break
    return conf

# BOOK BROWSER

def run_book_picker(stdscr, translation_key: str) -> Optional[str]:
    """Let user pick a book. Returns book abbrev or None."""
    curses.curs_set(0)
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    books = available_books(translation_key)
    if not books:
        return None
    sel = 0
    scroll = 0
    list_h = h - 6
    search_str = ""
    filtered = books[:]

    def refilter():
        nonlocal filtered, sel, scroll
        if search_str:
            q = search_str.lower()
            filtered = [b for b in books if
                        q in BOOK_NAMES.get(b, b).lower() or
                        q in b.lower()]
        else:
            filtered = books[:]
        sel = 0
        scroll = 0

    while True:
        stdscr.clear()
        tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
        tc.safe_addstr(stdscr, 0, 2, f"Books: {TRANSLATIONS[translation_key]['name']}", curses.color_pair(4))
        tc.hline(stdscr, 1, 0, w - 1)
        # Search bar
        tc.safe_addstr(stdscr, 2, 2, f"Search: {search_str}_", curses.color_pair(6) | curses.A_BOLD)
        tc.hline(stdscr, 3, 0, w - 1)
        # Book list
        for row, i in enumerate(range(scroll, min(scroll + list_h, len(filtered)))):
            b = filtered[i]
            name = BOOK_NAMES.get(b, b)
            y = 4 + row
            prefix = " ▶  " if i == sel else "    "
            attr = curses.A_BOLD if i == sel else 0
            tc.safe_addstr(stdscr, y, 2, f"{prefix}{name}", attr)
        # Footer
        tc.hline(stdscr, h - 2, 0, w - 1)
        tc.safe_addstr(stdscr, h - 1, 2,
            "↑/↓ move   Enter select   type to search   Esc back",
            curses.color_pair(5))
        stdscr.refresh()

        key = stdscr.getch()
        if key in (curses.KEY_UP, ord('k')) and sel > 0:
            sel -= 1
            if sel < scroll:
                scroll = sel
        elif key in (curses.KEY_DOWN, ord('j')) and sel < len(filtered) - 1:
            sel += 1
            if sel >= scroll + list_h:
                scroll = sel - list_h + 1
        elif key in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            if filtered:
                return filtered[sel]
        elif key == 27:  # Esc
            return None
        elif key in (curses.KEY_BACKSPACE, 127, 8):
            if search_str:
                search_str = search_str[:-1]
                refilter()
        elif 32 <= key <= 126:
            search_str += chr(key)
            refilter()

# CHAPTER PICKER

def run_chapter_picker(stdscr, translation_key: str, book: str) -> Optional[int]:
    curses.curs_set(0)
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    total = get_book_chapters(translation_key, book)
    if total == 0:
        return None
    book_name = BOOK_NAMES.get(book, book)
    # Arrange chapters in columns
    cols = max(1, (w - 6) // 5)
    sel = 0

    while True:
        stdscr.clear()
        tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
        tc.safe_addstr(stdscr, 0, 2, f"{book_name}: Select Chapter", curses.color_pair(4))
        tc.hline(stdscr, 1, 0, w - 1)
        for i in range(total):
            col = i % cols
            row = i // cols
            y = 3 + row
            x = 3 + col * 5
            if y < h - 3:
                attr = curses.A_BOLD | curses.A_REVERSE if i == sel else 0
                tc.safe_addstr(stdscr, y, x, f"{i + 1:3d} ", attr)
        tc.hline(stdscr, h - 2, 0, w - 1)
        tc.safe_addstr(stdscr, h - 1, 2,
            "←/→/↑/↓ navigate   Enter select   Esc back",
            curses.color_pair(5))
        stdscr.refresh()

        key = stdscr.getch()
        if key in (curses.KEY_RIGHT, ord('l')):
            if sel < total - 1:
                sel += 1
        elif key in (curses.KEY_LEFT, ord('h')):
            if sel > 0:
                sel -= 1
        elif key in (curses.KEY_DOWN, ord('j')):
            if sel + cols < total:
                sel += cols
        elif key in (curses.KEY_UP, ord('k')):
            if sel - cols >= 0:
                sel -= cols
        elif key in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            return sel + 1
        elif key == 27:
            return None
        elif 49 <= key <= 57:
            # Number shortcut: jump to start of that "hundred" range
            pass

# QUICK REFERENCE INPUT

def run_reference_input(stdscr) -> Optional[tuple]:
    """Show a small input box. Returns parsed reference tuple or None."""
    curses.curs_set(1)
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    box_w = min(50, w - 8)
    box_h = 5
    box_y = h // 2 - box_h // 2
    box_x = w // 2 - box_w // 2

    input_str = ""
    error = ""

    while True:
        # Draw box background
        for i in range(box_h):
            tc.safe_addstr(stdscr, box_y + i, box_x,
                           " " * box_w, curses.color_pair(3))
        tc.safe_addstr(stdscr, box_y, box_x + 2, "Go to passage:", curses.color_pair(3) | curses.A_BOLD)
        tc.safe_addstr(stdscr, box_y + 1, box_x + 2, "-" * (box_w - 4), curses.color_pair(3))
        tc.safe_addstr(stdscr, box_y + 2, box_x + 2, input_str + "_", curses.color_pair(3) | curses.A_BOLD)
        if error:
            tc.safe_addstr(stdscr, box_y + 3, box_x + 2, error[:box_w - 4], curses.color_pair(3))
        else:
            tc.safe_addstr(stdscr, box_y + 3, box_x + 2,
                "e.g. John 3:16  Gen 1  Rom 8:28-39", curses.color_pair(3))
        stdscr.refresh()

        key = stdscr.getch()
        if key in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            result = parse_reference(input_str)
            if result:
                curses.curs_set(0)
                return result
            else:
                error = "Can't parse that. Try: John 3:16 or Gen 1"
        elif key == 27:
            curses.curs_set(0)
            return None
        elif key in (curses.KEY_BACKSPACE, 127, 8):
            if input_str:
                input_str = input_str[:-1]
                error = ""
        elif 32 <= key <= 126:
            if len(input_str) < box_w - 5:
                input_str += chr(key)
                error = ""

# IN-CHAPTER SEARCH INPUT

def run_search_input(stdscr, current: str = "") -> Optional[str]:
    """Small search box. Returns query string, empty string to clear, or None to cancel."""
    curses.curs_set(1)
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    box_w = min(48, w - 8)
    box_y = h - 4
    box_x = 2
    query = current

    while True:
        bg = curses.color_pair(3)
        for i in range(3):
            tc.safe_addstr(stdscr, box_y + i, box_x, " " * box_w, bg)
        tc.safe_addstr(stdscr, box_y,     box_x + 1, "Search:", bg | curses.A_BOLD)
        tc.safe_addstr(stdscr, box_y + 1, box_x + 1, (query + "_")[:box_w - 2], bg | curses.A_BOLD)
        tc.safe_addstr(stdscr, box_y + 2, box_x + 1, "Enter confirm   Esc cancel   clear=empty+Enter", bg)
        stdscr.refresh()

        key = stdscr.getch()
        if key in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            curses.curs_set(0)
            return query
        elif key == 27:
            curses.curs_set(0)
            return None
        elif key in (curses.KEY_BACKSPACE, 127, 8):
            query = query[:-1]
        elif 32 <= key <= 126 and len(query) < box_w - 3:
            query += chr(key)

# BOOKMARK BROWSER

def run_bookmark_browser(stdscr) -> Optional[tuple]:
    """Show saved bookmarks. Returns (book, chapter, verse) or None."""
    curses.curs_set(0)
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    bmarks = load_bookmarks()

    if not bmarks:
        stdscr.clear()
        tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
        tc.safe_addstr(stdscr, 0, 2, "Bookmarks", curses.color_pair(4) | curses.A_BOLD)
        tc.hline(stdscr, 1, 0, w - 1)
        tc.safe_addstr(stdscr, 3, 4, "No bookmarks yet.  Press m in the reader to add one.", 0)
        tc.hline(stdscr, h - 2, 0, w - 1)
        tc.safe_addstr(stdscr, h - 1, 2, "any key to close", curses.color_pair(5))
        stdscr.refresh()
        stdscr.getch()
        return None

    sel = 0
    scroll = 0
    list_h = h - 5

    while True:
        stdscr.clear()
        tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
        tc.safe_addstr(stdscr, 0, 2, "Bookmarks", curses.color_pair(4) | curses.A_BOLD)
        tc.hline(stdscr, 1, 0, w - 1)

        for row in range(list_h):
            i = scroll + row
            if i >= len(bmarks):
                break
            b = bmarks[i]
            book_name = BOOK_NAMES.get(b["book"], b["book"])
            verse_str = f":{b['verse']}" if b.get("verse") else ""
            ref = f"{book_name} {b['chapter']}{verse_str}"
            label = b.get("label", "")
            display = f"  {ref:<22}  {label}" if label else f"  {ref}"
            y = 2 + row
            is_sel = (i == sel)
            prefix = " ▶  " if is_sel else "    "
            attr = curses.A_BOLD if is_sel else 0
            tc.safe_addstr(stdscr, y, 2, prefix + display[:w - 8], attr)

        tc.hline(stdscr, h - 2, 0, w - 1)
        tc.safe_addstr(stdscr, h - 1, 2,
            "↑/↓ navigate   Enter jump   d delete   Esc back",
            curses.color_pair(5))
        stdscr.refresh()

        key = stdscr.getch()
        if key in (curses.KEY_UP, ord('k')) and sel > 0:
            sel -= 1
            if sel < scroll:
                scroll = sel
        elif key in (curses.KEY_DOWN, ord('j')) and sel < len(bmarks) - 1:
            sel += 1
            if sel >= scroll + list_h:
                scroll = sel - list_h + 1
        elif key in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            b = bmarks[sel]
            return (b["book"], b["chapter"], b.get("verse"))
        elif key == ord('d'):
            bmarks.pop(sel)
            save_bookmarks(bmarks)
            sel = max(0, sel - 1)
            if not bmarks:
                return None
        elif key in (27, ord('q')):
            return None

# PASSAGE VIEWER
# The main reading view. Supports scrolling, selection, copy, save, search, bookmarks.

def format_chapter(translation_key: str, book: str, chapter: int,
                   wrap_w: int, show_nums: bool) -> list[tuple]:
    """
    Returns list of (verse_num_or_none, line_text) for display.
    verse_num_or_none is the verse number for the first line of each verse, else None.
    """
    ch = get_chapter(translation_key, book, chapter)
    if not ch:
        return [("", "  [passage not available in this translation]")]
    lines = []
    for vnum in sorted(ch.keys(), key=lambda x: int(x)):
        text = ch[vnum]
        if show_nums:
            prefix = f"{vnum:>3}  "
            indent = "     "
        else:
            prefix = "  "
            indent = "  "
        wrapped = textwrap.wrap(text, width=max(20, wrap_w - len(prefix)))
        if not wrapped:
            wrapped = [""]
        first = True
        for wline in wrapped:
            if first:
                lines.append((int(vnum), prefix + wline))
                first = False
            else:
                lines.append((None, indent + wline))
    return lines

def run_viewer(stdscr, conf: dict, book: str, chapter: int,
               verse_start: Optional[int] = None) -> str:
    """
    Full-screen passage viewer.
    Returns: 'quit', 'books', 'chapters'

    ── Selection model (simple and reliable) ────────────────────────────────
    State: cursor_line (int|None), anchor_line (int|None)

    cursor_line  — the highlighted line you navigate.  Shown with A_REVERSE
                   on a single line when no range is selected.
    anchor_line  — set by pressing Space.  Together with cursor_line it
                   defines the selected range.

    Workflow:
      a            → enter cursor mode at current top of screen
      j / k / ↑/↓ → move cursor (in cursor mode) OR scroll (normal mode)
      Space        → toggle anchor at cursor position (start/clear selection)
      j / k        → after anchor is set, moves cursor to extend selection
      y            → copy selected lines
      s            → save selected lines (or whole chapter if no selection)
      m            → bookmark cursor line's verse
      Esc          → exit cursor mode / clear selection

    Shift+Up/Down are attempted but terminals vary — j/k always works.
    Mouse: left click sets cursor; second click on different line anchors range.
    ──────────────────────────────────────────────────────────────────────────
    """
    curses.curs_set(0)
    tc = TermCompat
    show_nums   = conf.get("verse_numbers", "true") == "true"
    translation_key = conf.get("translation", "KJV")

    # Try to restore last scroll position for this book+chapter
    scroll = 0
    if (conf.get("last_book") == book and
            conf.get("last_chapter") == str(chapter)):
        try:
            scroll = int(conf.get("last_scroll", 0))
        except (ValueError, TypeError):
            scroll = 0

    # Selection / cursor state
    cursor_line = None   # line index of the movable cursor
    anchor_line = None   # fixed end of selection (set by Space)
    cursor_mode = False  # are we in cursor-navigation mode?

    # In-chapter search state
    search_str   = ""
    search_hits  = []    # list of line indices matching search
    search_idx   = 0     # which hit is current

    message = ""

    # Mouse
    mouse_first_click = None   # line index of first mouse click
    try:
        curses.mousemask(curses.BUTTON1_PRESSED)
    except Exception:
        pass

    total_chapters = get_book_chapters(translation_key, book)
    book_name  = BOOK_NAMES.get(book, book)
    trans_name = TRANSLATIONS[translation_key]["name"]

    # ── helpers ──────────────────────────────────────────────────────────

    def has_selection():
        return cursor_mode and cursor_line is not None and anchor_line is not None

    def sel_range():
        lo = min(cursor_line, anchor_line)
        hi = max(cursor_line, anchor_line)
        return lo, hi

    def clear_cursor():
        nonlocal cursor_line, anchor_line, cursor_mode, mouse_first_click
        cursor_line = anchor_line = None
        cursor_mode = False
        mouse_first_click = None

    def enter_cursor(line):
        nonlocal cursor_line, cursor_mode, anchor_line
        anchor_line  = None
        cursor_line  = max(0, min(line, total_lines - 1))
        cursor_mode  = True

    def move_cursor(delta):
        nonlocal cursor_line, scroll
        if cursor_line is None:
            return
        new = max(0, min(cursor_line + delta, total_lines - 1))
        cursor_line = new
        # Auto-scroll to keep cursor visible
        if cursor_line < scroll:
            scroll = cursor_line
        elif cursor_line >= scroll + content_h:
            scroll = cursor_line - content_h + 1

    def find_hits(query: str):
        nonlocal search_hits, search_idx
        if not query:
            search_hits = []
            search_idx  = 0
            return
        q = query.lower()
        search_hits = [i for i, (_, txt) in enumerate(lines) if q in txt.lower()]
        search_idx  = 0

    def verse_at_line(li: int) -> Optional[int]:
        """Return the verse number for display line li (may be None for wrapped lines)."""
        vn, _ = lines[li]
        if vn is not None:
            return vn
        # Walk back to find owning verse
        for i in range(li - 1, -1, -1):
            if lines[i][0] is not None:
                return lines[i][0]
        return None

    # Sentinel
    content_h  = 1
    total_lines = 1
    lines: list = []
    _last_search_chapter = None   # track when to rebuild hits
    _last_search_str     = None

    while True:
        h, w = stdscr.getmaxyx()
        wrap_w   = int(conf.get("wrap_width", 0)) or max(40, min(w - 4, 80))
        content_h = max(1, h - 4)

        lines      = format_chapter(translation_key, book, chapter, wrap_w, show_nums)
        total_lines = len(lines)

        # Auto-scroll to verse on open
        if verse_start is not None:
            for i, (vn, _) in enumerate(lines):
                if vn == verse_start:
                    scroll = max(0, i - 2)
                    break
            verse_start = None

        # Clamp scroll and cursor
        scroll = max(0, min(scroll, max(0, total_lines - content_h)))
        if cursor_line is not None:
            cursor_line = max(0, min(cursor_line, total_lines - 1))

        # Rebuild search hits only when chapter or query changes (not every frame!)
        if search_str and (chapter != _last_search_chapter or search_str != _last_search_str):
            find_hits(search_str)
            _last_search_chapter = chapter
            _last_search_str     = search_str
        elif not search_str:
            _last_search_chapter = None
            _last_search_str     = None

        stdscr.clear()

        # ── Header ───────────────────────────────────────────────────────
        header     = f"  {book_name}  {chapter} / {total_chapters}"
        trans_short = translation_key
        tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
        tc.safe_addstr(stdscr, 0, 0, header, curses.color_pair(4) | curses.A_BOLD)
        tc.safe_addstr(stdscr, 0, w - len(trans_short) - 2, trans_short, curses.color_pair(4))
        tc.hline(stdscr, 1, 0, w - 1)

        # ── Content ──────────────────────────────────────────────────────
        sel_lo, sel_hi = sel_range() if has_selection() else (None, None)
        cur_hit_line = (search_hits[search_idx % len(search_hits)]
                        if search_str and search_hits else None)

        for row in range(content_h):
            li = scroll + row
            if li >= total_lines:
                break
            vnum, text = lines[li]
            y = 2 + row

            in_sel    = sel_lo is not None and sel_lo <= li <= sel_hi
            is_cursor = cursor_mode and cursor_line == li and not in_sel
            is_hit    = bool(search_str and li in search_hits)
            is_cur_hit = (li == cur_hit_line)

            if in_sel:
                base_attr = curses.color_pair(3)
            elif is_cursor:
                base_attr = curses.color_pair(6) | curses.A_BOLD
            else:
                base_attr = 0

            # Draw line — with inline word highlighting when searching
            if is_hit and not in_sel and not is_cursor:
                # Split text around every occurrence of the query and draw
                # each segment, bolding the matched portions.
                q   = search_str.lower()
                tl  = text.lower()
                pos = 0
                x   = 0
                # Handle verse number prefix separately
                if show_nums and vnum is not None:
                    num_str = text[:5]
                    tc.safe_addstr(stdscr, y, 0, num_str,
                                   curses.color_pair(2) | curses.A_BOLD)
                    x   = 5
                    pos = 5

                word_attr     = curses.color_pair(2) | curses.A_BOLD
                cur_word_attr = curses.color_pair(3) | curses.A_BOLD  # reverse for current

                while pos < len(text):
                    idx = tl.find(q, pos)
                    if idx == -1:
                        # Rest of line — normal
                        segment = text[pos:]
                        tc.safe_addstr(stdscr, y, x, segment, 0)
                        break
                    # Text before match
                    if idx > pos:
                        before = text[pos:idx]
                        tc.safe_addstr(stdscr, y, x, before, 0)
                        x += len(before)
                    # The match itself
                    matched = text[idx:idx + len(q)]
                    attr = cur_word_attr if is_cur_hit else word_attr
                    tc.safe_addstr(stdscr, y, x, matched, attr)
                    x   += len(matched)
                    pos  = idx + len(q)
            else:
                # Normal rendering (selection / cursor / plain)
                if show_nums and vnum is not None:
                    num_str  = text[:5]
                    rest_str = text[5:]
                    num_attr = (curses.color_pair(2) | curses.A_BOLD) if base_attr == 0 else base_attr
                    tc.safe_addstr(stdscr, y, 0, num_str, num_attr)
                    tc.safe_addstr(stdscr, y, 5, rest_str, base_attr)
                else:
                    tc.safe_addstr(stdscr, y, 0, text, base_attr)

        # ── Footer ───────────────────────────────────────────────────────
        tc.hline(stdscr, h - 2, 0, w - 1)

        if message:
            footer_text = f"  {message}"
            message = ""
        elif search_str:
            hits = len(search_hits)
            idx_str = f"{search_idx + 1}/{hits}" if hits else "no matches"
            footer_text = f"  /{search_str}  [{idx_str}]  n next   N prev   Esc clear"
        elif has_selection():
            lo, hi = sel_range()
            count = hi - lo + 1
            footer_text = f"  {count} line(s) selected   y copy   s save   m bookmark   Esc clear"
        elif cursor_mode:
            vn = verse_at_line(cursor_line)
            vstr = f"v{vn} " if vn else ""
            footer_text = f"  CURSOR {vstr}  Space anchor   j/k move   m bookmark   W bookmarks   Esc exit"
        else:
            footer_text = ("  j/k scroll   a cursor   f search   m bookmark   W bookmarks"
                           "   n/p chapter   b books   t trans   ? help   q quit")

        tc.safe_addstr(stdscr, h - 1, 0, footer_text[:w - 1], curses.color_pair(5))

        if total_lines > content_h:
            pct = int(100 * scroll / max(1, total_lines - content_h))
            ind = f"{pct}%"
            tc.safe_addstr(stdscr, h - 1, w - len(ind) - 2, ind, curses.color_pair(5))

        stdscr.refresh()

        key = stdscr.getch()

        # ── Mouse ─────────────────────────────────────────────────────────
        if key == curses.KEY_MOUSE:
            try:
                _, mx, my, _, bstate = curses.getmouse()
                if (bstate & curses.BUTTON1_PRESSED) and 2 <= my < 2 + content_h:
                    clicked = scroll + (my - 2)
                    if 0 <= clicked < total_lines:
                        if mouse_first_click is None:
                            # First click: enter cursor mode at this line
                            enter_cursor(clicked)
                            mouse_first_click = clicked
                        else:
                            if clicked == mouse_first_click:
                                # Same line twice → clear
                                clear_cursor()
                            else:
                                # Different line → set anchor at first click,
                                # cursor at second click → selection complete
                                anchor_line = mouse_first_click
                                cursor_line = clicked
                                mouse_first_click = None
            except curses.error:
                pass
            continue

        # ── Shift+Up / Shift+Down via escape sequences ────────────────────
        # Most terminals send ESC [ 1 ; 2 A  (Shift+Up)
        #                        ESC [ 1 ; 2 B  (Shift+Down)
        # We read the sequence manually when we get ESC.
        # (curses.KEY_SR / KEY_SF exist on some builds but not all.)
        is_shift_up   = (hasattr(curses, 'KEY_SR') and key == curses.KEY_SR)
        is_shift_down = (hasattr(curses, 'KEY_SF') and key == curses.KEY_SF)

        if key == 27 and not is_shift_up and not is_shift_down:
            # Peek ahead for escape sequences
            stdscr.nodelay(True)
            seq = []
            while True:
                c = stdscr.getch()
                if c == -1:
                    break
                seq.append(c)
                if len(seq) > 8:
                    break
            stdscr.nodelay(False)
            # Shift+Up:   ESC [ 1 ; 2 A  → [91,49,59,50,65]
            # Shift+Down: ESC [ 1 ; 2 B  → [91,49,59,50,66]
            if seq == [91, 49, 59, 50, 65]:
                is_shift_up = True
            elif seq == [91, 49, 59, 50, 66]:
                is_shift_down = True
            elif not seq:
                # Plain ESC with no sequence → clear
                if cursor_mode or has_selection():
                    clear_cursor()
                elif search_str:
                    search_str = ""
                    search_hits = []
                continue

        if is_shift_up or is_shift_down:
            if not cursor_mode:
                enter_cursor(scroll)
            if anchor_line is None:
                anchor_line = cursor_line
            move_cursor(-1 if is_shift_up else 1)
            continue

        # ── Search: n / N to cycle hits (only when search active) ───────────
        if search_str and key == ord('n') and search_hits:
            search_idx = (search_idx + 1) % len(search_hits)
            target = search_hits[search_idx]
            scroll = max(0, min(target - content_h // 2, total_lines - content_h))
            continue
        if search_str and key == ord('N') and search_hits:
            search_idx = (search_idx - 1) % len(search_hits)
            target = search_hits[search_idx]
            scroll = max(0, min(target - content_h // 2, total_lines - content_h))
            continue

        # ── j / k : move cursor (cursor mode) or scroll (normal mode) ────
        if key in (curses.KEY_DOWN, ord('j')):
            if cursor_mode:
                move_cursor(1)
            else:
                scroll = min(scroll + 1, max(0, total_lines - content_h))
            continue
        if key in (curses.KEY_UP, ord('k')):
            if cursor_mode:
                move_cursor(-1)
            else:
                scroll = max(0, scroll - 1)
            continue

        # ── Navigation ────────────────────────────────────────────────────
        if key in (ord('q'), ord('Q')):
            conf["last_book"]    = book
            conf["last_chapter"] = str(chapter)
            conf["last_scroll"]  = str(scroll)
            save_config(conf)
            return 'quit'

        elif key == ord('b'):          # lowercase b → book browser
            return 'books'

        elif key == ord('c'):
            return 'chapters'

        elif key == ord('n') and not search_str and chapter < total_chapters:
            chapter += 1
            scroll = 0
            clear_cursor()

        elif key == ord('p') and chapter > 1:
            chapter -= 1
            scroll = 0
            clear_cursor()

        elif key == curses.KEY_RIGHT and chapter < total_chapters:
            chapter += 1
            scroll = 0
            clear_cursor()

        elif key == curses.KEY_LEFT and chapter > 1:
            chapter -= 1
            scroll = 0
            clear_cursor()

        elif key == curses.KEY_NPAGE:
            if cursor_mode:
                move_cursor(content_h)
            else:
                scroll = min(scroll + content_h, max(0, total_lines - content_h))

        elif key == curses.KEY_PPAGE:
            if cursor_mode:
                move_cursor(-content_h)
            else:
                scroll = max(0, scroll - content_h)

        elif key in (curses.KEY_HOME, ord('g')):
            scroll = 0
            if cursor_mode:
                cursor_line = 0

        elif key in (curses.KEY_END, ord('G')):
            scroll = max(0, total_lines - content_h)
            if cursor_mode:
                cursor_line = total_lines - 1

        # ── Quick jump ────────────────────────────────────────────────────
        elif key in (ord('/'), ord('r')):
            ref = run_reference_input(stdscr)
            if ref:
                b2, ch2, vs2, ve2 = ref
                data = load_translation(translation_key)
                if data and b2 in data:
                    book        = b2
                    chapter     = ch2 or 1
                    verse_start = vs2
                    scroll      = 0
                    clear_cursor()
                    book_name = BOOK_NAMES.get(book, book)
                else:
                    message = f"'{BOOK_NAMES.get(b2, b2)}' not in this translation"

        # ── In-chapter search ─────────────────────────────────────────────
        elif key == ord('f'):
            query = run_search_input(stdscr, search_str)
            if query is not None:
                search_str = query
                find_hits(search_str)
                _last_search_chapter = chapter
                _last_search_str     = search_str
                if search_hits:
                    target = search_hits[0]
                    scroll = max(0, min(target - content_h // 2, total_lines - content_h))
                    message = f"{len(search_hits)} match(es) — n/N to cycle"
                elif search_str:
                    message = "No matches"

        # ── Translation ───────────────────────────────────────────────────
        elif key == ord('t'):
            conf = run_translation_picker(stdscr, conf)
            translation_key = conf.get("translation", "KJV")
            trans_name = TRANSLATIONS[translation_key]["name"]
            scroll = 0
            clear_cursor()

        # ── Verse numbers ─────────────────────────────────────────────────
        elif key == ord('v'):
            show_nums = not show_nums
            conf["verse_numbers"] = "true" if show_nums else "false"
            message = f"Verse numbers {'on' if show_nums else 'off'}"

        # ── Cursor mode toggle ────────────────────────────────────────────
        elif key == ord('a'):
            if cursor_mode:
                clear_cursor()
            else:
                enter_cursor(scroll)

        # ── Space: set / clear anchor ─────────────────────────────────────
        elif key == ord(' '):
            if not cursor_mode:
                enter_cursor(scroll)
                anchor_line = cursor_line
            elif anchor_line is None:
                anchor_line = cursor_line
                message = "Anchor set — j/k to extend, Space to clear"
            else:
                anchor_line = None
                message = "Anchor cleared"

        # ── Bookmark add ──────────────────────────────────────────────────
        elif key == ord('m'):
            if cursor_mode and cursor_line is not None:
                vn = verse_at_line(cursor_line)
                label = f"{book_name} {chapter}" + (f":{vn}" if vn else "")
                add_bookmark(book, chapter, vn, label)
                message = f"Bookmarked: {label}"
            else:
                label = f"{book_name} {chapter}"
                add_bookmark(book, chapter, None, label)
                message = f"Bookmarked: {label}"

        # ── Bookmark browser  (capital B — distinct from lowercase b=books) ─
        elif key == ord('W'):
            result = run_bookmark_browser(stdscr)
            if result:
                bk, ch, vs = result
                data = load_translation(translation_key)
                if data and bk in data:
                    book        = bk
                    chapter     = ch
                    verse_start = vs
                    scroll      = 0
                    clear_cursor()
                    book_name = BOOK_NAMES.get(book, book)
                    total_chapters = get_book_chapters(translation_key, book)
                else:
                    message = f"'{BOOK_NAMES.get(bk, bk)}' not in this translation"

        # ── Copy ──────────────────────────────────────────────────────────
        elif key == ord('y'):
            if has_selection():
                lo, hi = sel_range()
                selected = [lines[i][1].strip() for i in range(lo, min(hi + 1, total_lines))]
                ok = copy_to_clipboard("\n".join(selected))
                message = "Copied!" if ok else "Clipboard unavailable — use s to save"
                clear_cursor()
            elif cursor_mode and cursor_line is not None:
                ok = copy_to_clipboard(lines[cursor_line][1].strip())
                message = "Line copied!" if ok else "Clipboard unavailable"
            else:
                message = "Press a then Space to select, then y to copy"

        # ── Save (S = ask for directory, s = use saved/default dir) ──────
        elif key in (ord('s'), ord('S')):
            ask_dir = (key == ord('S'))
            out_dir: Optional[Path] = None
            if ask_dir:
                saved_dir_str = conf.get("save_dir", "")
                default = Path(saved_dir_str) if saved_dir_str else get_default_save_dir()
                chosen = run_save_dir_input(stdscr, default)
                if chosen is not None:
                    out_dir = chosen
                    conf["save_dir"] = str(chosen)
                    save_config(conf)
                # If cancelled (chosen is None) use default
            else:
                saved_dir_str = conf.get("save_dir", "")
                out_dir = Path(saved_dir_str) if saved_dir_str else None

            if has_selection():
                lo, hi = sel_range()
                selected = [lines[i][1].strip() for i in range(lo, min(hi + 1, total_lines))]
                ref_str = f"{book_name} {chapter}"
                hdr     = f"{ref_str} ({trans_name})\n{'─' * len(ref_str)}\n\n"
                path = save_passage_to_file(hdr + "\n".join(selected), f"{book}_{chapter}", out_dir)
                message = f"Saved: {path}"
                clear_cursor()
            else:
                ch_lines = [ln[1].strip() for ln in lines]
                ref_str  = f"{book_name} {chapter}"
                hdr      = f"{ref_str} ({trans_name})\n{'─' * len(ref_str)}\n\n"
                path = save_passage_to_file(hdr + "\n".join(ch_lines), f"{book}_{chapter}", out_dir)
                message = f"Chapter saved: {path}"

        # ── Help ──────────────────────────────────────────────────────────
        elif key == ord('?'):
            run_help(stdscr)

        # ── Debug menu (F12) ──────────────────────────────────────────────
        elif key == curses.KEY_F12:
            run_debug_menu(stdscr, conf)

        # ── ESC handled above (after escape-sequence detection) ───────────

# HELP SCREEN

def run_help(stdscr):
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    lines = [
        ("logos  —  terminal Bible reader", True),
        ("", False),
        ("NAVIGATION", True),
        ("  j / ↓         Scroll down one line", False),
        ("  k / ↑         Scroll up one line", False),
        ("  PgDn / PgUp   Page down / up", False),
        ("  n / →         Next chapter", False),
        ("  p / ←         Previous chapter", False),
        ("  g / Home      Top of chapter", False),
        ("  G / End       Bottom of chapter", False),
        ("", False),
        ("JUMP", True),
        ("  /  or  r      Go to passage  (e.g. John 3:16, Gen 1, Rom 8:28-39)", False),
        ("  b             Book browser", False),
        ("  c             Chapter picker", False),
        ("  t             Switch translation / denomination", False),
        ("  v             Toggle verse numbers on/off", False),
        ("", False),
        ("SELECTION  (a → cursor mode → j/k move → Space anchor → j/k extend)", True),
        ("  a             Enter/exit cursor mode  (cursor appears bold/highlighted)", False),
        ("  j / k         Move cursor up/down  (while in cursor mode)", False),
        ("  Space         Set anchor at cursor  (second Space clears anchor)", False),
        ("  Shift+↑/↓     Extend selection  (auto-anchors if needed)", False),
        ("  Left click    Set cursor; second click on diff line → select range", False),
        ("  y             Copy selection to clipboard  (or single cursor line)", False),
        ("  s             Save selection to default dir  (no sel = whole chapter)", False),
        ("  S             Save — asks for output directory first (Tab autocompletes)", False),
        ("  Esc           Exit cursor mode / clear selection", False),
        ("", False),
        ("SEARCH", True),
        ("  f             Search within current chapter", False),
        ("  n             Next match", False),
        ("  N             Previous match", False),
        ("  f → Enter(empty)  Clear search", False),
        ("", False),
        ("BOOKMARKS", True),
        ("  m             Bookmark current position  (or cursor line if in cursor mode)", False),
        ("  W             Open bookmark browser  (Enter jump, d delete)", False),
        ("", False),
        ("OTHER", True),
        ("  ?             This help screen", False),
        ("  q             Quit  (reading position auto-saved)", False),
        ("", False),
        ("Clipboard requires xclip, xsel, or wl-copy on Linux.", False),
        ("Saves go to ~/logos_passages/   Bookmarks in ~/.local/share/logos/", False),
        ("No telemetry. No network calls. Your reading is always private.", False),
    ]
    scroll = 0
    content_h = h - 4

    while True:
        stdscr.clear()
        tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
        tc.safe_addstr(stdscr, 0, 2, "Help", curses.color_pair(4) | curses.A_BOLD)
        tc.hline(stdscr, 1, 0, w - 1)
        for row in range(content_h):
            li = scroll + row
            if li >= len(lines):
                break
            text, bold = lines[li]
            attr = curses.A_BOLD | curses.color_pair(1) if bold else 0
            tc.safe_addstr(stdscr, 2 + row, 2, text[:w - 4], attr)
        tc.hline(stdscr, h - 2, 0, w - 1)
        tc.safe_addstr(stdscr, h - 1, 2, "↑/↓ scroll   any other key close", curses.color_pair(5))
        stdscr.refresh()
        key = stdscr.getch()
        if key in (curses.KEY_DOWN, ord('j')):
            scroll = min(scroll + 1, max(0, len(lines) - content_h))
        elif key in (curses.KEY_UP, ord('k')):
            scroll = max(0, scroll - 1)
        else:
            return

# DATA NOT FOUND SCREEN

def run_no_data_screen(stdscr, translation_key: str):
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    info = TRANSLATIONS.get(translation_key, {})
    fname = info.get("file", "unknown.json")
    lines = [
        "",
        f"Translation data not found: {fname}",
        "",
        "logos ships with data files in the data/ directory.",
        "Make sure the data/ folder is in the same directory as logos.py.",
        "",
        f"Expected one of:",
    ]
    for p in get_data_paths(fname):
        lines.append(f"  {p}")
    lines += [
        "",
        "Press 't' to try a different translation, or 'q' to quit.",
    ]

    stdscr.clear()
    tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
    tc.safe_addstr(stdscr, 0, 2, "Data Not Found", curses.color_pair(4) | curses.A_BOLD)
    tc.hline(stdscr, 1, 0, w - 1)
    for i, line in enumerate(lines):
        tc.safe_addstr(stdscr, 2 + i, 2, line[:w - 4], curses.color_pair(5) if line.startswith("  ") else 0)
    stdscr.refresh()
    while True:
        key = stdscr.getch()
        if key == ord('q'):
            return 'quit'
        elif key == ord('t'):
            return 'switch'

# DEBUG MENU  (F12 from anywhere in the reader)

def run_debug_menu(stdscr, conf: dict):
    """
    Developer / diagnostic menu.  Access with F12.
    Lets you: override the detected OS, run self-tests, inspect state.
    """
    global _OS_OVERRIDE
    curses.curs_set(0)
    tc   = TermCompat
    sel  = 0

    def _run_self_tests(win) -> list[tuple[str, bool, str]]:
        """Run a battery of checks. Returns list of (name, passed, detail)."""
        results = []

        # 1. OS detection
        try:
            os_name = get_os()
            results.append(("OS detection", True, os_name))
        except Exception as e:
            results.append(("OS detection", False, str(e)))

        # 2. Config paths
        try:
            cd = get_config_dir()
            results.append(("Config dir", cd.exists(), str(cd)))
        except Exception as e:
            results.append(("Config dir", False, str(e)))

        try:
            dd = get_data_dir()
            results.append(("Data dir", dd.exists(), str(dd)))
        except Exception as e:
            results.append(("Data dir", False, str(e)))

        # 3. Save dir
        try:
            sd_str = conf.get("save_dir", "")
            sd = Path(sd_str) if sd_str else get_default_save_dir()
            writable = os.access(sd.parent if not sd.exists() else sd, os.W_OK)
            results.append(("Save dir writable", writable, str(sd)))
        except Exception as e:
            results.append(("Save dir", False, str(e)))

        # 4. Translation data files
        try:
            trans_key = conf.get("translation", "KJV")
            data = load_translation(trans_key)
            results.append(("Translation data", data is not None,
                             f"{trans_key} ({'loaded' if data else 'MISSING'})"))
        except Exception as e:
            results.append(("Translation data", False, str(e)))

        # 5. Bookmarks file
        try:
            bmarks = load_bookmarks()
            results.append(("Bookmarks", True, f"{len(bmarks)} saved"))
        except Exception as e:
            results.append(("Bookmarks", False, str(e)))

        # 6. Clipboard
        try:
            ok = copy_to_clipboard("logos clipboard test")
            results.append(("Clipboard", ok,
                             "functional" if ok else "no clipboard tool found (xclip/pbcopy/clip)"))
        except Exception as e:
            results.append(("Clipboard", False, str(e)))

        # 7. curses colors
        try:
            has_color = curses.has_colors()
            n_colors  = curses.COLORS if has_color else 0
            results.append(("Terminal colors", has_color, f"{n_colors} colors"))
        except Exception as e:
            results.append(("Terminal colors", False, str(e)))

        # 8. Terminal size sanity
        try:
            h2, w2 = win.getmaxyx()
            ok = h2 >= 10 and w2 >= 40
            results.append(("Terminal size", ok, f"{w2}×{h2} {'ok' if ok else '(too small)'}"))
        except Exception as e:
            results.append(("Terminal size", False, str(e)))

        # 9. KEY_F12 availability
        try:
            has_f12 = hasattr(curses, 'KEY_F12')
            results.append(("KEY_F12 constant", has_f12,
                             "defined" if has_f12 else "missing in this curses build"))
        except Exception as e:
            results.append(("KEY_F12 constant", False, str(e)))

        # 10. Scrolling arithmetic
        try:
            dummy = format_chapter("KJV", "John", 3, 60, True)
            results.append(("format_chapter (John 3)", len(dummy) > 0,
                             f"{len(dummy)} display lines"))
        except Exception as e:
            results.append(("format_chapter", False, str(e)))

        return results

    os_names = ["(auto)", "linux", "macos", "windows", "freebsd", "openbsd", "netbsd", "unknown"]

    while True:
        h, w = stdscr.getmaxyx()
        stdscr.clear()
        tc.safe_addstr(stdscr, 0, 0, " " * (w - 1), curses.color_pair(4))
        tc.safe_addstr(stdscr, 0, 2, "DEBUG MENU  (F12)", curses.color_pair(4) | curses.A_BOLD)
        tc.hline(stdscr, 1, 0, w - 1)

        effective_os = get_os()
        override_str = f"  Forced: {_OS_OVERRIDE}" if _OS_OVERRIDE else "  Auto-detected"
        tc.safe_addstr(stdscr, 2, 2, f"Detected OS : {_detect_os()}   Effective: {effective_os}{override_str}",
                       curses.color_pair(2))
        tc.safe_addstr(stdscr, 3, 2, f"Config file : {CONFIG_FILE}", curses.color_pair(5))
        tc.safe_addstr(stdscr, 4, 2, f"Data dir    : {DATA_DIR}", curses.color_pair(5))
        tc.safe_addstr(stdscr, 5, 2, f"Translation : {conf.get('translation','?')}   "
                                      f"Save dir: {conf.get('save_dir', '(default)')}", curses.color_pair(5))
        tc.safe_addstr(stdscr, 6, 2, f"Version     : {VERSION}   Python: {sys.version.split()[0]}",
                       curses.color_pair(5))

        options = [
            "Run self-tests",
            "Override OS detection",
            "Clear OS override (use auto)",
            "Clear config (reset to defaults)",
            "Show all config keys",
            "Close debug menu",
        ]
        menu_y = 8
        for i, label in enumerate(options):
            prefix = " ▶  " if i == sel else "    "
            attr = curses.A_BOLD if i == sel else 0
            tc.safe_addstr(stdscr, menu_y + i, 2, prefix + label, attr)

        tc.hline(stdscr, h - 2, 0, w - 1)
        tc.safe_addstr(stdscr, h - 1, 2, "j/k navigate   Enter select   Esc close", curses.color_pair(5))
        stdscr.refresh()

        key = stdscr.getch()
        if key in (curses.KEY_UP, ord('k')) and sel > 0:
            sel -= 1
        elif key in (curses.KEY_DOWN, ord('j')) and sel < len(options) - 1:
            sel += 1
        elif key in (27, ord('q')):
            return
        elif key in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            choice = options[sel]

            if choice == "Run self-tests":
                results = _run_self_tests(stdscr)
                # Show results in a scrollable screen
                scroll2 = 0
                while True:
                    h2, w2 = stdscr.getmaxyx()
                    stdscr.clear()
                    tc.safe_addstr(stdscr, 0, 0, " " * (w2 - 1), curses.color_pair(4))
                    tc.safe_addstr(stdscr, 0, 2, "Self-test results", curses.color_pair(4) | curses.A_BOLD)
                    tc.hline(stdscr, 1, 0, w2 - 1)
                    ch2 = h2 - 4
                    for row in range(ch2):
                        ri = scroll2 + row
                        if ri >= len(results):
                            break
                        name, passed, detail = results[ri]
                        status = "PASS" if passed else "FAIL"
                        attr   = curses.color_pair(1) if passed else curses.color_pair(2) | curses.A_BOLD
                        line   = f"  [{status}]  {name:<28}  {detail}"
                        tc.safe_addstr(stdscr, 2 + row, 0, line[:w2 - 1], attr)
                    tc.hline(stdscr, h2 - 2, 0, w2 - 1)
                    passed_n = sum(1 for _, p, _ in results if p)
                    tc.safe_addstr(stdscr, h2 - 1, 2,
                        f"{passed_n}/{len(results)} passed   j/k scroll   any other key back",
                        curses.color_pair(5))
                    stdscr.refresh()
                    k2 = stdscr.getch()
                    if k2 in (curses.KEY_DOWN, ord('j')):
                        scroll2 = min(scroll2 + 1, max(0, len(results) - ch2))
                    elif k2 in (curses.KEY_UP, ord('k')):
                        scroll2 = max(0, scroll2 - 1)
                    else:
                        break

            elif choice == "Override OS detection":
                # Small picker
                os_sel = 0
                while True:
                    h2, w2 = stdscr.getmaxyx()
                    stdscr.clear()
                    tc.safe_addstr(stdscr, 0, 0, " " * (w2 - 1), curses.color_pair(4))
                    tc.safe_addstr(stdscr, 0, 2, "Select OS to simulate", curses.color_pair(4) | curses.A_BOLD)
                    tc.hline(stdscr, 1, 0, w2 - 1)
                    for i, name in enumerate(os_names):
                        attr = curses.A_BOLD if i == os_sel else 0
                        prefix = " ▶  " if i == os_sel else "    "
                        tc.safe_addstr(stdscr, 2 + i, 2, prefix + name, attr)
                    tc.hline(stdscr, h2 - 2, 0, w2 - 1)
                    tc.safe_addstr(stdscr, h2 - 1, 2, "j/k navigate   Enter select   Esc cancel",
                                   curses.color_pair(5))
                    stdscr.refresh()
                    k2 = stdscr.getch()
                    if k2 in (curses.KEY_UP, ord('k')) and os_sel > 0:
                        os_sel -= 1
                    elif k2 in (curses.KEY_DOWN, ord('j')) and os_sel < len(os_names) - 1:
                        os_sel += 1
                    elif k2 in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
                        chosen = os_names[os_sel]
                        _OS_OVERRIDE = None if chosen == "(auto)" else chosen
                        break
                    elif k2 in (27, ord('q')):
                        break

            elif choice == "Clear OS override (use auto)":
                _OS_OVERRIDE = None

            elif choice == "Clear config (reset to defaults)":
                for k, v in DEFAULT_CONFIG.items():
                    conf[k] = v
                save_config(conf)

            elif choice == "Show all config keys":
                lines2 = [f"  {k} = {v}" for k, v in sorted(conf.items())]
                scroll2 = 0
                while True:
                    h2, w2 = stdscr.getmaxyx()
                    stdscr.clear()
                    tc.safe_addstr(stdscr, 0, 0, " " * (w2 - 1), curses.color_pair(4))
                    tc.safe_addstr(stdscr, 0, 2, "Config values", curses.color_pair(4) | curses.A_BOLD)
                    tc.hline(stdscr, 1, 0, w2 - 1)
                    ch2 = h2 - 4
                    for row in range(ch2):
                        ri = scroll2 + row
                        if ri >= len(lines2):
                            break
                        tc.safe_addstr(stdscr, 2 + row, 0, lines2[ri][:w2 - 1], curses.color_pair(5))
                    tc.hline(stdscr, h2 - 2, 0, w2 - 1)
                    tc.safe_addstr(stdscr, h2 - 1, 2, "j/k scroll   any other key back", curses.color_pair(5))
                    stdscr.refresh()
                    k2 = stdscr.getch()
                    if k2 in (curses.KEY_DOWN, ord('j')):
                        scroll2 = min(scroll2 + 1, max(0, len(lines2) - ch2))
                    elif k2 in (curses.KEY_UP, ord('k')):
                        scroll2 = max(0, scroll2 - 1)
                    else:
                        break

            elif choice == "Close debug menu":
                return

# SPLASH / HOME SCREEN

def run_home(stdscr, conf: dict) -> tuple:
    """
    Home screen with quick actions.
    Returns (action, extra_data).
    """
    curses.curs_set(0)
    h, w = stdscr.getmaxyx()
    tc = TermCompat
    translation_key = conf.get("translation", "KJV")
    trans_info = TRANSLATIONS.get(translation_key, {})

    # Build options — show "Continue reading" if a last position exists
    options = []
    last_book = conf.get("last_book", "")
    last_chap = conf.get("last_chapter", "")
    if last_book and last_chap:
        label = f"Continue  {BOOK_NAMES.get(last_book, last_book)} {last_chap}"
        options.append((label, 'continue'))
    options += [
        ("Browse books        b", 'browse'),
        ("Go to passage       /", 'goto'),
        ("Bookmarks           W", 'bookmarks'),
        ("Switch translation  t", 'translation'),
        ("Help                ?", 'help'),
        ("Quit                q", 'quit'),
    ]
    sel = 0

    # John 1:1 in Latin (Vulgate) — "In principio erat Verbum" = "In the beginning was the Word (Logos)"
    JOHN_1_1 = "In principio erat Verbum  —  Jn 1:1 (Vulgate)"

    while True:
        h, w = stdscr.getmaxyx()
        stdscr.clear()

        title_y = max(1, h // 2 - len(options) - 5)
        title    = "L O G O S"
        subtitle = "terminal Bible reader"
        tc.safe_addstr(stdscr, title_y,     (w - len(title))    // 2, title,    curses.color_pair(1) | curses.A_BOLD)
        tc.safe_addstr(stdscr, title_y + 1, (w - len(subtitle)) // 2, subtitle, curses.color_pair(5))
        tc.safe_addstr(stdscr, title_y + 2,
                       (w - len(trans_info.get('name', '')) - 2) // 2,
                       f"[{trans_info.get('name', translation_key)}]",
                       curses.color_pair(2))
        if w > len(JOHN_1_1) + 4:
            tc.safe_addstr(stdscr, title_y + 3,
                           (w - len(JOHN_1_1)) // 2, JOHN_1_1, curses.color_pair(5))

        menu_y = title_y + 5
        for i, (label, _) in enumerate(options):
            y = menu_y + i
            if y >= h - 3:
                break
            prefix = "  ▶  " if i == sel else "     "
            attr = curses.A_BOLD if i == sel else curses.color_pair(5)
            center_x = max(0, w // 2 - 20)
            tc.safe_addstr(stdscr, y, center_x, prefix + label, attr)

        tc.safe_addstr(stdscr, h - 1, 2,
                       f"logos {VERSION}  |  {get_os()}  |  no telemetry  |  fully offline  |  F12 debug",
                       curses.color_pair(5))
        stdscr.refresh()

        key = stdscr.getch()
        if key in (curses.KEY_UP, ord('k')) and sel > 0:
            sel -= 1
        elif key in (curses.KEY_DOWN, ord('j')) and sel < len(options) - 1:
            sel += 1
        elif key in (curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13):
            return (options[sel][1], None)
        elif key == ord('q'):
            return ('quit', None)
        elif key == ord('/'):
            return ('goto', None)
        elif key == ord('t'):
            return ('translation', None)
        elif key == ord('?'):
            return ('help', None)
        elif key == ord('W'):
            return ('bookmarks', None)
        elif key == ord('b'):
            return ('browse', None)
        elif key == curses.KEY_F12:
            conf2 = load_config()
            run_debug_menu(stdscr, conf2)

# MAIN APPLICATION LOOP

def main(stdscr):
    TermCompat.init_colors()
    conf = load_config()

    # First run setup
    if conf.get("setup_done", "false") == "false":
        conf = run_setup(stdscr, conf)

    # Restore last reading position, fall back to John 1
    current_book    = conf.get("last_book", "") or "John"
    current_chapter = 1
    try:
        current_chapter = int(conf.get("last_chapter", 1) or 1)
    except (ValueError, TypeError):
        current_chapter = 1

    while True:
        translation_key = conf.get("translation", "KJV")
        data = load_translation(translation_key)

        if data is None:
            action = run_no_data_screen(stdscr, translation_key)
            if action == 'quit':
                return
            elif action == 'switch':
                conf = run_translation_picker(stdscr, conf)
            continue

        # Ensure current book is valid for this translation
        books = available_books(translation_key)
        if current_book not in books:
            current_book    = books[0] if books else "Gen"
            current_chapter = 1

        action, extra = run_home(stdscr, conf)

        if action == 'quit':
            return

        elif action == 'continue':
            result = run_viewer(stdscr, conf, current_book, current_chapter)
            if result == 'quit':
                return
            elif result == 'books':
                action = 'browse'
            # fall through to next loop iteration

        elif action == 'translation':
            conf = run_translation_picker(stdscr, conf)

        elif action == 'help':
            run_help(stdscr)

        elif action == 'bookmarks':
            result = run_bookmark_browser(stdscr)
            if result:
                bk, ch, vs = result
                if bk in (data or {}):
                    current_book    = bk
                    current_chapter = ch
                    r2 = run_viewer(stdscr, conf, current_book, current_chapter, vs)
                    if r2 == 'quit':
                        return

        elif action == 'goto':
            ref = run_reference_input(stdscr)
            if ref:
                b2, ch2, vs2, ve2 = ref
                if b2 in (load_translation(translation_key) or {}):
                    current_book    = b2
                    current_chapter = ch2 or 1
                    result = run_viewer(stdscr, conf, current_book, current_chapter, vs2)
                    if result == 'quit':
                        return
                    elif result == 'books':
                        action = 'browse'

        elif action == 'browse':
            while True:
                book = run_book_picker(stdscr, conf.get("translation", "KJV"))
                if book is None:
                    break
                current_book = book
                chap = run_chapter_picker(stdscr, conf.get("translation", "KJV"), book)
                if chap is None:
                    continue
                current_chapter = chap
                result = run_viewer(stdscr, conf, current_book, current_chapter)
                if result == 'quit':
                    return
                elif result == 'books':
                    continue
                elif result == 'chapters':
                    chap2 = run_chapter_picker(stdscr, conf.get("translation", "KJV"), current_book)
                    if chap2:
                        current_chapter = chap2
                        result2 = run_viewer(stdscr, conf, current_book, current_chapter)
                        if result2 == 'quit':
                            return
                break

# ENTRY POINT

def entry():
    # Parse simple CLI args without external deps
    args = sys.argv[1:]
    if "--version" in args or "-V" in args:
        print(f"logos {VERSION}")
        sys.exit(0)
    if "--help" in args or "-h" in args:
        print(f"logos {VERSION} - terminal Bible reader")
        print()
        print("Usage: logos [OPTIONS] [REFERENCE]")
        print()
        print("  logos                    Launch interactive reader")
        print("  logos John 3:16          Open directly to John 3:16")
        print("  logos --setup            Re-run first-time setup")
        print("  logos --version          Show version")
        print()
        print("No network calls are made. Your reading is private.")
        print()
        print("Data files go in ./data/ next to logos.py")
        sys.exit(0)
    if "--setup" in args:
        conf = load_config()
        conf["setup_done"] = "false"
        save_config(conf)
        print("Setup reset. Run logos to go through setup again.")
        sys.exit(0)

    # Handle "logos John 3:16" style invocation
    direct_ref = None
    if args and not args[0].startswith("--"):
        ref_str = " ".join(args)
        direct_ref = parse_reference(ref_str)
        if not direct_ref:
            print(f"logos: could not parse reference '{ref_str}'")
            print("Try: logos John 3:16")
            sys.exit(1)

    try:
        if direct_ref:
            b2, ch2, vs2, ve2 = direct_ref
            def main_with_ref(stdscr):
                TermCompat.init_colors()
                conf = load_config()
                if conf.get("setup_done", "false") == "false":
                    conf = run_setup(stdscr, conf)
                translation_key = conf.get("translation", "KJV")
                data = load_translation(translation_key)
                book = b2
                if data and b2 not in data:
                    # Try fallback book
                    books = available_books(translation_key)
                    book = books[0] if books else "Gen"
                result = run_viewer(stdscr, conf, book, ch2 or 1, vs2)
                _ = result  # honour quit
            curses.wrapper(main_with_ref)
        else:
            curses.wrapper(main)
    except KeyboardInterrupt:
        pass

if __name__ == "__main__":
    entry()