"""
Job-Engine: Download eines macOS-Installers + Beschreiben eines USB-Sticks.

Zwei Pfade, unterschiedlich robust:

  legacy_dmg  (macOS bis Catalina/10.15): Apple liefert ein fertiges,
              bootfaehiges BaseSystem.dmg/InstallESD.dmg. Wir wandeln es mit
              dmg2img in ein rohes Image und schreiben es 1:1 mit dd auf den
              Stick. Etablierter, zuverlaessiger Weg.

  recovery    (macOS ab Big Sur/11): Apple liefert nur noch ein
              InstallAssistant.pkg. Das eigentliche createinstallmedia laeuft
              nur unter echtem macOS. Wir extrahieren das .pkg (xar -> pbzx
              -> cpio) und suchen darin ein SharedSupport.dmg/BaseSystem.dmg,
              das wir dann genauso per dd schreiben. EXPERIMENTELL: Apple hat
              den internen Aufbau von InstallAssistant.pkg mehrfach leicht
              geaendert, das kann brechen. Klar als "experimentell" markiert.

Drei Job-Typen:

  "stick"     Download (oder Wiederverwendung aus der lokalen Bibliothek) +
              Schreiben EINER macOS-Version auf einen kompletten USB-Stick.
  "download"  Nur herunterladen, dauerhaft in der lokalen Bibliothek ablegen.
              Kein Geraet noetig. Gedacht um sich vorab eine Offline-Sammlung
              aller macOS-Installer aufzubauen (z.B. auf eine externe Platte),
              die man auch ohne Internetzugang zum Stick-Bauen nutzen kann.
  "multiboot" Mehrere macOS-Versionen (2-8) auf EINEN Stick, jede in ihrer
              eigenen GPT-Partition. Macs EFI-Bootpicker (Alt/Option beim
              Start) scannt alle Partitionen eines angeschlossenen Datentraegers
              nach bootfaehigen Volumes -- deshalb reicht es, den Stick mit
              N Apple_HFS-Partitionen anzulegen und in jede das jeweilige
              vollstaendige Installer-Image zu dd'en. EXPERIMENTELL (siehe
              README): funktioniert zuverlaessig fuer den legacy_dmg-Pfad,
              beim recovery-Pfad (Big Sur+) erbt es dessen Unsicherheiten.

Lokale Bibliothek (Persistenz):

  Jeder erfolgreiche Download landet dauerhaft unter
  /data/downloads/library/<safer-name>/ (Original-Dateiname + meta.json).
  Das liegt im Bind-Mount ./downloads -- also ganz normal im Projektordner
  und damit portabel (Ordner/Platte kopieren reicht). Ein "stick"- oder
  "multiboot"-Job prueft IMMER zuerst, ob die Datei schon lokal vorhanden
  ist, und ueberspringt den Download wenn ja -- so wird aus jedem einzelnen
  Stick-Bau ganz nebenbei eine wachsende Offline-Bibliothek, ganz ohne
  Zusatzaufwand.

Sicherheits-Leitplanken:
  - Ziel-Device wird gegen die Root-Disk des Hosts geprueft (Refuse).
  - Ziel-Device muss "removable" oder USB-Transport sein (Refuse sonst).
  - Aufrufer muss den Device-Pfad im Request nochmal exakt bestaetigen.
"""
import json
import logging
import os
import re
import shutil
import subprocess
import tempfile
import threading
import time
import uuid
from queue import Queue, Empty

import requests

from devices import list_usb_sticks

log = logging.getLogger("installer")

DOWNLOAD_DIR = "/data/downloads"
LIBRARY_DIR = os.path.join(DOWNLOAD_DIR, "library")
JOBS: dict[str, "Job"] = {}

# Multiboot-Partitionierung: pro Partition oben drauf gerechneter Puffer
# (Dateisystem-Rundungen etc.), plus grober Abzug fuer GPT-Header/Backup-GPT
# und Ausrichtungs-Luecken zwischen den Partitionen.
PARTITION_PADDING_MB = 64
GPT_OVERHEAD_MB = 16
MULTIBOOT_MIN_IMAGES = 2
MULTIBOOT_MAX_IMAGES = 8


class JobAborted(Exception):
    pass


