"""Call every body_call-reachable entry point.

Each call uses the public worker. Sockets are blocked and logged in that
worker. Fake NEXUS and Sero checkouts sit beside the repo. Stage-2 entry
points are also called with the real arguments in stage2_arguments.
SwarmAgent.update is also called with the hive fixture from
tests/test_swarm_hive.py. An entry point is refused when any of those calls
opens a connection, starts a process, writes outside the sandbox, or loads
queen, miner, swarm_motion, inhouse_ai, ollama_config, or an HTTP client.

    bash measured/aureon_public_call_sweep.sh
"""

from __future__ import annotations

import argparse
import json
import os
import subprocess
import sys
from pathlib import Path
from typing import Any


def _tested_stage1_tools() -> set[tuple[str, str]]:
    return {
        ("alignment/harmonic_resonance.py", "compute_signal_consensus"),
        ("alignment/harmonic_resonance.py", "consonance_score"),
        ("alignment/harmonic_resonance.py", "analyse_frequency_harmony"),
        ("alignment/harmonic_resonance.py", "compute_phase_coherence"),
        ("alignment/harmonic_resonance.py", "derive_phase"),
        ("alignment/harmonic_resonance.py", "geometric_mean"),
        ("alignment/harmonic_resonance.py", "full_harmonic_analysis"),
        ("alignment/harmonic_resonance.py", "HarmonicAnalysis.to_dict"),
        ("alignment/pillar_alignment.py", "AlignmentCycleResult.to_dict"),
        ("alignment/pillar_alignment.py", "get_pillar_alignment"),
        ("alignment/unified_directive.py", "MasterDirective.to_dict"),
        ("generated/research_cinema/harmonic_nexus_score_model.py", "build_default_inputs"),
        ("generated/research_cinema/harmonic_nexus_score_model.py", "HarmonicNexusScoreInputs.normalized"),
        ("generated/research_cinema/harmonic_nexus_score_model.py", "harmonic_nexus_score"),
        ("generated/research_cinema/harmonic_nexus_score_model.py", "score_breakdown"),
        ("swarm/druidic_council.py", "voice_for_gamma"),
        ("swarm/fleadh.py", "steer_flow"),
        ("swarm/druidic_council.py", "build_seat_receipt"),
        ("swarm/agent.py", "SwarmAgent.substrate"),
        ("swarm/agent.py", "SwarmAgent.to_dict"),
        ("swarm/agent.py", "SwarmAgent.propose"),
        ("swarm/coherence.py", "ClusterCoherence.gamma"),
        ("swarm/coherence.py", "ClusterCoherence.to_dict"),
        ("swarm/memory_bus.py", "CausalEchoBus.echo"),
        ("swarm/memory_bus.py", "CausalEchoBus.to_dict"),
        ("swarm/steering.py", "SteeringField.steer"),
        ("swarm/druidic_council.py", "SeatReceipt.to_dict"),
        ("swarm/druidic_council.py", "CouncilReceipt.to_dict"),
        ("swarm/queen_gate.py", "Actualization.to_dict"),
        ("swarm/agent.py", "SwarmAgent.update"),
    }


def reachable_entries() -> list[dict[str, Any]]:
    """Entry points body_call will run while the call-sweep gate is open."""

    import aureon_public.body as body_module

    body_module.enable_sweep_measurement()
    from aureon_public.body import _inventory, _plan_stage, public_entry_refusal

    seen: set[tuple[str, str]] = set()
    found = []
    rows, _index = _inventory()
    for row in rows:
        if row["server"] != "public" or row["kind"] not in {"function", "method"}:
            continue
        key = (str(row["module"]), str(row["symbol"]))
        if key in seen:
            continue
        seen.add(key)
        if public_entry_refusal(row) is not None:
            continue
        found.append(
            {
                "module": key[0],
                "package": str(row["package"]),
                "plan_stage": _plan_stage(str(row["package"])),
                "symbol": key[1],
            }
        )
    return found


def hazard_reason(payload: dict[str, Any]) -> str | None:
    """The refusal sentence for one call. None when the call stayed inside the rules."""

    bad = payload.get("bad") or []
    sockets = payload.get("socket") or []
    processes = payload.get("process") or []
    writes = payload.get("writes") or []
    if bad or sockets:
        return "call loads a banned chain or opens a connection"
    if processes:
        return "call starts a process"
    if writes:
        return "call writes outside the sandbox"
    return None


