#!/usr/bin/env python3
"""embed_models.py — pluggable embedding-model factory for copernicus-rag.

The corpus vectors and the query vectors MUST come from the same model:
querying a gemini-768 corpus with a different embedder returns garbage.
rag_server guards this by comparing the embedder dim to the collection's
dense size and degrading to BM25-only on mismatch — but a real swap means
re-embedding the corpus first (see RAG/REBUILD.md §A).

Select the model with the EMBED_MODEL env var:

    gemini                          default; gemini-embedding-2-preview, 768d
                                    (API key via search.resolve_key)
    fastembed:<model_name>          local ONNX via fastembed (no torch), e.g.
                                    fastembed:BAAI/bge-small-en-v1.5   (384d)
                                    fastembed:BAAI/bge-base-en-v1.5   (768d)
                                    fastembed:intfloat/multilingual-e5-large (1024d)
    st:<model_name>                 sentence-transformers (optional dep), e.g.
                                    st:intfloat/e5-base-v2

Every embedder L2-normalizes its output (cosine parity with the indexes).
"""
from __future__ import annotations

import os
import threading
from abc import ABC, abstractmethod
from functools import lru_cache

import numpy as np


def _l2(v: np.ndarray) -> list[float]:
    n = float(np.linalg.norm(v))
    return (v / n).tolist() if n > 0 else v.tolist()


class EmbeddingModel(ABC):
    """One embedding model: identity (name/dim) + query/doc encoders."""

    name: str
    dim: int

    @abstractmethod
    def embed_query(self, text: str) -> list[float]: ...

    @abstractmethod
    def embed_docs(self, texts: list[str]) -> list[list[float]]: ...


class GeminiEmbedding(EmbeddingModel):
    """gemini-embedding-2-preview via google-genai (the corpus default)."""

    MODEL = "gemini-embedding-2-preview"

    def __init__(self, dim: int = 768):
        self.name = f"gemini:{self.MODEL}"
        self.dim = dim
        self._client = None
        self._lock = threading.Lock()

    def _cli(self):
        if self._client is None:
            with self._lock:
                if self._client is None:
                    from google import genai
                    import search as S  # key resolution lives with the server
                    self._client = genai.Client(api_key=S.resolve_key())
        return self._client

    def _embed(self, texts: list[str], task: str) -> list[list[float]]:
        from google.genai import types
        cfg = types.EmbedContentConfig(task_type=task,
                                       output_dimensionality=self.dim)
        out = []
        for t in texts:  # batch contents returns ONE vector — embed per item
            r = self._cli().models.embed_content(model=self.MODEL, contents=t,
                                                 config=cfg)
            out.append(_l2(np.array(list(r.embeddings[0].values),
                                    dtype=np.float32)))
        return out

    def embed_query(self, text: str) -> list[float]:
        return self._embed([text], "RETRIEVAL_QUERY")[0]

    def embed_docs(self, texts: list[str]) -> list[list[float]]:
        return self._embed(texts, "RETRIEVAL_DOCUMENT")


class FastEmbedModel(EmbeddingModel):
    """Local ONNX embedder via fastembed (already a dependency; no torch)."""

    def __init__(self, model_name: str):
        from fastembed import TextEmbedding
        self._m = TextEmbedding(model_name)
        self.name = f"fastembed:{model_name}"
        self.dim = len(next(iter(self._m.embed(["probe"]))))

    def embed_query(self, text: str) -> list[float]:
        fn = getattr(self._m, "query_embed", self._m.embed)
        return _l2(np.asarray(next(iter(fn([text]))), dtype=np.float32))

    def embed_docs(self, texts: list[str]) -> list[list[float]]:
        fn = getattr(self._m, "passage_embed", self._m.embed)
        return [_l2(np.asarray(v, dtype=np.float32)) for v in fn(texts)]


class SentenceTransformersModel(EmbeddingModel):
    """sentence-transformers embedder (optional dependency, torch-based)."""

    def __init__(self, model_name: str):
        from sentence_transformers import SentenceTransformer
        self._m = SentenceTransformer(model_name)
        self.name = f"st:{model_name}"
        self.dim = int(self._m.get_sentence_embedding_dimension())
        # e5-family expects "query: "/"passage: " prefixes
        self._e5 = "e5" in model_name.lower()

    def embed_query(self, text: str) -> list[float]:
        t = f"query: {text}" if self._e5 else text
        return self._m.encode(t, normalize_embeddings=True).tolist()

    def embed_docs(self, texts: list[str]) -> list[list[float]]:
        ts = [f"passage: {t}" for t in texts] if self._e5 else texts
        return self._m.encode(ts, normalize_embeddings=True).tolist()


@lru_cache(maxsize=None)
def get_embedder(spec: str | None = None) -> EmbeddingModel:
    """Factory: resolve an EmbeddingModel from a spec string or EMBED_MODEL env."""
    spec = (spec or os.environ.get("EMBED_MODEL") or "gemini").strip()
    if spec == "gemini" or spec.startswith("gemini:"):
        return GeminiEmbedding()
    if spec.startswith("fastembed:"):
        return FastEmbedModel(spec.split(":", 1)[1])
    if spec.startswith("st:"):
        return SentenceTransformersModel(spec.split(":", 1)[1])
    raise ValueError(
        f"unknown EMBED_MODEL spec {spec!r} — use 'gemini', "
        "'fastembed:<model>' or 'st:<model>'")