"""memory-graph adapter - SSE :9879.

Calls query_entities + query_relations. Authority tier: agent-memory.

RESPONSE SHAPE: The memory-graph MCP server returns raw JSON arrays, not wrapped

dicts.  call_mcp_tool json.loads each block text, so `blocks` is a list where

each element is the parsed payload - which for query_entities is a list of entity

dicts directly (not {"entities": [...]}):

    blocks = [[{entity}, {entity}], ...]

We extract entities from this by treating each block that is a list as the

entity list, and each block that is a dict as a single entity fallback.

For query terms, the server supports:

  - type=  filter by entity type (project, decision, person, etc.)

  - name=  substring match on entity name

  - q=     free-text search (may not be implemented in all versions)

  Omitting all filters returns all entities (use limit to cap).

Strategy: fetch all entities (limit=k*3) and filter client-side for relevance,

plus fetch relations for the most relevant entity ids.

"""

from __future__ import annotations

import asyncio

import os

from datetime import datetime, timezone

from models import Hit

from adapters.base import BaseAdapter

from adapters.mcp_base import call_mcp_tool

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

def _parse_dt(raw) -> datetime | None:

    if not raw:

        return None

    try:

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

    except Exception:

        return None

def _entity_to_hit(e: dict) -> Hit | None:

    """Convert a memory-graph entity dict to a Hit."""

    if not isinstance(e, dict):

        return None

    entity_id = e.get("id", "")

    name = e.get("name") or entity_id

    attributes = e.get("attributes") or {}

    snippet_parts = []

    for key in ("status", "summary", "description", "lesson", "notes"):

        val = attributes.get(key)

        if val:

            snippet_parts.append(f"{key}: {val}")

    if not snippet_parts:

        snippet_parts = [f"{k}: {v}" for k, v in attributes.items()]

    snippet = " | ".join(snippet_parts)[:400]

    dt = _parse_dt(

        e.get("updated_at") or e.get("created_at") or e.get("last_seen")

    )

    return Hit(

        engine="memgraph",

        title=str(name),

        path=f"memory://{entity_id}",

        snippet=snippet or str(attributes)[:300],

        score=0.6,

        last_seen=dt,

        confidence=0.75,

        authority_tier="agent-memory",

    )

def _relation_to_hit(r: dict) -> Hit | None:

    """Convert a memory-graph relation dict to a Hit."""

    if not isinstance(r, dict):

        return None

    from_id = r.get("from_id", "")

    to_id = r.get("to_id", "")

    relation = r.get("relation", "")

    if not (from_id and to_id and relation):

        return None

    snippet = f"{from_id} --[{relation}]--> {to_id}"

    attrs = r.get("attributes") or {}

    if attrs:

        snippet += f" | {attrs}"

    dt = _parse_dt(r.get("created_at") or r.get("valid_from"))

    return Hit(

        engine="memgraph",

        title=f"{from_id} → {to_id}",

        path=f"memory://relation/{r.get('id', '')}",

        snippet=snippet[:400],

        score=0.5,

        last_seen=dt,

        confidence=0.65,

        authority_tier="agent-memory",

    )

def _extract_items(blocks: list) -> list[dict]:

    """Extract entity/relation dicts from call_mcp_tool return value.

    Handles both:

      - blocks = [[{entity}, ...], ...]   (list of parsed JSON arrays)

      - blocks = [{"entities": [{...}]}, ...]  (list of parsed dicts with key)

      - blocks = [{entity}]               (flat list of dicts)

    """

    items: list[dict] = []

    for block in blocks:

        if isinstance(block, list):

            items.extend(block)

        elif isinstance(block, dict):

            inner = block.get("entities") or block.get("results") or block.get("relations")

            if isinstance(inner, list):

                items.extend(inner)

            elif block.get("id"):

                items.append(block)

    return items

def _score_by_query(entity: dict, query_lower: str) -> float:

    """Rough relevance score for an entity against the query."""

    text = " ".join([

        str(entity.get("name") or ""),

        str(entity.get("id") or ""),

        str(entity.get("type") or ""),

        str(entity.get("attributes") or ""),

    ]).lower()

    query_words = query_lower.split()

    matched = sum(1 for w in query_words if w in text and len(w) > 2)

    return min(1.0, 0.4 + matched * 0.15)

class MemgraphAdapter(BaseAdapter):

    engine = "memgraph"

    authority_tier = "agent-memory"

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

        query_lower = query.lower()

        entity_task = asyncio.create_task(

            call_mcp_tool(MEMGRAPH_URL, "query_entities", {"limit": k * 4}, timeout=3.5)

        )

        relation_task = asyncio.create_task(

            call_mcp_tool(MEMGRAPH_URL, "query_relations", {"limit": k * 2}, timeout=3.5)

        )

        entity_blocks, relation_blocks = await asyncio.gather(entity_task, relation_task)

        entities = _extract_items(entity_blocks)

        entity_hits: list[Hit] = []

        for e in entities:

            hit = _entity_to_hit(e)

            if hit:

                hit.score = _score_by_query(e, query_lower)

                entity_hits.append(hit)

        relations = _extract_items(relation_blocks)

        relation_hits: list[Hit] = []

        for r in relations:

            hit = _relation_to_hit(r)

            if hit:

                relation_hits.append(hit)

        all_hits = entity_hits + relation_hits

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

        seen: set[str] = set()

        deduped: list[Hit] = []

        for h in all_hits:

            key = h.path or h.title

            if key not in seen:

                seen.add(key)

                deduped.append(h)

        return deduped[:k]