#!/usr/bin/env python3
"""preflight.py - prueft PDFs vor dem Versand an die Druckerei.

Misst je Seite: Endformat (TrimBox), Beschnitt (BleedBox), Seitengroesse (MediaBox),
eingebettete Schriften, kleinste Schrift, Text im Sicherheitsabstand, Bildaufloesung (effektive ppi),
Farbraeume (CMYK/RGB/Grau/Sonderfarben), hoechsten Farbauftrag, Transparenzen, duennste Linie,
PDF/X-Kennung. Ergebnis als Tabelle, auf Wunsch als JSON.

Aufruf:   python preflight.py datei.pdf [weitere.pdf ...] [--beschnitt 3] [--sicherheit 5] [--json ergebnis.json]
Benoetigt: Python 3.9+ und PyMuPDF (pip install pymupdf)

Hinweis: Das Skript ersetzt keine Pruefung nach PDF/X-Norm (z. B. mit Acrobat oder callas pdfToolbox).
Es findet die typischen Fehler, bevor eine Datei rausgeht.
"""
import argparse, json, re, sys
import pymupdf as fitz

MM = 25.4 / 72


def mm(v):
    return round(v * MM, 2)


def box_mm(r):
    return [mm(r.x0), mm(r.y0), mm(r.x1), mm(r.y1)]


def eigener_eintrag(doc, page, name):
    typ, wert = doc.xref_get_key(page.xref, name)
    return typ != "null"


_STRING = re.compile(rb"\((?:\\.|[^\\()])*\)|<[0-9A-Fa-f\s]*>", re.S)
_INLINE = re.compile(rb"\bBI\b.*?\bID\b.*?\bEI\b", re.S)
_TOKEN = re.compile(rb"/[^\s/\[\]()<>{}%]+|[-+]?\d*\.?\d+|[A-Za-z'\"*]+")


def farben_aus_strom(daten, zaehler, cmyk_werte):
    daten = _INLINE.sub(b" ", daten)
    daten = _STRING.sub(b" ", daten)
    stapel = []
    for t in _TOKEN.findall(daten):
        if t[:1].isdigit() or t[:1] in b"-+.":
            try:
                stapel.append(float(t))
            except ValueError:
                stapel.clear()
            continue
        if t.startswith(b"/"):
            stapel.append(t.decode("latin-1"))
            continue
        op = t.decode("latin-1")
        if op in ("rg", "RG"):
            zaehler["rgb"] += 1
        elif op in ("k", "K"):
            zaehler["cmyk"] += 1
            werte = [x for x in stapel[-4:] if isinstance(x, float)]
            if len(werte) == 4:
                cmyk_werte.add(tuple(round(x, 3) for x in werte))
        elif op in ("g", "G"):
            zaehler["grau"] += 1
        elif op in ("cs", "CS"):
            name = stapel[-1] if stapel and isinstance(stapel[-1], str) else "?"
            zaehler["farbraum_namen"].add(name)
        elif op in ("sh",):
            zaehler["verlaeufe"] += 1
        stapel.clear()


def alle_stroeme(doc, page):
    """Inhaltsstroeme der Seite plus aller (verschachtelten) Form-XObjects."""
    gesehen, liste = set(), [page.read_contents()]
    offen = [x[0] for x in page.get_xobjects()]
    while offen:
        x = offen.pop()
        if x in gesehen or x <= 0:
            continue
        gesehen.add(x)
        try:
            if doc.xref_get_key(x, "Subtype")[1] == "/Form":
                liste.append(doc.xref_stream(x) or b"")
                typ, res = doc.xref_get_key(x, "Resources/XObject")
                for ref in re.findall(r"(\d+) 0 R", res or ""):
                    offen.append(int(ref))
        except Exception:
            pass
    return liste


def transparenz(doc):
    funde = []
    for x in range(1, doc.xref_length()):
        try:
            obj = doc.xref_object(x, compressed=True)
        except Exception:
            continue
        if "/ExtGState" in obj or "/ca " in obj or "/CA " in obj:
            for schl in ("ca", "CA"):
                m = re.search(r"/" + schl + r"\s+([\d.]+)", obj)
                if m and float(m.group(1)) < 1:
                    funde.append(f"xref {x}: /{schl} {m.group(1)}")
            m = re.search(r"/SMask\s+(/\w+|\d+ 0 R)", obj)
            if m and m.group(1) != "/None":
                funde.append(f"xref {x}: SMask")
            m = re.search(r"/BM\s*/(\w+)", obj)
            if m and m.group(1) not in ("Normal", "Compatible"):
                funde.append(f"xref {x}: Fuellmethode {m.group(1)}")
    return funde


