#!/usr/bin/env python3
import argparse
import json
import shutil
import tempfile
from pathlib import Path

import chromadb


def load_cases(path: Path):
    cases = []
    with path.open() as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            cases.append(json.loads(line))
    return cases


def run_case(case: dict):
    root = Path(tempfile.mkdtemp(prefix="mempalace-adv-"))
    try:
        client = chromadb.PersistentClient(path=str(root))
        col = client.get_or_create_collection("mempalace_drawers")
        ids = []
        docs = []
        metas = []
        for entry in case["entries"]:
            ids.append(entry["id"])
            docs.append(entry["text"])
            metas.append({
                "wing": "bench",
                "room": case["adversary_type"],
                "hall": "hall_facts",
                "source_file": entry["id"],
            })
        col.add(ids=ids, documents=docs, metadatas=metas)
        results = col.query(query_texts=[case["query"]], n_results=len(case["entries"]), include=["documents", "metadatas", "distances"])
        ranked_ids = [meta["source_file"] for meta in results["metadatas"][0]]
        relevant = set(case["relevant_ids"])
        hit_at_1 = bool(ranked_ids[:1] and ranked_ids[0] in relevant)
        hit_at_5 = any(item in relevant for item in ranked_ids[:5])
        mrr = 0.0
        for i, item in enumerate(ranked_ids):
            if item in relevant:
                mrr = 1.0 / float(i + 1)
                break
        return {
            "id": case["id"],
            "adversary_type": case["adversary_type"],
            "query": case["query"],
            "relevant_ids": case["relevant_ids"],
            "ranked_ids": ranked_ids,
            "hit_at_1": hit_at_1,
            "hit_at_5": hit_at_5,
            "mrr": mrr,
        }
    finally:
        shutil.rmtree(root, ignore_errors=True)


def main() -> int:
    parser = argparse.ArgumentParser(description="Run adversarial benchmark against MemPalace raw-style retrieval")
    parser.add_argument("--data", default=str(Path(__file__).resolve().parents[1] / "data" / "cases.jsonl"))
    parser.add_argument("--out", default="")
    args = parser.parse_args()

    cases = load_cases(Path(args.data))
    results = [run_case(case) for case in cases]
    report = summarize(results)
    print(json.dumps({key: report[key] for key in ["cases", "recall_at_1", "recall_at_5", "mrr"]}, indent=2))
    if args.out:
        out = Path(args.out)
        out.parent.mkdir(parents=True, exist_ok=True)
        out.write_text(json.dumps(report, indent=2))
    return 0


def summarize(results):
    hits1 = hits5 = 0
    total_mrr = 0.0
    per_category = {}
    for item in results:
        hits1 += 1 if item["hit_at_1"] else 0
        hits5 += 1 if item["hit_at_5"] else 0
        total_mrr += item["mrr"]
        bucket = per_category.setdefault(item["adversary_type"], {"hit": 0, "total": 0})
        bucket["total"] += 1
        bucket["hit"] += 1 if item["hit_at_5"] else 0
    return {
        "cases": len(results),
        "recall_at_1": hits1 / len(results) if results else 0,
        "recall_at_5": hits5 / len(results) if results else 0,
        "mrr": total_mrr / len(results) if results else 0,
        "per_category": {key: value["hit"] / value["total"] for key, value in per_category.items()},
        "results": results,
    }


if __name__ == "__main__":
    raise SystemExit(main())