#!/usr/bin/python3
# Sauvegarde vérifiée (Centre KemmOS 1.15.0) : relit pour de vrai quelques fichiers de la dernière sauvegarde
# Déjà Dup et les compare aux originaux (seulement des fichiers qui n'ont pas changé depuis la sauvegarde).
# Une sauvegarde jamais relue peut être illisible (disque abîmé, mot de passe perdu…) : on le découvre ici,
# pas le jour où on en a besoin.
#  - moteurs : restic et duplicity (les deux moteurs de Déjà Dup) ; emplacements : disque externe (Drive) et
#    dossier (Local) — pas les sauvegardes en ligne (Google, OneDrive, serveur), signalées « non vérifiable » ;
#  - mot de passe : celui que Déjà Dup garde dans le trousseau (secret-tool) ;
#  - résultat : ~/.local/state/kemmos/sauvegarde-verifiee.json, affiché par le Centre (Tableau de bord) ;
#    échec signalé par une notification.
#  « verif-sauvegarde » : vérifie maintenant ; « --surveiller » (autostart) : vérifie une minute après chaque
#  sauvegarde Déjà Dup, au plus une fois tous les 30 jours (ou tout de suite si la dernière vérification a échoué).
import gettext
import hashlib
import json
import os
import random
import re
import shutil
import subprocess
import sys
import tempfile
import time

from gi.repository import Gio, GLib


class _Francais(gettext.NullTranslations):
    def ngettext(self, singulier, pluriel, n):
        return singulier if n < 2 else pluriel


def _traduction(domaine):
    code = "fr"
    for var in ("LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"):
        v = os.environ.get(var, "")
        if v:
            code = v.split(":")[0].split(".")[0].split("@")[0].split("_")[0] or "fr"
            break
    if code in ("C", "POSIX"):
        code = "fr"
    if code == "fr":
        return _Francais(), code
    t = gettext.translation(domaine, os.environ.get("KEMMOS_LOCALE", "/usr/share/locale"),
                            languages=["br" if code == "br" else "en"], fallback=True)
    t.add_fallback(_Francais())
    return t, code


_trad, LANGUE = _traduction("kemmos-centre")
_, ngettext = _trad.gettext, _trad.ngettext

ETAT = os.path.join(GLib.get_user_state_dir(), "kemmos", "sauvegarde-verifiee.json")
ECHANTILLON = 5                 # fichiers relus
TAILLE_MAX = 50 * 1024 ** 2     # fichiers de plus de 50 Mo écartés (relecture trop longue)
INTERVALLE = 30 * 86400


def lire_etat():
    try:
        with open(ETAT) as f:
            return json.load(f)
    except (OSError, ValueError):
        return {}


def ecrire_etat(etat):
    os.makedirs(os.path.dirname(ETAT), exist_ok=True)
    with open(ETAT + ".tmp", "w") as f:
        json.dump(etat, f)
    os.replace(ETAT + ".tmp", ETAT)


def reglages(schema):
    source = Gio.SettingsSchemaSource.get_default()
    return Gio.Settings.new(schema) if source and source.lookup(schema, True) else None


def developper(dossier):
    return (dossier.replace("$HOSTNAME", GLib.get_host_name()).replace("$USER", GLib.get_user_name())
            .strip("/") if dossier else "")


def emplacement():
    """(chemin du dépôt de sauvegarde, message) — chemin None si non vérifiable ou disque absent."""
    dd = reglages("org.gnome.DejaDup")
    if dd is None:
        return None, _("Déjà Dup n'est pas installé")
    genre = dd.get_string("backend")
    if genre == "drive":
        d = reglages("org.gnome.DejaDup.Drive")
        uuid, dossier = d.get_string("uuid"), developper(d.get_string("folder"))
        for vol in Gio.VolumeMonitor.get().get_volumes():
            if vol.get_uuid() == uuid or vol.get_identifier("uuid") == uuid:
                m = vol.get_mount()
                if m is None:
                    return None, _("Disque de sauvegarde non monté")
                return os.path.join(m.get_root().get_path(), dossier), ""
        return None, _("Disque de sauvegarde non branché")
    if genre == "local":
        dossier = reglages("org.gnome.DejaDup.Local").get_string("folder")
        dossier = dossier.replace("$HOSTNAME", GLib.get_host_name())
        chemin = dossier if os.path.isabs(dossier) else os.path.join(os.path.expanduser("~"), dossier)
        return (chemin, "") if os.path.isdir(chemin) else (None, _("Dossier de sauvegarde introuvable"))
    if genre in ("google", "microsoft", "remote", "rclone"):
        return None, _("Sauvegarde en ligne : vérification non prise en charge")
    return None, _("Aucune sauvegarde configurée")


