"""Darwin Cortex Gateway - FastAPI app.

Port :9890 (HTTP API). MCP SSE shim on :9891 via mcp_server.py + mcp-proxy.

Start:

    uvicorn main:app --host 0.0.0.0 --port 9890

"""

from __future__ import annotations

import asyncio

import sys

import os

import time

from datetime import datetime, timezone

from typing import Optional

from fastapi import FastAPI

from fastapi.middleware.cors import CORSMiddleware

sys.path.insert(0, os.path.dirname(__file__))

from models import AskRequest, AskResponse, EngineStatus, HealthResponse, Hit, Receipt

from ranking import rank_hits, detect_conflicts

from synthesis import synthesize, warmup as synth_warmup

import state as live_state

from adapters.rag import RagAdapter

from adapters.cbm import CbmAdapter

from adapters.serena import SerenaAdapter

from adapters.memgraph import MemgraphAdapter

from adapters.inbox import InboxAdapter

from adapters.sources import source_statuses

app = FastAPI(title="Darwin Cortex", version="1.0.0")

app.add_middleware(

    CORSMiddleware,

    allow_origins=["*"],

    allow_methods=["*"],

    allow_headers=["*"],

)

ALL_ADAPTERS = {

    "rag": RagAdapter(),

    "cbm": CbmAdapter(),

    "serena": SerenaAdapter(),

    "memgraph": MemgraphAdapter(),

    "inbox": InboxAdapter(),

}

@app.on_event("startup")

async def _startup() -> None:

    """Best-effort: warm the LLM synthesizer onto the GPU so the first real

    /ask hits a resident model instead of a cold load."""

    asyncio.create_task(synth_warmup())

@app.get("/health", response_model=HealthResponse)

async def health() -> HealthResponse:

    """Whole-organism liveness: the 5 query engines PLUS the real ingestion

    data-sources (proxmox/white-pc/3060/browser-history/agents) with live

    per-source freshness from the homelab-rag manifest. Same EngineStatus

    schema for every entry; data-source entries are additive and never replace

    the engine entries, so the response stays backward-compatible."""

    async def probe(key: str, adapter) -> EngineStatus:

        _, status = await adapter.query("ping", k=1)

        return status

    engine_task = asyncio.gather(*(probe(k, v) for k, v in ALL_ADAPTERS.items()))

    sources_task = source_statuses()

    engine_statuses, data_sources = await asyncio.gather(

        engine_task, sources_task, return_exceptions=True,

    )

    if isinstance(engine_statuses, Exception):

        engine_statuses = []

    if isinstance(data_sources, Exception):

        data_sources = []

    all_statuses = list(engine_statuses) + list(data_sources)

    ok = any(s.status == "up" for s in all_statuses)

    return HealthResponse(engines=all_statuses, ok=ok)

@app.post("/ask", response_model=AskResponse)

async def ask(req: AskRequest) -> AskResponse:

    """Fan out to all engines, reconcile, synthesize."""

    t0 = time.monotonic()

    scope = req.scope or list(ALL_ADAPTERS.keys())

    adapters = {k: v for k, v in ALL_ADAPTERS.items() if k in scope}

    state_first = live_state.is_state_query(req.query)

    snapshot_task = asyncio.create_task(live_state.get_snapshot())

    async def run_adapter(key: str, adapter):

        return await adapter.query(req.query, k=req.k)

    tasks = {k: asyncio.create_task(run_adapter(k, v)) for k, v in adapters.items()}

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

    try:

        snapshot = await snapshot_task

        state_block = live_state.render_block(snapshot)

    except Exception:

        snapshot, state_block = None, None

    all_hits: list[Hit] = []

    engine_statuses: list[EngineStatus] = []

    for (key, _), result in zip(tasks.items(), results):

        if isinstance(result, Exception):

            engine_statuses.append(EngineStatus(engine=key, status="down"))

            continue

        hits, status = result

        all_hits.extend(hits)

        engine_statuses.append(status)

    ranked = rank_hits(all_hits, k=req.k * len(adapters))

    conflicts = detect_conflicts(ranked)

    answer: Optional[str] = None

    receipts = []

    if req.mode in ("chat", "both"):

        answer, receipts = await synthesize(

            req.query,

            ranked[:req.k],

            req.synthesize,

            live_state=state_block,

            state_first=state_first and state_block is not None,

        )

        if state_first and state_block:

            receipts = [Receipt(

                id="r0",

                source="live-state",

                path="cortex:/health + deck + darwin-term",

                last_seen=datetime.now(timezone.utc),

                confidence=1.0,

                snippet=state_block[:200],

            )] + list(receipts)

    took_ms = int((time.monotonic() - t0) * 1000)

    return AskResponse(

        answer=answer,

        receipts=receipts,

        hits=ranked[:req.k],

        conflicts=conflicts,

        engines=engine_statuses,

        took_ms=took_ms,

    )

@app.get("/")

async def root():

    return {"service": "darwin-cortex", "version": "1.0.0", "docs": "/docs"}