"""Manifestes d'apps : ~/dispatch/apps/<app>.json (source de vérité de « comment » tourne une app).

Schéma :
{
  "app": "lou-ka", "label": "Lou-Ka", "domain": "www.lou-ka.com", "port": 8095, "health_path": "/",
  "dir": "~/apps/lou-ka",                 # répertoire de l'app (même chemin absolu sur tous les nœuds)
  "extra_paths": ["~/.ssh/trouveka_tunnel"],  # autres fichiers/dossiers à copier avec l'app
  "sync_excludes": ["data/backups/"],     # exclusions rsync (relatives à dir)
  "requires": {"runtimes": ["python@3.14", "pm2"], "ram_gb": 2, "ports": [8095]},
  "ram_mb_observed": 400, "size_mb": 4359,
  "placement": {"pin": null, "prefer": null, "avoid": [], "reason": ""},
  "processes": [{"name": "lou-ka-web", "manager": "pm2", "script": "...", "args": [...], "interpreter": null,
                 "cwd": "...", "env": {...}, "cron_restart": null, "autorestart": true, "max_memory_restart": null}],
  "tunnel": {"domain": "www.lou-ka.com", "gateway": "BHS64", "redirects": ["lou-ka.com"], "websocket": false} | null,
                                          # exposition publique via MacLustr Tunnel : la route Caddy https://domain →
                                          # <nœud courant>:<port> est (re)pointée par `mld deploy`/`move`. `domain` seul suffit.
  "ngrok": null,                          # OBSOLÈTE (ngrok retiré le 2026-09-10) : un vieux bloc est converti en `tunnel` au chargement
  "launchd": [{"label": "...", "program_arguments": [...], "working_directory": "...", "env": {...}, "keep_alive": true}],
  "env_overrides": {".env": {"DATABASE_URL": "postgresql://...@{{IP:M2M32}}:5432/x"}},  # réécritures de fichiers .env
  "hooks": {"post_sync": ["bash ..."], "post_start": []},
  "ka_repo": true                          # inscrire dir dans ~/.ka-pousseur-repos du nœud hôte
}
Gabarits acceptés dans env/args/env_overrides : {{HOME}}, {{NODE}}, {{LAN_IP}}, {{IP:<alias>}}.
"""
import glob
import json
import os
import re
from . import config

DEFAULTS = {
    "label": None, "domain": None, "port": None, "health_path": "/", "extra_paths": [], "sync_excludes": [],
    "requires": {"runtimes": ["pm2"], "ram_gb": 1, "ports": []}, "ram_mb_observed": 512, "size_mb": 0,
    "placement": {"pin": None, "prefer": None, "avoid": [], "reason": ""}, "processes": [], "tunnel": None, "ngrok": None,
    "launchd": [], "env_overrides": {}, "hooks": {"post_sync": [], "post_start": []}, "ka_repo": False,
}


def path(app):
    return os.path.join(config.APPS_DIR, app + ".json")


def load(app):
    p = path(app)
    if not os.path.exists(p):
        raise SystemExit("manifeste introuvable : %s" % p)
    m = json.load(open(p))
    for k, v in DEFAULTS.items():
        m.setdefault(k, json.loads(json.dumps(v)))
    m["requires"].setdefault("runtimes", ["pm2"])
    m["requires"].setdefault("ram_gb", 1)
    m["requires"].setdefault("ports", [m["port"]] if m.get("port") else [])
    return modernize(m)


def modernize(m):
    """ngrok → MacLustr Tunnel (2026-09-10). Un ancien bloc `ngrok` devient une route `tunnel` ; le runtime « ngrok » disparaît
    des prérequis (plus installé nulle part) ; le nom du vieux processus PM2 `<app>-ngrok` est gardé pour le nettoyer au start."""
    n = m.get("ngrok")
    if n:
        if not m.get("tunnel"):
            m["tunnel"] = {"domain": n.get("url") or m.get("domain"), "gateway": config.TUNNEL_DEFAULT,
                           "note": "converti automatiquement depuis l'ancien bloc ngrok"}
        if not m.get("domain"):
            m["domain"] = n.get("url")
        if not m.get("port") and n.get("port"):
            m["port"] = n["port"]
        if n.get("name"):
            m["legacy_pm2"] = sorted(set((m.get("legacy_pm2") or []) + [n["name"]]))
        m["ngrok"] = None
    if m.get("domain") and not m.get("tunnel"):
        m["tunnel"] = {"domain": m["domain"], "gateway": config.TUNNEL_DEFAULT}
    if m.get("tunnel") and not m["tunnel"].get("domain"):
        m["tunnel"]["domain"] = m.get("domain")
    if m.get("tunnel") and not m.get("domain"):
        m["domain"] = m["tunnel"]["domain"]
    m["requires"]["runtimes"] = [r for r in m["requires"]["runtimes"] if r != "ngrok"]
    # les vieux processus `<app>-ngrok` (PM2) sont supprimés à chaque start/stop s'ils traînent encore
    m["legacy_pm2"] = sorted(set((m.get("legacy_pm2") or []) + ["%s-ngrok" % m["app"]]))
    return m


def save(m):
    json.dump(m, open(path(m["app"]), "w"), indent=2, ensure_ascii=False)
    os.chmod(path(m["app"]), 0o600)


def all_apps():
    return sorted(os.path.basename(p)[:-5] for p in glob.glob(os.path.join(config.APPS_DIR, "*.json")))


def load_all():
    return {a: load(a) for a in all_apps()}


def render(value, ctx):
    """Remplace {{HOME}}, {{NODE}}, {{LAN_IP}}, {{IP:alias}} dans une chaîne / liste / dict."""
    if isinstance(value, str):
        def sub(mo):
            key = mo.group(1)
            if key.startswith("IP:"):
                return ctx.get("ips", {}).get(key[3:], mo.group(0))
            return str(ctx.get(key, mo.group(0)))
        return re.sub(r"\{\{([A-Za-z0-9_:@.-]+)\}\}", sub, value)
    if isinstance(value, list):
        return [render(v, ctx) for v in value]
    if isinstance(value, dict):
        return {k: render(v, ctx) for k, v in value.items()}
    return value


def pm2_names(m):
    return [p["name"] for p in m["processes"] if p.get("manager", "pm2") == "pm2"]


def legacy_pm2_names(m):
    """Processus PM2 d'anciennes versions du manifeste (tunnels ngrok) à supprimer s'ils existent encore sur le nœud."""
    return [n for n in (m.get("legacy_pm2") or []) if n not in pm2_names(m)]


def launchd_labels(m):
    return [l["label"] for l in m.get("launchd", [])]


def detect_requirements(m):
    """Déduit les runtimes requis à partir des processus (complète requires.runtimes)."""
    req = set(m["requires"].get("runtimes") or [])
    req.add("pm2")
    req.discard("ngrok")
    blob = json.dumps(m["processes"]) + json.dumps(m.get("launchd", []))
    if "/opt/homebrew/bin/node" in blob or "next" in blob or "npm" in blob or ".mjs" in blob or ".js" in blob:
        req.add("node")
    if "pnpm" in blob:
        req.add("pnpm")
    vp = m.get("venv_python") or ""
    for ver in ("3.14", "3.13", "3.12"):
        if "python@%s" % ver in vp or "/%s/" % ver in vp or "python%s" % ver in vp:
            req.add("python@%s" % ver)
    if "uv/python/cpython-3.12" in vp:
        req.discard("python@3.12")
        req.add("uv-python@3.12")
    m["requires"]["runtimes"] = sorted(req)
    return m