#!/usr/bin/env python3
# ═══════════════════════════════════════════════════════════════════════════
# SONDE D'ACCESSIBILITÉ — ce qui se vérifie sur le HTML servi, et rien de plus
# ═══════════════════════════════════════════════════════════════════════════
#
# Produit TEMPOsystem. ⚠️ SÉPARÉE de `sonde-seuil.py`, qui appartient à la
# mesure associative d'Alliance MANA : même méthode, deux populations, deux
# artefacts. Cette séparation est fiscale autant que morale — voir le plan.
#
# 🔴 TROIS ÉTATS, JAMAIS DEUX. Chaque critère rend :
#     C   conforme          — vérifié, et ça passe
#     NC  non conforme      — vérifié, et ça ne passe pas
#     NT  NON TESTABLE      — l'instrument ne sait pas voir cela
#
# ⭐ Le troisième état est le produit. Un outil qui rend « conforme » là où il
# n'a rien pu lire vend une certitude qu'il n'a pas. Le RGAA lui-même prévoit
# « Non Applicable » ; nous ajoutons « Non Testable », qui dit quelque chose sur
# NOUS et pas sur le site — et c'est précisément ce qu'un avocat veut savoir
# avant d'opposer un rapport.
#
# ⚠️ CE QUE CETTE SONDE NE VERRA JAMAIS, et qui est déclaré dans chaque dossier :
#   · le CONTRASTE réel — il demande le rendu, donc un navigateur ;
#   · l'ORDRE DE TABULATION effectif, et le piège au clavier ;
#   · tout ce qu'un JavaScript injecte après le chargement ;
#   · la PERTINENCE d'un texte alternatif ou d'un intitulé de lien — c'est du
#     SENS, et c'est là, et seulement là, qu'un modèle de langage intervient ;
#   · le comportement réel sous lecteur d'écran.
# Ces cinq lignes valent un argument commercial : nous mesurons un PLANCHER et
# nous le disons. Un concurrent qui annonce un taux de conformité depuis le seul
# HTML annonce un chiffre qu'il ne peut pas tenir.
#
# Usage :  python3 sonde-a11y.py domaines.csv > a11y.csv
#   entrée : une colonne `domaine` (les autres colonnes sont conservées)

import csv, re, ssl, sys, gzip, socket
from collections import Counter
from concurrent.futures import ThreadPoolExecutor
from html.parser import HTMLParser
from urllib.request import Request, urlopen

AGENT = ("Mozilla/5.0 (compatible; TEMPOsystem-a11y/1.0; +https://temposystem.eu/ ; "
         "contact@temposystem.eu) mesure d'accessibilite")
DELAI = 20
PARALLELE = 4

# Les types de champ qui n'appellent pas d'étiquette visible.
SANS_ETIQUETTE = {"hidden", "submit", "button", "reset", "image"}

import unicodedata
def _sans_accent(t):
    return "".join(c for c in unicodedata.normalize("NFD", t.lower())
                   if unicodedata.category(c) != "Mn")

# ⭐ LA MENTION EST IMPOSÉE PAR L'ARRÊTÉ DU 20 SEPTEMBRE 2019 : toute page doit
# porter « Accessibilité : totalement / partiellement / non conforme ». C'est
# une DÉCLARATION FAITE PAR LE SITE LUI-MÊME. Nous la lisons telle quelle — et
# c'est le seul endroit où nous n'avons rien à prouver : c'est lui qui parle.
MENTION = re.compile(r"accessibilite\s*:?\s*(totalement|partiellement|non)\s+conforme")

# Les adresses où une déclaration se range quand elle n'est pas en page d'accueil.
# ⚠️ On ne les interroge QUE si la page d'accueil n'a rien dit : une requête de
# plus par site sondé, jamais six.
CHEMINS_USUELS = ["/accessibilite", "/accessibilite.html", "/declaration-accessibilite",
                  "/fr/accessibilite", "/mentions-legales"]


