#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
create_pkgs_share.py
====================

Crée un partage de packages (pkgs.pkgs_shares) lié à un relai
(xmppmaster.relayserver) ainsi que sa règle d'accès (pkgs.pkgs_rules_local).

Mode interactif par défaut : toute information non fournie en argument est
demandée à l'utilisateur.

Nom du partage (1ère réponse ; vide = nom du relai) :
  - pkgs_shares.comments : le nom tel quel, espaces et majuscules conservés ;
  - pkgs_shares.name, dossier et share_path : espaces remplacés par '_' et tout
    en minuscules. Le dossier /var/lib/pulse2/packages/sharing/<nom> est créé
    s'il n'existe pas, et ce chemin est inséré dans pkgs_shares.share_path.

Droits du dossier créé : syncthing:syncthing, mode 755 (--share-owner, --share-mode),
plus les ACL copiées depuis un partage existant (--acl-from, défaut <sharing-root>/global)
pour obtenir « drwxr-xr-x+ syncthing syncthing ». Un dossier déjà présent n'est jamais
modifié. Si le compte syncthing n'existe pas, le script s'arrête avant toute écriture.

Relais : le script se connecte en SSH à medulla@<nameserver du relai> (clé, sans mot de
passe). Si la connexion est bonne, il fait aussi SUR LE RELAI : création du dossier
<sharing-root>/<nom> avec les mêmes droits/ACL, et ajout d'un <folder> dans le config.xml
Syncthing du relai, copié depuis le <folder> modèle de CE fichier (pas celui du serveur
local). Il faut root ou sudo sans mot de passe sur le relai. Si la connexion échoue :
arrêt avant toute écriture avec --yes, sinon question ; --skip-relay ignore le relai.
En --dry-run, la connexion et les lectures sont faites (rien n'est écrit nulle part).

Syncthing : une copie complète de la section <folder id="pulsemaster_global"> de
/var/lib/syncthing/.config/syncthing/config.xml est ajoutée, avec
id="pulsemaster_<nom>", label="<nom>" et path="<share_path>" ; tout le reste
(paramètres, éléments internes) est repris à l'identique. Le fichier est
sauvegardé dans backup/ avant modification.

Exemples
--------
    # Mode interactif complet
    ./create_pkgs_share.py

    # Simulation : rien n'est écrit (ni sauvegarde, ni INSERT)
    ./create_pkgs_share.py --dry-run

    # Tout en arguments (aucune question posée avec --yes)
    ./create_pkgs_share.py --name "Partage Relay 01" \
        --relay-id 3 --order 5 --subject '.*' --permission rw --yes

Prérequis
---------
    apt install python3-pymysql mariadb-client openssh-client
    Connexion SQL : lue dans la section [database] de
    /etc/mmc/plugins/xmppmaster.ini.local (clés dbhost, dbport, dbuser, dbpasswd).
    Ce compte doit avoir accès aux bases `xmppmaster` et `pkgs`.
    À lancer en root (ou avec un compte pouvant écrire dans le dossier des
    partages et dans le config.xml de Syncthing), sur le serveur Medulla.
"""

from __future__ import annotations

import argparse
import base64
import configparser
import datetime as dt
import getpass
import grp
import hashlib
import os
import posixpath
import pwd
import re
import shlex
import shutil
import stat
import subprocess
import sys
import tempfile
from pathlib import Path
from xml.etree import ElementTree as ET
from xml.sax.saxutils import escape

try:
    import pymysql
    from pymysql.cursors import DictCursor
except ImportError:  # pragma: no cover
    sys.exit("Module manquant : pymysql  (apt install python3-pymysql)")

# --------------------------------------------------------------------------- #
# Constantes
# --------------------------------------------------------------------------- #
SCRIPT_DIR = Path(__file__).resolve().parent
BACKUP_DIR = SCRIPT_DIR / "backup"  # répertoire "backup" à côté du script

# Fichier de configuration Medulla où lire les accès SQL (section [database])
INI_FILES = ["/etc/mmc/plugins/xmppmaster.ini.local"]

DEFAULT_SHARING_ROOT = "/var/lib/pulse2/packages/sharing"
DEFAULT_SHARE_OWNER = "syncthing:syncthing"  # propriétaire:groupe du dossier créé
DEFAULT_SHARE_MODE = "755"                   # droits du dossier créé (octal)
ACL_XATTRS = ("system.posix_acl_access", "system.posix_acl_default")  # ce qui affiche « + »
DEFAULT_SYNCTHING_CONFIG = "/var/lib/syncthing/.config/syncthing/config.xml"
SYNCTHING_TEMPLATE_ID = "pulsemaster_global"  # <folder> copié comme modèle
SYNCTHING_ID_PREFIX = "pulsemaster_"
DEFAULT_SUBJECT = ".*"
VALID_PERMISSIONS = ("r", "rw")
BACKUP_TABLES = ("pkgs_shares", "pkgs_rules_local")

SQL_LIST_RELAYS = "SELECT * FROM xmppmaster.relayserver"

SQL_LIST_RULES = """
    SELECT r.id, r.`order`, r.pkgs_shares_id, s.name AS share_name,
           r.subject, r.permission
      FROM pkgs.pkgs_rules_local AS r
INNER JOIN pkgs.pkgs_shares AS s ON r.pkgs_shares_id = s.id
  ORDER BY r.`order`, r.id
"""

SQL_INSERT_SHARE = (
    "INSERT IGNORE INTO pkgs.pkgs_shares "
    "(id, name, comments, type, uri, ars_name, ars_id, share_path) "
    "VALUES (%s, %s, %s, 'local', %s, %s, %s, %s)"
)

SQL_INSERT_RULE = (
    "INSERT IGNORE INTO pkgs.pkgs_rules_local "
    "(pkgs_rules_algos_id, `order`, subject, permission, pkgs_shares_id) "
    "VALUES (1, %s, %s, %s, %s)"
)


# --------------------------------------------------------------------------- #
# Utilitaires d'affichage / saisie
# --------------------------------------------------------------------------- #
def fatal(message: str, code: int = 1) -> None:
    print(f"\n[ERREUR] {message}", file=sys.stderr)
    sys.exit(code)


def ask(prompt: str, default: str | None = None, allow_empty: bool = False) -> str:
    """Pose une question texte, avec valeur par défaut éventuelle."""
    suffix = f" [{default}]" if default is not None else ""
    while True:
        value = input(f"{prompt}{suffix} : ").strip()
        if value:
            return value
        if default is not None:
            return default
        if allow_empty:
            return ""
        print("  -> Une réponse est requise.")


def slugify_share_name(name: str) -> str:
    """Nom technique (colonne name, dossier, share_path) : espaces -> '_' et minuscules."""
    return re.sub(r"\s", "_", name.strip()).lower()


def validate_share_name(name: str) -> str | None:
    """Retourne un message d'erreur, ou None si le nom est valide (vide accepté).

    Les espaces sont permis (remplacés par '_' dans le nom technique) ; en revanche
    le nom sert de nom de dossier : pas de séparateur de chemin.
    """
    if "/" in name or "\\" in name or "\0" in name:
        return "les caractères / et \\ sont interdits (le nom sert de nom de dossier)"
    if slugify_share_name(name) in (".", ".."):
        return "nom invalide"
    return None


def ask_share_name() -> str:
    while True:
        name = ask("Nom public du partage (vide = nom du relai choisi ensuite)",
                   allow_empty=True).strip()
        error = validate_share_name(name)
        if error is None:
            return name
        print(f"  -> {error}.")


def ask_int(prompt: str, default: int | None = None, min_value: int = 0) -> int:
    while True:
        raw = ask(prompt, str(default) if default is not None else None)
        try:
            value = int(raw)
        except ValueError:
            print("  -> Merci de saisir un nombre entier.")
            continue
        if value < min_value:
            print(f"  -> La valeur doit être >= {min_value}.")
            continue
        return value


def ask_yes_no(prompt: str, default: bool = False) -> bool:
    hint = "[O/n]" if default else "[o/N]"
    while True:
        raw = input(f"{prompt} {hint} : ").strip().lower()
        if not raw:
            return default
        if raw in ("o", "oui", "y", "yes"):
            return True
        if raw in ("n", "non", "no"):
            return False
        print("  -> Répondre par o ou n.")


def print_table(rows: list[dict], columns: list[str]) -> None:
    """Affiche une liste de dictionnaires sous forme de tableau."""
    if not rows:
        print("  (aucune ligne)")
        return
    widths = {
        c: max(len(c), *(len(str(r.get(c, ""))) for r in rows)) for c in columns
    }
    line = "  ".join(c.ljust(widths[c]) for c in columns)
    print(line)
    print("  ".join("-" * widths[c] for c in columns))
    for r in rows:
        print("  ".join(str(r.get(c, "")).ljust(widths[c]) for c in columns))


# --------------------------------------------------------------------------- #
# Connexion à la base
# --------------------------------------------------------------------------- #
def load_db_settings(args: argparse.Namespace) -> dict:
    """Détermine les paramètres de connexion : arguments > env > ini > saisie."""
    ini = configparser.ConfigParser(interpolation=None)  # mots de passe avec %
    section = {}
    try:
        read_files = ini.read(INI_FILES)
    except configparser.Error as exc:
        read_files = []
        print(f"[ATTENTION] Lecture de {', '.join(INI_FILES)} impossible : {exc}")
    else:
        if not read_files:
            print(f"[ATTENTION] {', '.join(INI_FILES)} introuvable ou illisible "
                  "(le script tourne-t-il sur le serveur Medulla, en root ?).")
        elif not ini.has_section("database"):
            print(f"[ATTENTION] Section [database] absente de {read_files[0]}.")
        else:
            section = ini["database"]

    ini_user = section.get("dbuser")
    host = args.db_host or section.get("dbhost") or "localhost"
    port = args.db_port or int(section.get("dbport") or 3306)
    user = args.db_user or ini_user

    password = args.db_password or os.environ.get("PKGS_DB_PASSWORD")
    # Ne réutilise le mot de passe de l'ini que pour le même utilisateur
    if password is None and user and user == ini_user:
        password = section.get("dbpasswd")

    if not user:
        user = ask("Utilisateur SQL")
    if password is None:
        password = getpass.getpass(f"Mot de passe SQL pour {user}@{host} : ")

    return {"host": host, "port": int(port), "user": user, "password": password}


def connect(settings: dict):
    try:
        return pymysql.connect(
            host=settings["host"],
            port=settings["port"],
            user=settings["user"],
            password=settings["password"],
            charset="utf8mb4",
            cursorclass=DictCursor,
            autocommit=False,
        )
    except pymysql.MySQLError as exc:
        fatal(f"Connexion SQL impossible : {exc}")


# --------------------------------------------------------------------------- #
# Sauvegarde
# --------------------------------------------------------------------------- #
def find_dump_binary() -> str | None:
    return shutil.which("mysqldump") or shutil.which("mariadb-dump")


def backup_tables(settings: dict, dry_run: bool) -> Path:
    """Sauvegarde pkgs_shares et pkgs_rules_local dans ./backup/ (date + heure)."""
    stamp = dt.datetime.now().strftime("%Y%m%d_%H%M%S")
    target = BACKUP_DIR / f"pkgs_shares_rules_{stamp}.sql"

    if dry_run:
        print(f"[DRY-RUN] Sauvegarde simulée : tables {', '.join(BACKUP_TABLES)} "
              f"-> {target}")
        return target

    dump_bin = find_dump_binary()
    if not dump_bin:
        fatal("mysqldump / mariadb-dump introuvable (apt install mariadb-client). "
              "Aucune modification n'a été faite.")

    BACKUP_DIR.mkdir(parents=True, exist_ok=True)

    # Fichier d'options temporaire (0600) : évite de passer le mot de passe
    # en ligne de commande (visible dans `ps`).
    escaped_pwd = settings["password"].replace("\\", "\\\\").replace('"', '\\"')
    with tempfile.NamedTemporaryFile("w", suffix=".cnf", delete=False) as tmp:
        tmp.write("[client]\n")
        tmp.write(f"host={settings['host']}\n")
        tmp.write(f"port={settings['port']}\n")
        tmp.write(f"user={settings['user']}\n")
        tmp.write(f'password="{escaped_pwd}"\n')
        cnf_path = tmp.name

    try:
        os.chmod(cnf_path, 0o600)
        cmd = [
            dump_bin,
            f"--defaults-extra-file={cnf_path}",
            "--single-transaction",
            "--result-file", str(target),
            "pkgs",
            *BACKUP_TABLES,
        ]
        result = subprocess.run(cmd, capture_output=True, text=True)
    finally:
        os.unlink(cnf_path)

    if result.returncode != 0:
        if target.exists():
            target.unlink()
        fatal(f"Échec de la sauvegarde : {result.stderr.strip()}\n"
              "Aucune modification n'a été faite.")

    print(f"[OK] Sauvegarde créée : {target}")
    return target


# --------------------------------------------------------------------------- #
# Étapes de collecte
# --------------------------------------------------------------------------- #
def choose_relay(cur, relay_id_arg: int | None) -> dict:
    cur.execute(SQL_LIST_RELAYS)
    relays = sorted(cur.fetchall(), key=lambda r: r["id"])
    if not relays:
        fatal("Aucun relai trouvé dans xmppmaster.relayserver.")

    preferred = ["id", "nameserver", "ipserver", "jid", "enabled"]
    columns = [c for c in preferred if c in relays[0]]

    print("\nRelais disponibles (xmppmaster.relayserver) :\n")
    print_table(relays, columns)
    print()

    by_id = {r["id"]: r for r in relays}

    if relay_id_arg is not None:
        if relay_id_arg not in by_id:
            fatal(f"Relai id={relay_id_arg} introuvable.")
        return by_id[relay_id_arg]

    while True:
        chosen = ask_int("ID du relai à utiliser", min_value=0)
        if chosen in by_id:
            return by_id[chosen]
        print(f"  -> L'id {chosen} n'existe pas dans la liste.")


def choose_order(cur, order_arg: int | None) -> int:
    cur.execute(SQL_LIST_RULES)
    rules = cur.fetchall()

    print("\nRègles déjà présentes (pkgs.pkgs_rules_local) :\n")
    print_table(rules, ["id", "order", "pkgs_shares_id", "share_name",
                        "subject", "permission"])
    print()

    if order_arg is not None:
        return order_arg

    used = [r["order"] for r in rules if r["order"] is not None]
    suggestion = (max(used) + 1) if used else 1
    return ask_int("Ordre de la nouvelle règle", default=suggestion, min_value=0)


def next_share_id(cur, lock: bool = False) -> int:
    sql = "SELECT COALESCE(MAX(id), 0) AS last_id FROM pkgs.pkgs_shares"
    if lock:
        sql += " FOR UPDATE"
    cur.execute(sql)
    return int(cur.fetchone()["last_id"]) + 1


# --------------------------------------------------------------------------- #
# Dossier du partage
# --------------------------------------------------------------------------- #
def resolve_owner(spec: str) -> tuple[int, int]:
    """'utilisateur[:groupe]' -> (uid, gid) ; le groupe vaut l'utilisateur s'il est omis."""
    user, _, group = spec.partition(":")
    group = group or user
    try:
        uid = pwd.getpwnam(user).pw_uid
    except KeyError:
        raise RuntimeError(f"utilisateur « {user} » introuvable sur cette machine") from None
    try:
        gid = grp.getgrnam(group).gr_gid
    except KeyError:
        raise RuntimeError(f"groupe « {group} » introuvable sur cette machine") from None
    return uid, gid


def read_acl(path: Path) -> dict[str, bytes]:
    """ACL POSIX étendues d'un dossier (celles qui font afficher « + » dans ls -l)."""
    found: dict[str, bytes] = {}
    try:
        names = os.listxattr(path)
        for name in ACL_XATTRS:
            if name in names:
                found[name] = os.getxattr(path, name)
    except OSError:
        pass
    return found


def reference_acl(acl_from: Path) -> tuple[dict[str, bytes], str]:
    """ACL à copier sur le nouveau dossier, avec une phrase qui dit d'où elles viennent."""
    if not acl_from.is_dir():
        return {}, f"dossier de référence {acl_from} absent : ACL non copiées"
    acl = read_acl(acl_from)
    if not acl:
        return {}, f"{acl_from} n'a pas d'ACL étendue : rien à copier"
    return acl, f"ACL copiées de {acl_from}"


def describe_rights(path: Path) -> str:
    """Rendu type « ls -ld » : drwxr-xr-x+ syncthing:syncthing."""
    st = path.stat()
    try:
        user = pwd.getpwuid(st.st_uid).pw_name
    except KeyError:
        user = str(st.st_uid)
    try:
        group = grp.getgrgid(st.st_gid).gr_name
    except KeyError:
        group = str(st.st_gid)
    plus = "+" if read_acl(path) else ""
    return f"{stat.filemode(st.st_mode)}{plus} {user}:{group}"


def ensure_share_dir(path: Path, owner: tuple[int, int] | None, mode: int,
                     acl_from: Path) -> bool:
    """Crée le dossier du partage s'il n'existe pas. True s'il vient d'être créé.

    Un dossier déjà présent n'est jamais modifié. Un dossier créé reçoit le
    propriétaire/groupe et les droits demandés, puis les ACL de `acl_from`.
    Si une étape obligatoire échoue, le dossier créé est supprimé avant de remonter l'erreur.
    """
    if path.is_dir():
        print(f"[INFO] Dossier déjà présent (droits inchangés) : {path}")
        return False
    if path.exists():
        raise RuntimeError(f"{path} existe mais n'est pas un dossier.")
    if not path.parent.is_dir():
        raise RuntimeError(
            f"Répertoire de base introuvable : {path.parent} "
            "(le script doit tourner sur le serveur qui héberge les partages).")
    if owner is None:
        raise RuntimeError("propriétaire du dossier non résolu (voir --share-owner).")

    path.mkdir()
    try:
        try:
            os.chown(path, *owner)
        except OSError as exc:
            raise RuntimeError(f"chown impossible sur {path} : {exc} "
                               "(le script doit tourner en root).") from exc
        os.chmod(path, mode)

        acl, note = reference_acl(acl_from)
        if acl:
            try:
                for name, value in acl.items():
                    os.setxattr(path, name, value)
                print(f"[OK] {note}")
            except OSError as exc:  # non bloquant : le dossier reste utilisable
                print(f"[ATTENTION] Copie des ACL de {acl_from} impossible : {exc}")
        else:
            print(f"[INFO] {note}")

        actual = stat.S_IMODE(path.stat().st_mode)
        if actual != mode:
            print(f"[ATTENTION] Droits obtenus {actual:o} au lieu de {mode:o} : le masque "
                  f"des ACL copiées de {acl_from} remplace les droits du groupe.")
    except Exception:
        try:
            path.rmdir()
        except OSError:
            pass
        raise
    print(f"[OK] Dossier créé : {path}  ({describe_rights(path)})")
    return True


# --------------------------------------------------------------------------- #
# Syncthing
# --------------------------------------------------------------------------- #
def xml_attr(value: str) -> str:
    """Échappe une valeur d'attribut XML (entre guillemets doubles)."""
    return escape(value, {'"': "&quot;"})


def build_syncthing_config(text: str, template_id: str, folder_id: str,
                           label: str, path: str) -> tuple[str, str, str] | None:
    """Ajoute à la config Syncthing une copie de la section <folder> modèle.

    La copie reprend tout le contenu du modèle (paramètres et éléments internes) ;
    seuls id, label et path changent sur la 1ère ligne <folder ...>. Le reste du
    fichier est conservé tel quel (mise en forme, commentaires, fins de ligne).

    Retourne (nouveau_texte, bloc_ajouté, indentation), ou None si un <folder>
    avec cet id existe déjà.
    """
    root = ET.fromstring(text.encode("utf-8"))
    ids = [f.get("id") for f in root.findall("folder")]
    if folder_id in ids:
        return None
    if template_id not in ids:
        raise RuntimeError(f'section <folder id="{template_id}"> introuvable')

    pattern = re.compile(
        r'<folder\b(?=[^>]*\sid="%s")[^>]*>.*?</folder>' % re.escape(template_id),
        re.DOTALL)
    match = pattern.search(text)
    if not match:
        raise RuntimeError(f'section <folder id="{template_id}"> introuvable dans le texte')
    block = match.group(0)
    open_tag = re.match(r"<folder\b[^>]*>", block).group(0)
    if open_tag.endswith("/>"):
        raise RuntimeError(f'la section <folder id="{template_id}"> est vide (balise auto-fermante)')

    new_open = open_tag
    for attr, value in (("id", folder_id), ("label", label), ("path", path)):
        new_open, count = re.subn(
            r'(\s%s=")[^"]*(")' % attr,
            lambda m, v=xml_attr(value): m.group(1) + v + m.group(2),
            new_open, count=1)
        if count != 1:
            raise RuntimeError(f"attribut {attr} absent de la section modèle")
    new_block = new_open + block[len(open_tag):]

    line_start = text.rfind("\n", 0, match.start()) + 1
    indent = text[line_start:match.start()]
    if indent.strip():
        indent = ""
    newline = "\r\n" if "\r\n" in text else "\n"
    new_text = text[:match.end()] + newline + indent + new_block + text[match.end():]

    # Contrôle : XML valide, nouvel id présent une seule fois, un dossier de plus
    new_ids = [f.get("id") for f in ET.fromstring(new_text.encode("utf-8")).findall("folder")]
    if new_ids.count(folder_id) != 1 or len(new_ids) != len(ids) + 1:
        raise RuntimeError("le contrôle du XML généré a échoué")
    return new_text, new_block, indent


def read_syncthing_config(path: Path) -> str:
    with open(path, "r", encoding="utf-8", newline="") as fh:
        return fh.read()


def write_syncthing_config(path: Path, text: str) -> None:
    """Remplace config.xml de façon atomique, en conservant propriétaire et droits."""
    st = path.stat()
    tmp = path.with_name(f".{path.name}.tmp")
    try:
        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
        with os.fdopen(fd, "w", encoding="utf-8", newline="") as fh:
            fh.write(text)
        try:
            os.chown(tmp, st.st_uid, st.st_gid)
        except OSError as exc:
            print(f"[ATTENTION] Propriétaire de {path.name} non conservé : {exc}")
        os.chmod(tmp, stat.S_IMODE(st.st_mode))
        os.replace(tmp, path)
    finally:
        tmp.unlink(missing_ok=True)


def backup_syncthing_config(path: Path, dry_run: bool) -> Path:
    """Copie config.xml dans ./backup/ (date + heure)."""
    stamp = dt.datetime.now().strftime("%Y%m%d_%H%M%S")
    target = BACKUP_DIR / f"syncthing_config_{stamp}.xml"
    if dry_run:
        print(f"[DRY-RUN] Sauvegarde simulée : {path} -> {target}")
        return target
    BACKUP_DIR.mkdir(parents=True, exist_ok=True)
    shutil.copy2(path, target)
    print(f"[OK] Sauvegarde créée : {target}")
    return target


def prepare_syncthing(args: argparse.Namespace, name: str, share_path: str,
                      dry_run: bool) -> dict | None:
    """Prépare la modification de config.xml (rien n'est écrit ici)."""
    cfg = Path(args.syncthing_config)
    folder_id = SYNCTHING_ID_PREFIX + name
    try:
        original = read_syncthing_config(cfg)
        built = build_syncthing_config(original, args.syncthing_template_id,
                                       folder_id, name, share_path)
    except (OSError, ValueError, RuntimeError, ET.ParseError) as exc:
        msg = f"Syncthing ({cfg}) : {exc}"
        if dry_run:
            print(f"\n[DRY-RUN][ATTENTION] {msg}")
            return None
        fatal(msg + "\nAucune modification n'a été faite.")
    plan = {"path": cfg, "original": original, "folder_id": folder_id,
            "new_text": None, "block": None, "indent": ""}
    if built is not None:
        plan["new_text"], plan["block"], plan["indent"] = built
    return plan


# --------------------------------------------------------------------------- #
# Relais (SSH)
# --------------------------------------------------------------------------- #
class RelayError(Exception):
    """Erreur d'accès au relai (connexion, droits, fichier, commande distante)."""


RELAY_HOST_RE = re.compile(r"[A-Za-z0-9_][A-Za-z0-9_.:-]*")  # jamais de « - » en tête
RELAY_USER_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_.-]*")


