#!/usr/bin/env python3
"""Deterministic synthetic benchmark for long-range record retrieval.

This measures retrieval and evidence packing only; no language model is called.
"""
from __future__ import annotations

import json
import platform
import random
import sqlite3
import statistics
import tempfile
import time
from pathlib import Path

from context_memory import MemoryStore

SEED = 20261029
CORPUS_SIZE = 1000
QUERY_COUNT = 200
RECENCY_WINDOW = 24
CONTEXT_BUDGET_ESTIMATE = 256


def run_benchmark() -> dict:
    rng = random.Random(SEED)
    sampled_ids = rng.sample(range(CORPUS_SIZE), QUERY_COUNT)
    search_latencies_ms = []
    baseline_hits = 0
    retrieval_hits = 0
    packed_fact_hits = 0
    context_sizes = []
    with tempfile.TemporaryDirectory(prefix="effective-context-bench-") as tmp:
        db = Path(tmp) / "benchmark.sqlite3"
        with MemoryStore(db, chunk_chars=1200, overlap_chars=80) as store:
            for index in range(CORPUS_SIZE):
                code = "CODE-" + format(index, "04d") + "-" + format((index * 7919) % 100000, "05d")
                text = (
                    "Synthetic archive entry Record-" + format(index, "04d") +
                    " is assigned unique validation code " + code + ". "
                    "This deterministic record tests whether a small context can retrieve "
                    "a fact that is buried in a much larger history."
                )
                store.ingest_text(
                    "memory://synthetic/record/" + format(index, "04d"),
                    text, title="Record-" + format(index, "04d"),
                )

            for index in sampled_ids:
                query = "What unique validation code is assigned to Record-" + format(index, "04d") + "?"
                if index >= CORPUS_SIZE - RECENCY_WINDOW:
                    baseline_hits += 1

                started = time.perf_counter()
                hits = store.search(query, limit=5)
                search_latencies_ms.append((time.perf_counter() - started) * 1000)
                target_code = "CODE-" + format(index, "04d") + "-" + format((index * 7919) % 100000, "05d")
                if hits and target_code in hits[0]["text"]:
                    retrieval_hits += 1

                packed = store.build_context(query, max_tokens=CONTEXT_BUDGET_ESTIMATE, max_candidates=5)
                context_sizes.append(packed["estimated_tokens"])
                if target_code in packed["pack"]:
                    packed_fact_hits += 1

            ordered = sorted(search_latencies_ms)
            p95_index = max(0, min(len(ordered) - 1, int(0.95 * len(ordered) + 0.999999) - 1))
            return {
                "benchmark": "effective-context-memory-synthetic-v1",
                "date": "2026-10-29",
                "seed": SEED,
                "runtime": {
                    "python": platform.python_version(),
                    "sqlite": sqlite3.sqlite_version,
                },
                "corpus": {
                    "records": CORPUS_SIZE,
                    "all_synthetic": True,
                    "private_data_used": False,
                    "network_calls": 0,
                    "model_calls": 0,
                },
                "queries": QUERY_COUNT,
                "baseline": {
                    "name": "recency-only context window",
                    "last_records_kept": RECENCY_WINDOW,
                    "hits": baseline_hits,
                    "hit_rate": round(baseline_hits / QUERY_COUNT, 6),
                },
                "candidate": {
                    "name": "SQLite-backed lexical retrieval + provenance-linked context pack",
                    "retrieval_top_5_hits": retrieval_hits,
                    "retrieval_top_5_hit_rate": round(retrieval_hits / QUERY_COUNT, 6),
                    "packed_fact_hits": packed_fact_hits,
                    "packed_fact_hit_rate": round(packed_fact_hits / QUERY_COUNT, 6),
                    "estimated_context_budget": CONTEXT_BUDGET_ESTIMATE,
                    "max_observed_estimated_context": max(context_sizes),
                    "mean_estimated_context": round(statistics.mean(context_sizes), 3),
                },
                "latency_ms": {
                    "median_search": round(statistics.median(search_latencies_ms), 4),
                    "p95_search": round(ordered[p95_index], 4),
                    "scope": "search() only; one local server; synthetic corpus; not production SLO",
                },
                "integrity": store.verify_integrity(),
                "interpretation": (
                    "Retrieval mechanics only. Queries contain the unique record identifier; "
                    "this does not test semantic paraphrase, generated answer correctness, "
                    "reasoning quality, production load, or generalization to private corpora."
                ),
            }


if __name__ == "__main__":
    result = run_benchmark()
    print(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True))
    if not result["integrity"]["ok"]:
        raise SystemExit(2)
    if result["candidate"]["retrieval_top_5_hit_rate"] < 0.99:
        raise SystemExit(3)
    if result["candidate"]["packed_fact_hit_rate"] < 0.99:
        raise SystemExit(4)