"""Darwin Cortex - synthesis layer.

Two paths:

1. Deterministic ranked-merge (always works, no LLM required):

   top-k hits → templated answer + receipts.

2. LLM synthesis (pluggable, gated behind synthesize=True + backend availability):

   - qwen3:8b on 3060 (http://REDACTED-IP:11434/api/chat, think:false) - primary

   - Claude Opus (gated behind DARWIN_CLAUDE_API_KEY + DARWIN_ENABLE_OPUS=true) - hard questions

Current 3060 state: may be DOWN → graceful fallback to deterministic path.

"""

from __future__ import annotations

import os

from typing import Optional

import httpx

from models import Hit, Receipt

QWEN_URL = os.environ.get("DARWIN_QWEN_URL", "http://REDACTED-IP:11434/api/chat")

QWEN_MODEL = os.environ.get("DARWIN_QWEN_MODEL", "qwen3:8b")

QWEN_TIMEOUT = float(os.environ.get("DARWIN_QWEN_TIMEOUT", "20"))

QWEN_KEEP_ALIVE = os.environ.get("DARWIN_QWEN_KEEP_ALIVE", "30m")

ENABLE_OPUS = os.environ.get("DARWIN_ENABLE_OPUS", "false").lower() == "true"

CLAUDE_API_KEY = os.environ.get("DARWIN_CLAUDE_API_KEY", "")

def _make_receipts(hits: list[Hit], max_receipts: int = 6) -> list[Receipt]:

    receipts = []

    for i, h in enumerate(hits[:max_receipts]):

        receipts.append(Receipt(

            id=f"r{i+1}",

            source=h.engine,

            path=h.path,

            last_seen=h.last_seen,

            confidence=h.confidence,

            snippet=h.snippet[:200],

        ))

    return receipts

def _clean_snippet(text: str, limit: int = 240) -> str:

    """Flatten a snippet into one prose-ish sentence-fragment: strip markdown

    bullets/headers/backticks and collapse whitespace."""

    import re

    t = re.sub(r"[`*#>_]", "", text or "")

    t = re.sub(r"\s+", " ", t).strip()

    t = re.sub(r"^(?:[-•]\s*|\d+\.\s*)", "", t)

    if len(t) > limit:

        t = t[: limit - 1].rstrip() + "…"

    return t

_DESC_KEY_PRIORITY = ("summary", "description", "desc", "note", "title")

_JUNK_KEYS = {

    "date", "ts", "timestamp", "updated", "created", "endpoint", "url", "urls",

    "uri", "backups", "backup", "registered_agents", "agents", "service",

    "shim", "status", "state", "id", "ids", "path", "paths", "score", "engine",

    "source", "authority", "authority_tier", "type", "kind", "version",

}

def _extract_descriptive(snippet: str, title: str = "", limit: int = 400) -> tuple[str, int]:

    """Pull the single most descriptive value out of a snippet.

    Darwin memory-graph snippets are often pipe-delimited metadata like

    "status: DEPLOYED | summary: <real prose> | date: ...". This splits on

    " | ", parses "key: value" pairs, and returns the value of the highest-

    priority descriptive key (summary > description > desc > note > title,

    then the first non-junk value). Junk keys (date/endpoint/status/...) are

    never chosen. Returns (text, rank) where lower rank = more descriptive.

    Falls back to the cleaned snippet (or title) when not pipe-delimited.

    """

    s = _clean_snippet(snippet or "", limit=limit)

    if " | " in s:

        pairs: dict[str, str] = {}

        order: list[str] = []

        for part in s.split(" | "):

            k, sep, v = part.partition(":")

            k = k.strip().lower()

            v = v.strip()

            if k and sep and v:

                pairs[k] = v

                if k not in order:

                    order.append(k)

        if pairs:

            for rank, pk in enumerate(_DESC_KEY_PRIORITY):

                if pairs.get(pk):

                    return pairs[pk], rank

            for k in order:

                if k not in _JUNK_KEYS and pairs[k]:

                    return pairs[k], len(_DESC_KEY_PRIORITY)

            return "", 999

    if s:

        return s, len(_DESC_KEY_PRIORITY)

    return _clean_snippet(title or "", limit=limit), len(_DESC_KEY_PRIORITY)

def _strip_prose_junk(text: str) -> str:

    """Defensive net: ensure no pipe-chains, graph arrows, or raw URLs survive

    into the final prose. _extract_descriptive should already have handled

    pipes, but we never emit "key: value | key: value", "--[...]-->", or

    http/memory:// URLs regardless."""

    import re

    t = text or ""

    t = re.sub(r"--\s*\[[^\]]*\]\s*--*>?", "", t)

    t = t.split(" | ")[0]

    t = re.sub(r"https?://\S+", "", t)

    t = re.sub(r"\b(?:memory|file|s3|ftp)://\S+", "", t)

    t = re.sub(r"\s+", " ", t).strip(" ;,|")

    return t

