# agent_v1/network/updater.py
"""NOYAU client de la mise à jour silencieuse de Léa (DETTE-022 v2).

GATED — flag `RPA_AUTO_UPDATE_ENABLED` (défaut OFF). Tant qu'il est OFF,
rien ne se déclenche : l'intégration de ce module au runtime (boucle de poll
de `main.py`) ne fait aucune MAJ.

Ce module ne contient que les parties PURES / testables, sans réseau réel :

  - `parse_version` / `is_newer` (R3) : self-contained (le bundle client
    n'embarque PAS `server_v1` — duplication assumée, même algorithme).
  - `should_update(local_version, server_response)` : décide « faut-il
    updater ? quelle version/type ? » à partir de la réponse serveur. Double
    garde semver côté client (jamais de downgrade) = défense en profondeur.
  - `download_update(plan, staging_dir, downloader)` : télécharge le ZIP via un
    `downloader` callable INJECTABLE (aucun réseau réel en test), vérifie le
    SHA256, écrit le ZIP dans le **staging** (`Lea_next\\`-like) — JAMAIS dans
    les fichiers vivants. Retourne un plan d'application.
  - `auto_update_enabled()` : lit le flag (défaut OFF).

⚠️⚠️ PARTIES DANGEREUSES — RÉSERVÉES RÉVISION HUMAINE ⚠️⚠️
Le remplacement réel des fichiers (`apply_update`), l'écriture du marker
rollback (`write_boot_ok_marker`), l'édition de `Lea.bat` et le redémarrage
ne sont PAS implémentés ici : ce sont des STUBS no-op explicites. Un agent ne
doit pas écrire de code qui écrase des binaires vivants ou relance un process
sans supervision. Les points d'extension sont marqués `# TODO swap supervisé`.

Pattern d'import / résilience aligné sur `log_shipper.py` (même branche).

Branche feat/push-log-dgx.
"""

from __future__ import annotations

import hashlib
import logging
import os
from pathlib import Path
from typing import Callable, Optional, Tuple

logger = logging.getLogger(__name__)

# Niveaux de livraison (R2). `code-only` par défaut = 99 % des MAJ (~500 Ko).
VALID_UPDATE_TYPES = ("code-only", "full")
DEFAULT_UPDATE_TYPE = "code-only"

_FALLBACK_VERSION: Tuple[int, ...] = (0,)


# ---------------------------------------------------------------------------
# Flag d'activation — OFF par défaut (lu à chaque appel pour faciliter tests)
# ---------------------------------------------------------------------------

def auto_update_enabled() -> bool:
    """True si la MAJ auto client est activée (flag RPA_AUTO_UPDATE_ENABLED).

    Défaut PRUDENT = OFF. On l'active poste par poste via config.txt / variable
    d'environnement, sans rebuild de l'installateur (même esprit que
    LOG_SHIP_ENABLED).
    """
    return os.environ.get("RPA_AUTO_UPDATE_ENABLED", "false").lower() in (
        "true", "1", "yes", "on",
    )


# ---------------------------------------------------------------------------
# R3 — parse_version self-contained (le bundle client n'a pas server_v1)
# ---------------------------------------------------------------------------

def parse_version(v) -> Tuple[int, ...]:
    """Parse une version semver en tuple d'entiers. Voir server_v1/update_check.

    "1.0.2" → (1, 0, 2) ; "1.0.10" → (1, 0, 10) ; "v1.2.3" → (1, 2, 3).
    Tolérant et SANS exception : invalide → fallback `(0,)`.
    """
    if not isinstance(v, str):
        return _FALLBACK_VERSION
    s = v.strip().lstrip("vV").strip()
    if not s:
        return _FALLBACK_VERSION
    try:
        from packaging.version import Version

        return tuple(Version(s).release)
    except Exception:
        pass
    try:
        return tuple(int(x) for x in s.split("."))
    except (ValueError, AttributeError):
        return _FALLBACK_VERSION


def is_newer(candidate: str, baseline: str) -> bool:
    """True si `candidate` strictement plus récent que `baseline` (semver)."""
    return parse_version(candidate) > parse_version(baseline)


