#!/usr/bin/env python3
"""
Query interface for the Mixedbread CVE RAG index with reranking using Chroma DB.
"""

from __future__ import annotations

import argparse
import json
from typing import List, Sequence

import numpy as np
import chromadb
from chromadb.config import Settings as ChromaSettings
from chromadb import errors as chroma_errors
from sentence_transformers import SentenceTransformer, CrossEncoder

from .config import Settings, load_settings


class QueryEngine:
    def __init__(self, settings: Settings, normalize: bool):
        self.settings = settings
        self.normalize = normalize
        chroma_settings = ChromaSettings(
            is_persistent=True,
            persist_directory=str(settings.chroma_dir),
        )
        self.client = chromadb.Client(chroma_settings)
        try:
            self.collection = self.client.get_collection(settings.chroma_collection)
        except chroma_errors.NotFoundError as exc:
            raise FileNotFoundError(
                f"Chroma collection '{settings.chroma_collection}' not found in {settings.chroma_dir}. "
                "Run build_index.py first."
            ) from exc
        
        # Load embedding model locally
        print(f"Loading embedding model: {settings.embed_model}")
        embed_kwargs = {
            "device": settings.device,
        }
        if settings.hf_token:
            embed_kwargs["use_auth_token"] = settings.hf_token
        self.embed_model = SentenceTransformer(
            settings.embed_model,
            **embed_kwargs,
        )
        print(f"Loading reranker model: {settings.rerank_model}")
        rerank_kwargs = {
            "device": settings.device,
        }
        if settings.hf_token:
            rerank_kwargs["token"] = settings.hf_token
        self.rerank_model = CrossEncoder(
            settings.rerank_model,
            **rerank_kwargs,
        )
        print(f"Models loaded on {settings.device}")

    def _embed(self, texts: Sequence[str]) -> np.ndarray:
        """Embed texts using the local model."""
        embeddings = self.embed_model.encode(
            list(texts),
            batch_size=len(texts),
            show_progress_bar=False,
            normalize_embeddings=self.normalize,
            convert_to_numpy=True,
        )
        return embeddings

    def _rerank(self, query: str, candidates: List[dict], top_n: int) -> List[dict]:
        """Rerank candidates using the local CrossEncoder model."""
        pairs = [[query, c["text"]] for c in candidates]
        scores = self.rerank_model.predict(pairs)
        scored = []
        for candidate, score in zip(candidates, scores):
            scored.append({**candidate, "rerank_score": float(score)})
        scored.sort(key=lambda x: x.get("rerank_score", 0), reverse=True)
        return scored[:top_n]

    def query(self, query_text: str, top_k: int, top_n: int) -> List[dict]:
        query_vec = self._embed([query_text])
        results = self.collection.query(
            query_embeddings=query_vec.tolist(),
            n_results=top_k,
            include=["documents", "metadatas", "distances"],
        )

        documents = results.get("documents", [[]])[0]
        metadatas = results.get("metadatas", [[]])[0]
        distances = results.get("distances", [[]])[0]

        candidates = []
        for doc, meta, score in zip(documents, metadatas, distances):
            candidates.append(
                {
                    "score": float(score),
                    "text": doc,
                    "cve_id": meta.get("cve_id", "UNKNOWN"),
                    "chunk_id": meta.get("chunk_id", -1),
                    "metadata": {k: v for k, v in meta.items() if k not in {"cve_id", "chunk_id", "text"}},
                }
            )
        if not candidates:
            return []
        return self._rerank(query_text, candidates, top_n)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Query the Mixedbread CVE index.")
    parser.add_argument("query", help="Natural language query to search for.")
    parser.add_argument(
        "--top-k",
        type=int,
        default=20,
        help="Number of candidates to retrieve before reranking.",
    )
    parser.add_argument(
        "--top-n",
        type=int,
        default=5,
        help="Number of reranked results to display.",
    )
    parser.add_argument(
        "--normalize",
        action="store_true",
        help="Normalize query embeddings (must match build_index normalization).",
    )
    parser.add_argument(
        "--json",
        action="store_true",
        help="Emit results as JSON for downstream automation.",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    settings = load_settings()
    engine = QueryEngine(settings, normalize=args.normalize)
    results = engine.query(args.query, args.top_k, args.top_n)
    if args.json:
        print(json.dumps(results, indent=2))
        return
    for idx, result in enumerate(results, start=1):
        print(f"[{idx}] CVE {result['cve_id']} (chunk {result['chunk_id']})")
        print(f"    Rerank score: {result.get('rerank_score'):.4f}")
        meta = result["metadata"]
        if meta.get("cwe"):
            print(f"    CWE: {meta['cwe']}")
        if meta.get("published"):
            print(f"    Published: {meta['published']}")
        print("    Text preview:")
        preview = result["text"].strip().replace("\n", " ")
        print(f"        {preview[:400]}{'...' if len(preview) > 400 else ''}")
        print()


if __name__ == "__main__":
    main()