code/build_benchmark.py

"""
TempBench Builder
==========================
Constructs a 10K-question multi-hop temporal QA benchmark (see the TempBench paper).

Implements the full 6-stage pipeline:
  1. Question generation from KG triples and templates
  2. Composability filtering (validate temporal consistency)
  3. Answer uniqueness filtering (discard ambiguous questions)
  4. MinHash deduplication (Jaccard similarity threshold)
  5. Subgraph construction (S_star, S_dist, S_stale)
  6. Train/dev/test split (stratified by complexity)

Output: JSONL benchmark with one question per line, including supporting subgraphs.

Usage:
    python build_benchmark.py --kg_path kg.json --output_dir ./benchmark/ --target_n 10000

"""

from __future__ import annotations

import argparse
import hashlib
import json
import math
import random
import sys
from collections import defaultdict
from dataclasses import dataclass, asdict
from pathlib import Path
from typing import Dict, List, Optional, Set, Tuple

from indexer import (
    TemporalKGIndexer,
    Triple,
    ValidityWindow,
)

# ---------------------------------------------------------------------------
# Question generation templates
# ---------------------------------------------------------------------------

QUESTION_TEMPLATES = {
    # The TempBench paper cites the TimelineKGQA taxonomy for four operator types.
    # Each operator takes a compositional chain "path" (= anchor + hop
    # relations, joined by "'s") and attaches an operator-specific temporal
    # qualifier. See benchmark-design-decisions.md §1 for semantics.
    "point_in_time": [
        "In {year}, what was the {final_relation} of {path}?",
        "What was the {final_relation} of {path} in {year}?",
        "{path}'s {final_relation} in {year} was?",
    ],
    "before_after": [
        "Who was the {final_relation} of {path} {qualifier} {sibling}?",
        "{qualifier_cap} {sibling}, who was the {final_relation} of {path}?",
    ],
    "interval": [
        "In what year was the {final_relation} of {path} equal to {terminal}?",
        "When was {terminal} the {final_relation} of {path}?",
    ],
    "sequence": [
        "After {ref_subject} {ref_relation} {ref_object}, what was the {final_relation} of {path}?",
        "What was the {final_relation} of {path} after {ref_subject} {ref_relation} {ref_object}?",
    ],
}


def _render_composition_path(anchor: str, relations: List[str]) -> str:
    """
    Render the nested possessive prefix for compositional multi-hop questions.

    Example:
        anchor = "Obama", relations = ["spouse", "country"]
        returns: "Obama's spouse's country"
    Used as the {path} placeholder for the last-but-one hop; the final
    relation becomes the {final_relation} placeholder.
    """
    parts = [anchor] + relations
    return "'s ".join(parts)

# ---------------------------------------------------------------------------
# Data structures
# ---------------------------------------------------------------------------

@dataclass
class Candidate:
    """An intermediate candidate question before filtering."""
    id: str
    question: str
    t_query: float
    answer: str
    complexity: str  # "1hop", "2hop", "3plus"
    operator_type: str  # "point_in_time", "before_after", "interval", "sequence"
    question_type: str  # "explicit", "implicit", "ordinal"
    gold_chain: List[Triple]


@dataclass
class BenchmarkQuestion:
    """A final, fully-validated benchmark question."""
    id: str
    question: str
    t_query: float
    answer: str
    complexity: str
    operator_type: str
    question_type: str
    S_star: List[Dict]  # Gold chain
    S_dist: List[Dict]  # Distractor chain
    S_stale: List[Dict]  # Stale-fact chain
    split: str  # "train", "dev", "test"

    def to_jsonl_dict(self) -> Dict:
        """Convert to dict for JSONL serialization."""
        return {
            "id": self.id,
            "question": self.question,
            "t_query": self.t_query,
            "answer": self.answer,
            "complexity": self.complexity,
            "operator_type": self.operator_type,
            "question_type": self.question_type,
            "S_star": self.S_star,
            "S_dist": self.S_dist,
            "S_stale": self.S_stale,
            "split": self.split,
        }


# ---------------------------------------------------------------------------
# Stage 1: Question generation (fallback mode)
# ---------------------------------------------------------------------------

