"""Minimal pluggable vector store for the SCUT-SS RAG dataset.

Backends
  tfidf  : char n-gram TF-IDF (offline, no model download, good baseline for Chinese)
  sbert  : sentence-transformers dense embeddings (needs `pip install sentence-transformers`)
  openai : any OpenAI-compatible /embeddings endpoint (set EMBEDDING_* env vars)

Layout of <out_dir>:
  meta.json      backend / model / count
  chunks.jsonl   the indexed chunks (aligned with matrix rows)
  <backend files>
"""

import json
import os
import sys
from pathlib import Path

for _s in (sys.stdout, sys.stderr):
    try:
        _s.reconfigure(encoding="utf-8", errors="replace")
    except Exception:  # noqa: BLE001
        pass


def load_chunks(path):
    return [json.loads(l) for l in open(path, encoding="utf-8") if l.strip()]


class Backend:
    name = "base"

    def build(self, texts, out_dir):  # pragma: no cover - interface
        raise NotImplementedError

    def load(self, out_dir):  # pragma: no cover - interface
        raise NotImplementedError

    def encode_query(self, query):  # pragma: no cover - interface
        raise NotImplementedError

    def top_k(self, qvec, k):  # pragma: no cover - interface
        raise NotImplementedError


def _char_ngrams(text, sizes=(1, 2)):
    """Character n-grams with boundary padding — works for Chinese without a tokenizer."""
    s = " " + " ".join(text.split()) + " "
    out = []
    for n in sizes:
        for i in range(len(s) - n + 1):
            out.append(s[i : i + n])
    return out


class TfidfBackend(Backend):
    """Self-contained char n-gram TF-IDF (numpy + scipy only, no sklearn/pandas)."""

    name = "tfidf"

    def build(self, texts, out_dir):
        import numpy as np
        import scipy.sparse as sp
        from collections import Counter

        n_docs = len(texts)
        dfs = Counter()
        tfs = []
        for t in texts:
            c = Counter(_char_ngrams(t))
            tfs.append(c)
            dfs.update(c.keys())
        kept = sorted(g for g, df in dfs.items() if df >= 2)
        vocab = {g: i for i, g in enumerate(kept)}
        indptr, indices, data = [0], [], []
        for c in tfs:
            for g, cnt in c.items():
                j = vocab.get(g)
                if j is None:
                    continue
                indices.append(j)
                data.append(1.0 + np.log(cnt))
            indptr.append(len(indices))
        matrix = sp.csr_matrix((np.asarray(data), np.asarray(indices), np.asarray(indptr)), shape=(n_docs, len(vocab)))
        idf = np.log((1 + n_docs) / (1 + np.array([dfs[g] for g in vocab], dtype=float))) + 1.0
        matrix = sp.csr_matrix(matrix.multiply(idf))
        norms = np.sqrt(np.asarray(matrix.multiply(matrix).sum(axis=1)).ravel()) + 1e-12
        matrix = sp.diags(1.0 / norms) @ matrix
        matrix = sp.csr_matrix(matrix)
        sp.save_npz(str(out_dir / "tfidf.npz"), matrix)
        (out_dir / "tfidf_vocab.json").write_text(json.dumps(vocab, ensure_ascii=False), encoding="utf-8")
        return {"dim": int(matrix.shape[1]), "nnz": int(matrix.nnz)}

    def load(self, out_dir):
        import scipy.sparse as sp

        self.matrix = sp.load_npz(str(out_dir / "tfidf.npz"))
        self.vocab = json.loads((out_dir / "tfidf_vocab.json").read_text(encoding="utf-8"))

    def encode_query(self, query):
        import numpy as np
        import scipy.sparse as sp
        from collections import Counter

        c = Counter(_char_ngrams(query))
        idx, vals, tot = [], [], 0.0
        for g, cnt in c.items():
            j = self.vocab.get(g)
            if j is None:
                continue
            v = 1.0 + np.log(cnt)
            idx.append(j)
            vals.append(v)
            tot += v * v
        if not idx:
            return sp.csr_matrix((1, self.matrix.shape[1]))
        q = sp.csr_matrix((np.asarray(vals), np.asarray(idx), np.array([0, len(idx)])), shape=(1, self.matrix.shape[1]))
        return sp.csr_matrix(q / (np.sqrt(tot) + 1e-12))

    def top_k(self, qvec, k):
        import numpy as np

        scores = (self.matrix @ qvec.T).toarray().ravel()
        idx = np.argsort(-scores)[:k]
        return [(int(i), float(scores[i])) for i in idx if scores[i] > 0]


