#!/usr/bin/env python3
"""La reconstruction REMET l'etat d'avant — et chaque detenteur d'etat sait le faire.

POURQUOI (2026-09-30). Technolibre a ete reconstruite, 0 echec, `make valider` vert — et
rien n'etait revenu : ni l'annuaire (le mot de passe de `sysadmin` etait celui de
l'amorcage), ni la racine de l'AC, ni les bases, ni Nextcloud. « Restauration verifiee »
voulait dire « restauree dans un repertoire temporaire, lue, jetee ».

Ce test verifie deux choses :

1. COUVERTURE (statique). Chaque groupe detenteur d'etat (`client_backup_groupes_etat`)
   inclut `restaurer.yml` depuis son propre role. Une liste qui en suit une autre prend du
   retard : ajouter un detenteur d'etat sans son point de restauration doit echouer ICI.

2. L'OUTIL DE NOEUD (`setops-restaurer`), rendu depuis son vrai gabarit, avec `restic`,
   `psql` & co. remplaces par des doublures :
   - le candidat est le dernier instantane ANTERIEUR a la naissance de la machine ;
   - un repertoire non vide n'est jamais ecrase sans `--remplacer` ;
   - la sauvegarde refuse de deposer tant qu'un etat d'avant attend (code 3), et
     reprend une fois chaque jeu acte ; un depot inexistant = premiere vie (« neuf ») ;
   - la section d'une base s'arrete avant le `DROP DATABASE postgres;` que `pg_dumpall
     --clean` place apres la derniere base (le piege du runbook, rencontre le 2026-09-30).
"""
from __future__ import annotations

import json
import os
import stat
import subprocess
import sys
import tempfile
from pathlib import Path

import jinja2
import yaml

RACINE = Path(__file__).resolve().parents[2]
GABARIT = RACINE / "roles/client_backup/templates/restaurer.sh.j2"
SAUVEGARDE = RACINE / "roles/client_backup/templates/sauvegarder.sh.j2"
COMPARATEUR = RACINE / "roles/client_backup/files/setops-temoins.py"

ECHECS: list[str] = []


def verifier(cond: bool, msg: str) -> None:
    print(("OK     " if cond else "ECHEC  ") + msg)
    if not cond:
        ECHECS.append(msg)


# --- 1. Couverture -------------------------------------------------------------------

def couverture() -> None:
    groupes = yaml.safe_load((RACINE / "roles/client_backup/vars/main.yml").read_text())[
        "client_backup_groupes_etat"]
    for g in groupes:
        taches = RACINE / "roles" / g / "tasks"
        texte = "".join(p.read_text() for p in sorted(taches.glob("*.yml"))) if taches.is_dir() else ""
        verifier(f"client_backup_restaurer_jeu: {g}" in texte,
                 f"{g} inclut son point de restauration (restaurer.yml)")
    verifier("{#" not in GABARIT.read_text(), "le gabarit ne contient aucune sequence accolade-diese")

    # UN ICINGA NEUF ENTEND LE NOEUD TOUT DE SUITE (2026-09-30) : sinon `restauration` reste
    # rouge jusqu'au dimanche apres chaque reconstruction.
    # PAS SUR LA COPIE DE L'AC : `client_sante` la depose aussi, plus tot — sur une flotte
    # neuve elle ne change donc jamais ici (reconstruction de Chezlepro, 2026-09-30).
    taches = yaml.safe_load((RACINE / "roles/client_backup/tasks/verifier.yml").read_text())
    notifiants = [t.get("name", "") for t in taches if t.get("notify") == "Premier rapport a Icinga"]
    verifier(notifiants and all("AC d'Icinga pour la" not in n for n in notifiants)
             and any("jamais entendus" in n for n in notifiants),
             "le premier rapport part d'un marqueur propre a client_backup, pas de la copie partagee de l'AC")
    gest = yaml.safe_load((RACINE / "roles/client_backup/handlers/main.yml").read_text())
    ecoute = [g for g in gest if g.get("listen") == "Premier rapport a Icinga"]
    ordre = [g.get("ansible.builtin.systemd", {}).get("name", "marqueur") for g in ecoute]
    verifier(ordre == ["setops-sauvegarde.service", "setops-verification-depot.service",
                       "setops-verification-restauration.service", "marqueur"],
             f"premier rapport : deposer, verifier le depot, la restauration, PUIS retenir ({ordre})")


