#!/bin/bash
# script destiné à être lancé par l'utilisateur se4install afin d générer l'image wine-$1.img, et également si besoin tous les éléments nécessaires pour
# faire un paquet wine-$1

# au logon, les prefix sont montés sur /var/tmp/$USER/wine/wine-appli/prefix.
# toute modification apportée au prefix est enregistrée en overlay.
# le script peut refaire une image à partir du montage en cours modifié, par exemple en cas de mise à jour.

# les lanceurs sont à modifier manuellement :
# wine va en général mettre un lanceur .desktop dans ~/.local/share/applications/, avec une icone en référence.
# afin de permettre une personnalisation maximale, il est conseillé de faire fichier /tmp/appli/appli.desktop qui lance un script wrapper /usr/bin/appli qui accepte éventuelleemnt des arguments
# ce script doit être nommé /tmp/appli/appli

# généralement wine va ajouter les associations de fichiers définies par l'installeur dans .config/mimeapps.list. Il faut extraire celles que l'on souhaite conserver et les
# mettre dans un fichier mime.list

# en résumé :

# /tmp/appli/wine-appli.img -> image du prefix -> /var/sambaedu/unattended/install/wine/wine-appli.img + sha256sum  + lien dans /usr/share/sambaedu/wine/
# /tmp/appli/appli.desktop -> entrée de menu -> .local/share/applications/
# /tmp/appli/appli.png -> icone -> .local/share/icons/XxX/
# /tmp/appli/appli -> wrapper (executable) -> /usr/bin/appli
# /tmp/appli/mime.list -> associations par défaut -> fusionner avec .config/mimeapps.list

# test local

# /usr/share/sambaedu/sbin/make_prefix_image.sh appli local
#

# envoi sur le dépôt (il faut avoir la clé pour ssh root@deb.sambaedu.org)

git="$HOME/git/sambaedu-wpkg-xml/sources"

# dépôt des recettes wpkg (stable/testing/XP/manuel), et checkout local de se4
# (pour wpkg-se4.js). Utilisés par install_wpkg et test_wine_apps ci-dessous.
# $HOME et non /home/$USER : ne pas supposer que le home d'un utilisateur suit
# ce schéma (faux par exemple pour ci.runner, dont le home est local, hors
# NFS/Kerberos - voir le commentaire sur /etc/passwd sur le runner CI).
wpkg_xml_repo="$HOME/git/sambaedu-wpkg-xml"
git_se4="$HOME/git/se4"

# cherche la recette wpkg d'une application dans le dépôt sambaedu-wpkg-xml.
# affiche le chemin trouvé sur stdout, échoue si aucune recette n'existe.
function find_package_xml() {
    local appli="$1" repo
    for repo in stable testing XP manuel; do
        if [ -f "$wpkg_xml_repo/$repo/$appli.xml" ]; then
            echo "$wpkg_xml_repo/$repo/$appli.xml"
            return 0
        fi
    done
    # repli : le nom de fichier ne correspond pas toujours à linux/@package
    # (ex: NotepadPlusPlus.xml déclare <linux type="wine" package="notepadplusplus">
    # - seule la casse diffère ici, mais IndexEducPronote25.xml/pronote montre que
    # ça peut aussi être un nom totalement différent). La variable APPLI du
    # pipeline (.gitlab-ci.yml de sambaedu-wpkg-xml) est renseignée avec la
    # valeur linux/@package (celle utilisée par
    # create_debian_source/xml_wine_categories), pas le nom de fichier : sans
    # ce repli, install_wpkg échoue "recette introuvable" dès que les deux
    # diffèrent - constaté en réel avec notepadplusplus.
    python3 -c '
import sys, os, glob
import xml.etree.ElementTree as ET
appli, repo = sys.argv[1], sys.argv[2]
for sub in ("stable", "testing", "XP", "manuel"):
    for path in sorted(glob.glob(os.path.join(repo, sub, "*.xml"))):
        try:
            root = ET.parse(path).getroot()
        except ET.ParseError:
            continue
        linux = root.find(".//linux")
        if linux is not None and linux.get("type") == "wine" and linux.get("package") == appli:
            print(path)
            sys.exit(0)
sys.exit(1)
' "$appli" "$wpkg_xml_repo"
}

# résout un id de paquet (<package id="...">, PAS un nom de fichier) vers
# le chemin de sa recette xml, en respectant la même priorité que
# find_package_xml (stable > testing > XP > manuel). Contrairement à
# find_package_xml, l'id ne correspond pas toujours au nom de fichier
# (ex : "dotnet3.5" n'est défini que dans dotnet35.xml, "python-idle" dans
# python.xml) : on tente d'abord le nom de fichier par optimisme, puis on
# scanne tout le dépôt si besoin. Utilisée pour résoudre les <depends>.
function find_package_by_id() {
    local pkgid="$1" fast
    if fast="$(find_package_xml "$pkgid")"; then
        if python3 -c '
import sys, xml.etree.ElementTree as ET
try:
    pkg = ET.parse(sys.argv[1]).getroot().find("package")
except ET.ParseError:
    pkg = None
sys.exit(0 if pkg is not None and pkg.get("id") == sys.argv[2] else 1)
' "$fast" "$pkgid"; then
            echo "$fast"
            return 0
        fi
    fi
    python3 -c '
import sys, os, glob
import xml.etree.ElementTree as ET
pkgid, repo = sys.argv[1], sys.argv[2]
for sub in ("stable", "testing", "XP", "manuel"):
    for path in sorted(glob.glob(os.path.join(repo, sub, "*.xml"))):
        try:
            root = ET.parse(path).getroot()
        except ET.ParseError:
            continue
        pkg = root.find("package")
        if pkg is not None and pkg.get("id") == pkgid:
            print(path)
            sys.exit(0)
sys.exit(1)
' "$pkgid" "$wpkg_xml_repo"
}

# calcule la fermeture transitive des dépendances (<depends package-id="X"/>)
# d'une recette wpkg, et produit sur stdout le packages.xml fusionné
# correspondant : wpkg-se4.js résout les dépendances uniquement à
# l'intérieur du packages.xml déjà chargé, jamais à la demande (confirmé en
# lisant getPackageDependencies()/installPackageReferences() dans
# wpkg-se4.js), donc packages.xml doit contenir toute la fermeture, pas
# seulement le paquet ciblé. Le parsing passe exclusivement par
# xml.etree.ElementTree (jamais grep/sed) car des <depends> commentés
# existent réellement dans le dépôt (ex: kompozer.xml) et ne doivent pas
# être suivis. Émet sur stderr un "SRCFILE:<chemin>" par fichier xml source
# contribuant à la fermeture (nécessaire ensuite pour télécharger aussi les
# installeurs des dépendances), et un "MISSING-DEP:<id>" par dépendance
# non commentée mais introuvable (échec, exit 1, aucun xml produit).
function compute_packages_closure() {
    python3 - "$1" "$wpkg_xml_repo" <<'PYEOF'
import sys, os, glob
import xml.etree.ElementTree as ET

xmlsrc, repo = sys.argv[1], sys.argv[2]
subdirs = ("stable", "testing", "XP", "manuel")


def resolve(pkgid):
    for sub in subdirs:
        fast = os.path.join(repo, sub, pkgid + ".xml")
        if os.path.isfile(fast):
            try:
                root = ET.parse(fast).getroot()
            except ET.ParseError:
                root = None
            if root is not None:
                pkg = root.find("package")
                if pkg is not None and pkg.get("id") == pkgid:
                    return fast
    for sub in subdirs:
        for path in sorted(glob.glob(os.path.join(repo, sub, "*.xml"))):
            try:
                root = ET.parse(path).getroot()
            except ET.ParseError:
                continue
            pkg = root.find("package")
            if pkg is not None and pkg.get("id") == pkgid:
                return path
    return None


visited = {}
order = []
srcfiles = []
missing = []
queue = [xmlsrc]
queued_ids = set()

while queue:
    path = queue.pop(0)
    try:
        root = ET.parse(path).getroot()
    except ET.ParseError as e:
        print("MISSING-DEP:" + path + " (xml invalide : " + str(e) + ")", file=sys.stderr)
        continue
    pkg = root.find("package")
    if pkg is None:
        print("MISSING-DEP:" + path + " (pas de <package>)", file=sys.stderr)
        continue
    pkgid = pkg.get("id")
    if pkgid in visited:
        continue
    visited[pkgid] = pkg
    order.append(pkgid)
    srcfiles.append(path)
    for dep in pkg.findall("depends"):
        depid = dep.get("package-id")
        if not depid or depid in visited or depid in queued_ids:
            continue
        target = resolve(depid)
        if target is None:
            missing.append(depid)
            continue
        queued_ids.add(depid)
        queue.append(target)

if missing:
    for m in missing:
        print("MISSING-DEP:" + m, file=sys.stderr)
    sys.exit(1)

print('<?xml version="1.0" encoding="UTF-8"?>')
print("<packages>")
for pkgid in order:
    print(ET.tostring(visited[pkgid], encoding="unicode"))
print("</packages>")

for s in srcfiles:
    print("SRCFILE:" + s, file=sys.stderr)
PYEOF
}

# vrai (exit 0) si l'application n'a pas besoin d'être testée sous wine
# car elle dispose d'un équivalent linux :
#
# 1. balise <linux .../> explicite (type ou method="apt" : les deux
#    s'utilisent dans le dépôt, les 63 occurrences actuelles sont toutes des
#    déclarations apt) : on fait confiance à cette déclaration du xml sans
#    condition, même si apt-cache ne trouve pas (encore) le paquet sur cette
#    machine - ex: bambustudio.xml déclare <linux type="apt"
#    package="bambustudio"/> alors que le paquet n'est pas encore synchronisé
#    dans le cache apt local : ce n'est pas une raison de tester l'appli
#    sous wine, la déclaration du xml fait foi.
# 2. sinon (pas de balise <linux>), convention implicite documentée dans le
#    README de sambaedu-wpkg-xml : l'id du <package> en minuscules est
#    utilisé comme nom de paquet Debian. Ici, contrairement au cas explicite,
#    on vérifie via apt-cache que ce paquet existe réellement : c'est une
#    simple supposition (l'id peut très bien ne correspondre à aucun paquet).
function has_native_linux() {
    local pkgname
    pkgname="$(python3 -c '
import sys, xml.etree.ElementTree as ET
root = ET.parse(sys.argv[1]).getroot()
linux = root.find(".//linux")
if linux is not None:
    print("EXPLICIT")
else:
    print(root.find("package").get("id").lower())
' "$1")"
    [ "$pkgname" = "EXPLICIT" ] && return 0
    [ -n "$pkgname" ] && apt-cache show "$pkgname" >/dev/null 2>&1
}

# vrai (exit 0) si au moins une dépendance transitive (<depends
# package-id="...">) de l'appli a elle-même un équivalent linux natif
# (has_native_linux). Tester l'appli sous wine impliquerait alors
# d'installer sous wine cette dépendance alors qu'elle est déjà couverte
# nativement - un exercice inutile, et souvent voué à l'échec pour une
# raison sans rapport avec la recette elle-même (ex: freemind dépend de
# jre, qui a un paquet debian natif mais dont l'installeur .exe échoue
# sous wine avec une erreur MSI 1603).
# Réutilise compute_packages_closure (définie plus bas) pour la résolution
# de dépendances : une seule logique de résolution dans tout le script.
function has_native_dependency() {
    local xmlfile="$1" stderr_out line dep
    stderr_out="$(compute_packages_closure "$xmlfile" 2>&1 >/dev/null)"
    while IFS= read -r line; do
        case "$line" in
            SRCFILE:*)
                dep="${line#SRCFILE:}"
                [ "$dep" = "$xmlfile" ] && continue
                has_native_linux "$dep" && return 0
                ;;
        esac
    done <<<"$stderr_out"
    return 1
}

