"""Elke app in apps/ moet renderen naar geldige, startbare compose-YAML.

Deze suite draait over de echte templates, niet over voorbeelden. Zo valt een
kapot template op vóórdat iemand het probeert te installeren.
"""
import re
import subprocess
import sys
import tempfile
from pathlib import Path

import pytest
import yaml

WORTEL = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(WORTEL / "server-up"))

from core import boilerplates as bp

APPS = sorted(d for d in (WORTEL / "apps").iterdir() if d.is_dir())
NAMEN = [d.name for d in APPS]


def _render(d: Path, tmp: Path) -> dict:
    velden = bp.fields(d)
    waarden = {f["name"]: f["default"] for f in velden if f.get("default") is not None}
    waarden.setdefault("service_name", d.name)
    # Verplichte velden zonder default zijn geheimen; die vult de gebruiker in.
    for f in velden:
        if f.get("required") and not waarden.get(f["name"]):
            waarden[f["name"]] = "testwaarde12345678901234567890ab"
    bp.render_to_dir(d, tmp, waarden)
    return yaml.safe_load((tmp / "docker-compose.yml").read_text())


def test_er_zijn_apps():
    assert len(APPS) >= 190


@pytest.mark.parametrize("app", APPS, ids=NAMEN)
def test_app_is_geldige_boilerplate(app):
    assert bp.is_boilerplate(app), "template.json of files/ ontbreekt"
    meta = bp.metadata(app)
    assert meta["name"], "naam ontbreekt in template.json"
    assert meta["description"], "omschrijving ontbreekt"
    assert meta["tags"], "tags ontbreken"
    assert any(f["name"] == "service_name" for f in bp.fields(app)), \
        "service_name-variabele ontbreekt"


@pytest.mark.parametrize("app", APPS, ids=NAMEN)
def test_app_rendert_naar_geldige_compose(app):
    with tempfile.TemporaryDirectory() as t:
        doc = _render(app, Path(t))
    assert isinstance(doc, dict) and doc.get("services"), "geen services"
    for naam, svc in doc["services"].items():
        assert isinstance(svc, dict), f"{naam} is geen mapping"
        assert svc.get("image") or svc.get("build"), f"{naam}: geen image of build"


@pytest.mark.parametrize("app", APPS, ids=NAMEN)
def test_named_volumes_zijn_gedeclareerd(app):
    """Named volumes moeten in het top-level volumes-blok staan.

    _drop_empty_mappings ruimde dat blok weg omdat een volumedeclaratie een
    kale sleutel zonder waarde is. Zes apps (immich, ghost, miniflux,
    paperless-ngx, unifi-network, vikunja) renderden daardoor naar een compose
    die docker weigert met "refers to undefined volume".
    """
    with tempfile.TemporaryDirectory() as t:
        doc = _render(app, Path(t))
    gedeclareerd = set((doc.get("volumes") or {}).keys())
    for naam, svc in doc["services"].items():
        for v in svc.get("volumes") or []:
            if isinstance(v, str) and not v.startswith(("/", ".")):
                bron = v.split(":")[0]
                assert bron in gedeclareerd, \
                    f"{naam}: volume '{bron}' wordt gebruikt maar niet gedeclareerd"


@pytest.mark.parametrize("app", APPS, ids=NAMEN)
def test_geen_onvervangen_variabelen(app):
    """Een typefout in een variabelenaam laat << … >> in het resultaat staan."""
    with tempfile.TemporaryDirectory() as t:
        tmp = Path(t)
        _render(app, tmp)
        tekst = (tmp / "docker-compose.yml").read_text()
    assert "<<" not in tekst and ">>" not in tekst, "onvervangen variabele"


# ── Apps die hun eigen database meebrengen ───────────────────────────────────

_DATABASE_IMAGES = ("postgres", "postgis", "mariadb", "mysql", "mongo",
                    "redis", "valkey")