def _normalize_update_type(update_type) -> str:
    if update_type in VALID_UPDATE_TYPES:
        return update_type
    return DEFAULT_UPDATE_TYPE


# ---------------------------------------------------------------------------
# Décision client : faut-il updater ?
# ---------------------------------------------------------------------------

def should_update(local_version: str, server_response) -> Optional[dict]:
    """Décide à partir de la réponse serveur s'il faut updater.

    Args:
        local_version : version courante du client (config.AGENT_VERSION).
        server_response : dict renvoyé par l'endpoint serveur
            {update_available, latest_version, update_type, url, [sha256]}.

    Returns:
        Un PLAN d'update `{target_version, update_type, url, sha256}` si une MAJ
        valide est à faire, sinon None.

    Défense en profondeur : même si `update_available` est True, le client
    REVÉRIFIE en semver (`is_newer`) — il ne descend JAMAIS vers une version
    <= locale. Tolérant : réponse malformée → None (jamais d'exception).
    """
    if not isinstance(server_response, dict):
        return None
    if not server_response.get("update_available"):
        return None

    target = server_response.get("latest_version")
    url = server_response.get("url")
    if not target or not url:
        return None

    # Double garde semver : pas de downgrade, pas d'égalité.
    if not is_newer(target, local_version):
        return None

    return {
        "target_version": target,
        "update_type": _normalize_update_type(server_response.get("update_type")),
        "url": url,
        "sha256": server_response.get("sha256"),
    }


# ---------------------------------------------------------------------------
# Téléchargement — downloader INJECTABLE, SHA256, staging only
# ---------------------------------------------------------------------------

def _default_downloader(url: str) -> bytes:
    """Téléchargement réel du ZIP (best-effort, pattern streamer/log_shipper).

    Résout l'URL relative contre SERVER_BASE, ajoute le Bearer si présent.
    INJECTABLE : remplacé par un fake en test (aucun réseau réel).
    """
    import requests  # import tardif (absent de certains envs de test)

    full_url = url
    headers = {}
    try:
        from ..config import SERVER_BASE, API_TOKEN

        if url.startswith("/"):
            full_url = f"{SERVER_BASE}{url}"
        if API_TOKEN:
            headers["Authorization"] = f"Bearer {API_TOKEN}"
    except Exception:
        # Hors package (test isolé) : on utilise l'URL telle quelle.
        pass

    resp = requests.get(full_url, headers=headers, timeout=30, stream=False)
    resp.raise_for_status()
    return resp.content


def download_update(
    plan: dict,
    staging_dir,
    downloader: Optional[Callable[[str], bytes]] = None,
) -> dict:
    """Télécharge le ZIP d'update dans le staging et vérifie son intégrité.

    NE TOUCHE PAS aux fichiers vivants : écrit uniquement dans `staging_dir`
    (équivalent de `Lea_next\\`). L'application réelle (swap) est un stub
    réservé révision humaine (voir `apply_update`).

    Args:
        plan : sortie de `should_update` (target_version, update_type, url, sha256).
        staging_dir : dossier de staging (créé si absent).
        downloader : callable `(url) -> bytes` INJECTABLE (défaut = HTTP réel).

    Returns:
        Succès : {ok: True, staged_zip: str, update_type, target_version,
                  sha256_verified: bool}
        Échec  : {ok: False, error: str}
    Best-effort : aucune exception ne remonte ; un échec laisse le staging propre
    (pas de ZIP corrompu).
    """
    dl = downloader if downloader is not None else _default_downloader
    staging = Path(staging_dir)

    try:
        data = dl(plan["url"])
    except Exception as e:
        logger.warning("Téléchargement update échoué : %s", e)
        return {"ok": False, "error": f"download_failed: {e}"}

    expected_sha = (plan.get("sha256") or "").strip().lower()
    sha256_verified = False
    if expected_sha:
        actual = hashlib.sha256(data).hexdigest()
        if actual != expected_sha:
            logger.warning(
                "SHA256 mismatch update (attendu=%s, obtenu=%s) — rejeté",
                expected_sha, actual,
            )
            return {"ok": False, "error": "sha256 mismatch — ZIP rejeté"}
        sha256_verified = True
    else:
        # Best-effort : pas de SHA fourni → on accepte mais on le signale.
        logger.info("Pas de SHA256 fourni pour l'update — intégrité non vérifiée")

    try:
        staging.mkdir(parents=True, exist_ok=True)
        target_version = plan.get("target_version", "unknown")
        staged_zip = staging / f"lea_update_{target_version}.zip"
        staged_zip.write_bytes(data)
    except Exception as e:
        logger.warning("Écriture ZIP staging échouée : %s", e)
        return {"ok": False, "error": f"staging_write_failed: {e}"}

    return {
        "ok": True,
        "staged_zip": str(staged_zip),
        "update_type": _normalize_update_type(plan.get("update_type")),
        "target_version": plan.get("target_version"),
        "sha256_verified": sha256_verified,
    }