# applique, si la recette le demande (<package><wine winetricks="..."
# script="fichier"/></package>), une préparation du prefix avant
# l'installation Windows proprement dite : winetricks (verbes séparés par des
# espaces) et/ou un script exécuté sur l'HÔTE de packaging (pas sous wine,
# contrairement à winetricks) qui reçoit le chemin du prefix en argument - à
# lui d'invoquer wine/winetricks/wine reg import selon ses besoins, avec la
# même liberté que make-prefix lui-même. "fichier" (script=) doit avoir été
# récupéré au préalable par un <download url=... saveto="fichier"> classique
# (n'importe où dans le xml, y compris sous <linux> : le téléchargement
# existant d'install_wpkg parcourt tout l'arbre via iter("download"), aucun
# changement nécessaire là).
# Idempotent par prefix+paquet (fichier marqueur) : dans un prefix partagé
# (ex. prefix=svt-apps utilisé par plusieurs applis), ne s'applique qu'une
# fois par paquet, pas à chaque réinstallation/nouvel essai.
function apply_wine_config() {
    local xmlsrc="$1" prefixname="$2" pkgid="$3"
    local PREFIX="/var/tmp/$USER/wine/wine-$prefixname/prefix"
    local INSTALL_DIR="$PREFIX/drive_c/windows/install"
    local marker="$PREFIX/.sambaedu-wine-config-$pkgid"
    [ -f "$marker" ] && return 0

    local winetricks_verbs script_saveto
    IFS=$'\t' read -r winetricks_verbs script_saveto < <(python3 -c '
import sys, xml.etree.ElementTree as ET
root = ET.parse(sys.argv[1]).getroot()
wine = root.find("package/wine")
w = wine.get("winetricks", "") if wine is not None else ""
s = wine.get("script", "") if wine is not None else ""
print(w + "\t" + s)
' "$xmlsrc")

    if [ -n "$winetricks_verbs" ]; then
        echo "$pkgid : winetricks $winetricks_verbs sur $prefixname"
        # $winetricks_verbs volontairement non quoté : liste de verbes séparés par des espaces
        if ! WINEDLLOVERRIDES='winemenubuilder.exe=' WINEPREFIX="$PREFIX" winetricks -q $winetricks_verbs >/dev/null 2>&1; then
            echo "$pkgid : échec winetricks ($winetricks_verbs)"
            return 1
        fi
    fi

    if [ -n "$script_saveto" ]; then
        local script_path="$INSTALL_DIR/$script_saveto"
        if [ ! -f "$script_path" ]; then
            echo "$pkgid : script de configuration $script_saveto introuvable (vérifier le <download saveto=\"$script_saveto\"> de la recette)"
            return 1
        fi
        echo "$pkgid : exécution du script de configuration $script_saveto sur $prefixname"
        chmod +x "$script_path"
        if ! "$script_path" "$PREFIX"; then
            echo "$pkgid : échec du script de configuration $script_saveto"
            return 1
        fi
    fi

    touch "$marker"
}

# nom du builder déclaré par la recette (<package><wine builder="nom"/>), vide sinon
function recipe_builder() {
    python3 -c '
import sys, xml.etree.ElementTree as ET
wine = ET.parse(sys.argv[1]).getroot().find("package/wine")
print(wine.get("builder", "") if wine is not None else "")
' "$1"
}

# exécute, si la recette le demande (<package><wine builder="nom"/></package>),
# le builder spécifique de l'appli, livré dans son paquet wine-<appli> mais
# pris ici dans le dépôt (pas besoin d'installer le paquet pour construire
# son propre prefix) :
#   $wpkg_xml_repo/sources/usr/share/sambaedu/wine/builders/<nom>/build.sh build <prefix>
# Contrairement à apply_wine_config, pas de marqueur : le builder repasse à
# chaque install_wpkg (mise à jour de l'appli dans le prefix publié) et doit
# donc être idempotent. Il télécharge et installe lui-même l'application
# (les <download> de la recette sont ignorés, voir install_wpkg) : wpkg n'a
# plus qu'à vérifier le résultat par le <check> de la recette.
function run_wine_builder() {
    local xmlsrc="$1" prefixname="$2" pkgid="$3"
    local PREFIX="/var/tmp/$USER/wine/wine-$prefixname/prefix"

    local builder
    builder="$(recipe_builder "$xmlsrc")"
    [ -n "$builder" ] || return 0

    local script="$wpkg_xml_repo/sources/usr/share/sambaedu/wine/builders/$builder/build.sh"
    if [ ! -f "$script" ]; then
        echo "$pkgid : builder $builder introuvable ($script)"
        return 1
    fi
    local log="/var/tmp/$USER/wine/wine-$prefixname-builder.log"
    echo "$pkgid : exécution du builder $builder sur $prefixname (log : $log)"
    if ! bash "$script" build "$PREFIX" >"$log" 2>&1; then
        tail -n 20 "$log"
        echo "$pkgid : échec du builder $builder"
        return 1
    fi
}

# installe une application via le client wpkg natif (wpkg-native.py) dans un
# prefix wine dédié, à partir de la recette du dépôt local sambaedu-wpkg-xml.
# En prod le téléchargement des installeurs est fait côté serveur : on le
# reproduit ici, en réutilisant en lecture seule /opt/install/packages
# (partage réseau serveur) si présent, sinon /opt/local/packages (cache
# local persistant, alimenté ici même après chaque téléchargement - utile
# quand /opt/install n'est pas monté : poste sans serveur SambaEdu, CI...),
# et en téléchargeant sinon dans le prefix lui-même.
function install_wpkg() {
    local appli="$1" prefixname="$2"
    local PREFIX="/var/tmp/$USER/wine/wine-$prefixname/prefix"
    if [ ! -d "$PREFIX" ]; then
        echo "Le prefix $prefixname n'existe pas. Lancez d'abord : $0 new $prefixname"
        return 1
    fi
    echo "tentative d'installation via wpkg windows de l'application $appli sur le prefix wine-$prefixname"

    local xmlsrc
    if ! xmlsrc="$(find_package_xml "$appli")"; then
        echo "recette wpkg introuvable pour $appli dans $wpkg_xml_repo"
        return 1
    fi

    # l'id du paquet (attribut id="..." du <package>) ne correspond pas
    # toujours exactement (à la casse près) au nom du fichier xml : c'est lui
    # qu'il faut utiliser pour /install: et profiles.xml, pas $appli.
    local pkgid
    pkgid="$(python3 -c '
import sys, xml.etree.ElementTree as ET
print(ET.parse(sys.argv[1]).getroot().find("package").get("id"))
' "$xmlsrc")"
    if [ -z "$pkgid" ]; then
        echo "impossible de déterminer l'id du paquet dans $xmlsrc"
        return 1
    fi

    local INSTALL_DIR="$PREFIX/drive_c/windows/install"
    local WPKG_DIR="$INSTALL_DIR/wpkg"
    mkdir -p "$WPKG_DIR"

    # packages.xml doit contenir $xmlsrc ET toute sa fermeture de
    # dépendances (<depends package-id="...">) : voir compute_packages_closure.
    local closure_err="/var/tmp/$USER/wine/wine-$prefixname-closure.err"
    if ! compute_packages_closure "$xmlsrc" >"$WPKG_DIR/packages.xml" 2>"$closure_err"; then
        echo "résolution des dépendances impossible pour $appli :"
        cat "$closure_err"
        rm -f "$closure_err"
        return 1
    fi
    local srcfiles=()
    mapfile -t srcfiles < <(grep "^SRCFILE:" "$closure_err" | sed 's/^SRCFILE://')
    rm -f "$closure_err"

    # hosts.xml/profiles.xml ne sont pas régénérés : c'était un artefact du
    # protocole CLI de wpkg-se4.js (/profile:/host:), inutile pour
    # wpkg-native.py, qui prend directement packages.xml en entrée.

    # certaines recettes (ex: adnarn, curl, geogebra, vlc...) utilisent dans
    # leurs commandes <install cmd="..."> des utilitaires livrés à côté de
    # wpkg-se4.js en production (%Z%\wpkg\tools\7za.exe, nircmd.exe...) : sans
    # cette copie elles échouent avec "fichier introuvable".
    if [ -d "$git_se4/sources/var/sambaedu/unattended/install/wpkg/tools" ]; then
        rm -rf "$WPKG_DIR/tools"
        cp -r "$git_se4/sources/var/sambaedu/unattended/install/wpkg/tools" "$WPKG_DIR/tools"
    fi

    # téléchargement des fichiers d'installation référencés par la recette
    # ET par toute sa fermeture de dépendances (srcfiles, calculée plus
    # haut) : une dépendance a aussi ses propres <download> à récupérer.
    # le cache /opt/install/packages n'est réutilisé que si son checksum
    # correspond à celui attendu par la recette (sinon il peut être plus
    # ancien que ce que déclare le xml : on retélécharge dans ce cas).
    # dlerrors/INSTALL_WPKG_DL_ERROR (volontairement PAS locale : elle doit
    # rester lisible par l'appelant, ex. test_wine_apps, après le retour de
    # cette fonction) permet de distinguer explicitement dans le rapport un
    # échec de téléchargement (url injoignable, checksum différent - donc un
    # problème de recette/ressource externe) d'un échec d'installation.
    local ok=1 url saveto sha256 dest cached cached_sha256 got srcfile localcache
    local dlerrors=()
    INSTALL_WPKG_DL_ERROR=""
    # une appli à builder (<wine builder=...>, voir run_wine_builder) gère
    # elle-même ses téléchargements : les <download> de la recette servent au
    # déploiement Windows (sha256 figé d'un installeur qui change côté
    # éditeur) et feraient échouer le build ici.
    local builder
    builder="$(recipe_builder "$xmlsrc")"
    [ -n "$builder" ] && srcfiles=()
    for srcfile in "${srcfiles[@]}"; do
        while IFS=$'\t' read -r url saveto sha256; do
            [ -z "$url" ] && continue
            dest="$INSTALL_DIR/$saveto"
            mkdir -p "$(dirname "$dest")"
            localcache="/opt/local/packages/$saveto"

            if [ ! -f "$dest" ]; then
                cached="/opt/install/$saveto"
                cached_sha256="$(sha256sum "$cached" 2>/dev/null | cut -d' ' -f1)"
                if [ -f "$cached" ] && { [ -z "$sha256" ] || [ "${cached_sha256^^}" == "${sha256^^}" ]; }; then
                    echo "copie depuis le cache $cached"
                    cp "$cached" "$dest"
                else
                    # /opt/install n'existe (partage réseau serveur) que sur
                    # un poste rattaché à un serveur SambaEdu : sur un poste
                    # sans serveur (ou ce runner CI), /opt/local/packages sert
                    # de repli, alimenté ci-dessous après chaque téléchargement
                    # réussi, pour éviter de re-télécharger à chaque run.
                    cached_sha256="$(sha256sum "$localcache" 2>/dev/null | cut -d' ' -f1)"
                    if [ -f "$localcache" ] && { [ -z "$sha256" ] || [ "${cached_sha256^^}" == "${sha256^^}" ]; }; then
                        echo "copie depuis le cache local $localcache"
                        cp "$localcache" "$dest"
                    else
                        echo "téléchargement de $url"
                        if ! wget -q -O "$dest" "$url"; then
                            echo "échec du téléchargement de $url"
                            rm -f "$dest"
                            ok=0
                            dlerrors+=("url injoignable : $url")
                            continue
                        fi
                    fi
                fi
            fi

            if [ -n "$sha256" ]; then
                got="$(sha256sum "$dest" | cut -d' ' -f1)"
                if [ "${got^^}" != "${sha256^^}" ]; then
                    echo "sha256 invalide pour $dest (attendu $sha256, obtenu $got)"
                    ok=0
                    dlerrors+=("checksum différent : $saveto (attendu ${sha256^^}, obtenu ${got^^})")
                    continue
                fi
            fi

            # alimente /opt/local/packages (pas /opt/install, qui n'est
            # écrit que côté serveur) uniquement si le fichier n'y est pas
            # déjà et que $dest vient de passer la vérification sha256
            # ci-dessus (ou qu'aucun sha256 n'est fourni par la recette).
            if [ ! -f "$localcache" ] && [ ! -f "/opt/install/$saveto" ]; then
                mkdir -p "$(dirname "$localcache")" 2>/dev/null && cp "$dest" "$localcache" 2>/dev/null
            fi
        done < <(python3 -c '
import sys, xml.etree.ElementTree as ET
tree = ET.parse(sys.argv[1])
for d in tree.getroot().iter("download"):
    print(d.get("url","") + "\t" + d.get("saveto","") + "\t" + d.get("sha256sum",""))
' "$srcfile")
    done

    if [ "$ok" != "1" ]; then
        INSTALL_WPKG_DL_ERROR="$(IFS='; '; echo "${dlerrors[*]}")"
        echo "téléchargement des fichiers d'installation incomplet pour $appli : $INSTALL_WPKG_DL_ERROR"
        return 3
    fi

    # configuration préalable du prefix (winetricks/script), si la recette le
    # demande via <package><wine winetricks="..." script="..."/></package> -
    # doit se faire après le téléchargement (le script= éventuel est un
    # <download> comme un autre) et avant l'installation Windows proprement
    # dite ci-dessous, dont elle peut être un prérequis.
    # repère de début d'installation de CETTE appli : prepare n'en propose
    # que les raccourcis créés depuis (prefix partagé : raccourcis d'autres
    # applis non retenus, voir create_debian_source)
    touch "/var/tmp/$USER/wine/wine-$prefixname-$appli.installstart"
    if ! apply_wine_config "$xmlsrc" "$prefixname" "$pkgid"; then
        return 4
    fi
    if ! run_wine_builder "$xmlsrc" "$prefixname" "$pkgid"; then
        return 4
    fi

    # certains installeurs silencieux (dont celui de 7-Zip) rendent la main
    # avant d'avoir fini d'écrire tous les fichiers sur disque (plus visible
    # sous Wine que sous Windows) : la vérification post-installation de
    # wpkg-se4.js peut donc échouer alors que l'application est bel et bien
    # installée. wpkg est idempotent (la vérification pré-installation d'un
    # nouvel essai constate alors que le paquet est déjà installé) : on
    # retente donc quelques fois avant de déclarer un échec définitif.
    local log="/var/tmp/$USER/wine/wine-$prefixname-wpkg.log"
    local attempt
    local wpkg_status
    for attempt in 1 2 3; do
        # certains installeurs affichent leur propre boîte d'erreur, ou wine
        # affiche sa fenêtre de crash (winedbg, désactivée dans create_prefix
        # mais on garde ce filet de sécurité) : sans limite de temps, un test
        # non interactif resterait bloqué indéfiniment sur un clic humain qui
        # ne viendra jamais. timeout garantit qu'on ne reste jamais coincé.
        # WINEDLLOVERRIDES=winemenubuilder.exe= : winemenubuilder n'a pas
        # d'option pour désactiver spécifiquement l'export d'icônes vers le
        # VRAI bureau linux (confirmé en lisant son binaire) - il le fait
        # unilatéralement pour tout raccourci créé pendant l'installation, ce
        # qui pollue le bureau réel de l'utilisateur pour chaque appli
        # testée. On le désactive donc entièrement ici (les .lnk bruts
        # restent dans le prefix, utilisés directement par
        # run_prefix_app/smoke_test_app) ; create_debian_source le
        # réactive ponctuellement, pour la seule appli qu'on package
        # réellement, où avoir un menu/icônes est nécessaire. wpkg-native.py
        # transmet cette variable d'environnement aux commandes wine qu'il
        # lance pour les <install cmd="...">.
        WINEDLLOVERRIDES='winemenubuilder.exe=' \
            timeout --kill-after=10 300 \
            wpkg-native.py --packages "$WPKG_DIR/packages.xml" --prefix "$PREFIX" \
            >"$log.attempt$attempt" 2>&1
        wpkg_status=$?
        cp "$log.attempt$attempt" "$log"
        if grep -q "RESULT:$pkgid:OK" "$log"; then
            echo "$appli : installation réussie (log : $log, essai $attempt/3)"
            return 0
        fi
        if [ "$wpkg_status" -eq 124 ] || [ "$wpkg_status" -eq 137 ]; then
            echo "$appli : installation interrompue après 300s (blocage probable : boîte de dialogue, crash) (essai $attempt/3)"
        fi
        # état propre pour le prochain essai : un process tué par timeout
        # peut laisser une boîte de dialogue ou un mutex qui referait
        # bloquer l'essai suivant sinon.
        WINEPREFIX="$PREFIX" wineserver -k >/dev/null 2>&1
        sleep 3
    done

    echo "$appli : échec de l'installation (log : $log)"
    return 1
}

# lance brièvement l'application installée pour vérifier qu'elle ne plante
# pas immédiatement - un signal complémentaire, PAS une preuve de bon
# fonctionnement (une appli bloquée sur une boîte de dialogue de première
# utilisation est indiscernable ici d'une appli qui marche). N'utilise
# jamais le PID bash du lancement en arrière-plan pour détecter/tuer le
# process réel : sur un lancement via .lnk, ce PID est celui du wrapper
# "start.exe" de wine, jamais l'exécutable réel (vérifié via pstree) - on
# utilise donc "wine tasklist" (le vrai tasklist.exe de wine, scopé au
# WINEPREFIX) pour observer les process réels, via un diff avant/après
# (aucune balise StartupWMClass disponible ici : winemenubuilder, seule
# source de cette information, est désactivé pendant install_wpkg - voir
# find_prefix_shortcuts). wineserver -k pour tout arrêter proprement à la
# fin. Affiche sur stdout un statut parmi : SMOKE-OK, SMOKE-FAIL,
# SMOKE-SKIPPED-no-shortcut, SMOKE-SKIPPED-tasklist-unavailable.
# smoke_test_app appli prefix
function smoke_test_app() {
    local appli="$1" prefixname="$2"
    local PREFIX="/var/tmp/$USER/wine/wine-$prefixname/prefix"
    local grace=10

    local lnk
    lnk="$(find_prefix_shortcuts "$prefixname" | head -n1)"
    if [ -z "$lnk" ]; then
        echo "SMOKE-SKIPPED-no-shortcut"
        return 0
    fi

    # wine tasklist encode sa sortie dans la page de code OEM (pas UTF-8) :
    # grep -a force le mode texte, sinon grep peut détecter à tort un
    # "fichier binaire" sur les octets non-UTF-8 des colonnes accentuées
    # (ex: "Mémoire") et se comporter de façon peu fiable.
    local before status
    if ! before="$(WINEPREFIX="$PREFIX" wine tasklist 2>/dev/null)"; then
        echo "SMOKE-SKIPPED-tasklist-unavailable"
        return 0
    fi

    local log="/var/tmp/$USER/wine/wine-$prefixname-smoke.log"
    WINEPREFIX="$PREFIX" WINEDLLOVERRIDES='winemenubuilder.exe=' wine "$lnk" >"$log" 2>&1 &
    sleep "$grace"

    local after new_procs
    if ! after="$(WINEPREFIX="$PREFIX" wine tasklist 2>/dev/null)"; then
        status="SMOKE-SKIPPED-tasklist-unavailable"
    else
        # une ligne présente après le lancement mais pas avant = un nouveau
        # process réel (l'appli elle-même, pas le wrapper start.exe qui,
        # lui, apparaît puis disparaît généralement avant ce point).
        new_procs="$(comm -13 <(echo "$before" | sort) <(echo "$after" | sort))"
        if [ -n "$new_procs" ]; then
            status="SMOKE-OK"
        else
            status="SMOKE-FAIL"
        fi
    fi

    WINEPREFIX="$PREFIX" wineserver -k >/dev/null 2>&1
    echo "$status"
}

# crée (ou remet à niveau) un prefix wine. Non-interactif (wineboot --init),
# utilisable en CI. Ne dépend plus de wsh57/msxml3 (winetricks) : ces verbes
# n'étaient nécessaires que pour faire tourner wpkg-se4.js (JScript/MSXML)
# sous wine, remplacé par wpkg-native.py (voir install_wpkg), qui n'a besoin
# d'aucun des deux.
function create_prefix() {
    local prefixname="$1"
    local image="wine-$prefixname"
    local wp="/var/tmp/$USER/wine/$image/prefix"
    local fresh=1

    # prefix partagé déjà monté sur cette machine (mise à jour d'un prefix
    # existant) : on le réutilise tel quel, jamais de réinitialisation.
    if mountpoint -q "$wp" 2>/dev/null; then
        fresh=0
    # sinon, avant de créer un prefix tout neuf, on simule le
    # download_wine_prefix d'un postinst de paquet wine-* (voir
    # wine.inc.sh) : le prefix peut déjà exister côté serveur (déjà publié
    # par un run précédent, ou par un autre poste) sans jamais avoir été
    # utilisé sur CETTE machine (CI, ou poste tout juste réinstallé) - dans
    # ce cas il faut télécharger l'image et la monter, pas repartir de zéro.
    # Échoue silencieusement si le prefix n'existe pas encore côté serveur :
    # cas normal d'un tout nouveau prefix, cf. plus bas.
    elif sudo /usr/share/sambaedu/scripts/download_wine.sh "$image" >/dev/null 2>&1 \
        && systemctl --user start "wine-prepare-prefix@${image}.service" >/dev/null 2>&1 \
        && mountpoint -q "$wp" 2>/dev/null; then
        echo "prefix partagé $image téléchargé et monté."
        fresh=0
    # image publiée (ou déjà présente sur ce poste) mais pas montée : jamais
    # de prefix neuf à la place - il ne contiendrait que les applis de ce
    # passage, et l'image reconstruite écraserait l'image partagée publiée
    # (constaté sur le runner : montage de science-apps en échec, prefix
    # vide créé, Regressi/Algodoo... auraient disparu de l'image).
    elif [ -e "/usr/share/sambaedu/wine/$image.img" ] ||
        wget -q -O /dev/null "http://deb.sambaedu.org/wpkg/files/wine/$image.sha256"; then
        echo "$image : image publiée mais montage impossible (voir journalctl --user -u wine-mount-prefix@$image) : prefix non créé" >&2
        return 1
    fi

    if [ "$fresh" = 1 ]; then
        mkdir -p "$wp"
        WINEDLLOVERRIDES='winemenubuilder.exe=' WINEPREFIX="$wp" wineboot --init >/dev/null 2>&1
    fi

    # borné : un prefix monté peut avoir des services résidents (FlexNet...)
    WINEPREFIX="$wp" timeout 60 wineserver -w 2>/dev/null
    # désactive la fenêtre de crash de wine (winedbg) : sans ça, un
    # installeur qui plante sous wine affiche une boîte de dialogue qui
    # attend un clic humain et bloque indéfiniment un test non interactif.
    WINEPREFIX="$wp" wine reg add "HKEY_CURRENT_USER\\Software\\Wine\\WineDbg" /v ShowCrashDialog /t REG_DWORD /d 0 /f >/dev/null 2>&1
    # désactive XF86VidMode : sous xrdp, l'extension est annoncée mais
    # XF86VidModeSetGamma renvoie BadValue, erreur X fatale pour wine (ex :
    # eDrawings via d3d9). Avec XRandR présent, VidMode ne sert qu'au gamma.
    WINEPREFIX="$wp" wine reg add "HKEY_CURRENT_USER\\Software\\Wine\\X11 Driver" /v UseXVidMode /t REG_SZ /d N /f >/dev/null 2>&1

    [ "$fresh" = 1 ] || return 0

    # wineboot --init pointe par défaut Desktop/Documents/Pictures/Music/
    # Videos/Downloads (drive_c/users/$USER/*) vers les VRAIS dossiers de
    # l'utilisateur (Documents et Pictures pointent même directement sur
    # $HOME en entier !). Un installeur qui écrit là (raccourci sur le
    # bureau, fichier dans "Mes documents"...) pollue donc directement les
    # vrais fichiers de l'utilisateur. On remplace tout symlink qui pointe
    # sous $HOME par un vrai dossier local, confiné au prefix jetable.
    # (pour un prefix partagé réutilisé, prepare_prefix.sh a déjà fait
    # l'équivalent - voir wine-prepare-prefix@.service)
    local f target
    for f in "$wp/drive_c/users/$USER"/*; do
        [ -L "$f" ] || continue
        target="$(readlink -f "$f")"
        case "$target" in
        "$HOME" | "$HOME"/*)
            rm -f "$f"
            mkdir -p "$f"
            ;;
        esac
    done
}

# boucle d'intégration continue : teste, chacune dans un prefix wine séparé,
# toutes les applications du dépôt sambaedu-wpkg-xml (stable/) pour lesquelles
# aucun paquet debian du même id n'existe (voir has_native_linux).
function test_wine_apps() {
    local report="/var/tmp/$USER/wine/wpkg-ci-report.txt"
    local mode="$1"

    # reprise : par défaut (pas d'argument "reset"), une appli déjà présente
    # dans le rapport (d'une exécution précédente, interrompue ou non)
    # n'est pas retestée. Une interruption (Ctrl+C, timeout bloquant, arrêt
    # manuel) ne fait donc jamais repartir de zéro.
    local -A done_apps=()
    if [ "$mode" = "reset" ]; then
        : >"$report"
    elif [ -f "$report" ]; then
        local line
        while IFS= read -r line; do
            done_apps["${line%%:*}"]=1
        done <"$report"
    else
        : >"$report"
    fi

    local total=0 xmlfile appli status smoke

    for xmlfile in "$wpkg_xml_repo/stable/"*.xml; do
        [ -f "$xmlfile" ] || continue
        appli="$(basename "$xmlfile" .xml)"

        [ -n "${done_apps[$appli]:-}" ] && continue

        if has_native_linux "$xmlfile"; then
            continue
        fi

        # inutile de tester sous wine une appli dont une dépendance a déjà
        # un équivalent natif (voir has_native_dependency) : cela reviendrait
        # à installer cette dépendance sous wine sans raison.
        if has_native_dependency "$xmlfile"; then
            continue
        fi

        # image construite à la main sur un poste de construction (voir
        # xml_wine_modes) : pas d'installation automatique à tester
        if grep -q 'build="manuel"' "$xmlfile"; then
            continue
        fi

        total=$((total + 1))
        echo "=== Test de $appli ($total) ==="
        create_prefix "$appli"
        install_wpkg "$appli" "$appli"
        status=$?
        case $status in
            0)
                # signal complémentaire, non bloquant (cf. smoke_test_app) :
                # ne modifie jamais le statut ok/fail/untestable ci-dessus.
                smoke="$(smoke_test_app "$appli" "$appli")"
                echo "$appli: OK ($smoke)" >>"$report"
                ;;
            2)
                echo "$appli: NON TESTABLE (erreur d'accès au registre)" >>"$report"
                ;;
            3)
                # échec de téléchargement (url injoignable, checksum différent) :
                # un problème de recette/ressource externe, pas un défaut de
                # wpkg-se4.js ou de l'installeur lui-même - à distinguer
                # explicitement d'un échec d'installation (voir install_wpkg).
                echo "$appli: ECHEC (téléchargement : $INSTALL_WPKG_DL_ERROR)" >>"$report"
                ;;
            4)
                # échec de la configuration préalable du prefix (winetricks
                # ou script=, voir apply_wine_config) : distinct d'un échec
                # de l'installeur Windows lui-même.
                echo "$appli: ECHEC (configuration prefix winetricks/script)" >>"$report"
                ;;
            *)
                echo "$appli: ECHEC (installation)" >>"$report"
                ;;
        esac

        # le sweep sert à valider la compatibilité, pas à produire des
        # artefacts à publier (ça, c'est le rôle de new/install_wpkg/prepare/
        # image pour UNE appli choisie séparément) : chaque prefix (plusieurs
        # Go avec winetricks) est donc supprimé aussitôt son résultat
        # enregistré, sinon le disque se remplit en quelques dizaines
        # d'applis. Les logs (petits fichiers texte, utiles pour le
        # diagnostic) sont conservés, eux.
        WINEPREFIX="/var/tmp/$USER/wine/wine-$appli/prefix" wineserver -k >/dev/null 2>&1
        rm -rf "/var/tmp/$USER/wine/wine-$appli"
    done

    # décompte final à partir du rapport complet (cumulatif d'éventuelles
    # reprises précédentes), pas seulement des applis traitées dans cet
    # appel, pour rester cohérent après une reprise.
    local ok fail untestable skipped=0
    ok="$(grep -c ': OK' "$report")"
    untestable="$(grep -c ': NON TESTABLE' "$report")"
    fail="$(grep -c ': ECHEC' "$report")"
    for xmlfile in "$wpkg_xml_repo/stable/"*.xml; do
        [ -f "$xmlfile" ] || continue
        if has_native_linux "$xmlfile" || has_native_dependency "$xmlfile"; then
            skipped=$((skipped + 1))
        fi
    done
    echo "Résumé : $ok/$((ok + fail + untestable)) réussites, $fail échec(s), $untestable non testable(s) (registre), $skipped application(s) native(s) ou à dépendance native ignorée(s)."
    echo "Détail : $report"
}

# cherche le(s) raccourci(s) .lnk créés par l'installeur dans le prefix
# wine-$prefixname (Menu Démarrer, tous utilisateurs et utilisateur
# courant). Utilisé directement (winemenubuilder étant désactivé pendant
# install_wpkg, voir plus haut, aucun .desktop n'est généré à ce stade) par
# run_prefix_app et smoke_test_app. Un chemin unix par ligne sur stdout
# (peut être vide : certaines applis n'ont pas de raccourci, ex. outils en
# ligne de commande ou mises à jour silencieuses).
function find_prefix_shortcuts() {
    local prefixname="$1" PREFIX
    PREFIX="/var/tmp/$USER/wine/wine-$prefixname/prefix"
    find "$PREFIX/drive_c/ProgramData/Microsoft/Windows/Start Menu/Programs" \
        "$PREFIX/drive_c/users/$USER/AppData/Roaming/Microsoft/Windows/Start Menu/Programs" \
        -iname "*.lnk" 2>/dev/null
}

# lance interactivement une application déjà installée dans son prefix, pour
# validation fonctionnelle manuelle par un humain (contrairement à
# install_wpkg/test_wine, ce n'est PAS une action pensée pour le CI :
# premier plan, pas de log, pas de retry - l'utilisateur observe et
# interagit directement avec wine, Ctrl+C pour arrêter).
# run_prefix_app appli prefix [sous-chaine-desktop]
function run_prefix_app() {
    local appli="$1" prefixname="$2" filtre="$3"
    local PREFIX="/var/tmp/$USER/wine/wine-$prefixname/prefix"
    if [ ! -d "$PREFIX" ]; then
        echo "Le prefix $prefixname n'existe pas. Lancez d'abord : $0 new $prefixname puis $0 install_wpkg $appli $prefixname"
        return 1
    fi

    local shortcuts=()
    mapfile -t shortcuts < <(find_prefix_shortcuts "$prefixname")
    if [ -n "$filtre" ]; then
        local filtered=() d
        for d in "${shortcuts[@]}"; do
            [[ "$d" == *"$filtre"* ]] && filtered+=("$d")
        done
        shortcuts=("${filtered[@]}")
    fi

    if [ "${#shortcuts[@]}" -eq 0 ]; then
        echo "aucun raccourci .lnk trouvé pour le prefix wine-$prefixname (l'appli n'a peut-être pas de raccourci Menu Démarrer, ex. outil en ligne de commande)."
        return 1
    fi

    local choix
    if [ "${#shortcuts[@]}" -eq 1 ]; then
        choix="${shortcuts[0]}"
    else
        echo "plusieurs raccourcis trouvés pour wine-$prefixname :"
        local i
        for i in "${!shortcuts[@]}"; do
            echo "  $((i + 1))) $(basename "${shortcuts[$i]}" .lnk)"
        done
        local reponse
        read -r -p "lequel lancer (numéro, ou relancez avec un 3e argument pour filtrer) ? " reponse
        if ! [[ "$reponse" =~ ^[0-9]+$ ]] || [ "$reponse" -lt 1 ] || [ "$reponse" -gt "${#shortcuts[@]}" ]; then
            echo "choix invalide."
            return 1
        fi
        choix="${shortcuts[$((reponse - 1))]}"
    fi

    echo "lancement de $(basename "$choix" .lnk) (Ctrl+C pour arrêter) :"
    WINEPREFIX="$PREFIX" WINEDLLOVERRIDES='winemenubuilder.exe=' wine "$choix"
}

# cherche, dans tout le dépôt sambaedu-wpkg-xml (stable/testing/XP/manuel),
# la balise <linux type="wine" package="$1"> et affiche son attribut
# categories= (vide si non trouvée). $1 est ici la valeur de linux/@package,
# PAS le nom de fichier xml ni le <package id=> : les deux peuvent différer
# (ex : IndexEducPronote25.xml déclare <linux type="wine" package="pronote"
# ...>, et c'est "pronote" que l'opérateur passe à "prepare"), un scan
# complet du dépôt est donc nécessaire ici (pas de raccourci par nom de
# fichier possible, à la différence de find_package_by_id qui indexe sur
# l'id).
function xml_wine_categories() {
    python3 -c '
import sys, os, glob
import xml.etree.ElementTree as ET
pkgname, repo = sys.argv[1], sys.argv[2]
for sub in ("stable", "testing", "XP", "manuel"):
    for path in sorted(glob.glob(os.path.join(repo, sub, "*.xml"))):
        try:
            root = ET.parse(path).getroot()
        except ET.ParseError:
            continue
        for linux in root.findall(".//linux"):
            if linux.get("type") == "wine" and linux.get("package") == pkgname:
                print(linux.get("categories", ""))
                sys.exit(0)
print("")
' "$1" "$wpkg_xml_repo"
}

# _progid_is_generic prefix progid : vrai si l'association de fichier
# <progid> du prefix est une association générique Wine/Windows (commande
# d'ouverture dans C:\windows, %SystemRoot% ou sans chemin : regedit, wscript, hh,
# rundll32, msiexec, PresentationHost...) et non une association déclarée
# par une application installée (Program Files...). Lecture directe de
# system.reg/user.reg ([Software\\Classes\\<progid>\\shell\\open\\command],
# valeur par défaut) plutôt que "wine reg query" (lent, un wineserver par
# appel). ProgID sans commande "open" trouvée : conservé (faux négatif
# préférable à la perte d'une vraie association).
# _progid_command prefix progid : commande d'ouverture du ProgID, en
# minuscules, telle qu'écrite dans le registre (\\ doublés), vide si absente.
function _progid_command() {
    local reg="/var/tmp/$USER/wine/wine-$1/prefix"
    # clé passée par ENVIRON (pas -v, qui interpréterait les "\\")
    PROGID_KEY="[software\\\\classes\\\\$(printf '%s' "$2" | tr '[:upper:]' '[:lower:]')\\\\shell\\\\open\\\\command]" awk '
        BEGIN { key = ENVIRON["PROGID_KEY"] }
        /^\[/ { l = tolower($0); sub(/\] [0-9]+$/, "]", l); inkey = (l == key); next }
        inkey && /^@=/ { print; exit }
    ' "$reg/system.reg" "$reg/user.reg" 2>/dev/null | tr '[:upper:]' '[:lower:]'
}

function _progid_is_generic() {
    local cmd
    cmd="$(_progid_command "$1" "$2")"
    [ -n "$cmd" ] || return 1
    case "$cmd" in
        *'c:\\windows\\'* | *'%systemroot%'* | *'%windir%'*) return 0 ;;
        # sans chemin absolu (ex: "rundll32.exe dfshim.dll,..." pour
        # Application.Manifest) : résolu via le PATH système, donc générique -
        # une application installée a toujours un chemin absolu.
        *':\\'*) return 1 ;;
    esac
    return 0
}

# _launcher_icon_key desktop : icône d'un .desktop winemenubuilder sans son
# index de ressource (B644_Regressi64.0 -> B644_Regressi64) : <hash du
# chemin>_<exe>, identique pour un lanceur et les associations du même exe.
function _launcher_icon_key() {
    sed -n 's/^Icon=//p' "$1" | head -n1 | sed 's/\.[0-9]*$//'
}

# _launcher_dir prefix desktop : répertoire de travail du lanceur (Path=,
# en général le répertoire d'installation de l'appli), en chemin windows
# minuscules aux \\ doublés comme dans le registre (voir _progid_command) ;
# vide si absent ou hors de drive_c.
function _launcher_dir() {
    local path root="/var/tmp/$USER/wine/wine-$1/prefix/drive_c/" w
    path="$(sed -n 's/^Path=//p' "$2" | head -n1)"
    case "$path" in
        "$root"?*) ;;
        *) return 0 ;;
    esac
    w="c:/${path#"$root"}"
    w="${w%/}/"
    w="${w//\//\\\\}"
    printf '%s' "${w,,}"
}

# _assoc_is_foreign prefix assoc_desktop progid : vrai si l'association se
# rattache à un lanceur du prefix NON retenu pour ce paquet (tableau
# "others" de l'appelant : autre appli du prefix, ou appli sœur déjà
# packagée) et à aucun lanceur retenu (tableau "selected"). Rattachement
# par l'icône d'abord (même exe), sinon par le répertoire d'installation
# (Path= du lanceur contenu dans la commande d'ouverture du ProgID). Une
# association qu'on ne sait rattacher à rien est conservée (comportement
# antérieur) : on ne perd jamais une vraie association.
function _assoc_is_foreign() {
    local key cmd l dir sel=0 oth=0
    key="$(_launcher_icon_key "$2")"
    if [ -n "$key" ]; then
        for l in "${selected[@]}"; do [ "$(_launcher_icon_key "$l")" = "$key" ] && sel=1; done
        for l in "${others[@]}"; do [ "$(_launcher_icon_key "$l")" = "$key" ] && oth=1; done
    fi
    if [ "$sel" = 0 ] && [ "$oth" = 0 ]; then
        cmd="$(_progid_command "$1" "$3")"
        [ -n "$cmd" ] || return 1
        for l in "${selected[@]}"; do
            dir="$(_launcher_dir "$1" "$l")"
            [ -n "$dir" ] && [[ "$cmd" == *"$dir"* ]] && sel=1
        done
        for l in "${others[@]}"; do
            dir="$(_launcher_dir "$1" "$l")"
            [ -n "$dir" ] && [[ "$cmd" == *"$dir"* ]] && oth=1
        done
    fi
    [ "$sel" = 0 ] && [ "$oth" = 1 ]
}

# lanceurs déclarés dans la recette de l'appli :
#   <linux type="wine" package="<appli>" .../>
#   <wine ...><launch name=".." icon=".." desktop="..">C:\chemin\dans\le\prefix</launch>...</wine>
# une ligne par <launch> sur stdout : chemin, name, icon, desktop séparés par \x1f
# - chemin : chemin Windows dans le prefix (.lnk, .exe, Z:\... pour un
#   fichier fourni par le paquet), {{USER}} pour le nom de l'utilisateur
#   (même convention que l'image), jokers * ? [] admis (résolus au
#   lancement, correspondance la plus récente : ex. dossier de version
#   webdeploy\production\<hash>\ de Fusion360.exe) ;
# - name/icon : facultatifs, pour le .desktop généré ;
# - desktop : facultatif, .desktop winemenubuilder du prefix (nom sans
#   .desktop) dont on reprend Name/Icon/Comment et les associations mime
#   (ex. "Autodesk Fusion", raccourci de FusionLauncher.exe), la commande
#   lancée restant le <launch>.
function xml_wine_launches() {
    python3 -c '
import sys, xml.etree.ElementTree as ET
path, appli = sys.argv[1], sys.argv[2]
root = ET.parse(path).getroot()
for pkg in root.iter("package"):
    if not any(l.get("type") == "wine" and l.get("package") == appli for l in pkg.findall("linux")):
        continue
    wine = pkg.find("wine")
    if wine is None:
        break
    for la in wine.findall("launch"):
        t = (la.text or "").strip()
        if t:
            print("\x1f".join([t, la.get("name", ""), la.get("icon", ""), la.get("desktop", "")]))
    break
' "$1" "$2"
}

# fichiers ou dossiers du profil wine à conserver d'une session à l'autre :
#   <wine ...><persist>AppData\Local\Editeur\fichier.db</persist>...</wine>
# chemin relatif au profil (C:\users\<utilisateur>), "\" ou "/". Une ligne
# par <persist> sur stdout, en chemin unix ; chemins absolus ou contenant
# ".." refusés (avertissement sur stderr).
function xml_wine_persists() {
    python3 -c '
import sys, xml.etree.ElementTree as ET
path, appli = sys.argv[1], sys.argv[2]
root = ET.parse(path).getroot()
for pkg in root.iter("package"):
    if not any(l.get("type") == "wine" and l.get("package") == appli for l in pkg.findall("linux")):
        continue
    wine = pkg.find("wine")
    if wine is None:
        break
    for p in wine.findall("persist"):
        t = (p.text or "").strip().replace("\\", "/").strip("/")
        parts = t.split("/")
        if not t or ":" in parts[0] or ".." in parts:
            print("<persist> ignoré (chemin relatif au profil attendu) : %s" % p.text, file=sys.stderr)
            continue
        print(t)
    break
' "$1" "$2"
}

# mode de génération et statut de diffusion d'une appli wine, attributs de
# <linux type="wine" package="<appli>" build=".." distribution="..">.
# build : comment l'image est construite lors d'une nouvelle version du
#   logiciel (une nouvelle version de wine remet toujours à niveau l'image
#   publiée, quel que soit le mode, voir upgrade_wine_images) :
#   auto    : installeur silencieux de la recette, image reconstruite par la CI
#   builder : builder spécifique (<wine builder=...>), idem ; valeur déduite
#             de <wine builder> si l'attribut est absent
#   manuel  : image construite sur un poste de construction par un admin
#             (installation ou réglages non automatisables) ; la CI ne
#             reconstruit jamais l'image, au plus le paquet
# distribution (indicatif pour l'instant) : free (défaut, diffusion libre),
#   redist (diffusion autorisée par l'éditeur), restricted (diffusion
#   restreinte), unknown (situation inconnue)
# validation (indicatif pour l'instant) : untested (smoke-test passé, pas
#   encore validée en production - posé par le premier prepare d'un paquet,
#   voir create_debian_source), validated (défaut : recettes antérieures),
#   failed (échec du téléchargement, de l'installation ou du smoke-test lors
#   d'une création en lot, voir ci/create-wine-apps.sh de sambaedu-wpkg-xml)
#   ou shortcuts (installation réussie, <launch> à déclarer : plusieurs
#   raccourcis, choix impossible en CI)
# Sortie : "build<TAB>distribution<TAB>validation" (valeur inconnue : défaut
# + avertissement).
function xml_wine_modes() {
    python3 -c '
import sys, xml.etree.ElementTree as ET
path, appli = sys.argv[1], sys.argv[2]
build, dist, valid = "auto", "free", "validated"
for pkg in ET.parse(path).getroot().iter("package"):
    lx = [l for l in pkg.findall("linux") if l.get("type") == "wine" and l.get("package") == appli]
    if not lx:
        continue
    wine = pkg.find("wine")
    if wine is not None and wine.get("builder"):
        build = "builder"
    b, d, v = lx[0].get("build"), lx[0].get("distribution"), lx[0].get("validation")
    if b:
        if b in ("auto", "builder", "manuel"):
            build = b
        else:
            print("%s : build=%s inconnu (auto|builder|manuel), %s retenu" % (appli, b, build), file=sys.stderr)
    if d:
        if d in ("free", "redist", "restricted", "unknown"):
            dist = d
        else:
            print("%s : distribution=%s inconnu (free|redist|restricted|unknown), free retenu" % (appli, d), file=sys.stderr)
    if v:
        if v in ("untested", "validated", "failed", "shortcuts"):
            valid = v
        else:
            print("%s : validation=%s inconnu (untested|validated|failed|shortcuts), validated retenu" % (appli, v), file=sys.stderr)
    break
print("%s\t%s\t%s" % (build, dist, valid))
' "$1" "$2"
}

# ajoute un attribut à la balise <linux type="wine" package="<appli>"> de la
# recette, s'il n'y est pas déjà. Édition textuelle (pas ElementTree, qui
# perdrait commentaires et mise en forme) ; usage : xml_set_linux_attr xml appli nom valeur
function xml_set_linux_attr() {
    python3 -c '
import re, sys
from xml.sax.saxutils import quoteattr
path, appli, name, value = sys.argv[1:5]
txt = open(path, encoding="utf-8").read()
# balises <linux> en commentaire ignorées
comments = [c.span() for c in re.finditer(r"<!--.*?-->", txt, re.S)]
for m in re.finditer(r"<linux\b[^>]*?>", txt):
    if any(a <= m.start() < b for a, b in comments):
        continue
    tag = m.group(0)
    if not (re.search(r"\btype=\"wine\"", tag) and re.search(r"\bpackage=\"%s\"" % re.escape(appli), tag)):
        continue
    if re.search(r"\b%s=" % re.escape(name), tag):
        sys.exit(0)
    end = len(tag) - (2 if tag.endswith("/>") else 1)
    new = tag[:end].rstrip() + " %s=%s" % (name, quoteattr(value)) + tag[end:]
    open(path, "w", encoding="utf-8").write(txt[:m.start()] + new + txt[m.end():])
    sys.exit(0)
sys.exit("<linux type=\"wine\" package=\"%s\"> introuvable dans %s" % (appli, path))
' "$1" "$2" "$3" "$4"
}

# licences de l'appli : état machine (HKLM, fichiers de drive_c) capturé par
# wine-licence-capture et réappliqué à chaque montage, jamais dans l'image :
#   <wine ...><licence name="snl" scope="etablissement|poste">
#     <key>Software\Editeur\Licences</key>   (état complet de la clé)
#     <anchor>Software\Classes\CLSID</anchor> (sous-clés ajoutées, modifiées
#                                   ou supprimées pendant la session
#                                   d'activation : ancres à noms aléatoires)
#     <file>ProgramData\FLEXnet\*_tsf.data*</file>
#   </licence></wine>
# Sans <key>, <anchor> ni <file> : toutes les modifications de HKLM.
# écrit sur stdout, séparés par une ligne "--", un descripteur par licence :
# "name=", "scope=", puis "key=", "anchor=" et "file=" (chemins relatifs à
# drive_c, "/" ; jokers admis). Licences invalides ignorées (avertissement
# stderr).
function xml_wine_licences() {
    python3 -c '
import re, sys, xml.etree.ElementTree as ET
path, appli = sys.argv[1], sys.argv[2]
root = ET.parse(path).getroot()

def rel(t):
    t = (t or "").strip().replace("\\", "/").strip("/")
    parts = t.split("/")
    return None if not t or ":" in parts[0] or ".." in parts else t

for pkg in root.iter("package"):
    if not any(l.get("type") == "wine" and l.get("package") == appli for l in pkg.findall("linux")):
        continue
    wine = pkg.find("wine")
    if wine is None:
        break
    for lic in wine.findall("licence"):
        name, scope = lic.get("name", ""), lic.get("scope", "")
        if not re.fullmatch(r"[a-z0-9_-]+", name) or scope not in ("etablissement", "poste"):
            print("<licence> ignorée (name=[a-z0-9_-]+ et scope=etablissement|poste attendus) : %s %s" % (name, scope), file=sys.stderr)
            continue
        lines = ["name=" + name, "scope=" + scope]
        for tag in ("key", "anchor"):
            for k in lic.findall(tag):
                t = rel(k.text)
                if t:
                    lines.append(tag + "=" + t.replace("/", "\\"))
        for f in lic.findall("file"):
            t = rel(f.text)
            if t:
                lines.append("file=" + t)
            else:
                print("<file> ignoré (chemin relatif à C:\\ attendu) : %s" % f.text, file=sys.stderr)
        print("\n".join(lines))
        print("--")
    break
' "$1" "$2"
}

# enregistre dans la recette les lanceurs choisis interactivement (un
# chemin par ligne sur stdin) : <launch> ajoutés au noeud <wine> du
# <package> de l'appli (créé après le <linux type="wine"> si absent).
# Édition textuelle (pas ElementTree, qui perdrait commentaires et mise en
# forme de la recette).
function xml_save_launches() {
    python3 -c '
import sys, re
from xml.sax.saxutils import escape
path, appli = sys.argv[1], sys.argv[2]
launches = [l.rstrip("\n") for l in sys.stdin if l.strip()]
if not launches:
    sys.exit(0)
txt = open(path, encoding="utf-8").read()
lm = None
# <linux .../> ou <linux ...></linux> (les deux formes existent dans le dépôt) ;
# balises en commentaire ignorées
comments = [c.span() for c in re.finditer(r"<!--.*?-->", txt, re.S)]
for m in re.finditer(r"<linux\b[^>]*?(/?)>(?:\s*</linux>)?", txt):
    if any(a <= m.start() < b for a, b in comments):
        continue
    tag = m.group(0)
    if re.search(r"\btype=\"wine\"", tag) and re.search(r"\bpackage=\"%s\"" % re.escape(appli), tag):
        lm = m
        break
if lm is None:
    sys.exit("noeud <linux type=\"wine\" package=\"%s\"> introuvable dans %s" % (appli, path))
end = txt.find("</package>", lm.end())
end = len(txt) if end < 0 else end
ind = re.search(r"([ \t]*)$", txt[:lm.start()]).group(1)
unit = "\t" if ind.startswith("\t") else "  "
lines = "".join("%s%s<launch>%s</launch>\n" % (ind, unit, escape(l)) for l in launches)
wm = re.compile(r"<wine\b([^>]*?)(/?)>").search(txt, lm.end(), end)
if wm and wm.group(2) == "/":
    new = "<wine%s>\n%s%s</wine>" % (wm.group(1).rstrip(), lines, ind)
    txt = txt[:wm.start()] + new + txt[wm.end():]
elif wm:
    close = txt.find("</wine>", wm.end())
    ls = txt.rfind("\n", 0, close) + 1
    txt = txt[:ls] + lines + txt[ls:]
else:
    txt = txt[:lm.end()] + "\n%s<wine>\n%s%s</wine>" % (ind, lines, ind) + txt[lm.end():]
open(path, "w", encoding="utf-8").write(txt)
' "$1" "$2"
}

# chemin Windows lancé par un .desktop winemenubuilder (Exec=env
# WINEPREFIX=... wine <chemin>), utilisateur remplacé par {{USER}}. La
# valeur d'Exec= est une chaîne .desktop ("\" doublés) puis une ligne de
# commande (guillemets, ou espaces échappés "\ " selon la version de
# winemenubuilder) : désechappement .desktop puis découpage façon shell.
function _desktop_launch_path() {
    python3 -c '
import sys, re, shlex
desktop, user = sys.argv[1], sys.argv[2]
ex = ""
for line in open(desktop, encoding="utf-8", errors="replace"):
    if line.startswith("Exec="):
        ex = line[5:].rstrip("\n")
        break
ex = ex.replace("\\\\", "\\")
try:
    toks = shlex.split(ex)
except ValueError:
    sys.exit(0)
if "wine" not in toks:
    sys.exit(0)
rest = [t for t in toks[toks.index("wine") + 1:] if t != "start" and not t.startswith("/")]
if rest:
    print(re.sub(r"(?i)(\\users\\)" + re.escape(user) + r"(?=\\|$)", r"\g<1>{{USER}}", rest[0]))
' "$1" "$USER"
}

# chemin unix (dans le prefix $1) d'un chemin Windows de <launch>, jokers
# non résolus ; Z:\ = racine du système
function _launch_unix_path() {
    local p="${2//\{\{USER\}\}/$USER}"
    p="${p//\\//}"
    case "${p:0:2}" in
    [Zz]:) echo "${p:2}" ;;
    [A-Za-z]:) echo "/var/tmp/$USER/wine/wine-$1/prefix/dosdevices/$(echo "${p:0:2}" | tr '[:upper:]' '[:lower:]')${p:2}" ;;
    *) echo "$p" ;;
    esac
}

# chemin de <launch> écrit entre guillemets doubles bash, {{USER}} -> $USER
function _launch_bash_quoted() {
    local s="$1"
    s="${s//\\/\\\\}"
    s="${s//\"/\\\"}"
    s="${s//\$/\\\$}"
    s="${s//\`/\\\`}"
    s="${s//\{\{USER\}\}/\$USER}"
    printf '"%s"' "$s"
}

# copie un .desktop (lanceur d'application ou association mime) et ses
# icônes dans l'arborescence git du paquet, ajoute les fichiers au .install.
# Factorisé car create_debian_source traite désormais deux familles de
# .desktop (lanceurs, associations mime) avec un traitement mécanique
# identique (copie, réécriture Exec=/icônes, ajout au .install) mais un
# Exec=/Categories= différents selon le cas - $3/$4 portent cette différence,
# calculés par l'appelant.
function _install_desktop_and_icons() {
    local pkg="$1" desktop="$2" exec_line="$3" categories_line="$4"
    local dest="usr/share/applications" fichier icon icone rel idest src

    mkdir -p "$git/$dest"
    fichier="$(basename "${desktop// /_}")"
    cp "$desktop" "$git/$dest/$fichier"

    icon="$(sed -n 's/^Icon=//p' "$desktop")"
    icone="${icon// /_}"
    sed -i "s#Exec=.*#Exec=$exec_line#;/Path=/d;s/${icon}/${icone}/" "$git/$dest/$fichier"
    if [ -n "$categories_line" ]; then
        echo "Categories=$categories_line" >>"$git/$dest/$fichier"
    fi

    echo "$dest/$fichier" >>"$git/debian/wine-$pkg.install"

    find "$HOME/.local/share/icons" -name "${icon}.png" | while read -r src; do
        rel="${src#"$HOME/.local/share/icons/"}"
        idest="usr/share/icons/${rel}"
        mkdir -p "$(dirname "$git/$idest")"
        cp "$src" "$git/${idest// /_}"
        # ajout icones dans le package
        echo "${idest// /_}" >>"$git/debian/wine-$pkg.install"
    done
}

# copie le .desktop et et les icones associées dans l'arborescence git du package
# ajoute les fichier au wine-$1.install
# ajoute la catégorie XDG (lue depuis <linux type="wine" package="$1"
# categories="..."> du dépôt sambaedu-wpkg-xml, ou $3 en override manuel)
# prépare un fichier usr/bin/$1 qui sert de lanceur pour le raccourci
# Si vous voulez pouvoir passer des arguments dans le .desktop,
# il faudra probablement éditer ce lanceur pour lancer directement l'exe et pas le .lnk qui est généralement
# utilisé dans le lanceur généré par wine

# les icones sont dans ./local/share/icons/hicolor/XxX/apps/
# on recherche leur nom à partir du raccourci créé par wine pour l'application
# on les copie toutes dans le git/sambaedu-wpkg-xml/sources/usr/share/icons
# on crée les dossiers si besoin.

# create_debian_source nom_package nom_image [categorie]

function create_debian_source() {
    # repart de zéro à chaque exécution (idempotent : "prepare" doit pouvoir
    # être rejoué pour mettre à jour un paquet existant sans accumuler de
    # doublons si le jeu de .desktop/icônes a changé entre deux versions).
    # sauvegarde : restaurée si rien n'est trouvé (voir fin de fonction)
    local install_bak new_package=0
    # paquet jamais préparé (voir validation, xml_wine_modes) ; en cas
    # d'échec, pas de .install restauré (il serait vide : le paquet
    # passerait ensuite pour déjà préparé)
    [ -f "$git/debian/wine-$1.install" ] || new_package=1
    install_bak="$(mktemp)"
    cp "$git/debian/wine-$1.install" "$install_bak" 2>/dev/null || : >"$install_bak"
    # éléments du résumé affiché en fin de prepare (_prepare_summary)
    local -a sum_launchers=() sum_assoc=() sum_generic=() sum_ignored=() sum_claimed=() sum_foreign=() sum_warn=()
    local sum_xml=""
    : >"$git/debian/wine-$1.install"

    # $3 reste un override manuel possible (rétrocompatibilité) ; par défaut
    # la catégorie est lue dans le xml (voir xml_wine_categories), qui
    # contient déjà le ";" final (convention XDG déjà en place), contrairement
    # à $3 qui n'en a pas.
    local categories="$3"
    if [ -z "$categories" ]; then
        categories="$(xml_wine_categories "$1")"
    elif [[ "$categories" != *\; ]]; then
        categories="$categories;"
    fi

    # install_wpkg désactive winemenubuilder pendant l'installation (pour ne
    # pas polluer le vrai bureau linux, voir install_wpkg) : aucun
    # .desktop/icône n'existe donc encore à ce stade pour cette appli. On
    # régénère ici, ponctuellement et volontairement (winemenubuilder
    # activé), les entrées de menu pour les seuls raccourcis de CE prefix -
    # nécessaire pour que les boucles ci-dessous (grep sur
    # ~/.local/share/applications/) trouvent quelque chose.
    #
    # timeout --kill-after : winemenubuilder peut rester bloqué indéfiniment
    # sur certains .lnk (constaté en réel : un raccourci pointant vers un
    # DOSSIER plutôt qu'un exécutable, ex. "Exemples Regressi.lnk", au lieu
    # d'échouer proprement) - sans limite de temps, un seul raccourci de ce
    # genre bloque ce job pour toujours. Même principe que la boucle de
    # retry d'install_wpkg.
    #
    # winemenubuilder n'exporte les associations de fichiers (.desktop
    # mime, étape 2 plus bas) que si elles sont absentes de
    # HKCU\Software\Wine\FileOpenAssociations, où il note celles déjà
    # exportées : un prepare rejoué sur un prefix déjà préparé (image
    # publiée remontée par create_prefix, user.reg compris, ou prepare
    # précédent dans un autre HOME) n'en retrouvait aucune, les .desktop du
    # précédent export n'étant plus là - constaté en réel sur wine-fusion360
    # (associations de fichiers (0)). On les oublie donc avant, pour
    # qu'elles soient toujours toutes réexportées.
    WINEPREFIX="/var/tmp/$USER/wine/wine-$2/prefix" wine reg delete \
        'HKCU\Software\Wine\FileOpenAssociations' /f >/dev/null 2>&1
    local lnk
    while IFS= read -r lnk; do
        # XDG_CURRENT_DESKTOP : wine >= 11 ne crée plus aucun .desktop sans
        # environnement de bureau détecté ("Skipping .desktop file
        # creation, no XDG-compliant desktop environment detected") - cas
        # d'un prepare lancé par ssh/su ou en CI (constaté en réel sur
        # micro-antec-21 : aucun .desktop régénéré, .install vidé).
        XDG_CURRENT_DESKTOP="${XDG_CURRENT_DESKTOP:-GNOME}" \
            WINEPREFIX="/var/tmp/$USER/wine/wine-$2/prefix" timeout --kill-after=10 60 \
            wine winemenubuilder.exe -w "$lnk" >/dev/null 2>&1
    done < <(find_prefix_shortcuts "$2")

    # raccourcis déjà revendiqués par un AUTRE paquet wine-* du dépôt
    # (sources/debian/wine-<autre>.install) : nécessaire dès qu'un 2e
    # paquet partage le même prefix wine ($2) - find_prefix_shortcuts (plus
    # haut) est scopé prefix, pas appli, donc winemenubuilder régénère aussi
    # les raccourcis des applis sœurs déjà packagées dans CE MÊME prefix
    # partagé, qui apparaîtraient sinon comme candidats pour CE paquet-ci
    # (cas réel visé : ajouter une 2e appli à svt-apps aux côtés de coeur).
    local -a claimed=()
    local install_file d
    for install_file in "$git"/debian/wine-*.install; do
        [ -f "$install_file" ] || continue
        [ "$(basename "$install_file")" = "wine-$1.install" ] && continue
        while IFS= read -r d; do
            claimed+=("$(basename "$d")")
        done < <(grep '^usr/share/applications/.*\.desktop$' "$install_file")
    done

    # étape 1 : lanceurs d'application (.desktop "normaux", ceux que
    # winemenubuilder écrit sous .../applications/wine/Programs/). Un
    # installeur peut en créer plusieurs (suite, sous-composants) : on
    # demande alors lesquels garder, avec la même UX que le sélecteur de
    # raccourcis déjà existant dans run_prefix_app (make-prefix:817-833).
    local -a candidates=() all_launchers=()
    while IFS= read -r desktop; do
        local base is_claimed=0 c
        all_launchers+=("$desktop")
        base="$(basename "$desktop")"
        for c in "${claimed[@]}"; do
            [ "$c" = "$base" ] && is_claimed=1 && break
        done
        [ "$is_claimed" = 1 ] && continue
        candidates+=("$desktop")
    done < <(grep -rl --include="*.desktop" "Exec=env \"WINEPREFIX=/var/tmp/$USER/wine/wine-$2/prefix\"" ~/.local/share/applications/wine/Programs/ 2>/dev/null)

    # prefix partagé : les raccourcis d'une autre appli du prefix dont le
    # prepare a échoué (non revendiqués par un .install) restaient
    # candidats, et chaque appli suivante échouait à son tour (création en
    # lot). Seuls sont gardés ceux dont le raccourci (.lnk, ou l'exe lancé)
    # est plus récent que le début de l'installation de CETTE appli
    # (install_wpkg) ; aucun plus récent (réinstallation sans nouveau
    # raccourci...) : liste inchangée.
    local stamp="/var/tmp/$USER/wine/wine-$2-$1.installstart"
    if [ "${#candidates[@]}" -gt 1 ] && [ -f "$stamp" ]; then
        local -a recent=()
        local cand target
        for cand in "${candidates[@]}"; do
            target="$(_launch_unix_path "$2" "$(_desktop_launch_path "$cand")")"
            [ -n "$target" ] && [ "$target" -nt "$stamp" ] && recent+=("$cand")
        done
        if [ "${#recent[@]}" -gt 0 ] && [ "${#recent[@]}" -lt "${#candidates[@]}" ]; then
            echo "raccourcis créés par l'installation de $1 : ${#recent[@]} sur ${#candidates[@]} candidats du prefix wine-$2"
            candidates=("${recent[@]}")
        fi
    fi

    # lanceurs déclarés dans la recette (<wine><launch>, voir
    # xml_wine_launches) : prioritaires, aucune question posée - prepare
    # rejouable à l'identique, y compris en CI. Sinon, choix interactif
    # parmi les .desktop du prefix, enregistré ensuite dans la recette.
    local xmlsrc
    xmlsrc="$(find_package_xml "$1" 2>/dev/null)" || xmlsrc=""
    local -a launch_path=() launch_name=() launch_icon=() launch_desk=()
    local lp ln li ld
    if [ -n "$xmlsrc" ]; then
        # séparateur \x1f (pas une tabulation : read fusionnerait les
        # champs vides consécutifs, la tabulation étant un blanc d'IFS)
        while IFS=$'\x1f' read -r lp ln li ld; do
            launch_path+=("$lp")
            launch_name+=("$ln")
            launch_icon+=("$li")
            launch_desk+=("$ld")
        done < <(xml_wine_launches "$xmlsrc" "$1")
    fi

    local -a selected=() picked=()
    if [ "${#launch_path[@]}" -gt 0 ]; then
        # rattachement de chaque <launch> à un .desktop du prefix : désigné
        # par desktop="...", sinon celui qui lance le même chemin ; aucun
        # = .desktop généré (lanceur fourni par le paquet, exe direct...)
        local i d2 found
        for i in "${!launch_path[@]}"; do
            found=""
            for d2 in "${all_launchers[@]}"; do
                if [ -n "${launch_desk[$i]}" ]; then
                    [ "$(basename "$d2" .desktop)" = "${launch_desk[$i]}" ] && found="$d2" && break
                elif [ "$(_desktop_launch_path "$d2" | tr '[:upper:]' '[:lower:]')" = "$(printf '%s' "${launch_path[$i]}" | tr '[:upper:]' '[:lower:]')" ]; then
                    found="$d2" && break
                fi
            done
            [ -n "${launch_desk[$i]}" ] && [ -z "$found" ] &&
                sum_warn+=("desktop=\"${launch_desk[$i]}\" introuvable dans le prefix (lanceur ${launch_path[$i]})")
            picked+=("$found")
            [ -n "$found" ] && selected+=("$found")
        done
    else
        if [ "${#candidates[@]}" -le 1 ]; then
            selected=("${candidates[@]}")
        else
            echo "plusieurs .desktop trouvés pour $1 :"
            local i
            for i in "${!candidates[@]}"; do
                echo "  $((i + 1))) $(basename "${candidates[$i]}" .desktop)"
            done
            local reponse idx
            # "read" échoue (EOF avant toute ligne complète) quand aucune entrée
            # n'est fournie du tout (ni tty, ni pipe) - à distinguer d'une ligne
            # VIDE effectivement reçue (tty : Enter direct, ou pipe : echo ''),
            # qui reste "all" comme documenté ci-dessous. Sans cette distinction,
            # un "prepare" lancé sans aucune entrée (job CI non interactif)
            # recevait une réponse vide interprétée à tort comme "all" - constaté
            # en réel sur wine-regressi.install, contaminé par les
            # raccourcis Uninstall/Reset d'une appli sœur (algodoo). On échoue
            # explicitement plutôt que de deviner.
            if ! read -r -p "lesquels conserver (numéros séparés par espace/virgule, vide ou 'all' = tous) ? " reponse; then
                echo "aucune entrée fournie (EOF) - relancez interactivement, déclarez les lanceurs dans la recette (<wine><launch>), ou fournissez une entrée explicite (ex: echo '1' | make-prefix prepare $1 $2)." >&2
                # lignes prêtes à coller dans la recette (repères lus par
                # ci/create-wine-apps.sh de sambaedu-wpkg-xml pour son rapport)
                local c cpath cn
                {
                    echo "--- lignes <launch> proposées pour ${xmlsrc:-la recette de $1} (garder les lanceurs utiles ; si la recette a déjà un <wine>, n'y copier que les <launch>) ---"
                    echo "<wine>"
                    for c in "${candidates[@]}"; do
                        cpath="$(_desktop_launch_path "$c")"
                        [ -n "$cpath" ] || continue
                        cn="$(sed -n 's/^Name=//p' "$c" | head -n1)"
                        cpath="${cpath//&/&amp;}"; cpath="${cpath//</&lt;}"; cpath="${cpath//>/&gt;}"
                        cn="${cn//--/- -}"
                        echo "    <!-- ${cn:-$(basename "$c" .desktop)} -->"
                        echo "    <launch>$cpath</launch>"
                    done
                    echo "</wine>"
                    echo "--- fin des lignes proposées ---"
                } >&2
                # .install vidé en début de fonction : restauré, paquet inchangé
                if [ "$new_package" = 1 ]; then rm -f "$git/debian/wine-$1.install"; else cp "$install_bak" "$git/debian/wine-$1.install"; fi
                rm -f "$install_bak"
                return 1
            fi
            if [ -z "$reponse" ] || [ "$reponse" = "all" ]; then
                selected=("${candidates[@]}")
            else
                for idx in ${reponse//,/ }; do
                    if [[ "$idx" =~ ^[0-9]+$ ]] && [ "$idx" -ge 1 ] && [ "$idx" -le "${#candidates[@]}" ]; then
                        selected+=("${candidates[$((idx - 1))]}")
                    fi
                done
            fi
        fi
        local d2
        for d2 in "${selected[@]}"; do
            lp="$(_desktop_launch_path "$d2")"
            if [ -z "$lp" ]; then
                sum_warn+=("chemin lancé illisible dans $(basename "$d2"), lanceur ignoré")
                continue
            fi
            launch_path+=("$lp")
            launch_name+=("")
            launch_icon+=("")
            launch_desk+=("")
            picked+=("$d2")
        done
        # choix mémorisé dans la recette : les prepare suivants (et la CI)
        # ne reposent plus la question
        if [ -n "$xmlsrc" ] && [ "${#launch_path[@]}" -gt 0 ]; then
            if printf '%s\n' "${launch_path[@]}" | xml_save_launches "$xmlsrc" "$1"; then
                sum_xml="lanceurs enregistrés dans $xmlsrc (<wine><launch>) - à commiter"
            else
                sum_warn+=("lanceurs non enregistrés dans $xmlsrc")
            fi
        fi
    fi
    [ -n "$xmlsrc" ] || sum_warn+=("recette xml de $1 introuvable : lanceurs non mémorisés")

    # un .desktop par lanceur : copie de celui du prefix (Name/Icon/
    # Comment), ou généré ; le N-ième lance "/usr/bin/$1 --launch N" (le
    # 1er, /usr/bin/$1 sans option - auparavant tous les .desktop
    # lançaient le premier lanceur).
    local desktop run="" n execl gen nm ic up wmclass
    for n in "${!launch_path[@]}"; do
        run=1
        execl="/usr/bin/$1"
        [ "$n" -gt 0 ] && execl="/usr/bin/$1 --launch $((n + 1))"
        desktop="${picked[$n]}"
        up="$(_launch_unix_path "$2" "${launch_path[$n]}")"
        # shellcheck disable=SC2086
        (shopt -s nocaseglob; compgen -G "$up" >/dev/null) || [ -e "$up" ] ||
            sum_warn+=("${launch_path[$n]} absent du prefix (fourni par le paquet ?)")
        # classe de fenêtre (StartupWMClass) : wine la nomme d'après l'exe
        # lancé, en minuscules. Seule une cible .exe permet de la déduire
        # (un .lnk ne dit pas quel exe il lance).
        wmclass=""
        case "${launch_path[$n],,}" in
        *.exe) wmclass="$(basename "${launch_path[$n]//\\//}")"; wmclass="${wmclass,,}" ;;
        esac
        # joker dans le nom de l'exe : nom réel pris dans le prefix
        # (correspondance la plus récente, comme au lancement), sinon inconnu
        case "$wmclass" in
        *[*?[]*)
            wmclass="$(shopt -s nocaseglob; compgen -G "$(_launch_unix_path "$2" "${launch_path[$n]}")" | while IFS= read -r x; do printf '%s\t%s\n' "$(stat -c %Y "$x")" "$x"; done | sort -rn | head -n1 | cut -f2-)"
            wmclass="$(basename "$wmclass" 2>/dev/null)"
            wmclass="${wmclass,,}"
            ;;
        esac
        if [ -n "$desktop" ]; then
            _install_desktop_and_icons "$1" "$desktop" "$execl" "$categories"
            local gd="$git/usr/share/applications/$(basename "${desktop// /_}")"
            [ -n "${launch_name[$n]}" ] && sed -i "s/^Name=.*/Name=${launch_name[$n]//\//\\/}/" "$gd"
            # <launch> différent de la cible du .desktop repris (desktop=,
            # ex. Fusion360.exe lancé au lieu de FusionLauncher.exe) : son
            # StartupWMClass (fusionlauncher.exe) ne correspondrait pas à la
            # fenêtre, que le bureau ne rattacherait plus à son icône.
            if [ -n "$wmclass" ] && [ "$(_desktop_launch_path "$desktop" | tr '[:upper:]' '[:lower:]')" != "${launch_path[$n],,}" ]; then
                sed -i '/^StartupWMClass=/d' "$gd"
                echo "StartupWMClass=$wmclass" >>"$gd"
            fi
            sum_launchers+=("$(sed -n 's/^Name=//p' "$git/usr/share/applications/$(basename "${desktop// /_}")" | head -n1)  ->  ${launch_path[$n]}")
        else
            nm="${launch_name[$n]}"
            if [ -z "$nm" ]; then
                nm="$(basename "${launch_path[$n]//\\//}")"
                nm="${nm%.*}"
            fi
            ic="${launch_icon[$n]:-wine}"
            gen="wine-$1"
            [ "$n" -gt 0 ] && gen="wine-$1-$((n + 1))"
            mkdir -p "$git/usr/share/applications"
            printf '%s\n' "[Desktop Entry]" "Type=Application" "Name=$nm" "Exec=$execl" "Icon=$ic" "StartupNotify=true" "Categories=$categories" \
                >"$git/usr/share/applications/$gen.desktop"
            [ -n "$wmclass" ] && echo "StartupWMClass=$wmclass" >>"$git/usr/share/applications/$gen.desktop"
            echo "usr/share/applications/$gen.desktop" >>"$git/debian/wine-$1.install"
            # icône extraite par winemenubuilder (icon="<nom>") : copiée
            find "$HOME/.local/share/icons" -name "${ic}.png" 2>/dev/null | while read -r src; do
                rel="usr/share/icons/${src#"$HOME/.local/share/icons/"}"
                mkdir -p "$(dirname "$git/$rel")"
                cp "$src" "$git/$rel"
                echo "$rel" >>"$git/debian/wine-$1.install"
            done
            sum_launchers+=("$nm (généré)  ->  ${launch_path[$n]}")
        fi
    done

    # étape 2 : .desktop d'association mime (enregistrement par l'installeur
    # d'un gestionnaire de type de fichier, distinct des lanceurs
    # d'application ci-dessus). winemenubuilder ne les écrit pas forcément au
    # même endroit que les lanceurs (confirmé en réel sur "coeur" : à plat
    # sous ~/.local/share/applications/, pas sous .../wine/Programs/) :
    # détection par contenu (WINEPREFIX + MimeType=). Un prefix possède
    # aussi des associations génériques Wine/Windows (.reg/.vbs/.chm/...
    # vers regedit/wscript/hh/rundll32..., Name=rundll32/wscript/"A Wine
    # application" - rien à voir avec l'appli), avec le même WINEPREFIX :
    # elles sont écartées d'après la commande d'ouverture de leur ProgID
    # dans le registre du prefix (voir _progid_is_generic). Auparavant un
    # filtre par date (fichiers plus récents qu'un marqueur posé avant
    # winemenubuilder) : faux dès que les .desktop d'association existaient
    # déjà (winemenubuilder -w <lnk> ne les régénère pas) - constaté en réel
    # sur micro-antec-21, aucune association solidworks retenue.
    # Dédoublonnage supplémentaire avec les lanceurs déjà traités ci-dessus
    # (un lanceur peut en théorie aussi déclarer MimeType= sur lui-même).
    # lanceurs du prefix non retenus pour CE paquet (autres applis du
    # prefix, ou applis sœurs déjà packagées) : leurs associations ne sont
    # pas reprises ici (voir _assoc_is_foreign).
    local already d has_mime=0
    local -a others=()
    for d in "${all_launchers[@]}"; do
        already=0
        for desktop in "${selected[@]}"; do
            [ "$d" = "$desktop" ] && already=1 && break
        done
        [ "$already" = 0 ] && others+=("$d")
    done

    local -a mime_candidates=()
    while IFS= read -r d; do
        mime_candidates+=("$d")
    done < <(find ~/.local/share/applications -name "*.desktop" 2>/dev/null \
        | xargs -r -d '\n' grep -l "WINEPREFIX=/var/tmp/$USER/wine/wine-$2/prefix" 2>/dev/null \
        | xargs -r -d '\n' grep -l '^MimeType=' 2>/dev/null)

    for d in "${mime_candidates[@]}"; do
        already=0
        for desktop in "${selected[@]}"; do
            [ "$d" = "$desktop" ] && already=1 && break
        done
        [ "$already" = 1 ] && continue
        # même exclusion que pour les lanceurs (étape 1) : une association
        # mime déjà revendiquée par une appli sœur du même prefix partagé ne
        # doit pas être reprise ici non plus.
        base="$(basename "$d")"
        for c in "${claimed[@]}"; do
            [ "$c" = "$base" ] && already=1 && break
        done
        if [ "$already" = 1 ]; then
            sum_claimed+=("$(_mime_exts "$d")")
            continue
        fi
        # winemenubuilder écrit pour une association :
        #   Exec=env "WINEPREFIX=/var/tmp/<user>/wine/..." wine start /ProgIDOpen "<ProgID>" %f
        # le WINEPREFIX contient le nom de l'utilisateur ayant préparé le
        # paquet, inutilisable tel quel dans /usr/share/applications : on ne
        # garde que le ProgID, passé en 1er argument au lanceur /usr/bin/$1
        # qui reconstruit la commande avec $USER (voir plus bas). Le ProgID
        # est conservé avec ses guillemets éventuels (syntaxe Exec= valide).
        local progid
        progid="$(sed -n 's#^Exec=.*/ProgIDOpen \("[^"]*"\|[^ ]*\).*#\1#p' "$d")"
        if [ -z "$progid" ]; then
            sum_ignored+=("$(basename "$d")")
            continue
        fi
        if _progid_is_generic "$2" "${progid//\"/}"; then
            sum_generic+=("$(_mime_exts "$d") ($(sed -n 's/^Name=//p' "$d" | head -n1))")
            continue
        fi
        if _assoc_is_foreign "$2" "$d" "${progid//\"/}"; then
            sum_foreign+=("$(_mime_exts "$d") ($(sed -n 's/^Name=//p' "$d" | head -n1))")
            continue
        fi
        _install_desktop_and_icons "$1" "$d" "/usr/bin/$1 --progid $progid %f" ""
        # le type MIME (application/x-wine-extension-<ext>) est inventé par
        # winemenubuilder, défini uniquement dans le home de l'utilisateur
        # ayant préparé le paquet (~/.local/share/mime/packages/) : sans sa
        # définition dans le paquet, aucun fichier n'a ce type sur un poste
        # et l'association ne sert à rien. Base MIME mise à jour par le
        # trigger dpkg de shared-mime-info (/usr/share/mime/packages).
        local mt
        for mt in $(sed -n 's/^MimeType=//p' "$d" | tr ';' ' '); do
            if [ -f "$HOME/.local/share/mime/packages/${mt#*/}.xml" ]; then
                mkdir -p "$git/usr/share/mime/packages"
                cp "$HOME/.local/share/mime/packages/${mt#*/}.xml" "$git/usr/share/mime/packages/"
                echo "usr/share/mime/packages/${mt#*/}.xml" >>"$git/debian/wine-$1.install"
            fi
        done
        has_mime=1
        sum_assoc+=("$(printf '%-12s %-28s %s' "$(_mime_exts "$d")" "${progid//\"/}" "$(sed -n 's/^Name=//p' "$d" | head -n1)")")
    done

    # lanceur /usr/bin/$1, commun aux lanceurs d'application (lance le .lnk
    # d'origine, avec les arguments éventuels) et aux associations mime
    # (Exec=/usr/bin/$1 --progid <ProgID> %f : relaie à "wine start
    # /ProgIDOpen", comme le .desktop d'origine de winemenubuilder, mais
    # avec le WINEPREFIX de l'utilisateur courant). Marqueur --progid
    # explicite : la seule présence d'arguments ne suffit pas, un raccourci
    # se4 peut en passer à l'application (ex: pronote -Adresse ... -PortTcp
    # ..., pris auparavant pour un ProgID : rien ne se lançait). Écrit aussi quand l'appli ne
    # déclare que des associations (pas de lanceur retenu) : sans lui, les
    # .desktop mime pointeraient vers un /usr/bin/$1 inexistant.
    # wine_scripts ((pre|post).d/<appli>, voir wine.inc.sh) est appelé
    # inconditionnellement : exec_script ne fait rien si aucun script
    # n'existe pour $1 (juste un test -f), donc pas besoin de le
    # commenter par défaut. Le paquet dépend déjà de
    # sambaedu-linux-stations-wine (voir plus bas), qui fournit
    # wine.inc.sh - d'où le "source" explicite ici, l'include n'étant
    # pas sourcé globalement par ailleurs.
    # rien trouvé (ni lanceur ni association) : on n'écrase pas le paquet
    # existant par un paquet vide - échec explicite, .install restauré.
    if [ -z "$run" ] && [ "$has_mime" != 1 ]; then
        if [ "$new_package" = 1 ]; then rm -f "$git/debian/wine-$1.install"; else cp "$install_bak" "$git/debian/wine-$1.install"; fi
        rm -f "$install_bak"
        echo "aucun lanceur ni association trouvé pour $1 dans le prefix wine-$2 (winemenubuilder n'a créé aucun .desktop ?) : paquet inchangé." >&2
        return 1
    fi
    rm -f "$install_bak"

    # fichiers propres à l'appli, maintenus à la main et non générés ici
    # (builder, scripts (pre|post).d, handlers d'url...) : le .install étant
    # recréé à chaque prepare, ils sont déclarés dans un .install.extra
    # statique, ajouté tel quel.
    if [ -f "$git/debian/wine-$1.install.extra" ]; then
        grep -vE '^[[:space:]]*(#|$)' "$git/debian/wine-$1.install.extra" >>"$git/debian/wine-$1.install"
    fi

    # fichiers conservés d'une session à l'autre (<wine><persist> de la
    # recette, voir xml_wine_persists et persist_restore/persist_save dans
    # wine.inc.sh) : une liste par appli dans le répertoire de l'image, les
    # postes prenant l'union des listes d'un prefix partagé.
    local persist_file="usr/share/sambaedu/wine/persist/$2/$1" persists=""
    rm -f "$git/$persist_file"
    [ -n "$xmlsrc" ] && persists="$(xml_wine_persists "$xmlsrc" "$1")"
    if [ -n "$persists" ]; then
        mkdir -p "$(dirname "$git/$persist_file")"
        {
            echo "# généré par make-prefix prepare depuis <wine><persist> de la recette"
            echo "$persists"
        } >"$git/$persist_file"
        echo "$persist_file" >>"$git/debian/wine-$1.install"
        echo "fichiers persistants (profil wine) :"
        sed 's/^/  /' <<<"$persists"
    fi

    # licences (<wine><licence> de la recette, voir xml_wine_licences) :
    # un descripteur <appli>.<nom> par licence, lu par wine-licence-capture
    local licdir="usr/share/sambaedu/wine/licence/$2" licences="" name
    rm -f "$git/$licdir/$1".*
    [ -n "$xmlsrc" ] && licences="$(xml_wine_licences "$xmlsrc" "$1")"
    if [ -n "$licences" ]; then
        mkdir -p "$git/$licdir"
        echo "licences (capture : sudo wine-licence-capture $1 <nom>) :"
        # noms validés par xml_wine_licences ([a-z0-9_-]+) : boucle sûre
        for name in $(sed -n 's/^name=//p' <<<"$licences"); do
            {
                echo "# généré par make-prefix prepare depuis <wine><licence> de la recette"
                awk -v n="name=$name" '$0 == n { b = 1; next } $0 == "--" { b = 0 } b' <<<"$licences"
            } >"$git/$licdir/$1.$name"
            echo "$licdir/$1.$name" >>"$git/debian/wine-$1.install"
            echo "  $name ($(sed -n 's/^scope=//p' "$git/$licdir/$1.$name"))"
        done
    fi

    if [ -n "$run" ] || [ "$has_mime" = 1 ]; then
        {
            echo "#!/bin/bash
# lanceur pour $1
# [arguments] : lance l'application (arguments transmis)
# --launch <N> [arguments] : lance le N-ième lanceur (<wine><launch> de la recette)
# --progid <ProgID> [fichier] : ouverture via l'association de fichier (.desktop mime)
. /usr/share/sambaedu/includes/wine.inc.sh
# disponible pour les scripts pre.d/$1 (wine reg ...)
export WINEPREFIX=\"/var/tmp/\$USER/wine/wine-$2/prefix\" PREFIX=\"/var/tmp/\$USER/wine/wine-$2/prefix\"
launches=("
            for lp in "${launch_path[@]}"; do
                echo "    $(_launch_bash_quoted "$lp")"
            done
            echo ")
# chemin à passer à wine : tel quel, ou, s'il contient des jokers, la
# correspondance la plus récente dans le prefix (chemin unix)
launch_target() {
    local p=\"\$1\" u f d
    case \"\$p\" in
    *[*?[]*) ;;
    *) printf '%s' \"\$p\"; return ;;
    esac
    u=\"\${p//\\\\//}\"
    case \"\${u:0:2}\" in
    [Zz]:) u=\"\${u:2}\" ;;
    [A-Za-z]:) d=\"\${u:0:1}\"; u=\"\$WINEPREFIX/dosdevices/\${d,,}:\${u:2}\" ;;
    esac
    # chemins Windows insensibles à la casse
    shopt -s nocaseglob
    f=\"\$(compgen -G \"\$u\" | while IFS= read -r x; do printf '%s\\t%s\\n' \"\$(stat -c %Y \"\$x\")\" \"\$x\"; done | sort -rn | head -n1 | cut -f2-)\"
    printf '%s' \"\$f\"
}
# arguments ajoutés par les scripts pre.d/$1 au lancement de l'application
# (APP_ARGS+=(-opt valeur) : les scripts sont sourcés dans une fonction,
# un set -- n'atteindrait pas les arguments du lanceur)
APP_ARGS=()
wine_scripts pre $1 || true
if [ \"\${1:-}\" = --progid ]; then
    shift
    wine start /ProgIDOpen \"\$@\""
            # sans argument : lancement de l'application (.lnk d'origine) ;
            # si l'appli ne déclare que des associations (aucun lanceur
            # retenu), il n'y a rien à lancer - message explicite plutôt
            # qu'un wrapper qui ne fait silencieusement rien.
            if [ -n "$run" ]; then
                echo "else
    n=1
    if [ \"\${1:-}\" = --launch ]; then
        n=\"\${2:-1}\"
        shift 2
    fi
    target=\"\$(launch_target \"\${launches[\$((n - 1))]}\")\"
    if [ -z \"\$target\" ]; then
        echo \"\$0 : lanceur \$n introuvable (\${launches[\$((n - 1))]})\" >&2
        exit 1
    fi
    wine \"\$target\" \"\${APP_ARGS[@]}\" \"\$@\""
            else
                echo "else
    echo \"usage : \$0 --progid <ProgID> [fichier] (pas de lanceur d'application pour $1)\" >&2
    exit 1"
            fi
            # pas d'attente de fin de l'appli : wineserver -w attendait tous
            # les process du prefix, services résidents compris (FlexNet,
            # EdgeUpdate... : jamais terminés, constaté sur solidworks), et
            # la fin d'une appli n'est pas mesurable de façon fiable (lanceur
            # intermédiaire, prefix partagé). Les scripts post.d/<appli> sont
            # exécutés au démontage de l'image (clean_prefix.sh), tout
            # arrêté, avant la sauvegarde du registre et des fichiers.
            echo "fi"
        } >"$git/usr/bin/$1"
        chmod 755 "$git/usr/bin/$1"
        echo "usr/bin/$1" >>"$git/debian/wine-$1.install"
        # applis de l'image : clean_prefix.sh exécute leurs post.d au démontage
        mkdir -p "$git/usr/share/sambaedu/wine/apps/$2"
        echo "# généré par make-prefix prepare : appli $1 de l'image wine-$2" >"$git/usr/share/sambaedu/wine/apps/$2/$1"
        echo "usr/share/sambaedu/wine/apps/$2/$1" >>"$git/debian/wine-$1.install"
        cp "$git/debian/wine-appli.postinst.ex" "$git/debian/wine-$1.postinst"
        sed -i "s/{{appli}}/$1/g" "$git/debian/wine-$1.postinst"
        sed -i "s/{{prefix}}/wine-$2/g" "$git/debian/wine-$1.postinst"
    fi

    # ajout/mise à jour du bloc dans debian/control : on retire d'abord
    # l'éventuel bloc déjà présent pour ce paquet avant d'en écrire un
    # nouveau, plutôt qu'un simple grep -q de non-présence - sinon un
    # deuxième "prepare" avec un $2 (prefix) différent du premier (ex :
    # passage d'un prefix dédié à un prefix partagé, cas réel rencontré en
    # préparant "coeur") laisse une Description obsolète, la balise
    # Depends/Description n'étant alors jamais régénérée.
    # Le bloc est réécrit à sa place (pas de diff parasite par
    # déplacement en fin de fichier), en conservant les champs de relation
    # ajoutés à la main (Provides/Conflicts/Replaces/Breaks/Recommends/
    # Suggests, ex: reprise de l'ancien paquet sambaedu-solidworks) -
    # auparavant perdus à chaque prepare.
    # mode de génération et statut de diffusion (xml_wine_modes) : champs
    # XB- recopiés dans le .deb, exploitables par la suite (accès aux
    # images "restricted"...)
    local block build_mode="auto" distribution="free" validation="validated"
    if [ -n "$xmlsrc" ]; then
        # tout premier prepare de ce paquet : appli pas encore validée en
        # production (smoke-test seulement), marquée dans la recette
        if [ "$new_package" = 1 ] && ! grep -q 'validation="' "$xmlsrc"; then
            xml_set_linux_attr "$xmlsrc" "$1" validation untested &&
                echo "recette : validation=\"untested\" ajouté (à passer à \"validated\" après essai en production)"
        fi
        IFS=$'\t' read -r build_mode distribution validation < <(xml_wine_modes "$xmlsrc" "$1")
    fi
    block="$(printf '%s\n' \
        "Package: wine-$1" \
        "Architecture: all" \
        "Depends: \${misc:Depends}, sambaedu-linux-stations-wine" \
        "XB-Sambaedu-Build: $build_mode" \
        "XB-Sambaedu-Distribution: $distribution" \
        "XB-Sambaedu-Validation: $validation")"
    awk -v pkg="Package: wine-$1" -v head="$block" \
        -v d1="Description: Package $1 pour l'image wine-$2." \
        -v d2=" Déploie sur le serveur se4fs l'image squashfs wine-$2, et ajoute les raccourcis et menus nécessaires." '
        function flush() { print head; if (keep != "") printf "%s", keep; print d1; print d2; done = 1 }
        $0 == pkg { inblk = 1; keep = ""; next }
        inblk && $0 == "" { flush(); inblk = 0; print; next }
        inblk { if ($0 ~ /^(Provides|Conflicts|Replaces|Breaks|Recommends|Suggests):/) keep = keep $0 "\n"; next }
        { print }
        END {
            if (inblk) flush()
            else if (!done) { print ""; flush() }
        }
    ' "$git/debian/control" >"$git/debian/control.tmp" && mv "$git/debian/control.tmp" "$git/debian/control"

    _prepare_summary "$1" "$2"
}

# extensions (.sldprt...) déclarées par un .desktop d'association wine
# (MimeType=application/x-wine-extension-<ext>;...), ou le type MIME tel
# quel s'il est standard (text/vbscript...)
function _mime_exts() {
    sed -n 's/^MimeType=//p' "$1" | tr ';' '\n' | sed '/^$/d;s#^application/x-wine-extension-#.#' | paste -sd' ' -
}

# résumé de create_debian_source (variables sum_* de l'appelant)
function _prepare_summary() {
    local x rel
    echo
    echo "=== résumé prepare wine-$1 (prefix wine-$2) ==="
    echo "lanceurs (${#sum_launchers[@]}) :"
    for x in "${sum_launchers[@]}"; do echo "  $x"; done
    [ "${#sum_launchers[@]}" = 0 ] && echo "  (aucun : lanceur /usr/bin/$1 utilisable seulement pour les associations)"
    echo "associations de fichiers (${#sum_assoc[@]}) :"
    [ "${#sum_assoc[@]}" -gt 0 ] && printf '  %s\n' "${sum_assoc[@]}" | sort
    if [ "${#sum_generic[@]}" -gt 0 ]; then
        echo "associations génériques Wine écartées (${#sum_generic[@]}) :"
        for x in "${sum_generic[@]}"; do echo "  $x"; done
    fi
    if [ "${#sum_foreign[@]}" -gt 0 ]; then
        echo "associations d'une autre appli du prefix écartées (${#sum_foreign[@]}) :"
        for x in "${sum_foreign[@]}"; do echo "  $x"; done
    fi
    if [ "${#sum_claimed[@]}" -gt 0 ]; then
        echo "associations déjà dans un autre paquet du prefix (${#sum_claimed[@]}) : ${sum_claimed[*]}"
    fi
    if [ "${#sum_ignored[@]}" -gt 0 ]; then
        echo "ignorés (pas de /ProgIDOpen dans Exec=) : ${sum_ignored[*]}"
    fi
    [ -n "$sum_xml" ] && echo "$sum_xml"
    if [ "${#sum_warn[@]}" -gt 0 ]; then
        echo "attention :"
        for x in "${sum_warn[@]}"; do echo "  $x"; done
    fi
    echo "lanceur : usr/bin/$1"
    rel="$(awk -v pkg="Package: wine-$1" '$0 == pkg { b = 1; next } b && $0 == "" { exit } b && /^(Provides|Conflicts|Replaces|Breaks|Recommends|Suggests):/ { print "  " $0 }' "$git/debian/control")"
    echo "debian/control : bloc wine-$1 à jour${rel:+, relations conservées :}"
    [ -n "$rel" ] && echo "$rel"
    echo "fichiers : $(grep -c . "$git/debian/wine-$1.install") dans debian/wine-$1.install - à vérifier avec : git -C \"$git\" status/diff"
}

# compile l'image squashfs à partir de l'image montée par l'utilisateur
# make_image prefix
# Maintenance sur site d'une image avec ses licences (poste de construction
# marqué aussi /etc/sambaedu/wine-builder-licences : licences appliquées au
# montage, voir prepare_prefix.sh). Avant mksquashfs, sur tout le périmètre
# des licences de l'image - <key>/<file> des recettes, plus clés et fichiers
# effectivement posés par les licences appliquées - l'état de l'image
# d'origine (couche lower) est rétabli : aucune licence ne part dans l'image,
# y compris un élément ajouté pendant la maintenance (réactivation...). Ce
# qui a changé dans ce périmètre pendant la session (registre depuis
# system.reg.orig, fichiers différents de ceux des licences) est d'abord
# copié dans une trace datée, hors image, pour analyse :
#   /var/tmp/$USER/wine/licence-trace/wine-<image>/<date>/
# Hors de ce périmètre, les réglages de la maintenance sont gardés.
# Exception : le périmètre déclaré par les recettes (<key>/<file>) est
# retiré de l'image, même s'il était dans l'image d'origine (licence
# activée dans une image publiée avant la déclaration de <licence>).
# Aussi appelée sans licence appliquée, dès qu'une recette du prefix
# déclare des licences et que l'image d'origine est montée.
# Affiche le dossier de travail (état de la session, remis par
# licence_unstrip après mksquashfs).
function licence_strip() {
    local img="$1" pfx="$PREFIX" lower="/var/tmp/$USER/wine/wine-$1/lower"
    local stage trace d f rel n_reg n_files
    if ! mountpoint -q "$lower"; then
        echo "licences appliquées mais image d'origine non montée ($lower) : impossible de les retirer, image non construite" >&2
        return 1
    fi
    stage="$(mktemp -d "/var/tmp/$USER/wine/.licence-strip-$img.XXXXXX")" || return 1
    trace="/var/tmp/$USER/wine/licence-trace/wine-$img/$(date +%Y%m%d-%H%M%S)"

    # périmètre : clés (une par ligne, format --keys de wine_userreg.py) et
    # fichiers (relatifs à drive_c, jokers admis)
    : >"$stage/keys"
    : >"$stage/files.list"
    : >"$stage/declared.keys"
    : >"$stage/declared.files"
    while IFS= read -r d; do
        sed -n 's/^key=//p' "$d" >>"$stage/declared.keys"
        sed -n 's/^file=//p' "$d" >>"$stage/declared.files"
    done < <(licence_descriptors "$img")
    cat "$stage/declared.keys" >>"$stage/keys"
    cat "$stage/declared.files" >>"$stage/files.list"
    while IFS= read -r d; do
        [ -s "$d/system.reg.diff" ] &&
            sed -n 's/^\[-\{0,1\}\([^]]*\)\].*/\1/p' "$d/system.reg.diff" >>"$stage/keys"
        [ -d "$d/files" ] && (cd "$d/files" && find . -type f -printf '%P\n') >>"$stage/files.list"
    done < <(licence_dirs "$img")
    sort -u -o "$stage/keys" "$stage/keys"
    sort -u -o "$stage/files.list" "$stage/files.list"

    mkdir -p "$trace"
    # registre : trace des changements de la session dans le périmètre, puis
    # retour à l'état d'origine (system.reg de l'image, noms réels)
    if [ -f "$pfx/system.reg.orig" ]; then
        python3 "$WINE_USERREG" diff "$pfx/system.reg.orig" "$pfx/system.reg" "$trace/system.reg.diff" \
            "$(hostname)" --keys "$stage/keys" >/dev/null || true
    fi
    sed "s/{{USER}}/$USER/g;s/{{HOSTNAME}}/$(hostname)/g" "$lower/system.reg" >"$stage/pre.reg"
    # clés déclarées par les recettes : absentes de l'image, même si l'image
    # d'origine les contenait
    if [ -s "$stage/declared.keys" ]; then
        {
            echo "SAMBAEDU USERREG DIFF 1"
            sed 's/\\/\\\\/g;s/^/[-/;s/$/]/' "$stage/declared.keys"
        } >"$stage/declared.diff"
        python3 "$WINE_USERREG" apply "$stage/declared.diff" "$stage/pre.reg" || {
            rm -rf "$stage"
            echo "retrait des clés de licence déclarées impossible : image non construite" >&2
            return 1
        }
    fi
    cp -p "$pfx/system.reg" "$stage/system.reg"
    if ! python3 "$WINE_USERREG" diff "$pfx/system.reg" "$stage/pre.reg" "$stage/revert.diff" --keys "$stage/keys" >/dev/null ||
        ! python3 "$WINE_USERREG" apply "$stage/revert.diff" "$pfx/system.reg"; then
        cp -p "$stage/system.reg" "$pfx/system.reg"
        rm -rf "$stage"
        echo "retrait des licences du registre impossible : image non construite" >&2
        return 1
    fi

    # fichiers : trace de ceux qui diffèrent de la licence appliquée (ou
    # n'en viennent pas), puis version de l'image d'origine (ou absence)
    mkdir -p "$stage/files"
    : >"$stage/present.list"
    while IFS= read -r rel; do
        [ -n "$rel" ] || continue
        (
            cd "$pfx/drive_c" || exit 0
            shopt -s nullglob
            # chemins avec espaces (Program Files) : découpage aux seuls retours
            # à la ligne, les jokers restent déroulés
            IFS=$'\n'
            # jokers de la recette : glob volontairement non quoté
            # shellcheck disable=SC2086
            for f in $rel; do
                [ -f "$f" ] && echo "$f"
            done
        ) >>"$stage/present.list"
    done <"$stage/files.list"
    sort -u -o "$stage/present.list" "$stage/present.list"
    # fichiers déclarés par les recettes : absents de l'image
    : >"$stage/declared.present"
    while IFS= read -r rel; do
        [ -n "$rel" ] || continue
        (
            cd "$pfx/drive_c" || exit 0
            shopt -s nullglob
            # chemins avec espaces (Program Files) : découpage aux seuls retours
            # à la ligne, les jokers restent déroulés
            IFS=$'\n'
            # shellcheck disable=SC2086
            for f in $rel; do
                [ -f "$f" ] && echo "$f"
            done
        ) >>"$stage/declared.present"
    done <"$stage/declared.files"
    while IFS= read -r f; do
        [ -n "$f" ] || continue
        local same=0
        while IFS= read -r d; do
            [ -f "$d/files/$f" ] && cmp -s "$d/files/$f" "$pfx/drive_c/$f" && same=1
        done < <(licence_dirs "$img")
        if [ "$same" = 0 ] && ! { [ -f "$lower/drive_c/$f" ] && cmp -s "$lower/drive_c/$f" "$pfx/drive_c/$f"; }; then
            mkdir -p "$trace/files/$(dirname "$f")" && cp -p "$pfx/drive_c/$f" "$trace/files/$f"
        fi
        mkdir -p "$stage/files/$(dirname "$f")" && cp -p "$pfx/drive_c/$f" "$stage/files/$f"
        if [ -f "$lower/drive_c/$f" ] && ! grep -qxF -- "$f" "$stage/declared.present"; then
            cp --preserve=mode,timestamps "$lower/drive_c/$f" "$pfx/drive_c/$f"
        else
            rm -f "$pfx/drive_c/$f"
        fi
    done <"$stage/present.list"

    n_reg=$(($(wc -l <"$trace/system.reg.diff" 2>/dev/null || echo 1) - 1))
    [ "$n_reg" -gt 0 ] || rm -f "$trace/system.reg.diff"
    n_files=$(find "$trace/files" -type f 2>/dev/null | wc -l)
    if [ "$n_reg" -gt 0 ] || [ "$n_files" -gt 0 ]; then
        {
            echo "wine-$img : changements de la session dans le périmètre des licences, retirés de l'image publiée ($(date))"
            echo "clés du périmètre :"
            sed 's/^/  /' "$stage/keys"
            echo "fichiers du périmètre :"
            sed 's/^/  /' "$stage/files.list"
        } >"$trace/README"
        echo "licences : changements de la session dans leur périmètre ($n_reg ligne(s) de registre, $n_files fichier(s)), retirés de l'image, trace : $trace" >&2
        echo "  (nouvelle activation de licence ? la capturer avec wine-licence-capture avant de fermer la session)" >&2
    else
        rmdir "$trace/files" "$trace" 2>/dev/null
        echo "licences retirées de l'image (aucun changement de la session dans leur périmètre)" >&2
    fi
    echo "$stage"
}

# descripteurs de licence des applis du prefix $1 (<wine><licence> des
# recettes, générés par prepare) : paquets installés, et sources git (paquet
# pas encore installé sur le poste de construction) - un par nom
function licence_descriptors() {
    local d seen=" "
    for d in "$git/usr/share/sambaedu/wine/licence/$1"/* /usr/share/sambaedu/wine/licence/"$1"/*; do
        [ -f "$d" ] || continue
        [[ "$seen" == *" $(basename "$d") "* ]] && continue
        seen+="$(basename "$d") "
        echo "$d"
    done
}

# remet l'état de la session (licences comprises) après mksquashfs
function licence_unstrip() {
    local stage="$1"
    [ -d "$stage" ] || return 0
    cp -p "$stage/system.reg" "$PREFIX/system.reg"
    [ -d "$stage/files" ] && cp -rp "$stage/files/." "$PREFIX/drive_c/"
    rm -rf "$stage"
}

function make_image() {
    PREFIX="/var/tmp/$USER/wine/wine-$1/prefix"
    # prefix absent ou vide : jamais d'image (auparavant mkdir -p puis
    # construction d'une image vide, arrêtée par chance par le contrôle de
    # .update-timestamp - constaté après un redémarrage du runner, montage
    # de l'image publiée perdu entre auto_update_wine_apps et la publication)
    if [ ! -f "$PREFIX/system.reg" ]; then
        echo "prefix wine-$1 absent ou non monté ($PREFIX) : image non construite (redémarrage depuis la mise à jour ? relancer make-prefix new $1 puis install_wpkg)" >&2
        return 1
    fi

    # version de wine de l'image (voir wine.inc.sh, wine_select_image) :
    # celle du paquet qui fournit le wine.inf du wine utilisé. Le prefix
    # doit être à jour pour ce wine (.update-timestamp = mtime de wine.inf,
    # ce que wine vérifie) : sinon l'image porterait une version qu'elle
    # n'a pas - passer d'abord par "make-prefix upgrade".
    . /usr/share/sambaedu/includes/wine.inc.sh
    # wineserver n'écrit user.reg/system.reg qu'à sa fin : réglages faits
    # dans la session (poste de construction) perdus sinon
    wine_stop_prefix
    local winever inf stamp
    winever="$(wine_installed_version)"
    inf="$(wine_inf)"
    if [ -z "$winever" ] || [ -z "$inf" ]; then
        echo "version de wine introuvable (paquet fournissant wine.inf) : image non construite" >&2
        return 1
    fi
    stamp="$(wine_prefix_stamp "$PREFIX")"
    if [ "$stamp" != "$(stat -c %Y "$inf")" ]; then
        echo "prefix wine-$1 pas à jour pour wine $winever (.update-timestamp : ${stamp:-absent}) : lancez make-prefix upgrade $1" >&2
        return 1
    fi
    # image construite depuis un prefix monté (poste de production, image
    # publiée remontée) : le montage y a appliqué licences, registre et
    # fichiers persistants de l'utilisateur (prepare_prefix.sh), sauf sur un
    # poste de construction (/etc/sambaedu/wine-builder, voir
    # wine_is_builder). Des licences (établissement ou poste) finiraient
    # dans l'image publiée, commune à tous les établissements : refus.
    local lic
    lic="$(compgen -G "/opt/install/wine/licences/$1/*"; compgen -G "/opt/local/wine/licences-etablissement/$1/*"; compgen -G "/opt/local/wine/licences/$1/*")"
    if [ -n "$lic" ] && ! wine_is_builder; then
        echo "licences présentes pour wine-$1 sur ce poste, appliquées au montage : elles iraient dans l'image publiée :" >&2
        sed 's/^/  /' <<<"$lic" >&2
        echo "marquer ce poste comme poste de construction (en root : touch /etc/sambaedu/wine-builder), rouvrir la session (montage sans licences ni données utilisateur), faire les réglages, puis relancer" >&2
        return 1
    fi
    if ! wine_is_builder && mountpoint -q "$PREFIX"; then
        echo "attention : prefix monté hors poste de construction : registre et fichiers persistants de $USER inclus dans l'image" >&2
    fi
    # maintenance avec licences (voir licence_strip)
    local lstage=""
    if [ -f "$PREFIX/.sambaedu-licences-applied" ] ||
        { [ -n "$(licence_descriptors "$1")" ] && mountpoint -q "/var/tmp/$USER/wine/wine-$1/lower"; }; then
        lstage="$(licence_strip "$1")" || return 1
    fi
    echo "$winever" >"$PREFIX/.sambaedu-wine-version"
    echo "$winever" >"/var/tmp/$USER/wine/wine-$1.version"
    # rename user and hostname in prefix
    sed -i "s/$USER/{{USER}}/g" $PREFIX/*.reg
    sed -i "s/$(hostname)/{{HOSTNAME}}/g" $PREFIX/*.reg
    mv "$PREFIX/drive_c/users/$USER" "$PREFIX/drive_c/users/{{USER}}"

    # Liens du profil wine vers les dossiers de l'utilisateur qui construit
    # l'image (Desktop -> /home/runner/Bureau, posés au montage par
    # prepare_prefix.sh) : exclus de l'image publiée. Ils y seraient morts sur
    # tous les autres postes, et un lien figé dans un dossier réel de l'image
    # (Documents/Documents -> /home/runner/Documents) n'est jamais remplacé au
    # montage. Seules les cibles propres à un utilisateur sont visées ; un
    # lien relatif ou vers un chemin système reste dans l'image.
    local -a userlinks=()
    local l t
    while IFS= read -r -d '' l; do
        t="$(readlink "$l")"
        case "$t" in
        /home/* | /var/tmp/* | /run/user/*) userlinks+=("${l#"$PREFIX"/}") ;;
        esac
    done < <(find "$PREFIX/drive_c/users/{{USER}}" -type l -print0 2>/dev/null)

    # zstd niveau 19, blocs de 1 Mio (au lieu du gzip/128 Kio par défaut) :
    # mesuré sur 2,2 Go réels du prefix solidworks, -12 % de taille
    # (938 Mo contre 1068) et décompression ~3x plus rapide (1,6 s contre
    # 4,7 s sur un cœur) ; xz gagnait encore 4 % mais décompressait 9x plus
    # lentement que zstd. Compression ~4x plus lente, une seule fois à la
    # fabrication. Lisible par les noyaux Debian (CONFIG_SQUASHFS_ZSTD=y)
    # et squashfuse ; les images gzip déjà déployées restent lisibles (le
    # compresseur est enregistré dans le superbloc).
    # fichiers de travail du montage (wine.inc.sh) exclus : un user.reg.orig
    # dans l'image ferait croire à reg_patch, sur tous les postes, que le
    # registre de l'utilisateur est déjà restauré (et il ne le serait plus).
    mksquashfs "$PREFIX" "/var/tmp/$USER/wine/wine-$1.img" -comp zstd -Xcompression-level 19 -b 1M \
        -all-root -no-progress -no-xattrs -noappend \
        -e user.reg.orig system.reg.orig .sambaedu-persist-restored .sambaedu-licences-applied \
        "${userlinks[@]}"
    sha256sum "/var/tmp/$USER/wine/wine-$1.img" | cut -d' ' -f1 >"/var/tmp/$USER/wine/wine-$1.sha256"

    # revert user and hostname in prefix
    sed -i "s/{{USER}}/$USER/g" $PREFIX/*.reg
    sed -i "s/{{HOSTNAME}}/$(hostname)/g" $PREFIX/*.reg
    mv "$PREFIX/drive_c/users/{{USER}}" "$PREFIX/drive_c/users/$USER"
    # licences remises pour la suite de la session de maintenance
    licence_unstrip "$lstage"
}
# construit le package wine-$1 demandé
# outils de construction de paquet : volontairement pas en Depends de
# sambaedu-linux-stations-wine (installé sur tous les postes, alors que
# seul l'opérateur qui construit des paquets en a besoin) mais en Suggests
# - d'où ce contrôle explicite plutôt qu'un "dch : commande introuvable"
# en cours de route (constaté en réel sur micro-antec-21).
function _require_build_tools() {
    local -A pkg_of=([dch]=devscripts [dh]=debhelper [fakeroot]=fakeroot)
    local tool missing=()
    for tool in dch dh fakeroot; do
        command -v "$tool" >/dev/null || missing+=("${pkg_of[$tool]}")
    done
    if [ "${#missing[@]}" -gt 0 ]; then
        echo "outils de construction absents, à installer (root) : apt install ${missing[*]}" >&2
        return 1
    fi
}

function make_package() {
    _require_build_tools || return 1
    cd "$git" || return
    rm -f "*.deb"
    # version explicite <base>+sambaeduN plutôt que "dch -i" seul, qui
    # suffixe +nmuN (DEBEMAIL de l'opérateur différent du Maintainer de
    # debian/control = "non-maintainer upload" pour dch). <base> = version
    # courante sans suffixe +nmuN/+sambaeduN ; N incrémenté à chaque build.
    # Ordre Debian : 4.18.43+sambaedu1 > 4.18.43+nmu20 ("s" > "n"), la
    # transition depuis les anciennes versions +nmu se fait donc bien.
    local cur base n
    cur="$(dpkg-parsechangelog -S Version)"
    base="${cur%%+*}"
    n=0
    [[ "$cur" =~ \+sambaedu([0-9]+)$ ]] && n="${BASH_REMATCH[1]}"
    DEBFULLNAME="$USER" DEBEMAIL="$USER@sambaedu.org" dch -v "$base+sambaedu$((n + 1))" "compilation du paquet $1"
    # "dh binary -pwine-$1" scopé (pas "debuild -us -uc -b", qui construit
    # TOUS les paquets binaires de ce dépôt monorepo) : évite qu'un paquet
    # tiers cassé ailleurs dans l'arbre (wine-proteus/wine-flowcode au
    # moment d'écrire ceci, .install référençant des fichiers absents) ne
    # fasse échouer dh_install globalement et ne produise un .deb vide pour
    # CE paquet - constaté en réel en construisant wine-coeur et
    # wine-notepadplusplus. DH_OPTIONS propage le scope dans les cibles
    # override_dh_install/override_dh_builddeb de debian/rules.
    # échec propagé : sans ça, la fonction renvoyait le code du "cd"
    # final (0) et install_repo committait/publiait quand même (constaté :
    # debian/control avec marqueurs de conflit, dh en erreur, puis commit).
    if ! fakeroot dh binary -pwine-$1; then
        cd
        return 1
    fi
    # "wine-$1_*" (pas "wine-$1*") : un .deb est <paquet>_<version>_<arch>.deb
    # et un nom de paquet ne contient jamais "_" - "wine-regressi*"
    # correspondait aussi à wine-regressi-legacy_*.deb.
    find ../ -maxdepth 1 -name "wine-*.deb" ! -name "wine-$1_*.deb" -delete
    cd
}

# installe l'image en local (il faut être root)
# compile le package et l'installe avec dpkg -i
#
function install_local() {
    dpkg -i "$(ls -t "$git"/../wine-"$1"_*.deb | head -1)"
}

# pousse l'image sur le repo, pousse les fichiers dans un projet git, et lance la construction distante du paquet
# et sa publication par reprepro
# install_repo prefix nom "message de commit"
# committe les fichiers de paquet générés par create_debian_source pour $1
# (control/changelog/*.install/*.postinst/usr/bin/$1 et le contenu du
# .install), sans toucher à l'image ni au dépôt apt distant (voir
# install_repo pour la publication complète) : permet de committer tôt,
# même quand la reconstruction de l'image/paquet est différée (voir
# ci/auto-update-wine.sh de sambaedu-wpkg-xml, qui appelle cette action
# seule via `make-prefix commit`). "git commit" est un no-op silencieux
# (pas d'erreur) si create_debian_source n'a rien changé de nouveau -
# cas normal d'une mise à jour où rien n'a changé côté lanceur/icônes.
function commit_package_source() {
    cd "$git"
    if git rev-parse -q --verify MERGE_HEAD >/dev/null || [ -n "$(git diff --name-only --diff-filter=U)" ]; then
        echo "$1 : dépôt en cours de fusion ou en conflit, rien n'est committé" >&2
        return 1
    fi
    # on commite uniquement les fichiers produits par create_debian_source
    # pour CE paquet (pas "commit -a") : sur un runner CI où le disque
    # persiste d'un job à l'autre, "-a" commiterait aussi toute modification
    # locale sans rapport (résidu d'un job précédent ou d'une investigation
    # manuelle sur ce runner).
    local -a to_add=(debian/control debian/changelog)
    local f
    for f in "debian/wine-$1.install" "debian/wine-$1.postinst" "usr/bin/$1"; do
        [ -e "$f" ] && to_add+=("$f")
    done
    if [ -f "debian/wine-$1.install" ]; then
        while IFS= read -r f; do
            [ -n "$f" ] && [ -e "$f" ] && to_add+=("$f")
        done <"debian/wine-$1.install"
    fi
    # recette du paquet, si make-prefix l'a modifiée (<launch> enregistrés,
    # validation="untested" au premier prepare...) : sinon jamais committée
    # sur le runner, et perdue
    local xmlsrc
    if xmlsrc="$(find_package_xml "$1" 2>/dev/null)" && [ -n "$xmlsrc" ] &&
        git -C "$(dirname "$xmlsrc")" ls-files --error-unmatch "$xmlsrc" >/dev/null 2>&1; then
        to_add+=("$xmlsrc")
    fi
    git add -- "${to_add[@]}"
    if git diff --cached --quiet; then
        echo "$1 : rien de nouveau à committer."
    else
        git commit -m "génération du paquet wine $1 $2" || return 1
    fi
    # échec constaté en réel (branches divergentes sans stratégie de
    # réconciliation configurée, puis échec d'authentification sur push) :
    # sans ce garde-fou explicite, le job continuait comme si de rien
    # n'était (aucun "set -e" dans ce script), laissant le dépôt distant
    # désynchronisé du .deb/image effectivement publiés sans que personne ne
    # le remarque.
    # --rebase : le commit local passe au-dessus des commits distants ; en
    # cas de conflit, on annule plutôt que de laisser le clone en plein
    # rebase (le job suivant échouerait alors sur pull_repo).
    if ! git pull --rebase; then
        git rebase --abort 2>/dev/null || true
        echo "$1 : échec de git pull --rebase (conflit avec origin ? commit local conservé, à réconcilier à la main)" >&2
        return 1
    fi
    if ! git push; then
        echo "$1 : échec de git push (credentials ? voir ~/.git-credentials sur ce runner)" >&2
        return 1
    fi
}

# remet à niveau l'image publiée d'un prefix pour le wine installé (voir
# "upgrade" plus bas). Uniquement sur un poste de construction
# (/etc/sambaedu/wine-builder, voir wine_is_builder) : ailleurs, le montage
# désactive justement la mise à jour du prefix (prepare_prefix.sh).
function upgrade_prefix() {
    . /usr/share/sambaedu/includes/wine.inc.sh
    local name="$1" wp="/var/tmp/$USER/wine/wine-$1/prefix" cur imgver
    if ! wine_is_builder; then
        echo "upgrade : réservé à un poste de construction (/etc/sambaedu/wine-builder absent)" >&2
        return 1
    fi
    cur="$(wine_installed_version)"
    local SERVER="http://deb.sambaedu.org/wpkg/files/wine" pubver out
    # référence : version PUBLIÉE (wine-<prefix>.latest du dépôt), pas celle
    # du prefix monté sur ce poste - qui peut avoir été remis à niveau lors
    # d'un passage précédent dont la publication a échoué (constaté sur
    # solidworks : prefix local en sw-2, dépôt resté en sw-1, et chaque
    # passage suivant concluait à tort "déjà construite").
    if ! wget -q -O /dev/null "$SERVER/wine-$name.sha256"; then
        echo "wine-$name : jamais publiée sur le dépôt, rien à remettre à niveau"
        return 0
    fi
    pubver="$(wget -q -O- "$SERVER/wine-$name.latest" 2>/dev/null | head -n1)"
    # image déjà publiée pour ce wine, d'après .latest ou d'après sa
    # présence dans le dossier de la version (.latest absent ou en retard :
    # publication interrompue, image construite et publiée depuis un poste
    # de construction - cas courant des applis build="manuel")
    if [ "$pubver" = "$cur" ] || wget -q -O /dev/null "$SERVER/$cur/wine-$name.sha256"; then
        echo "wine-$name : image publiée déjà construite pour wine $cur"
        return 0
    fi
    # image publiée, téléchargée et montée (jamais un prefix neuf : il n'y
    # aurait rien à remettre à niveau, et une image vide serait publiée)
    if ! mountpoint -q "$wp" 2>/dev/null; then
        if ! out="$(sudo /usr/share/sambaedu/scripts/download_wine.sh "wine-$name" 2>&1)"; then
            echo "wine-$name : échec du téléchargement de l'image publiée :" >&2
            echo "$out" | tail -n 20 >&2
            return 1
        fi
        # montage partiel resté d'un passage précédent (unités "active"
        # mais bindfs disparu, constaté sur le runner pour pronote-apps :
        # "start" ne refaisait rien, et prepare_prefix.sh avait écrit dans
        # le dossier non monté) : démontage complet avant de remonter. Sans
        # risque ici, le prefix n'étant pas monté (rien d'utilisable dans
        # l'upper). wine-overlay-prepare@ aussi : le démontage
        # (umount_wine.sh) supprime les dossiers de l'overlay, qu'elle seule
        # recrée.
        systemctl --user stop "wine-prepare-prefix@wine-$name.service" "wine-mount-prefix@wine-$name.service" \
            "wine-overlay-prepare@wine-$name.service" >/dev/null 2>&1 || true
        if ! systemctl --user start "wine-prepare-prefix@wine-$name.service"; then
            echo "wine-$name : échec du montage :" >&2
            journalctl --user -n 20 --no-pager -u "wine-mount-prefix@wine-$name.service" -u "wine-prepare-prefix@wine-$name.service" >&2 2>/dev/null
            return 1
        fi
    fi
    if ! mountpoint -q "$wp" 2>/dev/null; then
        echo "wine-$name : image publiée non montée ($wp)" >&2
        return 1
    fi
    imgver="$(cat "$wp/.sambaedu-wine-version" 2>/dev/null)"
    if [ "$imgver" = "$cur" ]; then
        # remise à niveau déjà faite localement, publication manquante
        echo "wine-$name : prefix local déjà à jour pour wine $cur, image publiée en ${pubver:-version inconnue} : reconstruction et publication"
        make_image "$name" && publish_image "$name"
        return
    fi
    echo "wine-$name : remise à niveau de l'image (wine ${imgver:-inconnu} -> $cur)"
    # wineboot --update peut rester bloqué sur une boîte d'erreur (rundll32
    # Wow64Install "This application could not be started", constaté en
    # 11.18) qui attend un clic, et des services du prefix ne s'arrêtent
    # jamais d'eux-mêmes (FlexNet FNPLicensingService64, EdgeUpdate... :
    # wineserver -w attendait indéfiniment, constaté sur solidworks) :
    # attente bornée, puis arrêt de tous les process du prefix (registre
    # écrit par wineserver à sa sortie).
    WINEDLLOVERRIDES='winemenubuilder.exe=' WINEPREFIX="$wp" timeout --kill-after=10 300 wineboot --update >/dev/null 2>&1
    WINEPREFIX="$wp" timeout 60 wineserver -w 2>/dev/null
    WINEPREFIX="$wp" wineserver -k 2>/dev/null
    WINEPREFIX="$wp" timeout 30 wineserver -w 2>/dev/null
    make_image "$name" && publish_image "$name"
}

# publie l'image wine-<prefix> sur le dépôt, rangée par version de wine
# (voir make_image) : /var/www/wpkg/files/wine/<version>/wine-<prefix>.img
# (+ .sha256), wine-<prefix>.latest = dernière version publiée, et les
# anciens noms à plat (wine-<prefix>.img/.sha256) en liens vers elle pour
# les postes et se4fs pas encore migrés. Seules les deux dernières versions
# (n et n-1) sont gardées : un poste dont wine n'est pas encore à jour
# trouve toujours son image. Image sans version (construite avant) :
# publication à plat, comme auparavant.
publish_image() {
    local img="/var/tmp/$USER/wine/wine-$1" ver remote=/var/www/wpkg/files/wine
    local SSH="ssh root@deb.sambaedu.org" SERVER="http://deb.sambaedu.org/wpkg/files/wine"
    ver="$(cat "$img.version" 2>/dev/null)"
    if [ -z "$ver" ]; then
        if ! wget -q -O "/tmp/wine-$1.sha256" "$SERVER/wine-$1.sha256" || ! cmp -s "/tmp/wine-$1.sha256" "$img.sha256"; then
            scp "$img.img" "$img.sha256" "root@deb.sambaedu.org:$remote/" || return 1
        fi
        return 0
    fi
    if wget -q -O "/tmp/wine-$1.sha256" "$SERVER/$ver/wine-$1.sha256" && cmp -s "/tmp/wine-$1.sha256" "$img.sha256"; then
        echo "wine-$1 : image déjà publiée pour wine $ver"
    else
        $SSH "mkdir -p '$remote/$ver'" || return 1
        # checksum en dernier : les postes s'y fient pour savoir l'image complète
        scp "$img.img" "root@deb.sambaedu.org:$remote/$ver/" &&
            scp "$img.sha256" "root@deb.sambaedu.org:$remote/$ver/" || return 1
    fi
    $SSH bash -s -- "$remote" "wine-$1" "$ver" <<'EOF'
set -e
cd "$1"
ln -sfn "$3/$2.img" "$2.img"
ln -sfn "$3/$2.sha256" "$2.sha256"
echo "$3" >"$2.latest"
# n et n-1 seulement (ordre des versions Debian : dpkg, pas sort -V,
# qui ne traite pas "~")
vers=()
for d in */"$2.img"; do
    [ -f "$d" ] || continue
    v="${d%%/*}"
    i=${#vers[@]}
    while [ "$i" -gt 0 ] && dpkg --compare-versions "$v" gt "${vers[$((i - 1))]}"; do
        vers[$i]="${vers[$((i - 1))]}"
        i=$((i - 1))
    done
    vers[$i]="$v"
done
for v in "${vers[@]:2}"; do
    echo "$2 : suppression de l'image wine $v (au-delà de n-1)"
    rm -f "$v/$2.img" "$v/$2.sha256"
    rmdir "$v" 2>/dev/null || true
done
EOF
}

install_repo() {
    # on pose l'image et le checksum Azerty-12345437765
    SSH="ssh root@deb.sambaedu.org"
    SERVER="http://deb.sambaedu.org/wpkg/files/wine"

    # test si l'image existe déjà, on compare son checksum avec celui du dépôt
    # ($2 vide : paquet seul, jamais d'image - voir l'action rebuild)
    if [ -n "$2" ] && [ -f "/var/tmp/$USER/wine/wine-$2.sha256" ]; then
        publish_image "$2" || return 1
    fi
    commit_package_source "$1" "${2:-(rebuild, sans image)}" || return 1
    # reprepro
    $SSH "mkdir -p /root/tmpse4"
    # le plus récent de CE paquet (voir make_package pour "wine-$1_*" ; ls -t
    # et non le tri alphabétique, qui dépend de la locale : en fr_FR,
    # wine-regressi-legacy_* était trié après wine-regressi_* et publié à
    # sa place)
    deb="$(ls -t "$git"/../wine-"$1"_*.deb 2>/dev/null | head -1)"
    if [ -n "$deb" ]; then
    scp "$deb" root@deb.sambaedu.org:/root/tmpse4
    paquet=$(basename "$deb")
    $SSH "echo \"traitement de $paquet\"; reprepro -C se4XP -b /var/www/debian includedeb trixie /root/tmpse4/$paquet"
    $SSH "echo \"traitement de $paquet\"; reprepro -C stable -b /var/www/debian includedeb trixie /root/tmpse4/$paquet"
    $SSH "rm -fr /root/tmpse4/$paquet"
    fi
}

pull_repo() {
    mkdir -p $HOME/git
    cd $HOME/git
    if [ ! -d "$HOME/git/sambaedu-wpkg-xml" ]; then
        git clone https://gitlab.sambaedu.org/sambaedu/sambaedu-wpkg-xml.git
    fi
    cd $HOME/git/sambaedu-wpkg-xml
    # fast-forward seulement : un clone qui a divergé (commits locaux jamais
    # poussés, ex: push refusé lors d'un job précédent) doit être réparé à
    # la main, pas fusionné automatiquement - une fusion en conflit laissait
    # des marqueurs dans debian/control, ensuite committés par
    # commit_package_source.
    if ! git pull --ff-only; then
        echo "~/git/sambaedu-wpkg-xml : git pull impossible en fast-forward (commits locaux non poussés ? voir git log origin/main..HEAD)" >&2
        cd
        return 1
    fi
    cd
}

action="$1"
package="$2"
if [ -z "$3" ]; then
    prefix="$package"
else
    prefix="$3"
fi
if [ -z "$action" ] || [ "$action" == "--help" ]; then
    echo "$0 new|install_wpkg|run|test_wine|prepare|image|build|install|publish|rebuild|upgrade <package> [prefix] [categorie]

 upgrade <prefix...> : remet à niveau pour le wine installé les images publiées (montage, wineboot --update,
    reconstruction, publication de l'image seule, rangée par version de wine). Poste de construction
    uniquement (/etc/sambaedu/wine-builder).

 new : crée un nouveau prefix (non-interactif, adapté au CI) ou remet à niveau un existant.
    A faire avant d'installer l'application Windows. le prefix est dans /var/tmp/$USER/wine/wine-$prefix/prefix
    Normalement toute commande wine doit être précédée de WINEPREFIX=/var/tmp/$USER/wine/wine-$prefix/prefix.
    Installe également wsh57 et msxml3 (indispensables pour install_wpkg).
    En cas de modification d'un prefix déjà en place, cette étape n'est pas nécessaire.

 install_wpkg : installe l'application via le client wpkg windows (wpkg-se4.js), à partir de la
    recette du dépôt local sambaedu-wpkg-xml (~/git/sambaedu-wpkg-xml). Le prefix doit déjà exister
    (make-prefix new). Ne dépend pas du domaine SambaEdu ni d'un poste joint au domaine. Installe
    aussi les dépendances éventuelles (<depends package-id=...>) de la recette.

 run : lance l'application déjà installée (install_wpkg) pour une validation fonctionnelle manuelle.
    Ce n'est PAS une action pour le CI : premier plan, interactif, Ctrl+C pour arrêter.
    make-prefix run <package> <prefix> [sous-chaine-desktop pour désambiguïser]

 test_wine : lance install_wpkg (dans un prefix séparé pour chacune) pour toutes les applications de
    sambaedu-wpkg-xml/stable pour lesquelles aucun paquet debian du même id n'existe, ni aucune de leurs
    dépendances (apt-cache show / balise <linux>). Pensé pour le CI.
    Rapport dans /var/tmp/$USER/wine/wpkg-ci-report.txt : une appli déjà présente dans ce rapport n'est PAS
    retestée (reprise automatique après une interruption). Pour repartir de zéro : make-prefix test_wine reset

 prepare : fusionne les éléments du prefix en cours avec le dépôt git sambaedu-wpkg-xml/sources. Tente de récupérer les
    .desktop (lanceurs et associations mime), icones, et crée un lanceur shell utilisable tel quel (lance le
    raccourci .lnk d'origine). Si plusieurs lanceurs sont trouvés, demande lesquels garder. À adapter manuellement
    seulement pour les cas particuliers (arguments à transmettre à l'exe réel, ex: association mime).
    [categorie] est optionnel : par défaut lu depuis categories= sur <linux type="wine"> dans la recette xml.

 image : construit l'image squashfs du prefix (assez long)

 build : construit le paquet debian. Le numéro de version est incrémenté.

 publish : pousse sur le dépôt gitlab et deb le paquet (authentification sur deb.sambaedu.org et gitlab indispensables).
    seuls les paquets indiqués seront publiés. Si certains ont des dépendances il faut publier aussi les dépendances.

 install : installe localement le paquet généré (droits root indispensables)

 rebuild <package> [package...] : reconstruit et publie le(s) paquet(s) depuis le seul dépôt git (sans prefix
    ni image), après une modification faite directement dans sambaedu-wpkg-xml/sources."
fi

case $action in
new)
    create_prefix "$prefix" || exit 1
    export WINEPREFIX="/var/tmp/$USER/wine/wine-$prefix/prefix"
    echo "le prefix /var/tmp/$USER/wine/wine-$prefix/prefix a été créé est est actif par défaut pour wine pour cette session."
    ;;
install_wpkg)
    # garantit que ~/git/sambaedu-wpkg-xml existe et est à jour avant de
    # chercher une recette dedans (find_package_xml) : sur un runner CI où
    # le home peut être réinitialisé entre deux logons, ce clone n'est pas
    # garanti présent avant ce tout premier job qui en a besoin.
    pull_repo || exit 1
    install_wpkg $package $prefix
    status=$?
    if [ "$status" = 0 ]; then
        smoke="$(smoke_test_app "$package" "$prefix")"
        echo "smoke-test : $smoke"
        # sans garde-fou humain (pipeline CI en mode mise à jour, où
        # validate_manually devient automatique), le smoke-test est le seul
        # signal disponible que l'appli démarre correctement - un SMOKE-FAIL
        # doit donc faire échouer ce job, pas seulement être loggué. Les
        # SMOKE-SKIPPED-* (pas de raccourci, tasklist indisponible) restent
        # non bloquants : ils signifient "indéterminé", pas "échec".
        [ "$smoke" = "SMOKE-FAIL" ] && status=1
    fi
    exit $status
    ;;
run)
    run_prefix_app "$package" "$prefix" "$4"
    ;;
test_wine)
    test_wine_apps "$package"
    ;;
prepare)
    pull_repo || exit 1
    if ! create_debian_source $package $prefix $4; then
        exit 1
    fi
    echo "le dépôt local $package a été mis à jour. modifiez manuellement les choses nécessaires..."
    ;;
image)
    make_image $prefix || exit 1
    ;;
upgrade)
    # remise à niveau d'images publiées pour le wine installé (passage à une
    # nouvelle version de wine) : montage de la dernière image publiée,
    # "wineboot --update", reconstruction et publication de l'image seule -
    # les paquets wine-<appli> ne dépendent pas de la version de wine.
    status=0
    for p in "${@:2}"; do
        upgrade_prefix "$p" || { echo "$p : échec de la remise à niveau" >&2; status=1; }
    done
    exit $status
    ;;
build)
    make_package $package || exit 1
    ;;
install)
    install_local $package $prefix
    ;;
commit)
    pull_repo || exit 1
    commit_package_source $package $prefix
    ;;
publish)
    install_repo $package $prefix
    ;;
rebuild)
    # reconstruit et publie le(s) paquet(s) à partir du seul dépôt git, sans
    # prefix ni image : pour une modification faite directement dans
    # sambaedu-wpkg-xml/sources (lanceur, .desktop, postinst...), sans
    # refaire prepare sur un poste ayant le prefix d'origine. N'envoie
    # jamais d'image (install_repo sans prefix).
    pull_repo || exit 1
    status=0
    for p in "${@:2}"; do
        if ! { make_package "$p" && install_repo "$p" ""; }; then
            echo "$p : échec de la reconstruction" >&2
            status=1
        fi
    done
    exit $status
    ;;
esac