def _bron(app: Path) -> str:
    return (app / "files" / "compose.yaml").read_text(encoding="utf-8")


@pytest.mark.parametrize("app", APPS, ids=NAMEN)
def test_extra_containers_dragen_de_servicenaam(app):
    """Een tweede container moet `<service_name>-…` heten.

    De instantienaam is het enige wat een gebruiker kiest als hij een app twee
    keer installeert. Heet de database dan gewoon `db`, dan botsen de twee
    installaties op de containernaam en start de tweede niet.
    """
    snaam = next((f.get("default") for f in bp.fields(app)
                  if f["name"] == "service_name"), None) or app.name
    with tempfile.TemporaryDirectory() as t:
        doc = _render(app, Path(t))
    for naam in doc["services"]:
        assert naam == snaam or naam.startswith(f"{snaam}-"), \
            f"'{naam}' draagt de servicenaam '{snaam}' niet"


@pytest.mark.parametrize("app", APPS, ids=NAMEN)
def test_bijgeleverde_database_heeft_geen_vast_wachtwoord(app):
    """Een database met een wachtwoord dat in het sjabloon staat, heeft bij
    iedereen hetzelfde wachtwoord. Dat is geen wachtwoord."""
    ruw = _bron(app)
    heeft_db = any(f"image: {i}" in ruw for i in _DATABASE_IMAGES)
    if not heeft_db:
        return
    for regel in ruw.splitlines():
        r = regel.strip()
        if not any(r.startswith(f"- {k}") for k in
                   ("POSTGRES_PASSWORD", "MARIADB_PASSWORD", "MARIADB_ROOT_PASSWORD",
                    "MYSQL_PASSWORD", "MYSQL_ROOT_PASSWORD",
                    "MONGO_INITDB_ROOT_PASSWORD")):
            continue
        waarde = r.split("=", 1)[1] if "=" in r else ""
        assert "<<" in waarde, f"vast databasewachtwoord: {r}"


@pytest.mark.parametrize("app", APPS, ids=NAMEN)
def test_bijgeleverde_database_wordt_afgewacht(app):
    """Zonder depends_on start de app vóór zijn database en valt hij om op de
    eerste verbinding."""
    with tempfile.TemporaryDirectory() as t:
        doc = _render(app, Path(t))
    diensten = doc["services"]
    dbs = {n for n, s in diensten.items()
           if isinstance(s, dict)
           and any(str(s.get("image", "")).startswith(i) for i in _DATABASE_IMAGES)}
    if not dbs:
        return
    wacht = {d for s in diensten.values() if isinstance(s, dict)
             for d in (s.get("depends_on") or [])}
    assert dbs <= wacht, f"niemand wacht op {sorted(dbs - wacht)}"


# Poorten die meerdere apps bewust delen: alternatieven voor dezelfde taak,
# die je nooit tegelijk draait. Alles daarbuiten hoort uniek te zijn.
GEDEELDE_POORTEN = {
    80:   {"nginx-proxy-manager", "traefik", "caddy", "zoraxy", "pangolin"},  # reverse proxies
    443:  {"nginx-proxy-manager", "traefik", "caddy", "zoraxy", "pangolin"},
    53:   {"adguard-home", "pihole"},                  # dns-blokkers
    # Twee manieren om een WireGuard-tunnel te draaien; je gebruikt er één.
    51820: {"pangolin", "wg-easy"},
    # Hieronder: botsingen die er al waren vóór deze testsuite. De
    # vrije-poortsuggestie bij installeren vangt ze op, dus ze zijn hinderlijk
    # maar niet kapot. Nieuwe apps horen hier niet bij te komen.
    3000: {"adguard-home", "forgejo", "grafana"},
    8080: {"miniflux", "nextcloud-aio", "pihole",
           "stirling-pdf", "traefik", "unifi-network"},
    9000: {"mealie", "portainer"},
}

