"""Content-bound reciprocal-rank fusion for teaching, not a retrieval benchmark."""

from dataclasses import asdict, dataclass, fields
import hashlib
import json
import math
import re
import sys


IDENTITY = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:/@-]{0,127}")
SHA256 = re.compile(r"[a-f0-9]{64}")
RETRIEVERS = ("lexical", "dense")


def identity(value):
    if type(value) is not str or not IDENTITY.fullmatch(value):
        raise ValueError("exact bounded identity required")
    return value


def sha256_text(value):
    if type(value) is not str or not SHA256.fullmatch(value):
        raise ValueError("exact lowercase SHA-256 required")
    return value


def number(value, lower, upper):
    if type(value) not in (int, float) or not math.isfinite(value):
        raise ValueError("finite non-boolean number required")
    if value != 0 and abs(value) < sys.float_info.min:
        raise ValueError("subnormal number rejected")
    if not lower <= value <= upper:
        raise ValueError("number outside contract range")
    return value


def count(value, lower, upper):
    if type(value) is not int or not lower <= value <= upper:
        raise ValueError("bounded non-boolean integer required")
    return value


def sequence(value, lower, upper):
    if type(value) not in (tuple, list):
        raise ValueError("bounded tuple or list required")
    count(len(value), lower, upper)
    return tuple(value)


def digest(value):
    encoded = json.dumps(
        value, sort_keys=True, separators=(",", ":"), allow_nan=False
    ).encode()
    return hashlib.sha256(encoded).hexdigest()


def seal(record):
    if type(record.content_id) is not str:
        raise ValueError("content digest requires exact string")
    data = asdict(record)
    data.pop("content_id")
    return digest(data)


def validate_record(record, cls):
    if type(record) is not cls:
        raise ValueError("concrete frozen record required")
    try:
        rebuilt = cls(**{field.name: getattr(record, field.name) for field in fields(cls)})
    except (AttributeError, TypeError) as error:
        raise ValueError("malformed record") from error
    if record != rebuilt or record.content_id != rebuilt.content_id:
        raise ValueError("noncanonical or modified record")
    return rebuilt


def scope_tuple(value):
    result = sequence(value, 8, 8)
    for item in result:
        identity(item)
    return result


