"""Simple keyword-retrieval baseline for BrainCore Memory Benchmark."""

import pickle
import time
from typing import Any


class BaselineAdapter:
    """Ingests memories into a flat list; retrieves via keyword overlap scoring."""

    def __init__(self):
        self.memories: list[dict] = []
        self._index: dict[str, list[int]] = {}  # word -> list of memory indices

    def ingest(self, raw_memories: list[dict]) -> None:
        self.memories = raw_memories
        self._index.clear()
        for idx, mem in enumerate(raw_memories):
            text = mem.get("text", "")
            for word in set(text.lower().split()):
                self._index.setdefault(word, []).append(idx)

    def retrieve(self, query: str, top_k: int = 1) -> list[dict]:
        query_words = set(query.lower().split())
        scores: dict[int, int] = {}
        for w in query_words:
            for idx in self._index.get(w, []):
                scores[idx] = scores.get(idx, 0) + 1
        # Break ties by recency (higher index = more recent).
        ranked = sorted(
            scores.items(),
            key=lambda x: (x[1], x[0]),
            reverse=True,
        )
        return [self.memories[i] for i, _ in ranked[:top_k]]

    def storage_bytes(self) -> int:
        return len(pickle.dumps(self.memories))


def build() -> BaselineAdapter:
    return BaselineAdapter()