# Alle namen in apps/, om een arr-stack-veld aan zijn losse sjabloon te koppelen.
_APP_NAMEN = sorted((d.name for d in APPS), key=len, reverse=True)


def _stack_tegenhangers() -> dict[int, set[str]]:
    """Poorten die de ARR-stack deelt met het losse sjabloon van datzelfde
    onderdeel.

    Elk onderdeel van de stack bestaat ook als losse app. Dat zijn twee
    verpakkingen van precies dezelfde container, en ze horen op dezelfde poort
    te staan — anders krijg je een ander adres afhankelijk van hoe je hem
    installeerde. Alleen dít soort botsing is toegestaan; twee verschillende
    apps op één poort blijft een fout.
    """
    uit: dict[int, set[str]] = {}
    for f in bp.fields(WORTEL / "apps" / "arr-stack"):
        if f.get("type") != "int" or not f["name"].startswith("port_"):
            continue
        if not isinstance(f.get("default"), int):
            continue
        rest = f["name"][len("port_"):]
        # port_tdarr én port_tdarr_server horen allebei bij tdarr; de langste
        # naam die past wint, zodat 'nzbget' niet aan 'nzb' blijft hangen. Een
        # streepje in de mapnaam (cross-seed) valt weg in de veldnaam.
        onderdeel = next((n for n in _APP_NAMEN
                          if rest in (k := n.replace("-", ""))
                          or rest.startswith(k + "_")), "")
        if onderdeel:
            uit.setdefault(f["default"], set()).update({"arr-stack", onderdeel})
    return uit


def test_poorten_botsen_niet_tussen_apps():
    """Twee apps met dezelfde standaardpoort geven bij installeren meteen een
    conflict. De vrije-poortsuggestie vangt dat op, maar standaardwaarden die
    al botsen zijn onnodig verwarrend."""
    per_poort: dict[int, list[str]] = {}
    for app in APPS:
        for f in bp.fields(app):
            if f.get("type") == "int" and "port" in f["name"].lower():
                d = f.get("default")
                if isinstance(d, int):
                    per_poort.setdefault(d, []).append(f"{app.name}:{f['name']}")
    toegestaan = _stack_tegenhangers()
    botsingen = {}
    for poort, gebruikers in per_poort.items():
        apps = {g.split(":")[0] for g in gebruikers}
        mag = GEDEELDE_POORTEN.get(poort, set()) | toegestaan.get(poort, set())
        if len(apps) > 1 and not apps <= mag:
            botsingen[poort] = sorted(apps)
    assert not botsingen, f"onbedoeld dubbele standaardpoorten: {botsingen}"


# ── ARR-stack: schakelbare onderdelen ────────────────────────────────────────

ARR = WORTEL / "apps" / "arr-stack"


def _arr_render(overrides: dict) -> dict:
    velden = bp.fields(ARR)
    waarden = {f["name"]: f["default"] for f in velden if f.get("default") is not None}
    waarden["service_name"] = "arr"
    waarden.update(overrides)
    with tempfile.TemporaryDirectory() as t:
        tmp = Path(t)
        bp.render_to_dir(ARR, tmp, waarden)
        return yaml.safe_load((tmp / "docker-compose.yml").read_text())


def _arr_schakelaars() -> list[str]:
    return [f["name"] for f in bp.fields(ARR) if f.get("is_group_toggle")]


def test_arr_heeft_veel_schakelbare_onderdelen():
    assert len(_arr_schakelaars()) >= 45


def test_arr_standaard_levert_een_werkbare_basis():
    doc = _arr_render({})
    diensten = {s.split("-", 1)[1] for s in doc["services"]}
    assert {"sonarr", "radarr", "prowlarr", "bazarr"} <= diensten


