from __future__ import annotations

import csv
import json
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any


def csv_count(path: Path) -> tuple[int, set[str]]:
    with path.open("r", encoding="utf-8", newline="") as stream:
        rows = list(csv.DictReader(stream))
    return len(rows), set(rows[0]) if rows else set()


def verify(config: dict[str, Any], results_dir: Path) -> dict[str, Any]:
    failures = []
    expected_runs = len(config["prompts"]) * int(config["campaign"]["replicates"]) * len(config["formats"])
    expected_per_format = len(config["prompts"]) * int(config["campaign"]["replicates"])
    expected_noise_groups = len(config["prompts"]) * int(config["campaign"]["replicates"])
    expected_trajectory_rows = (len(config["formats"]) - 1) * expected_per_format * int(config["controls"]["steps"]) * 2
    expected_weight_rows = (len(config["formats"]) - 1) * 430

    def require(condition: bool, message: str) -> None:
        if not condition:
            failures.append(message)

    manifest = json.loads((results_dir / "manifest.json").read_text(encoding="utf-8"))
    require(manifest["config_sha256"] == config["_config_sha256"], "Manifest configuration hash differs from current configuration")
    for name, expected in config["integrity"]["expected_sha256"].items():
        model = manifest["models"].get(name, {})
        require(model.get("sha256") == expected, f"Publisher hash mismatch or missing hash for {name}")
        require(model.get("publisher_hash_match") is True, f"Publisher match flag is not true for {name}")

    for name in ("preflight.json", "campaign_complete.json", "report_complete.json"):
        require((results_dir / name).is_file(), f"Missing completion marker {name}")
    require(json.loads((results_dir / "preflight.json").read_text(encoding="utf-8"))["passed"] is True, "Preflight marker is not passed")
    require(json.loads((results_dir / "campaign_complete.json").read_text(encoding="utf-8"))["scored_runs"] == expected_runs, f"Campaign marker does not declare {expected_runs} runs")
    if config.get("_base_results_dir"):
        require((results_dir / "extension_import.json").is_file(), "Extension import marker is missing")
        require((results_dir / "metrics" / "performance_bridge.json").is_file(), "Performance bridge evidence is missing")

    matrix = json.loads((results_dir / "run_matrix.json").read_text(encoding="utf-8"))
    require(len(matrix) == expected_runs, f"Run matrix has {len(matrix)} rows instead of {expected_runs}")
    require(len({row["run_id"] for row in matrix}) == expected_runs, "Run matrix contains duplicate run ids")
    counts = Counter(row["format_id"] for row in matrix)
    require(all(counts[format_id] == expected_per_format for format_id in config["formats"]), f"Format counts are wrong: {dict(counts)}")

    noise_groups = defaultdict(list)
    for row in matrix:
        directory = results_dir / "captures" / row["run_id"]
        required_files = ["metadata.json", "image.png", "decoded_float32.npy", "final_latent_float32.npy", "trajectory.npz"]
        require(all((directory / name).is_file() for name in required_files), f"Incomplete capture: {row['run_id']}")
        if (directory / "metadata.json").is_file():
            metadata = json.loads((directory / "metadata.json").read_text(encoding="utf-8"))
            require({"sampling", "vae_decode", "output"}.issubset(metadata), f"Metadata sections missing: {row['run_id']}")
            noise_groups[(row["prompt_id"], row["replicate"])].append(metadata["sampling"]["noise_sha256"])
    require(len(noise_groups) == expected_noise_groups, f"Expected {expected_noise_groups} prompt-seed noise groups, found {len(noise_groups)}")
    for key, values in noise_groups.items():
        require(len(values) == len(config["formats"]) and len(set(values)) == 1, f"Noise mismatch for {key}: {values}")

    for format_id in config["formats"]:
        hashes = []
        for repeat in range(3):
            metadata_path = results_dir / "captures" / f"repeatability__{format_id}__{repeat}" / "metadata.json"
            require(metadata_path.is_file(), f"Missing repeatability result {format_id}/{repeat}")
            if metadata_path.is_file():
                hashes.append(json.loads(metadata_path.read_text(encoding="utf-8"))["output"]["image_sha256"])
        require(len(hashes) == 3 and len(set(hashes)) == 1, f"Repeatability mismatch for {format_id}: {hashes}")

    expected_tables = {
        "image_core.csv": expected_runs,
        "image_advanced.csv": expected_runs,
        "latency_components.csv": expected_runs,
        "performance_runs.csv": expected_runs,
        "trajectory.csv": expected_trajectory_rows,
        "weight_parameters_all.csv": expected_weight_rows,
    }
    for name, expected_count in expected_tables.items():
        path = results_dir / "metrics" / name
        require(path.is_file(), f"Missing metric table {name}")
        if path.is_file():
            count, _ = csv_count(path)
            require(count == expected_count, f"Metric table {name} has {count} rows, expected {expected_count}")

    advanced_count, advanced_fields = csv_count(results_dir / "metrics" / "image_advanced.csv")
    required_advanced = {
        "lpips_alex",
        "lpips_vgg",
        "dists",
        "ms_ssim",
        "dinov2_large_image_cosine_to_bf16",
        "openclip_vith14_prompt_score",
        "pickscore_v1",
        "hpsv2_1",
        "pyiqa_musiq",
        "pyiqa_maniqa",
        "pyiqa_topiq_nr",
        "pyiqa_niqe",
        "pyiqa_brisque",
        "ocr_expected_phrase_exact_fraction",
    }
    require(required_advanced.issubset(advanced_fields), f"Advanced metric columns missing: {sorted(required_advanced - advanced_fields)}")

    for folder in ("full", "differences", "details"):
        count = len(list((results_dir / "comparison_sheets" / folder).glob("*.png")))
        require(count == 30, f"Comparison sheet folder {folder} has {count} PNGs instead of 30")
    require((results_dir / "comparison_sheets" / "contact_sheet_replicate0.png").is_file(), "Master contact sheet is missing")

    for format_id in config["formats"]:
        require((results_dir / "telemetry" / f"{format_id}.csv").is_file(), f"GPU telemetry missing for {format_id}")
        require((results_dir / "telemetry" / f"system_{format_id}.csv").is_file(), f"System telemetry missing for {format_id}")

    equivalence_path = results_dir / "validation" / "sampler_equivalence.json"
    require(equivalence_path.is_file(), "Sampler equivalence evidence is missing")
    if equivalence_path.is_file():
        equivalence = json.loads(equivalence_path.read_text(encoding="utf-8"))
        require(equivalence["latent_bit_exact"] and equivalence["image_bit_exact"], "Custom sampler is not bit-exact with standard KSampler")
        require(equivalence["latent_max_abs"] == 0.0 and equivalence["image_max_abs"] == 0.0, "Sampler equivalence has nonzero error")

    scored_errors = []
    with (results_dir / "runs.jsonl").open("r", encoding="utf-8") as stream:
        for line in stream:
            row = json.loads(line)
            if row.get("scored") and row.get("status") == "error":
                scored_errors.append(row["run_id"])
    require(not scored_errors, f"Scored run ledger contains errors: {scored_errors}")

    report_path = results_dir / "TECHNICAL_REPORT.md"
    require(report_path.is_file(), "Technical report is missing")
    if report_path.is_file():
        report = report_path.read_text(encoding="utf-8")
        for phrase in ("Best quantized BF16 fidelity", "INT8 ConvRot", "INT4 ConvRot", "GGUF Q8_0", "GGUF Q4_K_M", "OCR on prompts", "bit-identical", "Primary sources"):
            require(phrase in report, f"Technical report is missing required section/claim: {phrase}")

    workflows = [Path(config["_config_path"]).parent / "workflows" / "krea2_benchmark_api.json", Path(config["_config_path"]).parent / "workflows" / "krea2_benchmark_interactive.json"]
    has_gguf = any(fmt.startswith("gguf") for fmt in config.get("formats", {}))
    if has_gguf:
        workflows.extend([
            Path(config["_config_path"]).parent / "workflows" / "krea2_benchmark_api_gguf.json",
            Path(config["_config_path"]).parent / "workflows" / "krea2_benchmark_interactive_gguf.json"
        ])
    for workflow in workflows:
        require(workflow.is_file(), f"Workflow is missing: {workflow.name}")
        if workflow.is_file():
            json.loads(workflow.read_text(encoding="utf-8"))

    result = {
        "passed": not failures,
        "failures": failures,
        "scored_runs": len(matrix),
        "format_counts": dict(counts),
        "noise_groups": len(noise_groups),
        "metric_tables_checked": expected_tables,
        "advanced_metric_columns_checked": sorted(required_advanced),
        "comparison_sheet_groups": 30,
    }
    output_path = results_dir / "validation" / "completion_audit.json"
    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_path.write_text(json.dumps(result, indent=2, sort_keys=True), encoding="utf-8")
    if failures:
        raise RuntimeError("Completion audit failed:\n- " + "\n- ".join(failures))
    return result