#!/usr/bin/python3
# Bilan de santé (Centre KemmOS 1.14.0), lancé à l'ouverture de session (/etc/xdg/autostart).
# Vérifie en silence ce qui peut mal tourner sans que l'on s'en aperçoive, et ne prévient QUE s'il y a un
# problème, par une seule notification qui ouvre le Centre :
#  - disque qui faiblit (SMART, lu par UDisks2, sans mot de passe) : prévenu chaque jour, c'est urgent ;
#  - disque système presque plein (moins de 10 % ou de 5 Go libres) : au plus une fois par semaine ;
#  - mises à jour bloquées ou pas faites depuis plus de 3 semaines : au plus une fois par semaine ;
#  - batterie usée (moins de 50 % de la capacité d'origine) : une seule fois, puis à chaque perte de 10 points ;
#  - 1.15.0 : SSD usé à 90 % ou plus, processeur à 90 °C ou plus, mémoire vive souvent saturée (au plus une fois
#    par semaine) ; documents du coffre-fort des papiers qui arrivent à expiration (kemmos-coffre).
# La sauvegarde a son propre rappel (rappel-sauvegarde). État : ~/.local/state/kemmos/bilan-sante.json.
# Rien dans la session live. « bilan-sante --texte » affiche le bilan sans notifier (essais).
import gettext
import json
import os
import subprocess
import sys
import time

from gi.repository import Gio, GLib


class _Francais(gettext.NullTranslations):
    """Textes d'origine (français) : pluriel à partir de 2."""

    def ngettext(self, singulier, pluriel, n):
        return singulier if n < 2 else pluriel


def _traduction(domaine):
    """Langue de l'interface : français (textes d'origine), breton (repli sur le français pour ce qui n'est
    pas encore traduit), anglais pour toutes les autres langues."""
    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", "bilan-sante.json")
STATUT_MAJ = "/var/lib/kemmos-update/status.json"
JOUR = 86400
SEMAINE = 7 * JOUR
ATTENTE_MAX = 4 * 3600      # le processus attend la réponse au plus 4 h, puis se termine
GO = 1024 ** 3


def taille(n):
    """« 1,2 Go » en français et en breton, « 1.2 GB » en anglais (comme le Centre)."""
    t = f"{n / GO:.1f}"
    return t.replace(".", ",") + " Go" if LANGUE in ("fr", "br") else t + " GB"


# ---------- Vérifications : chacune renvoie une liste de (clé, texte, urgent) ----------

def objets_udisks():
    """Objets de UDisks2 (disques et leurs interfaces), {} s'il ne répond pas."""
    try:
        bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
        return bus.call_sync("org.freedesktop.UDisks2", "/org/freedesktop/UDisks2",
                             "org.freedesktop.DBus.ObjectManager", "GetManagedObjects", None,
                             GLib.VariantType("(a{oa{sa{sv}}})"), Gio.DBusCallFlags.NONE, 10000,
                             None).unpack()[0]
    except GLib.Error:
        return {}


def disques_smart():
    """Disques internes dont l'auto-diagnostic SMART annonce une panne proche (UDisks2)."""
    return analyse_smart(objets_udisks())


def nb_surveilles(objets):
    """Nombre de disques internes dont UDisks2 lit l'auto-diagnostic SMART (0 en machine virtuelle)."""
    n = 0
    for ifaces in objets.values():
        drive = ifaces.get("org.freedesktop.UDisks2.Drive")
        if not drive or drive.get("Removable") or drive.get("MediaRemovable"):
            continue
        ata = ifaces.get("org.freedesktop.UDisks2.Drive.Ata") or {}
        if ata.get("SmartEnabled") or "org.freedesktop.UDisks2.NVMe.Controller" in ifaces:
            n += 1
    return n