@pytest.mark.parametrize("schakelaar", _arr_schakelaars())
def test_arr_elk_onderdeel_levert_zijn_eigen_services(schakelaar):
    """Aan betekent minstens één container erbij, uit betekent geen enkel spoor.

    Eén container per onderdeel is de regel, maar niet de wet: Jellystat brengt
    zijn eigen database mee. Wat wél moet kloppen is dat elke container die
    verschijnt herkenbaar bij dít onderdeel hoort — anders sleept een schakelaar
    stilzwijgend iets anders mee naar binnen.
    """
    uit = {s: False for s in _arr_schakelaars()}
    naam = schakelaar.replace("enable_", "")

    doc = _arr_render({**uit, schakelaar: True})
    diensten = set(doc["services"])
    assert diensten, f"{schakelaar} levert niets op"
    for d in diensten:
        assert d == f"arr-{naam}" or d.startswith(f"arr-{naam}-"), \
            f"{schakelaar} levert ook '{d}' op"

    doc_uit = _arr_render(uit)
    assert not (doc_uit or {}).get("services")


def test_arr_downloadclients_zitten_achter_de_vpn():
    """Met Gluetun delen de clients diens netwerknamespace en mogen ze geen
    eigen poortmapping hebben — anders lekt het verkeer om de VPN heen."""
    uit = {s: False for s in _arr_schakelaars()}
    doc = _arr_render({**uit, "enable_gluetun": True, "enable_qbittorrent": True,
                       "enable_sabnzbd": True, "enable_nzbget": True})
    for client in ("qbittorrent", "sabnzbd", "nzbget"):
        svc = doc["services"][f"arr-{client}"]
        assert svc.get("network_mode") == "service:arr-gluetun", client
        assert "ports" not in svc, f"{client} heeft een eigen poort naast de VPN"


def test_arr_interne_poorten_botsen_niet_achter_de_vpn():
    """Alle clients delen één netwerknamespace, dus hun interne poorten moeten
    verschillen. qBittorrent en SABnzbd wilden allebei 8080."""
    uit = {s: False for s in _arr_schakelaars()}
    doc = _arr_render({**uit, "enable_gluetun": True, "enable_qbittorrent": True,
                       "enable_sabnzbd": True, "enable_nzbget": True})
    intern = [str(p).split(":", 1)[1] for p in doc["services"]["arr-gluetun"]["ports"]]
    assert len(intern) == len(set(intern)), f"botsende interne poorten: {intern}"


def test_arr_zonder_vpn_eigen_poorten():
    uit = {s: False for s in _arr_schakelaars()}
    doc = _arr_render({**uit, "enable_qbittorrent": True})
    svc = doc["services"]["arr-qbittorrent"]
    assert "network_mode" not in svc
    assert svc.get("ports")


def test_groepsschakelaar_krijgt_een_startwaarde():
    """Een groepsschakelaar was geen veld en werd dus nooit ge??nitialiseerd,
    waardoor elk onderdeel standaard uit stond in de installatiemodal."""
    schakelaars = [f for f in bp.fields(ARR) if f.get("is_group_toggle")]
    assert schakelaars
    assert all(isinstance(f["default"], bool) for f in schakelaars)
    aan = [f["name"] for f in schakelaars if f["default"]]
    assert "enable_sonarr" in aan and "enable_radarr" in aan


# ── Gedeeld netwerk over alle apps ───────────────────────────────────────────

from core import compose_transform as _ct


def _render_tekst(app: Path, overrides: dict | None = None) -> str:
    velden = bp.fields(app)
    waarden = {f["name"]: f["default"] for f in velden if f.get("default") is not None}
    waarden.setdefault("service_name", app.name)
    for f in velden:
        if f.get("required") and not waarden.get(f["name"]):
            waarden[f["name"]] = "testwaarde12345678901234567890ab"
    waarden.update(overrides or {})
    with tempfile.TemporaryDirectory() as t:
        tmp = Path(t)
        bp.render_to_dir(app, tmp, waarden)
        return (tmp / "docker-compose.yml").read_text()


