"""B-gatens rad 1, steg 2: de fire verktøykasse-dørene, drevet UTENFRA som en kommando.

Hver arm her er en **atferdsprobe** i B-gatens forstand: den starter `portfolio_optimiser.toolbox`
som en subprosess med underkommandoens navn i argv, og asserterer på det kommandoen SKREV. Ingen
av dem importerer kjernefunksjonen og kaller den in-prosess — det er nettopp den forskjellen
gaten finnes for å måle, og en probe som gjør begge deler beviser ingenting om døren.

Nevneren for «hva kommandoen skal ha skrevet» er hentet UTENFOR døren i hver arm: filsystemet
(navigate-bundle), en tabell transkribert fra prisskjema-fixturen (cost-baseline), det in-prosess
API-et den deler søm med (retrieve-chunks), og produsentens egen innsjekkede nyttelast
(prepass-admit). En arm som sammenlignet døren med seg selv ville vært grønn uansett hva døren
gjorde.

INGEN modellkall, intet nett: hele poenget med verktøykassen er at disse stegene ikke har en
chatklient på veien, og gaten feller døren om de får en.
"""

from __future__ import annotations

import ast
import json
import shutil
import subprocess
import sys
from pathlib import Path

from portfolio_optimiser import datasource

_REPO = Path(__file__).resolve().parents[1]
_MIKRO = _REPO / "shared" / "examples" / "bygg-energi-mikro"
_PRISSKJEMA = _REPO / "tests" / "fixtures" / "k2-prisskjema-SYNTETISK"
_PREPASS_PAYLOAD = (
    _REPO / "tests" / "fixtures" / "prepass" / "bygg-energi-mikro-fixture.payload.json"
)
_DECLARED_ID = "bygg-energi-mikro-fixture"

#: Prisskjema-fixturens tabell, transkribert fra fixturen — ikke fra derivasjonen som leser den.
_PRICED_ROWS = {
    "21.1": (1250.0, 850.0),
    "24.2": (48000.0, 42.5),
    "36.1": (4.0, 187500.0),
}


def _toolbox(*args: str) -> subprocess.CompletedProcess[str]:
    """Døren, som en subprosess. ``-m``-formen med vilje: den virker i en ren klone uten sync."""
    return subprocess.run(
        [sys.executable, "-m", "portfolio_optimiser.toolbox", *args],
        cwd=_REPO,
        capture_output=True,
        text=True,
    )


# --- navigate-bundle --------------------------------------------------------------------------


def test_navigate_bundle_from_outside_reports_every_file_the_base_holds() -> None:
    """Fasiten er FILSYSTEMET: mikro-basens `.md`-filer, talt her. Basen er bygget så hver av dem
    nås fra indeksen, så «navigert» og «finnes» skal falle sammen — og gjør de det ikke, er det
    dét armen skal si."""
    proc = _toolbox("navigate-bundle", "--bundle-dir", str(_MIKRO))
    assert proc.returncode == 0, proc.stderr
    payload = json.loads(proc.stdout)
    paa_disk = sorted(p.name for p in _MIKRO.glob("*.md"))
    assert sorted(f["name"] for f in payload["files"]) == paa_disk
    assert payload["counts"]["files"] == len(paa_disk)
    assert payload["bundle_dir"] == str(_MIKRO)
    # Sporet bæres UT av døren, ikke summert bort: mikro-basens indeks lenker med vilje til
    # `shared/README.md`, som ligger utenfor basen. En dør som bare ga et filtall ville latt
    # «dokumentet finnes ikke» og «lenken var feil» se like ut for den som skal rette det.
    assert payload["skipped"] == [
        {"from_file": "index.md", "target": "../../README.md", "reason": "outside-bundle"}
    ]
    assert payload["counts"]["skipped"] == 1


def test_navigate_bundle_refuses_a_directory_that_is_no_bundle_with_a_named_code() -> None:
    """rc-0-kontrollens motstykke: en avvisning må IKKE være 0. Exit-koden er det eneste
    signalet en agent som kaller døren har."""
    proc = _toolbox("navigate-bundle", "--bundle-dir", str(_REPO / "docs"))
    assert proc.returncode == 3, proc.stdout
    assert json.loads(proc.stdout)["error"]["kind"]


# --- cost-baseline ----------------------------------------------------------------------------


def test_cost_baseline_from_outside_derives_exactly_what_the_priced_table_says() -> None:
    proc = _toolbox(
        "cost-baseline", "--bundle-dir", str(_PRISSKJEMA), "--project-id", "K2"
    )
    assert proc.returncode == 0, proc.stderr
    payload = json.loads(proc.stdout)
    assert payload["project_id"] == "K2"
    assert set(payload["items"]) == set(_PRICED_ROWS)
    for code, (quantity, unit_cost) in _PRICED_ROWS.items():
        assert payload["items"][code]["quantity"] == quantity, code
        assert payload["items"][code]["unit_cost"] == unit_cost, code


