#!/usr/bin/env python3
"""Devis du PLACEMENT — les quatre objets d'hebergeur que le tenant monte designe.

D-80 : un tenant est agnostique de son underlay ; tout son adressage derive du seed.
Ce qui le lie a une fabric tient en QUATRE valeurs, et elles nomment des objets qui
appartiennent a l'hebergeur :

    proxmox_clone_noeud        sur quel noeud cloner
    proxmox_clone_stockage     ou poser le disque
    proxmox_clone_pont         ou brancher la carte
    proxmox_clone_vmid_modele  quel gabarit cloner

**P37 en verifie trois**, statiquement, contre les listes que l'hebergeur DECLARE
(`proxmox-hebergeur.yml`). C'est utile et insuffisant : une liste declaree peut elle-meme
etre perimee, et le GABARIT n'y figure pas — c'est un objet du cluster, pas une
declaration.

Ce devis interroge donc le CLUSTER. Il ne verifie pas ce qui est ecrit : il verifie ce qui
existe. Sur un site inconnu, c'est la premiere chose a savoir — sans quoi l'ecart se
decouvre au premier clone, apres quarante minutes de deploiement.

N'ECRIT RIEN. Lecture seule, sans effet de bord.

  python3 scripts/devis_placement.py            # tableau lisible
  python3 scripts/devis_placement.py --verifier # code de sortie (0 = tout existe)
"""
from __future__ import annotations

import argparse
import os
import sys
from pathlib import Path

import yaml

RACINE = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(RACINE / "scripts"))

import underlay as underlay_mod  # noqa: E402
from inventory_rules import instance_courante  # noqa: E402
from proxmox_api import Cluster  # noqa: E402

INVENTAIRES = ("principal", "production", "lab")


def placement_du_tenant() -> tuple[dict, Path | None]:
    """Les valeurs de placement declarees par le tenant VISE.

    SETOPS_INSTANCE d'abord ; le symlink `instance/` n'en est que le cas courant. Code en
    dur, il rendait ce devis incapable de regarder un AUTRE tenant : viser un autre tenant
    mesurait en silence le placement de l'instance montee, et rendait un verdict juste
    pour le mauvais tenant (mesure du 2026-08-20 — les deux avaient les memes quatre
    valeurs, ce qui est exactement la circonstance ou l'erreur ne se voit pas).
    """
    base = instance_courante()
    for nom in INVENTAIRES:
        f = base / "inventories" / nom / "group_vars" / "proxmox.yml"
        if f.is_file():
            return (yaml.safe_load(f.read_text(encoding="utf-8")) or {}), f
    return {}, None


def _liste(api: Cluster, chemin: str) -> list:
    """Une reponse de l'API garantie ITERABLE — ou un refus lisible.

    POURQUOI (mesure du 2026-08-20, un soir de reconstruction). Sur erreur,
    `Cluster.__call__` rend `{"_erreur": "..."}` — un DICT. Itere comme une liste, un
    dict rend ses CLEFS : le devis mourait sur
    `AttributeError: 'str' object has no attribute 'get'`, dix lignes de trace Python
    pour dire « le nom `asgard` ne se resout pas ».

    C'est le pire endroit pour un message illisible : ce devis est precisement ce qu'on
    lance AVANT quarante minutes de deploiement, quand on cherche a savoir si le terrain
    est bon. `Cluster.rate()` existait pour ca ; il n'etait pas appele ici.
    """
    rep = api(chemin)
    faute = api.rate(rep)
    if faute:
        raise SystemExit(
            f"Le cluster ne repond pas sur `{chemin}` : {faute}\n"
            f"  hote interroge : {api.hote}\n"
            f"  a verifier : le nom se resout-il d'ici, le VPN est-il monte, "
            f"le jeton d'API est-il encore valide ?")
    if not isinstance(rep, list):
        raise SystemExit(
            f"Reponse inattendue du cluster sur `{chemin}` : "
            f"{type(rep).__name__} au lieu d'une liste.\n"
            f"  hote interroge : {api.hote}")
    return rep


def _ponts_derives(base: Path | None) -> set[str]:
    """Les reseaux ou les VM de CE tenant atterriront reellement.

    Ce ne sont pas les valeurs du plan : `instancier` pose dans chaque hote le pont
    DERIVE de sa zone (`proxmox_pont` = le VNet du tenant), et `make creer-vm` le passe au
    clone en ecrasant le defaut. C'est donc la seule chose a confronter au cluster.
    """
    ponts: set[str] = set()
    if base is None:
        return ponts
    for f in sorted(base.glob("inventories/*/hosts.yml")):
        data = yaml.safe_load(f.read_text(encoding="utf-8")) or {}

        def marcher(noeud):
            if not isinstance(noeud, dict):
                return
            for hote in (noeud.get("hosts") or {}).values():
                if isinstance(hote, dict) and hote.get("proxmox_pont"):
                    ponts.add(str(hote["proxmox_pont"]))
            for enfant in (noeud.get("children") or {}).values():
                marcher(enfant or {})
        marcher((data.get("all") or {}))
    return ponts