def _safe_name(product: dict) -> str:
    """Stabiler, lesbarer Ordnername fuer die Bibliothek, z.B.
    'macOS_Sonoma_14.6_061-12345'. Die Produkt-ID am Ende macht ihn eindeutig,
    auch wenn zwei Eintraege denselben Titel haben."""
    raw = f"{product.get('title', 'macOS')}_{product.get('version', '0')}_{product.get('id', '')}"
    return re.sub(r"[^A-Za-z0-9._-]+", "_", raw).strip("_")


def _partition_label(product: dict) -> str:
    """Kurzes, GPT-taugliches Label fuer den Bootpicker, z.B. 'macOS Sonoma 14.6'.
    GPT-Partitionsnamen sind auf 36 UTF-16-Zeichen begrenzt."""
    raw = f"{product.get('title', 'macOS')} {product.get('version', '')}".strip()
    label = re.sub(r"[^A-Za-z0-9 ._-]+", "", raw).strip()
    return (label or "macOS")[:36]


def _payload_url(product: dict) -> str:
    if product["mode"] == "legacy_dmg":
        return product["base_system_url"]
    return product["install_assistant_url"]


def library_entry_dir(product: dict) -> str:
    return os.path.join(LIBRARY_DIR, _safe_name(product))


def library_payload_path(product: dict) -> str:
    filename = os.path.basename(_payload_url(product)) or (
        "BaseSystem.dmg" if product["mode"] == "legacy_dmg" else "InstallAssistant.pkg"
    )
    return os.path.join(library_entry_dir(product), filename)


def get_cached_payload(product: dict):
    """Gibt den Pfad zurueck wenn die Datei schon vollstaendig in der
    Bibliothek liegt (meta.json + Datei vorhanden, Groesse passt), sonst
    None."""
    path = library_payload_path(product)
    meta_path = os.path.join(library_entry_dir(product), "meta.json")
    if not (os.path.isfile(path) and os.path.isfile(meta_path)):
        return None
    try:
        with open(meta_path) as f:
            meta = json.load(f)
        if meta.get("complete") and os.path.getsize(path) == meta.get("size_bytes"):
            return path
    except (OSError, ValueError):
        pass
    return None


def list_library():
    """Fuer die GUI: alle vollstaendig heruntergeladenen Produkte + Gesamtgroesse."""
    items = []
    total = 0
    if os.path.isdir(LIBRARY_DIR):
        for entry in sorted(os.listdir(LIBRARY_DIR)):
            meta_path = os.path.join(LIBRARY_DIR, entry, "meta.json")
            if not os.path.isfile(meta_path):
                continue
            try:
                with open(meta_path) as f:
                    meta = json.load(f)
            except (OSError, ValueError):
                continue
            if not meta.get("complete"):
                continue
            items.append(meta)
            total += meta.get("size_bytes", 0)
    return {"items": items, "total_bytes": total}


def _device_size_bytes(device_path: str) -> int:
    match = next((s for s in list_usb_sticks() if s["path"] == device_path), None)
    if not match:
        raise ValueError(f"Geraet {device_path} nicht mehr in der aktuellen USB-Liste gefunden.")
    return match["size_bytes"]


def _partition_path(device_path: str, index: int) -> str:
    """Partitions-Devicenode fuer ein Ziel-Device, z.B. /dev/sdb -> /dev/sdb1,
    aber /dev/nvme0n1 -> /dev/nvme0n1p1 (Devices die schon auf eine Ziffer
    enden brauchen ein 'p' vor der Partitionsnummer, sonst waer der Name
    mehrdeutig)."""
    base = os.path.basename(device_path)
    sep = "p" if base and base[-1].isdigit() else ""
    return f"{device_path}{sep}{index}"


