emulator.py

#!/usr/bin/env python3
"""
emulator.py — NetID Monitor display emulator

Shows a live tkinter window of what the USB display would render, allowing
development of display changes without a physical dongle.

Usage:
    python emulator.py                              # large screen, live data
    python emulator.py --small --scale 4            # small screen, scaled up
    python emulator.py --hostname "test-01" --ip "10.0.0.1"
    python emulator.py --interval 2 --verbose       # fast refresh
"""

import argparse
import logging
import sys
from typing import Optional

try:
    import tkinter as tk
except ImportError:
    print(
        "ERROR: tkinter is not available.\n"
        "Install it with:  sudo apt install python3-tk",
        file=sys.stderr,
    )
    sys.exit(1)

try:
    from PIL import Image, ImageTk
except ImportError:
    print(
        "ERROR: Pillow is not installed.\n"
        "Install it with:  pip install pillow",
        file=sys.stderr,
    )
    sys.exit(1)

# Import render functions and constants from the production module.
# emulator.py is expected to live alongside netid_monitor.py.
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from netid_monitor import (
    render_screen,
    render_small_screen,
    get_hostname,
    get_ip,
)

log = logging.getLogger("emulator")


class EmulatorWindow:
    """Tkinter window that mirrors the USB display, refreshing periodically."""

    def __init__(
        self,
        small: bool = False,
        interval: float = 10.0,
        hostname_override: Optional[str] = None,
        ip_override: Optional[str] = None,
        scale: int = 1,
    ) -> None:
        self._small = small
        self._interval_ms = int(interval * 1000)
        self._hostname = hostname_override
        self._ip = ip_override
        self._scale = max(1, min(scale, 8))
        self._tk_image: Optional[ImageTk.PhotoImage] = None  # must stay on self (GC safety)

        self._root = tk.Tk()
        self._root.resizable(False, False)
        self._root.configure(bg="black")

        self._label = tk.Label(self._root, bd=0, bg="black")
        self._label.pack()

        # Populate immediately so the window is never blank on open
        self._refresh()

    def _refresh(self) -> None:
        hostname = self._hostname if self._hostname is not None else get_hostname()
        ip = self._ip if self._ip is not None else get_ip()

        if self._small:
            img = render_small_screen(hostname, ip)
        else:
            img = render_screen(hostname, ip)

        if self._scale != 1:
            img = img.resize(
                (img.width * self._scale, img.height * self._scale),
                Image.NEAREST,
            )

        # Store on self — a local variable would be GC'd before tkinter renders it
        self._tk_image = ImageTk.PhotoImage(img)
        self._label.configure(image=self._tk_image)

        size_label = "80×160" if self._small else "320×480"
        self._root.title(
            f"NetID Emulator — {hostname} | {ip} | {size_label} | {self._interval_ms // 1000}s"
        )

        log.debug("Refreshed: hostname=%s ip=%s", hostname, ip)
        self._root.after(self._interval_ms, self._refresh)

    def run(self) -> None:
        self._root.mainloop()


def main() -> None:
    parser = argparse.ArgumentParser(
        description="NetID Monitor display emulator — no hardware required."
    )
    parser.add_argument(
        "--small",
        action="store_true",
        help="Use the 80×160 small-screen layout (default: 320×480)",
    )
    parser.add_argument(
        "--interval", "-i",
        type=float,
        default=10.0,
        metavar="N",
        help="Refresh interval in seconds (default: 10)",
    )
    parser.add_argument(
        "--hostname",
        default=None,
        metavar="STR",
        help="Override hostname string (default: use real hostname)",
    )
    parser.add_argument(
        "--ip",
        default=None,
        metavar="STR",
        help="Override IP address string (default: use real IP)",
    )
    parser.add_argument(
        "--scale",
        type=int,
        default=3,
        metavar="N",
        help="Integer pixel upscale factor 1–8 (default: 3)",
    )
    parser.add_argument(
        "--verbose", "-v",
        action="store_true",
        help="Enable debug logging",
    )
    args = parser.parse_args()

    logging.basicConfig(
        level=logging.DEBUG if args.verbose else logging.INFO,
        format="%(levelname)s %(message)s",
    )

    try:
        window = EmulatorWindow(
            small=args.small,
            interval=args.interval,
            hostname_override=args.hostname,
            ip_override=args.ip,
            scale=args.scale,
        )
        window.run()
    except tk.TclError as exc:
        print(
            f"ERROR: Cannot open display — {exc}\n"
            "Set the DISPLAY environment variable or run on a desktop system.",
            file=sys.stderr,
        )
        sys.exit(1)


if __name__ == "__main__":
    main()