def constater(api: Cluster, place: dict, base: Path | None = None,
              routage: str = "sdn", ponts: set[str] | None = None) -> list[dict]:
    """Confronte chaque valeur au cluster. Renvoie une ligne par objet.

    `ponts` : ceux que la face reseau du locataire publie (`--locataire`) ; sans eux, ceux de
    l'inventaire de l'instance montee."""
    lignes: list[dict] = []
    place = {**place, "_instance": base, "_ponts": ponts}

    noeuds = [n.get("node") for n in _liste(api, "/nodes")]
    voulu = place.get("proxmox_clone_noeud")
    lignes.append({"objet": "noeud", "voulu": voulu,
                   "existe": voulu in noeuds, "offre": noeuds})

    # Un stockage ne suffit pas : il doit accepter le contenu `images`, sinon on ne peut
    # pas y poser un disque de VM — et l'erreur ne se lit qu'au clone.
    stockages = {}
    for s in _liste(api, "/storage"):
        stockages[s.get("storage")] = str(s.get("content") or "")
    voulu = place.get("proxmox_clone_stockage")
    lignes.append({"objet": "stockage", "voulu": voulu,
                   "existe": voulu in stockages and "images" in stockages[voulu],
                   "offre": [k for k, v in stockages.items() if "images" in v],
                   "note": ("" if voulu not in stockages or "images" in stockages[voulu]
                            else f"present mais n'accepte pas `images` ({stockages[voulu]})")})

    # LE RESEAU OU LES VM ATTERRISSENT — pas `proxmox_clone_pont`.
    #
    # Mesure du 2026-08-20, remarque de l'exploitant : « le pont ne me semble pas approprie
    # depuis qu'on cree des VNets par tenant ». Il avait raison, et le defaut etait pire
    # que cosmetique. Ce devis validait `vmbr1` — le REPLI des clones manuels — pendant que
    # le point d'attache reel des VM de la flotte n'etait controle par personne :
    # `creer-vm` lit le pont DERIVE de chaque hote (`SETOPS_PONT`, le VNet de sa zone) et
    # ecrase le defaut. Resultat : « CONFORME » sur un tenant dont aucun VNet n'existait.
    #
    # D-80 corrigee le 2026-08-13 dit deja que la liaison de placement est nœud, stockage
    # et gabarit — le pont se derive. Le devis, lui, continuait de compter quatre objets.
    ponts_derives = sorted(place["_ponts"] if place.get("_ponts") is not None
                           else _ponts_derives(place.get("_instance")))
    if routage == "sdn":
        vnets = {v.get("vnet") for v in _liste(api, "/cluster/sdn/vnets")}
        manquants = [p for p in ponts_derives if p not in vnets]
        lignes.append({
            "objet": "reseaux VM", "voulu": ", ".join(ponts_derives) or "(aucun)",
            "existe": bool(ponts_derives) and not manquants,
            "offre": sorted(vnets),
            "note": ("" if not manquants else
                     f"VNet(s) absent(s) du cluster : {', '.join(manquants)} — "
                     f"passer `make sdn-appliquer` AVANT de creer les VM")})
    else:
        n = place.get("proxmox_clone_noeud")
        ponts: list[str] = []
        if n in noeuds:
            ponts = [i.get("iface") for i in _liste(api, f"/nodes/{n}/network")
                     if str(i.get("type")) in ("bridge", "OVSBridge")]
        manquants = [p for p in ponts_derives if p not in ponts]
        lignes.append({
            "objet": "reseaux VM", "voulu": ", ".join(ponts_derives) or "(aucun)",
            "existe": bool(ponts_derives) and not manquants,
            "offre": ponts,
            "note": ("noeud introuvable : ponts non verifiables" if n not in noeuds else
                     "" if not manquants else
                     f"pont(s) absent(s) sur {n} : {', '.join(manquants)}")})

    # Le gabarit : celui que P37 ne peut PAS voir. Presence, et surtout `template=1` —
    # cloner une VM ordinaire marcherait, et produirait quatorze copies d'une machine
    # vivante.
    vmid = place.get("proxmox_clone_vmid_modele")
    vms = {v.get("vmid"): v for v in _liste(api, "/cluster/resources?type=vm")}
    trouve = vms.get(int(vmid)) if vmid is not None else None
    est_gabarit = bool(trouve and str(trouve.get("template", 0)) == "1")
    lignes.append({"objet": "gabarit", "voulu": vmid,
                   "existe": est_gabarit,
                   "offre": [f"{v.get('vmid')} ({v.get('name')})" for v in vms.values()
                             if str(v.get("template", 0)) == "1"],
                   "note": ("" if est_gabarit else
                            (f"VMID {vmid} existe (« {trouve.get('name')} ») mais n'est PAS "
                             f"un gabarit" if trouve else f"aucune VM au VMID {vmid}"))})
    return lignes