def parse_kv(output: bytes) -> dict[str, str]:
    """Lit les lignes « clé=valeur » renvoyées par un script distant."""
    result: dict[str, str] = {}
    for line in output.decode("utf-8", "replace").splitlines():
        key, sep, value = line.partition("=")
        if sep and re.fullmatch(r"[a-z_]+", key):
            result[key] = value.strip()
    return result


def last_error_line(proc: subprocess.CompletedProcess) -> str:
    lines = proc.stderr.decode("utf-8", "replace").strip().splitlines()
    return lines[-1] if lines else f"code retour {proc.returncode}"


def run_remote(args: argparse.Namespace, host: str, script: str, sudo: bool = False,
               timeout: int = 60) -> subprocess.CompletedProcess:
    """Exécute un script `sh` sur le relai, via SSH (avec sudo si besoin).

    Le script est envoyé sur l'entrée standard de `sh -s` : la commande SSH reste
    constante, donc aucun échappement shell n'est nécessaire côté commande.
    Seules les erreurs SSH (code 255, ssh absent, délai dépassé) lèvent RelayError ;
    le code retour du script est laissé à l'appelant.
    """
    cmd = ["ssh", "-o", "BatchMode=yes", "-o", f"ConnectTimeout={args.ssh_timeout}"]
    if args.relay_ssh_port:
        cmd += ["-p", str(args.relay_ssh_port)]
    if args.relay_ssh_key:
        cmd += ["-i", args.relay_ssh_key]
    for option in args.ssh_option or []:
        cmd += ["-o", option]
    cmd += [f"{args.relay_ssh_user}@{host}", "sudo -n sh -s" if sudo else "sh -s"]
    try:
        proc = subprocess.run(cmd, input=script.encode("utf-8"),
                              capture_output=True, timeout=timeout)
    except FileNotFoundError:
        raise RelayError("commande ssh introuvable (apt install openssh-client)") from None
    except subprocess.TimeoutExpired:
        raise RelayError(f"délai dépassé ({timeout} s)") from None
    if proc.returncode == 255:
        hint = ""
        if b"Host key verification failed" in proc.stderr:
            hint = (" — connectez-vous une première fois à la main (ssh "
                    f"{args.relay_ssh_user}@{host}) pour accepter la clé du serveur, ou ajoutez "
                    "--ssh-option StrictHostKeyChecking=accept-new")
        elif b"Permission denied" in proc.stderr:
            hint = " — l'authentification par clé est requise (aucun mot de passe n'est demandé)"
        raise RelayError(f"connexion SSH impossible : {last_error_line(proc)}{hint}")
    return proc


