#!/usr/bin/env python3
"""Privileged worker. Emits newline-delimited JSON on stdout."""

import argparse
import hashlib
import json
import os
import signal
import sys
import time

sys.path.insert(0, "/usr/lib/viridis")

from viridis import core, isopatch, ventoy, wtg  # noqa: E402

_cancelled = False


_log_fh = None


def emit(**kw):
    kw.setdefault("t", time.strftime("%Y-%m-%dT%H:%M:%S"))
    line = json.dumps(kw)
    sys.stdout.write(line + "\n")
    sys.stdout.flush()
    if _log_fh:
        _log_fh.write(line + "\n")
        _log_fh.flush()


def _sha256(path):
    h = hashlib.sha256()
    with open(path, "rb") as fh:
        while True:
            buf = fh.read(4 * 1024 * 1024)
            if not buf:
                break
            h.update(buf)
    return h.hexdigest()


def on_signal(*_):
    global _cancelled
    _cancelled = True


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--iso", required=True)
    ap.add_argument("--dev", required=True)
    ap.add_argument("--opts", default="{}")
    ap.add_argument("--verify", action="store_true")
    ap.add_argument("--dry-run", action="store_true")
    ap.add_argument("--mode", choices=("installer", "wtg", "ventoy", "patchiso"),
                    default="installer")
    ap.add_argument("--log", default="")
    args = ap.parse_args()

    signal.signal(signal.SIGTERM, on_signal)
    signal.signal(signal.SIGINT, on_signal)

    if os.geteuid() != 0:
        emit(type="error", msg="helper must run as root")
        return 1

    global _log_fh
    if not args.log:
        os.makedirs("/var/log/viridis", exist_ok=True)
        args.log = "/var/log/viridis/" + time.strftime("build-%Y%m%d-%H%M%S.jsonl")
    _log_fh = open(args.log, "a", encoding="utf-8")

    devinfo = core.run(["lsblk", "-dno", "MODEL,SERIAL,SIZE", args.dev])
    emit(type="header", helper="viridis", iso=args.iso,
         iso_size=os.path.getsize(args.iso), iso_sha256=_sha256(args.iso),
         dev=args.dev, device=devinfo.stdout.strip(), mode=args.mode,
         opts=json.loads(args.opts), log=args.log)

    try:
        emit(type="phase", msg="validating ISO")
        info = core.validate_iso(args.iso)
        emit(type="log", msg=f"ISO ok - EFI={info['efi']} BIOS={info['bios']} "
                             f"image={info['image_mb']} MB")
        if args.dry_run:
            emit(type="done")
            return 0

        progress = lambda pct, msg: emit(type="progress", pct=pct, msg=msg)
        log = lambda m: emit(type="log", msg=m)

        def span(lo, hi):
            return lambda pct, msg: emit(
                type="progress", pct=lo + (hi - lo) * pct / 100.0, msg=msg)

        if args.mode == "wtg":
            wtg.build(args.iso, args.dev, json.loads(args.opts),
                      progress, lambda: _cancelled, log)
        elif args.mode == "ventoy":
            ventoy.build(args.iso, args.dev, json.loads(args.opts),
                         progress, lambda: _cancelled, log)
        elif args.mode == "patchiso":
            isopatch.bake(args.iso, json.loads(args.opts),
                           progress, lambda: _cancelled, log)
        else:
            if json.loads(args.opts).get("dd"):
                emit(type="phase", msg="writing image (DD)")
                core.write_iso(
                    args.iso, args.dev, span(0, 68 if args.verify else 82),
                    lambda: _cancelled, verify=args.verify, log=log,
                    verify_progress=span(68, 82) if args.verify else None)
            else:
                emit(type="phase", msg="extracting ISO")
                log("ISO mode - laying files onto FAT32")
                core.extract_build(args.iso, args.dev, span(0, 82),
                                   lambda: _cancelled, log,
                                   json.loads(args.opts))
            emit(type="phase", msg="injecting bypass files")
            core.patch_media(args.dev, json.loads(args.opts), log,
                             span(82, 100))

        core.run(["sync"])
        emit(type="progress", pct=100, msg="finished")
        emit(type="done")
        return 0
    except core.WinUsbError as exc:
        emit(type="error", msg=str(exc))
        return 2
    except Exception as exc:  # noqa: BLE001
        emit(type="error", msg=f"{type(exc).__name__}: {exc}")
        return 3


if __name__ == "__main__":
    sys.exit(main())
