#!/usr/bin/python3
"""kemmos-limier — Limier, l'outil de recherche de l'enquêteur, dans sa propre fenêtre.

Limier (rangé dans /usr/share/kemmos-limier) est fait de deux morceaux :
  - un serveur LOCAL en Python (adresse 127.0.0.1 : personne d'autre que cet ordinateur ne
    peut s'y connecter) qui interroge les moteurs de recherche et range les enquêtes ;
  - une interface web (HTML, CSS, JavaScript) qui lui parle.
Ce lanceur démarre le serveur dans le même programme, puis ouvre une fenêtre avec un moteur
web (WebKitGTK) qui affiche l'interface. Les liens des résultats s'ouvrent dans le navigateur.

Les enquêtes et les réglages sont rangés comme avec ./lancer.sh :
~/.local/share/limier/enquetes et ~/.config/limier/reglages.json.
Le port dépend du numéro de l'utilisateur (51000 pour uid 1000), pour que les petites
préférences de l'interface (thème, enquête ouverte) soient retrouvées d'une fois sur l'autre.

« kemmos-limier --arnaque » ouvre « Est-ce une arnaque ? » (1.1.0) : la page de vérification d'un lien, d'un
SMS ou d'un e-mail, dans sa propre fenêtre (identifiant org.kemmos.Arnaque, icône à part dans le menu).

Variables pour les tests : KEMMOS_LIMIER_DIR (autre dossier de Limier), KEMMOS_LOCALE (fr, br ou en).
"""

import os
import shutil
import sys
import threading

import gi

gi.require_version("Gtk", "4.0")
gi.require_version("Adw", "1")
gi.require_version("WebKit", "6.0")
from gi.repository import Adw, Gio, GLib, Gtk, WebKit  # noqa: E402

ARNAQUE = "--arnaque" in sys.argv[1:]
ID = "org.kemmos.Arnaque" if ARNAQUE else "org.kemmos.Limier"
PAGE = "arnaque.html" if ARNAQUE else ""
RACINE = os.environ.get("KEMMOS_LIMIER_DIR", "/usr/share/kemmos-limier")

# ---------- Les quelques textes du lanceur (Limier lui-même est en français) ----------

TEXTES = {
    "titre": {"fr": "Est-ce une arnaque ?", "br": "Est-ce une arnaque ?", "en": "Is it a scam?"} if ARNAQUE
    else {"fr": "Limier", "br": "Limier", "en": "Limier"},
    "enregistre": {"fr": "Enregistré : {}", "br": "Enrollet : {}", "en": "Saved: {}"},
    "echec-telechargement": {
        "fr": "L'enregistrement a échoué : {}",
        "br": "C'hwitet eo an enrollañ : {}",
        "en": "Saving failed: {}",
    },
    "sans-serveur": {
        "fr": "Impossible de démarrer le serveur local de Limier : {}",
        "br": "N'haller ket loc'hañ servijer lec'hel Limier : {}",
        "en": "Could not start Limier's local server: {}",
    },
}


def langue():
    """fr, br ou en, d'après la langue de la session (le breton et le français d'abord)."""
    for variable in ("KEMMOS_LOCALE", "LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"):
        valeur = os.environ.get(variable, "")
        if valeur and valeur not in ("C", "POSIX"):
            code = valeur.split(":")[0][:2]
            return code if code in ("fr", "br") else "en"
    return "fr"


LANGUE = langue()


def _(cle, *valeurs):
    return TEXTES[cle][LANGUE].format(*valeurs)


# ---------- Le serveur de Limier ----------


def demarrer_serveur():
    """Démarre le serveur de Limier dans un fil à part. Renvoie (adresse, None) ou (None, erreur)."""
    sys.dont_write_bytecode = True  # /usr/share n'est pas modifiable : pas de __pycache__
    sys.path.insert(0, RACINE)
    try:
        from limier.api import demarrer  # noqa: E402  (importé ici : le chemin vient d'être ajouté)

        serveur, port = demarrer(50000 + os.getuid() % 10000)  # essaie 20 ports à partir de celui-ci
    except (ImportError, SystemExit, OSError) as e:
        return None, str(e)
    serveur.daemon_threads = True
    threading.Thread(target=serveur.serve_forever, daemon=True).start()
    return f"http://127.0.0.1:{port}/", None


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


