#!/usr/bin/env python3
"""
schriftarten_ersetzen.py -- ersetzt Microsoft-Schriftarten in ODT/DOCX-Dateien durch freie Schriftarten.

Aufruf:
    python3 schriftarten_ersetzen.py datei.odt              # schreibt datei_frei.odt
    python3 schriftarten_ersetzen.py datei.docx -o neu.docx
    python3 schriftarten_ersetzen.py *.odt *.docx           # mehrere Dateien auf einmal
    python3 schriftarten_ersetzen.py datei.odt --liste      # nur anzeigen, was ersetzt würde
    python3 schriftarten_ersetzen.py datei.odt --inplace    # Originaldatei überschreiben (Sicherung: datei.odt.bak)

Unterstützt: ODF (.odt, .ott, .ods, .odp ...) und Word (.docx, .dotx). Nur Python-Standardbibliothek.
Die Ersatzschriften sind metrikkompatibel (gleiche Zeichenbreiten), der Seitenumbruch bleibt also gleich.

✦ Entwickelt mit Claude Code (https://claude.com/claude-code)
"""
import argparse
import re
import shutil
import sys
import zipfile
from collections import Counter
from pathlib import Path

# ------------------------------------------------------------------ hier anpassen
ERSATZ = {
    "Calibri": "Carlito",
    "Cambria": "Caladea",
    "Arial": "Liberation Sans",
    "Times New Roman": "Liberation Serif",
    "Courier New": "Liberation Mono",
    "Tahoma": "DejaVu Sans",
    "Verdana": "DejaVu Sans",
}
# ----------------------------------------------------------------------------------

gefunden = Counter()  # welche Ersetzungen wurden vorgenommen?


def ersetze_name(wert):
    """'Calibri' -> 'Carlito'; 'Calibri1' -> 'Carlito1'; &apos;Times New Roman&apos; -> &apos;Liberation Serif&apos;"""
    m = re.fullmatch(r"(&apos;|')?(.+?)(\d*)(&apos;|')?", wert)
    if not m:
        return wert
    q1, name, ziffern, q2 = m.groups()
    if name in ERSATZ:
        gefunden[f"{name} -> {ERSATZ[name]}"] += 1
        return f"{q1 or ''}{ERSATZ[name]}{ziffern}{q2 or ''}"
    return wert


def ersetze_attribute(xml, attribute):
    """Ersetzt den Wert aller Attribute, die auf das Muster 'attribute' passen."""
    muster = re.compile(r'(\b' + attribute + r')="([^"]*)"')
    return muster.sub(lambda m: f'{m.group(1)}="{ersetze_name(m.group(2))}"', xml)


def doppelte_entfernen(xml, element_muster, name_muster):
    """Entfernt Deklarationen mit gleichem Namen (nach der Ersetzung gäbe es z.B. zweimal 'Carlito')."""
    gesehen = set()

    def pruefe(m):
        n = re.search(name_muster, m.group(0))
        if not n:
            return m.group(0)
        if n.group(1) in gesehen:
            return ""
        gesehen.add(n.group(1))
        return m.group(0)

    return re.sub(element_muster, pruefe, xml, flags=re.S)


def bearbeite_odf(xml):
    # Schriftname in Formatvorlagen und Deklarationen (font-name, font-name-asian, font-name-complex, font-family ...)
    xml = ersetze_attribute(xml, r"(?:style:font-name(?:-asian|-complex)?|svg:font-family|fo:font-family|style:font-family-(?:asian|complex))")
    # Deklaration <style:font-face style:name="Calibri" ...> umbenennen, damit die Verweise weiter passen
    xml = re.sub(r"<style:font-face\b[^>]*>",
                 lambda m: ersetze_attribute(m.group(0), r"style:name"), xml)
    xml = doppelte_entfernen(xml, r"<style:font-face\b[^>]*?/>", r'style:name="([^"]*)"')
    return xml


def bearbeite_ooxml(xml):
    xml = ersetze_attribute(xml, r"w:(?:ascii|hAnsi|eastAsia|cs)")        # Schriftnamen in Absätzen/Formatvorlagen
    xml = ersetze_attribute(xml, r"typeface")                              # Designschriften (theme1.xml)
    xml = re.sub(r"<w:font\b[^>]*>",                                       # fontTable.xml
                 lambda m: ersetze_attribute(m.group(0), r"w:name"), xml)
    xml = doppelte_entfernen(xml, r"<w:font\b[^>]*?>.*?</w:font>", r'w:name="([^"]*)"')
    # Alternativnamen (<w:altName w:val="Calibri"/>) von Microsoft-Schriften entfernen
    xml = re.sub(r'<w:altName w:val="([^"]*)"\s*/>',
                 lambda m: "" if m.group(1) in ERSATZ else m.group(0), xml)
    return xml


def verarbeite(quelle, ziel, nur_liste=False):
    gefunden.clear()
    with zipfile.ZipFile(quelle) as zin:
        namen = zin.namelist()
        if "content.xml" in namen:
            art = "odf"
        elif "word/document.xml" in namen:
            art = "ooxml"
        else:
            raise SystemExit(f"{quelle}: weder ODF- noch Word-Datei")

        zout = None if nur_liste else zipfile.ZipFile(ziel, "w")
        try:
            for info in zin.infolist():
                daten = zin.read(info.filename)
                n = info.filename
                if art == "odf" and n in ("content.xml", "styles.xml"):
                    daten = bearbeite_odf(daten.decode("utf-8")).encode("utf-8")
                elif art == "ooxml" and n.startswith("word/") and n.endswith(".xml"):
                    daten = bearbeite_ooxml(daten.decode("utf-8")).encode("utf-8")
                if zout is not None:
                    # Reihenfolge beibehalten; 'mimetype' muss bei ODF unkomprimiert bleiben
                    typ = zipfile.ZIP_STORED if n == "mimetype" else zipfile.ZIP_DEFLATED
                    zout.writestr(zipfile.ZipInfo(n, date_time=info.date_time), daten, compress_type=typ)
        finally:
            if zout is not None:
                zout.close()

    print(f"{quelle}:")
    if gefunden:
        for k, v in sorted(gefunden.items()):
            print(f"   {v:4d} x {k}")
    else:
        print("   keine ersetzbaren Schriften gefunden")


def main():
    p = argparse.ArgumentParser(description="Microsoft-Schriften in ODT/DOCX durch freie Schriften ersetzen")
    p.add_argument("dateien", nargs="+", type=Path)
    p.add_argument("-o", "--ausgabe", type=Path, help="Zieldatei (nur bei einer Eingabedatei)")
    p.add_argument("--inplace", action="store_true", help="Original überschreiben (Sicherung als .bak)")
    p.add_argument("--liste", action="store_true", help="nur anzeigen, nichts schreiben")
    a = p.parse_args()

    if a.ausgabe and len(a.dateien) > 1:
        sys.exit("-o geht nur mit einer Eingabedatei")
    for q in a.dateien:
        if a.inplace:
            sicherung = q.with_name(q.name + ".bak")
            shutil.copy2(q, sicherung)
            ziel = q
            quelle = sicherung
        else:
            quelle = q
            ziel = a.ausgabe or q.with_name(q.stem + "_frei" + q.suffix)
        verarbeite(quelle, ziel, nur_liste=a.liste)
        if not a.liste:
            print(f"   -> {ziel}")


if __name__ == "__main__":
    main()