def build_relay_plan(args: argparse.Namespace, host: str, name: str) -> dict:
    """Teste la connexion SSH puis prépare les modifications du relai (lecture seule)."""
    user = args.relay_ssh_user
    if not RELAY_USER_RE.fullmatch(user):
        raise RelayError(f"compte SSH invalide : {user!r}")
    if not RELAY_HOST_RE.fullmatch(host):
        raise RelayError(f"nom de relai inutilisable pour SSH : {host!r}")
    q = shlex.quote

    # 1. Connexion et droits d'administration (root ou sudo sans mot de passe)
    proc = run_remote(args, host,
                      'echo "uid=$(id -u)"\n'
                      'if sudo -n sh -c true >/dev/null 2>&1; then echo sudo=ok; else echo sudo=no; fi\n')
    info = parse_kv(proc.stdout)
    if proc.returncode != 0 or "uid" not in info:
        raise RelayError(f"connexion SSH établie mais le test des droits a échoué : "
                         f"{last_error_line(proc)}")
    is_root = info["uid"] == "0"
    if not is_root and info.get("sudo") != "ok":
        raise RelayError(
            f"connexion SSH établie, mais {user} n'a pas sudo sans mot de passe sur le relai "
            "(nécessaire pour modifier la config Syncthing et créer le dossier)")
    sudo = not is_root

    # 2. Sonde : fichiers, dossiers, comptes, ACL
    owner_user, _, owner_group = args.share_owner.partition(":")
    owner_group = owner_group or owner_user
    cfg = args.relay_syncthing_config
    root = args.relay_sharing_root
    share_path = posixpath.join(root, name)
    ref = args.acl_from or posixpath.join(root, "global")
    probe = f"""CFG={q(cfg)}
ROOT={q(root)}
DIR={q(share_path)}
REF={q(ref)}
OUSER={q(owner_user)}
OGROUP={q(owner_group)}
if [ -f "$CFG" ]; then echo cfg=ok; else echo cfg=missing; fi
if [ -d "$ROOT" ]; then echo root=ok; else echo root=missing; fi
if [ -d "$DIR" ]; then echo dir=exists; elif [ -e "$DIR" ]; then echo dir=notdir; else echo dir=missing; fi
if getent passwd "$OUSER" >/dev/null 2>&1; then echo user=ok; else echo user=missing; fi
if getent group "$OGROUP" >/dev/null 2>&1; then echo group=ok; else echo group=missing; fi
if [ -d "$REF" ]; then
  echo ref=ok
  case "$(ls -ld "$REF" | cut -d' ' -f1)" in *+) echo refacl=yes ;; *) echo refacl=no ;; esac
else
  echo ref=missing
fi
if command -v getfacl >/dev/null 2>&1 && command -v setfacl >/dev/null 2>&1; then echo acltools=ok; else echo acltools=missing; fi
"""
    proc = run_remote(args, host, probe, sudo=sudo)
    if proc.returncode != 0:
        raise RelayError(f"analyse du relai impossible : {last_error_line(proc)}")
    probed = parse_kv(proc.stdout)
    if probed.get("cfg") != "ok":
        raise RelayError(f"{cfg} introuvable sur le relai (Syncthing y est-il installé ?)")
    if probed.get("dir") == "notdir":
        raise RelayError(f"{share_path} existe sur le relai mais n'est pas un dossier")
    if probed.get("dir") == "missing":
        if probed.get("root") != "ok":
            raise RelayError(f"répertoire de base introuvable sur le relai : {root}")
        if probed.get("user") != "ok":
            raise RelayError(f"utilisateur « {owner_user} » introuvable sur le relai (voir --share-owner)")
        if probed.get("group") != "ok":
            raise RelayError(f"groupe « {owner_group} » introuvable sur le relai (voir --share-owner)")

    # 3. Configuration Syncthing du RELAI : copie de son propre <folder> modèle
    proc = run_remote(args, host, f"cat {q(cfg)}\n", sudo=sudo)
    if proc.returncode != 0:
        raise RelayError(f"lecture de {cfg} impossible : {last_error_line(proc)}")
    raw = proc.stdout
    try:
        text = raw.decode("utf-8")
    except UnicodeDecodeError:
        raise RelayError(f"{cfg} n'est pas en UTF-8") from None
    folder_id = SYNCTHING_ID_PREFIX + name
    try:
        built = build_syncthing_config(text, args.syncthing_template_id, folder_id, name, share_path)
    except (ValueError, RuntimeError, ET.ParseError) as exc:
        raise RelayError(f"configuration Syncthing du relai ({cfg}) : {exc}") from exc

    # 4. Description de ce qui sera fait côté dossier
    if probed.get("ref") != "ok":
        acl_note = f"dossier de référence {ref} absent sur le relai : ACL non copiées"
    elif probed.get("refacl") != "yes":
        acl_note = f"{ref} n'a pas d'ACL étendue sur le relai : rien à copier"
    elif probed.get("acltools") != "ok":
        acl_note = f"ACL de {ref} non copiées : getfacl/setfacl absents du relai (apt install acl)"
    else:
        acl_note = f"ACL copiées de {ref}"
    dir_exists = probed.get("dir") == "exists"
    plan = {
        "args": args, "host": host, "target": f"{user}@{host}", "sudo": sudo,
        "cfg": cfg, "raw": raw, "sha": hashlib.sha256(raw).hexdigest(),
        "folder_id": folder_id, "new_text": None, "block": None, "indent": "",
        "root": root, "share_path": share_path, "ref": ref,
        "owner": f"{owner_user}:{owner_group}", "mode": args.share_mode,
        "dir_exists": dir_exists,
        "dir_rights": ("droits inchangés (dossier déjà présent)" if dir_exists
                       else f"{owner_user}:{owner_group} {args.share_mode}, {acl_note}"),
    }
    if built is not None:
        plan["new_text"], plan["block"], plan["indent"] = built
    return plan