def outil(chemin):
    """restic ou duplicity, d'après le contenu du dépôt."""
    if os.path.exists(os.path.join(chemin, "config")) and os.path.isdir(os.path.join(chemin, "snapshots")):
        return "restic"
    try:
        if any(n.startswith("duplicity-") for n in os.listdir(chemin)):
            return "duplicity"
    except OSError:
        pass
    return None


def mot_de_passe():
    """Mot de passe de Déjà Dup (trousseau GNOME), "" si les sauvegardes ne sont pas chiffrées."""
    try:
        return subprocess.run(["secret-tool", "lookup", "owner", "deja-dup", "type", "passphrase"],
                              capture_output=True, text=True, timeout=30).stdout.strip()
    except (OSError, subprocess.SubprocessError):
        return ""


def empreinte(chemin):
    h = hashlib.sha256()
    with open(chemin, "rb") as f:
        for bloc in iter(lambda: f.read(1 << 20), b""):
            h.update(bloc)
    return h.hexdigest()


def choisir(candidats, date_sauvegarde, n=ECHANTILLON, hasard=random):
    """Fichiers à relire : [(chemin absolu)] encore présents, de même taille et non modifiés depuis la sauvegarde.
    candidats : [(chemin absolu, taille)]."""
    bons = []
    for chemin, taille in candidats:
        try:
            st = os.stat(chemin)
        except OSError:
            continue
        if 0 < taille <= TAILLE_MAX and st.st_size == taille and st.st_mtime < date_sauvegarde:
            bons.append(chemin)
    hasard.shuffle(bons)
    return bons[:n]


def lancer(cmd, env, timeout=1800):
    p = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, env={**os.environ, **env})
    return p.returncode, p.stdout, p.stderr


def verifier_restic(depot, mdp):
    env = {"RESTIC_PASSWORD": mdp, "RESTIC_REPOSITORY": depot}
    code, out, err = lancer(["restic", "snapshots", "--json", "--latest", "1"], env)
    if code != 0:
        return False, 0, _("Sauvegarde illisible (restic : {erreur})").format(erreur=(err.strip().splitlines() or ["?"])[-1])
    instants = json.loads(out or "[]")
    if not instants:
        return False, 0, _("Aucune sauvegarde dans le dépôt")
    dernier = instants[-1]
    date = GLib.DateTime.new_from_iso8601(dernier["time"], None)
    date = date.to_unix() if date else time.time()
    code, out, err = lancer(["restic", "ls", "--json", dernier["id"]], env)
    candidats = []
    for ligne in out.splitlines():
        try:
            e = json.loads(ligne)
        except ValueError:
            continue
        if e.get("type") == "file" and e.get("path"):
            candidats.append((e["path"], e.get("size", 0)))
    choix = choisir(candidats, date)
    if not choix:
        return None, 0, _("Aucun fichier inchangé depuis la sauvegarde à relire")
    with tempfile.TemporaryDirectory(prefix="kemmos-verif-") as cible:
        cmd = ["restic", "restore", dernier["id"], "--target", cible]
        for c in choix:
            cmd += ["--include", c]
        code, _o, err = lancer(cmd, env)
        if code != 0:
            return False, 0, _("Relecture impossible (restic : {erreur})").format(erreur=(err.strip().splitlines() or ["?"])[-1])
        return comparer(choix, lambda c: os.path.join(cible, c.lstrip("/")))