@pytest.mark.parametrize("app", APPS, ids=NAMEN)
def test_gedeeld_netwerk_botst_niet_met_network_mode(app):
    """Een service met network_mode deelt al andermans namespace; compose
    weigert die samen met `networks`. Dat maakte Homebridge, Scrypted, Beszel
    en de ARR-stack achter Gluetun onin­stalleerbaar met de standaardkeuze
    "Verbinden met andere apps"."""
    doc = yaml.safe_load(_ct.add_shared_network(_render_tekst(app), "serverup"))
    for naam, svc in doc["services"].items():
        if svc.get("network_mode"):
            assert "networks" not in svc, \
                f"{naam}: network_mode={svc['network_mode']!r} én networks"


def test_gedeeld_netwerk_bij_arr_stack_met_vpn():
    """De downloadclients zitten dan op network_mode: service:…-gluetun."""
    tekst = _render_tekst(ARR, {s: False for s in _arr_schakelaars()} | {
        "enable_gluetun": True, "enable_qbittorrent": True,
        "enable_sabnzbd": True, "enable_sonarr": True})
    doc = yaml.safe_load(_ct.add_shared_network(tekst, "serverup"))
    for client in ("qbittorrent", "sabnzbd"):
        svc = doc["services"][f"arr-{client}"]
        assert svc["network_mode"].startswith("service:")
        assert "networks" not in svc
    # Sonarr heeft geen network_mode en hoort er wél op te zitten.
    assert "serverup" in doc["services"]["arr-sonarr"]["networks"]
    assert doc["networks"]["serverup"] == {"external": True}


def test_alleen_network_mode_services_levert_geen_netwerkblok():
    """Zit geen enkele service op het gedeelde netwerk, dan hoeft het ook niet
    gedeclareerd te worden."""
    tekst = "services:\n  a:\n    image: x\n    network_mode: host\n"
    doc = yaml.safe_load(_ct.add_shared_network(tekst, "serverup"))
    assert "networks" not in doc["services"]["a"]
    assert "networks" not in doc


def test_huidige_versie_heeft_een_changelog_sectie():
    """release.yml haalt de release-notes uit CHANGELOG.md. Ontbreekt de sectie
    voor de versie die je tagt, dan krijg je een lege release."""
    versie = (WORTEL / "VERSION").read_text(encoding="utf-8").strip()
    changelog = (WORTEL / "CHANGELOG.md").read_text(encoding="utf-8")
    assert f"# v{versie}" in changelog, f"geen changelog-sectie voor {versie}"


def _controleer_javascript_van_initscript(script: str):
    """`bash -n` ziet de JavaScript in de heredoc niet — node wel.

    Een typefout daarin blijkt anders pas op de server, wanneer de reparatie
    van de database stilletjes niets doet.
    """
    import shutil
    node = shutil.which("node")
    if not node:
        pytest.skip("node niet beschikbaar")
    binnen = script.split("<<EOF\n", 1)[1].split("\nEOF", 1)[0]
    # De shell vult ${...} in vóór het script de mongo-shell in gaat.
    js = re.sub(r"\$\{[^}]+\}", "x", binnen)
    r = subprocess.run([node, "--check", "-"], input=js, text=True,
                       capture_output=True)
    assert r.returncode == 0, r.stderr


