"""Scan public modules, classes, and functions for the full-body plan.

The scan is AST only. It does not import aureon and it does not call anything.
"""

from __future__ import annotations

import ast
import json
import re
from collections import Counter, defaultdict
from pathlib import Path

STAGE = {
    "harmonic": 1,
    "cognition": 2,
    "queen": 2,
    "swarm": 2,
    "swarm_motion": 2,
    "gates": 2,
    "governance": 2,
    "alignment": 2,
    "observer": 2,
    "organism": 3,
    "bio": 3,
    "evaluation": 3,
    "vault": 3,
    "identity": 3,
    "data_feeds": 4,
    "atn": 4,
    "decoders": 4,
    "search": 4,
    "portals": 4,
    "monitors": 4,
    "analytics": 4,
    "trading": 5,
    "exchanges": 5,
    "bots": 5,
    "bots_intelligence": 5,
    "bridges": 5,
    "scanners": 5,
    "strategies": 5,
    "portfolio": 5,
    "accounting": 5,
    "conversion": 5,
    "autonomous": 6,
    "code_architect": 6,
    "inhouse_ai": 6,
    "operator": 6,
    "launch": 6,
    "command_centers": 6,
    "connectors": 6,
    "saas": 6,
    "miner": 6,
    "generated": 6,
}

OPERATOR_PACKAGES = {
    "trading",
    "exchanges",
    "bots",
    "bots_intelligence",
    "bridges",
    "scanners",
    "strategies",
    "portfolio",
    "accounting",
    "conversion",
    "autonomous",
    "code_architect",
    "inhouse_ai",
    "operator",
    "launch",
    "command_centers",
    "connectors",
    "saas",
    "miner",
    "identity",
    "vault",
}

ORDER_RE = re.compile(
    r"place_order|create_order|submit_order|live_order|market_order|limit_order|send_order",
    re.I,
)
LAUNCH_RE = re.compile(
    r"^(main|start_|stop_|launch|serve|run_server|boot|demo)$|serve_forever|continuous|create_web",
    re.I,
)
WRITE_RE = re.compile(r"write_text|write_bytes|\.write\(|mkdir|open\([^)]*['\"][wa]", re.I)
KEY_RE = re.compile(
    r"api_key|secret|password|credential|dotenv|owner_address|master_key|from_env|private_key|read_identity",
    re.I,
)
FETCH_RE = re.compile(r"^(fetch_|download_|get_live)|requests\.|urlopen|httpx\.", re.I)
RISKY_RE = re.compile(
    r"(?<![\w])append(?![\w])|"
    r"(?<![\w])publish(?![\w])|"
    r"\bThread\b|"
    r"\.start\s*\(|"
    r"\bunlink\b|"
    r"\bmkdir\b|"
    r"(?<![\w.])eval\s*\(|"
    r"(?<![\w.])exec\s*\(|"
    r"\bemit_\w*|"
    r"open\s*\([^)]*['\"][wa]",
    re.I,
)


def stage_for(pkg: str, rel: str) -> int:
    low = rel.lower()
    if pkg == "core":
        if any(token in low for token in ("organism", "memory", "thought_bus")):
            return 3
        if any(token in low for token in ("hnc", "lambda", "field", "harmonic", "canonical")):
            return 1
        return 6
    if pkg == "utils":
        return 1 if any(token in low for token in ("auris", "queen_hive", "queen")) else 6
    if pkg == "wisdom":
        return 1 if "qgita" in low else 6
    return STAGE.get(pkg, 6)


def source_is_risky(src: str) -> bool:
    """True when a full function body or a class ``__init__`` has a risky token."""

    return bool(src and RISKY_RE.search(src))


def safety(pkg: str, name: str, src: str, stage: int) -> tuple[str, str]:
    blob = name + "\n" + src
    if pkg == "identity" or (pkg == "vault" and KEY_RE.search(blob)):
        return "operator", "personal or key material; operator only; never returned"
    if ORDER_RE.search(blob) or pkg in {
        "trading",
        "exchanges",
        "bots",
        "bots_intelligence",
        "bridges",
        "scanners",
    }:
        return "operator", "order-capable path; live_orders refused; no live send"
    if LAUNCH_RE.search(name) or "serve_forever" in src or "while True" in src:
        return "operator", "process, loop, or UI start; own flag; status and stop"
    if WRITE_RE.search(src) or source_is_risky(src):
        return "operator", "full-body scan found a risky token; the public server refuses it"
    if KEY_RE.search(blob):
        return "operator", "reads keys from env only; never logged or returned"
    if pkg in OPERATOR_PACKAGES and stage >= 5:
        return "operator", "package is operator-scoped; no public import"
    if FETCH_RE.search(blob):
        return "public", "live public fetch allowed; source label and timeout"
    server, text = "public", "runs from inputs or committed files; no keys and no repo write"
    return _honest_effect(name, server, text)


