"""Authentification auprès du serveur, après montage du tunnel.

Le tunnel qui monte ne donne accès à rien : le serveur place le pair en
quarantaine et ne laisse passer son trafic vers le réseau distant qu'une
fois un code à 6 chiffres validé. C'est ce que fait ce module.

Le code est vérifié **par le serveur**, contre un secret que cette
application ne détient pas — contrairement au MFA local d'origine, qui
validait un code qu'elle pouvait elle-même produire, et ne verrouillait
donc que sa propre interface.

L'ordre est imposé par le réseau : l'API du serveur n'est joignable que
depuis l'intérieur du tunnel. On monte donc d'abord, on s'authentifie
ensuite — le tunnel jouant le rôle d'un réseau de quarantaine tant que le
code n'est pas passé.

`urllib` plutôt qu'une bibliothèque HTTP tierce : un seul appel POST, aucune
raison d'alourdir les dépendances de l'application.
"""

from __future__ import annotations

import ipaddress
import json
import urllib.error
import urllib.request

from app.core.config import Config

_TIMEOUT = 10


def api_base_url(cfg: Config) -> str:
    """URL de l'API du serveur, telle qu'atteignable depuis le tunnel.

    À défaut d'URL explicite, elle est déduite de l'adresse du client : le
    serveur occupe la première adresse de ce réseau (10.6.0.1 pour un client
    en 10.6.0.6). C'est l'adresse la plus fiable depuis la quarantaine — elle
    désigne le serveur lui-même, dont l'accès n'est jamais filtré, alors
    qu'une adresse du réseau distant le serait.
    """
    explicit = (cfg.wg.get("api_url") or "").strip()
    if explicit:
        return explicit.rstrip("/")

    client_address = (cfg.wg.get("client_address") or "").split("/")[0].strip()
    try:
        host = ipaddress.ip_address(client_address)
    except ValueError:
        return ""
    gateway = ipaddress.ip_address(int(host) - (int(host) & 0xFF) + 1)
    return f"http://{gateway}:8000"


def authenticate(cfg: Config, code: str, username: str = "") -> tuple[bool, str]:
    """Valide un code TOTP auprès du serveur et ouvre l'accès réseau.

    Retourne (succès, message). Un échec n'est jamais silencieux : sans
    cette validation le tunnel reste monté mais ne mène nulle part, et
    l'utilisateur doit comprendre pourquoi plutôt que de constater un
    réseau inexplicablement muet.

    `username` permet de fournir l'identifiant à la volée, quand il n'est pas
    encore en configuration : la fenêtre de saisie le demande alors avec le
    code, plutôt que de renvoyer l'utilisateur vers le panneau Administrateur
    au moment précis où il cherche à ouvrir son accès. Il est enregistré
    une fois le serveur l'ayant accepté.
    """
    base = api_base_url(cfg)
    if not base:
        return False, ("Adresse du serveur d'authentification inconnue. "
                       "Renseignez-la dans le panneau Administrateur.")

    username = (username or cfg.wg.get("vpn_username") or "").strip()
    if not username:
        return False, "Indiquez votre identifiant VPN."

    payload = json.dumps({"username": username, "code": code}).encode("utf-8")
    request = urllib.request.Request(
        f"{base}/api/session", data=payload,
        headers={"Content-Type": "application/json"}, method="POST",
    )
    try:
        with urllib.request.urlopen(request, timeout=_TIMEOUT) as response:
            body = json.loads(response.read().decode("utf-8"))
        until = (body.get("access_until") or "").replace("T", " ")[:16]
        return True, f"Accès réseau ouvert jusqu'à {until}" if until else "Accès réseau ouvert"
    except urllib.error.HTTPError as exc:
        # Le serveur explique lui-même le refus (code invalide, compte
        # verrouillé, expiré…) : le relayer tel quel vaut mieux qu'un
        # message générique qui obligerait à consulter les journaux.
        try:
            detail = json.loads(exc.read().decode("utf-8")).get("detail", "")
        except (ValueError, OSError):
            detail = ""
        return False, detail or f"Authentification refusée (code {exc.code})"
    except urllib.error.URLError as exc:
        return False, (f"Serveur d'authentification injoignable ({base}) : "
                       f"{exc.reason}")
    except (OSError, ValueError) as exc:
        return False, f"Échec de l'authentification : {exc}"