"""Build deterministic proportional test/train splits from hybrid references."""

from __future__ import annotations

import argparse
import csv
import hashlib
import json
from collections import Counter, defaultdict
from datetime import date
from pathlib import Path
from typing import Any

from build_dataset_splits import SOURCE_RELATIVE_PATH, SOURCE_SHA256, sha256_file


CANONICAL_TASK_COUNT = 676
TEST_COUNT = 100
MIN_TEST_STEPS = 4
SELECTION_SEED = "hybrid-proportional-test-v2"


def read_jsonl(path: Path) -> list[dict[str, Any]]:
    with path.open(encoding="utf-8") as handle:
        return [json.loads(line) for line in handle if line.strip()]


def write_json(path: Path, payload: Any) -> None:
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")


def proportional_quotas(counts: Counter[int], sample_count: int) -> dict[int, int]:
    total = sum(counts.values())
    exact = {step: count * sample_count / total for step, count in counts.items()}
    quotas = {step: int(value) for step, value in exact.items()}
    remaining = sample_count - sum(quotas.values())
    order = sorted(counts, key=lambda step: (-(exact[step] - quotas[step]), step))
    for step in order[:remaining]:
        quotas[step] += 1
    return dict(sorted(quotas.items()))


def stable_rank(sample_id: str) -> str:
    return hashlib.sha256(f"{SELECTION_SEED}:{sample_id}".encode()).hexdigest()


def main() -> None:
    parser = argparse.ArgumentParser(description="Build proportional test/train splits")
    parser.add_argument(
        "--source-dir",
        default="dataset_splits/hybrid_beam256_exact30_v1",
    )
    parser.add_argument(
        "--output-dir",
        default="dataset_splits/hybrid_beam256_exact30_proportional_v2",
    )
    args = parser.parse_args()

    root = Path.cwd().resolve()
    source_dir = root / args.source_dir
    output_dir = root / args.output_dir
    tasks_path = root / SOURCE_RELATIVE_PATH
    results_path = source_dir / "hybrid_reference_results.jsonl"
    if sha256_file(tasks_path) != SOURCE_SHA256:
        raise RuntimeError("Canonical task SHA-256 mismatch")

    rows = read_jsonl(results_path)
    ids = [str(row["sample_id"]) for row in rows]
    if len(rows) != CANONICAL_TASK_COUNT or len(set(ids)) != CANONICAL_TASK_COUNT:
        raise RuntimeError("Hybrid references must contain exactly 676 unique tasks")

    by_step: dict[int, list[str]] = defaultdict(list)
    rows_by_id = {}
    for row in rows:
        sample_id = str(row["sample_id"])
        rows_by_id[sample_id] = row
        by_step[int(row["best_known_reference_steps"])].append(sample_id)

    overall = Counter({step: len(step_ids) for step, step_ids in by_step.items()})
    eligible = Counter({step: count for step, count in overall.items() if step >= MIN_TEST_STEPS})
    quotas = proportional_quotas(eligible, TEST_COUNT)
    test = sorted(
        sample_id
        for step, step_ids in by_step.items()
        if step >= MIN_TEST_STEPS
        for sample_id in sorted(step_ids, key=stable_rank)[: quotas[step]]
    )
    train = sorted(set(ids) - set(test))
    splits = {"test": test, "train": train}
    if len(test) != TEST_COUNT or len(train) != CANONICAL_TASK_COUNT - TEST_COUNT:
        raise RuntimeError("Split counts are incorrect")
    if set(test) & set(train) or set(test) | set(train) != set(ids):
        raise RuntimeError("Splits must cover every task exactly once")

    output_dir.mkdir(parents=True, exist_ok=True)
    split_version = "hybrid_beam256_exact30_proportional_v2"
    for name, sample_ids in splits.items():
        write_json(output_dir / f"{name}.json", {
            "split_version": split_version,
            "split_name": name,
            "count": len(sample_ids),
            "sample_ids": sample_ids,
        })

    assignment = {sample_id: name for name, sample_ids in splits.items() for sample_id in sample_ids}
    with (output_dir / "assignments.csv").open("w", encoding="utf-8", newline="") as handle:
        writer = csv.writer(handle)
        writer.writerow(["sample_id", "split", "best_known_reference_steps", "reference_source"])
        for sample_id in sorted(ids):
            row = rows_by_id[sample_id]
            writer.writerow([
                sample_id, assignment[sample_id], row["best_known_reference_steps"], row["reference_source"]
            ])

    split_distribution = {
        name: dict(sorted(Counter(
            int(rows_by_id[sample_id]["best_known_reference_steps"]) for sample_id in sample_ids
        ).items()))
        for name, sample_ids in splits.items()
    }
    manifest = {
        "split_version": split_version,
        "created_at": date.today().isoformat(),
        "canonical_tasks_file": SOURCE_RELATIVE_PATH,
        "canonical_tasks_sha256": SOURCE_SHA256,
        "canonical_task_count": CANONICAL_TASK_COUNT,
        "reference_results": str(results_path.relative_to(root)).replace("\\", "/"),
        "reference_results_sha256": sha256_file(results_path),
        "difficulty_name": "best_known_reference_steps; not a global optimality proof",
        "selection": {
            "test": "Hamilton largest-remainder proportional allocation across eligible reference-step strata",
            "test_eligibility": f"best_known_reference_steps >= {MIN_TEST_STEPS}",
            "within_stratum": "deterministic SHA-256 rank of selection seed and sample_id",
            "selection_seed": SELECTION_SEED,
            "train": "all remaining tasks",
            "challenge": "not used",
            "near_duplicate_policy": "ignored by design",
        },
        "split_counts": {name: len(sample_ids) for name, sample_ids in splits.items()},
        "overall_step_distribution": dict(sorted(overall.items())),
        "eligible_step_distribution": dict(sorted(eligible.items())),
        "test_step_quotas": quotas,
        "split_step_distribution": split_distribution,
        "files": {},
    }
    for path in sorted(output_dir.iterdir()):
        if path.name != "manifest.json":
            manifest["files"][path.name] = sha256_file(path)
    write_json(output_dir / "manifest.json", manifest)
    print(json.dumps({
        "split_counts": manifest["split_counts"],
        "overall_step_distribution": manifest["overall_step_distribution"],
        "test_step_quotas": quotas,
        "split_step_distribution": split_distribution,
    }, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()