def verifier_duplicity(depot, mdp):
    # dates de « list-current-files » au format anglais quelle que soit la langue de la session
    env = {"LC_ALL": "C.UTF-8", **({"PASSPHRASE": mdp} if mdp else {})}
    chiffre = [] if mdp else ["--no-encryption"]
    url = "file://" + depot
    code, out, err = lancer(["duplicity", "list-current-files", *chiffre, url], env)
    if code != 0:
        return False, 0, _("Sauvegarde illisible (duplicity : {erreur})").format(erreur=(err.strip().splitlines() or ["?"])[-1])
    # duplicity ne donne pas la taille sauvegardée : fichiers non modifiés depuis la dernière sauvegarde
    # (date gardée par Déjà Dup), de taille actuelle raisonnable
    candidats = []
    for ligne in out.splitlines():
        m = re.match(r"\w{3} \w{3} +\d+ \d\d:\d\d:\d\d \d{4} (.+)$", ligne)
        if m and os.path.isfile("/" + m.group(1)):
            candidats.append(("/" + m.group(1), os.path.getsize("/" + m.group(1))))
    derniere = GLib.DateTime.new_from_iso8601(reglages("org.gnome.DejaDup").get_string("last-backup") or "x", None)
    date = derniere.to_unix() if derniere else time.time() - 3600
    choix = choisir(candidats, date)
    if not choix:
        return None, 0, _("Aucun fichier inchangé depuis la sauvegarde à relire")
    with tempfile.TemporaryDirectory(prefix="kemmos-verif-") as cible:
        for c in choix:
            code, _o, err = lancer(["duplicity", "restore", *chiffre, "--path-to-restore", c.lstrip("/"), url,
                                    os.path.join(cible, c.lstrip("/"))], env)
            if code != 0:
                return False, 0, _("Relecture impossible (duplicity : {erreur})").format(
                    erreur=(err.strip().splitlines() or ["?"])[-1])
        return comparer(choix, lambda c: os.path.join(cible, c.lstrip("/")))


def comparer(choix, relu):
    for c in choix:
        r = relu(c)
        if not os.path.isfile(r) or empreinte(r) != empreinte(c):
            return False, len(choix), _("Le fichier relu « {f} » est différent de l'original : la sauvegarde est "
                                        "peut-être abîmée").format(f=os.path.basename(c))
    return True, len(choix), ""


def verifier():
    depot, message = emplacement()
    etat = {"date": time.time(), "ok": None, "fichiers": 0, "message": message}
    if depot:
        genre = outil(depot)
        if genre is None:
            etat["message"] = _("Aucune sauvegarde Déjà Dup dans « {d} »").format(d=depot)
        elif not shutil.which(genre):
            etat["message"] = _("{outil} n'est pas installé").format(outil=genre)
        else:
            try:
                ok, n, msg = (verifier_restic if genre == "restic" else verifier_duplicity)(depot, mot_de_passe())
            except (OSError, subprocess.SubprocessError, ValueError) as e:
                ok, n, msg = False, 0, str(e)
            etat.update(ok=ok, fichiers=n, message=msg, outil=genre)
    if etat["ok"] is not None or not lire_etat():
        ecrire_etat(etat)
    return etat


def notifier_echec(etat):
    try:
        bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
        bus.call_sync("org.freedesktop.Notifications", "/org/freedesktop/Notifications",
                      "org.freedesktop.Notifications", "Notify",
                      GLib.Variant("(susssasa{sv}i)", (_("Centre KemmOS"), 0, "dialog-warning-symbolic",
                                                       _("Sauvegarde : la vérification a échoué"), etat["message"],
                                                       [], {"desktop-entry": GLib.Variant("s", "org.kemmos.Centre")},
                                                       -1)),
                      GLib.VariantType("(u)"), Gio.DBusCallFlags.NONE, -1, None)
    except GLib.Error:
        pass


def surveiller():
    dd = reglages("org.gnome.DejaDup")
    if dd is None:
        return 0
    boucle = GLib.MainLoop()
    attente = {"id": 0}

    def apres_sauvegarde():
        attente["id"] = 0
        etat = lire_etat()
        if etat.get("ok") is not False and time.time() - etat.get("date", 0) < INTERVALLE:
            return False
        etat = verifier()
        if etat.get("ok") is False:
            notifier_echec(etat)
        return False

    def change(_s, _cle):
        if attente["id"]:
            GLib.source_remove(attente["id"])
        attente["id"] = GLib.timeout_add_seconds(60, apres_sauvegarde)
    dd.connect("changed::last-backup", change)
    boucle.run()
    return 0


def main(args):
    try:
        if "rd.live.image" in open("/proc/cmdline").read().split():
            return 0
    except OSError:
        pass
    if "--surveiller" in args:
        return surveiller()
    etat = verifier()
    if etat["ok"]:
        print(ngettext("Sauvegarde vérifiée : {n} fichier relu, identique à l'original",
                       "Sauvegarde vérifiée : {n} fichiers relus, identiques aux originaux",
                       etat["fichiers"]).format(n=etat["fichiers"]))
    else:
        print(etat["message"])
    return 0 if etat["ok"] else 1


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))
