"""Embedding helpers for semantic skill matching.

Uses OpenAI embeddings when OPENAI_API_KEY is set; otherwise a deterministic
local hashed n-gram embedding (no extra dependencies).
"""

from __future__ import annotations

import hashlib
import logging
import math
import re
from typing import Sequence

import httpx

from app.config import get_settings

logger = logging.getLogger(__name__)

LOCAL_DIM = 256


def _tokenize(text: str) -> list[str]:
    return re.findall(r"[a-z0-9+]{2,}", (text or "").lower())


def local_embed(text: str, *, dim: int = LOCAL_DIM) -> list[float]:
    """Deterministic bag-of-hashed-ngrams embedding."""
    vec = [0.0] * dim
    tokens = _tokenize(text)
    if not tokens:
        return vec
    grams = list(tokens)
    # add bigrams
    grams += [f"{tokens[i]}_{tokens[i+1]}" for i in range(len(tokens) - 1)]
    for g in grams:
        h = int(hashlib.sha256(g.encode("utf-8")).hexdigest()[:8], 16)
        idx = h % dim
        sign = 1.0 if (h & 1) == 0 else -1.0
        vec[idx] += sign
    # L2 normalize
    norm = math.sqrt(sum(v * v for v in vec)) or 1.0
    return [v / norm for v in vec]


def cosine(a: Sequence[float], b: Sequence[float]) -> float:
    if not a or not b or len(a) != len(b):
        return 0.0
    dot = sum(x * y for x, y in zip(a, b))
    na = math.sqrt(sum(x * x for x in a)) or 1.0
    nb = math.sqrt(sum(y * y for y in b)) or 1.0
    return max(-1.0, min(1.0, dot / (na * nb)))


async def openai_embed(texts: list[str], *, model: str | None = None) -> list[list[float]]:
    settings = get_settings()
    key = (settings.openai_api_key or "").strip()
    if not key:
        raise RuntimeError("OPENAI_API_KEY not configured")
    model = model or getattr(settings, "openai_embedding_model", None) or "text-embedding-3-small"
    async with httpx.AsyncClient(timeout=60.0) as client:
        res = await client.post(
            "https://api.openai.com/v1/embeddings",
            headers={"Authorization": f"Bearer {key}"},
            json={"model": model, "input": texts},
        )
        if res.status_code >= 400:
            raise RuntimeError(f"OpenAI embeddings HTTP {res.status_code}: {res.text[:300]}")
        data = res.json()["data"]
        data = sorted(data, key=lambda d: d["index"])
        return [row["embedding"] for row in data]


async def embed_texts(texts: list[str]) -> tuple[list[list[float]], str, bool]:
    """Return (vectors, provider, stub)."""
    cleaned = [t if (t or "").strip() else " " for t in texts]
    settings = get_settings()
    key = (getattr(settings, "openai_api_key", None) or "").strip()
    if key:
        try:
            vectors = await openai_embed(cleaned)
            return vectors, "openai", False
        except Exception as exc:  # noqa: BLE001
            logger.warning("OpenAI embeddings failed; using local: %s", exc)
    return [local_embed(t) for t in cleaned], "local_hash", True