def analyse_smart(objets):
    res = []
    for _chemin, ifaces in sorted(objets.items()):
        drive = ifaces.get("org.freedesktop.UDisks2.Drive")
        if not drive or drive.get("Removable") or drive.get("MediaRemovable"):
            continue
        nom = " ".join(x for x in (drive.get("Vendor", ""), drive.get("Model", "")) if x).strip() or _("Disque")
        ata = ifaces.get("org.freedesktop.UDisks2.Drive.Ata") or {}
        nvme = ifaces.get("org.freedesktop.UDisks2.NVMe.Controller") or {}
        if ata.get("SmartFailing"):
            res.append(("smart:" + nom, _("Le disque « {nom} » annonce une panne prochaine (SMART). Sauvegardez vos "
                                          "fichiers dès maintenant et prévoyez de le remplacer.").format(nom=nom), True))
        elif nvme.get("SmartCriticalWarning"):
            res.append(("smart:" + nom, _("Le disque « {nom} » signale un problème grave (SMART : {alerte}). "
                                          "Sauvegardez vos fichiers dès maintenant.").format(
                nom=nom, alerte=", ".join(nvme["SmartCriticalWarning"])), True))
        elif ata.get("SmartNumBadSectors", 0) > 0:
            n = ata["SmartNumBadSectors"]
            res.append(("secteurs:" + nom, ngettext(
                "Le disque « {nom} » a {n} secteur défectueux : surveillez-le et gardez une sauvegarde à jour.",
                "Le disque « {nom} » a {n} secteurs défectueux : surveillez-le et gardez une sauvegarde à jour.",
                n).format(nom=nom, n=n), False))
    return res


def attributs_smart(bus, chemin, ifaces):
    """Usure d'un SSD en % (0 = neuf), None si inconnue. NVMe : « percent_used » ; SATA : attributs 177, 231,
    233 (valeur normalisée = vie restante)."""
    try:
        if "org.freedesktop.UDisks2.NVMe.Controller" in ifaces:
            r = bus.call_sync("org.freedesktop.UDisks2", chemin, "org.freedesktop.UDisks2.NVMe.Controller",
                              "SmartGetAttributes", GLib.Variant("(a{sv})", ({},)), GLib.VariantType("(a{sv})"),
                              Gio.DBusCallFlags.NONE, 10000, None).unpack()[0]
            return int(r["percent_used"]) if "percent_used" in r else None
        if "org.freedesktop.UDisks2.Drive.Ata" in ifaces and ifaces["org.freedesktop.UDisks2.Drive"].get("RotationRate") == 0:
            r = bus.call_sync("org.freedesktop.UDisks2", chemin, "org.freedesktop.UDisks2.Drive.Ata",
                              "SmartGetAttributes", GLib.Variant("(a{sv})", ({},)), None,
                              Gio.DBusCallFlags.NONE, 10000, None).unpack()[0]
            for ident, _nom, _f, valeur, *_r in r:
                if ident in (177, 231, 233) and 0 <= valeur <= 100:
                    return 100 - valeur
    except (GLib.Error, KeyError, ValueError, TypeError):
        pass
    return None


def usure_ssd(objets):
    """[(nom, % d'usure)] des SSD internes qui donnent l'information."""
    res = []
    try:
        bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
    except GLib.Error:
        return res
    for chemin, ifaces in sorted(objets.items()):
        drive = ifaces.get("org.freedesktop.UDisks2.Drive")
        if not drive or drive.get("Removable") or drive.get("MediaRemovable"):
            continue
        u = attributs_smart(bus, chemin, ifaces)
        if u is not None:
            nom = " ".join(x for x in (drive.get("Vendor", ""), drive.get("Model", "")) if x).strip() or _("Disque")
            res.append((nom, u))
    return res


def ssd_uses(objets):
    return [("ssd:" + nom, _("Le SSD « {nom} » est usé à {pct} % : prévoyez de le remplacer et gardez une sauvegarde "
                             "à jour.").format(nom=nom, pct=u), False) for nom, u in usure_ssd(objets) if u >= 90]


def temperature_processeur(base="/sys/class/hwmon"):
    """Température du processeur en °C (capteur coretemp, k10temp ou zenpower), None si inconnue."""
    try:
        noms = sorted(os.listdir(base))
    except OSError:
        return None
    for n in noms:
        try:
            with open(f"{base}/{n}/name") as f:
                capteur = f.read().strip()
            if capteur not in ("coretemp", "k10temp", "zenpower", "cpu_thermal"):
                continue
            with open(f"{base}/{n}/temp1_input") as f:
                return int(f.read().strip()) / 1000
        except (OSError, ValueError):
            continue
    return None


def chaleur():
    t = temperature_processeur()
    if t is not None and t >= 90:
        return [("chaleur", _("Le processeur chauffe beaucoup ({t} °C). Vérifiez que les aérations ne sont pas "
                              "bouchées (poussière, ordinateur posé sur un lit ou un canapé).").format(t=round(t)),
                 False)]
    return []