class SbertBackend(Backend):
    name = "sbert"
    default_model = "paraphrase-multilingual-MiniLM-L12-v2"

    def __init__(self, model=None):
        self.model_name = model or os.environ.get("EMBEDDING_MODEL") or self.default_model

    def build(self, texts, out_dir):
        import numpy as np
        from sentence_transformers import SentenceTransformer

        model = SentenceTransformer(self.model_name)
        emb = model.encode(texts, batch_size=32, show_progress_bar=True, normalize_embeddings=True)
        emb = np.asarray(emb, dtype="float32")
        np.save(str(out_dir / "embeddings.npy"), emb)
        return {"dim": int(emb.shape[1]), "model": self.model_name}

    def load(self, out_dir):
        import numpy as np

        self.emb = np.load(str(out_dir / "embeddings.npy"))

    def encode_query(self, query):
        from sentence_transformers import SentenceTransformer

        model = SentenceTransformer(self.model_name)
        v = model.encode([query], normalize_embeddings=True)
        import numpy as np

        return np.asarray(v, dtype="float32")

    def top_k(self, qvec, k):
        import numpy as np

        scores = (self.emb @ qvec.T).ravel()
        idx = np.argsort(-scores)[:k]
        return [(int(i), float(scores[i])) for i in idx]


class OpenAIBackend(Backend):
    """Any OpenAI-compatible /embeddings endpoint (for students with no local model)."""

    name = "openai"

    def __init__(self, model=None, provider=None):
        import llm  # local import keeps tfidf path dependency-free

        conf = llm.resolve_embedding(provider=provider, model=model)
        self.base_url = conf["base_url"]
        self.api_key = conf["api_key"]
        self.model = conf["model"]

    def _post(self, payload):
        if not self.api_key:
            raise RuntimeError(
                "未配置 embedding 的 API Key：设置 EMBEDDING_API_KEY，或在 config/llm.json 里填写 api_key。"
            )
        import urllib.request

        req = urllib.request.Request(
            f"{self.base_url}/embeddings",
            data=json.dumps(payload).encode("utf-8"),
            headers={"Content-Type": "application/json", "Authorization": f"Bearer {self.api_key}"},
        )
        with urllib.request.urlopen(req, timeout=120) as resp:
            return json.loads(resp.read().decode("utf-8"))

    def build(self, texts, out_dir):
        import numpy as np

        vectors = []
        batch = 64
        for i in range(0, len(texts), batch):
            part = texts[i : i + batch]
            data = self._post({"model": self.model, "input": part})
            vectors.extend(d["embedding"] for d in data["data"])
        emb = np.asarray(vectors, dtype="float32")
        emb /= (np.linalg.norm(emb, axis=1, keepdims=True) + 1e-12)
        np.save(str(out_dir / "embeddings.npy"), emb)
        return {"dim": int(emb.shape[1]), "model": self.model, "base_url": self.base_url}

    def load(self, out_dir):
        import numpy as np

        self.emb = np.load(str(out_dir / "embeddings.npy"))

    def encode_query(self, query):
        import numpy as np

        data = self._post({"model": self.model, "input": [query]})
        v = np.asarray(data["data"][0]["embedding"], dtype="float32")
        return v / (np.linalg.norm(v) + 1e-12)

    def top_k(self, qvec, k):
        import numpy as np

        scores = self.emb @ qvec
        idx = np.argsort(-scores)[:k]
        return [(int(i), float(scores[i])) for i in idx]


BACKENDS = {"tfidf": TfidfBackend, "sbert": SbertBackend, "openai": OpenAIBackend}


def build_index(chunks_path, out_dir, backend="tfidf", model=None, provider=None):
    out_dir = Path(out_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    chunks = load_chunks(chunks_path)
    texts = [c["text"] for c in chunks]
    if backend == "openai":
        be = OpenAIBackend(model=model, provider=provider)
    elif backend == "sbert":
        be = SbertBackend(model)
    else:
        be = BACKENDS[backend]()
    info = be.build(texts, out_dir)
    meta = {"backend": backend, "n_chunks": len(chunks), **(info or {})}
    (out_dir / "meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
    with (out_dir / "chunks.jsonl").open("w", encoding="utf-8") as f:
        for c in chunks:
            f.write(json.dumps(c, ensure_ascii=False) + "\n")
    print(f"built {backend} index: {len(chunks)} chunks -> {out_dir}")
    return meta


class Index:
    def __init__(self, out_dir):
        self.dir = Path(out_dir)
        self.meta = json.loads((self.dir / "meta.json").read_text(encoding="utf-8"))
        self.chunks = load_chunks(self.dir / "chunks.jsonl")
        backend = self.meta["backend"]
        if backend == "openai":
            self.be = OpenAIBackend(model=self.meta.get("model"))
        elif backend == "sbert":
            self.be = SbertBackend(self.meta.get("model"))
        else:
            self.be = BACKENDS[backend]()
        self.be.load(self.dir)

    def search(self, query, k=5):
        return [(self.chunks[i], s) for i, s in self.be.top_k(self.be.encode_query(query), k)]