#!/usr/bin/python3
# Coffre-fort des papiers (Centre KemmOS 1.15.0) : un dossier chiffré pour les papiers importants (identité,
# impôts, santé, banque, logement…) et des rappels avant l'expiration des documents.
#  - Chiffrement : gocryptfs (fichier par fichier, AES-GCM) ; données chiffrées dans
#    ~/.local/share/kemmos-coffre/donnees, dossier lisible ~/Coffre (nom traduit) seulement quand le coffre est
#    ouvert. Il se referme seul après 30 minutes sans utilisation (gocryptfs -idle) et quand la fenêtre se ferme.
#  - Clé de secours : montrée une seule fois à la création (à noter ou enregistrer sur une clé USB) ; seule façon
#    de retrouver les documents si le mot de passe est oublié.
#  - Échéances : ~/.local/share/kemmos-coffre/echeances.json (non chiffré : nom du document et date seulement),
#    rappels par le bilan de santé (notification à l'ouverture de session).
import datetime
import gettext
import json
import os
import shutil
import subprocess
import sys


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. Renvoie (traduction, code de langue)."""
    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

APP_ID = "org.kemmos.Coffre"
DONNEES = os.path.join(os.environ.get("XDG_DATA_HOME", os.path.expanduser("~/.local/share")), "kemmos-coffre")
CHIFFRE = os.path.join(DONNEES, "donnees")
ECHEANCES = os.path.join(DONNEES, "echeances.json")
REGLAGES = os.path.join(DONNEES, "reglages.json")
GOCRYPTFS = shutil.which("gocryptfs") or "/usr/bin/gocryptfs"
INACTIF = "30m"
MIN_MDP = 8
DOSSIERS = [_("Identité"), _("Impôts"), _("Santé"), _("Banque"), _("Logement"), _("Véhicule"), _("Travail"),
            _("Famille")]
# type de document : (libellé, rappel par défaut en jours) — délais des mairies et préfectures pour l'identité
TYPES = [("identite", _("Carte d'identité"), 90), ("passeport", _("Passeport"), 90),
         ("permis", _("Permis de conduire"), 60), ("sejour", _("Titre de séjour"), 120),
         ("assurance", _("Assurance"), 30), ("controle", _("Contrôle technique"), 30),
         ("mutuelle", _("Mutuelle"), 30), ("garantie", _("Garantie"), 30), ("abonnement", _("Abonnement"), 30),
         ("autre", _("Autre"), 30)]
RAPPELS = [(7, _("1 semaine avant")), (30, _("1 mois avant")), (60, _("2 mois avant")), (90, _("3 mois avant")),
           (120, _("4 mois avant")), (180, _("6 mois avant"))]


# ---------- logique (sans interface, testée par tests/test_coffre.py) ----------

def lire_json(chemin, defaut):
    try:
        with open(chemin) as f:
            return json.load(f)
    except (OSError, ValueError):
        return defaut


def ecrire_json(chemin, valeur):
    os.makedirs(os.path.dirname(chemin), exist_ok=True)
    with open(chemin + ".tmp", "w") as f:
        json.dump(valeur, f, ensure_ascii=False, indent=1)
    os.chmod(chemin + ".tmp", 0o600)
    os.replace(chemin + ".tmp", chemin)


def montage():
    """Dossier lisible du coffre (nom choisi à la création, dans la langue de l'utilisateur)."""
    return lire_json(REGLAGES, {}).get("montage") or os.path.expanduser("~/" + _("Coffre"))


def existe():
    return os.path.exists(os.path.join(CHIFFRE, "gocryptfs.conf"))


def ouvert():
    return os.path.ismount(montage())


def lire_date(texte):
    """« 12/03/2027 » (ou 12-03-2027, 12.03.2027) → date, None si invalide."""
    t = texte.strip().replace("-", "/").replace(".", "/")
    try:
        return datetime.datetime.strptime(t, "%d/%m/%Y").date()
    except ValueError:
        return None


def statut(echeance, aujourdhui):
    """(« expire » | « bientot » | « ok », jours restants) d'une échéance {date: AAAA-MM-JJ, rappel: jours}."""
    try:
        d = datetime.date.fromisoformat(echeance["date"])
    except (KeyError, ValueError):
        return "ok", 0
    jours = (d - aujourdhui).days
    if jours < 0:
        return "expire", jours
    if jours <= int(echeance.get("rappel", 30)):
        return "bientot", jours
    return "ok", jours


def delai_lisible(jours):
    if jours < 0:
        return ngettext("expiré depuis {n} jour", "expiré depuis {n} jours", -jours).format(n=-jours)
    if jours == 0:
        return _("expire aujourd'hui")
    if jours < 60:
        return ngettext("dans {n} jour", "dans {n} jours", jours).format(n=jours)
    mois = round(jours / 30.4)
    return ngettext("dans {n} mois", "dans {n} mois", mois).format(n=mois)


def a_rappeler(echeances, aujourdhui):
    """Échéances à rappeler : expirées depuis moins de 60 jours, ou dans leur délai de rappel."""
    res = []
    for e in echeances:
        s, jours = statut(e, aujourdhui)
        if s == "bientot" or (s == "expire" and jours > -60):
            res.append((e, s, jours))
    return sorted(res, key=lambda x: x[2])


def gocryptfs(args, mot_de_passe):
    """Lance gocryptfs, mot de passe sur l'entrée standard. Renvoie (code, sortie)."""
    try:
        p = subprocess.run([GOCRYPTFS, *args], input=mot_de_passe + "\n", capture_output=True, text=True, timeout=120)
        return p.returncode, (p.stdout + p.stderr).strip()
    except (OSError, subprocess.SubprocessError) as e:
        return 1, str(e)


def creer(mot_de_passe):
    """Crée le coffre ; renvoie (ok, clé de secours ou message d'erreur)."""
    os.makedirs(CHIFFRE, mode=0o700, exist_ok=True)
    code, out = gocryptfs(["-init", "-q", "-passfile", "/dev/stdin", CHIFFRE], mot_de_passe)
    if code != 0:
        return False, out
    xray = shutil.which("gocryptfs-xray") or "/usr/bin/gocryptfs-xray"
    try:
        p = subprocess.run([xray, "-dumpmasterkey", os.path.join(CHIFFRE, "gocryptfs.conf")],
                           input=mot_de_passe + "\n", capture_output=True, text=True, timeout=60)
        cle = p.stdout.strip().splitlines()[-1] if p.returncode == 0 and p.stdout.strip() else ""
    except (OSError, subprocess.SubprocessError, IndexError):
        cle = ""
    reglages = lire_json(REGLAGES, {})
    reglages["montage"] = montage()
    ecrire_json(REGLAGES, reglages)
    return True, "-".join(cle[i:i + 8] for i in range(0, len(cle), 8))


def ouvrir(mot_de_passe):
    """(ok, message) ; code 12 de gocryptfs = mot de passe incorrect."""
    m = montage()
    os.makedirs(m, exist_ok=True)
    if os.path.ismount(m):
        return True, ""
    if os.listdir(m):
        return False, _("Le dossier « {d} » n'est pas vide : déplacez son contenu avant d'ouvrir le coffre.").format(d=m)
    code, out = gocryptfs(["-q", "-idle", INACTIF, "-passfile", "/dev/stdin", CHIFFRE, m], mot_de_passe)
    if code == 12:
        return False, _("Mot de passe incorrect")
    if code != 0:
        return False, out
    # première ouverture : un dossier par grande famille de papiers
    reglages = lire_json(REGLAGES, {})
    if not reglages.get("dossiers"):
        for d in DOSSIERS:
            os.makedirs(os.path.join(m, d), exist_ok=True)
        reglages["dossiers"] = True
        ecrire_json(REGLAGES, reglages)
    return True, ""


def fermer(forcer=False):
    m = montage()
    if not os.path.ismount(m):
        return True, ""
    p = subprocess.run(["fusermount3", "-u", *(["-z"] if forcer else []), m], capture_output=True, text=True)
    if p.returncode != 0:
        return False, _("Des documents du coffre sont encore ouverts : fermez-les, puis réessayez.")
    return True, ""


def nouveau_mot_de_passe(cle, mot_de_passe):
    """Mot de passe oublié : nouveau mot de passe grâce à la clé de secours."""
    cle = "".join(c for c in cle.lower() if c in "0123456789abcdef")
    if len(cle) != 64:
        return False, _("La clé de secours compte 64 caractères (chiffres et lettres de a à f)")
    bak = os.path.join(CHIFFRE, "gocryptfs.conf.bak")
    if os.path.exists(bak):
        os.remove(bak)
    code, out = gocryptfs(["-passwd", "-q", f"-masterkey={cle}", CHIFFRE], mot_de_passe)
    if os.path.exists(bak):
        os.remove(bak)   # l'ancienne configuration contient la clé protégée par l'ancien mot de passe
    if code != 0:
        return False, _("Clé de secours refusée")
    return True, ""


# ---------- fenêtre ----------

def fenetre():
    import gi
    gi.require_version("Gtk", "4.0")
    gi.require_version("Adw", "1")
    from gi.repository import Adw, Gdk, Gio, GLib, Gtk

    class Fenetre(Adw.ApplicationWindow):
        def __init__(self, app):
            super().__init__(application=app, title=_("Coffre-fort des papiers"), default_width=760,
                             default_height=640)
            self.toasts = Adw.ToastOverlay()
            vue = Adw.ToolbarView()
            entete = Adw.HeaderBar()
            self.pile = Adw.ViewStack()
            entete.set_title_widget(Adw.ViewSwitcher(stack=self.pile, policy=Adw.ViewSwitcherPolicy.WIDE))
            vue.add_top_bar(entete)
            vue.set_content(self.pile)
            self.toasts.set_child(vue)
            self.set_content(self.toasts)
            self.page_coffre = Gtk.ScrolledWindow(hscrollbar_policy=Gtk.PolicyType.NEVER)
            self.pile.add_titled_with_icon(self.page_coffre, "coffre", _("Coffre"), "channel-secure-symbolic")
            self.page_echeances = Adw.PreferencesPage()
            self.pile.add_titled_with_icon(self.page_echeances, "echeances", _("Échéances"),
                                           "alarm-symbolic")
            self.connect("close-request", self.a_la_fermeture)
            self.construire_coffre()
            self.construire_echeances()
            if not os.path.exists(GOCRYPTFS):
                self.toast(_("gocryptfs n'est pas installé : réinstallez le paquet kemmos-centre"))

        def toast(self, texte):
            self.toasts.add_toast(Adw.Toast(title=texte, timeout=5))

        def a_la_fermeture(self, *_a):
            if ouvert():
                ok, _m = fermer()
                if not ok:
                    fermer(forcer=True)   # refermé dès que les documents ouverts seront fermés
            return False

        # ----- coffre -----

        def statut_page(self, titre, texte, icone, enfant):
            p = Adw.StatusPage(title=titre, description=texte, icon_name=icone)
            p.set_child(enfant)
            self.page_coffre.set_child(p)

        def construire_coffre(self):
            if not existe():
                self.page_creation()
            elif ouvert():
                self.page_ouvert()
            else:
                self.page_ferme()

        def page_creation(self):
            boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=18, halign=Gtk.Align.CENTER,
                            width_request=420)
            g = Adw.PreferencesGroup()
            mdp = Adw.PasswordEntryRow(title=_("Mot de passe (8 caractères au moins)"))
            mdp2 = Adw.PasswordEntryRow(title=_("Le même mot de passe, une seconde fois"))
            g.add(mdp)
            g.add(mdp2)
            boite.append(g)
            b = Gtk.Button(label=_("Créer mon coffre-fort"), halign=Gtk.Align.CENTER)
            b.add_css_class("suggested-action")
            b.add_css_class("pill")
            b.connect("clicked", lambda _b: self.creer(mdp.get_text(), mdp2.get_text()))
            mdp2.connect("entry-activated", lambda _e: self.creer(mdp.get_text(), mdp2.get_text()))
            boite.append(b)
            self.statut_page(_("Coffre-fort des papiers"),
                             _("Un dossier chiffré pour vos papiers importants : identité, impôts, santé, banque, "
                               "logement… Sans le mot de passe, personne ne peut les lire, même avec le disque "
                               "de l'ordinateur entre les mains."), "channel-secure-symbolic", boite)

        def creer(self, m1, m2):
            if len(m1) < MIN_MDP:
                self.toast(_("Mot de passe trop court : 8 caractères au moins"))
                return
            if m1 != m2:
                self.toast(_("Les deux mots de passe sont différents"))
                return
            ok, cle = creer(m1)
            if not ok:
                self.toast(_("Création impossible : {erreur}").format(erreur=cle))
                return
            ouvrir(m1)
            self.montrer_cle(cle)
            self.construire_coffre()

        def montrer_cle(self, cle):
            boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12)
            texte = Gtk.Label(label=cle, selectable=True, wrap=True, wrap_mode=2)
            texte.add_css_class("monospace")
            texte.add_css_class("title-4")
            boite.append(texte)
            boutons = Gtk.Box(spacing=12, halign=Gtk.Align.CENTER)
            copier = Gtk.Button(label=_("Copier"))
            copier.connect("clicked", lambda _b: (Gdk.Display.get_default().get_clipboard().set(cle),
                                                 self.toast(_("Clé copiée"))))
            fichier = Gtk.Button(label=_("Enregistrer…"))
            fichier.connect("clicked", lambda _b: self.enregistrer_cle(cle))
            boutons.append(copier)
            boutons.append(fichier)
            boite.append(boutons)
            d = Adw.AlertDialog(
                heading=_("Votre clé de secours"),
                body=_("Si vous oubliez le mot de passe, cette clé est le SEUL moyen de retrouver vos documents. "
                       "Recopiez-la sur papier et rangez-la en lieu sûr, ou enregistrez-la sur une clé USB. "
                       "Elle ne sera plus jamais affichée."))
            d.set_extra_child(boite)
            d.add_response("ok", _("Je l'ai notée"))
            d.set_response_appearance("ok", Adw.ResponseAppearance.SUGGESTED)
            d.set_close_response("ok")
            d.present(self)

        def enregistrer_cle(self, cle):
            dlg = Gtk.FileDialog(title=_("Enregistrer la clé de secours"),
                                 initial_name=_("cle-de-secours-coffre-kemmos.txt"))

            def fini(dlg, res):
                try:
                    f = dlg.save_finish(res)
                except GLib.Error:
                    f = None
                if f:
                    with open(f.get_path(), "w") as fh:
                        fh.write(_("Clé de secours du coffre-fort KemmOS") + "\n\n" + cle + "\n")
                    self.toast(_("Clé enregistrée : {fichier}").format(fichier=f.get_path()))
            dlg.save(self, None, fini)

        def page_ferme(self):
            boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=18, halign=Gtk.Align.CENTER,
                            width_request=420)
            g = Adw.PreferencesGroup()
            mdp = Adw.PasswordEntryRow(title=_("Mot de passe du coffre"))
            g.add(mdp)
            boite.append(g)
            b = Gtk.Button(label=_("Ouvrir le coffre"), halign=Gtk.Align.CENTER)
            b.add_css_class("suggested-action")
            b.add_css_class("pill")
            b.connect("clicked", lambda _b: self.ouvrir(mdp))
            mdp.connect("entry-activated", lambda _e: self.ouvrir(mdp))
            boite.append(b)
            oubli = Gtk.Button(label=_("Mot de passe oublié ?"), halign=Gtk.Align.CENTER)
            oubli.add_css_class("flat")
            oubli.connect("clicked", lambda _b: self.dialogue_oubli())
            boite.append(oubli)
            self.statut_page(_("Coffre fermé"), _("Vos documents sont chiffrés."), "channel-secure-symbolic", boite)
            GLib.idle_add(mdp.grab_focus)

        def ouvrir(self, mdp):
            ok, message = ouvrir(mdp.get_text())
            if not ok:
                self.toast(message)
                mdp.set_text("")
                return
            self.construire_coffre()
            self.ouvrir_dossier()

        def page_ouvert(self):
            boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12, halign=Gtk.Align.CENTER)
            b = Gtk.Button(label=_("Ouvrir le dossier"))
            b.add_css_class("suggested-action")
            b.add_css_class("pill")
            b.connect("clicked", lambda _b: self.ouvrir_dossier())
            boite.append(b)
            f = Gtk.Button(label=_("Fermer le coffre"))
            f.add_css_class("pill")
            f.connect("clicked", lambda _b: self.fermer())
            boite.append(f)
            self.statut_page(_("Coffre ouvert"),
                             _("Vos documents sont dans le dossier « {dossier} ». Le coffre se referme tout seul "
                               "après 30 minutes sans utilisation, et quand vous fermez cette fenêtre.").format(
                                 dossier=os.path.basename(montage())), "folder-open-symbolic", boite)

        def ouvrir_dossier(self):
            try:
                Gio.AppInfo.launch_default_for_uri(GLib.filename_to_uri(montage()), None)
            except GLib.Error as e:
                self.toast(e.message)

        def fermer(self):
            ok, message = fermer()
            if not ok:
                d = Adw.AlertDialog(heading=_("Documents encore ouverts"), body=message)
                d.add_response("attendre", _("Annuler"))
                d.add_response("forcer", _("Fermer quand même"))
                d.set_response_appearance("forcer", Adw.ResponseAppearance.DESTRUCTIVE)
                d.connect("response", lambda _d, r: r == "forcer" and (fermer(forcer=True), self.construire_coffre()))
                d.present(self)
                return
            self.toast(_("Coffre fermé"))
            self.construire_coffre()

        def dialogue_oubli(self):
            g = Adw.PreferencesGroup()
            cle = Adw.EntryRow(title=_("Clé de secours"))
            m1 = Adw.PasswordEntryRow(title=_("Nouveau mot de passe"))
            m2 = Adw.PasswordEntryRow(title=_("Le même, une seconde fois"))
            for w in (cle, m1, m2):
                g.add(w)
            d = Adw.AlertDialog(heading=_("Mot de passe oublié"),
                                body=_("Saisissez la clé de secours donnée à la création du coffre, puis un nouveau "
                                       "mot de passe."))
            d.set_extra_child(g)
            d.add_response("annuler", _("Annuler"))
            d.add_response("ok", _("Changer le mot de passe"))
            d.set_response_appearance("ok", Adw.ResponseAppearance.SUGGESTED)

            def reponse(_d, rep):
                if rep != "ok":
                    return
                if len(m1.get_text()) < MIN_MDP or m1.get_text() != m2.get_text():
                    self.toast(_("Nouveau mot de passe : 8 caractères au moins, deux fois le même"))
                    return
                ok, message = nouveau_mot_de_passe(cle.get_text(), m1.get_text())
                self.toast(_("Mot de passe changé : vous pouvez ouvrir le coffre") if ok else message)
            d.connect("response", reponse)
            d.present(self)

        # ----- échéances -----

        def construire_echeances(self):
            page = self.page_echeances
            for g in list(getattr(page, "_groupes", [])):
                page.remove(g)
            page._groupes = []
            liste = lire_json(ECHEANCES, [])
            aujourdhui = datetime.date.today()
            g = Adw.PreferencesGroup(
                title=_("Dates d'expiration"),
                description=_("Carte d'identité, passeport, assurance, contrôle technique… KemmOS vous prévient "
                              "à l'ouverture de session quand une date approche. Seuls le nom et la date sont "
                              "enregistrés, pas le document."))
            ajout = Gtk.Button(icon_name="list-add-symbolic", tooltip_text=_("Ajouter"), valign=Gtk.Align.CENTER)
            ajout.add_css_class("flat")
            ajout.connect("clicked", lambda _b: self.editer(None))
            g.set_header_suffix(ajout)
            if not liste:
                g.add(Adw.ActionRow(title=_("Aucune échéance"), subtitle=_("Bouton + pour en ajouter une")))
            for i, e in sorted(enumerate(liste), key=lambda x: x[1].get("date", "")):
                s, jours = statut(e, aujourdhui)
                try:
                    d = datetime.date.fromisoformat(e["date"]).strftime("%d/%m/%Y")
                except (KeyError, ValueError):
                    d = "?"
                libelle = dict((k, l) for k, l, _r in TYPES).get(e.get("type"), "")
                r = Adw.ActionRow(title=GLib.markup_escape_text(e.get("titre") or libelle),
                                  subtitle=_("Expire le {date} — {delai}").format(date=d, delai=delai_lisible(jours)))
                p = Gtk.Label(label={"expire": "✖", "bientot": "⚠", "ok": "✔"}[s])
                p.add_css_class("title-4")
                p.add_css_class({"expire": "error", "bientot": "warning", "ok": "success"}[s])
                r.add_prefix(p)
                for icone, info, rappel in (("document-edit-symbolic", _("Modifier"), lambda i=i: self.editer(i)),
                                            ("user-trash-symbolic", _("Supprimer"), lambda i=i: self.supprimer(i))):
                    b = Gtk.Button(icon_name=icone, tooltip_text=info, valign=Gtk.Align.CENTER)
                    b.add_css_class("flat")
                    b.connect("clicked", lambda _b, f=rappel: f())
                    r.add_suffix(b)
                g.add(r)
            page.add(g)
            page._groupes.append(g)

        def editer(self, index):
            liste = lire_json(ECHEANCES, [])
            e = liste[index] if index is not None else {"type": "identite", "rappel": 90}
            g = Adw.PreferencesGroup()
            genre = Adw.ComboRow(title=_("Document"), model=Gtk.StringList.new([l for _k, l, _r in TYPES]))
            cles = [k for k, _l, _r in TYPES]
            genre.set_selected(cles.index(e.get("type")) if e.get("type") in cles else len(cles) - 1)
            titre = Adw.EntryRow(title=_("Nom (facultatif, ex. « Passeport de Léa »)"), text=e.get("titre", ""))
            try:
                date_txt = datetime.date.fromisoformat(e["date"]).strftime("%d/%m/%Y")
            except (KeyError, ValueError):
                date_txt = ""
            date = Adw.EntryRow(title=_("Date d'expiration (JJ/MM/AAAA)"), text=date_txt)
            rappel = Adw.ComboRow(title=_("Me prévenir"), model=Gtk.StringList.new([l for _j, l in RAPPELS]))
            jours = [j for j, _l in RAPPELS]
            rappel.set_selected(jours.index(e.get("rappel")) if e.get("rappel") in jours else 1)
            # le type choisi propose son délai de rappel habituel (ex. 3 mois pour une carte d'identité)
            genre.connect("notify::selected", lambda c, _p: index is None and rappel.set_selected(
                jours.index(TYPES[c.get_selected()][2]) if TYPES[c.get_selected()][2] in jours else 1))
            for w in (genre, titre, date, rappel):
                g.add(w)
            d = Adw.AlertDialog(heading=_("Nouvelle échéance") if index is None else _("Modifier l'échéance"))
            d.set_extra_child(g)
            d.add_response("annuler", _("Annuler"))
            d.add_response("ok", _("Enregistrer"))
            d.set_response_appearance("ok", Adw.ResponseAppearance.SUGGESTED)

            def reponse(_d, rep):
                if rep != "ok":
                    return
                jour = lire_date(date.get_text())
                if jour is None:
                    self.toast(_("Date invalide : écrivez-la comme 12/03/2027"))
                    return
                nouvelle = {"type": TYPES[genre.get_selected()][0], "titre": titre.get_text().strip(),
                            "date": jour.isoformat(), "rappel": RAPPELS[rappel.get_selected()][0]}
                liste = lire_json(ECHEANCES, [])
                if index is None:
                    liste.append(nouvelle)
                else:
                    liste[index] = nouvelle
                ecrire_json(ECHEANCES, liste)
                self.construire_echeances()
            d.connect("response", reponse)
            d.present(self)

        def supprimer(self, index):
            liste = lire_json(ECHEANCES, [])
            if 0 <= index < len(liste):
                del liste[index]
                ecrire_json(ECHEANCES, liste)
            self.construire_echeances()

    class Appli(Adw.Application):
        def __init__(self):
            super().__init__(application_id=APP_ID)

        def do_activate(self):
            (self.props.active_window or Fenetre(self)).present()

    return Appli().run([sys.argv[0]])


if __name__ == "__main__":
    if "--fermer" in sys.argv[1:]:
        sys.exit(0 if fermer()[0] else 1)
    sys.exit(fenetre())