def pression_memoire(texte):
    """Part du temps (%) où des programmes ont attendu la mémoire, sur 5 minutes (/proc/pressure/memory)."""
    for ligne in texte.splitlines():
        if ligne.startswith("some "):
            for champ in ligne.split():
                if champ.startswith("avg300="):
                    try:
                        return float(champ[7:])
                    except ValueError:
                        return None
    return None


def memoire_saturee():
    try:
        with open("/proc/pressure/memory") as f:
            p = pression_memoire(f.read())
    except OSError:
        return []
    if p is not None and p >= 10:
        return [("memoire", _("La mémoire vive est souvent pleine : l'ordinateur ralentit. Fermez les onglets et "
                              "applications inutiles ; si cela revient souvent, ajouter de la mémoire aidera."), False)]
    return []


ECHEANCES = os.path.join(GLib.get_user_data_dir(), "kemmos-coffre", "echeances.json")


def echeances(maintenant):
    """Documents du coffre-fort des papiers qui expirent bientôt (ou viennent d'expirer)."""
    import datetime
    try:
        with open(ECHEANCES) as f:
            liste = json.load(f)
    except (OSError, ValueError):
        return []
    jour = datetime.date.fromtimestamp(maintenant)
    res = []
    for e in liste:
        try:
            d = datetime.date.fromisoformat(e["date"])
        except (KeyError, ValueError, TypeError):
            continue
        jours = (d - jour).days
        nom = e.get("titre") or _("Un document")
        quand = d.strftime("%d/%m/%Y")
        if -60 < jours < 0:
            texte = _("« {nom} » a expiré le {date}.").format(nom=nom, date=quand)
        elif 0 <= jours <= int(e.get("rappel", 30)):
            texte = ngettext("« {nom} » expire le {date} (dans {n} jour) : pensez à le renouveler.",
                             "« {nom} » expire le {date} (dans {n} jours) : pensez à le renouveler.",
                             jours).format(nom=nom, date=quand, n=jours)
        else:
            continue
        res.append((f"echeance:{nom}:{e['date']}", texte, False))
    return res


def disque_plein():
    try:
        st = os.statvfs("/")
    except OSError:
        return []
    libre, total = st.f_bavail * st.f_frsize, st.f_blocks * st.f_frsize
    if total and (libre < 5 * GO or libre < total / 10):
        return [("plein", _("Le disque système est presque plein : {libre} libres. Videz la corbeille et les "
                            "téléchargements, ou « Nettoyer seulement » dans KemmOS-Update.").format(libre=taille(libre)),
                 False)]
    return []


def derniere_installation():
    """Date (epoch) du dernier paquet installé ou mis à jour."""
    try:
        sortie = subprocess.run(["rpm", "-qa", "--qf", "%{INSTALLTIME}\n"], capture_output=True, text=True,
                                timeout=60).stdout
        return max(int(x) for x in sortie.split() if x.isdigit())
    except (OSError, subprocess.SubprocessError, ValueError):
        return None