def farbauftrag(page, clip, dpi):
    fitz.TOOLS.set_icc(False)        # CMYK-Werte ohne Farbmanagement auslesen
    pix = page.get_pixmap(dpi=dpi, colorspace=fitz.csCMYK, clip=clip, alpha=False)
    fitz.TOOLS.set_icc(True)
    n = pix.n
    hoechst = 0
    werte = memoryview(pix.samples)
    for i in range(0, len(werte) - n + 1, n):
        t = werte[i] + werte[i + 1] + werte[i + 2] + werte[i + 3]
        if t > hoechst:
            hoechst = t
    return round(hoechst / 255 * 100)


def farbauftrag_np(page, clip, dpi):
    try:
        import numpy as np
    except ImportError:
        return farbauftrag(page, clip, dpi)
    fitz.TOOLS.set_icc(False)
    pix = page.get_pixmap(dpi=dpi, colorspace=fitz.csCMYK, clip=clip, alpha=False)
    fitz.TOOLS.set_icc(True)
    a = np.frombuffer(pix.samples, dtype=np.uint8).reshape(-1, pix.n)[:, :4].astype(np.uint16).sum(axis=1)
    return round(int(a.max()) / 255 * 100)


def pruefe(pfad, beschnitt_soll, sicherheit_mm, dpi_farbauftrag=72):
    doc = fitz.open(pfad)
    erg = {"datei": pfad, "seiten": [], "pdf_version": doc.metadata.get("format"),
           "erzeuger": doc.metadata.get("producer"), "ersteller": doc.metadata.get("creator")}
    # PDF/X-Kennung
    kat = doc.pdf_catalog()
    oi = doc.xref_get_key(kat, "OutputIntents")
    pdfx = None
    for x in range(1, doc.xref_length()):
        try:
            o = doc.xref_object(x, compressed=True)
        except Exception:
            continue
        m = re.search(r"/GTS_PDFXVersion\s*\(([^)]*)\)", o)
        if m:
            pdfx = m.group(1)
    erg["pdfx"] = pdfx or "keine"
    erg["output_intent"] = "ja" if oi[0] != "null" else "nein"
    erg["transparenz"] = transparenz(doc)

    fonts_gesamt = {}
    for pno, page in enumerate(doc):
        s = {"seite": pno + 1}
        mb, tb, bb, cb = page.mediabox, page.trimbox, page.bleedbox, page.cropbox
        s["mediabox_mm"] = [mm(mb.width), mm(mb.height)]
        s["trimbox_gesetzt"] = eigener_eintrag(doc, page, "TrimBox")
        s["bleedbox_gesetzt"] = eigener_eintrag(doc, page, "BleedBox")
        s["endformat_mm"] = [mm(tb.width), mm(tb.height)]
        s["beschnitt_mm"] = {"links": mm(tb.x0 - bb.x0), "oben": mm(tb.y0 - bb.y0), "rechts": mm(bb.x1 - tb.x1), "unten": mm(bb.y1 - tb.y1)}
        s["beschnitt_min_mm"] = min(s["beschnitt_mm"].values())

        # Schriften
        schriften = []
        for f in page.get_fonts(full=True):
            xref, ext, typ, basis, name = f[0], f[1], f[2], f[3], f[4]
            eingebettet = ext not in ("n/a", "")
            schriften.append({"name": basis, "typ": typ, "eingebettet": eingebettet, "teilmenge": bool(re.match(r"^[A-Z]{6}\+", basis))})
            fonts_gesamt[(basis, typ)] = eingebettet
        s["schriften"] = schriften

        # Text: kleinste Schrift, Sicherheitsabstand
        innen = fitz.Rect(tb.x0 + sicherheit_mm / MM, tb.y0 + sicherheit_mm / MM, tb.x1 - sicherheit_mm / MM, tb.y1 - sicherheit_mm / MM)
        kleinste, verstoesse, im_anschnitt = None, [], 0
        for blk in page.get_text("dict")["blocks"]:
            for ln in blk.get("lines", []):
                for sp in ln["spans"]:
                    if not sp["text"].strip():
                        continue
                    r = fitz.Rect(sp["bbox"])
                    if not r.intersects(tb):
                        im_anschnitt += 1          # Infozeile ausserhalb des Endformats
                        continue
                    kleinste = sp["size"] if kleinste is None else min(kleinste, sp["size"])
                    # Glyphenkasten etwas enger fassen (Zeilenhoehe > Schrifthoehe)
                    eng = fitz.Rect(r.x0, r.y0 + (r.height - sp["size"]) / 2, r.x1, r.y1 - (r.height - sp["size"]) / 2)
                    if not innen.contains(eng):
                        verstoesse.append(sp["text"][:40])
        s["kleinste_schrift_pt"] = round(kleinste, 2) if kleinste else None
        s["text_ausserhalb_sicherheitsabstand"] = verstoesse
        s["text_ausserhalb_endformat"] = im_anschnitt

        # Bilder
        bilder = []
        for info in page.get_image_info(xrefs=True):
            bx = fitz.Rect(info["bbox"])
            if bx.is_empty:
                continue
            ppi_x = info["width"] / (bx.width / 72)
            ppi_y = info["height"] / (bx.height / 72)
            cs = info.get("cs-name") or ""
            bilder.append({"px": [info["width"], info["height"]], "platz_mm": [mm(bx.width), mm(bx.height)],
                           "ppi": round(min(ppi_x, ppi_y), 1), "farbraum": cs, "bpc": info.get("bpc")})
        s["bilder"] = bilder

        # Farben in allen Inhaltsstroemen
        z = {"rgb": 0, "cmyk": 0, "grau": 0, "verlaeufe": 0, "farbraum_namen": set()}
        werte = set()
        for st in alle_stroeme(doc, page):
            farben_aus_strom(st, z, werte)
        s["farboperatoren"] = {"cmyk": z["cmyk"], "rgb": z["rgb"], "grau": z["grau"], "verlaeufe": z["verlaeufe"],
                               "farbraum_namen": sorted(z["farbraum_namen"])}
        s["cmyk_farben"] = sorted(werte)
        s["hoechster_farbauftrag_vektor_pct"] = round(max((sum(w) for w in werte), default=0) * 100)
        clip = bb if s["bleedbox_gesetzt"] else mb
        s["hoechster_farbauftrag_pct"] = farbauftrag_np(page, clip, dpi_farbauftrag)

        # duennste Linie innerhalb des Endformats
        duennste = None
        for d in page.get_drawings():
            if d.get("type") in ("s", "fs") and d.get("width") is not None:
                r = fitz.Rect(d["rect"])            # waagerechte/senkrechte Linien haben Hoehe/Breite 0
                if r.x0 <= tb.x1 and r.x1 >= tb.x0 and r.y0 <= tb.y1 and r.y1 >= tb.y0:
                    w = d["width"]
                    duennste = w if duennste is None else min(duennste, w)
        s["duennste_linie_pt"] = round(duennste, 3) if duennste is not None else None
        erg["seiten"].append(s)

    erg["schriften_gesamt"] = len(fonts_gesamt)
    erg["schriften_eingebettet"] = sum(1 for v in fonts_gesamt.values() if v)
    erg["urteil"] = urteil(erg, beschnitt_soll)
    return erg