class Page(HTMLParser):
    """Un seul passage sur le document. On collecte des FAITS, on ne juge pas ici."""

    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.lang = None
        self.titre = ""
        self._dans_titre = False
        self.img_total = 0
        self.img_sans_alt = 0
        self.iframes = 0
        self.iframes_sans_titre = 0
        self.iframes_masquees = 0
        self._dans_noscript = 0
        self.liens = 0
        self.liens_muets = 0
        self.boutons = 0
        self.boutons_muets = 0
        self.champs = 0
        self.champs_sans_etiquette = 0
        self.titres = []            # niveaux rencontrés, dans l'ordre
        self.tables = 0
        self.tables_sans_th = 0
        self._table_a_th = []
        self.ids = Counter()
        self.tabindex_positif = 0
        self.autoplay = 0
        self.labels_for = set()
        self.liens_accessibilite = 0
        self.chemins_accessibilite = []   # les cibles trouvées, pour le dossier
        self.texte_corps = []             # ce que la page dit sans JavaScript
        self._dans_a = 0
        # un élément « muet » peut recevoir du texte ensuite : on garde la pile
        self._pile_lien = []
        self._pile_bouton = []
        self._champs_en_attente = []   # (id, a_une_etiquette_intrinseque)
        self._dans_label = 0

    # ── collecte ──────────────────────────────────────────────────────────
    def handle_starttag(self, tag, attrs):
        a = {k.lower(): (v or "") for k, v in attrs}
        if tag == "html":
            self.lang = a.get("lang") or a.get("xml:lang")
        elif tag == "title":
            self._dans_titre = True
        elif tag == "img":
            self.img_total += 1
            # 🔴 FAUTE DE LA v1, TROUVÉE SUR ameli.fr. Un lien qui ne contient
            # qu'une image porte son intitulé dans l'`alt` de cette image, pas
            # dans du texte. Ne compter que le texte accusait de « lien muet »
            # des liens parfaitement accessibles — et un rapport qui accuse à
            # tort se retourne entièrement contre celui qui le signe.
            if (a.get("alt") or "").strip():
                if self._pile_lien:
                    self._pile_lien[-1] = True
                if self._pile_bouton:
                    self._pile_bouton[-1] = True
            # ⚠️ `alt=""` est VALIDE : il déclare une image décorative. L'absence
            # d'attribut, elle, est une faute. Confondre les deux ferait un
            # rapport faux dans le sens le plus coûteux — celui qui accuse.
            if "alt" not in a:
                self.img_sans_alt += 1
        elif tag == "iframe":
            # ⚠️ Celle de Google Tag Manager vit dans un <noscript>, masquée : un
            # lecteur d'écran ne la rencontre jamais. L'exiger titrée serait
            # reprocher une faute à un objet que personne ne peut atteindre.
            style = (a.get("style") or "").replace(" ", "").lower()
            masquee = (self._dans_noscript > 0 or "hidden" in a
                       or a.get("aria-hidden") == "true"
                       or "display:none" in style or "visibility:hidden" in style)
            if masquee:
                self.iframes_masquees += 1
            else:
                self.iframes += 1
                if not (a.get("title") or "").strip() and not a.get("aria-label"):
                    self.iframes_sans_titre += 1
        elif tag == "noscript":
            self._dans_noscript += 1
        elif tag == "a":
            if "href" in a:
                self.liens += 1
                nomme = bool((a.get("aria-label") or a.get("title") or "").strip())
                self._pile_lien.append(nomme)
                self._dans_a += 1
                cible = (a.get("href") or "")
                if "accessib" in _sans_accent(cible):
                    self.liens_accessibilite += 1
                    self.chemins_accessibilite.append(cible[:120])
        elif tag == "button":
            self.boutons += 1
            self._pile_bouton.append(bool((a.get("aria-label") or a.get("title") or "").strip()))
        elif tag == "label":
            self._dans_label += 1
            if a.get("for"):
                self.labels_for.add(a["for"])
        elif tag in ("input", "select", "textarea"):
            if tag == "input" and a.get("type", "text").lower() in SANS_ETIQUETTE:
                pass
            else:
                self.champs += 1
                intrinseque = bool(
                    (a.get("aria-label") or a.get("aria-labelledby") or a.get("title") or "").strip()
                ) or self._dans_label > 0
                self._champs_en_attente.append((a.get("id", ""), intrinseque))
        elif tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
            self.titres.append(int(tag[1]))
        elif tag == "table":
            self.tables += 1
            self._table_a_th.append(False)
        elif tag == "th" and self._table_a_th:
            self._table_a_th[-1] = True
        elif tag in ("video", "audio") and "autoplay" in a:
            self.autoplay += 1

        if a.get("id"):
            self.ids[a["id"]] += 1
        ti = a.get("tabindex")
        if ti and ti.lstrip("+").isdigit() and int(ti) > 0:
            self.tabindex_positif += 1

    def handle_endtag(self, tag):
        if tag == "title":
            self._dans_titre = False
        elif tag == "noscript":
            self._dans_noscript = max(0, self._dans_noscript - 1)
        elif tag == "a":
            self._dans_a = max(0, self._dans_a - 1)
            if self._pile_lien and not self._pile_lien.pop():
                self.liens_muets += 1
        elif tag == "button" and self._pile_bouton:
            if not self._pile_bouton.pop():
                self.boutons_muets += 1
        elif tag == "label":
            self._dans_label = max(0, self._dans_label - 1)
        elif tag == "table" and self._table_a_th:
            if not self._table_a_th.pop():
                self.tables_sans_th += 1

    def handle_data(self, texte):
        if self._dans_titre:
            self.titre += texte
        t = texte.strip()
        if t:
            self.texte_corps.append(t)
            # ⭐ Un lien « Accessibilité : partiellement conforme » ne porte le mot
            # que dans son TEXTE. Ne regarder que le `href` ratait la moitié du web.
            if self._dans_a and "accessib" in _sans_accent(t):
                self.liens_accessibilite += 1
            # du texte à l'intérieur d'un lien ou d'un bouton le rend nommé
            if self._pile_lien:
                self._pile_lien[-1] = True
            if self._pile_bouton:
                self._pile_bouton[-1] = True

    # ── jugement, séparé de la collecte ───────────────────────────────────
    def verdicts(self):
        """Rend {critere: (etat, detail)} — jamais un score."""
        v = {}

        v["lang"] = ("C", self.lang) if (self.lang or "").strip() else ("NC", "attribut lang absent")
        t = self.titre.strip()
        v["titre_page"] = ("C", t[:60]) if t else ("NC", "titre de page vide ou absent")

        v["img_alt"] = (
            ("NT", "aucune image") if self.img_total == 0 else
            ("C", f"{self.img_total} images, toutes pourvues") if self.img_sans_alt == 0 else
            ("NC", f"{self.img_sans_alt} image(s) sans attribut alt sur {self.img_total}")
        )
        v["liens_intitules"] = (
            ("NT", "aucun lien") if self.liens == 0 else
            ("C", f"{self.liens} liens nommés") if self.liens_muets == 0 else
            ("NC", f"{self.liens_muets} lien(s) sans intitulé sur {self.liens}")
        )
        v["boutons_intitules"] = (
            ("NT", "aucun bouton") if self.boutons == 0 else
            ("C", f"{self.boutons} boutons nommés") if self.boutons_muets == 0 else
            ("NC", f"{self.boutons_muets} bouton(s) sans intitulé sur {self.boutons}")
        )

        sans_etiq = sum(
            1 for cid, intr in self._champs_en_attente
            if not intr and cid not in self.labels_for
        )
        v["champs_etiquetes"] = (
            ("NT", "aucun champ") if self.champs == 0 else
            ("C", f"{self.champs} champs étiquetés") if sans_etiq == 0 else
            ("NC", f"{sans_etiq} champ(s) sans étiquette sur {self.champs}")
        )

        v["iframes_titrees"] = (
            ("NT", f"aucune iframe visible"
                   + (f" ({self.iframes_masquees} masquée(s), écartée(s))" if self.iframes_masquees else ""))
            if self.iframes == 0 else
            ("C", f"{self.iframes} iframes titrées"
                  + (f" ({self.iframes_masquees} masquée(s), écartée(s))" if self.iframes_masquees else ""))
            if self.iframes_sans_titre == 0 else
            ("NC", f"{self.iframes_sans_titre} iframe(s) sans title sur {self.iframes}")
        )

        # 🔴 LA v1 RENDAIT « NC » À PARTIR DE DEUX h1, ET C'ÉTAIT UNE CONVENTION
        # PRISE POUR LA NORME. Le RGAA exige une hiérarchie cohérente, pas un h1
        # unique ; HTML5 en admet plusieurs dans des sections distinctes, et sur
        # ameli.fr le second titrait une boîte de dialogue. ⭐ Un critère
        # DISPONIBLE n'est pas un critère JUSTE : ce qui manque vraiment à une
        # page, c'est de n'avoir AUCUN titre de premier niveau.
        n_h1 = self.titres.count(1)
        v["h1"] = (
            ("NC", "aucun h1 — la page n'a pas de titre de premier niveau") if n_h1 == 0 else
            ("C", "un h1") if n_h1 == 1 else
            ("C", f"{n_h1} h1 — admis en HTML5, à vérifier à la main si ce sont bien "
                  "des sections distinctes")
        )
        sauts = [
            (a, b) for a, b in zip(self.titres, self.titres[1:]) if b > a + 1
        ]
        v["hierarchie_titres"] = (
            ("NT", "moins de deux titres") if len(self.titres) < 2 else
            ("C", f"{len(self.titres)} titres, sans saut") if not sauts else
            ("NC", f"{len(sauts)} saut(s) de niveau, ex. h{sauts[0][0]} → h{sauts[0][1]}")
        )

        v["tableaux_entetes"] = (
            ("NT", "aucun tableau") if self.tables == 0 else
            ("C", f"{self.tables} tableaux pourvus") if self.tables_sans_th == 0 else
            ("NC", f"{self.tables_sans_th} tableau(x) sans th sur {self.tables}")
        )

        doublons = [i for i, n in self.ids.items() if n > 1]
        v["ids_uniques"] = (
            ("NT", "aucun id") if not self.ids else
            ("C", f"{len(self.ids)} ids uniques") if not doublons else
            ("NC", f"{len(doublons)} id(s) en double, ex. « {doublons[0][:30]} »")
        )

        v["tabindex"] = (
            ("C", "aucun tabindex positif") if self.tabindex_positif == 0 else
            ("NC", f"{self.tabindex_positif} tabindex positif(s)")
        )
        v["autoplay"] = (
            ("C", "aucun média en lecture automatique") if self.autoplay == 0 else
            ("NC", f"{self.autoplay} média(s) en autoplay")
        )

        # ⭐ Le signal le plus fort du lot : la déclaration d'accessibilité est
        # elle-même une OBLIGATION (arrêté du 20/09/2019), et elle se voit de
        # l'extérieur en une seconde.
        #
        # 🔴 MAIS LA PREMIÈRE VERSION A ÉCRIT « AUCUNE DÉCLARATION » SUR
        # service-public.fr. Le site en a une ; son pied de page est injecté par
        # JavaScript, et je n'avais lu qu'une page. ⭐ Trouver est une preuve,
        # NE PAS TROUVER n'en est pas une — j'avais fait dire à l'absence ce que
        # seule une recherche peut dire. Le sentinelle `CHERCHER` renvoie donc la
        # question à `sonder()`, qui va VOIR aux adresses usuelles avant de
        # conclure. Sur un faux rouge, le client agit : il coûte plus qu'un vert.
        v["declaration_accessibilite"] = (
            ("C", f"trouvée en page d'accueil ({self.liens_accessibilite} lien(s))")
            if self.liens_accessibilite else ("CHERCHER", "")
        )

        # Ce que le site déclare de LUI-MÊME. Donnée, pas verdict.
        m = MENTION.search(_sans_accent(" ".join(self.texte_corps)))
        v["_conformite_declaree"] = ("", m.group(1) if m else "")

        # Les cinq que nous ne savons pas voir. Déclarées, jamais omises.
        for critere, pourquoi in [
            ("contraste", "demande le rendu de la page"),
            ("ordre_tabulation", "demande une interaction clavier"),
            ("contenu_injecte_js", "demande l'exécution du JavaScript"),
            ("pertinence_alternatives", "demande un jugement de sens"),
            ("lecteur_ecran", "demande une restitution vocale"),
        ]:
            v[critere] = ("NT", pourquoi)

        return v