def test_unifi_heeft_pi_geschikte_en_correct_geinitialiseerde_mongodb():
    app = WORTEL / "apps" / "unifi-network"
    with tempfile.TemporaryDirectory() as t:
        tmp = Path(t)
        doc = _render(app, tmp)
        script = (tmp / "init-mongo.sh").read_text(encoding="utf-8")

    mongo = doc["services"]["unifi-mongo"]
    reparatie = doc["services"]["unifi-mongo-init"]
    unifi = doc["services"]["unifi"]
    assert mongo["image"] == reparatie["image"], "reparatie moet dezelfde versie draaien"
    assert "./init-mongo.sh:/docker-entrypoint-initdb.d/init-mongo.sh:ro" in mongo["volumes"]
    assert any(v == "MONGO_AUTHSOURCE=admin" for v in unifi["environment"])
    assert any(v == "MONGO_AUTHSOURCE=admin" for v in mongo["environment"])
    assert unifi["depends_on"]["unifi-mongo"]["condition"] == "service_healthy"
    assert unifi["depends_on"]["unifi-mongo-init"]["condition"] == \
        "service_completed_successfully"
    assert reparatie["depends_on"]["unifi-mongo"]["condition"] == "service_healthy"
    assert reparatie["restart"] == "no"
    assert "./init-mongo.sh:/init-mongo.sh:ro" in reparatie["volumes"]
    assert any(v == "MONGO_HOST=unifi-mongo" for v in reparatie["environment"])
    # De beheerdersnaam van het allereerste sjabloon. Een volume van toen kent
    # geen 'root', en dan mislukte elke reparatie én elke mongodump.
    assert any(v == "MONGO_INITDB_ROOT_USERNAME=unifi" for v in mongo["environment"])
    assert any(v == "MONGO_INITDB_ROOT_USERNAME=unifi" for v in reparatie["environment"])
    # De healthcheck mag geen inloggegevens gebruiken: bestaat de beheerder
    # niet, dan blijft de container ongezond en start de reparatie nooit.
    assert mongo["healthcheck"]["test"][0] == "CMD-SHELL"
    assert isinstance(mongo["healthcheck"]["test"][1], str)
    assert "--username" not in mongo["healthcheck"]["test"][1]
    assert "ping" in mongo["healthcheck"]["test"][1]
    assert "createUser" in script
    assert "clusterMonitor" in script
    assert 'role: "dbOwner"' in script
    assert "getUser" in script and "updateUser" in script
    assert "grantRolesToUser" in script
    # Rollen die de backup nodig heeft voor mongodump/mongorestore.
    assert 'role: "backup"' in script and 'role: "restore"' in script
    # Meerdere beheerders proberen, inclusief de naam uit het eerste sjabloon.
    assert '"root", "unifi"' in script
    assert "ensureUser(authBron)" in script
    assert "ensureUser(appDatabase)" in script
    syntaxis = subprocess.run(["bash", "-n"], input=script, text=True,
                              capture_output=True)
    assert syntaxis.returncode == 0, syntaxis.stderr
    _controleer_javascript_van_initscript(script)
    assert bp.metadata(app)["architectures"] == ["amd64", "arm64"]
    assert bp.metadata(app)["web"] == {"scheme": "https", "port": 8443}