def prepare_relay(args: argparse.Namespace, hostname: str, name: str,
                  dry_run: bool) -> dict | None:
    """Teste la connexion SSH au relai et prépare ses modifications (rien n'est écrit ici).

    Lectures seules, y compris en --dry-run. Si le relai est inaccessible : simple
    avertissement en --dry-run, arrêt avec --yes, sinon question à l'utilisateur.
    """
    if args.skip_relay:
        print("\n[INFO] Relais ignoré (--skip-relay) : ni dossier ni config Syncthing côté relai.")
        return None
    target = f"{args.relay_ssh_user}@{hostname}"
    print(f"\nTest de connexion SSH vers {target} ...")
    try:
        plan = build_relay_plan(args, hostname, name)
    except RelayError as exc:
        msg = f"Relais {target} : {exc}"
        if dry_run:
            print(f"[DRY-RUN][ATTENTION] {msg}")
            return None
        if args.yes:
            fatal(msg + "\nAucune modification n'a été faite "
                        "(--skip-relay pour ne pas configurer le relai).")
        print(f"[ERREUR] {msg}", file=sys.stderr)
        if not ask_yes_no("Continuer sans configurer le relai ?", default=False):
            print("Annulé, rien n'a été modifié.")
            sys.exit(0)
        return None
    how = "root" if not plan["sudo"] else "sudo sans mot de passe"
    print(f"[OK] Connexion SSH établie : {plan['target']} ({how})")
    return plan