class Job:
    def __init__(self, product, device_path: str = None, job_type: str = "stick"):
        self.id = str(uuid.uuid4())
        # "stick"/"download": product ist ein einzelnes Produkt-Dict.
        # "multiboot": product ist eine Liste von 2-8 Produkt-Dicts.
        self.product = product
        self.device_path = device_path
        self.job_type = job_type  # "stick" | "download" | "multiboot"
        self.status = "queued"  # queued -> running -> done | failed | aborted
        self.phase = "warten"
        self.progress = 0  # 0-100 im aktuellen Phase
        self.error = None
        self._q: Queue = Queue()
        self._lock = threading.Lock()
        self.history = []

    def emit(self, phase=None, progress=None, msg=None, status=None):
        with self._lock:
            if phase is not None:
                self.phase = phase
            if progress is not None:
                self.progress = progress
            if status is not None:
                self.status = status
            event = {
                "phase": self.phase,
                "progress": self.progress,
                "status": self.status,
                "msg": msg,
                "ts": time.time(),
            }
            self.history.append(event)
        self._q.put(event)

    def stream(self):
        # erst die bisherige Historie nachliefern, dann live weiter
        for event in list(self.history):
            yield event
        while True:
            try:
                yield self._q.get(timeout=30)
            except Empty:
                if self.status in ("done", "failed", "aborted"):
                    return
                yield {"phase": self.phase, "progress": self.progress, "status": self.status, "msg": None, "ts": time.time()}

    def snapshot(self):
        with self._lock:
            return {
                "id": self.id,
                "job_type": self.job_type,
                "status": self.status,
                "phase": self.phase,
                "progress": self.progress,
                "error": self.error,
            }


def _validate_stick_target(device_path: str, confirm_path: str):
    if confirm_path != device_path:
        raise ValueError("Bestaetigungs-Pfad stimmt nicht mit dem Ziel-Geraet ueberein.")
    sticks = list_usb_sticks()
    match = next((s for s in sticks if s["path"] == device_path), None)
    if not match:
        raise ValueError(f"Geraet {device_path} nicht in der aktuellen USB-Liste gefunden.")
    if match["is_root_disk"]:
        raise ValueError("Verweigert: das ist die System-Platte des Hosts.")
    if match["mounted"]:
        raise ValueError("Geraet ist aktuell gemountet -- bitte vorher aushaengen.")
    if not (match["transport"] == "usb"):
        raise ValueError("Geraet ist nicht als USB-Transport erkannt -- Sicherheitsstop.")


def create_job(product, device_path: str = None, confirm_path: str = None, job_type: str = "stick") -> Job:
    if job_type == "download":
        job = Job(product, device_path=None, job_type="download")
        JOBS[job.id] = job
        threading.Thread(target=_run_job, args=(job,), daemon=True).start()
        return job

    if job_type == "multiboot":
        if not isinstance(product, list) or len(product) < MULTIBOOT_MIN_IMAGES:
            raise ValueError(f"Multiboot braucht mindestens {MULTIBOOT_MIN_IMAGES} macOS-Versionen.")
        if len(product) > MULTIBOOT_MAX_IMAGES:
            raise ValueError(f"Zu viele Versionen fuer einen Multiboot-Stick (max. {MULTIBOOT_MAX_IMAGES}).")
        _validate_stick_target(device_path, confirm_path)
        job = Job(product, device_path, job_type="multiboot")
        JOBS[job.id] = job
        threading.Thread(target=_run_job, args=(job,), daemon=True).start()
        return job

    if job_type != "stick":
        raise ValueError(f"Unbekannter job_type: {job_type}")

    _validate_stick_target(device_path, confirm_path)
    job = Job(product, device_path, job_type="stick")
    JOBS[job.id] = job
    t = threading.Thread(target=_run_job, args=(job,), daemon=True)
    t.start()
    return job


def _run(job: Job, cmd: list[str], phase: str, progress_from_stderr=False):
    log.info("job %s: %s", job.id, " ".join(cmd))
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)
    for line in proc.stdout:
        line = line.strip()
        if line:
            job.emit(phase=phase, msg=line)
    ret = proc.wait()
    if ret != 0:
        raise RuntimeError(f"Befehl fehlgeschlagen ({ret}): {' '.join(cmd)}")