# ---------------------------------------------------------------------------
# Interrogation serveur — checker INJECTABLE (GET /agents/update/check)
# ---------------------------------------------------------------------------

def _default_update_checker(local_version: str, machine_id: str):
    """Interroge le serveur : y a-t-il une MAJ ? (best-effort, INJECTABLE).

    GET SERVER_URL/agents/update/check?current_version=..&machine_id=..
    (endpoint gated côté serveur — 503 si RPA_AUTO_UPDATE_SERVER_ENABLED OFF,
    auquel cas on renvoie None : pas de MAJ). Bearer si présent. Pattern aligné
    sur `log_shipper._default_sender`. INJECTABLE : remplacé par un fake en test.

    Returns:
        Le dict réponse serveur (`should_update` sait le lire), ou None si
        indisponible / gated / erreur (jamais d'exception ne remonte).
    """
    try:
        import requests  # import tardif

        headers = {}
        try:
            from ..config import SERVER_URL, API_TOKEN

            base = SERVER_URL
            if API_TOKEN:
                headers["Authorization"] = f"Bearer {API_TOKEN}"
        except Exception:
            base = ""
        url = f"{base}/agents/update/check"
        resp = requests.get(
            url,
            params={"current_version": local_version, "machine_id": machine_id},
            headers=headers,
            timeout=10,
            allow_redirects=False,
        )
        # 503 = endpoint gated OFF côté serveur → pas de MAJ (silencieux).
        if resp.status_code == 503:
            return None
        if not resp.ok:
            logger.debug("update/check HTTP %s", resp.status_code)
            return None
        return resp.json()
    except Exception as e:
        logger.debug("update/check indisponible : %s", e)
        return None


# ---------------------------------------------------------------------------
# Orchestrateur GATED — check → décide → download (staging) → stub apply
# ---------------------------------------------------------------------------