def backup_relay_config(plan: dict, dry_run: bool) -> Path:
    """Copie locale (backup/, droits 0600) du config.xml du relai avant modification."""
    stamp = dt.datetime.now().strftime("%Y%m%d_%H%M%S")
    target = BACKUP_DIR / f"syncthing_config_{plan['host']}_{stamp}.xml"
    if dry_run:
        print(f"[DRY-RUN] Sauvegarde simulée : {plan['target']}:{plan['cfg']} -> {target}")
        return target
    BACKUP_DIR.mkdir(parents=True, exist_ok=True)
    fd = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)  # contient la clé API
    with os.fdopen(fd, "wb") as fh:
        fh.write(plan["raw"])
    print(f"[OK] Sauvegarde créée : {target}")
    return target


def relay_create_dir(plan: dict) -> bool:
    """Crée le dossier du partage sur le relai, avec les mêmes droits qu'en local.

    True s'il vient d'être créé. Un dossier déjà présent n'est jamais modifié.
    """
    q = shlex.quote
    script = f"""set -eu
DIR={q(plan['share_path'])}
ROOT={q(plan['root'])}
REF={q(plan['ref'])}
OWNER={q(plan['owner'])}
MODE={q(plan['mode'])}
if [ -d "$DIR" ]; then echo dir=exists; exit 0; fi
if [ -e "$DIR" ]; then echo dir=notdir; exit 2; fi
if [ ! -d "$ROOT" ]; then echo root=missing; exit 2; fi
mkdir "$DIR"
if ! chown "$OWNER" "$DIR" || ! chmod "$MODE" "$DIR"; then rmdir "$DIR"; echo chown=failed; exit 2; fi
if [ -d "$REF" ] && command -v getfacl >/dev/null 2>&1 && command -v setfacl >/dev/null 2>&1; then
  case "$(ls -ld "$REF" | cut -d' ' -f1)" in
    *+) if getfacl -p "$REF" 2>/dev/null | setfacl --set-file=- "$DIR" 2>/dev/null; then echo acl=copied; else echo acl=failed; fi ;;
  esac
fi
echo "mode=$(stat -c %a "$DIR")"
echo "ls=$(ls -ld "$DIR")"
echo dir=created
"""
    proc = run_remote(plan["args"], plan["host"], script, sudo=plan["sudo"])
    info = parse_kv(proc.stdout)
    path = plan["share_path"]
    if proc.returncode != 0:
        if info.get("chown") == "failed":
            raise RelayError(f"chown/chmod {plan['owner']} impossible sur {path} (relai)")
        if info.get("dir") == "notdir":
            raise RelayError(f"{path} existe sur le relai mais n'est pas un dossier")
        if info.get("root") == "missing":
            raise RelayError(f"répertoire de base introuvable sur le relai : {plan['root']}")
        raise RelayError(f"création de {path} impossible sur le relai : {last_error_line(proc)}")
    if info.get("dir") == "exists":
        print(f"[INFO] Relais : dossier déjà présent (droits inchangés) : {path}")
        return False
    if info.get("acl") == "copied":
        print(f"[OK] Relais : ACL copiées de {plan['ref']}")
    elif info.get("acl") == "failed":
        print(f"[ATTENTION] Relais : copie des ACL de {plan['ref']} impossible")
    try:
        if int(info.get("mode", "0"), 8) != int(plan["mode"], 8):
            print(f"[ATTENTION] Relais : droits obtenus {info.get('mode')} au lieu de "
                  f"{plan['mode']} (le masque des ACL copiées remplace les droits du groupe).")
    except ValueError:
        pass
    print(f"[OK] Relais : dossier créé : {path}  ({info.get('ls', '').split(' ', 1)[0]} {plan['owner']})")
    return True