def child_main(module: str, symbol: str, arguments_json: str = "") -> None:
    import aureon_public.body as body_module
    from aureon_public.sweep_guard import declare_sandbox

    declare_sandbox()
    body_module.enable_sweep_measurement()
    text = body_module.body_call(module, symbol, arguments_json)
    try:
        body = json.loads(text)
    except json.JSONDecodeError:
        body = {"status": "unavailable", "reason": "result was not JSON"}
    report = body_module.last_sweep_report or {}
    json.dump(
        {
            "bad": list(report.get("modules") or []),
            "called": body.get("called") is True,
            "process": list(report.get("processes") or []),
            "reason": body.get("reason"),
            "sandbox_writes": list(report.get("sandbox_writes") or []),
            "socket": list(report.get("sockets") or []),
            "status": body.get("status"),
            "writes": list(report.get("writes") or []),
        },
        sys.stdout,
    )


def _one(module: str, symbol: str, timeout: float, arguments_json: str = "") -> dict[str, Any]:
    command = [
        sys.executable,
        "-m",
        "aureon_public.call_sweep",
        "--module",
        module,
        "--symbol",
        symbol,
    ]
    if arguments_json:
        command.extend(["--arguments", arguments_json])
    try:
        completed = subprocess.run(
            command,
            cwd=os.environ.get("TMPDIR") or "/tmp",
            capture_output=True,
            text=True,
            timeout=timeout,
            check=False,
            env={key: value for key, value in os.environ.items() if key != "AUREON_PUBLIC_SWEEP"},
        )
    except subprocess.TimeoutExpired:
        return {
            "bad": [],
            "called": False,
            "error": "sweep exceeded the timeout",
            "process": [],
            "socket": [],
            "status": "unavailable",
            "writes": [],
        }
    if not completed.stdout.strip():
        return {
            "bad": [],
            "called": False,
            "error": f"sweep exited {completed.returncode}",
            "process": [],
            "socket": [],
            "status": "unavailable",
            "writes": [],
        }
    try:
        payload = json.loads(completed.stdout)
    except json.JSONDecodeError:
        return {
            "bad": [],
            "called": False,
            "error": "sweep result was not JSON",
            "process": [],
            "socket": [],
            "status": "unavailable",
            "writes": [],
        }
    return payload if isinstance(payload, dict) else {}


def _first_hazard(hazards: list[str]) -> str | None:
    order = (
        "call loads a banned chain or opens a connection",
        "call starts a process",
        "call writes outside the sandbox",
        "call did not finish",
    )
    for sentence in order:
        if sentence in hazards:
            return sentence
    return None


def _stage1_extra_attempts(module: str, symbol: str) -> list[dict[str, Any]]:
    """Real stage-1 arguments copied from tests/test_swarm_hive.py."""

    if (module, symbol) != ("swarm/agent.py", "SwarmAgent.update"):
        return []
    return [
        {
            "arguments": {
                "cluster_states": [],
                "context": [0.4, 0.2, -0.1, 0.3, 0.0, 0.1, -0.2, 0.05],
                "echo": None,
                "init": {
                    "actions": ["hold", "advance", "retreat"],
                    "agent_id": "a1",
                    "role": "research",
                },
            },
            "label": "hive_first_update",
            "note": "The first update call in test_agent_keeps_a_normalized_soft_simplex. Empty cluster and no echo.",
            "source": "tests/test_swarm_hive.py",
        }
    ]


