"""Data-source health aggregation for Darwin's organism.

The Face's organism (health-as-anatomy: a fresh source glows, a stale one

withers) renders nodes keyed by name. Cortex `/health` historically reported

only the 5 query engines (rag/cbm/serena/memgraph/inbox). This module enriches

`/health` with the REAL ingestion data-sources so the organism reflects the

whole nervous system, not just the engines.

Freshness is read live from the homelab-rag manifest via the RAG bridge's

`GET /sources` endpoint (CT215:9875), which reads /var/tmp/homelab-rag/state.sqlite

(max sync_runs.finished_at per source_id). The Deck (CT215:9893/health) supplies

the live active-agent count for the `agents` node.

Organism node keys (must match DarwinOrganism.tsx SOURCE_CONFIG):

    proxmox, white-pc, 3060, browser-history, agents

    (the 5 engines are emitted by main.py, not here)

source_id -> organism node mapping (SOURCE_NODE_MAP). A node may be fed by more

than one source_id; we take the FRESHEST contributing source (min staleness).

A node with no contributing source present in the manifest is emitted as

status:"down" so the organism withers it (e.g. white-pc, which is not yet

ingesting).

"""

from __future__ import annotations

import os

from datetime import datetime, timezone

import httpx

from models import EngineStatus

RAG_BRIDGE_URL = os.environ.get("RAG_BRIDGE_URL", "http://REDACTED-IP:9875")

DECK_URL = os.environ.get("DECK_URL", "http://REDACTED-IP:9893")

DOWN_THRESHOLD_H = float(os.environ.get("SOURCE_DOWN_THRESHOLD_H", "48"))

SOURCE_NODE_MAP: dict[str, list[str]] = {

    "proxmox": ["pve-node"],

    "white-pc": ["desktop-qi823gr"],

    "3060": ["desktop-f8o1v2s"],

    "browser-history": ["desktop-f8o1v2s-browser"],

    "agents": ["ct215-shell-history", "ct241-shell-history"],

}

async def _fetch_bridge_sources() -> dict:

    async with httpx.AsyncClient(timeout=3.0) as client:

        resp = await client.get(f"{RAG_BRIDGE_URL}/sources")

        resp.raise_for_status()

        return resp.json()

async def _fetch_deck_agents() -> int | None:

    try:

        async with httpx.AsyncClient(timeout=2.5) as client:

            resp = await client.get(f"{DECK_URL}/health")

            resp.raise_for_status()

            return int(resp.json().get("active_agents", 0))

    except Exception:

        return None

def _parse_iso(val: str | None) -> datetime | None:

    if not val:

        return None

    try:

        return datetime.fromisoformat(str(val).replace("Z", "+00:00"))

    except Exception:

        return None

async def source_statuses() -> list[EngineStatus]:

    """Return one EngineStatus per organism data-source node.

    Same schema as the engine entries (engine=node-key, status up/down,

    last_ingest, staleness_h). Graceful: if the bridge is down, every node is

    emitted status:"down" so the organism withers rather than vanishing.

    """

    try:

        payload = await _fetch_bridge_sources()

        by_id = {

            s["source_id"]: s

            for s in payload.get("sources", [])

            if isinstance(s, dict) and s.get("source_id")

        }

    except Exception:

        by_id = {}

    out: list[EngineStatus] = []

    for node_key, source_ids in SOURCE_NODE_MAP.items():

        best: dict | None = None

        for sid in source_ids:

            s = by_id.get(sid)

            if not s:

                continue

            sh = s.get("staleness_h")

            if best is None or (sh is not None and (

                best.get("staleness_h") is None or sh < best["staleness_h"]

            )):

                best = s

        if best is None:

            out.append(EngineStatus(engine=node_key, status="down"))

            continue

        staleness_h = best.get("staleness_h")

        status = "up"

        if staleness_h is None or staleness_h > DOWN_THRESHOLD_H:

            status = "down"

        out.append(EngineStatus(

            engine=node_key,

            status=status,

            last_ingest=_parse_iso(best.get("last_ingest")),

            staleness_h=staleness_h,

        ))

    active = await _fetch_deck_agents()

    if active is not None:

        for st in out:

            if st.engine == "agents":

                st.ms = active

    return out