from __future__ import annotations
import math
from collections import defaultdict


class BM25Retriever:
    def __init__(self, k1: float = 1.5, b: float = 0.75):
        self.k1 = k1
        self.b = b
        self.doc_ids: list[str] = []
        self.doc_texts: list[str] = []
        self.doc_token_lists: list[list[str]] = []
        self.avgdl: float = 0.0
        self.df: dict[str, int] = defaultdict(int)
        self.N: int = 0

    def _tokenize(self, text: str) -> list[str]:
        return text.lower().split()

    def build_index(self, sessions: list[dict]) -> None:
        self.doc_ids = []
        self.doc_texts = []
        self.doc_token_lists = []
        self.df = defaultdict(int)

        for sess in sessions:
            session_id = sess["session_id"]
            text = self._session_to_text(sess)
            tokens = self._tokenize(text)

            self.doc_ids.append(session_id)
            self.doc_texts.append(text)
            self.doc_token_lists.append(tokens)

            seen = set()
            for token in tokens:
                if token not in seen:
                    self.df[token] += 1
                    seen.add(token)

        self.N = len(self.doc_ids)
        total_len = sum(len(tl) for tl in self.doc_token_lists)
        self.avgdl = total_len / self.N if self.N > 0 else 1.0

    def _session_to_text(self, session: dict) -> str:
        turns = session.get("turns", [])
        parts = []
        for turn in turns:
            parts.append(f"{turn['role']}: {turn['content']}")
        return "\n".join(parts)

    def _score(self, query_tokens: list[str], doc_idx: int) -> float:
        doc_tokens = self.doc_token_lists[doc_idx]
        dl = len(doc_tokens)
        tf_map: dict[str, int] = defaultdict(int)
        for t in doc_tokens:
            tf_map[t] += 1

        score = 0.0
        for qt in query_tokens:
            if qt not in self.df:
                continue
            tf = tf_map.get(qt, 0)
            if tf == 0:
                continue
            idf = math.log((self.N - self.df[qt] + 0.5) / (self.df[qt] + 0.5) + 1)
            tf_norm = (tf * (self.k1 + 1)) / (
                tf + self.k1 * (1 - self.b + self.b * dl / self.avgdl)
            )
            score += idf * tf_norm
        return score

    def search(self, query: str, top_k: int = 10) -> list[tuple[str, float]]:
        query_tokens = self._tokenize(query)
        scores = []
        for i in range(self.N):
            s = self._score(query_tokens, i)
            scores.append((self.doc_ids[i], s))
        scores.sort(key=lambda x: x[1], reverse=True)
        return scores[:top_k]

    def get_rank(self, query: str, gold_ids: list[str], top_k: int = 50) -> int | None:
        results = self.search(query, top_k=top_k)
        for rank, (doc_id, _) in enumerate(results, 1):
            if doc_id in gold_ids:
                return rank
        return None

    def recall_at_k(self, query: str, gold_ids: list[str], k: int = 5) -> bool:
        results = self.search(query, top_k=k)
        retrieved_ids = {doc_id for doc_id, _ in results}
        return bool(retrieved_ids & set(gold_ids))