def urteil(erg, beschnitt_soll):
    punkte = []
    for s in erg["seiten"]:
        p = f"S.{s['seite']}"
        if not s["trimbox_gesetzt"]:
            punkte.append(("WARNUNG", f"{p}: keine TrimBox (Endformat nicht ausgewiesen)"))
        if s["beschnitt_min_mm"] < beschnitt_soll - 0.05:
            punkte.append(("FEHLER", f"{p}: Beschnitt {s['beschnitt_min_mm']} mm statt {beschnitt_soll} mm"))
        if any(not f["eingebettet"] for f in s["schriften"]):
            punkte.append(("FEHLER", f"{p}: Schrift nicht eingebettet"))
        if any(f["typ"] == "Type3" for f in s["schriften"]):
            punkte.append(("HINWEIS", f"{p}: Type-3-Schrift"))
        for b in s["bilder"]:
            if b["ppi"] < 150:
                punkte.append(("FEHLER", f"{p}: Bild nur {b['ppi']} ppi"))
            elif b["ppi"] < 295:
                punkte.append(("WARNUNG", f"{p}: Bild {b['ppi']} ppi (unter 300)"))
            if "RGB" in b["farbraum"].upper():
                punkte.append(("WARNUNG", f"{p}: Bild in RGB"))
        if s["farboperatoren"]["rgb"] or any("RGB" in n.upper() for n in s["farboperatoren"]["farbraum_namen"]):
            punkte.append(("WARNUNG", f"{p}: RGB-Farben, Umwandlung nach Druckerei-Profil nötig"))
        if s["hoechster_farbauftrag_pct"] > 300:
            punkte.append(("WARNUNG", f"{p}: Farbauftrag {s['hoechster_farbauftrag_pct']} % (ueber 300 %)"))
        if s["text_ausserhalb_sicherheitsabstand"]:
            n = len(s['text_ausserhalb_sicherheitsabstand'])
            punkte.append(("WARNUNG", f"{p}: {n} Textstelle{'' if n == 1 else 'n'} im Sicherheitsabstand"))
        if s["kleinste_schrift_pt"] and s["kleinste_schrift_pt"] < 6:
            punkte.append(("HINWEIS", f"{p}: Schrift unter 6 pt"))
        if s["duennste_linie_pt"] is not None and s["duennste_linie_pt"] < 0.25:
            punkte.append(("WARNUNG", f"{p}: Linie dünner als 0,25 pt"))
    if erg["transparenz"]:
        punkte.append(("HINWEIS", "Transparenzen vorhanden (für PDF/X-1a reduzieren)"))
    if erg["pdfx"] == "keine":
        punkte.append(("HINWEIS", "keine PDF/X-Kennung, kein Ausgabeprofil"))
    return punkte


