#!/usr/bin/env python3
"""Export the published finite-audit results into deterministic flat CSV tables.

Python 3.10+, standard library only. The source JSON remains authoritative.
No simulation, training, or new evidence is created by this conversion.
"""
from __future__ import annotations

import argparse
import csv
import json
import math
from pathlib import Path


def compact(value: object) -> str:
    return json.dumps(value, ensure_ascii=False, separators=(",", ":"), allow_nan=False)


def require(condition: bool, message: str) -> None:
    if not condition:
        raise ValueError(message)


def tables(results: dict) -> dict[str, list[dict]]:
    """Validate source shape and produce five evaluation-fixture tables."""
    enumeration = results["enumeration"]
    rank = results["additive_rank_regime"]
    cue = results["delayed_cue_observability"]
    coherence = results["program_coherence"]
    interventions = results["nonunique_fillings"]["candidate_interventions"]
    require(enumeration["all_complexes_including_empty"] == 167, "Unexpected complex count")
    require(enumeration["nested_pairs"] == 7413, "Unexpected nested-pair count")
    require(enumeration["failures"] == 0 and rank["failures"] == 0, "Source reports audit failures")
    require(rank["seed"] == results["seed"] == 314159, "Unexpected random seed")
    require(rank["instances"] == len(rank["instances_detail"]) == 100, "Expected 100 rank-cover instances")
    require(len(interventions) == 4, "Expected four interventions")
    require(cue["one_bit_machine_count"] == len(cue["all_machines"]) == 16, "Expected 16 one-bit machines")
    require(len(coherence["programs"]) == 3, "Expected three coherent-program examples")

    rank_rows = []
    for item in rank["instances_detail"]:
        d = item["d"]
        require(d in (1, 2, 3, 4), "Unexpected vector-space dimension")
        require(len(item["blocks"]) == len(item["costs"]) == rank["candidates_per_instance"] == 6,
                "Candidate count mismatch")
        require(all(isinstance(c, int) and c > 0 for c in item["costs"]), "Nonpositive cost")
        require(all(isinstance(v, int) and 0 <= v < 2 ** d for block in item["blocks"] for v in block),
                "Vector bitmask outside its dimension")
        require(item["optimal_cost"] > 0 and math.isclose(item["ratio"], item["greedy_cost"] / item["optimal_cost"]),
                "Cost-ratio mismatch")
        require(item["ratio"] <= item["H_d"] + 1e-12, "Greedy harmonic bound fails")
        rank_rows.append({
            "id": f"rank-d{d}-i{item['instance']:02d}", "d": d, "instance": item["instance"],
            "blocks_json": compact(item["blocks"]), "costs_json": compact(item["costs"]),
            "optimal_cost": item["optimal_cost"], "greedy_cost": item["greedy_cost"],
            "ratio": item["ratio"], "H_d": item["H_d"], "H_d_exact": item["H_d_exact"],
            "greedy_order_json": compact(item["greedy_order"]), "seed": rank["seed"],
        })

    intervention_rows = [{
        "id": f"intervention-{item['name']}", "name": item["name"],
        "added_simplices_json": compact(item["added_simplices"]),
        "hits_one_witness_support": item["hits_one_witness_support"],
        "contains_one_complete_witness_support": item["contains_one_complete_witness_support"],
        "actually_kills_fixed_cycle": item["actually_kills_fixed_cycle"],
        "fillable_dimension_after": item["fillable_dimension_after"],
    } for item in interventions]

    cue_rows = []
    for item in cue["all_machines"]:
        encoder, decoder, outputs = item["cue_to_memory"], item["memory_to_action"], item["outputs_by_cue"]
        require(all(len(v) == 2 and all(x in (0, 1) for x in v) for v in (encoder, decoder, outputs)),
                "Malformed binary machine")
        require(outputs == [decoder[encoder[h]] for h in (0, 1)], "Machine-output mismatch")
        require(item["balanced_accuracy"] == sum(outputs[h] == h for h in (0, 1)) / 2,
                "Machine-accuracy mismatch")
        cue_rows.append({
            "id": f"cue-e{encoder[0]}{encoder[1]}-d{decoder[0]}{decoder[1]}",
            "encode_cue_0": encoder[0], "encode_cue_1": encoder[1],
            "decode_state_0": decoder[0], "decode_state_1": decoder[1],
            "output_cue_0": outputs[0], "output_cue_1": outputs[1],
            "balanced_accuracy": item["balanced_accuracy"],
            "perfect": item["balanced_accuracy"] == 1.0,
        })
    require(sum(row["perfect"] for row in cue_rows) == cue["perfect_one_bit_machine_count"] == 2,
            "Expected exactly two perfect machines")

    coherence_rows = [{
        "id": f"coherence-{item['program']}", "program": item["program"],
        "cost": item["cost"], "cost_is_stipulated": True, "betti_H1": item["betti_H1"],
        "fixed_square_cycle_is_boundary": item["fixed_square_cycle_is_boundary"],
        "example_budget": coherence["budget"],
        "affordable_at_example_budget": item["cost"] <= coherence["budget"],
    } for item in coherence["programs"]]

    audit_rows = []
    for suite, values, fields in (
        ("enumeration", enumeration, ("identity_checks", "boundary_squared_checks", "cycle_filling_witness_checks")),
        ("additive_rank_regime", rank, ("submodularity_checks", "monotonicity_checks", "quotient_residual_checks",
                                      "optimal_cover_enumerations", "weighted_greedy_bound_checks")),
    ):
        for field in fields:
            audit_rows.append({
                "id": f"audit-{suite}-{field}", "suite": suite, "metric": field,
                "check_count": values[field], "suite_failure_count": values["failures"],
                "source_json_pointer": f"/{suite}/{field}",
            })

    result = {"rank_cover": rank_rows, "interventions": intervention_rows, "delayed_cue": cue_rows,
              "program_coherence": coherence_rows, "audit_summary": audit_rows}
    for name, rows in result.items():
        require(len({row["id"] for row in rows}) == len(rows), f"Duplicate row IDs in {name}")
    return result


def write_tables(results: dict, output: Path) -> dict[str, int]:
    converted = tables(results)
    output.mkdir(parents=True, exist_ok=True)
    for name, rows in converted.items():
        with (output / f"{name}.csv").open("w", encoding="utf-8", newline="") as stream:
            writer = csv.DictWriter(stream, fieldnames=list(rows[0]), lineterminator="\n")
            writer.writeheader()
            writer.writerows({key: str(value).lower() if isinstance(value, bool) else value
                             for key, value in row.items()} for row in rows)
    return {name: len(rows) for name, rows in converted.items()}


def main() -> None:
    root = Path(__file__).resolve().parents[1]
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--source", type=Path, default=root / "experiments" / "results.json")
    parser.add_argument("--output", type=Path, default=root / "data")
    args = parser.parse_args()
    results = json.loads(args.source.read_text(encoding="utf-8"))
    counts = write_tables(results, args.output)
    print(json.dumps({"row_counts": counts, "total_rows": sum(counts.values())}, sort_keys=True))


if __name__ == "__main__":
    main()