def build_record(timeout: float) -> dict[str, Any]:
    from aureon_public.guard_loader import aureon_source
    from aureon_public.measurement_stamp import measurement_stamp
    from aureon_public.sweep_layout import layout_record

    from aureon_public.stage2_arguments import attempts_for

    source = aureon_source()
    stamp = measurement_stamp()
    tested = _tested_stage1_tools()
    entries = []
    for row in reachable_entries():
        print(f"{row['module']} {row['symbol']}", file=sys.stderr)
        planned = [
            {
                "arguments": {},
                "label": "no_arguments",
                "note": "No arguments.",
                "source": None,
            }
        ]
        if row["plan_stage"] == 2:
            planned.extend(attempts_for(row["module"], row["symbol"]))
        planned.extend(_stage1_extra_attempts(row["module"], row["symbol"]))
        recorded = []
        hazards: list[str] = []
        for attempt in planned:
            if attempt.get("fixture"):
                arguments_json = json.dumps({"__sweep_fixture__": attempt["fixture"]})
                shown: dict[str, Any] = {"__sweep_fixture__": attempt["fixture"]}
            else:
                arguments = attempt.get("arguments") if isinstance(attempt.get("arguments"), dict) else {}
                arguments_json = json.dumps(arguments) if arguments else ""
                shown = arguments if isinstance(arguments, dict) else {}
            payload = _one(row["module"], row["symbol"], timeout, arguments_json)
            reason = hazard_reason(payload)
            if reason:
                hazards.append(reason)
            elif row["plan_stage"] == 2 and payload.get("error"):
                hazards.append("call did not finish")
                reason = "call did not finish"
            recorded.append(
                {
                    "arguments": shown,
                    "bad": [str(item) for item in payload.get("bad") or []],
                    "called": payload.get("called") is True,
                    "error": payload.get("error"),
                    "label": attempt.get("label"),
                    "note": attempt.get("note"),
                    "process": [str(item) for item in payload.get("process") or []],
                    "reason": payload.get("reason"),
                    "refusal": reason,
                    "sandbox_writes": [str(item) for item in payload.get("sandbox_writes") or []],
                    "socket": [str(item) for item in payload.get("socket") or []],
                    "source": attempt.get("source"),
                    "status": payload.get("status"),
                    "writes": [str(item) for item in payload.get("writes") or []],
                }
            )
        first = recorded[0]
        refusal = _first_hazard(hazards)
        key = (row["module"], row["symbol"])
        entries.append(
            {
                "attempts": recorded,
                "bad": first["bad"],
                "called": first["called"],
                "error": first["error"],
                "module": row["module"],
                "package": row["package"],
                "plan_stage": row["plan_stage"],
                "process": first["process"],
                "reason": first["reason"],
                "refusal": refusal,
                "refused": refusal is not None,
                "sandbox_writes": sorted(
                    {item for attempt in recorded for item in attempt["sandbox_writes"]}
                ),
                "socket": first["socket"],
                "status": first["status"],
                "symbol": row["symbol"],
                "tested_stage1_tool": key in tested,
                "writes": first["writes"],
            }
        )
    from aureon_public.sweep_layout import beside

    home = beside() / "home"
    return {
        "aureon_source": source,
        "entries": entries,
        "layout": layout_record(),
        "user_dirs": {
            "HOME": str(home),
            "USERPROFILE": str(home),
            "XDG_CACHE_HOME": str(home / ".cache"),
            "XDG_CONFIG_HOME": str(home / ".config"),
            "XDG_DATA_HOME": str(home / ".local" / "share"),
            "XDG_RUNTIME_DIR": str(beside() / "runtime"),
            "XDG_STATE_HOME": str(home / ".local" / "state"),
        },
        "processes": "blocked",
        "sockets": "blocked",
        "writes": "outside sandbox blocked",
        **stamp,
    }


def main(argv: list[str] | None = None) -> None:
    parser = argparse.ArgumentParser(prog="aureon-public-call-sweep")
    parser.add_argument("--module")
    parser.add_argument("--symbol")
    parser.add_argument("--arguments", default="")
    parser.add_argument("--out", type=Path)
    parser.add_argument("--timeout", type=float, default=45.0)
    args = parser.parse_args(argv)
    if args.module or args.symbol:
        if not args.module or not args.symbol:
            raise SystemExit("module and symbol are both required")
        child_main(args.module, args.symbol, args.arguments)
        return
    record = build_record(args.timeout)
    text = json.dumps(record, indent=2, sort_keys=True) + "\n"
    if args.out is None:
        sys.stdout.write(text)
        return
    args.out.parent.mkdir(parents=True, exist_ok=True)
    args.out.write_text(text, encoding="utf-8")


if __name__ == "__main__":
    main()