class Fenetre(Adw.ApplicationWindow):
    def __init__(self, appli, adresse):
        super().__init__(application=appli, title=_("titre"), default_width=860 if ARNAQUE else 1280,
                         default_height=900 if ARNAQUE else 860)
        self.adresse = adresse
        # Une barre de titre GNOME (déplacer, agrandir, fermer) au-dessus de la page
        self.toasts = Adw.ToastOverlay()
        cadre = Adw.ToolbarView()
        cadre.add_top_bar(Adw.HeaderBar())
        cadre.set_content(self.toasts)
        self.set_content(cadre)

        # Session éphémère : la fenêtre n'écrit rien sur le disque (cache des vignettes…) ; ce qui doit rester
        # (historique, enquêtes, réglages, thème) est gardé par Limier. Données des versions 1.0.0 et 1.0.1 effacées.
        for ancien in (os.path.join(GLib.get_user_data_dir(), "kemmos-limier"), os.path.join(GLib.get_user_cache_dir(), "kemmos-limier")):
            shutil.rmtree(ancien, ignore_errors=True)
        session = WebKit.NetworkSession.new_ephemeral()
        session.connect("download-started", self.telechargement)

        self.vue = WebKit.WebView(network_session=session)
        reglages = self.vue.get_settings()
        reglages.set_enable_developer_extras(False)
        reglages.set_javascript_can_open_windows_automatically(False)
        self.vue.connect("decide-policy", self.decider)
        self.vue.connect("notify::title", self.titre_change)
        self.toasts.set_child(self.vue)
        self.vue.load_uri(adresse + PAGE)

    def titre_change(self, vue, _param):
        titre = vue.get_title()
        self.set_title(titre if titre else _("titre"))

    def decider(self, _vue, decision, type_decision):
        """Les résultats et les liens vers Internet s'ouvrent dans le navigateur ; Limier reste dans la fenêtre."""
        if type_decision in (WebKit.PolicyDecisionType.NAVIGATION_ACTION, WebKit.PolicyDecisionType.NEW_WINDOW_ACTION):
            uri = decision.get_navigation_action().get_request().get_uri()
            if uri.startswith(("http://", "https://", "mailto:")) and not uri.startswith(self.adresse):
                Gtk.UriLauncher.new(uri).launch(self, None, None, None)
                decision.ignore()
                return True
        return False  # WebKit fait le reste (dont les exports, qui sont des téléchargements)

    # Exports (CSV, JSON, Markdown, rapport HTML, enquête) : le fichier va dans Téléchargements
    def telechargement(self, _session, telechargement):
        telechargement.connect("decide-destination", self.destination)
        telechargement.connect("finished", self.telechargement_fini)
        telechargement.connect("failed", lambda _t, erreur: self.toast(_("echec-telechargement", erreur.message)))

    def destination(self, telechargement, nom_propose):
        dossier = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_DOWNLOAD) or GLib.get_home_dir()
        os.makedirs(dossier, exist_ok=True)
        nom = os.path.basename(nom_propose) or "limier"
        base, extension = os.path.splitext(nom)
        chemin = os.path.join(dossier, nom)
        n = 1
        while os.path.exists(chemin):  # ne jamais écraser un fichier : nom (1), nom (2)…
            chemin = os.path.join(dossier, f"{base} ({n}){extension}")
            n += 1
        telechargement.set_destination(chemin)
        return True

    def telechargement_fini(self, telechargement):
        chemin = telechargement.get_destination()
        if chemin and os.path.exists(chemin):
            self.toast(_("enregistre", chemin.replace(GLib.get_home_dir(), "~", 1)))

    def toast(self, texte):
        self.toasts.add_toast(Adw.Toast.new(texte))


class Appli(Adw.Application):
    def __init__(self):
        super().__init__(application_id=ID, flags=Gio.ApplicationFlags.DEFAULT_FLAGS)
        self.adresse = None
        self.erreur = None

    def do_startup(self):
        Adw.Application.do_startup(self)
        GLib.set_application_name(_("titre"))
        self.adresse, self.erreur = demarrer_serveur()
        # Raccourcis : Ctrl+Q / Ctrl+W pour fermer, Ctrl+R / F5 pour recharger
        quitter = Gio.SimpleAction.new("quitter", None)
        quitter.connect("activate", lambda *_a: self.quit())
        self.add_action(quitter)
        self.set_accels_for_action("app.quitter", ["<Control>q", "<Control>w"])
        recharger = Gio.SimpleAction.new("recharger", None)
        recharger.connect("activate", lambda *_a: self.props.active_window and self.props.active_window.vue.reload())
        self.add_action(recharger)
        self.set_accels_for_action("app.recharger", ["<Control>r", "F5"])

    def do_activate(self):
        # Une seule fenêtre : relancer Limier la remet au premier plan
        if self.props.active_window:
            self.props.active_window.present()
            return
        if not self.adresse:
            dialogue = Adw.AlertDialog.new(_("titre"), _("sans-serveur", self.erreur))
            dialogue.add_response("ok", "OK")
            fenetre = Adw.ApplicationWindow(application=self, title=_("titre"))
            fenetre.present()
            dialogue.connect("response", lambda *_a: self.quit())
            dialogue.present(fenetre)
            return
        Fenetre(self, self.adresse).present()


if __name__ == "__main__":
    raise SystemExit(Appli().run(None))