def _is_noise(text: str) -> bool:

    """True if the extracted text is graph-relation noise, empty, or just an

    id/url - i.e. not worth a clause in the answer."""

    import re

    t = (text or "").strip()

    if not t:

        return True

    if re.search(r"--\s*\[[^\]]*\]\s*--*>?", t):

        return True

    if re.match(r"^(https?|memory|file|s3|ftp)://", t, re.I):

        return True

    if len(t) < 8:

        return True

    return False

def _to_sentence(text: str) -> str:

    """Make a fragment read as a standalone sentence: leading cap + terminal

    punctuation."""

    t = (text or "").strip()

    if not t:

        return t

    t = t[0].upper() + t[1:]

    if t[-1] not in ".!?":

        t += "."

    return t

def deterministic_answer(query: str, hits: list[Hit]) -> tuple[str, list[Receipt]]:

    """Deterministic (no-LLM) fallback answer.

    Parses each top hit's snippet (handling Darwin's pipe-delimited

    "key: value | key: value" metadata format), extracts the single most

    descriptive value per hit, drops graph-relation / id-only noise, then

    composes a short answer that LEADS with the most descriptive fact and

    folds in 0-2 more distinct facts - each tagged with an inline [rN] marker

    that maps back to its receipt. Never emits raw pipe-junk, graph arrows,

    or URLs in the prose."""

    receipts = _make_receipts(hits)

    if not hits:

        answer = f"I couldn't find anything in the indexed sources for \"{query}\"."

        return answer, []

    facts: list[tuple[int, str, int]] = []

    seen: set[str] = set()

    for i, h in enumerate(hits[:3]):

        text, rank = _extract_descriptive(h.snippet or "", h.title or "")

        if _is_noise(text):

            continue

        text = _strip_prose_junk(text)

        if _is_noise(text):

            continue

        key = text[:60].lower()

        if key in seen:

            continue

        seen.add(key)

        facts.append((i, text, rank))

    if not facts:

        first = _clean_snippet(hits[0].title or hits[0].path or "the top reference", limit=80)

        answer = (

            f'I have indexed references to "{query}" but no source with a clear '

            f'description - the top reference is {first}. [r1]'

        )

        return answer, receipts

    facts.sort(key=lambda f: (f[2], -len(f[1])))

    best = facts[0]

    rest = facts[1:3]

    parts = [f"{_to_sentence(best[1])} [r{best[0] + 1}]"]

    for idx, text, _rank in rest:

        parts.append(f"{_to_sentence(text)} [r{idx + 1}]")

    answer = " ".join(parts)

    return answer, receipts

