"""
Embedding Katmanı
----------------------
İki backend destekler (EMBEDDING_BACKEND ortam değişkeni: "real" | "mock"):

  - "real": magibu/embeddingmagibu-200m'i sentence-transformers ile yükler,
            768 boyutlu gerçek Türkçe embedding üretir. GPU önerilir ama
            CPU'da da (yavaş) çalışır.
  - "mock": Bu sandbox'ta Hugging Face model indirme erişimi olmadığı için,
            TF-IDF tabanlı DETERMİNİSTİK bir "sahte" embedder kullanılır.
            Gerçek bir semantik embedding modeli DEĞİLDİR, ancak aynı kelime
            kökenli sorular ile ilgili chunk'lar arasında anlamlı bir cosine
            similarity sıralaması üretir — bu da threshold/pozitif-negatif
            ayrıştırma mantığını (asıl test edilmek istenen şey) uçtan uca,
            GPU/internet olmadan doğrulamamıza yetiyor.

İki backend de aynı arayüzü uygular: embed(texts: list[str]) -> np.ndarray (N, D)
Bu sayede vector_store.py ve search.py hangi backend kullanıldığından bağımsız çalışır.
"""
import os
import sys
import numpy as np

sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
from src import config


class RealEmbedder:
    """magibu/embeddingmagibu-200m ile gerçek 768 boyutlu embedding üretir."""

    def __init__(self, model_id: str = None):
        from sentence_transformers import SentenceTransformer
        self.model_id = model_id or config.EMBEDDING_MODEL_ID
        self.model = SentenceTransformer(self.model_id, trust_remote_code=True)
        self.dim = self.model.get_sentence_embedding_dimension()

    def embed(self, texts: list) -> np.ndarray:
        return np.asarray(self.model.encode(texts, normalize_embeddings=True))


class MockEmbedder:
    """
    TF-IDF tabanlı, deterministik mock embedder. fit(corpus) çağrıldıktan sonra
    embed() aynı kelime dağarcığı (vocabulary) uzayına projekte eder.

    NOT: Boyut, gerçek modelin 768'i ile AYNI DEĞİLDİR (vocabulary büyüklüğüne
    bağlıdır) — bu sadece offline pipeline testi içindir, deliverable'daki
    768 boyut şartı yalnızca gerçek magibu/embeddingmagibu-200m backend'i için
    geçerlidir. Küçük korpuslarda (bu sandbox'taki gibi) SVD ile boyut indirgeme
    konu ayrımını bozduğu için kasıtlı olarak KULLANILMAZ; ham TF-IDF vektörleri
    zaten kelime örtüşmesine dayalı, yorumlanabilir bir benzerlik sağlar.
    """

    def __init__(self, dim: int = None):
        from sklearn.feature_extraction.text import TfidfVectorizer
        self.dim = dim or config.EMBEDDING_DIM
        self.vectorizer = TfidfVectorizer(
            analyzer="word",
            ngram_range=(1, 2),
            min_df=1,
            sublinear_tf=True,
        )
        self._fitted = False

    def fit(self, corpus: list):
        self.vectorizer.fit(corpus)
        self._fitted = True

    def embed(self, texts: list) -> np.ndarray:
        if not self._fitted:
            # fit edilmemişse (ör. tek bir sorgu embed ediliyorsa) verilen metinlerle fit et
            self.fit(texts)
        tfidf_matrix = self.vectorizer.transform(texts)
        vectors = tfidf_matrix.toarray()
        # normalize et (cosine similarity için)
        norms = np.linalg.norm(vectors, axis=1, keepdims=True)
        norms[norms == 0] = 1.0
        return vectors / norms

    def save(self, path: str = None):
        """Fit edilmiş vectorizer durumunu diske kaydeder (build_index.py çağırır).
        Böylece search.py AYNI süreçte olmasa bile (ör. ayrı bir script/Gradio app)
        chunk'ların embed edildiği vektör uzayını yeniden kullanabilir."""
        import pickle
        path = path or config.MOCK_EMBEDDER_STATE_PATH
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path, "wb") as f:
            pickle.dump({"vectorizer": self.vectorizer, "dim": self.dim}, f)

    @classmethod
    def load(cls, path: str = None):
        import pickle
        path = path or config.MOCK_EMBEDDER_STATE_PATH
        with open(path, "rb") as f:
            state = pickle.load(f)
        obj = cls(dim=state["dim"])
        obj.vectorizer = state["vectorizer"]
        obj._fitted = True
        return obj


_embedder_singleton = {}


def get_embedder(fit_corpus: list = None):
    """
    Konfigürasyona göre embedder döner. Mock backend için, chunk metinleri
    külliyatıyla (fit_corpus) bir kez fit edilir ve tekrar kullanılır — bu sayede
    hem chunk'lar hem de daha sonra gelen sorgular AYNI vektör uzayında kalır.
    """
    key = config.EMBEDDING_BACKEND
    if key in _embedder_singleton:
        return _embedder_singleton[key]

    if config.EMBEDDING_BACKEND == "real":
        try:
            embedder = RealEmbedder()
        except Exception as e:
            print(f"[UYARI] Gerçek embedding modeli yüklenemedi ({e}), mock embedder'a düşülüyor.")
            embedder = _get_or_fit_mock_embedder(fit_corpus)
    else:
        embedder = _get_or_fit_mock_embedder(fit_corpus)

    _embedder_singleton[key] = embedder
    return embedder


def _get_or_fit_mock_embedder(fit_corpus):
    """Diskte kayıtlı bir mock embedder state'i varsa onu yükler (arama/search.py
    çağrıları için), yoksa (index build sırasında) verilen korpusla fit eder."""
    if os.path.exists(config.MOCK_EMBEDDER_STATE_PATH):
        try:
            return MockEmbedder.load()
        except Exception as e:
            print(f"[UYARI] Kayıtlı mock embedder yüklenemedi ({e}), yeniden fit ediliyor.")
    embedder = MockEmbedder()
    if fit_corpus:
        embedder.fit(fit_corpus)
    return embedder


if __name__ == "__main__":
    from data.synthetic_corpus import SYNTHETIC_ARTICLES
    corpus = [a["text"] for a in SYNTHETIC_ARTICLES]
    embedder = get_embedder(fit_corpus=corpus)
    vecs = embedder.embed(corpus[:2])
    print("Embedding shape:", vecs.shape)
    print("Norm (1.0 olmalı):", np.linalg.norm(vecs[0]))