CRITERES = [
    "lang", "titre_page", "img_alt", "liens_intitules", "boutons_intitules",
    "champs_etiquetes", "iframes_titrees", "h1", "hierarchie_titres",
    "tableaux_entetes", "ids_uniques", "tabindex", "autoplay",
    "declaration_accessibilite",
    "contraste", "ordre_tabulation", "contenu_injecte_js",
    "pertinence_alternatives", "lecteur_ecran",
]


def _charger(url, ctx):
    """Rend (html, code) ou (None, nom_de_l_erreur). Une seule requête."""
    try:
        req = Request(url, headers={"User-Agent": AGENT, "Accept-Encoding": "gzip",
                                    "Accept-Language": "fr,en;q=0.5"})
        with urlopen(req, timeout=DELAI, context=ctx) as r:
            brut = r.read(3_000_000)
            if r.headers.get("Content-Encoding") == "gzip":
                try:
                    brut = gzip.decompress(brut)
                except Exception:
                    pass
            return brut.decode("utf-8", "replace"), r.status
    except Exception as e:
        return None, type(e).__name__


def _chercher_declaration(racine, ctx):
    """Va voir aux adresses usuelles. Rend (etat, detail).

    ⚠️ Le troisième état sert ici pleinement : une adresse qui répond 200 avec la
    page d'accueil (beaucoup de sites redirigent tout vers elle) ne prouve rien.
    On exige que la page trouvée PARLE d'accessibilité.
    """
    vus = []
    for chemin in CHEMINS_USUELS:
        html, code = _charger(racine + chemin, ctx)
        if html is None:
            continue
        p = Page()
        try:
            p.feed(html)
        except Exception:
            pass
        corps = _sans_accent(" ".join(p.texte_corps))
        if MENTION.search(corps) or corps.count("accessib") >= 3:
            return "C", f"trouvée à {chemin}"
        vus.append(f"{chemin}={code}")
    return "NC", "absente de la page d'accueil et des adresses usuelles (" + \
                 (", ".join(vus) or "aucune ne répond") + ")"