def test_unifi_zet_zijn_system_properties_bij_elke_start_goed(tmp_path):
    """Het image schrijft /config/data/system.properties alleen bij de eerste
    start ("Only evaluated on first run"). Een later toegevoegde authSource of
    een gewijzigd wachtwoord kwam daar dus nooit in, en UniFi bleef met de oude
    gegevens verbinden — met UserNotFound tot gevolg.
    """
    app = WORTEL / "apps" / "unifi-network"
    doc = _render(app, tmp_path)
    reparatie = doc["services"]["unifi-mongo-init"]
    assert any(v.endswith(":/unifi-config") for v in reparatie["volumes"])

    # De reparatie draaien tegen een bestaand bestand van vóór de authSource.
    config = tmp_path / "unifi-config" / "data"
    config.mkdir(parents=True)
    props = config / "system.properties"
    props.write_text(
        "unifi.https.port=8443\n"
        "db.mongo.local=false\n"
        "db.mongo.uri=mongodb://unifi:oudgeheim@unifi-mongo:27017/unifi?tls=false\n"
        "statdb.mongo.uri=mongodb://unifi:oudgeheim@unifi-mongo:27017/unifi_stat?tls=false\n"
        "unifi.db.name=unifi\n", encoding="utf-8")

    nep = tmp_path / "nepbin"
    nep.mkdir()
    (nep / "mongo").write_text("#!/bin/bash\ncat > /dev/null\n", encoding="utf-8")
    (nep / "mongo").chmod(0o755)
    omgeving = {
        "PATH": f"{nep}:/usr/bin:/bin",
        "MONGO_INITDB_ROOT_USERNAME": "unifi", "MONGO_INITDB_ROOT_PASSWORD": "nieuw@geheim",
        "MONGO_USER": "unifi", "MONGO_PASS": "nieuw@geheim",
        "MONGO_HOST": "unifi-mongo", "MONGO_PORT": "27017",
        "MONGO_DBNAME": "unifi", "MONGO_AUTHSOURCE": "admin",
        "UNIFI_CONFIG_DIR": str(tmp_path / "unifi-config"),
    }
    r = subprocess.run(["bash", str(tmp_path / "init-mongo.sh")],
                       capture_output=True, text=True, env=omgeving, timeout=30)
    assert r.returncode == 0, r.stdout + r.stderr

    regels = dict(l.split("=", 1) for l in props.read_text().strip().splitlines())
    assert "authSource=admin" in regels["db.mongo.uri"]
    assert "authSource=admin" in regels["statdb.mongo.uri"]
    # Bijzondere tekens horen ge-url-codeerd te zijn, anders knipt de @ de URI
    # doormidden.
    assert "nieuw%40geheim" in regels["db.mongo.uri"]
    assert "oudgeheim" not in props.read_text()
    assert regels["statdb.mongo.uri"].split("?")[0].endswith("/unifi_stat")
    # Instellingen die niet over de database gaan blijven staan.
    assert regels["unifi.https.port"] == "8443"


def test_unifi_probeert_ook_het_wachtwoord_uit_system_properties(tmp_path):
    """Wijkt het wachtwoord in .env af van dat waarmee de database ooit is
    aangemaakt, dan is het wachtwoord in system.properties het enige waarmee we
    nog binnenkomen — en dus de enige weg om alles weer gelijk te trekken."""
    _render(WORTEL / "apps" / "unifi-network", tmp_path)
    config = tmp_path / "unifi-config" / "data"
    config.mkdir(parents=True)
    (config / "system.properties").write_text(
        "db.mongo.uri=mongodb://unifi:oud%40geheim@unifi-mongo:27017/unifi?tls=false\n",
        encoding="utf-8")

    nep = tmp_path / "nepbin"
    nep.mkdir()
    # De 'mongo-shell' schrijft op wat hij binnenkrijgt, zodat we kunnen zien
    # welke wachtwoorden geprobeerd worden.
    (nep / "mongo").write_text(
        f"#!/bin/bash\ncat > {tmp_path / 'ontvangen.js'}\n", encoding="utf-8")
    (nep / "mongo").chmod(0o755)
    r = subprocess.run(
        ["bash", str(tmp_path / "init-mongo.sh")], capture_output=True, text=True,
        env={"PATH": f"{nep}:/usr/bin:/bin", "MONGO_INITDB_ROOT_USERNAME": "unifi",
             "MONGO_INITDB_ROOT_PASSWORD": "nieuwgeheim", "MONGO_USER": "unifi",
             "MONGO_PASS": "nieuwgeheim", "MONGO_HOST": "unifi-mongo",
             "MONGO_PORT": "27017", "MONGO_DBNAME": "unifi",
             "MONGO_AUTHSOURCE": "admin",
             "UNIFI_CONFIG_DIR": str(tmp_path / "unifi-config")},
        timeout=30)
    assert r.returncode == 0, r.stdout + r.stderr

    js = (tmp_path / "ontvangen.js").read_text()
    # %40 hoort weer een @ te zijn voordat MongoDB hem te zien krijgt.
    assert 'const oudWachtwoord = "oud@geheim";' in js
    assert 'const beheerWachtwoord = "nieuwgeheim";' in js


