#!/usr/bin/python3
"""kemmos-formation — La formation Linux de KemmOS, dans sa propre fenêtre.

L'application de formation est une page web (HTML, CSS, JavaScript) rangée dans
/usr/share/kemmos-formation. Ce lanceur :
  1. démarre un petit serveur web LOCAL (adresse 127.0.0.1 : personne d'autre que
     cet ordinateur ne peut s'y connecter) qui sert ces fichiers ;
  2. ouvre une fenêtre avec un moteur web (WebKitGTK) qui affiche la page.

Pourquoi pas le navigateur ? La progression de l'élève est gardée par le moteur web
(localStorage). Un navigateur qui efface les données des sites en se fermant (comme
LibreWolf) ferait tout perdre. Ici, elle est rangée dans ~/.local/share/kemmos-formation.

Le port du serveur dépend du numéro de l'utilisateur (41000 pour uid 1000) : il reste
le même d'une fois sur l'autre, donc la progression est retrouvée.

1.1.0 : la page peut demander d'ouvrir le VRAI terminal (bouton « Essayer sur mon ordinateur » des leçons) :
message « kemmos » {action: "terminal", commandes: [...]} → Ptyxis s'ouvre, la PREMIÈRE commande est copiée dans
le presse-papiers, sans retour à la ligne (coller plusieurs lignes les exécutait toutes : rien ne doit se lancer
à la place de l'élève).

Variables pour les tests : KEMMOS_FORMATION_DIR (autre dossier de l'appli),
KEMMOS_LOCALE (fr, br ou en).
"""

import functools
import http.server
import json
import os
import shutil
import subprocess
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, Gdk, Gio, GLib, Gtk, WebKit  # noqa: E402

ID = "org.kemmos.Formation"
RACINE = os.environ.get("KEMMOS_FORMATION_DIR", "/usr/share/kemmos-formation")

# ---------- Les quelques textes du lanceur (l'appli elle-même est en français) ----------

TEXTES = {
    "titre": {"fr": "Formation Linux", "br": "Stummadur Linux", "en": "Linux training"},
    "enregistre": {"fr": "Enregistré : {}", "br": "Enrollet : {}", "en": "Saved: {}"},
    "echec-telechargement": {
        "fr": "L'enregistrement a échoué : {}",
        "br": "C'hwitet eo an enrollañ : {}",
        "en": "Saving failed: {}",
    },
    "terminal": {
        "fr": "Terminal ouvert : collez la commande avec Ctrl+Maj+V, puis Entrée",
        "br": "Termenell digor : pegit an urzhiad gant Ctrl+Pennlizherenn+V, ha neuze Enter",
        "en": "Terminal opened: paste the command with Ctrl+Shift+V, then press Enter",
    },
    "sans-terminal": {"fr": "Aucun terminal trouvé", "br": "Termenell ebet kavet", "en": "No terminal found"},
    "sans-serveur": {
        "fr": "Impossible de démarrer le serveur local de la formation (aucun port libre).",
        "br": "N'haller ket loc'hañ servijer lec'hel ar stummadur (porzh dieub ebet).",
        "en": "Could not start the training's local server (no free port).",
    },
}


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 web local ----------


class Gestionnaire(http.server.SimpleHTTPRequestHandler):
    """Sert les fichiers de l'appli, sans cache (une mise à jour du paquet se voit tout de suite)."""

    extensions_map = {**http.server.SimpleHTTPRequestHandler.extensions_map, ".js": "text/javascript", ".md": "text/markdown; charset=utf-8"}

    def end_headers(self):
        self.send_header("Cache-Control", "no-store")
        super().end_headers()

    def log_message(self, *args):
        pass  # pas de journal à chaque fichier servi


def demarrer_serveur():
    """Démarre le serveur dans un fil à part. Renvoie son adresse, ou None si aucun port n'est libre."""
    gestionnaire = functools.partial(Gestionnaire, directory=RACINE)
    depart = 40000 + os.getuid() % 10000
    for port in range(depart, depart + 20):
        try:
            serveur = http.server.ThreadingHTTPServer(("127.0.0.1", port), gestionnaire)
        except OSError:
            continue  # port déjà pris : on essaie le suivant
        serveur.daemon_threads = True
        threading.Thread(target=serveur.serve_forever, daemon=True).start()
        return f"http://127.0.0.1:{port}/"
    return None


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


class Fenetre(Adw.ApplicationWindow):
    def __init__(self, appli, adresse):
        super().__init__(application=appli, title=_("titre"), default_width=1200, default_height=820)
        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)

        # Les données (progression, réglages) restent d'une fois sur l'autre
        donnees = os.path.join(GLib.get_user_data_dir(), "kemmos-formation")
        cache = os.path.join(GLib.get_user_cache_dir(), "kemmos-formation")
        session = WebKit.NetworkSession.new(donnees, cache)
        session.connect("download-started", self.telechargement)

        # Messages de la page (1.1.0) : window.webkit.messageHandlers.kemmos.postMessage({...})
        contenu = WebKit.UserContentManager()
        contenu.register_script_message_handler("kemmos", None)
        contenu.connect("script-message-received::kemmos", self.message_page)

        self.vue = WebKit.WebView(network_session=session, user_content_manager=contenu)
        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)

    def message_page(self, _contenu, valeur):
        """La page demande d'ouvrir le vrai terminal : commandes copiées, Ptyxis ouvert dans le dossier personnel."""
        try:
            message = json.loads(valeur.to_json(0))
        except (ValueError, AttributeError):
            return
        if not isinstance(message, dict) or message.get("action") != "terminal":
            return
        commandes = [c for c in message.get("commandes", []) if isinstance(c, str)][:20]
        if commandes:
            Gdk.Display.get_default().get_clipboard().set(commandes[0].strip())
        for appli, secours in (("org.gnome.Ptyxis.desktop", "ptyxis"), ("org.gnome.Console.desktop", "kgx")):
            try:
                info = Gio.DesktopAppInfo.new(appli)
            except TypeError:
                info = None
            if info:
                info.launch([], None)
                self.toast(_("terminal"))
                return
            if shutil.which(secours):
                subprocess.Popen([secours], cwd=GLib.get_home_dir(), start_new_session=True)
                self.toast(_("terminal"))
                return
        self.toast(_("sans-terminal"))

    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 liens vers Internet s'ouvrent dans le navigateur ; l'appli 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 téléchargements « download »)

    # Exporter sa progression ou une fiche mémo : 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 "formation-linux"
        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

    def do_startup(self):
        Adw.Application.do_startup(self)
        GLib.set_application_name(_("titre"))
        self.adresse = 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 l'appli 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"))
            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))
