"""Regression checks for DCP identity and synthetic calibration boundaries."""
from __future__ import annotations

import json
import shutil
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq
import pytest

import self_benchmark as contract

ROOT = Path(__file__).resolve().parents[1]


def test_published_sources_and_libraries_reconcile():
    manifest = contract.read(ROOT / contract.LEAF / "manifest.json")
    files = contract.validate_snapshot(ROOT, manifest)
    assert len(files) == 5


@pytest.mark.parametrize(
    "field,value", [("dcp", 1), ("cp", 8), ("physical_gpu_count", 64), ("moe_ep", 8)]
)
def test_rejects_conflating_dcp_with_other_parallel_dimensions(field, value):
    manifest = contract.read(ROOT / contract.LEAF / "manifest.json")
    manifest[field] = value
    with pytest.raises(ValueError, match="configuration identity mismatch"):
        contract.validate_snapshot(ROOT, manifest)


def test_rejects_calibration_as_independent_truth():
    manifest = contract.read(ROOT / contract.LEAF / "manifest.json")
    manifest["measurements"].update(
        file_count=1, protocol_id="forward-pass-measurement-v1"
    )
    with pytest.raises(ValueError, match="independent measurement truth"):
        contract.validate_snapshot(ROOT, manifest)


def test_rejects_synthetic_boundary_promoted_to_primary():
    manifest = contract.read(ROOT / contract.LEAF / "manifest.json")
    manifest["fpm"][1]["role"] = "primary"
    with pytest.raises(ValueError, match="synthetic data promoted"):
        contract.validate_snapshot(ROOT, manifest)


def test_rejects_latency_change_even_with_updated_parquet_hash(tmp_path):
    shutil.copytree(ROOT / contract.LEAF, tmp_path / contract.LEAF)
    shutil.copytree(ROOT / "schemas", tmp_path / "schemas")
    manifest = contract.read(tmp_path / contract.LEAF / "manifest.json")
    record = manifest["fpm"][0]
    path = tmp_path / record["path"]
    table = pq.read_table(path)
    values = table["latency_ms"].to_pylist()
    values[0] *= 1.1
    table = table.set_column(
        table.schema.get_field_index("latency_ms"),
        table.schema.field("latency_ms"),
        pa.array(values, type=pa.float64()),
    )
    pq.write_table(table, path)
    record["sha256"] = contract.sha(path)
    with pytest.raises(ValueError, match="published rows differ from source"):
        contract.validate_snapshot(tmp_path, manifest)


def test_rejects_nonuniform_layout_change_even_with_updated_source_hash(tmp_path):
    shutil.copytree(ROOT / contract.LEAF, tmp_path / contract.LEAF)
    shutil.copytree(ROOT / "schemas", tmp_path / "schemas")
    manifest = contract.read(tmp_path / contract.LEAF / "manifest.json")
    provenance_path = tmp_path / contract.LEAF / "fpm/provenance/import.json"
    provenance = contract.read(provenance_path)
    nonuniform_path = (
        tmp_path / contract.LEAF / "fpm/provenance/nonuniform-prefill.json"
    )
    rows = contract.read(nonuniform_path)
    rows[0]["result"]["point"]["rows"][0][0] += 1
    nonuniform_path.write_text(json.dumps(rows))
    for entry in provenance["supporting_files"]:
        if entry["path"] == nonuniform_path.relative_to(tmp_path).as_posix():
            entry["sha256"] = contract.sha(nonuniform_path)
    provenance_path.write_text(json.dumps(provenance))
    for entry in manifest["fpm"]:
        path = tmp_path / entry["metadata_path"]
        metadata = contract.read(path)
        metadata["provenance_sha256"] = contract.sha(provenance_path)
        path.write_text(json.dumps(metadata))
    with pytest.raises(ValueError, match="nonuniform request layouts were changed"):
        contract.validate_snapshot(tmp_path, manifest)