def _honest_effect(name: str, server: str, text: str) -> tuple[str, str]:
    """Names that write or start are not 'no repo write'."""

    leaf = name.split(".")[-1]
    if re.match(r"^(write_|save_|export_|dump_)", leaf, re.I) or leaf.lower() == "start":
        if "no repo write" in text:
            return server, "write or process start; the public server refuses it"
    return server, text


def required_count(node: ast.AST) -> int:
    if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
        return 0
    args = [item for item in node.args.args if item.arg not in {"self", "cls"}]
    required = len(args) - len(node.args.defaults)
    for default in node.args.kw_defaults:
        if default is None:
            required += 1
    if node.args.vararg or node.args.kwarg:
        return required
    return max(required, 0)


def _span(lines: list[str], node: ast.AST) -> str:
    start = getattr(node, "lineno", 1) - 1
    end = getattr(node, "end_lineno", None) or getattr(node, "lineno", 1)
    return "\n".join(lines[start:end])


def _init_source(lines: list[str], class_node: ast.ClassDef) -> str:
    for item in class_node.body:
        if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)) and item.name == "__init__":
            return _span(lines, item)
    return ""


def _scan_tree(pkg: str, rel: str, text: str, server_default: str | None = None) -> list[dict]:
    rows: list[dict] = []
    try:
        tree = ast.parse(text)
    except SyntaxError:
        stage = 5 if pkg == "unified_margin_trader" else stage_for(pkg, rel)
        rows.append(
            {
                "package": pkg,
                "module": rel,
                "symbol": "<syntax>",
                "kind": "module",
                "server": "operator",
                "form": "resource",
                "safety": "file does not parse",
                "stage": stage,
                "required": 0,
            }
        )
        return rows
    stage = 5 if pkg == "unified_margin_trader" else stage_for(pkg, rel)
    lines = text.splitlines()
    module_server = server_default or "operator" if pkg == "unified_margin_trader" else safety(pkg, Path(rel).stem, "", stage)[0]
    module_safety = (
        "order-capable tree; live_orders refused"
        if pkg == "unified_margin_trader"
        else "module surface; import is lazy and blob-checked when the file is the checkout"
    )
    rows.append(
        {
            "package": pkg,
            "module": rel,
            "symbol": Path(rel).stem,
            "kind": "module",
            "server": module_server,
            "form": "resource",
            "safety": module_safety,
            "stage": stage,
            "required": 0,
        }
    )
    for node in tree.body:
        if isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
            server, safe = (
                ("operator", "live_orders refused; no live send")
                if pkg == "unified_margin_trader"
                else safety(pkg, node.name, _init_source(lines, node) or _span(lines, node), stage)
            )
            rows.append(
                {
                    "package": pkg,
                    "module": rel,
                    "symbol": node.name,
                    "kind": "class",
                    "server": server,
                    "form": "resource",
                    "safety": safe,
                    "stage": stage,
                    "required": 0,
                }
            )
            for item in node.body:
                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)) and not item.name.startswith("_"):
                    server, safe = (
                        ("operator", "live_orders refused; no live send")
                        if pkg == "unified_margin_trader"
                        else safety(
                            pkg,
                            item.name,
                            _span(lines, item) + "\n" + _init_source(lines, node),
                            stage,
                        )
                    )
                    rows.append(
                        {
                            "package": pkg,
                            "module": rel,
                            "symbol": f"{node.name}.{item.name}",
                            "kind": "method",
                            "server": server,
                            "form": "tool",
                            "safety": safe,
                            "stage": stage,
                            "required": required_count(item),
                            "async": isinstance(item, ast.AsyncFunctionDef),
                        }
                    )
        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and not node.name.startswith("_"):
            server, safe = (
                ("operator", "live_orders refused; no live send")
                if pkg == "unified_margin_trader"
                else safety(pkg, node.name, _span(lines, node), stage)
            )
            rows.append(
                {
                    "package": pkg,
                    "module": rel,
                    "symbol": node.name,
                    "kind": "function",
                    "server": server,
                    "form": "tool",
                    "safety": safe,
                    "stage": stage,
                    "required": required_count(node),
                    "async": isinstance(node, ast.AsyncFunctionDef),
                }
            )
    return rows


def scan(root: Path) -> list[dict]:
    rows: list[dict] = []
    aureon = root / "aureon"
    for pkg_path in sorted(path for path in aureon.iterdir() if (path / "__init__.py").is_file()):
        for path in sorted(pkg_path.rglob("*.py")):
            if "__pycache__" in path.parts:
                continue
            rel = str(path.relative_to(aureon))
            text = path.read_text(encoding="utf-8", errors="replace")
            rows.extend(_scan_tree(pkg_path.name, rel, text))
    umt = root / "unified_margin_trader"
    for path in sorted(umt.rglob("*.py")):
        if "__pycache__" in path.parts:
            continue
        text = path.read_text(encoding="utf-8", errors="replace")
        rows.extend(_scan_tree("unified_margin_trader", str(path.relative_to(root)), text, "operator"))
    return rows