def _download_to_library(job: Job, product: dict) -> str:
    """Laedt den Installer-Payload herunter und legt ihn dauerhaft in der
    Bibliothek ab (nicht im temporaeren Scratch-Verzeichnis). Schreibt zuerst
    in eine .part-Datei und benennt erst nach Erfolg um, damit ein
    abgebrochener Download nicht als "vollstaendig" durchgeht."""
    url = _payload_url(product)
    entry_dir = library_entry_dir(product)
    os.makedirs(entry_dir, exist_ok=True)
    final_path = library_payload_path(product)
    part_path = final_path + ".part"

    job.emit(phase="download", progress=0, msg=f"Lade {url}")
    with requests.get(url, stream=True, timeout=30) as r:
        r.raise_for_status()
        total = int(r.headers.get("Content-Length", 0)) or None
        done = 0
        last_pct = -1
        with open(part_path, "wb") as f:
            for chunk in r.iter_content(chunk_size=1024 * 1024 * 4):
                if not chunk:
                    continue
                f.write(chunk)
                done += len(chunk)
                if total:
                    pct = int(done * 100 / total)
                    if pct != last_pct:
                        job.emit(phase="download", progress=pct)
                        last_pct = pct

    size_bytes = os.path.getsize(part_path)
    os.replace(part_path, final_path)
    with open(os.path.join(entry_dir, "meta.json"), "w") as f:
        json.dump(
            {
                "id": product.get("id"),
                "title": product.get("title"),
                "version": product.get("version"),
                "mode": product.get("mode"),
                "source_url": url,
                "filename": os.path.basename(final_path),
                "size_bytes": size_bytes,
                "downloaded_at": time.time(),
                "complete": True,
            },
            f,
        )
    job.emit(phase="download", progress=100, msg=f"Download fertig, liegt dauerhaft unter {final_path}")
    return final_path


def _dmg_to_raw(job: Job, dmg_path: str, work_dir: str) -> str:
    os.makedirs(work_dir, exist_ok=True)
    raw_path = os.path.join(work_dir, os.path.basename(dmg_path) + ".img")
    job.emit(phase="konvertieren", progress=0, msg="dmg2img: DMG -> rohes Image")
    _run(job, ["dmg2img", "-i", dmg_path, "-o", raw_path], phase="konvertieren")
    return raw_path


def _dd_with_progress(job: Job, raw_path: str, target_path: str, phase: str):
    size = os.path.getsize(raw_path)
    job.emit(phase=phase, progress=0, msg=f"Schreibe {raw_path} -> {target_path} (dd)")
    cmd = ["dd", f"if={raw_path}", f"of={target_path}", "bs=4M", "status=progress", "conv=fsync"]
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)
    for line in proc.stdout:
        line = line.strip()
        if not line:
            continue
        job.emit(phase=phase, msg=line)
        # dd status=progress schreibt Zeilen wie "1234567890 bytes (1.2 GB, 1.1 GiB) copied, ..."
        try:
            bytes_done = int(line.split(" ")[0])
            pct = min(100, int(bytes_done * 100 / size))
            job.emit(phase=phase, progress=pct)
        except (ValueError, IndexError, ZeroDivisionError):
            pass
    ret = proc.wait()
    if ret != 0:
        raise RuntimeError(f"dd fehlgeschlagen ({target_path})")
    job.emit(phase=phase, progress=100, msg=f"dd fertig ({target_path}), sync...")
    subprocess.run(["sync"])


def _write_raw_to_device(job: Job, raw_path: str, device_path: str):
    job.emit(phase="schreiben", progress=0, msg=f"Loesche vorhandene Signaturen auf {device_path} (wipefs)")
    _run(job, ["wipefs", "-a", device_path], phase="schreiben")
    _dd_with_progress(job, raw_path, device_path, phase="schreiben")


def _extract_recovery_dmg(job: Job, pkg_path: str, work_dir: str) -> str:
    """Experimentell: InstallAssistant.pkg -> xar -> pbzx -> cpio, sucht SharedSupport/BaseSystem.dmg."""
    job.emit(phase="extrahieren", progress=0, msg="xar: InstallAssistant.pkg entpacken (experimentell)")
    extract_dir = os.path.join(work_dir, "xar")
    os.makedirs(extract_dir, exist_ok=True)
    _run(job, ["xar", "-xf", pkg_path, "-C", extract_dir], phase="extrahieren")

    payloads = []
    for root, _dirs, files in os.walk(extract_dir):
        for fn in files:
            if fn == "Payload":
                payloads.append(os.path.join(root, fn))
    if not payloads:
        raise RuntimeError("Kein Payload in InstallAssistant.pkg gefunden -- Apple-Struktur hat sich vermutlich geaendert.")

    cpio_dir = os.path.join(work_dir, "cpio")
    os.makedirs(cpio_dir, exist_ok=True)
    for payload in payloads:
        job.emit(phase="extrahieren", msg=f"pbzx+cpio: {payload}")
        # pbzx dekomprimiert das payload, cpio packt den entstandenen Stream aus
        pbzx_proc = subprocess.Popen(["pbzx", "-n", payload], stdout=subprocess.PIPE)
        cpio_proc = subprocess.Popen(
            ["cpio", "-idm"], cwd=cpio_dir, stdin=pbzx_proc.stdout,
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
        )
        pbzx_proc.stdout.close()
        for line in cpio_proc.stdout:
            line = line.strip()
            if line:
                job.emit(phase="extrahieren", msg=line)
        cpio_proc.wait()
        pbzx_proc.wait()

    dmg_candidates = []
    for root, _dirs, files in os.walk(cpio_dir):
        for fn in files:
            if fn in ("SharedSupport.dmg", "BaseSystem.dmg"):
                dmg_candidates.append(os.path.join(root, fn))
    if not dmg_candidates:
        raise RuntimeError(
            "Kein SharedSupport.dmg/BaseSystem.dmg im entpackten Installer gefunden. "
            "Das ist der bekannte fragile Punkt bei macOS Big Sur+ ohne echten Mac."
        )
    # SharedSupport.dmg bevorzugen (enthaelt das vollstaendige Recovery-System)
    dmg_candidates.sort(key=lambda p: 0 if "SharedSupport" in p else 1)
    return dmg_candidates[0]


