"""
pusula_dense.py — Embedding modelleri icin retriever + calistirma/kaydetme yardimcilari.

Prompt'lar ACIKCA cozumlenir (spec > modelin kendi prompt'lari > bos) ve her zaman encode(prompt=...) ile verilir;
sentence-transformers'in varsayilana sessizce donmesine izin verilmez. Benzerlik numpy ile hesaplanir.
"""
import gc
import hashlib
import json
import os
import time
from dataclasses import asdict, dataclass

import numpy as np

QUERY_PROMPT_KEYS = ["query"]
DOC_PROMPT_KEYS = ["document", "passage", "corpus"]   # sentence-transformers ile ayni sira


@dataclass
class ModelSpec:
    model_id: str
    short: str
    params_m: int
    tier: str = "small"                 # "small" (T4) | "large" (>=30 GB GPU)
    query_prompt: str | None = None     # None → modelin kendi prompt'u, o da yoksa ""
    doc_prompt: str | None = None
    trust_remote_code: bool = False
    max_seq_length: int = 512
    batch_size: int | None = None       # None → parametre sayisina gore
    revision: str | None = None         # model reposunun commit hash'i; dis katkilarda ZORUNLU tutulur


def resolve_prompts(spec, model_prompts):
    mp = model_prompts or {}
    q = spec.query_prompt if spec.query_prompt is not None else next((mp[k] for k in QUERY_PROMPT_KEYS if k in mp), "")
    d = spec.doc_prompt if spec.doc_prompt is not None else next((mp[k] for k in DOC_PROMPT_KEYS if k in mp), "")
    return q or "", d or ""


def auto_batch_size(spec):
    if spec.batch_size:
        return spec.batch_size
    return 128 if spec.params_m <= 150 else 64 if spec.params_m <= 600 else 16 if spec.params_m <= 4500 else 8


def select_dtype(torch, device="cuda"):
    """bf16 yalnizca DONANIMDA destekleniyorsa (compute capability >= 8.0: A100, L4, H100).
    T4 (7.5) icin is_bf16_supported() True donebilir ama bf16 emule edilir ve cok yavastir → fp16."""
    if device != "cuda" or not torch.cuda.is_available():
        return torch.float32
    major, _ = torch.cuda.get_device_capability(0)
    return torch.bfloat16 if major >= 8 else torch.float16


def load_sentence_transformer(spec, device="cuda"):
    """Gercek model yukleme (Colab). transformers surumune gore dogru dtype argumani secilir."""
    import torch
    import transformers
    from sentence_transformers import SentenceTransformer

    dtype = select_dtype(torch, device)
    dtype_key = "dtype" if int(transformers.__version__.split(".")[0]) >= 5 else "torch_dtype"
    extra = {"revision": spec.revision} if spec.revision else {}
    model = SentenceTransformer(spec.model_id, device=device, trust_remote_code=spec.trust_remote_code,
                                model_kwargs={dtype_key: dtype}, **extra)
    model.max_seq_length = min(spec.max_seq_length, model.max_seq_length or spec.max_seq_length)
    return model, str(dtype).replace("torch.", "")


class DenseRetriever:
    def __init__(self, spec, model, dtype_name="?"):
        self.spec, self.model, self.dtype_name = spec, model, dtype_name
        self.name = spec.short
        self.query_prompt, self.doc_prompt = resolve_prompts(spec, getattr(model, "prompts", {}))
        self.batch_size = auto_batch_size(spec)

    def _encode(self, texts, prompt):
        """Bellek yetmezse batch'i yariya indirip AYNI metinleri yeniden dener (8B'yi yarida kaybetmemek icin)."""
        while True:
            try:
                emb = self.model.encode(list(texts), prompt=prompt, batch_size=self.batch_size,
                                        normalize_embeddings=True, convert_to_numpy=True, show_progress_bar=False)
                return np.asarray(emb, dtype=np.float32)
            except Exception as e:
                if not is_oom_error(e) or self.batch_size <= 1:
                    raise
                self.batch_size = max(1, self.batch_size // 2)
                print(f"    ⚠️ GPU belleği yetmedi → batch {self.batch_size} ile yeniden deneniyor")
                free_gpu()

    def index(self, corpus):
        self.doc_ids = list(corpus)
        self.D = self._encode([corpus[d] for d in self.doc_ids], self.doc_prompt)
        return self

    def search(self, queries, k=100, chunk=512):
        qids = list(queries)
        Q = self._encode([queries[q] for q in qids], self.query_prompt)
        run, kk = {}, min(k, len(self.doc_ids))
        for s in range(0, len(qids), chunk):
            S = Q[s:s + chunk] @ self.D.T
            top = np.argpartition(-S, kk - 1, axis=1)[:, :kk]
            for i, q in enumerate(qids[s:s + chunk]):
                run[q] = {self.doc_ids[j]: float(S[i, j]) for j in top[i]}
        return run


def free_gpu(*objs):
    """Temizlik ASLA yeni hata uretmemeli: bozuk CUDA baglaminda empty_cache de patlar."""
    for o in objs:
        del o
    gc.collect()
    try:
        import torch
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
    except Exception:
        pass


FATAL_CUDA_MARKERS = ("device-side assert", "cudaErrorAssert", "illegal memory access", "unspecified launch failure")


def is_oom_error(exc):
    return "OutOfMemory" in type(exc).__name__ or "out of memory" in str(exc).lower()


def is_fatal_cuda_error(exc):
    """GPU baglamini kalici bozan hatalar: ayni Python surecinde baska CUDA islemi yapilamaz."""
    text = f"{type(exc).__name__}: {exc}"
    return any(m in text for m in FATAL_CUDA_MARKERS)


# ═══ Parmak izi + sonuc kaydi: farkli oturumlardan gelen sonuclar ancak ayni benchmark'taysa birlesir ═══
def benchmark_fingerprint(sets, pert_queries):
    h = hashlib.sha256()
    for name in sorted(sets):
        rs = sets[name]
        h.update(name.encode())
        for d in sorted(rs.corpus):
            h.update(f"D|{d}|{rs.corpus[d]}".encode())
        for q in sorted(rs.qrels):
            for d, s in sorted(rs.qrels[q].items()):
                h.update(f"R|{q}|{d}|{s}".encode())
        for p in sorted(pert_queries[name]):
            for q, t in sorted(pert_queries[name][p].items()):
                h.update(f"Q|{p}|{q}|{t}".encode())
    return h.hexdigest()[:16]


def save_result(path, spec, fingerprint, per_query, prompts, dtype_name, seconds, error=None):
    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
    payload = {"spec": asdict(spec), "fingerprint": fingerprint, "prompts": prompts, "dtype": dtype_name,
               "seconds": seconds, "error": error, "per_query": per_query, "saved_at": time.strftime("%Y-%m-%d %H:%M")}
    with open(path, "w", encoding="utf-8") as f:
        json.dump(payload, f, ensure_ascii=False)


def load_results(paths, fingerprint):
    ok, rejected = {}, []
    for p in paths:
        with open(p, encoding="utf-8") as f:
            r = json.load(f)
        if r.get("fingerprint") != fingerprint:
            rejected.append((os.path.basename(p), r.get("fingerprint")))
        elif r.get("error"):
            rejected.append((os.path.basename(p), "hata: " + r["error"][:80]))
        else:
            ok[r["spec"]["short"]] = r
    return ok, rejected