def relay_remove_dir(plan: dict) -> None:
    """Annulation : supprime le dossier créé sur le relai (seulement s'il est vide)."""
    run_remote(plan["args"], plan["host"], f"rmdir {shlex.quote(plan['share_path'])}\n",
               sudo=plan["sudo"])


def relay_write_config(plan: dict, content: bytes, expected_sha: str) -> str:
    """Remplace le config.xml du relai de façon atomique ; retourne le sha256 écrit.

    Refuse d'écrire si le fichier a changé depuis sa lecture (Syncthing l'a peut-être
    réécrit). cp -a conserve propriétaire, droits, ACL et contexte de sécurité.
    """
    q = shlex.quote
    b64 = base64.b64encode(content).decode("ascii")
    body = "\n".join(b64[i:i + 76] for i in range(0, len(b64), 76))
    script = f"""set -eu
CFG={q(plan['cfg'])}
TMP="$CFG.new.$$"
trap 'rm -f "$TMP"' EXIT
cur=$(sha256sum "$CFG" | cut -d' ' -f1)
if [ "$cur" != {q(expected_sha)} ]; then echo cfg=changed; exit 3; fi
cp -a "$CFG" "$TMP"
base64 -d > "$TMP" <<'__B64__'
{body}
__B64__
mv -f "$TMP" "$CFG"
echo "sha=$(sha256sum "$CFG" | cut -d' ' -f1)"
"""
    proc = run_remote(plan["args"], plan["host"], script, sudo=plan["sudo"])
    info = parse_kv(proc.stdout)
    if proc.returncode == 3 and info.get("cfg") == "changed":
        raise RelayError(f"{plan['cfg']} a été modifié sur le relai depuis sa lecture "
                         "(Syncthing tourne-t-il ?) : rien n'a été écrit")
    if proc.returncode != 0:
        raise RelayError(f"écriture de {plan['cfg']} impossible sur le relai : {last_error_line(proc)}")
    written = info.get("sha", "")
    if written != hashlib.sha256(content).hexdigest():
        raise RelayError(f"contrôle d'intégrité de {plan['cfg']} échoué après écriture sur le relai")
    return written


def print_relay_dry_run(relay: dict | None) -> None:
    if relay is None:
        print("[DRY-RUN] Relais : non configuré (ignoré ou connexion impossible, voir plus haut).")
        return
    print(f"[DRY-RUN] Relais {relay['target']} : connexion SSH OK (lectures seules).")
    if relay["dir_exists"]:
        print(f"[DRY-RUN] Relais : dossier {relay['share_path']} déjà présent (droits inchangés).")
    else:
        print(f"[DRY-RUN] Relais : dossier {relay['share_path']} serait créé : {relay['dir_rights']}.")
    if relay["new_text"] is None:
        print(f"[DRY-RUN] Relais : le dossier Syncthing {relay['folder_id']} existe déjà dans "
              f"{relay['cfg']}, rien à ajouter.")
    else:
        print(f"[DRY-RUN] Relais : bloc qui serait ajouté dans {relay['cfg']} (sur le relai) :\n")
        print(relay["indent"] + relay["block"] + "\n")