def _fetch_and_convert(job: Job, product: dict, work_dir: str, tag: str) -> str:
    """Gemeinsamer Schritt fuer 'stick' und 'multiboot': Bibliothek pruefen /
    herunterladen, bei Bedarf Big-Sur+-Pfad extrahieren, am Ende immer ein
    rohes dd-faehiges Image zurueckgeben."""
    cached = get_cached_payload(product)
    if cached:
        payload_path = cached
        job.emit(phase="download", progress=100, msg=f"{tag}: bereits lokal in der Bibliothek vorhanden, Download uebersprungen.")
    else:
        job.emit(phase="download", progress=0, msg=f"{tag}: lade herunter...")
        payload_path = _download_to_library(job, product)

    if product["mode"] != "legacy_dmg":
        job.emit(phase="extrahieren", msg=f"{tag}: Big Sur+ Pfad, experimentell.")
        dmg_path = _extract_recovery_dmg(job, payload_path, os.path.join(work_dir, "extract"))
    else:
        dmg_path = payload_path

    return _dmg_to_raw(job, dmg_path, os.path.join(work_dir, "raw"))


def _plan_partitions(raw_images: list[dict], device_size_bytes: int):
    """Rechnet pro Image die noetige Partitionsgroesse (inkl. Puffer) aus und
    wirft eine verstaendliche Fehlermeldung, wenn der Stick zu klein ist --
    BEVOR irgendwas geschrieben wird."""
    total_mb = GPT_OVERHEAD_MB
    for img in raw_images:
        img["partition_mb"] = (img["size_bytes"] // (1024 * 1024)) + 1 + PARTITION_PADDING_MB
        total_mb += img["partition_mb"]
    needed_bytes = total_mb * 1024 * 1024
    if needed_bytes > device_size_bytes:
        raise ValueError(
            f"Stick zu klein: benoetigt ca. {needed_bytes / 1e9:.1f} GB fuer {len(raw_images)} "
            f"Versionen (inkl. Partitions-Puffer), Stick hat aber nur {device_size_bytes / 1e9:.1f} GB."
        )


def _partition_device_multiboot(job: Job, device_path: str, raw_images: list[dict]):
    job.emit(phase="partitionieren", progress=0, msg=f"Loesche {device_path} komplett (wipefs + sgdisk zap)")
    _run(job, ["wipefs", "-a", device_path], phase="partitionieren")
    _run(job, ["sgdisk", "--zap-all", device_path], phase="partitionieren")

    cmd = ["sgdisk"]
    for idx, img in enumerate(raw_images, start=1):
        cmd += [
            "-n", f"{idx}:0:+{img['partition_mb']}M",
            "-t", f"{idx}:AF00",  # AF00 = Apple HFS/HFS+ Partitionstyp
            "-c", f"{idx}:{img['label']}",
        ]
    cmd.append(device_path)
    job.emit(phase="partitionieren", progress=50, msg=f"Lege {len(raw_images)} Partitionen an (sgdisk)")
    _run(job, cmd, phase="partitionieren")

    # Kernel/udev Zeit geben, die neuen Partitions-Devicenodes anzulegen,
    # bevor wir versuchen sie zu beschreiben.
    subprocess.run(["partprobe", device_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    time.sleep(2)
    job.emit(phase="partitionieren", progress=100, msg="Partitionstabelle steht.")


def _run_stick_job(job: Job):
    """job_type == 'stick': eine einzelne macOS-Version auf einen ganzen Stick."""
    scratch_dir = tempfile.mkdtemp(dir=DOWNLOAD_DIR, prefix="scratch_")
    try:
        job.emit(status="running", phase="start", progress=0, msg="Job gestartet")
        raw_path = _fetch_and_convert(job, job.product, scratch_dir, tag=job.product.get("title", "macOS"))
        _write_raw_to_device(job, raw_path, job.device_path)
        job.emit(status="done", phase="fertig", progress=100, msg="Stick ist fertig.")
    finally:
        shutil.rmtree(scratch_dir, ignore_errors=True)


def _run_download_job(job: Job):
    """job_type == 'download': nur in die lokale Bibliothek laden."""
    cached = get_cached_payload(job.product)
    if cached:
        job.emit(status="running", phase="download", progress=100, msg=f"Bereits lokal vorhanden ({cached}).")
    else:
        job.emit(status="running", phase="start", progress=0, msg="Job gestartet")
        _download_to_library(job, job.product)
    job.emit(status="done", phase="fertig", progress=100, msg="Image liegt jetzt dauerhaft in der lokalen Bibliothek (Offline nutzbar).")


def _run_multiboot_job(job: Job):
    """job_type == 'multiboot': mehrere macOS-Versionen, je eine eigene
    GPT-Partition auf demselben Stick. Erst ALLE Images vollstaendig
    herunterladen/konvertieren, dann Groesse pruefen, dann EINMAL
    partitionieren, dann nacheinander in die jeweilige Partition schreiben."""
    products = job.product  # Liste
    scratch_dir = tempfile.mkdtemp(dir=DOWNLOAD_DIR, prefix="scratch_mb_")
    try:
        job.emit(status="running", phase="start", progress=0, msg=f"Multiboot-Job gestartet ({len(products)} Versionen)")

        raw_images = []
        for idx, product in enumerate(products, start=1):
            tag = f"[{idx}/{len(products)}] {product.get('title', 'macOS')} {product.get('version', '')}"
            work_dir = os.path.join(scratch_dir, f"img{idx}")
            raw_path = _fetch_and_convert(job, product, work_dir, tag)
            raw_images.append(
                {
                    "label": _partition_label(product),
                    "path": raw_path,
                    "size_bytes": os.path.getsize(raw_path),
                    "title": f"{product.get('title', 'macOS')} {product.get('version', '')}".strip(),
                }
            )
            job.emit(phase="konvertieren", progress=100, msg=f"{tag}: fertig konvertiert.")

        job.emit(phase="planen", progress=0, msg="Pruefe ob der Stick fuer alle gewaehlten Versionen gross genug ist...")
        device_size = _device_size_bytes(job.device_path)
        _plan_partitions(raw_images, device_size)

        _partition_device_multiboot(job, job.device_path, raw_images)

        for idx, img in enumerate(raw_images, start=1):
            part_path = _partition_path(job.device_path, idx)
            tag = f"[{idx}/{len(raw_images)}] {img['title']}"
            job.emit(phase="schreiben", progress=0, msg=f"{tag}: schreibe nach {part_path}")
            _dd_with_progress(job, img["path"], part_path, phase="schreiben")

        job.emit(
            status="done", phase="fertig", progress=100,
            msg=f"Multiboot-Stick fertig -- {len(raw_images)} Versionen, per Alt/Option-Taste beim Boot auswaehlbar.",
        )
    finally:
        shutil.rmtree(scratch_dir, ignore_errors=True)


def _run_job(job: Job):
    os.makedirs(DOWNLOAD_DIR, exist_ok=True)
    os.makedirs(LIBRARY_DIR, exist_ok=True)
    try:
        if job.job_type == "multiboot":
            _run_multiboot_job(job)
        elif job.job_type == "download":
            _run_download_job(job)
        else:
            _run_stick_job(job)
    except Exception as exc:  # noqa: BLE001
        log.exception("job %s failed", job.id)
        job.error = str(exc)
        job.emit(status="failed", msg=f"FEHLER: {exc}")