"""Reviewed Kimi K3 native self-benchmark import contract.

DCP overlaps the TP group and is recorded explicitly in the v6 identity.
The reviewed original and sanitized source hashes bind every imported point.
"""
from __future__ import annotations

import hashlib
import json
import math
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq

POLICY = "dynamo-selfbench-kimi-k3-20260916-v1"
CAMPAIGN = "kimi-k3-selfbench-20260916"
SCHEMA_NAME = "aic_fpm_forward_perf"
SCHEMA_VERSION = 6
METHOD = "dynamo_native_self_benchmark"
LEAF = "data/moonshotai--Kimi-K3/gb300/vllm/0.29.0/tp8-dcp8"
# Original SHA-256, Dynamo revision, row count, reviewed sanitized SHA-256.
SOURCES = {
    "2201004": (
        "9e902768fc79f03aaa78554baf05a9ef3a7a47eae08ca2460a0109dec81bb010",
        "54174204af65eec5661fb1ba451c19012dac9306",
        451,
        "b1d5ba27b6b6a643cdfe1f8c052d249707722077b9d75d1a0767141da19b90a3",
    ),
    "2209472": (
        "da7a7611d9ee166c1f16dde5610e42cfa2f94f4284078ac28d0418899223c2e9",
        "e8382179d91636626e7844b2da9f99066af2f639",
        288,
        "38e875570738119c8f6b13d5ed76c2b960d85341e7e36d6d04e7afbdc0dbe1ae",
    ),
}
IDENTITY = {
    "model_id": "moonshotai/Kimi-K3",
    "model_revision": None,
    "system": "gb300",
    "gpu_family": "GB300",
    "framework": "vllm",
    "framework_version": "0.29.0",
    "parallelism": "tp8-dcp8",
    "parallel_strategy": "pure_tp",
    "tp": 8,
    "pp": 1,
    "dp": 1,
    "moe_tp": 8,
    "moe_ep": 1,
    "cp": 1,
    "dcp": 8,
    "physical_gpu_count": 8,
    "weight_quantization": "mxfp4",
    "kv_cache_dtype": "fp8",
    "collection_method": METHOD,
}


# The sidecar uses canonical FPM fields, not the richer manifest identity.
FPM_SELECTOR = {
    "model_path": IDENTITY["model_id"],
    "system": IDENTITY["system"],
    "backend": IDENTITY["framework"],
    "backend_version": IDENTITY["framework_version"],
    **{
        key: IDENTITY[key]
        for key in (
            "weight_quantization",
            "kv_cache_dtype",
            "parallel_strategy",
            "tp",
            "pp",
            "dp",
            "moe_tp",
            "moe_ep",
            "cp",
            "dcp",
        )
    },
}


def read(path: Path):
    return json.loads(path.read_text())


