#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Vernier Field Cipher System
kmsp42.com // rev 2.0

Interactive encoder/decoder implementing the five-stave hybrid OTP system.
TRNG from /dev/random mixed with timing jitter and user-sourced entropy.

Usage: python3 vernier.py
"""

import os
import sys
import time
import hashlib
import struct
import platform
import threading
from typing import List, Dict, Tuple, Optional

# ═══════════════════════════════════════════════════════════════════════════
# TERMINAL / COLOR
# ═══════════════════════════════════════════════════════════════════════════

USE_COLOR = hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()

# Enable ANSI on Windows if possible
if platform.system() == 'Windows':
    try:
        import ctypes
        kernel = ctypes.windll.kernel32
        kernel.SetConsoleMode(kernel.GetStdHandle(-11), 7)
        USE_COLOR = True
    except Exception:
        USE_COLOR = False

def _c(code: str, text: str) -> str:
    return f'\033[{code}m{text}\033[0m' if USE_COLOR else text

def gold(t):    return _c('38;5;179', t)
def dim(t):     return _c('2',         t)
def bright(t):  return _c('1',         t)
def orange(t):  return _c('38;5;208',  t)
def blue(t):    return _c('38;5;75',   t)
def green(t):   return _c('38;5;77',   t)
def red(t):     return _c('38;5;196',  t)
def purple(t):  return _c('38;5;141',  t)
def gray(t):    return _c('38;5;240',  t)
def cyan(t):    return _c('38;5;87',   t)

# ═══════════════════════════════════════════════════════════════════════════
# Vernier ENCODING TABLES
# ═══════════════════════════════════════════════════════════════════════════

# Primary tier: 8 most frequent English letters -- single digit codes 0-7
PRIMARY: Dict[str, int] = {
    'E': 0, 'T': 1, 'A': 2, 'O': 3,
    'I': 4, 'N': 5, 'S': 6, 'H': 7,
}

# Secondary tier: next 10 letters -- two digit codes 80-89 (prefix 8)
SECONDARY: Dict[str, int] = {
    'R': 80, 'D': 81, 'L': 82, 'C': 83, 'U': 84,
    'M': 85, 'W': 86, 'F': 87, 'G': 88, 'Y': 89,
}

# Tertiary tier: remaining rare letters + period -- two digit codes 90-98 (prefix 9, second 0-8)
TERTIARY: Dict[str, int] = {
    'P': 90, 'B': 91, 'V': 92, 'K': 93, 'J': 94,
    'X': 95, 'Q': 96, 'Z': 97, '.': 98,
}

# Numerals: digit d -> [9, 9, d] (prefix 99, third digit is numeral)
# Spaces are stripped before encoding -- no code needed

# Reverse lookup tables
_REV_PRIMARY   = {v: k for k, v in PRIMARY.items()}
_REV_SECONDARY = {v: k for k, v in SECONDARY.items()}
_REV_TERTIARY  = {v: k for k, v in TERTIARY.items()}

# All encodable chars
ALL_ENCODABLE = set(PRIMARY) | set(SECONDARY) | set(TERTIARY) | set('0123456789. ')

# ZM sequence in digits (end-of-message marker)
# Z=97=[9,7], M=85=[8,5]  -->  [9,7,8,5,3,1]
ZM_DIGITS = [9, 7, 8, 5, 3, 1]  # 6-digit marker (1-in-1M false match)

# ═══════════════════════════════════════════════════════════════════════════
# CODEBOOK
# ═══════════════════════════════════════════════════════════════════════════

# Full codebook (all 26 codes — backward compatible)
CODEBOOK: Dict[str, str] = {
    'ZA': 'CONFIRMED',
    'ZB': 'ABORT',
    'ZC': 'PROCEED',
    'ZD': 'DANGER',
    'ZE': 'DELAY',
    'ZF': 'COMPLETE',
    'ZG': 'CONFIRM LAST',
    'ZH': 'EMERGENCY',
    'ZI': 'NOTHING TO REPORT',
    'ZJ': 'AS PLANNED',
    'ZK': 'PRIMARY LOCATION',
    'ZL': 'ALTERNATE LOCATION',
    'ZM': 'END OF MESSAGE',       # RESERVED -- never reassign
    'ZN': 'MEET',
    'ZO': 'TOMORROW',
    'ZP': 'TODAY',
    'ZQ': 'LOCATION FOLLOWS',
    'ZR': 'TIME FOLLOWS',
    'ZS': 'SWITCH TO ALTERNATE',
    'ZT': 'DEAD DROP',
    'ZU': 'SURVEILLANCE DETECTED',
    'ZV': 'CLEAR',
    'ZW': 'RECEIVED AND UNDERSTOOD',
    'ZX': 'DOCUMENT FOLLOWS',
    'ZY': 'COORDINATES FOLLOW',
    'ZZ': 'NAME FOLLOWS',
}

# ── FIELD ESSENTIAL: 10 codes to memorize. The rest are on the card. ──
FIELD_ESSENTIAL = {
    'ZA': 'CONFIRMED',
    'ZB': 'ABORT',
    'ZD': 'DANGER',
    'ZH': 'EMERGENCY',
    'ZI': 'NOTHING TO REPORT',
    'ZM': 'END OF MESSAGE',
    'ZN': 'MEET',
    'ZO': 'TOMORROW',
    'ZP': 'TODAY',
    'ZW': 'RECEIVED AND UNDERSTOOD',
}

# Reverse: phrase -> code (for suggestion matching)
_CB_REVERSE: Dict[str, str] = {v: k for k, v in CODEBOOK.items() if k != 'ZM'}

# Routine circuit codes -- most useful to memorize
ROUTINE_CODES = {'ZI', 'ZW', 'ZA'}

# ═══════════════════════════════════════════════════════════════════════════
# KEYWORD DIGIT TABLE — print on pad sheet, one glance per letter
# ═══════════════════════════════════════════════════════════════════════════

KEYWORD_TABLE: Dict[str, int] = {chr(i): (i - ord('A') + 1) % 10 for i in range(ord('A'), ord('Z') + 1)}
# A=1 B=2 C=3 D=4 E=5 F=6 G=7 H=8 I=9 J=0 K=1 L=2 M=3 N=4 O=5 P=6 Q=7 R=8 S=9 T=0 U=1 V=2 W=3 X=4 Y=5 Z=6

# ═══════════════════════════════════════════════════════════════════════════
# BLOCK CLASSES
# ═══════════════════════════════════════════════════════════════════════════

BLOCK_CLASSES: Dict[str, Dict] = {
    'S': {'prefix': [0, 0], 'size': 50,  'groups': 10, 'max_content': 44},
    'M': {'prefix': [0, 1], 'size': 100, 'groups': 20, 'max_content': 94},
    'L': {'prefix': [0, 2], 'size': 200, 'groups': 40, 'max_content': 194},
}

def select_block_class(content_digit_count: int) -> str:
    """Select block class. Default to M (100 digits) — one fewer decision under stress.
    Only use S for very short messages, L only when M overflows."""
    if content_digit_count <= 94:
        return 'M'    # Default: 100 digits. Simpler than choosing.
    elif content_digit_count <= 194:
        return 'L'
    return 'SPLIT'

# ═══════════════════════════════════════════════════════════════════════════
# TRNG -- TRUE RANDOM NUMBER GENERATION
# ═══════════════════════════════════════════════════════════════════════════

class EntropyPool:
    """
    Collects entropy from multiple sources.

    Sources (combined via SHA-256):
      /dev/random  -- Linux hardware entropy pool (blocks until sufficient)
      /dev/urandom -- macOS CSPRNG (cryptographically equivalent on modern kernels)
      timing jitter -- nanosecond deltas between user events
      os.urandom   -- OS CSPRNG as mixing baseline
    """

    def __init__(self):
        self._pool: bytearray = bytearray()
        self._lock = threading.Lock()
        self._last_ns: int = time.time_ns()
        self.events: int = 0
        self.dev_bytes: int = 0

    def add_bytes(self, data: bytes) -> None:
        with self._lock:
            self._pool.extend(data)

    def add_timing(self) -> None:
        """Record a timing event. Each call adds 8 bytes of jitter entropy."""
        now = time.time_ns()
        with self._lock:
            delta = now - self._last_ns
            # Pack nanosecond delta + current timestamp for maximum jitter capture
            self._pool.extend(struct.pack('<QQ', delta, now))
            self._last_ns = now
            self.events += 1

    def size(self) -> int:
        with self._lock:
            return len(self._pool)

    def derive(self, n_bytes: int) -> bytes:
        """
        Derive n_bytes from the pool using a SHA-256 chain.
        Output is deterministically derived from the pool contents.
        Pool must contain genuine entropy for output to be secure.
        """
        with self._lock:
            seed = bytes(self._pool)

        # Final mix: hash the pool with os.urandom for defense-in-depth
        seed = hashlib.sha256(seed + os.urandom(32)).digest()

        result = b''
        ctr = 0
        while len(result) < n_bytes:
            block = hashlib.sha256(seed + struct.pack('<I', ctr)).digest()
            result += block
            ctr += 1
        return result[:n_bytes]


def _dev_random_reader(pool: EntropyPool, target: int, stop: threading.Event) -> None:
    """Background thread: drain /dev/random into the entropy pool."""
    try:
        # /dev/random on Linux blocks until the kernel entropy pool has enough bits.
        # On macOS, /dev/urandom is the correct choice (equivalent quality).
        # On Windows, fall through to os.urandom below.
        if platform.system() == 'Linux':
            dev_path = '/dev/random'
        elif platform.system() == 'Darwin':
            dev_path = '/dev/urandom'
        else:
            raise OSError('No device path on this platform')

        collected = 0
        with open(dev_path, 'rb') as f:
            while collected < target and not stop.is_set():
                want = min(32, target - collected)
                chunk = f.read(want)
                if chunk:
                    pool.add_bytes(chunk)
                    pool.dev_bytes += len(chunk)
                    collected += len(chunk)

    except OSError:
        pass
    finally:
        # Always supplement with os.urandom regardless of device availability
        pool.add_bytes(os.urandom(target))
        stop.set()


def bytes_to_uniform_digits(raw: bytes) -> List[int]:
    """
    Convert raw bytes to uniformly distributed digits 0-9.

    Uses rejection sampling: accept byte b only if b < 250.
    250 = 25 x 10, so b % 10 is exactly uniform for b in 0-249.
    Rejection rate: 6/256 = ~2.3%.
    """
    return [b % 10 for b in raw if b < 250]


def collect_entropy(n_digits: int, silent: bool = False) -> List[int]:
    """
    Collect n_digits of cryptographically random digits (0-9).

    Blocks until sufficient entropy is gathered from all sources.
    Interactive: prompts user to type/move mouse for timing entropy.
    """
    pool = EntropyPool()
    stop_event = threading.Event()

    # We need ~1.025x bytes to account for rejection sampling
    target_bytes = int(n_digits * 1.05) + 96

    # Start /dev/random reader in background
    reader = threading.Thread(
        target=_dev_random_reader,
        args=(pool, target_bytes, stop_event),
        daemon=True
    )
    reader.start()

    if not silent:
        _rule()
        print(f'\n  {gold("// ENTROPY COLLECTION")}')
        _rule()
        print(f'\n  Generating {orange(str(n_digits))} random digits.')
        print(f'\n  {dim("Sources:")}')
        dev = '/dev/random' if platform.system() == 'Linux' else '/dev/urandom'
        print(f'  {dim("  ")}  {green(dev):<22} {dim("-- hardware entropy pool")}')
        print(f'  {dim("  ")}  {green("timing jitter"):<22} {dim("-- nanosecond keystroke intervals")}')
        print(f'  {dim("  ")}  {green("os.urandom"):<22} {dim("-- CSPRNG baseline mixing")}')

        print(f'\n  {orange("While gathering:")} type random characters, vary speed and rhythm.')
        print(f'  {dim("Each keystroke timing adds entropy to the pool.")}')
        print(f'  {dim("Press")} {gold("ENTER")} {dim("when done (minimum 5 keystrokes recommended).")}')
        print()

    # Collect timing entropy interactively
    _collect_keystroke_entropy(pool, silent)

    # Wait for /dev/random reader (timeout 8s -- don't block forever)
    reader.join(timeout=8.0)

    # Final timing sample + os.urandom mixing
    pool.add_timing()
    pool.add_bytes(os.urandom(32))

    if not silent:
        print(f'\n  {dim("Pool size:")} {gold(str(pool.size()))} bytes  '
              f'{dim("Events:")} {gold(str(pool.events))}  '
              f'{dim("Device bytes:")} {gold(str(pool.dev_bytes))}')

    # Generate digits with overflow headroom
    raw = pool.derive(target_bytes * 3)
    digits = bytes_to_uniform_digits(raw)

    # Should always have enough, but safety loop just in case
    while len(digits) < n_digits:
        extra = pool.derive(64)
        digits.extend(bytes_to_uniform_digits(extra))

    result = digits[:n_digits]

    if not silent:
        check = _uniformity_check(result)
        print(f'  {dim("Uniformity:")} {check}')

    return result


def _collect_keystroke_entropy(pool: EntropyPool, silent: bool) -> None:
    """Read characters one at a time to capture keystroke timing."""
    if not silent:
        print(f'  {gray(">")} ', end='', flush=True)

    try:
        import termios
        import tty

        fd = sys.stdin.fileno()
        old = termios.tcgetattr(fd)
        try:
            tty.setraw(fd)
            while True:
                ch = sys.stdin.read(1)
                pool.add_timing()
                pool.add_bytes(bytes([ord(ch) & 0xFF]))

                if ch in ('\r', '\n'):
                    break
                elif ch == '\x03':        # Ctrl-C
                    termios.tcsetattr(fd, termios.TCSADRAIN, old)
                    raise KeyboardInterrupt
                elif ch == '\x7f':        # Backspace -- still good entropy
                    if not silent:
                        print(dim('<'), end='', flush=True)
                else:
                    if not silent:
                        print(dim('*'), end='', flush=True)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old)
    except (ImportError, Exception):
        # Windows or non-tty fallback
        try:
            line = input()
            pool.add_timing()
            pool.add_bytes(line.encode())
        except (EOFError, KeyboardInterrupt):
            pass

    if not silent:
        print()


def _uniformity_check(digits: List[int]) -> str:
    """Simple chi-squared-style uniformity test on digit distribution."""
    if not digits:
        return red('NO DATA')
    counts = [digits.count(i) for i in range(10)]
    expected = len(digits) / 10.0
    max_dev = max(abs(c - expected) / expected * 100 for c in counts)
    if max_dev < 15.0:
        return green(f'PASS  (max deviation {max_dev:.1f}%)')
    elif max_dev < 30.0:
        return orange(f'MARGINAL  (max deviation {max_dev:.1f}%)')
    else:
        return red(f'FAIL  (max deviation {max_dev:.1f}% -- regenerate)')

# ═══════════════════════════════════════════════════════════════════════════
# Vernier ENCODE / DECODE
# ═══════════════════════════════════════════════════════════════════════════

def encode_char(ch: str) -> List[int]:
    """Encode a single character to a list of Vernier digits."""
    ch = ch.upper()
    if ch in PRIMARY:
        return [PRIMARY[ch]]
    if ch in SECONDARY:
        v = SECONDARY[ch]
        return [v // 10, v % 10]           # e.g. R=80 -> [8, 0]
    if ch in TERTIARY:
        v = TERTIARY[ch]
        return [v // 10, v % 10]           # e.g. Z=97 -> [9, 7]
    if ch.isdigit():
        return [9, 9, int(ch)]             # e.g. '6' -> [9, 9, 6]
    return []                              # space and unknowns stripped


def encode_string(text: str) -> List[int]:
    """Encode a full string to Vernier digit stream. Spaces are stripped."""
    digits: List[int] = []
    for ch in text.upper():
        if ch != ' ':
            digits.extend(encode_char(ch))
    return digits


def decode_digits(digits: List[int]) -> Tuple[str, int]:
    """
    Decode a Vernier digit stream to a string.

    Returns (decoded_text, zm_position) where zm_position is the index
    of the first ZM marker in the digit stream, or -1 if not found.
    Decoding stops at ZM.
    """
    result: List[str] = []
    i = 0
    zm_pos = -1

    while i < len(digits):
        # Detect ZM = [9,7,8,5,3,1]
        if (i + 3 < len(digits) and
                digits[i] == 9 and digits[i+1] == 7 and
                digits[i+2] == 8 and digits[i+3] == 5):
            zm_pos = i
            break

        d = digits[i]

        if 0 <= d <= 7:
            # Primary: single digit
            result.append(_REV_PRIMARY.get(d, '?'))
            i += 1

        elif d == 8:
            # Secondary: two digits
            if i + 1 < len(digits):
                code = 80 + digits[i + 1]
                result.append(_REV_SECONDARY.get(code, '?'))
                i += 2
            else:
                i += 1  # truncated -- skip

        elif d == 9:
            if i + 1 >= len(digits):
                i += 1
                continue

            d2 = digits[i + 1]

            if d2 == 9:
                # Numeral: three digits [9, 9, x]
                if i + 2 < len(digits):
                    result.append(str(digits[i + 2]))
                    i += 3
                else:
                    i += 2
            else:
                # Tertiary: two digits [9, x] where x in 0-8
                code = 90 + d2
                result.append(_REV_TERTIARY.get(code, '?'))
                i += 2
        else:
            i += 1  # should not occur (digits are 0-9)

    return ''.join(result), zm_pos


def expand_codebook(text: str) -> str:
    """Expand Z-code pairs in decoded text to their full phrases."""
    out: List[str] = []
    i = 0
    while i < len(text):
        if text[i] == 'Z' and i + 1 < len(text):
            code = 'Z' + text[i + 1]
            if code in CODEBOOK and code != 'ZM':
                out.append(f'[{CODEBOOK[code]}]')
                i += 2
                continue
        out.append(text[i])
        i += 1
    return ''.join(out)


# ═══════════════════════════════════════════════════════════════════════════
# CODEBOOK INTERACTIVE APPLICATION
# ═══════════════════════════════════════════════════════════════════════════

def apply_codebook_interactive(text: str) -> str:
    """
    Suggest codebook substitutions and apply with user confirmation.
    Returns modified text with Z-codes substituted where accepted.
    """
    print(f'\n  {gold("// CODEBOOK APPLICATION")}')
    _rule()
    print(f'  Original: {bright(text)}\n')

    working = text.upper()

    # Sort by phrase length descending so longer matches take priority
    candidates = sorted(
        [(phrase, code) for code, phrase in CODEBOOK.items() if code != 'ZM'],
        key=lambda x: len(x[0]),
        reverse=True
    )

    applied: List[str] = []
    skipped: List[str] = []

    for phrase, code in candidates:
        if phrase in working:
            tag = cyan('(routine)') if code in ROUTINE_CODES else ''
            digits = encode_string('Z' + code[1])  # show encoded cost
            cost = f'{dim(str(len(digits)))} digits'
            print(f'  {gold("Match:")} {orange(phrase):<32} {green(code)} {tag}')
            print(f'  {dim("Encoded as:")} {dim(str(digits))} ({cost})')
            ans = input(f'  {dim("Apply? [Y/n]")} ').strip().lower()
            if ans != 'n':
                working = working.replace(phrase, code, 1)
                applied.append(f'{code}={phrase}')
                print(f'  {green("Applied.")}')
            else:
                skipped.append(phrase)
            print()

    # Clean up spacing
    working = ' '.join(working.split())

    if applied:
        print(f'  {green("Applied:")} {", ".join(applied)}')
    else:
        print(f'  {dim("No substitutions applied.")}')
    if skipped:
        print(f'  {dim("Skipped:")} {", ".join(skipped)}')

    print(f'  {dim("Working text:")} {bright(working)}')
    return working


# ═══════════════════════════════════════════════════════════════════════════
# MOD-10 ARITHMETIC
# ═══════════════════════════════════════════════════════════════════════════

def add_mod10(p: int, k: int) -> int:
    return (p + k) % 10

def sub_mod10(c: int, k: int) -> int:
    return (c - k + 10) % 10

def encrypt_stream(plain: List[int], key: List[int]) -> List[int]:
    """Apply (P+K) mod 10 across parallel digit streams."""
    return [add_mod10(p, k) for p, k in zip(plain, key)]

def decrypt_stream(cipher: List[int], key: List[int]) -> List[int]:
    """Apply (C-K+10) mod 10 across parallel digit streams."""
    return [sub_mod10(c, k) for c, k in zip(cipher, key)]

# ═══════════════════════════════════════════════════════════════════════════
# KEYWORD LAYER (Stave 5)
# ═══════════════════════════════════════════════════════════════════════════

def keyword_to_stream(keyword: str, length: int) -> List[int]:
    """
    Convert keyword to a cycling digit stream.
    Conversion: (alphabet position) mod 10
    A=1, B=2, ... J=0(10%10), K=1, ... Z=6(26%10)
    """
    stream: List[int] = []
    for ch in keyword.upper():
        if ch.isalpha():
            pos = ord(ch) - ord('A') + 1   # A=1 ... Z=26
            stream.append(pos % 10)
    if not stream:
        return [0] * length
    result: List[int] = []
    while len(result) < length:
        result.extend(stream)
    return result[:length]


def keyword_stream_preview(keyword: str) -> str:
    """Show the digit stream a keyword produces (first 20 digits, cycling)."""
    stream = keyword_to_stream(keyword, 20)
    return ' '.join(str(d) for d in stream) + '  ...'

# ═══════════════════════════════════════════════════════════════════════════
# DISPLAY HELPERS
# ═══════════════════════════════════════════════════════════════════════════

def _clear():
    os.system('clear' if platform.system() != 'Windows' else 'cls')

def _rule(width: int = 48):
    print(dim('  ' + '\u2500' * width))

def _header(subtitle: str = ''):
    print()
    print(gold('  \u2554' + '\u2550' * 46 + '\u2557'))
    print(gold('  \u2551') + bright('  Vernier FIELD CIPHER SYSTEM') + ' ' * 16 + gold('\u2551'))
    print(gold('  \u2551') + dim('  kmsp42.com // rev 2.0') + ' ' * 24 + gold('\u2551'))
    if subtitle:
        pad = 46 - len(subtitle) - 2
        print(gold('  \u2551') + orange(f'  {subtitle}') + ' ' * max(0, pad) + gold('\u2551'))
    print(gold('  \u255a' + '\u2550' * 46 + '\u255d'))
    print()

def _groups(digits: List[int], group_sz: int = 5, line_width: int = 10) -> str:
    """Format digit list into grouped lines (line_width groups per line)."""
    flat = ''.join(str(d) for d in digits)
    groups = [flat[i:i+group_sz] for i in range(0, len(flat), group_sz)]
    lines = []
    for i in range(0, len(groups), line_width):
        lines.append('  '.join(groups[i:i+line_width]))
    return '\n  '.join(lines)

def _print_row(label: str, digits: List[int], color_fn=None, max_digits: int = 0):
    """Print a labeled row of digit groups."""
    cf = color_fn or (lambda x: x)
    show = digits[:max_digits] if max_digits else digits
    continuation = dim('  ...') if max_digits and len(digits) > max_digits else ''
    print(f'  {gold(label + ":")}')
    print(f'  {cf(_groups(show))}' + continuation)

def _wait(msg: str = 'Press ENTER to continue...'):
    input(f'\n  {dim(msg)}')

# ═══════════════════════════════════════════════════════════════════════════
# REFERENCE SCREENS
# ═══════════════════════════════════════════════════════════════════════════

def show_encoding_table():
    _clear()
    _header('RADIX ENCODING TABLE')

    print(f'  {gold("PRIMARY")}  {dim("(0-7, single digit)")}')
    print(f'  {dim("Mnemonic: Eat Tangerines And Oranges In Nice Spanish Hotels")}')
    print()
    row = '  '
    for ch, d in PRIMARY.items():
        row += f'{bright(ch)}{dim("=")}{green(str(d))}   '
    print(row)

    print(f'\n  {gold("SECONDARY")}  {dim("(prefix 8, codes 80-89)")}')
    print(f'  {dim("Mnemonic: Really Dull Lessons Can Undermine Many Willing Fields, Gaining Yesterday")}')
    print()
    row = '  '
    for ch, d in SECONDARY.items():
        row += f'{bright(ch)}{dim("=")}{blue(str(d))}  '
    print(row)

    print(f'\n  {gold("TERTIARY")}  {dim("(prefix 9, codes 90-98)")}')
    print(f'  {dim("Mnemonic: Please Be Very Kind, Just eXercise Quietly, Zealously.")}')
    print()
    row = '  '
    for ch, d in TERTIARY.items():
        row += f'{bright(ch)}{dim("=")}{orange(str(d))}  '
    print(row)

    print(f'\n  {gold("NUMERALS")}  {dim("(prefix 99, codes 990-999)")}')
    print(f'  {dim("Rule: 990 + digit")}')
    print()
    row = '  '
    for i in range(10):
        row += f'{bright(str(i))}{dim("=")}{purple(str(990+i))}  '
    print(row)

    print(f'\n  {gold("ZM END MARKER")}  {dim("= [9,7,8,5,3,1]")}  {dim("(Z=97, M=85)")}')

    _rule()
    print(f'\n  {gold("PARSING RULE:")}')
    print(f'  {dim("d in 0-7")}        {dim("-->")}  complete. {green("One digit.")}')
    print(f'  {dim("d = 8")}           {dim("-->")}  read one more. {blue("8x secondary table.")}')
    print(f'  {dim("d = 9, x in 0-8")} {dim("-->")}  two digits total. {orange("9x tertiary table.")}')
    print(f'  {dim("d = 9, x = 9")}   {dim("-->")}  read one more. {purple("Numeral = that digit.")}')
    print()
    print(f'  {cyan("No lookahead required at any position. Each decision is final.")}')
    _wait()


def show_codebook():
    _clear()
    _header('CODEBOOK // Z-PREFIX SYSTEM')
    print(f'  {dim("Z encodes as [9,7]. Any Z+letter pair is a codebook entry.")}')
    print(f'  {dim("ZM is reserved as end-of-message. Never reassign.")}')
    print(f'  {gold("★")} {dim("= FIELD ESSENTIAL (memorize these 10)")}')
    _rule()
    print()

    items = [(k, v) for k, v in CODEBOOK.items()]
    for i in range(0, len(items), 2):
        lk, lv = items[i]
        tag_l = gold(' ★') if lk in FIELD_ESSENTIAL else ''
        ls = f'  {gold(lk)}  {dim(lv):<34}{tag_l}'
        if i + 1 < len(items):
            rk, rv = items[i + 1]
            tag_r = gold(' ★') if rk in FIELD_ESSENTIAL else ''
            rs = f'{gold(rk)}  {dim(rv)}{tag_r}'
            print(f'{ls:<52}  {rs}')
        else:
            print(ls)

    _rule()
    print(f'\n  {gold("Routine circuit")} {dim("(all fit in Short block -- 50 digits):")}')
    print(f'  {green("ZI")} {dim("ZM")}  =  nothing to report')
    print(f'  {green("ZW")} {dim("ZM")}  =  received and understood')
    print(f'  {green("ZG")} {dim("ZM")}  =  confirm last message received correctly')
    print()
    print(f'  {dim("Encoding cost per Z-code entry:")}')
    for code in ['ZA', 'ZD', 'ZN', 'ZU', 'ZI', 'ZH']:
        digs = encode_string('Z' + code[1])
        meaning = CODEBOOK[code]
        print(f'  {gold(code)} {dim("=>")} {dim(str(digs))} {dim(f"({len(digs)} digits)  [{meaning}]")}')
    _wait()


def show_block_classes():
    _clear()
    _header('BLOCK CLASSES')
    print(f'  {"Class":<8}  {"Prefix":<8}  {"Block":<8}  {"Max Content":<14}  {"Groups":<8}  Dice Rolls')
    _rule()
    print(f'  {green("S SHORT"):<8}  {dim("00"):<8}  {dim("50"):<8}  {dim("44 digits"):<14}  {dim("10"):<8}  {dim("50")}')
    print(f'  {gold("M MEDIUM"):<8}  {dim("01"):<8}  {dim("100"):<8}  {dim("94 digits"):<14}  {dim("20"):<8}  {dim("100")}')
    print(f'  {orange("L LONG"):<8}  {dim("02"):<8}  {dim("200"):<8}  {dim("194 digits"):<14}  {dim("40"):<8}  {dim("200")}')
    _rule()
    print(f'\n  {gold("Structure:")}')
    print(f'  {dim("[OFFSET 2][SALT 4][RANDOM FILL][CONTENT][ZM 6][PADDING] = block size (25, 50, or 100)")}')
    print(f'\n  {gold("Decision rule:")}')
    print(f'  {dim("Encode message fully. Count digits. Select class. Then roll dice.")}')
    print(f'  {dim("Key block size matches class (50 / 100 / 200 rolls).")}')
    print(f'\n  {gold("Typical messages:")}')
    print(f'  {green("ZI ZM")}              = 8 digits   --> {green("Short")}')
    print(f'  {green("ZH ZB ZM")}           = 11 digits  --> {green("Short")}')
    print(f'  {gold("ZN ZP ZK ZA ZM")}       = 16 digits  --> {gold("Short")}')
    print(f'  {gold("Mixed report ~60 digits")}            --> {gold("Medium")}')
    print(f'  {orange("Coordinates + instructions ~150 d")} --> {orange("Long")}')
    print(f'\n  {dim("Over 194 digits: split across two pad sheets.")}')
    _wait()


def show_mod_table():
    _clear()
    _header('MOD-10 CIPHER TABLE')
    print(f'  {dim("Row = plaintext digit (P). Column = key digit (K). Cell = cipher digit (C).")}')
    print(f'  {dim("Decrypt: find cipher value in key row, column header = plaintext.")}')
    print()

    # Header row
    hdr = f'  {dim("P\\K"):>5}'
    for j in range(10):
        hdr += f'  {blue(str(j)):>4}'
    print(hdr)
    _rule(52)

    for i in range(10):
        row_str = f'  {gold(str(i)):>5}'
        for j in range(10):
            val = (i + j) % 10
            cell = green(str(val)) if i == j else dim(str(val))
            row_str += f'  {cell:>4}'
        print(row_str)

    _rule(52)
    print(f'\n  {gold("ENCRYPT:")}  C = (P + K) mod 10')
    print(f'  {gold("DECRYPT:")}  P = (C - K + 10) mod 10')
    print(f'\n  {dim("Shaded diagonal (green): P = K. Cipher equals plaintext. Key digit is zero.")}')
    print(f'  {dim("Zero is equally likely from a random source -- not a security flaw.")}')
    _wait()

# ═══════════════════════════════════════════════════════════════════════════
# ENCRYPTION WORKFLOW
# ═══════════════════════════════════════════════════════════════════════════

def encrypt_workflow():
    _clear()
    _header('ENCRYPT MESSAGE')

    # ── Step 1: Plaintext input ──────────────────────────────────────────
    print(f'  {orange("STEP 1")}  {dim("/")}  Input plaintext')
    _rule()
    print(f'  {dim("Type or paste your message. Press ENTER when done.")}')
    print(f'  {dim("Use plain English. Codebook suggestions follow.")}')
    print()
    plaintext = input(f'  {gold("> ")}').strip()
    if not plaintext:
        print(red('\n  No input. Cancelling.'))
        time.sleep(1)
        return

    # ── Step 2: Codebook ─────────────────────────────────────────────────
    print(f'\n  {orange("STEP 2")}  {dim("/")}  Apply codebook')
    _rule()
    coded = apply_codebook_interactive(plaintext)

    # ── Step 3: RADIX encode ─────────────────────────────────────────────
    print(f'\n  {orange("STEP 3")}  {dim("/")}  Vernier encode')
    _rule()

    # Show per-character encoding
    stripped = coded.replace(' ', '')
    print(f'  {dim("Encoding:")} {bright(stripped)}\n')

    encoded: List[int] = []
    char_table: List[Tuple[str, List[int]]] = []
    for ch in stripped.upper():
        d = encode_char(ch) if ch != ' ' else []
        encoded.extend(d)
        char_table.append((ch, d))

    # Print encoding table (compact)
    line = '  '
    for ch, d in char_table:
        entry = f'{bright(ch)}{dim("->")}{cyan("".join(str(x) for x in d))}  '
        if len(line) + len(entry) > 72:
            print(line)
            line = '  '
        line += entry
    if line.strip():
        print(line)

    # Append ZM — ALWAYS
    content = encoded + ZM_DIGITS
    print(f'\n  {gold(">>> APPEND ZM END-OF-MESSAGE: 9 7 8 5 <<<")}')
    print(f'  {dim("Content + ZM:")}')
    _print_row('ENCODED', content, blue)
    print(f'  {dim("Content digit count:")} {gold(str(len(content)))}')

    # ── Step 4: Block class selection ───────────────────────────────────
    print(f'\n  {orange("STEP 4")}  {dim("/")}  Select block class')
    _rule()

    cls = select_block_class(len(content))

    if cls == 'SPLIT':
        print(f'  {red("Message too long!")} {len(content)} digits exceeds 194 digit maximum.')
        print(f'  {dim("Split into two messages on separate pad sheets.")}')
        _wait()
        return

    bc     = BLOCK_CLASSES[cls]
    bsize  = bc['size']
    prefix = bc['prefix']
    null_n = bsize - 2 - len(content)

    cls_color = {
        'S': green, 'M': gold, 'L': orange
    }.get(cls, gold)

    print(f'  Content: {gold(str(len(content)))} digits  -->  class {cls_color(cls)}')
    print(f'  Block size: {dim(str(bsize))} digits  |  Prefix: {dim(str(prefix))}  '
          f'|  Groups: {dim(str(bc["groups"]))}  |  Null fill: {dim(str(null_n))}')

    # ── Step 5: Optional keyword layer ──────────────────────────────────
    print(f'\n  {orange("STEP 5")}  {dim("/")}  Keyword layer (optional)')
    _rule()
    print(f'  {dim("Apply a memorized keyword for defense against pad physical compromise.")}')
    print(f'  {dim("Leave blank to skip Stave 5.")}')
    print(f'\n  {dim("KEYWORD DIGIT TABLE (one glance per letter):")}')
    print(f'  {blue("A=1 B=2 C=3 D=4 E=5 F=6 G=7 H=8 I=9 J=0")}')
    print(f'  {blue("K=1 L=2 M=3 N=4 O=5 P=6 Q=7 R=8 S=9 T=0")}')
    print(f'  {blue("U=1 V=2 W=3 X=4 Y=5 Z=6")}')
    print()
    kw_raw = input(f'  {gold("Keyword (ENTER to skip): ")}').strip()
    use_kw = bool(kw_raw)
    if use_kw:
        preview = keyword_stream_preview(kw_raw)
        print(f'  {dim("Keyword digit stream:")} {blue(preview)}')
        print(f'  {green("Stave 5 active.")}')
    else:
        print(f'  {dim("Stave 5 skipped.")}')

    # ── Step 6: Key generation ───────────────────────────────────────────
    print(f'\n  {orange("STEP 6")}  {dim("/")}  Generate key material ({bsize} digits)')
    _rule()
    key_digits = collect_entropy(bsize)
    _print_row('KEY', key_digits, blue)

    # ── Step 7: Build full plaintext stream and encrypt ──────────────────
    print(f'\n  {orange("STEP 7")}  {dim("/")}  Encrypt')
    _rule()

    # Full plaintext = prefix + encoded_content (ZM included)
    plain_active = prefix + content

    # Apply keyword layer before OTP if requested
    if use_kw:
        kw_stream = keyword_to_stream(kw_raw, len(plain_active))
        plain_kw = [add_mod10(p, k) for p, k in zip(plain_active, kw_stream)]
        print(f'  {dim("After keyword layer:")}')
        _print_row('P+KW', plain_kw[:30], purple, max_digits=30)
    else:
        plain_kw = plain_active

    # OTP encryption
    key_active   = key_digits[:len(plain_kw)]
    cipher_active = encrypt_stream(plain_kw, key_active)

    # Null fill: plaintext = 0, so cipher = key digit
    null_key    = key_digits[len(plain_kw):]
    cipher_null = null_key[:]   # (0 + k) mod 10 = k

    cipher_full = cipher_active + cipher_null

    # Display
    _print_row('PLAIN',  plain_active[:20], dim,   max_digits=20)
    _print_row('KEY',    key_digits[:20],   blue,  max_digits=20)
    _print_row('CIPHER', cipher_full,       green)

    verify = cipher_full[:5]

    # ── Step 8: Output ───────────────────────────────────────────────────
    print(f'\n  {orange("STEP 8")}  {dim("/")}  Transmit')
    _rule()
    print(f'\n  {gold("CIPHERTEXT:")}')
    print(f'  {green(_groups(cipher_full))}')
    print(f'\n  {gold("VERIFY STRIP")} {dim("(first 5 cipher digits):")} '
          f'{orange(_groups(verify))}')
    print(f'\n  {dim("Class:")} {cls_color(cls)}  '
          f'{dim("Digits:")} {gold(str(len(cipher_full)))}  '
          f'{dim("Groups:")} {gold(str(bc["groups"]))}')

    # ── Step 9: Save option ──────────────────────────────────────────────
    _rule()
    print(f'\n  {gold("Save key block to file?")}')
    print(f'  {red("Key file is sensitive. Share only via physical exchange.")}')
    print(f'  {dim("The receiver needs this to decrypt.")}')
    print()
    save = input(f'  {gold("Save? [y/N] ")}').strip().lower()
    if save == 'y':
        fname = input(f'  {gold("Filename [vernier_pad.txt]: ")}').strip() or 'vernier_pad.txt'
        try:
            with open(fname, 'w') as f:
                f.write('Vernier PAD SHEET\n')
                f.write('kmsp42.com // rev 2.0\n')
                f.write('=' * 48 + '\n')
                f.write(f'BLOCK CLASS:  {cls}\n')
                f.write(f'BLOCK SIZE:   {bsize}\n')
                f.write(f'GROUPS:       {bc["groups"]}\n')
                f.write(f'VERIFY STRIP: {"".join(str(d) for d in verify)}\n')
                f.write(f'KEYWORD:      {"YES (memorized only -- not stored)" if use_kw else "NO"}\n')
                f.write('KEY DIGITS:\n')
                f.write(_groups(key_digits) + '\n')
                f.write('=' * 48 + '\n')
                f.write('DESTROY THIS FILE AFTER COUNTERPART HAS THE KEY.\n')
            print(f'  {green("Saved:")} {gold(fname)}')
            print(f'  {red("Destroy file once key is physically exchanged.")}')
        except OSError as e:
            print(f'  {red("Save failed:")} {e}')

    _wait()


# ═══════════════════════════════════════════════════════════════════════════
# DECRYPTION WORKFLOW
# ═══════════════════════════════════════════════════════════════════════════

def decrypt_workflow():
    _clear()
    _header('DECRYPT MESSAGE')

    # ── Step 1: Ciphertext ───────────────────────────────────────────────
    print(f'  {orange("STEP 1")}  {dim("/")}  Enter ciphertext')
    _rule()
    print(f'  {dim("Paste received digit groups. Spaces/newlines are ignored.")}')
    print()
    raw = input(f'  {gold("Ciphertext: ")}').strip()
    cipher_digits = [int(c) for c in raw if c.isdigit()]

    if not cipher_digits:
        print(red('\n  No digits found. Cancelling.'))
        time.sleep(1)
        return

    # Detect block class
    detected_cls = None
    for cls, bc in BLOCK_CLASSES.items():
        if len(cipher_digits) == bc['size']:
            detected_cls = cls
            break

    if detected_cls:
        cls_color = {'S': green, 'M': gold, 'L': orange}[detected_cls]
        print(f'  {dim("Block class detected:")} {cls_color(detected_cls)} '
              f'{dim(f"({len(cipher_digits)} digits)")}')
    else:
        print(f'  {orange("Non-standard block size:")} {len(cipher_digits)} digits')

    _print_row('CIPHER', cipher_digits, green)

    # ── Step 2: Key digits ───────────────────────────────────────────────
    print(f'\n  {orange("STEP 2")}  {dim("/")}  Enter key digits')
    _rule()
    load = input(f'  {gold("Load from file? [y/N] ")}').strip().lower()

    key_digits: List[int] = []

    if load == 'y':
        fname = input(f'  {gold("Filename: ")}').strip()
        try:
            in_key = False
            raw_key = ''
            with open(fname, 'r') as f:
                for line in f:
                    if line.startswith('KEY DIGITS:'):
                        in_key = True
                        continue
                    if in_key:
                        raw_key += line
                        if line.startswith('='):
                            break
            key_digits = [int(c) for c in raw_key if c.isdigit()]
            print(f'  {green("Loaded")} {gold(str(len(key_digits)))} key digits from {gold(fname)}')
        except OSError as e:
            print(f'  {red("Load failed:")} {e}')

    if not key_digits:
        print(f'  {dim("Enter key digits (spaces are ignored):")}')
        raw_key = input(f'  {gold("Key: ")}').strip()
        key_digits = [int(c) for c in raw_key if c.isdigit()]

    if not key_digits:
        print(red('\n  No key digits. Cancelling.'))
        time.sleep(1)
        return

    if len(key_digits) < len(cipher_digits):
        print(f'  {orange("Warning:")} key ({len(key_digits)}) shorter than ciphertext ({len(cipher_digits)})')
        key_digits += [0] * (len(cipher_digits) - len(key_digits))

    _print_row('KEY', key_digits[:len(cipher_digits)], blue)

    # ── Step 3: Keyword layer ────────────────────────────────────────────
    print(f'\n  {orange("STEP 3")}  {dim("/")}  Keyword layer')
    _rule()
    print(f'  {dim("Enter keyword if Stave 5 was active during encryption.")}')
    kw_raw = input(f'  {gold("Keyword (ENTER to skip): ")}').strip()
    use_kw = bool(kw_raw)

    # ── Step 4: Decrypt ──────────────────────────────────────────────────
    print(f'\n  {orange("STEP 4")}  {dim("/")}  Decrypt')
    _rule()

    key_slice = key_digits[:len(cipher_digits)]
    plain_raw = decrypt_stream(cipher_digits, key_slice)

    # Remove keyword layer if active
    if use_kw:
        kw_stream = keyword_to_stream(kw_raw, len(plain_raw))
        plain_raw = [sub_mod10(p, k) for p, k in zip(plain_raw, kw_stream)]
        print(f'  {dim("Keyword layer removed.")}')

    _print_row('PLAIN RAW', plain_raw[:40], dim, max_digits=40)

    # Read block class prefix (first two digits)
    if len(plain_raw) >= 2:
        p_val = plain_raw[0] * 10 + plain_raw[1]
        prefix_map = {0: 'S', 1: 'M', 2: 'L'}
        if p_val in prefix_map:
            pfx_cls = prefix_map[p_val]
            pfx_color = {'S': green, 'M': gold, 'L': orange}[pfx_cls]
            print(f'  {dim("Prefix:")} {dim(str(plain_raw[:2]))} --> class {pfx_color(pfx_cls)}')
            content_digits = plain_raw[2:]
        else:
            print(f'  {orange("Unexpected prefix digits:")} {plain_raw[:2]}')
            content_digits = plain_raw
    else:
        content_digits = plain_raw

    # ── Step 5: RADIX decode ─────────────────────────────────────────────
    print(f'\n  {orange("STEP 5")}  {dim("/")}  RADIX decode')
    _rule()

    decoded, zm_pos = decode_digits(content_digits)

    if zm_pos >= 0:
        print(f'  {dim("ZM marker found at content position")} {gold(str(zm_pos))} '
              f'{dim("-- truncating null fill.")}')
    else:
        print(f'  {orange("ZM marker not found.")} '
              f'{dim("Wrong key, wrong block class, or transmission error.")}')

    expanded = expand_codebook(decoded)

    print()
    print(f'  {gold("DECODED RAW:")}')
    print(f'  {blue(decoded)}')
    print()
    print(f'  {gold("PLAINTEXT:")}')
    print(f'  {bright(expanded)}')

    # Show codebook expansions detail
    if any(f'Z{c}' in decoded for c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'):
        _rule()
        print(f'\n  {gold("Codebook expansions:")}')
        i = 0
        while i < len(decoded):
            if decoded[i] == 'Z' and i + 1 < len(decoded):
                code = 'Z' + decoded[i+1]
                if code in CODEBOOK:
                    print(f'  {green(code)} --> {CODEBOOK[code]}')
                i += 2
            else:
                i += 1

    _wait()

# ═══════════════════════════════════════════════════════════════════════════
# QUICK ENCODE / DECODE UTILITIES
# ═══════════════════════════════════════════════════════════════════════════

def quick_encode():
    """Encode a string to RADIX digits without encryption."""
    _clear()
    _header('QUICK ENCODE -- No Encryption')
    print(f'  {dim("Encodes text to Vernier digits only. For practice and testing.")}')
    _rule()
    text = input(f'\n  {gold("Text: ")}').strip()
    if not text:
        return
    enc = encode_string(text)
    print(f'\n  {gold("Input:")}'
          f'  {bright(text.upper())}')
    print(f'\n  {gold("RADIX digits:")}')
    _print_row('OUT', enc, green)
    print(f'\n  {dim("Count:")} {gold(str(len(enc)))} digits')

    # Also show block class this would require
    cls = select_block_class(len(enc) + 4)  # +4 for ZM
    print(f'  {dim("Block class (with ZM):")} {gold(cls)}')
    _wait()


def quick_decode():
    """Decode a RADIX digit string without decryption."""
    _clear()
    _header('QUICK DECODE -- No Decryption')
    print(f'  {dim("Decodes Vernier digit stream only. For practice and testing.")}')
    _rule()
    raw = input(f'\n  {gold("Digits: ")}').strip()
    digits = [int(c) for c in raw if c.isdigit()]
    if not digits:
        return
    decoded, zm_pos = decode_digits(digits)
    expanded = expand_codebook(decoded)
    print(f'\n  {gold("Decoded raw:")}   {blue(decoded)}')
    print(f'\n  {gold("Plaintext:")}     {bright(expanded)}')
    if zm_pos >= 0:
        print(f'\n  {dim("ZM at position")} {gold(str(zm_pos))}')
    _wait()


def keyword_tool():
    """Preview keyword digit stream."""
    _clear()
    _header('KEYWORD STREAM PREVIEW')
    print(f'  {dim("Converts a keyword to its cycling mod-10 digit stream.")}')
    print(f'  {dim("Use this to verify both parties have the same stream before operation.")}')
    _rule()
    kw = input(f'\n  {gold("Keyword: ")}').strip()
    if not kw:
        return
    stream = keyword_to_stream(kw, 50)
    print(f'\n  {dim("Keyword:")} {bright(kw.upper())}')
    print()
    chars = list(kw.upper())
    detail = '  '
    for ch in chars:
        if ch.isalpha():
            pos = ord(ch) - ord('A') + 1
            d = pos % 10
            detail += f'{bright(ch)}{dim("->")}{blue(str(d))}  '
    print(detail)
    print(f'\n  {dim("Cycling stream (50 digits):")}')
    _print_row('STREAM', stream, blue)
    check = _uniformity_check(stream)
    print(f'\n  {dim("Distribution:")} {check}')
    _wait()

# ═══════════════════════════════════════════════════════════════════════════
# PRINTABLE FIELD CARD + WORKSHEET GENERATOR
# ═══════════════════════════════════════════════════════════════════════════

def generate_field_card():
    """Generate a printable text field card with everything needed for hand operation."""
    _clear()
    _header('GENERATE FIELD CARD')
    print(f'  {dim("Generates a printable text file with:")}')
    print(f'  {dim("  - RADIX encoding table")}')
    print(f'  {dim("  - Essential codebook (10 codes)")}')
    print(f'  {dim("  - Keyword digit table")}')
    print(f'  {dim("  - Mod-10 addition/subtraction tables")}')
    print(f'  {dim("  - Pre-ruled encryption worksheet with key + null digits")}')
    print()

    sheets = 1
    raw = input(f'  {gold("How many pad sheets? [1] ")}').strip()
    if raw.isdigit() and int(raw) > 0:
        sheets = min(int(raw), 10)

    fname = input(f'  {gold("Filename [vernier_field_card.txt]: ")}').strip() or 'vernier_field_card.txt'

    import random as _rng

    try:
        with open(fname, 'w') as f:
            w = f.write

            # ── Header ──
            w('=' * 60 + '\n')
            w('  Vernier FIELD CARD // kmsp42.com rev 2.0\n')
            w('  PRINT THIS. LAMINATE THE CARD. DESTROY PAD SHEETS AFTER USE.\n')
            w('=' * 60 + '\n\n')

            # ── RADIX Encoding Table ──
            w('─── RADIX ENCODING TABLE ───────────────────────────────\n\n')
            w('  SINGLE DIGIT (0-7):  most common letters\n')
            w('  ┌───┬───┬───┬───┬───┬───┬───┬───┐\n')
            w('  │ E │ T │ A │ O │ I │ N │ S │ H │\n')
            w('  │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │\n')
            w('  └───┴───┴───┴───┴───┴───┴───┴───┘\n\n')
            w('  TWO DIGIT (8x):  medium frequency\n')
            w('  ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐\n')
            w('  │ R  │ D  │ L  │ C  │ U  │ M  │ W  │ F  │ G  │ Y  │\n')
            w('  │ 80 │ 81 │ 82 │ 83 │ 84 │ 85 │ 86 │ 87 │ 88 │ 89 │\n')
            w('  └────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘\n\n')
            w('  TWO DIGIT (9x):  rare letters + period\n')
            w('  ┌────┬────┬────┬────┬────┬────┬────┬────┬────┐\n')
            w('  │ P  │ B  │ V  │ K  │ J  │ X  │ Q  │ Z  │ .  │\n')
            w('  │ 90 │ 91 │ 92 │ 93 │ 94 │ 95 │ 96 │ 97 │ 98 │\n')
            w('  └────┴────┴────┴────┴────┴────┴────┴────┴────┘\n\n')
            w('  NUMERALS: digit d → 99d  (e.g. 6 → 996)\n\n')
            w('  PARSING: 0-7=done | 8=read 1 more | 9(0-8)=done | 99=read 1 more\n')
            w('  END OF MESSAGE: ALWAYS APPEND  9 7 8 5  (ZM)\n\n')

            # ── Essential Codebook ──
            w('─── ESSENTIAL CODEBOOK (memorize these 10) ──────────────\n\n')
            for code, phrase in FIELD_ESSENTIAL.items():
                w(f'  {code}  {phrase}\n')
            w('\n')

            # ── Keyword Digit Table ──
            w('─── KEYWORD DIGIT TABLE ─────────────────────────────────\n\n')
            w('  A=1  B=2  C=3  D=4  E=5  F=6  G=7  H=8  I=9  J=0\n')
            w('  K=1  L=2  M=3  N=4  O=5  P=6  Q=7  R=8  S=9  T=0\n')
            w('  U=1  V=2  W=3  X=4  Y=5  Z=6\n\n')

            # ── Mod-10 Tables ──
            w('─── MOD-10 ADDITION TABLE ───────────────────────────────\n')
            w('  ENCRYPT: find P row, K column, read cipher digit\n\n')
            w('    + │ 0  1  2  3  4  5  6  7  8  9\n')
            w('  ────┼──────────────────────────────\n')
            for r in range(10):
                row = '  '.join(str((r + c) % 10) for c in range(10))
                w(f'    {r} │ {row}\n')
            w('\n')

            w('─── MOD-10 SUBTRACTION TABLE ────────────────────────────\n')
            w('  DECRYPT: find C row, K column, read plain digit\n\n')
            w('    - │ 0  1  2  3  4  5  6  7  8  9\n')
            w('  ────┼──────────────────────────────\n')
            for r in range(10):
                row = '  '.join(str((r - c + 10) % 10) for c in range(10))
                w(f'    {r} │ {row}\n')
            w('\n')

            # ── Pad Sheets ──
            for sheet_num in range(1, sheets + 1):
                w('=' * 60 + '\n')
                w(f'  PAD SHEET {sheet_num:02d}  //  100 DIGITS  //  SINGLE USE\n')
                w('  DESTROY AFTER ENCRYPTING OR DECRYPTING ONE MESSAGE.\n')
                w('=' * 60 + '\n\n')

                # Generate 100 truly random key digits
                pool = EntropyPool()
                pool.collect_urandom(200)
                key = pool.extract_digits(100)

                # Pre-generate 100 null digits too
                pool2 = EntropyPool()
                pool2.collect_urandom(200)
                nulls = pool2.extract_digits(100)

                w('  KEY DIGITS (100):\n')
                flat = ''.join(str(d) for d in key)
                for i in range(0, 100, 50):
                    groups = [flat[j:j+5] for j in range(i, min(i+50, 100), 5)]
                    w('  ' + '  '.join(groups) + '\n')
                w('\n')

                w('  NULL FILL DIGITS (use to pad short messages):\n')
                flat_n = ''.join(str(d) for d in nulls)
                for i in range(0, 100, 50):
                    groups = [flat_n[j:j+5] for j in range(i, min(i+50, 100), 5)]
                    w('  ' + '  '.join(groups) + '\n')
                w('\n')

                # Pre-ruled worksheet
                w('  ─── ENCRYPTION WORKSHEET ───\n\n')
                w('  PLAINTEXT:  _____ _____ _____ _____ _____ _____ _____ _____ _____ _____\n')
                w('              _____ _____ _____ _____ _____ _____ _____ _____ _____ _____\n\n')
                w('  + KEYWORD:  _____ _____ _____ _____ _____ _____ _____ _____ _____ _____\n')
                w('              _____ _____ _____ _____ _____ _____ _____ _____ _____ _____\n\n')
                w('  = P+KW:    _____ _____ _____ _____ _____ _____ _____ _____ _____ _____\n')
                w('              _____ _____ _____ _____ _____ _____ _____ _____ _____ _____\n\n')
                w('  + KEY:     (copy from KEY DIGITS above)\n\n')
                w('  = CIPHER:  _____ _____ _____ _____ _____ _____ _____ _____ _____ _____\n')
                w('              _____ _____ _____ _____ _____ _____ _____ _____ _____ _____\n\n')
                w('  VERIFY STRIP (first 5 cipher digits): _____\n')
                w('  Remember: APPEND 9 7 8 5 (ZM) TO YOUR ENCODED TEXT BEFORE ENCRYPTING\n\n')

        print(f'\n  {green("Saved:")} {gold(fname)}')
        print(f'  {dim(f"Contains: encoding table, codebook, keyword table, mod-10 tables, {sheets} pad sheet(s) with worksheets")}')
        print(f'  {red("Print the card. Laminate it. Destroy pad sheets after single use.")}')
    except OSError as e:
        print(f'  {red("Save failed:")} {e}')

    _wait()


# ═══════════════════════════════════════════════════════════════════════════
# AUTOMATIC DEMO — FULL ENCRYPT/DECRYPT CYCLE
# ═══════════════════════════════════════════════════════════════════════════

def demo_workflow():
    """Run the complete five-stave encrypt/decrypt cycle automatically with narration."""
    _clear()
    _header('AUTOMATIC DEMO — SOUP TO NUTS')

    # ── Setup ────────────────────────────────────────────────────────────
    sample   = 'MEET AT DEAD DROP TOMORROW'
    keyword  = 'CIPHER'

    print(f'  {gold("This demo encrypts a message through all five staves,")}')
    print(f'  {gold("then decrypts it back, showing every intermediate step.")}')
    print()
    print(f'  {dim("Plaintext:")}  {bright(sample)}')
    print(f'  {dim("Keyword:")}    {bright(keyword)}')
    print(f'  {dim("Codebook:")}   active')
    print(f'  {dim("Block size:")} auto-selected')
    _rule()
    input(f'\n  {dim("Press ENTER to begin...")}')

    # ══════════════════════════════════════════════════════════════════════
    # ENCRYPTION
    # ══════════════════════════════════════════════════════════════════════

    print(f'\n  {orange("═══ ENCRYPTION ═══")}')

    # ── Stave 1: Codebook ────────────────────────────────────────────────
    print(f'\n  {orange("STAVE 1")}  {dim("/")}  Codebook compression')
    _rule()
    print(f'  {dim("Original:")}    {bright(sample)}')

    # Apply codebook manually: MEET -> ZN, DEAD DROP -> ZT, TOMORROW -> ZO
    coded = 'ZN AT ZT ZO'
    # Build the mapping display
    print(f'  {dim("MEET")}         {dim("->")} {cyan("ZN")} {dim("(codebook)")}'  )
    print(f'  {dim("DEAD DROP")}    {dim("->")} {cyan("ZT")} {dim("(codebook)")}')
    print(f'  {dim("TOMORROW")}     {dim("->")} {cyan("ZO")} {dim("(codebook)")}')
    print(f'  {dim("After codebook:")} {bright(coded)}')
    print(f'  {dim("Compression:")} {green(f"{len(sample)} chars -> {len(coded.replace(chr(32), str()))} chars")}')
    input(f'\n  {dim("ENTER to continue...")}')

    # ── Stave 2: Vernier Encoding ───────────────────────────────────────
    print(f'\n  {orange("STAVE 2")}  {dim("/")}  Vernier variable-length encoding')
    _rule()
    stripped = coded.replace(' ', '')
    print(f'  {dim("Input:")} {bright(stripped)}')
    print()

    # Show per-character encoding
    encoded: List[int] = []
    for ch in stripped.upper():
        d = encode_char(ch)
        encoded.extend(d)
        code_str = ''.join(str(x) for x in d)
        length_desc = {1: 'single', 2: 'double', 3: 'triple'}.get(len(d), '?')
        tier = ''
        if ch in PRIMARY:    tier = 'primary (0-7)'
        elif ch in SECONDARY: tier = 'secondary (8x)'
        elif ch in TERTIARY:  tier = 'tertiary (9x)'
        print(f'    {bright(ch)}  {dim("->")}  {cyan(code_str):>5}  '
              f'{dim(f"[{length_desc}, {tier}]")}')

    # Append end-of-message marker
    content = encoded + ZM_DIGITS
    print(f'\n  {dim("End-of-message marker (ZM):")} {cyan("978531")}')
    print(f'\n  {dim("Full digit stream:")}')
    _print_row('ENCODED', content, cyan)
    print(f'  {dim("Digit count:")} {gold(str(len(content)))}')
    print(f'\n  {dim("Parsing rule:")} {green("0-7 = 1 digit  |  8x = 2 digits  |  9(0-8) = 2 digits  |  99x = 3 digits")}')
    input(f'\n  {dim("ENTER to continue...")}')

    # ── Block class selection ────────────────────────────────────────────
    print(f'\n  {orange("BLOCK")}  {dim("/")}  Select block class')
    _rule()
    cls = select_block_class(len(content))
    bc  = BLOCK_CLASSES[cls]
    bsize  = bc['size']
    prefix = bc['prefix']
    null_n = bsize - 2 - len(content)
    print(f'  {dim("Content:")} {gold(str(len(content)))} digits')
    print(f'  {dim("Block class:")} {green(cls)} ({bsize} digits, {bc["groups"]} groups)')
    print(f'  {dim("Prefix:")} {cyan("".join(str(d) for d in prefix))}')
    print(f'  {dim("Null fill:")} {gold(str(null_n))} random digits')

    # Build full plaintext
    plain_active = prefix + content

    # ── Stave 5: Keyword ─────────────────────────────────────────────────
    print(f'\n  {orange("STAVE 5")}  {dim("/")}  Keyword defense')
    _rule()
    print(f'  {dim("Keyword:")} {bright(keyword)}')
    kw_stream = keyword_to_stream(keyword, len(plain_active))
    print(f'  {dim("Keyword -> digit stream:")}')
    kw_preview = ' '.join(str(d) for d in kw_stream[:20])
    print(f'    {blue(kw_preview)} {dim("... (lagged Fibonacci, non-repeating)")}')
    print()
    print(f'  {dim("Before keyword:")}')
    _print_row('PLAIN', plain_active, dim)
    print(f'  {dim("Keyword stream:")}')
    _print_row('KW',    kw_stream[:len(plain_active)], blue)

    plain_kw = [add_mod10(p, k) for p, k in zip(plain_active, kw_stream)]
    print(f'  {dim("After keyword (P + KW) mod 10:")}')
    _print_row('P+KW', plain_kw, purple)
    input(f'\n  {dim("ENTER to continue...")}')

    # ── Stave 3: One-Time Pad ────────────────────────────────────────────
    print(f'\n  {orange("STAVE 3")}  {dim("/")}  One-time pad encryption')
    _rule()
    print(f'  {dim("Generating")} {gold(str(bsize))} {dim("truly random key digits...")}')
    key_digits = collect_entropy(bsize)
    print()

    # Active encryption
    key_active    = key_digits[:len(plain_kw)]
    cipher_active = encrypt_stream(plain_kw, key_active)

    # Null fill (random)
    null_key     = key_digits[len(plain_kw):]
    cipher_null  = null_key[:]  # (0 + k) mod 10 = k

    cipher_full  = cipher_active + cipher_null

    print(f'  {dim("P+KW digits:")}')
    _print_row('P+KW', plain_kw, purple)
    print(f'  {dim("OTP key:")}')
    _print_row('KEY',  key_digits, blue)
    print(f'  {dim("Cipher (P+KW + KEY) mod 10:")}')
    _print_row('CIPHER', cipher_full, green)
    print()
    print(f'  {dim("Null-filled:")} {gold(str(null_n))} {dim("digits at end are indistinguishable from ciphertext")}')
    input(f'\n  {dim("ENTER to continue...")}')

    # ── Stave 4: Block formatting ────────────────────────────────────────
    print(f'\n  {orange("STAVE 4")}  {dim("/")}  Fixed-size block discipline')
    _rule()
    print(f'  {dim("All messages are")} {gold(str(bsize))} {dim("digits regardless of content length.")}')
    print(f'  {dim("An eavesdropper cannot determine message length.")}')
    print()
    print(f'  {gold("CIPHERTEXT FOR TRANSMISSION:")}')
    print()
    groups_str = _groups(cipher_full)
    print(f'  {green(groups_str)}')
    print()
    verify = cipher_full[:5]
    print(f'  {gold("VERIFY STRIP")} {dim("(first 5):")} {orange(_groups(verify))}')
    print(f'  {dim("Class:")} {green(cls)}  {dim("Digits:")} {gold(str(len(cipher_full)))}  '
          f'{dim("Groups:")} {gold(str(bc["groups"]))}')

    _rule()
    print(f'\n  {bright("Encryption complete. All 5 layers applied.")}')
    print(f'  {dim("The ciphertext above is what gets transmitted.")}')
    input(f'\n  {dim("ENTER for decryption...")}')

    # ══════════════════════════════════════════════════════════════════════
    # DECRYPTION — reverse all layers
    # ══════════════════════════════════════════════════════════════════════

    _clear()
    _header('AUTOMATIC DEMO — DECRYPTION')

    print(f'  {orange("═══ DECRYPTION ═══")}')
    print(f'\n  {dim("Received ciphertext:")}')
    print(f'  {green(groups_str)}')
    print(f'  {dim("Key material (from pad sheet):")}')
    _print_row('KEY', key_digits, blue)

    # ── Strip OTP ────────────────────────────────────────────────────────
    print(f'\n  {orange("STAVE 3")}  {dim("/")}  Remove one-time pad')
    _rule()
    decrypted_full = decrypt_stream(cipher_full, key_digits)
    print(f'  {dim("(CIPHER - KEY + 10) mod 10:")}')
    _print_row('DEC', decrypted_full, purple)

    # ── Strip keyword ────────────────────────────────────────────────────
    print(f'\n  {orange("STAVE 5")}  {dim("/")}  Remove keyword')
    _rule()
    print(f'  {dim("Keyword:")} {bright(keyword)}')
    kw_full = keyword_to_stream(keyword, len(decrypted_full))
    plain_recovered = [sub_mod10(d, k) for d, k in zip(decrypted_full, kw_full)]
    print(f'  {dim("(DEC - KW + 10) mod 10:")}')
    _print_row('PLAIN', plain_recovered, cyan)

    # ── Parse prefix and content ─────────────────────────────────────────
    print(f'\n  {orange("BLOCK")}  {dim("/")}  Parse block prefix')
    _rule()
    pfx = plain_recovered[:2]
    body = plain_recovered[2:]
    pfx_str = ''.join(str(d) for d in pfx)
    detected_cls = None
    for k, v in BLOCK_CLASSES.items():
        if v['prefix'] == pfx:
            detected_cls = k
            break
    print(f'  {dim("Prefix:")} {cyan(pfx_str)} {dim("-> class")} {green(detected_cls or "?")}')

    # ── RADIX decode ─────────────────────────────────────────────────────
    print(f'\n  {orange("STAVE 2")}  {dim("/")}  Vernier decode')
    _rule()
    decoded, consumed = decode_digits(body)
    print(f'  {dim("Digit stream -> characters:")}')

    # Show the parsing process
    pos = 0
    parse_body = body[:consumed] if consumed > 0 else body
    while pos < len(parse_body):
        d0 = parse_body[pos]
        if d0 <= 7:
            ch = _REV_PRIMARY.get(d0, '?')
            print(f'    {cyan(str(d0)):>8}  {dim("->")}  {bright(ch)}  {dim("[single digit, primary]")}')
            pos += 1
        elif d0 == 8:
            if pos + 1 < len(parse_body):
                code = d0 * 10 + parse_body[pos + 1]
                ch = _REV_SECONDARY.get(code, '?')
                print(f'    {cyan(str(d0) + str(parse_body[pos+1])):>8}  {dim("->")}  {bright(ch)}  {dim("[two digit, secondary]")}')
                pos += 2
            else:
                break
        elif d0 == 9:
            if pos + 1 < len(parse_body):
                d1 = parse_body[pos + 1]
                if d1 <= 8:
                    code = d0 * 10 + d1
                    ch = _REV_TERTIARY.get(code, '?')
                    if ch == '?' and code == 97 and pos + 2 < len(parse_body) and parse_body[pos+2] == 8 and pos + 3 < len(parse_body) and parse_body[pos+3] == 5:
                        # ZM marker
                        print(f'    {cyan("978531"):>8}  {dim("->")}  {gold("ZM")}  {dim("[end-of-message]")}')
                        break
                    print(f'    {cyan(str(d0) + str(d1)):>8}  {dim("->")}  {bright(ch)}  {dim("[two digit, tertiary]")}')
                    pos += 2
                elif d1 == 9:
                    if pos + 2 < len(parse_body):
                        numeral = parse_body[pos + 2]
                        print(f'    {cyan(str(d0) + str(d1) + str(numeral)):>8}  {dim("->")}  {bright(str(numeral))}  {dim("[three digit, numeral]")}')
                        pos += 3
                    else:
                        break
            else:
                break
        else:
            pos += 1

    print(f'\n  {dim("Decoded text:")} {bright(decoded)}')

    # ── Codebook expansion ───────────────────────────────────────────────
    print(f'\n  {orange("STAVE 1")}  {dim("/")}  Codebook expansion')
    _rule()
    expanded = decoded
    for code, phrase in CODEBOOK.items():
        if code in expanded and code != 'ZM':
            expanded = expanded.replace(code, phrase)
            print(f'    {cyan(code)}  {dim("->")}  {bright(phrase)}')
    print(f'\n  {dim("Final plaintext:")} {bright(expanded)}')

    # ── Verify ───────────────────────────────────────────────────────────
    _rule()
    original_clean = sample.replace(' ', '').upper()
    recovered_clean = expanded.replace(' ', '').upper()
    if original_clean == recovered_clean:
        print(f'\n  {green("✓ INTEGRITY VERIFIED")} — decrypted plaintext matches original')
    else:
        print(f'\n  {red("✗ MISMATCH")}')
        print(f'    {dim("Original:")}  {sample}')
        print(f'    {dim("Recovered:")} {expanded}')

    print(f'\n  {dim("All 5 layers reversed successfully.")}')
    print(f'  {dim("The cipher is information-theoretically secure: no computation,")}')
    print(f'  {dim("classical or quantum, can break it without the key material.")}')
    _wait()


# ═══════════════════════════════════════════════════════════════════════════
# MAIN MENU
# ═══════════════════════════════════════════════════════════════════════════

MENU_ITEMS = [
    ('1', 'Encrypt message',         encrypt_workflow,    bright),
    ('2', 'Decrypt message',         decrypt_workflow,    bright),
    (None, None, None, None),
    ('3', 'Quick encode (no OTP)',   quick_encode,        dim),
    ('4', 'Quick decode (no OTP)',   quick_decode,        dim),
    ('5', 'Keyword stream preview',  keyword_tool,        dim),
    (None, None, None, None),
    ('6', 'Encoding table',          show_encoding_table, dim),
    ('7', 'Codebook',                show_codebook,       dim),
    ('8', 'Block classes',           show_block_classes,  dim),
    ('9', 'Mod-10 cipher table',     show_mod_table,      dim),
    (None, None, None, None),
    ('D', 'Demo (full cycle)',       demo_workflow,       gold),
    ('F', 'Field card + pad sheets', generate_field_card, gold),
    ('Q', 'Quit',                    None,                gray),
]


def main():
    try:
        while True:
            _clear()
            _header()
            for key, label, _, color_fn in MENU_ITEMS:
                if key is None:
                    print(dim('  ' + '\u2500' * 32))
                else:
                    print(f'  {gold(key)}  {color_fn(label)}')
            print()

            choice = input(f'  {gold("> ")}').strip().lower()

            for key, _, fn, _ in MENU_ITEMS:
                if key and choice == key.lower():
                    if fn:
                        fn()
                    break
            else:
                if choice in ('exit', 'quit', 'q'):
                    break

    except KeyboardInterrupt:
        pass
    finally:
        _clear()
        print(f'\n  {dim("Vernier // session ended cleanly")}\n')
        sys.exit(0)


if __name__ == '__main__':
    if '--demo' in sys.argv:
        demo_workflow()
    else:
        main()