def test_cost_baseline_refuses_an_unpriced_schedule_and_names_the_row() -> None:
    proc = _toolbox(
        "cost-baseline", "--bundle-dir", str(_MIKRO), "--project-id", "bygg-kontor-nord"
    )
    assert proc.returncode == 3, proc.stdout
    assert json.loads(proc.stdout)["error"]["message"]


# --- retrieve-chunks --------------------------------------------------------------------------


def test_retrieve_chunks_from_outside_matches_the_in_process_seam_exactly() -> None:
    """Den ene armen der fasiten ER det in-prosess API-et: verktøykassen skal gi en ekstern
    kaller NØYAKTIG det MAF-agentene får gjennom sin FunctionTool, ikke en egen variant."""
    proc = _toolbox(
        "retrieve-chunks", "--query", "LED retrofit", "--docs-dir", str(_MIKRO), "--top-k", "2"
    )
    assert proc.returncode == 0, proc.stderr
    payload = json.loads(proc.stdout)
    assert payload == datasource.retrieve_chunks("LED retrofit", str(_MIKRO), 2)
    assert len(payload) == 2
    assert payload[0]["snippet"]


def test_retrieve_chunks_refuses_a_top_k_that_asks_for_nothing() -> None:
    proc = _toolbox(
        "retrieve-chunks", "--query", "x", "--docs-dir", str(_MIKRO), "--top-k", "0"
    )
    assert proc.returncode == 3, proc.stdout
    assert "top_k" in json.loads(proc.stdout)["error"]["message"]


# --- prepass-admit ----------------------------------------------------------------------------


def _base_declaring_its_id(tmp_path: Path) -> str:
    """Mikro-basen kopiert med `bundle_id` erklært — `shared/` er et pull-only subtree."""
    root = tmp_path / "en-annen-mount"
    shutil.copytree(_MIKRO, root)
    index = root / "index.md"
    lines = index.read_text(encoding="utf-8").split("\n")
    assert lines[0].strip() == "---", "basen åpner ikke lenger med frontmatter"
    lines.insert(1, f"bundle_id: {_DECLARED_ID}")
    index.write_text("\n".join(lines), encoding="utf-8")
    return str(root)


def test_prepass_admit_from_outside_admits_the_producers_own_payload(tmp_path: Path) -> None:
    """Produsentens innsjekkede output, uendret. Uten denne rc-0-kontrollen måler avvisnings-
    armen under ingenting — den ville vært grønn mot en dør som avviste alt."""
    proc = _toolbox(
        "prepass-admit",
        "--payload",
        str(_PREPASS_PAYLOAD),
        "--bundle-dir",
        _base_declaring_its_id(tmp_path),
    )
    assert proc.returncode == 0, proc.stderr
    payload = json.loads(proc.stdout)
    assert payload["admitted"] is True
    assert payload["bundle_id"] == _DECLARED_ID
    assert payload["delivered"] == 4


def test_prepass_admit_refuses_a_payload_that_names_another_base(tmp_path: Path) -> None:
    raw = json.loads(_PREPASS_PAYLOAD.read_text(encoding="utf-8"))
    raw["bundle"]["bundle_id"] = "en-helt-annen-base"
    endret = tmp_path / "endret.payload.json"
    endret.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8")
    proc = _toolbox(
        "prepass-admit",
        "--payload",
        str(endret),
        "--bundle-dir",
        _base_declaring_its_id(tmp_path),
    )
    assert proc.returncode == 3, proc.stdout
    assert "en-helt-annen-base" in json.loads(proc.stdout)["error"]["message"]


# --- døren selv ---------------------------------------------------------------------------------


def test_the_toolbox_has_no_chat_client_on_any_of_its_paths() -> None:
    """Verktøykassens ene forutsetning, målt i kilden: ingen av de fire kommandoene drar en
    modell med seg. Gaten måler det samme på rad 1; her står det som en egen påstand, fordi det
    er DENNE modulens grunn til å finnes."""
    modul = _REPO / "src" / "portfolio_optimiser" / "toolbox.py"
    tre = ast.parse(modul.read_text(encoding="utf-8"))
    kalt = {
        node.func.attr if isinstance(node.func, ast.Attribute) else getattr(node.func, "id", "")
        for node in ast.walk(tre)
        if isinstance(node, ast.Call)
    }
    for navn in ("create_chat_client", "client_factory", "BaseChatClient", "get_backend"):
        assert navn not in kalt, navn

    importert: set[str] = set()
    for node in ast.walk(tre):
        if isinstance(node, ast.ImportFrom):
            importert |= {f"{node.module}.{a.name}" for a in node.names}
        elif isinstance(node, ast.Import):
            importert |= {a.name for a in node.names}
    assert not any(navn.startswith("portfolio_optimiser.run") for navn in importert), importert
    assert "portfolio_optimiser.run" not in importert
    # Kontroll: armen KAN se en import — uten den ville den vært grønn mot et tomt sett.
    assert "portfolio_optimiser.okf" in importert or "portfolio_optimiser.prepass" in importert


def test_wrong_usage_is_exit_two_and_never_a_silent_zero() -> None:
    assert _toolbox().returncode == 2
    assert _toolbox("ingen-slik-kommando").returncode == 2
    assert _toolbox("navigate-bundle").returncode == 2