def run_update_cycle(
    local_version: str,
    machine_id: str,
    staging_dir,
    checker: Optional[Callable[[str, str], object]] = None,
    downloader: Optional[Callable[[str], bytes]] = None,
) -> dict:
    """Un cycle complet de MAJ silencieuse — GATED, best-effort, SANS swap.

    Enchaîne :
      1. GATE `auto_update_enabled()` (RPA_AUTO_UPDATE_ENABLED, défaut OFF) —
         si OFF, ne fait STRICTEMENT rien (aucun appel réseau).
      2. `checker(local_version, machine_id)` → réponse serveur (canary-aware).
      3. `should_update(...)` → plan (double garde semver, jamais de downgrade).
      4. `download_update(...)` → ZIP dans le STAGING + vérif SHA256. Ne touche
         JAMAIS les fichiers vivants.
      5. Le swap réel N'EST PAS FAIT ici : `apply_update` reste un stub no-op
         (réservé révision humaine + Lea.bat hors-process). Le résultat porte
         `applied: False`.

    Jamais d'exception ne remonte (ne doit JAMAIS casser Léa). Retourne un dict
    d'état pour le diagnostic / le log :
        status ∈ {disabled, check_failed, up_to_date, download_failed, staged}

    Args:
        checker    : callable `(local_version, machine_id) -> dict|None`
                     INJECTABLE (défaut = HTTP réel vers l'endpoint gated).
        downloader : callable `(url) -> bytes` INJECTABLE (défaut = HTTP réel).
    """
    if not auto_update_enabled():
        return {"status": "disabled", "applied": False}

    chk = checker if checker is not None else _default_update_checker

    try:
        server_response = chk(local_version, machine_id)
    except Exception as e:
        logger.warning("update check a levé : %s", e)
        return {"status": "check_failed", "applied": False, "error": str(e)}

    plan = should_update(local_version, server_response)
    if plan is None:
        return {"status": "up_to_date", "applied": False}

    staged = download_update(plan, staging_dir, downloader=downloader)
    if not staged.get("ok"):
        return {
            "status": "download_failed",
            "applied": False,
            "error": staged.get("error"),
        }

    # ⚠️ Le swap réel est réservé révision humaine : on APPELLE le stub (no-op)
    # pour matérialiser le point d'extension, mais rien n'est écrasé/redémarré.
    applied = apply_update(staged)

    return {
        "status": "staged",
        "applied": bool(applied.get("applied", False)),
        "target_version": staged.get("target_version"),
        "update_type": staged.get("update_type"),
        "staged_zip": staged.get("staged_zip"),
        "sha256_verified": staged.get("sha256_verified", False),
        "apply_reason": applied.get("reason"),
    }


# ===========================================================================
# ⚠️ ZONE DANGEREUSE — STUBS RÉSERVÉS RÉVISION HUMAINE (NE PAS IMPLÉMENTER
#    PAR UN AGENT). Points d'extension explicites, no-op pour l'instant.
# ===========================================================================

def apply_update(prepared: dict) -> dict:
    """STUB — application réelle de l'update (swap des fichiers).

    Réservé révision humaine : remplacer des fichiers vivants du client et
    déclencher un swap est trop risqué pour être généré par un agent. La
    mécanique cible (design v2) est :

      - code-only : extraire `agent_v1\\` + `lea_ui\\` + `run_agent_v1.py` +
        `config.py` du ZIP staging, poser un marker `UPDATE_READY`
        (`update_type=code-only`) ; le swap effectif est fait par `Lea.bat`
        au prochain démarrage (xcopy ciblé).
      - full : poser `UPDATE_READY` (`update_type=full`) ; `Lea.bat` fait le
        backup complet `Lea_prev\\` puis le swap complet.

    # TODO swap supervisé : extraction ZIP + écriture marker UPDATE_READY.
    #   NE PAS écraser les fichiers vivants depuis Python — c'est Lea.bat qui
    #   swappe hors-process. Édition de Lea.bat + restart = hors périmètre agent.

    Returns:
        {applied: False, reason: "réservé révision humaine (swap supervisé)"}
    """
    logger.info(
        "apply_update appelé mais NON implémenté (stub réservé révision humaine) : %r",
        prepared.get("target_version") if isinstance(prepared, dict) else prepared,
    )
    return {
        "applied": False,
        "reason": "réservé révision humaine — swap supervisé (Lea.bat), hors périmètre agent",
    }


def write_boot_ok_marker(version: str) -> dict:
    """STUB — écriture du marker rollback `boot_ok_{version}` (R1).

    Réservé révision humaine : le marker pilote le rollback de Lea.bat au
    prochain démarrage. Sa sémantique (health-check ~60s heartbeat DGX +
    session active AVANT écriture) doit être validée à la main pour éviter un
    faux rollback (cas DGX down ≠ Léa N+1 buguée — cf. design R1, cas edge 3).

    # TODO swap supervisé : écrire `%LOCALAPPDATA%\\Lea\\boot_ok_{version}`
    #   après ~60s de heartbeat DGX sain + session active (main.py startup).

    Returns:
        {written: False, reason: "..."}
    """
    logger.info(
        "write_boot_ok_marker appelé mais NON implémenté (stub R1) : version=%s",
        version,
    )
    return {
        "written": False,
        "reason": "réservé révision humaine — marker rollback (health-check), hors périmètre agent",
    }