def sha(path: Path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def require(condition, message):
    if not condition:
        raise ValueError(message)


def checked_file(root: Path, record):
    path = root / record["path"]
    require(
        path.resolve().is_relative_to(root.resolve()), "provenance path escapes dataset"
    )
    require(sha(path) == record["sha256"], f"source hash mismatch: {path}")
    return path


def arrow_schema(root):
    spec = read(root / "schemas/aisim-fpm-forward-v6.schema.json")
    types = {
        "string": pa.string(),
        "int64": pa.int64(),
        "float64": pa.float64(),
        "bool": pa.bool_(),
    }
    return pa.schema(
        [
            pa.field(f["name"], types[f["arrow_type"]], nullable=f["nullable"])
            for f in spec["fields"]
        ]
    )


def classify(point, regime):
    rows = point.get("rows")
    balanced = not point.get("partition") and (
        not rows or len({tuple(r) for r in rows}) == 1
    )
    if regime == "fake_attention_kv_random_kda":
        return "synthetic_attention_boundary"
    return "primary" if balanced else "nonuniform_prefill"


def canonical_row(source, entry):
    point = entry["point"]
    fpm = entry["fpms"][0]
    repeats = fpm.get("kvwarm_giant_median_of", 1)
    return {
        "cell_id": "kimi-k3-gb300-vllm-0.29.0-tp8-dcp8",
        "model_path": IDENTITY["model_id"],
        "system": "gb300",
        "backend": "vllm",
        "backend_version": "0.29.0",
        "weight_quantization": "mxfp4",
        "gemm_quant_mode": "bfloat16",
        "moe_quant_mode": "w4a16_mxfp4",
        "fmha_quant_mode": None,
        "fmha_resolution": "runtime_not_resolved",
        "comm_quant_mode": None,
        "kv_cache_dtype": "fp8",
        "parallel_strategy": "pure_tp",
        "tp": 8,
        "pp": 1,
        "dp": 1,
        "moe_tp": 8,
        "moe_ep": 1,
        "cp": 1,
        "dcp": 8,
        "moe_backend": "auto",
        "attention_backend": "FLASHINFER_MLA",
        "enable_wideep": False,
        "enable_eplb": False,
        "workload_kind": point["point_type"],
        "batch_size": point["batch_size"],
        "total_prefill_tokens": point["total_prefill_tokens"],
        "total_kv_read_tokens": point["total_kv_read_tokens"],
        "partition_policy": "balanced_v1",
        "kv_seed_regime": entry["kv_seed_regime"],
        "latency_ms": fpm["wall_time"] * 1000,
        "global_warmup_iterations": source["config"]["warmup_iterations"],
        "warmup_repeats": None,
        "measurement_repeats": repeats,
        "measurement_policy": "kvwarm_median_of_3"
        if repeats == 3
        else "dynamo_native_single_sample_v1",
        "model_support_level": None,
        "model_template_id": None,
        "model_template_version": None,
        "aic_database_version": None,
        "source_plan_sha256": None,
        "collector_attempt_id": None,
        "runtime_run_id": source["run_id"],
        "runtime_grid_digest": source["grid_digest"],
    }


def validate_sources(root: Path, provenance):
    require(
        provenance["policy_id"] == POLICY, "unreviewed self-benchmark import policy"
    )
    require(
        provenance["source_kind"] == "self_benchmark", "wrong collection source kind"
    )
    require(provenance["collection_method"] == METHOD, "wrong collection method")
    require(provenance["timing_scope"] == "scheduler_wall_time", "wrong latency scope")
    require(
        provenance["independent_evaluation_truth"] is False,
        "calibration is not independent truth",
    )
    require(
        {s["job_id"] for s in provenance["sources"]} == set(SOURCES),
        "unexpected source set",
    )
    outputs = {
        "primary": [],
        "synthetic_attention_boundary": [],
        "nonuniform_prefill": [],
    }
    seen = set()
    for record in provenance["sources"]:
        original_hash, commit, count, sanitized_hash = SOURCES[record["job_id"]]
        require(
            record["original_sha256"] == original_hash
            and record["dynamo_commit"] == commit,
            "unreviewed source revision",
        )
        source_path = checked_file(root, record)
        require(
            sha(source_path) == sanitized_hash,
            f"source differs from reviewed sanitized bytes: {record['job_id']}",
        )
        data = read(source_path)
        require(
            data["status"] == "complete"
            and data["valid"]
            and data["usable"]
            and data["timing_valid"],
            "incomplete source",
        )
        require(
            not data["error"] and not data["skipped_points"],
            "source has skipped/failed points",
        )
        require(
            len(data["results"]) == len(data["iteration_groups"]) == count,
            "source count mismatch",
        )
        require(
            data["coverage"]["completed_points"] == count, "source coverage mismatch"
        )
        require(
            data["limits"]["max_num_running_reqs"] == 32
            and data["limits"]["max_model_len"] == 1048576,
            "engine limit mismatch",
        )
        require(
            data["recurrent_state"]
            == {
                "initialization": "random",
                "policy": "uniform-request-layer-rank-v1",
                "uniform_bound": 0.01,
            },
            "unknown KDA state policy",
        )
        for entry, group in zip(data["results"], data["iteration_groups"]):
            point = entry["point"]
            require(
                group["benchmark_id"] == point["benchmark_id"], "benchmark ID mismatch"
            )
            require(len(entry["fpms"]) == 1, "expected one attention-DP observation")
            fpm = entry["fpms"][0]
            phase, batch = point["point_type"], point["batch_size"]
            require(fpm["dp_rank"] == 0, "unexpected attention-DP rank")
            require(
                phase in ("prefill", "decode") and 0 < batch <= 32,
                "invalid phase or batch",
            )
            require(
                math.isfinite(fpm["wall_time"]) and fpm["wall_time"] > 0,
                "invalid latency",
            )
            require(
                fpm.get("kvwarm_giant_median_of", 1) in (1, 3),
                "unexpected repeat policy",
            )
            metrics = fpm["scheduled_requests"]
            require(
                metrics[f"num_{phase}_requests"] == batch, "scheduled batch mismatch"
            )
            require(
                metrics["sum_prefill_tokens"] == point["total_prefill_tokens"],
                "scheduled prefill mismatch",
            )
            kv_field = (
                "sum_decode_kv_tokens" if phase == "decode" else "sum_prefill_kv_tokens"
            )
            require(
                metrics[kv_field] == point["total_kv_read_tokens"],
                "scheduled KV mismatch",
            )
            require(
                group["point"] == point
                and group["complete"]
                and group["expected_dp_ranks"] == [0],
                "invalid synchronization",
            )
            require(
                group["rank_results"] == [{"dp_rank": 0, "fpms": entry["fpms"]}]
                and group["wall_time"] == fpm["wall_time"],
                "rank timing mismatch",
            )
            if phase == "decode":
                require(
                    entry["kv_seed_regime"]
                    in ("real_attention_kv_random_kda", "fake_attention_kv_random_kda"),
                    "unknown decode KV regime",
                )
            else:
                require(
                    entry["kv_seed_regime"] in ("not_applicable", "real_prefix"),
                    "unknown prefill KV regime",
                )
            key = (data["run_id"], point["benchmark_id"])
            require(key not in seen, "duplicate source point")
            seen.add(key)
            classification = classify(point, entry["kv_seed_regime"])
            if classification == "nonuniform_prefill":
                require(
                    phase == "prefill" and point["rows"],
                    "nonuniform point needs explicit prefill rows",
                )
                require(
                    len(point["rows"]) == batch
                    and sum(r[0] for r in point["rows"])
                    == point["total_prefill_tokens"]
                    and sum(r[1] for r in point["rows"])
                    == point["total_kv_read_tokens"],
                    "nonuniform rows disagree with totals",
                )
                outputs[classification].append(
                    {
                        "runtime_run_id": data["run_id"],
                        "source_job_id": record["job_id"],
                        "result": entry,
                    }
                )
            else:
                outputs[classification].append(canonical_row(data, entry))
    require(
        {k: len(v) for k, v in outputs.items()}
        == {
            "primary": 669,
            "synthetic_attention_boundary": 14,
            "nonuniform_prefill": 56,
        },
        "classification count mismatch",
    )
    for key in ("primary", "synthetic_attention_boundary"):
        coords = [
            tuple(
                r[k]
                for k in (
                    "workload_kind",
                    "batch_size",
                    "total_prefill_tokens",
                    "total_kv_read_tokens",
                )
            )
            for r in outputs[key]
        ]
        require(len(set(coords)) == len(coords), "duplicate canonical coordinates")
    return outputs


def validate_snapshot(root: Path, manifest):
    require(manifest["configuration_path"] == LEAF, "unreviewed self-benchmark leaf")
    require(
        all(manifest.get(k) == v for k, v in IDENTITY.items()),
        "DCP configuration identity mismatch",
    )
    require(
        manifest["tp"] * manifest["pp"] * manifest["dp"] * manifest["cp"]
        == manifest["physical_gpu_count"],
        "DCP must not multiply GPU count",
    )
    require(manifest["tp"] % manifest["dcp"] == 0, "DCP must divide TP")
    require(
        manifest["measurements"]["file_count"] == 0
        and manifest["measurements"]["protocol_id"] is None,
        "self-calibration cannot be independent measurement truth",
    )
    provenance_path = root / LEAF / "fpm/provenance/import.json"
    provenance = read(provenance_path)
    expected = validate_sources(root, provenance)
    engine = read(root / LEAF / "fpm/provenance/engine-config.json")
    require(
        engine["physical_gpu_count"] == 8 and engine["model_runner"] == "V1",
        "engine topology/runner mismatch",
    )
    require(
        engine["enable_expert_parallel"] is False
        and engine["speculative_decoding"] is False,
        "unexpected EP or speculation",
    )
    for key, value in {
        "tensor-parallel-size": "8",
        "pipeline-parallel-size": "1",
        "decode-context-parallel-size": "8",
        "max-num-seqs": "32",
        "max-model-len": "1048576",
        "kv-cache-dtype": "fp8",
    }.items():
        require(engine["flags"][key] == value, f"engine flag mismatch: {key}")
    require(
        len(manifest["fpm"]) == 2, "expected primary and synthetic-boundary libraries"
    )
    claimed = {provenance_path.relative_to(root).as_posix()}
    claimed.update(s["path"] for s in provenance["sources"])
    for source in provenance["supporting_files"]:
        checked_file(root, source)
        claimed.add(source["path"])
    found_roles = set()
    for record in manifest["fpm"]:
        data_path = checked_file(root, record)
        metadata = read(root / record["metadata_path"])
        category = metadata["sample_classification"]
        require(
            category in ("primary", "synthetic_attention_boundary"),
            "invalid library class",
        )
        require(category not in found_roles, "duplicate library class")
        found_roles.add(category)
        require(
            metadata["schema_name"] == SCHEMA_NAME
            and metadata["schema_version"] == SCHEMA_VERSION,
            "wrong DCP schema",
        )
        require(
            metadata["import_policy"] == POLICY
            and metadata["collection_method"] == METHOD
            and metadata["source_kind"] == "self_benchmark",
            "missing collection policy",
        )
        require(
            metadata["provenance_sha256"] == sha(provenance_path),
            "import provenance hash mismatch",
        )
        require(
            record["role"] == ("primary" if category == "primary" else "comparator"),
            "synthetic data promoted to primary",
        )
        table = pq.read_table(data_path)
        require(
            table.schema.remove_metadata().equals(arrow_schema(root)),
            "physical DCP schema mismatch",
        )
        require(
            table.to_pylist() == expected[category], "published rows differ from source"
        )
        require(
            metadata["configuration_selector"] == FPM_SELECTOR,
            "metadata identity mismatch",
        )
    nonuniform = read(root / LEAF / "fpm/provenance/nonuniform-prefill.json")
    require(
        nonuniform == expected["nonuniform_prefill"],
        "nonuniform request layouts were changed",
    )
    return claimed


def validate_catalog_record(root: Path, record):
    metadata = read(root / record["metadata_path"])
    require(
        record["schema_name"] == SCHEMA_NAME
        and record["schema_version"] == SCHEMA_VERSION,
        "unreviewed external FPM schema",
    )
    require(
        record["configuration_path"] == LEAF
        and all(record.get(k) == v for k, v in IDENTITY.items()),
        "catalog DCP identity mismatch",
    )
    require(metadata["import_policy"] == POLICY, "catalog import policy mismatch")
    require(
        record.get("source_kind") == "self_benchmark"
        and record.get("timing_scope") == "scheduler_wall_time",
        "catalog method/timing mismatch",
    )
    manifest = read(root / LEAF / "manifest.json")
    entry = next(item for item in manifest["fpm"] if item["path"] == record["path"])
    for field in ("path", "metadata_path", "sha256", "row_count", "role", "phases"):
        require(record[field] == entry[field], f"catalog/manifest mismatch: {field}")
    catalog_row = next(
        row
        for row in pq.read_table(root / "catalog/fpm.parquet").to_pylist()
        if row["path"] == record["path"]
    )
    require(
        {k: v for k, v in catalog_row.items() if v is not None}
        == {k: v for k, v in record.items() if v is not None},
        "DCP catalog Parquet/JSON mismatch",
    )
    return SCHEMA_VERSION