# --- 2. L'outil de noeud, avec des doublures ------------------------------------------

def executable(chemin: Path, texte: str) -> None:
    chemin.write_text(texte)
    chemin.chmod(chemin.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)


DUMP = r"""--
DROP DATABASE nextcloud;
DROP DATABASE keycloak;
CREATE DATABASE keycloak WITH TEMPLATE = template0 ENCODING = 'UTF8' LOCALE = 'fr_CA.UTF-8';
ALTER DATABASE keycloak OWNER TO keycloak;
\connect keycloak
CREATE TABLE realm (id text);
COPY realm FROM stdin;
\.
CREATE DATABASE nextcloud WITH TEMPLATE = template0 ENCODING = 'UTF8' LOCALE = 'fr_CA.UTF-8';
ALTER DATABASE nextcloud OWNER TO nextcloud;
\connect nextcloud
CREATE TABLE oc_users (uid text);
REVOKE CONNECT,TEMPORARY ON DATABASE nextcloud FROM PUBLIC;
DROP DATABASE postgres;
CREATE DATABASE postgres WITH TEMPLATE = template0;
\connect postgres
"""


def outil() -> None:
    with tempfile.TemporaryDirectory() as d:
        d = Path(d)
        bin_, fixt, log = d / "bin", d / "instantanes", d / "journal"
        for p in (bin_, fixt, log):
            p.mkdir()
        cle = d / "ssh_host_ed25519_key.pub"
        cle.write_text("cle\n")                         # nee MAINTENANT
        staging = d / "staging"

        # Deux instantanes : l'un d'AVANT la naissance, l'autre d'apres (l'etat neuf).
        avant, apres = fixt / "avant01", fixt / "apres02"
        for snap, contenu in ((avant, "ancien"), (apres, "neuf")):
            (snap / str(d / "vmail").lstrip("/") / "boite").mkdir(parents=True)
            (snap / str(d / "vmail").lstrip("/") / "boite" / "msg").write_text(contenu)
            dump = snap / str(staging).lstrip("/") / "postgresql" / "toutes-bases.sql"
            dump.parent.mkdir(parents=True)
            dump.write_text(DUMP)
        # Le troisieme, etiquete au rasage, est PLUS ANCIEN que le candidat : les temoins
        # doivent le choisir quand meme (c'est l'etiquette qui designe, pas l'heure).
        rasage = fixt / "rasage03" / str(d / "vmail").lstrip("/") / "boite" / "cur"
        rasage.mkdir(parents=True)
        (rasage / "1700.M1.h:2,S").write_text("le courriel d'avant")
        snaps = [
            {"short_id": "rasage03", "id": "rasage03" + "0" * 56, "time": "2026-09-29T10:00:00-04:00",
             "tags": ["setops", "avant-raser"]},
            {"short_id": "avant01", "id": "avant01" + "0" * 56, "time": "2026-09-29T23:50:50.123456789-04:00",
             "tags": ["setops"]},
            {"short_id": "apres02", "id": "apres02" + "0" * 56, "time": "2099-01-01T00:00:00Z", "tags": ["setops"]},
        ]
        (d / "snapshots.json").write_text(json.dumps(snaps))

        # restic : `snapshots --json` et `restore ID --target T --include P...`.
        # SETOPS_TEST_DEPOT_ABSENT=1 imite restic 0.17+ face a un depot inexistant (code 10).
        executable(bin_ / "restic", f"""#!/bin/bash
if [[ -n "${{SETOPS_TEST_DEPOT_ABSENT:-}}" ]]; then exit 10; fi
# L'outil passe `--retry-lock <duree>` avant la sous-commande (74) : on l'exige, puis on le saute.
[[ "$1" == --retry-lock && -n "$2" ]] || {{ echo "restic appele sans --retry-lock : $*" >&2; exit 99; }}
shift 2
case "$1" in
  snapshots)
    etiquette=""
    while (( $# )); do [[ "$1" == --tag ]] && etiquette="$2"; shift; done
    python3 -c 'import json, sys; e = sys.argv[2]
print(json.dumps([x for x in json.load(open(sys.argv[1])) if not e or e in x.get("tags", [])]))' \
      "{d}/snapshots.json" "$etiquette" ;;
  restore)
    id="$2"; shift 2; cible=""; inc=()
    while (( $# )); do case "$1" in --target) cible="$2"; shift 2;; --include) inc+=("$2"); shift 2;; *) shift;; esac; done
    for i in "${{inc[@]}}"; do
      [[ -e "{fixt}/$id$i" ]] || continue
      mkdir -p "$cible$(dirname "$i")"; cp -a "{fixt}/$id$i" "$cible$(dirname "$i")/"
    done ;;
esac
""")
        # PostgreSQL : on journalise, on garde la section rejouee ; toute base est vierge.
        executable(bin_ / "runuser", '#!/bin/bash\nwhile [[ "$1" != "--" ]]; do shift; done; shift; exec "$@"\n')
        # Sans `-c`, psql lit la section sur son entree standard : c'est ainsi que l'outil
        # doit la lui passer (`postgres` ne lit pas le repertoire jetable de root).
        executable(bin_ / "psql", f"""#!/bin/bash
echo "psql $*" >> "{log}/pg"
avec_c=0
while (( $# )); do
  case "$1" in -f) echo "psql -f INTERDIT" >> "{log}/pg"; shift 2;; -c) avec_c=1; [[ "$2" == select* ]] && echo 0; shift 2;; *) shift;; esac
done
if (( ! avec_c )); then cat > "{log}/section.sql"; fi
""")
        executable(bin_ / "pg_dump", '#!/bin/bash\necho dump\n')
        executable(bin_ / "dropdb", f'#!/bin/bash\necho "dropdb $*" >> "{log}/pg"\n')

        executable(bin_ / "setops-temoins", f'#!/bin/bash\nexec python3 "{COMPARATEUR}" "$@"\n')

        def rendre(nom: str, jeux: list[dict]) -> Path:
            rendu = jinja2.Environment(undefined=jinja2.StrictUndefined).from_string(
                GABARIT.read_text()).render(
                client_backup_repo="sftp:restic@depot:hote",
                inventory_hostname="hote",
                client_backup_restauration_marques=str(d / "marques"),
                client_backup_restauration_mise_de_cote=str(d / "mis-de-cote"),
                client_backup_staging=str(staging),
                client_backup_jobs=jeux,
                client_backup_attente_verrou="30m",
                client_backup_etiquette_avant_raser="avant-raser",
            ).replace("/etc/ssh/ssh_host_ed25519_key.pub", str(cle)) \
             .replace("/etc/setops/restic.pass", str(d / "restic.pass")) \
             .replace("/usr/local/sbin/setops-temoins", str(bin_ / "setops-temoins"))
            executable(d / nom, rendu)
            return d / nom

        vmail_jeu = {"nom": "courriel", "chemins": [str(d / "vmail")]}
        script = rendre("setops-restaurer", [vmail_jeu, {"nom": "postgresql", "chemins": [str(staging / "postgresql")]}])
        env = {**os.environ, "PATH": f"{bin_}:{os.environ['PATH']}"}

        def lancer(*args: str, outil: Path = script, **extra: str) -> subprocess.CompletedProcess:
            return subprocess.run(["bash", str(outil), *args], env={**env, **extra},
                                  capture_output=True, text=True)

        r = lancer("choisir")
        verifier(r.returncode == 0 and json.loads(r.stdout)["instantane"] == "avant01",
                 f"le candidat est l'instantane d'AVANT la naissance, pas l'etat neuf ({r.stdout.strip() or r.stderr.strip()})")

        r = lancer("garde")
        verifier(r.returncode == 3, f"la sauvegarde refuse tant qu'un etat d'avant attend (code {r.returncode})")

        vmail = d / "vmail"
        (vmail / "neuf").mkdir(parents=True)
        (vmail / "neuf" / "x").write_text("x")
        r = lancer("fichiers", str(vmail))
        verifier(r.returncode != 0 and (vmail / "neuf" / "x").exists(),
                 "un repertoire non vide n'est pas ecrase sans --remplacer")

        r = lancer("fichiers", "--remplacer", str(vmail))
        verifier(r.returncode == 0 and (vmail / "boite" / "msg").read_text() == "ancien"
                 and not (vmail / "neuf").exists(),
                 f"--remplacer remet l'etat d'avant, a l'identique ({r.stdout.strip() or r.stderr.strip()})")
        verifier(any((d / "mis-de-cote").rglob("x")), "l'etat ecrase a ete mis de cote")

        # LES TEMOINS (2026-10-07) : l'instantane etiquete au rasage, pas le candidat.
        seul_courriel = rendre("setops-restaurer-courriel", [vmail_jeu])
        r = lancer("temoins", outil=seul_courriel)
        verifier(r.returncode == 1 and "instantane rasage03" in r.stdout and "perdu : boite/msg/1700.M1.h" in r.stdout,
                 f"les temoins comparent a l'instantane etiquete au rasage, et voient le courriel perdu "
                 f"(code {r.returncode}) {r.stdout.strip()[-200:] or r.stderr.strip()[-200:]}")
        r = lancer("temoins", "--candidat", outil=seul_courriel)
        verifier(r.returncode == 0 and "instantane avant01" in r.stdout,
                 f"--candidat compare au candidat, que la restauration a remis a l'identique ({r.stdout.strip()[-160:]})")
        r = lancer("temoins", outil=rendre("setops-restaurer-vide", []))
        verifier(r.returncode == 4 and "SANS OBJET" in r.stdout, "un noeud sans etat : rien a comparer (code 4)")

        r = lancer("base", "nextcloud")
        section = (log / "section.sql").read_text() if (log / "section.sql").exists() else ""
        verifier(r.returncode == 0 and "oc_users" in section, f"la section nextcloud est rejouee ({r.stderr.strip()[:120]})")
        verifier("DROP DATABASE" not in section and "realm" not in section,
                 "la section s'arrete avant le DROP DATABASE postgres, et ne deborde sur aucune autre base")
        pg = (log / "pg").read_text()
        verifier("--single-transaction" in pg, "la base est rejouee en une seule transaction")
        verifier("INTERDIT" not in pg, "la section passe par l'entree standard, jamais par `psql -f`")

        r = lancer("base", "inexistante")
        verifier(r.returncode == 0 and "ABSENTE" in r.stdout, "une base absente de l'instantane est dite, pas inventee")

        lancer("acter", "courriel", "restaure", "chasse09")
        lancer("acter", "postgresql", "restaure", "avant01")
        r = lancer("garde")
        verifier(r.returncode == 0, "la sauvegarde reprend une fois chaque jeu acte")

        # LE BILAN DIT CE QUI A ETE RESTAURE, ET S'IL EST ENCORE AU DEPOT (2026-10-07).
        r = lancer("etat")
        verifier("jeu courriel : etat=restaure instantane=chasse09" in r.stdout and "(RETIRE du depot)" in r.stdout,
                 "un instantane restaure puis chasse du depot est dit RETIRE")
        verifier("instantane=avant01" in r.stdout and "(au depot)" in r.stdout, "un instantane encore la est dit au depot")
        verifier("avant-raser: rasage03" in r.stdout and "lancee maintenant" in r.stdout,
                 "le bilan nomme l'instantane d'avant rasage, et dit que le candidat est calcule maintenant")

        for f in (d / "marques").iterdir():
            f.unlink()
        r = lancer("garde", SETOPS_TEST_DEPOT_ABSENT="1")
        marques = sorted(p.name for p in (d / "marques").iterdir())
        verifier(r.returncode == 0 and marques == ["courriel", "postgresql"]
                 and "etat=neuf" in (d / "marques" / "courriel").read_text(),
                 "depot inexistant = premiere vie : chaque jeu est acte « neuf »")