class QuestionGenerator:
    """
    Generates candidate questions from KG triples using templates.
    Fallback mode when TimelineKGQA is not available.
    """

    def __init__(self, indexer: TemporalKGIndexer, seed: int = 42):
        self.indexer = indexer
        self.rng = random.Random(seed)
        self.triples = indexer._all_triples
        self.candidate_id_counter = 0
        # Collect all actual timestamps for point-in-time TKGs (t_start == t_end)
        self._timestamps: List[float] = sorted(
            {t.t_start for t in self.triples}
        )
        # tkgl-smallpedia is 100% point-in-time; multi-hop chains need every
        # hop at exactly the same year. Pre-index (subject, year) → triples
        # so the 2-hop and 3+-hop samplers can forward-chain in O(bucket_size)
        # instead of O(entity_degree across all years).
        self._subject_year: Dict[str, Dict[float, List[Triple]]] = defaultdict(
            lambda: defaultdict(list)
        )
        for t in self.triples:
            self._subject_year[t.subject][t.t_start].append(t)
        self._subjects_with_outgoing: List[str] = list(self._subject_year.keys())

    # --- Public entry point ---------------------------------------------

    def generate_candidates(
        self,
        target_candidates: int = 40000,
        min_depth: int = 1,
        max_depth: int = 4,
    ) -> List[Candidate]:
        """
        Generate candidates across the 12-cell matrix (3 complexity levels ×
        4 temporal operator types). Target per cell is an even split of the
        per-complexity budget (4K/4K/2K per the TempBench paper).

        Implementation: sample chains per complexity, and for each chain try
        each of the four operator builders. PIT and INT succeed for almost
        every chain; BA requires a sibling fact and SEQ requires an earlier
        reference triple, so those buckets yield less per chain.
        """
        # The TempBench paper commits to 4000 / 4000 / 2000 at target_n = 10000.
        # Scale proportionally to target_candidates (= 4 × target_n from the
        # BenchmarkBuilder).
        per_complexity = {
            "1hop": target_candidates // 10,    # 40% of target_n
            "2hop": target_candidates // 10,    # 40% of target_n
            "3plus": target_candidates // 20,   # 20% of target_n
        }
        # 3× oversample to absorb Stage 3/4 attrition (uniqueness + dedup).
        pool_per_complexity = {k: v * 3 for k, v in per_complexity.items()}
        operators = ["point_in_time", "before_after", "interval", "sequence"]

        candidates: List[Candidate] = []
        for complexity, pool_target in pool_per_complexity.items():
            sampler = {
                "1hop": lambda n: self._sample_1hop_chains(n),
                "2hop": lambda n: self._sample_2hop_chains(n),
                "3plus": lambda n: self._sample_3plus_chains(n, max_depth),
            }[complexity]
            # Each chain can produce up to len(operators) candidates, so we
            # only need pool_target / len(operators) chains — but many
            # BA/SEQ attempts fail, so keep a healthy buffer.
            chains = sampler(pool_target // 2)
            for chain, t_query in chains:
                for op in operators:
                    cand = self._build_operator_candidate(
                        op, chain, t_query, complexity
                    )
                    if cand is not None:
                        candidates.append(cand)

        self.rng.shuffle(candidates)
        return candidates

    # --- Chain samplers (return chain + t_query, no templating) ---------

    def _sample_1hop_chains(
        self, target_count: int
    ) -> List[Tuple[List[Triple], float]]:
        chains = []
        sampled = self.rng.sample(
            self.triples, min(len(self.triples), target_count)
        )
        for t in sampled:
            chains.append(([t], t.t_start))
        return chains

    def _sample_2hop_chains(
        self, target_count: int
    ) -> List[Tuple[List[Triple], float]]:
        """
        Year-first 2-hop sampler. Pick an anchor subject that has outgoing
        facts, pick a year from that subject, then find a second hop from the
        pivot at the same year. Much higher success rate than sampling t1
        first and hoping for a matching t2.
        """
        chains = []
        attempts = 0
        max_attempts = target_count * 8
        while len(chains) < target_count and attempts < max_attempts:
            attempts += 1
            anchor = self.rng.choice(self._subjects_with_outgoing)
            year_index = self._subject_year[anchor]
            year = self.rng.choice(list(year_index.keys()))
            t1_candidates = year_index[year]
            t1 = self.rng.choice(t1_candidates)

            pivot_year_index = self._subject_year.get(t1.obj)
            if pivot_year_index is None:
                continue
            t2_candidates = [
                t for t in pivot_year_index.get(year, [])
                if t.relation != t1.relation
                and t.obj != t1.subject  # cycle guard
            ]
            if not t2_candidates:
                continue
            t2 = self.rng.choice(t2_candidates)

            chains.append(([t1, t2], year))
        return chains

    def _sample_3plus_chains(
        self, target_count: int, max_depth: int
    ) -> List[Tuple[List[Triple], float]]:
        """
        Year-first 3+-hop sampler. Pick an anchor subject, pick a year that
        subject has outgoing facts, walk forward through hops at that year.
        Uses the pre-built (subject, year) index for fast forward-chaining.
        """
        chains = []
        attempts = 0
        max_attempts = target_count * 15
        while len(chains) < target_count and attempts < max_attempts:
            attempts += 1
            anchor = self.rng.choice(self._subjects_with_outgoing)
            year_index = self._subject_year[anchor]
            year = self.rng.choice(list(year_index.keys()))
            depth = self.rng.randint(3, min(max_depth, 4))

            chain: List[Triple] = []
            current = anchor
            visited = {current}
            for _ in range(depth):
                hops = [
                    t for t in self._subject_year.get(current, {}).get(year, [])
                    if t.obj not in visited
                ]
                if not hops:
                    break
                hop = self.rng.choice(hops)
                chain.append(hop)
                current = hop.obj
                visited.add(current)

            if len(chain) < 3:
                continue

            if any(
                chain[i].relation == chain[i - 1].relation
                for i in range(1, len(chain))
            ):
                continue

            window = ValidityWindow.full()
            valid = True
            for triple in chain:
                window = TemporalKGIndexer.compose(window, triple, year)
                if window is None or window.is_empty():
                    valid = False
                    break
            if not valid:
                continue

            chains.append((chain, year))
        return chains

    # --- Operator builders ----------------------------------------------

    def _build_operator_candidate(
        self,
        operator: str,
        chain: List[Triple],
        t_query: float,
        complexity: str,
    ) -> Optional[Candidate]:
        """Dispatch to the right operator builder."""
        dispatch = {
            "point_in_time": self._build_pit,
            "before_after": self._build_ba,
            "interval": self._build_interval,
            "sequence": self._build_sequence,
        }
        return dispatch[operator](chain, t_query, complexity)

    def _build_pit(
        self, chain: List[Triple], t_query: float, complexity: str
    ) -> Optional[Candidate]:
        """Point-in-time: "In {year}, what was {path}'s {r_n}?"."""
        path = _render_composition_path(
            chain[0].subject, [h.relation for h in chain[:-1]]
        )
        template = self.rng.choice(QUESTION_TEMPLATES["point_in_time"])
        question = template.format(
            path=path,
            final_relation=chain[-1].relation,
            year=int(t_query),
        )
        return self._make_candidate(
            question, t_query, chain[-1].obj, chain, complexity,
            "point_in_time", "explicit",
        )

    def _build_ba(
        self, chain: List[Triple], t_query: float, complexity: str
    ) -> Optional[Candidate]:
        """
        Before/after: same chain as PIT, but the temporal anchor is a sibling
        fact (another holder of the terminal relation at a different time).
        The candidate is dropped if no such sibling exists.
        """
        terminal = chain[-1]
        siblings = [
            t for t in self.indexer.entity_index.get(terminal.subject, [])
            if t.subject == terminal.subject
            and t.relation == terminal.relation
            and t.obj != terminal.obj
            and t.t_start != t_query
        ]
        if not siblings:
            return None
        sibling = self.rng.choice(siblings)
        # Qualifier: answer came *before* sibling if t_query < sibling.t_start.
        if sibling.t_start > t_query:
            qualifier, qualifier_cap = "before", "Before"
        else:
            qualifier, qualifier_cap = "after", "After"

        path = _render_composition_path(
            chain[0].subject, [h.relation for h in chain[:-1]]
        )
        template = self.rng.choice(QUESTION_TEMPLATES["before_after"])
        question = template.format(
            path=path,
            final_relation=terminal.relation,
            qualifier=qualifier,
            qualifier_cap=qualifier_cap,
            sibling=sibling.obj,
        )
        return self._make_candidate(
            question, t_query, terminal.obj, chain, complexity,
            "before_after", "ordinal",
        )

    def _build_interval(
        self, chain: List[Triple], t_query: float, complexity: str
    ) -> Optional[Candidate]:
        """
        Interval (temporal pinpoint): "In what year was {path}'s {r_n} equal
        to {terminal}?". Answer is the query year. Uniqueness of the year
        is enforced by a custom check in Stage 3 (AnswerUniquenessFilter).
        """
        path = _render_composition_path(
            chain[0].subject, [h.relation for h in chain[:-1]]
        )
        terminal = chain[-1]
        template = self.rng.choice(QUESTION_TEMPLATES["interval"])
        question = template.format(
            path=path,
            final_relation=terminal.relation,
            terminal=terminal.obj,
        )
        return self._make_candidate(
            question, t_query, str(int(t_query)), chain, complexity,
            "interval", "ordinal",
        )

    def _build_sequence(
        self, chain: List[Triple], t_query: float, complexity: str
    ) -> Optional[Candidate]:
        """
        Sequence: "After {ref_subject} {ref_rel} {ref_obj}, what was {path}'s
        {r_n}?". Reference triple is an earlier fact involving any entity in
        the chain (makes the anchor event contextually relevant).
        """
        chain_entities = {h.subject for h in chain} | {h.obj for h in chain}
        chain_ids = {(h.subject, h.relation, h.obj) for h in chain}
        answer_entity = chain[-1].obj
        refs = []
        for e in chain_entities:
            for t in self.indexer.entity_index.get(e, []):
                if (
                    t.t_start < t_query
                    and (t.subject, t.relation, t.obj) not in chain_ids
                    # The reference must not contain the answer anywhere —
                    # otherwise the question literally names its own answer.
                    and t.subject != answer_entity
                    and t.obj != answer_entity
                ):
                    refs.append(t)
        if not refs:
            return None
        ref = self.rng.choice(refs)
        path = _render_composition_path(
            chain[0].subject, [h.relation for h in chain[:-1]]
        )
        template = self.rng.choice(QUESTION_TEMPLATES["sequence"])
        question = template.format(
            path=path,
            final_relation=chain[-1].relation,
            ref_subject=ref.subject,
            ref_relation=ref.relation,
            ref_object=ref.obj,
        )
        return self._make_candidate(
            question, t_query, chain[-1].obj, chain, complexity,
            "sequence", "ordinal",
        )

    def _make_candidate(
        self,
        question: str,
        t_query: float,
        answer: str,
        chain: List[Triple],
        complexity: str,
        operator_type: str,
        question_type: str,
    ) -> Candidate:
        cand = Candidate(
            id=f"cand_{self.candidate_id_counter}",
            question=question,
            t_query=t_query,
            answer=answer,
            complexity=complexity,
            operator_type=operator_type,
            question_type=question_type,
            gold_chain=chain,
        )
        self.candidate_id_counter += 1
        return cand


# ---------------------------------------------------------------------------
# Stage 2: Composability filter
# ---------------------------------------------------------------------------

class ComposabilityFilter:
    """Validates temporal consistency of candidate chains."""

    @staticmethod
    def filter_candidates(candidates: List[Candidate]) -> List[Candidate]:
        """
        Discard candidates whose gold chain has empty composed validity window.
        Uses the ⊕ operator from ValidityWindow.intersect().
        """
        valid = []

        for cand in candidates:
            # Compose all triples in the chain
            window = ValidityWindow.full()
            is_valid = True

            for triple in cand.gold_chain:
                window = TemporalKGIndexer.compose(window, triple, cand.t_query)
                if window is None or window.is_empty():
                    is_valid = False
                    break

            if is_valid:
                valid.append(cand)

        return valid


# ---------------------------------------------------------------------------
# Stage 3: Answer uniqueness filter
# ---------------------------------------------------------------------------

class AnswerUniquenessFilter:
    """Discards ambiguous questions with multiple valid answers at t_query."""

    def __init__(self, indexer: TemporalKGIndexer):
        self.indexer = indexer

    def filter_candidates(self, candidates: List[Candidate]) -> List[Candidate]:
        valid = [c for c in candidates if self._answer_is_unique(c)]
        return valid

    def _answer_is_unique(self, cand: Candidate) -> bool:
        """
        Construction pipeline, Step 4: "removing ambiguous questions with multiple valid
        answers at t_q". Scope is terminal-answer only — intermediate fan-out
        along the chain is permitted.

        Entity-valued operators (PIT, BA, SEQ): the final hop's (subject,
        relation) must have exactly one valid object at t_q, and that object
        must equal the recorded answer.

        Year-valued operator (INT): the specific terminal triple (subject,
        relation, object) must be valid at exactly one distinct t in the KG.
        Otherwise the year-answer is ambiguous.

        See benchmark-design-decisions.md §3 for the full rationale.
        """
        if not cand.gold_chain:
            return False

        terminal = cand.gold_chain[-1]

        if cand.operator_type == "interval":
            # Year answer: the specific (s, r, o) triple must be unique in time.
            matches = [
                t for t in self.indexer.entity_index.get(terminal.subject, [])
                if t.subject == terminal.subject
                and t.relation == terminal.relation
                and t.obj == terminal.obj
            ]
            distinct_years = {t.t_start for t in matches}
            return len(distinct_years) == 1

        # Entity-valued operators: terminal (s, r) must have a single valid
        # object at t_q.
        terminal_objs = {
            t.obj
            for t in self.indexer.entity_index.get(terminal.subject, [])
            if t.subject == terminal.subject
            and t.relation == terminal.relation
            and t.valid_at(cand.t_query)
        }
        return len(terminal_objs) == 1 and cand.answer in terminal_objs


# ---------------------------------------------------------------------------
# Stage 4: MinHash deduplication
# ---------------------------------------------------------------------------

class MinHasher:
    """
    MinHash with Jaccard similarity for deduplicating near-duplicate questions.
    Uses character 3-grams and 128 hash functions.
    """

    def __init__(self, num_hashes: int = 128, gram_size: int = 3, seed: int = 42):
        self.num_hashes = num_hashes
        self.gram_size = gram_size
        self.seed = seed

    @staticmethod
    def _get_grams(text: str, gram_size: int) -> Set[str]:
        """Extract character n-grams from text."""
        text = text.lower()
        return {text[i : i + gram_size] for i in range(len(text) - gram_size + 1)}

    def _hash_gram(self, gram: str, hash_idx: int) -> int:
        """Compute hash value for a gram and hash function index."""
        seed_str = f"{self.seed}_{hash_idx}_{gram}"
        h = hashlib.sha256(seed_str.encode()).hexdigest()
        return int(h, 16)

    def signature(self, text: str) -> List[int]:
        """Compute MinHash signature for a text."""
        grams = self._get_grams(text, self.gram_size)

        if not grams:
            return [0] * self.num_hashes

        sig = []
        for hash_idx in range(self.num_hashes):
            min_hash = float("inf")
            for gram in grams:
                h = self._hash_gram(gram, hash_idx)
                min_hash = min(min_hash, h)
            sig.append(min_hash)

        return sig

    @staticmethod
    def jaccard_similarity(sig_a: List[int], sig_b: List[int]) -> float:
        """Estimate Jaccard similarity from MinHash signatures."""
        if len(sig_a) == 0 or len(sig_b) == 0:
            return 0.0
        matches = sum(1 for a, b in zip(sig_a, sig_b) if a == b)
        return matches / len(sig_a)


class MinHashDeduplicator:
    """Deduplicates candidates using MinHash with Jaccard threshold."""

    def __init__(self, similarity_threshold: float = 0.8, seed: int = 42):
        self.threshold = similarity_threshold
        self.hasher = MinHasher(num_hashes=128, seed=seed)

    def deduplicate(self, candidates: List[Candidate]) -> List[Candidate]:
        """
        Remove near-duplicate questions (Jaccard > threshold).
        Keep the first occurrence of each group.
        """
        if not candidates:
            return []

        # Compute signatures
        sigs = [(c, self.hasher.signature(c.question)) for c in candidates]

        # Greedy clustering: each candidate either starts a cluster or is merged
        clusters = []
        used = set()

        for i, (cand_i, sig_i) in enumerate(sigs):
            if i in used:
                continue

            cluster = [cand_i]
            used.add(i)

            for j in range(i + 1, len(sigs)):
                if j in used:
                    continue

                cand_j, sig_j = sigs[j]
                sim = self.hasher.jaccard_similarity(sig_i, sig_j)

                if sim > self.threshold:
                    used.add(j)

            clusters.append(cluster[0])  # Keep first of each cluster

        return clusters


# ---------------------------------------------------------------------------
# Stage 5: Subgraph construction
# ---------------------------------------------------------------------------

class SubgraphConstructor:
    """
    Builds three subgraphs for each question:
      - S_star: ground truth chain
      - S_dist: distractor (one wrong hop, same relation, different object)
      - S_stale: stale-fact (one hop replaced by temporally adjacent version)
    """

    def __init__(self, indexer: TemporalKGIndexer, seed: int = 42):
        self.indexer = indexer
        self.rng = random.Random(seed)

    def construct(
        self,
        candidate: Candidate,
    ) -> Tuple[List[Dict], List[Dict], List[Dict]]:
        """
        Build S_star, S_dist, S_stale for a candidate.
        Returns (S_star, S_dist, S_stale) as list of triple dicts.
        """
        # S_star: the gold chain
        S_star = [t.to_dict() for t in candidate.gold_chain]

        # S_dist: replace one hop with a distractor (same relation, different object, valid at t_query)
        S_dist = self._build_distractor(candidate)

        # S_stale: replace one hop with a temporally adjacent version
        S_stale = self._build_stale(candidate)

        return S_star, S_dist, S_stale

    def _build_distractor(self, candidate: Candidate) -> List[Dict]:
        """
        Replace one random hop with a semantically similar but wrong triple.
        Same subject, same relation, different object, valid at t_query.
        """
        if not candidate.gold_chain:
            return [t.to_dict() for t in candidate.gold_chain]

        S_dist = [t.to_dict() for t in candidate.gold_chain]
        hop_to_replace = self.rng.randint(0, len(candidate.gold_chain) - 1)
        replaced_triple = candidate.gold_chain[hop_to_replace]

        # Find alternative triples with same (s, r) but different object AT ANY TIME.
        # We can't require valid_at(t_query) — the answer-uniqueness filter has
        # already guaranteed no such alternatives exist, so that constraint would
        # always return an empty list. Taking any alternative object across time
        # gives a semantically plausible but factually wrong distractor (e.g. a
        # former CEO when the question asks about a later year).
        alternatives = [
            t for t in self.indexer.entity_index.get(replaced_triple.subject, [])
            if (t.subject == replaced_triple.subject and
                t.relation == replaced_triple.relation and
                t.obj != replaced_triple.obj)
        ]

        if alternatives:
            distractor = self.rng.choice(alternatives)
            S_dist[hop_to_replace] = distractor.to_dict()

        return S_dist

    def _build_stale(self, candidate: Candidate) -> List[Dict]:
        """
        Replace one hop with a temporally adjacent version
        (same s, r, o but different validity window that does NOT contain t_query).
        """
        if not candidate.gold_chain:
            return [t.to_dict() for t in candidate.gold_chain]

        S_stale = [t.to_dict() for t in candidate.gold_chain]
        hop_to_replace = self.rng.randint(0, len(candidate.gold_chain) - 1)
        replaced_triple = candidate.gold_chain[hop_to_replace]

        # Find temporally adjacent versions of the same triple
        adjacent = [
            t for t in self.indexer._all_triples
            if (t.subject == replaced_triple.subject and
                t.relation == replaced_triple.relation and
                t.obj == replaced_triple.obj and
                t.t_start != replaced_triple.t_start and
                not t.valid_at(candidate.t_query))
        ]

        if adjacent:
            stale_triple = self.rng.choice(adjacent)
            S_stale[hop_to_replace] = stale_triple.to_dict()

        return S_stale


# ---------------------------------------------------------------------------
# Stage 6: Train/dev/test split
# ---------------------------------------------------------------------------

class DatasetSplitter:
    """Stratified split by complexity level."""

    def __init__(self, seed: int = 42):
        self.rng = random.Random(seed)

    def split(
        self,
        questions: List[BenchmarkQuestion],
        train_frac: float = 0.7,
        dev_frac: float = 0.1,
        test_frac: float = 0.2,
    ) -> List[BenchmarkQuestion]:
        """
        Stratified split by complexity.
        Target: 1-hop: 4K (2.8K train), 2-hop: 4K (2.8K train), 3+-hop: 2K (1.4K train)
        """
        # Group by complexity
        by_complexity: Dict[str, List[BenchmarkQuestion]] = defaultdict(list)
        for q in questions:
            by_complexity[q.complexity].append(q)

        # Split each group
        result = []
        for complexity, qs in by_complexity.items():
            self.rng.shuffle(qs)

            n = len(qs)
            train_end = int(n * train_frac)
            dev_end = train_end + int(n * dev_frac)

            for i, q in enumerate(qs):
                if i < train_end:
                    q.split = "train"
                elif i < dev_end:
                    q.split = "dev"
                else:
                    q.split = "test"

            result.extend(qs)

        return result


# ---------------------------------------------------------------------------
# Main builder
# ---------------------------------------------------------------------------

class BenchmarkBuilder:
    """Orchestrates all six pipeline stages."""

    def __init__(
        self,
        kg_path: str,
        output_dir: str = "./benchmark/",
        target_n: int = 10000,
        seed: int = 42,
        min_depth: int = 1,
        max_depth: int = 4,
    ):
        self.kg_path = kg_path
        self.output_dir = Path(output_dir)
        self.target_n = target_n
        self.seed = seed
        self.min_depth = min_depth
        self.max_depth = max_depth
        self.rng = random.Random(seed)

        # Build or load indexer
        self.indexer = TemporalKGIndexer()
        if kg_path.endswith(".json"):
            self.indexer.load_from_json(kg_path)
        else:
            self.indexer.load_tkgl_smallpedia(kg_path)

    def build(self) -> List[BenchmarkQuestion]:
        """Run the full 6-stage pipeline."""
        print("[Benchmark Builder] Starting pipeline...")
        print(f"[Indexer] {self.indexer}")

        # Stage 1: Generate candidates
        print("\n[Stage 1] Question generation...")
        gen = QuestionGenerator(self.indexer, seed=self.seed)
        target_candidates = int(self.target_n * 4)  # 40K to yield 10K
        candidates = gen.generate_candidates(
            target_candidates=target_candidates,
            min_depth=self.min_depth,
            max_depth=self.max_depth,
        )
        print(f"  Generated {len(candidates):,} candidates")

        # Stage 2: Composability filter
        print("\n[Stage 2] Composability filtering...")
        comp_filter = ComposabilityFilter()
        candidates = comp_filter.filter_candidates(candidates)
        print(f"  Passed composability check: {len(candidates):,}")

        # Stage 3: Answer uniqueness filter
        print("\n[Stage 3] Answer uniqueness filtering...")
        uniq_filter = AnswerUniquenessFilter(self.indexer)
        candidates = uniq_filter.filter_candidates(candidates)
        print(f"  Passed uniqueness check: {len(candidates):,}")

        # Stage 4: MinHash deduplication
        print("\n[Stage 4] MinHash deduplication...")
        deduplicator = MinHashDeduplicator(similarity_threshold=0.8, seed=self.seed)
        candidates = deduplicator.deduplicate(candidates)
        print(f"  After deduplication: {len(candidates):,}")

        # Stratified trim: hit the paper's per-complexity targets
        # (4K / 4K / 2K at target_n = 10K) and, within each complexity, spread
        # across the four operator types. Under-yield in an operator cell
        # is topped up with point-in-time from the same complexity, because
        # PIT is the most reliable operator and degrades the benchmark least
        # if it fills in for a short cell.
        candidates = self._stratified_trim(candidates)
        print(f"  Trimmed to target: {len(candidates):,}")

        # Stage 5: Subgraph construction
        print("\n[Stage 5] Subgraph construction...")
        sg_constructor = SubgraphConstructor(self.indexer, seed=self.seed)
        questions = []

        for i, cand in enumerate(candidates):
            S_star, S_dist, S_stale = sg_constructor.construct(cand)

            q = BenchmarkQuestion(
                id=f"q_{i:06d}",
                question=cand.question,
                t_query=cand.t_query,
                answer=cand.answer,
                complexity=cand.complexity,
                operator_type=cand.operator_type,
                question_type=cand.question_type,
                S_star=S_star,
                S_dist=S_dist,
                S_stale=S_stale,
                split="",  # Will be set in Stage 6
            )
            questions.append(q)

        print(f"  Subgraphs constructed: {len(questions):,}")

        # Stage 6: Train/dev/test split
        print("\n[Stage 6] Train/dev/test split (stratified)...")
        splitter = DatasetSplitter(seed=self.seed)
        questions = splitter.split(questions)

        # Print split statistics
        splits = defaultdict(lambda: defaultdict(int))
        for q in questions:
            splits[q.complexity][q.split] += 1

        print("  Split distribution:")
        for complexity in ["1hop", "2hop", "3plus"]:
            if complexity in splits:
                train = splits[complexity]["train"]
                dev = splits[complexity]["dev"]
                test = splits[complexity]["test"]
                total = train + dev + test
                print(f"    {complexity:8s}: {total:5d} ({train:4d} train, {dev:3d} dev, {test:3d} test)")

        return questions

    def _stratified_trim(self, candidates: List[Candidate]) -> List[Candidate]:
        """
        Reduce candidates to per-complexity/per-operator quotas matching paper
        the TempBench paper (4K 1-hop, 4K 2-hop, 2K 3+-hop at target_n = 10K), with each
        complexity split evenly across four operators. Cells that under-yield
        are topped up from PIT in the same complexity.
        """
        per_complexity_target = {
            "1hop":  self.target_n * 4 // 10,   # 40%
            "2hop":  self.target_n * 4 // 10,   # 40%
            "3plus": self.target_n * 2 // 10,   # 20%
        }
        operators = ("point_in_time", "before_after", "interval", "sequence")

        # Bucket candidates by (complexity, operator)
        buckets: Dict[Tuple[str, str], List[Candidate]] = defaultdict(list)
        for c in candidates:
            buckets[(c.complexity, c.operator_type)].append(c)
        for bucket in buckets.values():
            self.rng.shuffle(bucket)

        trimmed: List[Candidate] = []
        for complexity, cx_target in per_complexity_target.items():
            per_op_target = cx_target // len(operators)
            cx_kept: List[Candidate] = []
            # First pass: take up to per_op_target from each operator cell.
            for op in operators:
                cell = buckets.get((complexity, op), [])
                cx_kept.extend(cell[:per_op_target])
            # Top up shortfall with PIT first, then anything available.
            shortfall = cx_target - len(cx_kept)
            if shortfall > 0:
                topup_pool: List[Candidate] = []
                for op in ("point_in_time", "sequence", "before_after", "interval"):
                    cell = buckets.get((complexity, op), [])
                    if len(cell) > per_op_target:
                        topup_pool.extend(cell[per_op_target:])
                self.rng.shuffle(topup_pool)
                cx_kept.extend(topup_pool[:shortfall])
            trimmed.extend(cx_kept)

        self.rng.shuffle(trimmed)
        return trimmed

    def save(self, questions: List[BenchmarkQuestion]) -> None:
        """Write benchmark to JSONL file."""
        self.output_dir.mkdir(parents=True, exist_ok=True)
        output_path = self.output_dir / "benchmark.jsonl"

        with open(output_path, "w", encoding="utf-8") as f:
            for q in questions:
                f.write(json.dumps(q.to_jsonl_dict()) + "\n")

        print(f"\n[Output] Benchmark saved to {output_path}")
        print(f"  {len(questions):,} questions written")


# ---------------------------------------------------------------------------
# Smoke test
# ---------------------------------------------------------------------------

def smoke_test():
    """Run on synthetic Deutsche Bank KG (same 5 triples as indexer.py tests)."""
    print("=" * 70)
    print("SMOKE TEST: TempBench Builder")
    print("=" * 70)

    # Create a temporary indexer with synthetic data
    indexer = TemporalKGIndexer()
    indexer.build([
        ("Deutsche_Bank", "has_CFO", "John_Cryan", 2015.0, 2018.0),
        ("Deutsche_Bank", "has_CFO", "Christian_Sewing", 2018.0, math.inf),
        ("Deutsche_Bank", "settled", "LIBOR_Case", 2015.25, 2015.25),
        ("John_Cryan", "member_of", "Deutsche_Bank", 2015.0, 2018.0),
        ("Christian_Sewing", "member_of", "Deutsche_Bank", 2018.0, math.inf),
    ])

    print(f"\nIndexer: {indexer}\n")

    # Generate candidates
    gen = QuestionGenerator(indexer, seed=42)
    candidates = gen.generate_candidates(
        target_candidates=100,
        min_depth=1,
        max_depth=3,
    )
    print(f"Generated {len(candidates)} candidates")

    # Filter by composability
    comp_filter = ComposabilityFilter()
    candidates = comp_filter.filter_candidates(candidates)
    print(f"Passed composability: {len(candidates)}")

    # Filter by uniqueness
    uniq_filter = AnswerUniquenessFilter(indexer)
    candidates = uniq_filter.filter_candidates(candidates)
    print(f"Passed uniqueness: {len(candidates)}")

    # Deduplicate
    deduplicator = MinHashDeduplicator(similarity_threshold=0.8, seed=42)
    candidates = deduplicator.deduplicate(candidates)
    print(f"After deduplication: {len(candidates)}")

    # Build subgraphs
    sg_constructor = SubgraphConstructor(indexer, seed=42)
    questions = []

    for i, cand in enumerate(candidates[:min(5, len(candidates))]):
        S_star, S_dist, S_stale = sg_constructor.construct(cand)

        q = BenchmarkQuestion(
            id=f"q_{i:06d}",
            question=cand.question,
            t_query=cand.t_query,
            answer=cand.answer,
            complexity=cand.complexity,
            operator_type=cand.operator_type,
            question_type=cand.question_type,
            S_star=S_star,
            S_dist=S_dist,
            S_stale=S_stale,
            split="train",
        )
        questions.append(q)

    print(f"Built {len(questions)} benchmark questions\n")

    # Print sample
    print("Sample questions:")
    for q in questions[:3]:
        print(f"\n  ID: {q.id}")
        print(f"  Question: {q.question}")
        print(f"  Complexity: {q.complexity}")
        print(f"  Answer: {q.answer}")
        print(f"  t_query: {q.t_query}")
        print(f"  Operator: {q.operator_type}")
        print(f"  S_star: {len(q.S_star)} triples")
        print(f"  S_dist: {len(q.S_dist)} triples")
        print(f"  S_stale: {len(q.S_stale)} triples")

    print("\n" + "=" * 70)
    print("SMOKE TEST PASSED")
    print("=" * 70)


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------

def main():
    parser = argparse.ArgumentParser(
        description="Build TempBench: 10K-question temporal QA benchmark"
    )
    parser.add_argument(
        "--kg_path",
        type=str,
        default=None,
        help="Path to KG file (JSON or TKGL CSV)",
    )
    parser.add_argument(
        "--output_dir",
        type=str,
        default="./benchmark/",
        help="Output directory for benchmark JSONL",
    )
    parser.add_argument(
        "--target_n",
        type=int,
        default=10000,
        help="Target number of benchmark questions (default 10000)",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=42,
        help="Random seed (default 42)",
    )
    parser.add_argument(
        "--min_depth",
        type=int,
        default=1,
        help="Minimum chain depth (default 1)",
    )
    parser.add_argument(
        "--max_depth",
        type=int,
        default=4,
        help="Maximum chain depth (default 4)",
    )
    parser.add_argument(
        "--smoke_test",
        action="store_true",
        help="Run smoke test on synthetic data",
    )

    args = parser.parse_args()

    if args.smoke_test:
        smoke_test()
        sys.exit(0)

    if not args.kg_path:
        print("Error: --kg_path required (or use --smoke_test)")
        sys.exit(1)

    builder = BenchmarkBuilder(
        kg_path=args.kg_path,
        output_dir=args.output_dir,
        target_n=args.target_n,
        seed=args.seed,
        min_depth=args.min_depth,
        max_depth=args.max_depth,
    )

    questions = builder.build()
    builder.save(questions)


if __name__ == "__main__":
    main()