# --------------------------------------------------------------------------- #
# Insertion
# --------------------------------------------------------------------------- #
def insert_all(conn, cur, data: dict, dry_run: bool, syncthing: dict | None = None,
               relay: dict | None = None) -> None:
    new_id = next_share_id(cur, lock=not dry_run)
    share_params = (
        new_id,
        data["name"],
        data["comment"],
        data["hostname_relay"],  # uri
        data["hostname_relay"],  # ars_name
        data["id_relay"],        # ars_id
        data["share_path"],
    )
    rule_params = (data["order"], data["subject"], data["permission"], new_id)

    if dry_run:
        share_dir = Path(data["share_path"])
        if share_dir.is_dir():
            dir_msg = f"{share_dir} existe déjà (droits inchangés)."
        elif share_dir.parent.is_dir():
            dir_msg = f"{share_dir} serait créé : {data['dir_rights']}."
        else:
            dir_msg = f"{share_dir} ne pourrait PAS être créé (répertoire de base absent)."
        print("\n[DRY-RUN] Dossier : " + dir_msg)
        print("\n[DRY-RUN] Requêtes qui seraient exécutées :\n")
        print(cur.mogrify(SQL_INSERT_SHARE, share_params) + ";\n")
        print(cur.mogrify(SQL_INSERT_RULE, rule_params) + ";\n")
        if syncthing is None:
            print("[DRY-RUN] Syncthing : configuration non analysée (voir l'avertissement plus haut).")
        elif syncthing["new_text"] is None:
            print(f"[DRY-RUN] Syncthing : le dossier {syncthing['folder_id']} existe déjà dans "
                  f"{syncthing['path']}, rien à ajouter.")
        else:
            print(f"[DRY-RUN] Syncthing : bloc qui serait ajouté dans {syncthing['path']} :\n")
            print(syncthing["indent"] + syncthing["block"] + "\n")
        print_relay_dry_run(relay)
        print("[DRY-RUN] Aucune écriture effectuée.")
        return

    created_dir = False
    config_written = False
    relay_dir_created = False
    relay_config_written = None  # sha256 du config.xml du relai tel que nous l'avons écrit
    try:
        # Dossier d'abord : une erreur de droits échoue avant toute écriture en base
        created_dir = ensure_share_dir(Path(data["share_path"]), data["dir_owner"],
                                       data["dir_mode"], data["acl_from"])
        # INSERT IGNORE n'échoue pas en cas de doublon : on vérifie rowcount
        if cur.execute(SQL_INSERT_SHARE, share_params) != 1:
            raise RuntimeError(
                f"Insertion ignorée dans pkgs_shares (id={new_id} ou clé en doublon)."
            )
        if cur.execute(SQL_INSERT_RULE, rule_params) != 1:
            raise RuntimeError(
                "Insertion ignorée dans pkgs_rules_local (clé en doublon ?)."
            )
        if syncthing and syncthing["new_text"]:
            write_syncthing_config(syncthing["path"], syncthing["new_text"])
            config_written = True
        # Relai : tout ce qui reste annulable est fait AVANT le commit SQL
        if relay:
            relay_dir_created = relay_create_dir(relay)
            if relay["new_text"] is not None:
                relay_config_written = relay_write_config(
                    relay, relay["new_text"].encode("utf-8"), relay["sha"])
        conn.commit()
    except Exception as exc:
        conn.rollback()
        if relay_config_written:
            try:
                relay_write_config(relay, relay["raw"], relay_config_written)
                print(f"[INFO] {relay['target']}:{relay['cfg']} restauré (annulation).")
            except RelayError as restore_exc:
                print(f"[ATTENTION] Restauration de {relay['target']}:{relay['cfg']} impossible : "
                      f"{restore_exc} (copie disponible dans backup/).")
        if relay_dir_created:
            try:
                relay_remove_dir(relay)
                print(f"[INFO] Relais : dossier {relay['share_path']} supprimé (annulation).")
            except RelayError as restore_exc:
                print(f"[ATTENTION] Suppression de {relay['share_path']} sur le relai impossible : "
                      f"{restore_exc}")
        if config_written:
            try:
                write_syncthing_config(syncthing["path"], syncthing["original"])
                print(f"[INFO] {syncthing['path']} restauré (annulation).")
            except OSError as restore_exc:
                print(f"[ATTENTION] Restauration de {syncthing['path']} impossible : "
                      f"{restore_exc} (copie disponible dans backup/).")
        if created_dir:
            try:
                Path(data["share_path"]).rmdir()  # seulement s'il est vide
                print(f"[INFO] Dossier {data['share_path']} supprimé (annulation).")
            except OSError:
                pass
        fatal(f"{exc}\nTransaction annulée (rollback). "
              "Une sauvegarde reste disponible dans le dossier backup/.")

    print(f"\n[OK] Partage créé : pkgs_shares.id = {new_id}")
    print(f"[OK] Règle créée  : order={data['order']} subject='{data['subject']}' "
          f"permission='{data['permission']}' -> pkgs_shares_id={new_id}")
    if syncthing and syncthing["new_text"]:
        print(f"[OK] Syncthing : dossier {syncthing['folder_id']} ajouté dans {syncthing['path']}")
        print("[INFO] Redémarrer Syncthing pour le prendre en compte (il réécrit lui-même ce "
              "fichier : modifier la config pendant qu'il tourne peut la faire écraser).")
    elif syncthing:
        print(f"[INFO] Syncthing : {syncthing['folder_id']} déjà présent, configuration inchangée.")
    if relay and relay_config_written:
        print(f"[OK] Relais : dossier {relay['folder_id']} ajouté dans {relay['target']}:{relay['cfg']}")
        print("[INFO] Redémarrer Syncthing sur le relai aussi (même risque d'écrasement du fichier).")
    elif relay:
        print(f"[INFO] Relais : {relay['folder_id']} déjà présent dans la config Syncthing, inchangée.")


# --------------------------------------------------------------------------- #
# Programme principal
# --------------------------------------------------------------------------- #
def octal_mode(value: str) -> str:
    if not re.fullmatch(r"[0-7]{3,4}", value):
        raise argparse.ArgumentTypeError("mode octal attendu (ex. 755)")
    return value


def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(
        description="Crée un partage de packages lié à un relai "
                    "(mode interactif par défaut).",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )
    p.add_argument("--dry-run", action="store_true",
                   help="simule les actions (sauvegarde + INSERT) sans rien écrire")
    p.add_argument("-y", "--yes", action="store_true",
                   help="ne pas demander la confirmation finale")

    g = p.add_argument_group("réponses (sinon demandées en interactif)")
    g.add_argument("--name", help="nom public du partage (espaces permis) : repris tel quel en commentaire ; "
                        "name et dossier : espaces -> '_' et minuscules (vide = nom du relai)")
    g.add_argument("--relay-id", type=int, help="id du relai (xmppmaster.relayserver.id)")
    g.add_argument("--order", type=int, help="ordre de la règle")
    g.add_argument("--subject", help="sujet de la règle ('.*' = tout le monde, ou un utilisateur)")
    g.add_argument("--permission", choices=VALID_PERMISSIONS,
                   help="r = lecture seule, rw = lecture/écriture")
    p.add_argument("--sharing-root", default=DEFAULT_SHARING_ROOT,
                   help="répertoire parent des partages (share_path = <répertoire>/<nom>)")

    dr = p.add_argument_group("droits du dossier créé (un dossier déjà présent n'est jamais modifié)")
    dr.add_argument("--share-owner", default=DEFAULT_SHARE_OWNER, metavar="USER[:GROUP]",
                    help="propriétaire et groupe du dossier créé")
    dr.add_argument("--share-mode", default=DEFAULT_SHARE_MODE, type=octal_mode, metavar="OCTAL",
                    help="droits du dossier créé")
    dr.add_argument("--acl-from", metavar="DOSSIER",
                    help="dossier dont les ACL sont copiées sur le nouveau "
                         "(défaut : <sharing-root>/global)")

    rl = p.add_argument_group("relais (SSH)")
    rl.add_argument("--skip-relay", action="store_true",
                    help="ne pas configurer le relai (aucune connexion SSH)")
    rl.add_argument("--relay-ssh-user", default="medulla", metavar="COMPTE",
                    help="compte SSH sur le relai (clé requise, sudo sans mot de passe)")
    rl.add_argument("--relay-ssh-port", type=int, metavar="PORT", help="port SSH du relai")
    rl.add_argument("--relay-ssh-key", metavar="FICHIER", help="clé privée SSH à utiliser")
    rl.add_argument("--ssh-option", action="append", metavar="OPTION",
                    help="option SSH supplémentaire passée à -o (répétable), "
                         "ex. StrictHostKeyChecking=accept-new")
    rl.add_argument("--ssh-timeout", type=int, default=10, metavar="SECONDES",
                    help="délai de connexion SSH")
    rl.add_argument("--relay-syncthing-config", default=DEFAULT_SYNCTHING_CONFIG,
                    help="config.xml de Syncthing sur le relai")
    rl.add_argument("--relay-sharing-root", default=DEFAULT_SHARING_ROOT,
                    help="répertoire parent des partages sur le relai")

    sy = p.add_argument_group("Syncthing")
    sy.add_argument("--syncthing-config", default=DEFAULT_SYNCTHING_CONFIG,
                    help="fichier config.xml de Syncthing")
    sy.add_argument("--syncthing-template-id", default=SYNCTHING_TEMPLATE_ID,
                    help="id du <folder> copié comme modèle")

    d = p.add_argument_group("connexion SQL")
    d.add_argument("--db-host", help="hôte SQL (défaut : ini ou localhost)")
    d.add_argument("--db-port", type=int, help="port SQL (défaut : ini ou 3306)")
    d.add_argument("--db-user", help="utilisateur SQL (défaut : ini)")
    d.add_argument("--db-password",
                   help="mot de passe SQL (préférer la variable PKGS_DB_PASSWORD)")
    return p.parse_args()