def mises_a_jour(maintenant, etat):
    try:
        with open(STATUT_MAJ) as f:
            s = json.load(f)
    except (OSError, ValueError):
        return []
    if s.get("system", 0) < 0 and s.get("system_problem"):
        # bloquée : prévenir si cela dure depuis plus d'une semaine (KemmOS-Update l'affiche déjà)
        depuis = etat.setdefault("bloquee_depuis", maintenant)
        if maintenant - depuis >= SEMAINE:
            jours = int((maintenant - depuis) // JOUR)
            texte = (_("Les mises à jour sont bloquées depuis {n} jours. KemmOS-Update (icône en haut de "
                       "l'écran) explique pourquoi et peut souvent les débloquer.").format(n=jours))
            return [("bloquee", texte, False)]
        return []
    etat.pop("bloquee_depuis", None)
    if s.get("system", 0) > 0:
        derniere = derniere_installation()
        if derniere and maintenant - derniere >= 3 * SEMAINE:
            jours = int((maintenant - derniere) // JOUR)
            return [("retard", ngettext("{m} mise à jour en attente, la dernière date de {n} jours. Lancez « Mettre "
                                        "à jour et nettoyer » dans KemmOS-Update.",
                                        "{m} mises à jour en attente, la dernière date de {n} jours. Lancez « Mettre "
                                        "à jour et nettoyer » dans KemmOS-Update.", s["system"]).format(
                m=s["system"], n=jours), False)]
    return []


def batterie(etat):
    base = "/sys/class/power_supply"
    res = []
    try:
        noms = sorted(os.listdir(base))
    except OSError:
        return res
    for n in noms:
        def lire(f):
            try:
                with open(f"{base}/{n}/{f}") as fh:
                    return fh.read().strip()
            except OSError:
                return ""
        if lire("type") != "Battery":
            continue
        for plein, origine in (("energy_full", "energy_full_design"), ("charge_full", "charge_full_design")):
            try:
                pct = min(100, 100 * int(lire(plein)) / int(lire(origine)))
            except (ValueError, ZeroDivisionError):
                continue
            # une seule fois par palier de 10 points (49 %, puis 39 %…)
            palier = int(pct // 10)
            cle = "batterie:" + n
            if pct < 50 and etat.get(cle, 99) > palier:
                etat[cle] = palier
                res.append((cle, _("La batterie ({nom}) ne garde plus que {pct} % de sa capacité d'origine : "
                                   "l'autonomie est réduite. Elle peut être remplacée.").format(nom=n, pct=round(pct)),
                            False))
            break
    return res


# ---------- Notification ----------

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 a_signaler(problemes, etat, maintenant):
    """Problèmes à signaler maintenant : urgents chaque jour, nouveaux tout de suite, les autres une fois par
    semaine. La batterie n'arrive ici que lorsqu'elle passe un palier (voir batterie())."""
    vus = etat.get("signales", {})
    garder = []
    for cle, texte, urgent in problemes:
        delai = JOUR if urgent else SEMAINE
        if cle.startswith("batterie:") or cle not in vus or maintenant - vus[cle] >= delai:
            garder.append((cle, texte, urgent))
    return garder


def notifier(problemes):
    urgent = any(u for _c, _t, u in problemes)
    titre = (_("Bilan de santé : problème urgent") if urgent else
             ngettext("Bilan de santé : {n} point à vérifier", "Bilan de santé : {n} points à vérifier",
                      len(problemes)).format(n=len(problemes)))
    corps = "\n".join("• " + t for _c, t, _u in problemes)
    bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
    boucle = GLib.MainLoop()
    ident = bus.call_sync(
        "org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications",
        "Notify", GLib.Variant("(susssasa{sv}i)", (
            _("Centre KemmOS"), 0, "dialog-warning-symbolic" if urgent else "computer-symbolic", titre, corps,
            ["centre", _("Ouvrir le Centre KemmOS")],
            {"desktop-entry": GLib.Variant("s", "org.kemmos.Centre"),
             "urgency": GLib.Variant("y", 2 if urgent else 1)}, -1)),
        GLib.VariantType("(u)"), Gio.DBusCallFlags.NONE, -1, None).unpack()[0]

    def action(_c, _e, _p, _i, signal, params):
        if params[0] != ident:
            return
        if signal == "ActionInvoked" and params[1] == "centre":
            appli = Gio.DesktopAppInfo.new("org.kemmos.Centre.desktop")
            if appli:
                appli.launch([], None)
        boucle.quit()

    for sig in ("ActionInvoked", "NotificationClosed"):
        bus.signal_subscribe("org.freedesktop.Notifications", "org.freedesktop.Notifications", sig,
                             "/org/freedesktop/Notifications", None, Gio.DBusSignalFlags.NONE, action)
    GLib.timeout_add_seconds(ATTENTE_MAX, boucle.quit)
    boucle.run()


def bilan(maintenant, etat):
    objets = objets_udisks()
    return (analyse_smart(objets) + ssd_uses(objets) + disque_plein() + mises_a_jour(maintenant, etat)
            + batterie(etat) + chaleur() + memoire_saturee() + echeances(maintenant))


def main(args):
    maintenant = time.time()
    if "--texte" in args:
        problemes = bilan(maintenant, {})
        print("\n".join(("[URGENT] " if u else "") + t for _c, t, u in problemes) or _("Rien à signaler."))
        return 0
    try:
        if "rd.live.image" in open("/proc/cmdline").read().split():
            return 0
    except OSError:
        pass
    etat = lire_etat()
    problemes = a_signaler(bilan(maintenant, etat), etat, maintenant)
    for cle, _t, _u in problemes:
        etat.setdefault("signales", {})[cle] = maintenant
    ecrire_etat(etat)
    if problemes:
        notifier(problemes)
    return 0


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