def nom_du_tenant(source: Path | None, locataire: str | None = None) -> str:
    """Le nom que le devis annonce. Un devis doit nommer ce qu'il a mesure.

    `.resolve()` : sans lui, un tenant monte par symlink s'annonce « instance » — le nom du
    lien, pas celui du tenant. NOMME (`--locataire`, 2026-10-07) : il n'y a pas de fichier
    source d'ou tirer le nom, le devis annoncait « ? » ; le nom est celui qu'on a donne.
    """
    if locataire:
        return locataire
    return source.parents[3].resolve().name if source else "?"


def ce_que_le_clonage_utilise(place: dict, gabarit: dict) -> dict:
    """Le placement tel que `cloner-vm` le passe REELLEMENT a Proxmox.

    LE DEVIS VERIFIAIT CE QUE PERSONNE NE CLONE (2026-10-07). Depuis le 2026-09-01, le gabarit
    et son stockage viennent du SITE (`underlay.py --gabarit`) : `cloner-vm` les passe en
    `-e`, par-dessus ce que dit le tenant. Le devis, lui, lisait encore le tenant. Chez
    Technolibre, il validait le 99998, que plus rien ne clone (M4 est nee du 9006, sur
    CephNVMe) ; chez Chezlepro, qui ne declare plus de gabarit (c'est la regle), il refusait
    « None » — trouve au pre-vol de sa reconstruction.

    Meme regle que le Makefile : le site decide ; s'il ne declare rien, le tenant reprend
    la main. Degrader, jamais deviner.
    """
    vu = dict(place)
    if gabarit.get("vmid") not in (None, ""):
        vu["proxmox_clone_vmid_modele"] = int(gabarit["vmid"])
    if gabarit.get("stockage"):
        vu["proxmox_clone_stockage"] = gabarit["stockage"]
    return vu


def afficher(lignes: list[dict], tenant: str, depot: Path) -> bool:
    print(f"Devis du placement — tenant « {tenant} » sur l'hebergeur « {depot.name} »\n")
    print(f"  {'OBJET':<12} {'DEMANDE':<34} {'VERDICT'}")
    ok = True
    for l in lignes:
        verdict = "existe" if l["existe"] else "INTROUVABLE"
        ok = ok and l["existe"]
        print(f"  {l['objet']:<12} {str(l['voulu']):<34} {verdict}")
        if l.get("note"):
            print(f"  {'':<12} {'':<34} -> {l['note']}")
        if not l["existe"] and l["offre"]:
            offert = ", ".join(str(x) for x in l["offre"][:6])
            print(f"  {'':<12} {'':<34} offert : {offert}")
    print("\n" + ("CONFORME : le noeud, le stockage, le gabarit et les reseaux des VM "
                  "existent sur ce cluster." if ok else
                  "ECART : le tenant a besoin d'objets que ce cluster n'offre pas."))
    return ok


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--verifier", action="store_true", help="code de sortie seulement")
    ap.add_argument("--locataire", help="le locataire NOMME, d'apres sa face reseau publiee "
                    "(le site, sans monter son depot)")
    a = ap.parse_args()

    ponts = None
    if a.locataire:
        # LE SITE CONFRONTE LE PLACEMENT D'UN LOCATAIRE NOMME (2026-10-05, materialisation M2) :
        # ses valeurs de placement et les ponts de ses machines viennent de sa face publiee.
        import contexte
        face = contexte.Locataire.charger(a.locataire).face_publiee()
        if face is None:
            print(f"{a.locataire} n'a pas publie sa face reseau.", file=sys.stderr)
            return 2
        place, source = dict(face.get("placement") or {}), None
        ponts = contexte.ponts_publies(face)
    else:
        place, source = placement_du_tenant()
    tenant = nom_du_tenant(source, a.locataire)
    place = ce_que_le_clonage_utilise(place, underlay_mod.gabarit())
    if not place:
        print(f"Aucun placement declare par « {tenant} » — rien a confronter.")
        return 0
    try:
        api, depot = Cluster.depuis_hebergeur()
    except Exception as e:  # noqa: BLE001 — l'API est un tiers : on rend la cause lisible
        print(f"Cluster injoignable : {e}", file=sys.stderr)
        return 2

    base = source.parents[3] if source else None
    routage = underlay_mod.routage_tenants(underlay_mod.charger())
    lignes = constater(api, place, base, routage, ponts)
    if a.verifier:
        mauvais = [l for l in lignes if not l["existe"]]
        if mauvais:
            for l in mauvais:
                print(f"placement : {l['objet']} « {l['voulu']} » introuvable"
                      + (f" — {l['note']}" if l.get("note") else ""), file=sys.stderr)
            return 1
        print(f"Placement conforme : noeud, stockage, gabarit et reseaux des VM "
              f"existent sur « {depot.name} ».")
        return 0
    return 0 if afficher(lignes, tenant, depot) else 1


if __name__ == "__main__":
    sys.exit(main())