def sonder(ligne):
    domaine = ligne["domaine"].strip()
    res = dict(ligne)
    res.update({"joignable": 0, "code": "", "texte_servi": 0,
                "conformite_declaree": "", "contradiction": ""})
    for c in CRITERES:
        res[c] = ""
        res[c + "_detail"] = ""

    ctx = ssl.create_default_context()
    ctx.check_hostname = False
    ctx.verify_mode = ssl.CERT_NONE
    for schema in ("https://", "http://"):
        racine = schema + domaine
        html, code = _charger(racine, ctx)
        res["code"] = code
        if html is None:
            continue

        res["joignable"] = 1
        p = Page()
        try:
            p.feed(html)
        except Exception:
            pass
        verdicts = p.verdicts()
        res["conformite_declaree"] = verdicts.pop("_conformite_declaree")[1]
        res["texte_servi"] = sum(len(t) for t in p.texte_corps)

        for critere, (etat, detail) in verdicts.items():
            if etat == "CHERCHER":
                etat, detail = _chercher_declaration(racine, ctx)
            res[critere] = etat
            res[critere + "_detail"] = detail

        etats = [res[c] for c in CRITERES]
        res["nb_C"] = etats.count("C")
        res["nb_NC"] = etats.count("NC")
        res["nb_NT"] = etats.count("NT")

        # ⭐ LE POINT QUI SE PLAIDE. Le site déclare « totalement conforme » et la
        # sonde relève au moins un manquement AUTOMATIQUE, donc indiscutable : la
        # déclaration est contredite par le HTML que le site sert lui-même. Ce
        # n'est pas notre jugement contre le sien — c'est le sien contre le sien.
        if res["conformite_declaree"] == "totalement" and res["nb_NC"] > 0:
            res["contradiction"] = "déclare totalement conforme, " \
                                   f"{res['nb_NC']} manquement(s) automatiques relevés"
        break
    return res


def main():
    lignes = list(csv.DictReader(open(sys.argv[1], newline="", encoding="utf-8")))
    colonnes = list(lignes[0].keys()) + ["joignable", "code", "texte_servi",
                                         "conformite_declaree", "contradiction"]
    for c in CRITERES:
        colonnes += [c, c + "_detail"]
    colonnes += ["nb_C", "nb_NC", "nb_NT"]

    w = csv.DictWriter(sys.stdout, fieldnames=colonnes, extrasaction="ignore")
    w.writeheader()
    socket.setdefaulttimeout(DELAI + 5)
    faits = 0
    with ThreadPoolExecutor(max_workers=PARALLELE) as pool:
        for r in pool.map(sonder, lignes):
            w.writerow(r)
            faits += 1
            if faits % 25 == 0:
                print(f"  … {faits}/{len(lignes)}", file=sys.stderr, flush=True)
    print(f"  terminé : {faits}", file=sys.stderr)


if __name__ == "__main__":
    main()