def ausgabe(erg):
    print("=" * 78)
    print(erg["datei"])
    print(f"PDF {erg['pdf_version']} · Schriften {erg['schriften_eingebettet']}/{erg['schriften_gesamt']} eingebettet · "
          f"PDF/X: {erg['pdfx']} · Transparenzen: {len(erg['transparenz'])}")
    for s in erg["seiten"]:
        b = s["beschnitt_mm"]
        print(f"  Seite {s['seite']}: Endformat {s['endformat_mm'][0]} x {s['endformat_mm'][1]} mm · Seite {s['mediabox_mm'][0]} x {s['mediabox_mm'][1]} mm · "
              f"Beschnitt {b['links']}/{b['oben']}/{b['rechts']}/{b['unten']} mm")
        fo = s["farboperatoren"]
        print(f"    Farben: CMYK {fo['cmyk']} · RGB {fo['rgb']} · Grau {fo['grau']} · Farbraeume {', '.join(fo['farbraum_namen']) or '-'} · "
              f"max. Farbauftrag {s['hoechster_farbauftrag_pct']} %" + (" (aus RGB umgerechnet, nur Anhaltswert)" if fo["rgb"] else ""))
        print(f"    Text: kleinste Schrift {s['kleinste_schrift_pt']} pt · im Sicherheitsabstand {len(s['text_ausserhalb_sicherheitsabstand'])} · "
              f"duennste Linie {s['duennste_linie_pt']} pt")
        for bi in s["bilder"]:
            print(f"    Bild {bi['px'][0]} x {bi['px'][1]} px auf {bi['platz_mm'][0]} x {bi['platz_mm'][1]} mm = {bi['ppi']} ppi · {bi['farbraum']}")
    if erg["urteil"]:
        for stufe, text in erg["urteil"]:
            print(f"  {stufe:8} {text}")
    else:
        print("  OK       keine Befunde")


def main():
    try:
        sys.stdout.reconfigure(errors="replace")   # Konsole ohne Umlaute: ersetzen statt abbrechen
    except Exception:
        pass
    ap = argparse.ArgumentParser(description="Druckvorstufen-Pruefung fuer PDFs")
    ap.add_argument("pdf", nargs="+")
    ap.add_argument("--beschnitt", type=float, default=3.0, help="geforderter Beschnitt in mm (Standard 3)")
    ap.add_argument("--sicherheit", type=float, default=3.0, help="Sicherheitsabstand Text zum Endformat in mm (Standard 3)")
    ap.add_argument("--json", help="Ergebnis zusaetzlich als JSON speichern")
    a = ap.parse_args()
    alle = []
    for p in a.pdf:
        erg = pruefe(p, a.beschnitt, a.sicherheit)
        ausgabe(erg)
        alle.append(erg)
    if a.json:
        with open(a.json, "w", encoding="utf-8") as f:
            json.dump(alle, f, ensure_ascii=False, indent=1, default=list)
    fehler = any(st == "FEHLER" for e in alle for st, _ in e["urteil"])
    sys.exit(1 if fehler else 0)


if __name__ == "__main__":
    main()
