"""cbm-homelab adapter - SSE :9877.

Calls search_graph across indexed projects. Authority tier: recent-file.

CBM's search_graph requires a project parameter. We discover the project list

by calling list_projects first (cached after first success), then fan out

search_graph calls to the most relevant projects in parallel.

If list_projects is unavailable we fall back to the project list embedded

in the "project not found" error that search_graph returns without a project arg.

"""

from __future__ import annotations

import asyncio

import json

import os

from models import Hit

from adapters.base import BaseAdapter

from adapters.mcp_base import call_mcp_tool

CBM_URL = os.environ.get("CBM_URL", "http://REDACTED-IP:9877/sse")

_PROJECT_CACHE: list[str] | None = None

MAX_PROJECTS = 6

async def _get_projects() -> list[str]:

    """Return list of available CBM project names, cached."""

    global _PROJECT_CACHE

    if _PROJECT_CACHE is not None:

        return _PROJECT_CACHE

    blocks = await call_mcp_tool(CBM_URL, "list_projects", {}, timeout=3.5)

    for block in blocks:

        projects = block.get("projects") if isinstance(block, dict) else None

        if isinstance(projects, list):

            _PROJECT_CACHE = [str(p) for p in projects]

            return _PROJECT_CACHE

    err_blocks = await call_mcp_tool(CBM_URL, "search_graph", {"query": "status", "limit": 1}, timeout=3.5)

    for block in err_blocks:

        raw = block.get("text", "") if isinstance(block, dict) else ""

        try:

            parsed = json.loads(raw)

            avail = parsed.get("available_projects") or []

            if avail:

                _PROJECT_CACHE = [str(p) for p in avail]

                return _PROJECT_CACHE

        except Exception:

            pass

    _PROJECT_CACHE = []

    return _PROJECT_CACHE

def _rank_projects(projects: list[str], query: str) -> list[str]:

    """Pick the most query-relevant projects to search (heuristic)."""

    query_lower = query.lower()

    query_words = set(query_lower.split())

    def relevance(proj: str) -> int:

        p = proj.lower()

        score = 0

        for word in query_words:

            if word in p:

                score += 3

        if any(k in p for k in ("hermes", "treetrace", "jobforge", "oversight",

                                  "darwin", "personal", "homelab", "portfolio")):

            score += 2

        if any(k in p for k in ("archive", "bounty", "staging", "triage",

                                  "mirror", "cache", "plugins")):

            score -= 1

        return score

    ranked = sorted(projects, key=relevance, reverse=True)

    return ranked[:MAX_PROJECTS]

def _parse_cbm_block(block: dict) -> list[Hit]:

    """Parse one content block from search_graph into Hit objects."""

    results = block.get("results") or block.get("nodes") or []

    hits = []

    if isinstance(results, list):

        for r in results:

            if not isinstance(r, dict):

                continue

            name = r.get("name") or r.get("title") or r.get("qualified_name", "")

            if not name:

                continue

            file_path = r.get("file") or r.get("path") or r.get("file_path", "")

            snippet = (r.get("summary") or r.get("snippet") or

                       r.get("signature") or "")[:300]

            raw = r.get("score") or r.get("relevance") or r.get("rank") or 0

            try:

                score = min(1.0, max(0.0, -float(raw) / 10.0)) if float(raw) < 0 else float(raw)

            except Exception:

                score = 0.5

            hits.append(Hit(

                engine="cbm",

                title=str(name),

                path=str(file_path),

                snippet=str(snippet),

                score=score,

                last_seen=None,

                confidence=0.8,

                authority_tier="recent-file",

            ))

    elif isinstance(block, dict) and "text" in block:

        text = str(block["text"])

        if '"error"' not in text:

            hits.append(Hit(

                engine="cbm",

                title="code graph result",

                snippet=text[:300],

                score=0.5,

                confidence=0.7,

                authority_tier="recent-file",

            ))

    return hits

class CbmAdapter(BaseAdapter):

    engine = "cbm"

    authority_tier = "recent-file"

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

        projects = await _get_projects()

        if not projects:

            return []

        selected = _rank_projects(projects, query)

        if not selected:

            return []

        tasks = [

            asyncio.create_task(

                call_mcp_tool(CBM_URL, "search_graph",

                              {"project": proj, "query": query, "limit": k},

                              timeout=3.0)

            )

            for proj in selected

        ]

        all_blocks_list = await asyncio.gather(*tasks, return_exceptions=True)

        all_hits: list[Hit] = []

        seen: set[str] = set()

        for blocks in all_blocks_list:

            if isinstance(blocks, Exception) or not blocks:

                continue

            for block in blocks:

                for hit in _parse_cbm_block(block):

                    key = hit.path or hit.title

                    if key not in seen:

                        seen.add(key)

                        all_hits.append(hit)

        all_hits.sort(key=lambda h: h.score, reverse=True)

        return all_hits[:k]