"""Titelgelijkenis en reekstitel, in de geest van hfydl (niet die code).

hfydl gebruikt model2vec (minishlab/potion-base-8M) en cosine ≥ temperature
(standaard 0.5) om te beslissen of een next-link nog bij dezelfde reeks hoort.
De serietitel is het gemeenschappelijke woord-voorvoegsel van de titels.

Wij doen hetzelfde principe, maar:
- embeddings op de post-titel (stabieler dan het label "Next");
- tags en part-nummers gaan er eerst af, anders faalt het voorvoegsel op '[OC]';
- zonder model2vec valt de indexer terug op een lexicale embedder, zodat tests
  en CI zonder modeldownload werken.
"""

from __future__ import annotations

import math
import os
import re
from typing import Iterable, Protocol

from .normalize import normalize_title

DEFAULT_TEMPERATURE = 0.5
MODEL_NAME = "minishlab/potion-base-8M"


class Embedder(Protocol):
    name: str

    def encode(self, texts: list[str]) -> list[list[float]]:
        ...


def cosine(a: list[float] | tuple[float, ...], b: list[float] | tuple[float, ...]) -> float:
    if not a or not b or len(a) != len(b):
        return 0.0
    dot = 0.0
    na = 0.0
    nb = 0.0
    for x, y in zip(a, b):
        dot += x * y
        na += x * x
        nb += y * y
    if na <= 0 or nb <= 0:
        return 0.0
    return dot / math.sqrt(na * nb)


def mean_vec(vectors: Iterable[list[float]]) -> list[float]:
    items = list(vectors)
    if not items:
        return []
    n = len(items)
    dim = len(items[0])
    acc = [0.0] * dim
    for v in items:
        if len(v) != dim:
            continue
        for i, x in enumerate(v):
            acc[i] += x
    return [x / n for x in acc]


class LexicalEmbedder:
    """Lichte, deterministische embedder op woord- en karakter-n-grams."""

    name = "lexical"

    def encode(self, texts: list[str]) -> list[list[float]]:
        return [self._one(t) for t in texts]

    def _one(self, text: str) -> list[float]:
        key = normalize_title(text) or (text or "").strip().lower()
        tokens = re.findall(r"[a-z0-9]+", key)
        grams: dict[str, float] = {}
        for tok in tokens:
            grams[f"w:{tok}"] = grams.get(f"w:{tok}", 0.0) + 2.0
            padded = f"#{tok}#"
            for i in range(len(padded) - 2):
                g = padded[i : i + 3]
                grams[f"c:{g}"] = grams.get(f"c:{g}", 0.0) + 1.0
        if not grams:
            return [1.0]
        # Vaste dimensie-volgorde: sorteer de sleutels en maak een compacte
        # hash-bag, zodat twee titels in één gemeenschappelijke ruimte liggen.
        dim = 256
        vec = [0.0] * dim
        for k, val in grams.items():
            idx = (hash(k) % dim + dim) % dim
            # hash() is per proces stabiel, niet per machine. Voor tests in
            # één proces is dat genoeg; voor model2vec geldt die zorg niet.
            # We gebruiken een stabiele FNV-achtige hash in plaats van hash().
            idx = _stable_hash(k) % dim
            vec[idx] += val
        return _l2(vec)


def _stable_hash(text: str) -> int:
    h = 2166136261
    for ch in text.encode("utf-8"):
        h ^= ch
        h = (h * 16777619) & 0xFFFFFFFF
    return h


def _l2(vec: list[float]) -> list[float]:
    n = math.sqrt(sum(x * x for x in vec))
    if n <= 0:
        return vec
    return [x / n for x in vec]


class Model2VecEmbedder:
    name = "model2vec"

    def __init__(self, model: object) -> None:
        self._model = model

    def encode(self, texts: list[str]) -> list[list[float]]:
        cleaned = [normalize_title(t) or t for t in texts]
        raw = self._model.encode(cleaned)  # type: ignore[attr-defined]
        out: list[list[float]] = []
        for row in raw:
            out.append(_l2([float(x) for x in row]))
        return out


def load_embedder(kind: str | None = None) -> Embedder:
    """kind: auto | lexical | model2vec. auto probeert model2vec en valt terug."""
    choice = (kind or os.environ.get("HFY_EMBEDDER") or "auto").strip().lower()
    if choice in {"lexical", "lex"}:
        return LexicalEmbedder()
    if choice in {"auto", "model2vec", "m2v"}:
        try:
            from model2vec import StaticModel

            model = StaticModel.from_pretrained(MODEL_NAME)
            return Model2VecEmbedder(model)
        except Exception:
            if choice in {"model2vec", "m2v"}:
                raise
            return LexicalEmbedder()
    return LexicalEmbedder()


def guess_title(titles: list[str]) -> str:
    """Gemeenschappelijk woord-voorvoegsel, ná het strippen van tags en part-nummers."""
    split = [normalize_title(t).split() for t in titles]
    split = [s for s in split if s]
    if not split:
        return "Untitled"
    first = split[0]
    end = 0
    for i, word in enumerate(first):
        if any(len(s) <= i or s[i] != word for s in split):
            break
        end = i + 1
    if end == 0:
        # Geen gemeenschappelijk voorvoegsel: val terug op de langste genormaliseerde titel.
        longest = max((normalize_title(t) for t in titles), key=len, default="")
        return longest.title() if longest else "Untitled"
    return " ".join(first[:end]).title()