@dataclass(frozen=True)
class FusionContract:
    scope: tuple = (
        "fusion-v1",
        "corpus-v1",
        "query-policy-v1",
        "bm25-v1",
        "dense-v1",
        "embedding-v1",
        "evaluation-v1",
        "source-v1",
    )
    rrf_k: int = 60
    max_rank: int = 100
    top_k: int = 3
    retrievers: tuple = RETRIEVERS
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        count(self.rrf_k, 1, 10_000)
        count(self.max_rank, 1, 10_000)
        count(self.top_k, 1, self.max_rank)
        retrievers = sequence(self.retrievers, 2, 2)
        if any(type(item) is not str for item in retrievers) or retrievers != RETRIEVERS:
            raise ValueError("exact lexical and dense retrievers required")
        object.__setattr__(self, "retrievers", retrievers)
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("fusion contract digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class RankedHit:
    scope: tuple
    query_id: str
    retriever: str
    document_id: str
    revision: str
    content_sha256: str
    rank: int
    raw_score: float
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        for value in (self.query_id, self.document_id, self.revision):
            identity(value)
        if type(self.retriever) is not str or self.retriever not in RETRIEVERS:
            raise ValueError("exact retriever name required")
        sha256_text(self.content_sha256)
        count(self.rank, 1, 10_000)
        number(self.raw_score, -1e9, 1e9)
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("ranked hit digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class RetrievalRun:
    scope: tuple
    query_id: str
    query_sha256: str
    retriever: str
    hits: tuple
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        identity(self.query_id)
        sha256_text(self.query_sha256)
        if type(self.retriever) is not str or self.retriever not in RETRIEVERS:
            raise ValueError("exact retriever name required")
        hits = sequence(self.hits, 1, 100)
        copies = tuple(validate_record(hit, RankedHit) for hit in hits)
        if any(
            hit.scope != self.scope
            or hit.query_id != self.query_id
            or hit.retriever != self.retriever
            for hit in copies
        ):
            raise ValueError("hit is outside run scope")
        if tuple(hit.rank for hit in copies) != tuple(range(1, len(copies) + 1)):
            raise ValueError("ranks must be unique and contiguous")
        if len({hit.document_id for hit in copies}) != len(copies):
            raise ValueError("duplicate document in one run")
        object.__setattr__(self, "hits", copies)
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("retrieval run digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class FusionReport:
    status: str
    ordered_document_ids: tuple
    fused_scores: tuple
    evidence_id: str
    claim: str = "ILLUSTRATIVE_FUSION_NOT_RETRIEVAL_BENCHMARK"


def fuse_rankings(contract: FusionContract, runs) -> FusionReport:
    """Fuse rank positions only; raw lexical and dense scores never share a scale."""
    contract = validate_record(contract, FusionContract)
    runs = sequence(runs, 2, 2)
    runs = tuple(validate_record(run, RetrievalRun) for run in runs)
    if tuple(run.retriever for run in runs) != contract.retrievers:
        raise ValueError("runs must follow the declared retriever order")
    if any(run.scope != contract.scope for run in runs):
        raise ValueError("retrieval run scope mismatch")
    if len({(run.query_id, run.query_sha256) for run in runs}) != 1:
        raise ValueError("runs must bind the same exact query")
    if any(len(run.hits) > contract.max_rank for run in runs):
        raise ValueError("retrieval run exceeds fusion depth")

    versions = {}
    ranks = {}
    for run in runs:
        for hit in run.hits:
            identity_pair = (hit.revision, hit.content_sha256)
            if hit.document_id in versions and versions[hit.document_id] != identity_pair:
                raise ValueError("cross-index document revision mismatch")
            versions[hit.document_id] = identity_pair
            ranks.setdefault(hit.document_id, {})[run.retriever] = hit.rank

    scored = []
    for document_id, document_ranks in ranks.items():
        score = math.fsum(
            1.0 / (contract.rrf_k + rank) for rank in document_ranks.values()
        )
        best_rank = min(document_ranks.values())
        scored.append((document_id, score, best_rank))
    scored.sort(key=lambda item: (-item[1], item[2], item[0]))
    selected = scored[: contract.top_k]
    evidence_id = digest(
        {
            "contract": contract.content_id,
            "runs": [run.content_id for run in runs],
            "selected": [(item[0], item[1]) for item in selected],
        }
    )
    return FusionReport(
        "FUSED_FOR_EVALUATION",
        tuple(item[0] for item in selected),
        tuple(item[1] for item in selected),
        evidence_id,
    )


def illustrative_fixture():
    contract = FusionContract()
    query_id = "query-1"
    query_sha = digest("how does hybrid retrieval fuse ranks")
    documents = {
        name: ("rev-1", digest({"document": name, "revision": "rev-1"}))
        for name in ("doc-a", "doc-b", "doc-c", "doc-d")
    }

    def run(retriever, ordered):
        hits = tuple(
            RankedHit(
                contract.scope,
                query_id,
                retriever,
                document_id,
                documents[document_id][0],
                documents[document_id][1],
                rank,
                raw_score,
            )
            for rank, (document_id, raw_score) in enumerate(ordered, start=1)
        )
        return RetrievalRun(
            contract.scope, query_id, query_sha, retriever, hits
        )

    lexical = run("lexical", (("doc-a", 12.4), ("doc-b", 8.1), ("doc-c", 4.2)))
    dense = run("dense", (("doc-c", 0.92), ("doc-a", 0.83), ("doc-d", 0.76)))
    return contract, (lexical, dense)


def main():
    report = fuse_rankings(*illustrative_fixture())
    print("example=illustrative_only")
    print(f"status={report.status}")
    print("order=" + ",".join(report.ordered_document_ids))
    print("scores=" + ",".join(f"{score:.6f}" for score in report.fused_scores))
    print(f"claim={report.claim}")


if __name__ == "__main__":
    main()