async def _try_qwen(query: str, context: str, prefer_state: bool = False) -> Optional[str]:

    """Try qwen3:8b. Returns None if unavailable."""

    if prefer_state:

        prompt = (

            f"You are Darwin, a second-brain assistant. The context below is the "

            f"REAL, LIVE state of the system - the highest authority (live infra "

            f"outranks any document).\n\n"

            f"HOW TO READ THE LIVE STATE:\n"

            f"- It is split into SEPARATE sections that describe DIFFERENT things: "

            f"engine/node health (up/down), data-source staleness, ingestion-source "

            f"staleness, active agents, and tmux sessions. Do NOT conflate them. "

            f"\"no data-source stale\" is NOT the same as \"no ingestion source stale\"; "

            f"\"all nodes up\" is NOT the same as \"no stale data\". Each section is "

            f"independent.\n"

            f"- Scan the ENTIRE block, every section, before answering. The answer to "

            f"\"what's stale\" or \"what's down\" may live in a later section - never stop "

            f"at the first line that mentions staleness or health.\n\n"

            f"ANSWER RULES:\n"

            f"1. Lead with the direct answer in your first sentence.\n"

            f"2. NAME the specific offending items with their real numbers - e.g. which "

            f"exact ingestion source is stale and how many hours (\"ct243-media (~135h "

            f"stale)\"), which exact nodes are down, how many of N. Never generalize as "

            f"\"nothing is stale\" or \"all up\" while ANY line in the block flags an item "

            f"STALE or down - enumerate those items by name. \"nothing\" is only valid if "

            f"zero sections report any STALE/down item.\n"

            f"3. Stay concise: 1-4 sentences, plain prose.\n"

            f"4. Do NOT add [rN] receipt markers - this is live infra, not receipts.\n"

            f"5. If the question asks about a category the block genuinely says nothing "

            f"about, say so in one sentence.\n\n"

            f"Live state:\n{context}\n\nQuestion: {query}\n\nAnswer:"

        )

    else:

        prompt = (

            f"You are Darwin, a personal second-brain assistant. A colleague asked "

            f"you a question and you are translating the answer for them - explain it "

            f"clearly, like a knowledgeable colleague, NOT like a search results page.\n\n"

            f"RULES:\n"

            f"1. ANSWER the question directly. Lead with the answer in your very first "

            f"sentence - no preamble, no \"based on the sources\", no \"here is\".\n"

            f"2. SYNTHESIZE across ALL the context entries collectively to form one "

            f"coherent explanation. Do NOT quote or recite a single source verbatim. "

            f"Do NOT output a numbered list of results. Do NOT say which source is "

            f"\"most relevant\" or \"most recent\".\n"

            f"3. Stay grounded: every factual claim must come from the context - never "

            f"invent. Right after the clause a piece of context supports, drop an inline "

            f"marker like [r1], [r2], ... (context entries are numbered [1], [2], ... so "

            f"map [1]->[r1], [2]->[r2], etc.).\n"

            f"4. Be concise: 2-5 sentences, flowing prose. No meta commentary.\n"

            f"5. If a [LIVE STATE] block is present it is the HIGHEST authority and "

            f"overrides any document - prefer it on conflicts.\n"

            f"6. If the context genuinely does not answer the question, say so briefly "

            f"in one sentence.\n\n"

            f"Context:\n{context}\n\nQuestion: {query}\n\nAnswer:"

        )

    payload = {

        "model": QWEN_MODEL,

        "messages": [{"role": "user", "content": prompt}],

        "stream": False,

        "keep_alive": QWEN_KEEP_ALIVE,

        "options": {"think": False},

    }

    try:

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

            resp = await client.post(QWEN_URL, json=payload)

            resp.raise_for_status()

            data = resp.json()

            content = (data.get("message") or {}).get("content", "")

            content = content.strip()

            return content or None

    except Exception:

        return None

async def warmup() -> bool:

    """Fire a tiny ping so the model loads onto the GPU at service start and

    stays resident (keep_alive). Best-effort; never raises."""

    payload = {

        "model": QWEN_MODEL,

        "messages": [{"role": "user", "content": "ok"}],

        "stream": False,

        "keep_alive": QWEN_KEEP_ALIVE,

        "options": {"think": False, "num_predict": 1},

    }

    try:

        async with httpx.AsyncClient(timeout=max(QWEN_TIMEOUT, 60.0)) as client:

            resp = await client.post(QWEN_URL, json=payload)

            resp.raise_for_status()

            return True

    except Exception:

        return False

async def synthesize(

    query: str,

    hits: list[Hit],

    synthesize_flag: bool = True,

    live_state: Optional[str] = None,

    state_first: bool = False,

) -> tuple[Optional[str], list[Receipt]]:

    """Return (answer_str_or_None, receipts).

    Falls back to deterministic if LLM unavailable or synthesize=False.

    live_state: an optional compact LIVE-STATE block. Per Darwin's source-of-truth

        hierarchy live infra is the HIGHEST authority, so when present it is fed to

        the synthesizer as the top-authority context (above RAG hits).

    state_first: when True the query is a status/state question - the live snapshot

        leads the answer, and a cold LLM falls back to a snapshot-driven answer.

    """

    receipts = _make_receipts(hits)

    if state_first and live_state:

        from state import get_snapshot, deterministic_state_answer

        snap = await get_snapshot()

        if synthesize_flag:

            llm_answer = await _try_qwen(query, live_state, prefer_state=True)

            if llm_answer:

                return llm_answer, receipts

        return deterministic_state_answer(query, snap), receipts

    if not synthesize_flag or not hits:

        if hits:

            answer, receipts = deterministic_answer(query, hits)

            return answer, receipts

        return None, []

    context_parts = []

    if live_state:

        context_parts.append(f"[LIVE STATE - highest authority]\n{live_state}")

    for i, h in enumerate(hits[:8]):

        context_parts.append(

            f"[{i+1}] Source: {h.engine} ({h.authority_tier}), "

            f"path: {h.path}, score: {h.score:.3f}\n{h.snippet}"

        )

    context = "\n\n".join(context_parts)

    llm_answer = await _try_qwen(query, context)

    if llm_answer:

        return llm_answer, receipts

    answer, receipts = deterministic_answer(query, hits)

    return answer, receipts