# --- 3. Le depot d'avant rasage (2026-10-07) ---------------------------------------------

def sauvegarde() -> None:
    """`--avant-raser` etiquette le depot ; l'etiquette passe du precedent au nouveau ; la
    retention la garde toujours. A M4, le premier depot d'apres reconstruction avait chasse
    l'instantane d'avant par `--keep-daily` : plus rien a quoi comparer l'etat remis."""
    with tempfile.TemporaryDirectory() as d:
        d = Path(d)
        bin_ = d / "bin"
        bin_.mkdir()
        (d / "vmail").mkdir()
        journal = d / "restic.log"
        # Deux instantanes etiquetes : l'ancien rasage, et celui qui vient d'etre depose.
        etiquetes = [{"id": "ancien" + "0" * 58, "time": "2026-10-01T10:00:00-04:00"},
                     {"id": "nouveau" + "0" * 57, "time": "2026-10-07T11:34:44-04:00"}]
        (d / "etiquetes.json").write_text(json.dumps(etiquetes))
        executable(bin_ / "restic", f"""#!/bin/bash
[[ "$1" == --retry-lock ]] && shift 2
echo "$*" >> "{journal}"
if [[ "$1" == snapshots && "$*" == *--json* ]]; then cat "{d}/etiquetes.json"; fi
exit 0
""")
        executable(bin_ / "setops-restaurer", "#!/bin/bash\nexit 0\n")
        rendu = jinja2.Environment(undefined=jinja2.StrictUndefined).from_string(
            SAUVEGARDE.read_text()).render(
            client_backup_repo="sftp:restic@depot:hote", inventory_hostname="hote",
            client_backup_attente_verrou="30m", client_backup_staging=str(d / "staging"),
            client_backup_jobs=[{"nom": "courriel", "chemins": [str(d / "vmail")]}],
            client_backup_retention="--keep-daily 7", client_backup_etiquette_avant_raser="avant-raser",
        ).replace("/usr/local/sbin/setops-restaurer", str(bin_ / "setops-restaurer"))
        script = d / "setops-sauvegarder.sh"
        executable(script, rendu)
        env = {**os.environ, "PATH": f"{bin_}:{os.environ['PATH']}"}

        def lancer(*args: str) -> list[str]:
            journal.unlink(missing_ok=True)
            r = subprocess.run(["bash", str(script), *args], env=env, capture_output=True, text=True)
            verifier(r.returncode == 0, f"la sauvegarde {' '.join(args) or 'ordinaire'} aboutit ({r.stderr.strip()[-160:]})")
            return journal.read_text().splitlines() if journal.exists() else []

        appels = lancer("--avant-raser")
        backup = next((a for a in appels if a.startswith("backup ")), "")
        verifier("--tag avant-raser" in backup, f"le depot d'avant rasage est etiquete ({backup})")
        retrait = [a for a in appels if a.startswith("tag ")]
        verifier(retrait == ["tag --remove avant-raser " + etiquetes[0]["id"]],
                 f"l'etiquette est retiree au precedent, et a lui seul ({retrait})")
        verifier(appels.index(backup) < appels.index(retrait[0]) if retrait else False,
                 "l'etiquette n'est retiree qu'APRES le nouveau depot")
        forget = next((a for a in appels if a.startswith("forget ")), "")
        verifier("--keep-tag avant-raser" in forget, f"la retention garde l'etiquette ({forget})")

        appels = lancer()
        backup = next((a for a in appels if a.startswith("backup ")), "")
        verifier("avant-raser" not in backup and not any(a.startswith("tag ") for a in appels),
                 "un depot ordinaire n'est pas etiquete et ne touche pas l'etiquette")
        forget = next((a for a in appels if a.startswith("forget ")), "")
        verifier("--keep-tag avant-raser" in forget,
                 "un depot ordinaire garde lui aussi l'instantane d'avant rasage (c'est lui qui le chassait)")


def main() -> int:
    couverture()
    outil()
    sauvegarde()
    if ECHECS:
        print(f"\n{len(ECHECS)} echec(s).")
        return 1
    print("\nLa restauration est couverte et l'outil se comporte comme annonce.")
    return 0


if __name__ == "__main__":
    sys.exit(main())