def test_catalog_writer_preserves_unchanged_nested_field_order(tmp_path):
    import manage_dataset as dataset

    path = tmp_path / "catalog.parquet"
    pq.write_table(
        pa.Table.from_pylist(
            [{"grouping": {"method": "pre_grouped", "authority": "producer"}}]
        ),
        path,
    )
    before = path.read_bytes()
    dataset.write_parquet(
        path, [{"grouping": {"authority": "producer", "method": "pre_grouped"}}]
    )
    assert path.read_bytes() == before


@pytest.mark.parametrize("job_id", ["2201004", "2209472"])
def test_rejects_resealed_source_and_output_tampering(tmp_path, job_id):
    shutil.copytree(ROOT / contract.LEAF, tmp_path / contract.LEAF)
    shutil.copytree(ROOT / "schemas", tmp_path / "schemas")
    manifest = contract.read(tmp_path / contract.LEAF / "manifest.json")
    provenance_path = tmp_path / contract.LEAF / "fpm/provenance/import.json"
    provenance = contract.read(provenance_path)
    source_record = next(s for s in provenance["sources"] if s["job_id"] == job_id)
    source_path = tmp_path / source_record["path"]
    data = contract.read(source_path)
    point = data["results"][0]["point"]
    data["results"][0]["fpms"][0]["wall_time"] *= 2
    data["iteration_groups"][0]["rank_results"][0]["fpms"][0]["wall_time"] *= 2
    data["iteration_groups"][0]["wall_time"] *= 2
    source_path.write_text(json.dumps(data))
    source_record["sha256"] = contract.sha(source_path)
    provenance_path.write_text(json.dumps(provenance))

    # Rewrite the matching output and all hashes consumed by validate_snapshot;
    # the source's claimed original hash and producer revision remain unchanged.
    entry = manifest["fpm"][0]
    parquet_path = tmp_path / entry["path"]
    table = pq.read_table(parquet_path)
    rows = table.to_pylist()
    index = next(
        i
        for i, row in enumerate(rows)
        if (
            row["runtime_run_id"] == data["run_id"]
            and row["batch_size"] == point["batch_size"]
            and row["total_prefill_tokens"] == point["total_prefill_tokens"]
            and row["total_kv_read_tokens"] == point["total_kv_read_tokens"]
        )
    )
    rows[index]["latency_ms"] *= 2
    pq.write_table(pa.Table.from_pylist(rows, schema=table.schema), parquet_path)
    entry["sha256"] = contract.sha(parquet_path)
    for record in manifest["fpm"]:
        metadata_path = tmp_path / record["metadata_path"]
        metadata = contract.read(metadata_path)
        metadata["parquet_sha256"] = record["sha256"]
        metadata["provenance_sha256"] = contract.sha(provenance_path)
        metadata_path.write_text(json.dumps(metadata))

    with pytest.raises(ValueError, match="reviewed sanitized bytes"):
        contract.validate_snapshot(tmp_path, manifest)


@pytest.mark.parametrize("change", ["missing_dcp", "wrong_dcp", "manifest_only_field"])
def test_sidecar_selector_requires_explicit_dcp_and_canonical_fields(tmp_path, change):
    shutil.copytree(ROOT / contract.LEAF, tmp_path / contract.LEAF)
    shutil.copytree(ROOT / "schemas", tmp_path / "schemas")
    manifest = contract.read(tmp_path / contract.LEAF / "manifest.json")
    path = tmp_path / manifest["fpm"][0]["metadata_path"]
    metadata = contract.read(path)
    selector = metadata["configuration_selector"]
    if change == "missing_dcp":
        del selector["dcp"]
    elif change == "wrong_dcp":
        selector["dcp"] = 1
    else:
        selector["physical_gpu_count"] = 8
    path.write_text(json.dumps(metadata))
    with pytest.raises(ValueError, match="metadata identity mismatch"):
        contract.validate_snapshot(tmp_path, manifest)