def render_plan(rows: list[dict]) -> str:
    lines = [
        "# Full body MCP plan",
        "",
        "This is the stage-0 inventory of every public module, class, function, and method in the 54 `aureon` packages plus `unified_margin_trader`. A name that starts with `_` is not listed.",
        "",
        "A layer is at full depth only where a measured call runs that entry point. Listing it here, or reading its signature, is not depth. A helper call is not that layer's cognition. The depth table in each later stage counts calls, not rows.",
        "",
        "MCP lets outside models call Aureon's tools. No outside model or API becomes Aureon's reasoning. The cognition runs in Aureon's own code.",
        "",
        "Public (`aureon-public`) runs entry points that need no keys, personal data, writes, or live fetches. Operator (`aureon-operator`) is stdio only and stays off unless `AUREON_OPERATOR_MCP=1`. It is deny-by-default: the only calls that run are `accounting/file_drop.py` `registered_ingestors` and `portfolio/aureon_billion_goal_tracker.py` `get_days_remaining`, both with `allow_fetch` and `allow_write` false. It does not read keys. Live orders return `live_orders: refused`.",
        "",
        "Functions and methods are tools. Modules and classes are resources (the surface, not a constructed instance). The running servers address them through `body_call` and `body_surface` so the catalog stays one pair of tools instead of nineteen thousand registrations. The form column is the kind of call. `body_call` runs the real function. `body_surface` does not.",
        "",
        "`repo_root()` and `aureon_source()` raise `FileNotFoundError` when there is no checkout. The servers need that checkout.",
        "",
        "Any checkout file loaded beside the pin must pass the git blob check in `mcp/aureon_public/pin_blob.py` before it is executed. A file whose blob is not the blob at pin `8aa6a2d9` is not imported.",
        "",
        "HOLD stays explicit: trade readiness, the Auris-to-Lambda link, QGITA detection and false-alarm rates, Schumann f0, and HumanEval not run. `consciousness_*` keys are dropped. The pin and `AUREON_PUBLIC_REQUIRE_PIN` stay. Space entry points call `enforce_public_pin()`.",
        "",
        "## Stages",
        "",
        "1. HNC, harmonic core, Auris, and QGITA.",
        "2. cognition, queen, swarm, swarm_motion, gates, governance, alignment, observer.",
        "3. organism, bio, evaluation, memory and vault, identity readers.",
        "4. data_feeds, atn, decoders, search, portals, monitors, analytics.",
        "5. trading, exchanges, bots, bots_intelligence, bridges, scanners, strategies, portfolio, accounting, unified_margin_trader, conversion. Operator server. Live orders refused.",
        "6. autonomous, code_architect, inhouse_ai, operator, launch, command_centers, connectors, saas, miner, generated, and the rest.",
        "7. Space entry points and MCP registry packaging.",
        "",
        "## Counts",
        "",
        "| Package | Symbols | Public | Operator | Stage |",
        "| --- | ---: | ---: | ---: | --- |",
    ]
    by_pkg: dict[str, list[dict]] = defaultdict(list)
    for row in rows:
        by_pkg[row["package"]].append(row)
    for pkg in sorted(by_pkg):
        items = by_pkg[pkg]
        public = sum(1 for row in items if row["server"] == "public")
        operator = sum(1 for row in items if row["server"] == "operator")
        stages = ",".join(str(item) for item in sorted({row["stage"] for row in items}))
        lines.append(f"| {pkg} | {len(items)} | {public} | {operator} | {stages} |")
    lines.extend(
        [
            "",
            f"Total symbols: {len(rows)}. Packages: {len(by_pkg)}.",
            "",
            "Stage totals: "
            + ", ".join(f"{stage}={count}" for stage, count in sorted(Counter(row["stage"] for row in rows).items()))
            + ".",
            "",
            "Server totals: "
            + ", ".join(f"{server}={count}" for server, count in sorted(Counter(row["server"] for row in rows).items()))
            + ".",
            "",
            "## Every public module, class, and function",
            "",
            "Columns: stage, server, form, kind, module, symbol, safety.",
            "",
            "| Stage | Server | Form | Kind | Module | Symbol | Safety |",
            "| ---: | --- | --- | --- | --- | --- | --- |",
        ]
    )
    for row in rows:
        safety_text = row["safety"].replace("|", "/")
        symbol = row["symbol"].replace("|", "/")
        lines.append(
            f"| {row['stage']} | {row['server']} | {row['form']} | {row['kind']} | `{row['module']}` | `{symbol}` | {safety_text} |"
        )
    return "\n".join(lines) + "\n"


def write_outputs(root: Path) -> tuple[int, Path, Path]:
    rows = scan(root)
    plan = root / "docs" / "mcp" / "FULL_BODY_PLAN.md"
    inventory = root / "docs" / "mcp" / "inventory.json"
    plan.parent.mkdir(parents=True, exist_ok=True)
    plan.write_text(render_plan(rows), encoding="utf-8")
    inventory.write_text(json.dumps(rows, separators=(",", ":")), encoding="utf-8")
    return len(rows), plan, inventory