def main() -> None:
    args = parse_args()
    dry_run = args.dry_run

    if dry_run:
        print("=== MODE DRY-RUN : aucune modification ne sera effectuée ===")

    settings = load_db_settings(args)
    conn = connect(settings)
    cur = conn.cursor()

    print("\n=== Création d'un partage de packages pour un relai ===\n")

    # 1 : nom public du partage (le commentaire reprendra cette même réponse)
    if args.name is not None:
        name_input = args.name.strip()
        error = validate_share_name(name_input)
        if error:
            fatal(f"--name « {name_input} » invalide : {error}.")
    else:
        name_input = ask_share_name()

    # 3 : relai
    relay = choose_relay(cur, args.relay_id)
    id_relay = relay["id"]
    hostname_relay = relay["nameserver"]
    comment = name_input or hostname_relay.strip()  # 1ère réponse, telle que saisie
    error = validate_share_name(comment)
    if error or not comment:
        fatal(f"Nom de partage « {comment} » invalide ({error or 'vide'}). "
              "Relancez en saisissant explicitement un nom valide.")
    name = slugify_share_name(comment)  # name, dossier, share_path : '_' et minuscules
    share_path = str(Path(args.sharing_root) / name)  # /var/lib/pulse2/packages/sharing/<nom>

    root = Path(args.sharing_root)
    if not root.is_dir():
        msg = (f"Répertoire de base introuvable : {root} "
               "(le script doit tourner sur le serveur qui héberge les partages).")
        if dry_run:
            print(f"\n[DRY-RUN][ATTENTION] {msg}")
        else:
            fatal(msg)

    # Droits du dossier créé : propriétaire, mode, ACL (échoue tôt, avant toute écriture)
    owner_user, _, owner_group = args.share_owner.partition(":")
    owner_label = f"{owner_user}:{owner_group or owner_user}"
    dir_mode = int(args.share_mode, 8)
    acl_from = Path(args.acl_from) if args.acl_from else root / "global"
    dir_owner = None
    if Path(share_path).is_dir():
        dir_rights = "droits inchangés (dossier déjà présent)"
    else:
        try:
            dir_owner = resolve_owner(args.share_owner)
        except RuntimeError as exc:
            msg = f"{exc} (voir --share-owner)."
            if dry_run:
                print(f"\n[DRY-RUN][ATTENTION] {msg}")
            else:
                fatal(msg + "\nAucune modification n'a été faite.")
        dir_rights = f"{owner_label} {args.share_mode}, {reference_acl(acl_from)[1]}"

    # Syncthing : prépare la copie du <folder> modèle (échoue tôt, avant toute écriture)
    syncthing = prepare_syncthing(args, name, share_path, dry_run)

    # Relais : test SSH puis lecture de sa config Syncthing (échoue tôt, avant toute écriture)
    relay = prepare_relay(args, hostname_relay, name, dry_run)

    # 4 : ordre
    order = choose_order(cur, args.order)

    # 5 : sujet
    print("Sujet de la règle : '.*' pour tout le monde, ou le nom d'un utilisateur.")
    subject = args.subject if args.subject is not None else ask(
        "Sujet", default=DEFAULT_SUBJECT)

    # 6 : permission
    if args.permission:
        permission = args.permission
    else:
        while True:
            permission = ask("Permission : rw (lecture/écriture) ou r (lecture seule)").lower()
            if permission in VALID_PERMISSIONS:
                break
            print("  -> Valeurs acceptées : r ou rw.")

    data = {
        "name": name,
        "comment": comment,
        "id_relay": id_relay,
        "hostname_relay": hostname_relay,
        "order": order,
        "subject": subject,
        "permission": permission,
        "share_path": share_path,
        "dir_owner": dir_owner,
        "dir_mode": dir_mode,
        "acl_from": acl_from,
        "dir_rights": dir_rights,
    }

    # Avertissement si un partage du même nom existe déjà
    cur.execute("SELECT id, ars_name FROM pkgs.pkgs_shares WHERE name = %s OR share_path = %s",
                (name, share_path))
    existing = cur.fetchall()
    if existing:
        print(f"\n[ATTENTION] Un partage de même nom ou de même chemin existe déjà : "
              + ", ".join(f"id={e['id']} (relai {e['ars_name']})" for e in existing))

    # Récapitulatif
    print("\n--- Récapitulatif ---")
    print(f"  Nom (name)   : {name}")
    print(f"  Commentaire  : {comment}")
    print(f"  Relai        : {hostname_relay} (id {id_relay})")
    print(f"  Chemin       : {share_path} "
          f"({'dossier existant' if Path(share_path).is_dir() else 'dossier à créer'})")
    print(f"  Droits       : {dir_rights}")
    if relay is None:
        print("  Relais       : " + ("ignoré (--skip-relay)" if args.skip_relay
                                     else "NON configuré (connexion impossible)"))
    else:
        print(f"  Relais       : {relay['target']} (connexion SSH OK)")
        print(f"    Dossier    : {relay['share_path']} ({relay['dir_rights']})")
        print("    Syncthing  : " + (
            f"{relay['folder_id']} déjà présent dans {relay['cfg']} (inchangé)"
            if relay["new_text"] is None
            else f"ajout du dossier {relay['folder_id']} dans {relay['cfg']}"))
    if syncthing is None:
        print("  Syncthing    : non analysé (config illisible)")
    elif syncthing["new_text"] is None:
        print(f"  Syncthing    : {syncthing['folder_id']} déjà présent dans {syncthing['path']} (inchangé)")
    else:
        print(f"  Syncthing    : ajout du dossier {syncthing['folder_id']} dans {syncthing['path']}")
    print(f"  Prochain id  : {next_share_id(cur)} (pkgs_shares)")
    print(f"  Règle        : order={order}, subject='{subject}', permission='{permission}'")
    print("---------------------\n")

    if not dry_run and not args.yes:
        if not ask_yes_no("Confirmer la création ?", default=False):
            print("Annulé, rien n'a été modifié.")
            conn.close()
            return

    # Sauvegarde puis insertions
    backup_tables(settings, dry_run)
    if syncthing and syncthing["new_text"]:
        backup_syncthing_config(syncthing["path"], dry_run)
    if relay and relay["new_text"] is not None:
        backup_relay_config(relay, dry_run)
    insert_all(conn, cur, data, dry_run, syncthing, relay)

    cur.close()
    conn.close()


if __name__ == "__main__":
    try:
        main()
    except (KeyboardInterrupt, EOFError):
        print("\nInterrompu, rien n'a été modifié.")
        sys.exit(130)
