"""homelab-rag adapter - queries the Darwin RAG bridge (port 9875) directly.

The RAG bridge is a lightweight HTTP service on CT215 that queries the

homelab-rag SQLite FTS index directly, bypassing the Node.js MCP SSE shim

which takes 70-80s per call due to per-call Node.js process spawning + CIFS reads.

Bridge endpoint: GET http://REDACTED-IP:9875/search?q=QUERY&limit=N

Returns: JSON array in the same shape as homelab_search results.

Authority tier: recent-file (homelab-rag indexes files with mtime).

"""

from __future__ import annotations

import os

from datetime import datetime, timezone

import httpx

from models import Hit

from adapters.base import BaseAdapter

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

RECENT_CUTOFF_DAYS = 30

def _parse_dt(val) -> datetime | None:

    if not val:

        return None

    try:

        if isinstance(val, (int, float)):

            ts = val / 1000.0 if val > 1e10 else float(val)

            return datetime.fromtimestamp(ts, tz=timezone.utc)

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

    except Exception:

        return None

def _authority_from_mtime(dt: datetime | None) -> str:

    if dt is None:

        return "older-note"

    age = (datetime.now(timezone.utc) - dt).days

    return "recent-file" if age <= RECENT_CUTOFF_DAYS else "older-note"

def _parse_bridge_results(results: list[dict]) -> list[Hit]:

    """Convert bridge response (list of result dicts) to Hit objects."""

    hits = []

    for r in results:

        if not isinstance(r, dict):

            continue

        mtime = _parse_dt(r.get("mtimeMs") or r.get("mtime") or r.get("last_seen"))

        snippet = r.get("text") or r.get("snippet") or r.get("content", "")

        hits.append(Hit(

            engine="rag",

            title=r.get("title") or r.get("relPath", "")[:80],

            path=r.get("path") or r.get("relPath", ""),

            snippet=str(snippet)[:400],

            score=float(r.get("score") or 0.5),

            last_seen=mtime,

            confidence=0.8,

            authority_tier=_authority_from_mtime(mtime),

        ))

    return hits

class RagAdapter(BaseAdapter):

    engine = "rag"

    authority_tier = "recent-file"

    async def _fetch(self, query: str, k: int) -> list[Hit]:

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

            resp = await client.get(

                f"{RAG_BRIDGE_URL}/search",

                params={"q": query, "limit": k},

            )

            resp.raise_for_status()

            results = resp.json()

        if not isinstance(results, list):

            return []

        hits = _parse_bridge_results(results)

        seen: set[str] = set()

        deduped = []

        for h in hits:

            key = h.path or h.snippet[:50]

            if key not in seen:

                seen.add(key)

                deduped.append(h)

        return deduped[:k]