def test_unifi_reparatie_werkt_ook_zonder_bestaande_system_properties(tmp_path):
    """Bij een verse installatie schrijft het image het bestand zelf; de
    reparatie mag daar niet over struikelen."""
    _render(WORTEL / "apps" / "unifi-network", tmp_path)
    nep = tmp_path / "nepbin"
    nep.mkdir()
    (nep / "mongo").write_text("#!/bin/bash\ncat > /dev/null\n", encoding="utf-8")
    (nep / "mongo").chmod(0o755)
    r = subprocess.run(
        ["bash", str(tmp_path / "init-mongo.sh")], capture_output=True, text=True,
        env={"PATH": f"{nep}:/usr/bin:/bin", "MONGO_INITDB_ROOT_USERNAME": "unifi",
             "MONGO_INITDB_ROOT_PASSWORD": "x", "MONGO_USER": "unifi", "MONGO_PASS": "x",
             "MONGO_HOST": "unifi-mongo", "MONGO_DBNAME": "unifi",
             "MONGO_AUTHSOURCE": "admin",
             "UNIFI_CONFIG_DIR": str(tmp_path / "bestaat-niet")},
        timeout=30)
    assert r.returncode == 0, r.stdout + r.stderr

AMD64_ALLEEN = {
    "cal-com", "comfyui", "dawarich", "focalboard", "formbricks",
    "mattermost", "pinchflat", "pixelfed", "tubearchivist", "unbound", "wazuh",
}


def test_catalogus_markeert_aantoonbaar_amd64_only_apps():
    for naam in AMD64_ALLEEN:
        meta = bp.metadata(WORTEL / "apps" / naam)
        assert meta["architectures"] == ["amd64"], naam
        assert "Raspberry Pi" in meta["architecture_note"], naam


def test_unifi_pint_mongodb_op_een_versie_die_op_een_pi_4_draait():
    """Vanaf 4.4.19 eist MongoDB ARMv8.2-A. Een Pi 4 is ARMv8.0-A, dus daar
    stopt mongod met 'Illegal instruction' — de container wordt nooit healthy
    en UniFi start niet ("dependency failed to start"). Het sjabloon zegt Pi's
    te ondersteunen, dus de standaardversie moet dat ook echt doen.

    Zie https://jira.mongodb.org/browse/SERVER-71772
    """
    app = WORTEL / "apps" / "unifi-network"
    velden = {f["name"]: f for f in bp.fields(app)}
    assert "mongo_version" in velden, "de versie hoort instelbaar te zijn"
    standaard = str(velden["mongo_version"]["default"])

    major, minor, patch = (int(x) for x in standaard.split(".")[:3])
    assert (major, minor) == (4, 4), f"{standaard} draait niet op een Pi 4"
    assert patch <= 18, (
        f"mongo:{standaard} eist ARMv8.2-A en crasht op een Pi 4; "
        "4.4.18 is de laatste die daar werkt")

    assert "arm64" in bp.metadata(app)["architectures"]
    assert "ARMv8.2" in bp.metadata(app)["architecture_note"], \
        "leg in de notitie uit waarom de versie zo laag staat"


def test_unifi_healthcheck_is_ruim_genoeg_voor_trage_hardware():
    """Op een Pi kost het starten van de mongo-shell zelf al seconden; met een
    krappe timeout is de container ongezond terwijl de database prima draait."""
    app = WORTEL / "apps" / "unifi-network"
    with tempfile.TemporaryDirectory() as t:
        gezond = _render(app, Path(t))["services"]["unifi-mongo"]["healthcheck"]

    def _sec(waarde):
        return int(str(waarde).rstrip("s"))

    assert _sec(gezond["timeout"]) >= 15
    assert _sec(gezond["start_period"]) >= 60
    # Genoeg pogingen om een trage eerste initialisatie te overleven.
    assert _sec(gezond["interval"]) * gezond["retries"] >= 120