#!/usr/bin/env python3
"""Measure evidence reads without running cases or changing acceptance status."""
import argparse
import json
import time
from datetime import datetime, timezone
from unittest.mock import patch

import business_acceptance as evidence
import run_business_acceptance as runner
from business_batching import module_batches


def measure(module, grouped):
    evidence.digest.cache_clear()
    evidence.module_inputs.cache_clear()
    rows = [row for row in evidence.requirements() if row["module"] == module]
    contract_path = evidence.ROOT / f"docs/business-acceptance/{module}.json"
    contract = evidence.read(contract_path)
    command = contract["command"]
    counts = {"jsonReads": 0, "evidenceReads": 0, "ledgerReads": 0}
    original_read = evidence.read
    def read(path):
        counts["jsonReads"] += 1
        counts["evidenceReads"] += int("business-evidence" in path.parts)
        counts["ledgerReads"] += int(path == evidence.LEDGER)
        return original_read(path)
    started = time.perf_counter()
    with patch.object(evidence, "read", side_effect=read), patch.object(runner, "read", side_effect=read):
        inputs = runner.case_inputs(contract_path, command, contract.get("dependencies", []))
        verified = evidence.accepted_ids(rows)
        entries = read(evidence.LEDGER).get("records", {}) if grouped else None
        reports = {} if grouped else None
        reusable = []
        for row in rows:
            if row["id"] not in verified:
                continue
            proofs = runner.reusable_reports([row], command, inputs, {}, {},
                **({"verified_ids": verified, "entries": entries, "reports": reports} if grouped else {}))
            if proofs:
                reusable.append(row["id"])
    return {**counts, "seconds": round(time.perf_counter() - started, 6),
            "currentPassed": len(verified), "reusableIds": sorted(reusable),
            "hashCache": evidence.digest.cache_info()._asdict()}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--module", default="Points")
    args = parser.parse_args()
    baseline = measure(args.module, False)
    optimized = measure(args.module, True)
    if baseline["reusableIds"] != optimized["reusableIds"]:
        raise AssertionError("Optimization changed evidence reuse decisions")
    batching = []
    for file in sorted((evidence.ROOT / "docs/business-acceptance").glob("*.json")):
        contract = evidence.read(file)
        ids = contract.get("coveredIds", [])
        batching.append({"module": file.stem, "ids": len(ids), "previousBatches": (len(ids)+7)//8,
                         "sharedOwnerBatches": len(list(module_batches(ids, contract)))})
    report = {"generatedAt": datetime.now(timezone.utc).isoformat(), "module": args.module,
              "scope": "Same-machine metadata/evidence benchmark, not browser/WASM compute throughput",
              "baselinePerId": baseline, "optimizedSharedReports": optimized, "batchPlan": batching,
              "sameReuseDecisions": True,
              "previousBatches": sum(row["previousBatches"] for row in batching),
              "sharedOwnerBatches": sum(row["sharedOwnerBatches"] for row in batching)}
    path = evidence.ROOT / "docs/current/acceptance-loading-benchmark.json"
    path.write_text(json.dumps(report, indent=2) + "\n")
    print(json.dumps(report))


if __name__ == "__main__":
    main()