#!/usr/bin/env python3
"""Validate teacher-generated records and emit safe, split-separated SFT JSONL.

This is intentionally stdlib-only. It does not load models, contact a teacher,
download data, or execute tools. A separate, trusted producer must write the
candidate JSONL and a human/external checker must set ``quality_pass``.
"""

from __future__ import annotations

import argparse
import hashlib
import json
from pathlib import Path
from typing import Any


REQUIRED = {
    "id",
    "split",
    "task_key",
    "prompt",
    "teacher_response",
    "teacher_model",
    "teacher_revision",
    "quality_pass",
}
ALLOWED_SPLITS = {"train", "eval"}
PRIVATE_KEYS = {
    "analysis",
    "chain_of_thought",
    "cot",
    "private_reasoning",
    "reasoning",
    "reasoning_content",
    "scratchpad",
}


class DatasetError(ValueError):
    """Raised when a candidate record violates the distillation contract."""


def _reject_reasoning_fields(value: Any) -> None:
    if isinstance(value, dict):
        if PRIVATE_KEYS.intersection(value):
            raise DatasetError("private reasoning field detected")
        for item in value.values():
            _reject_reasoning_fields(item)
    elif isinstance(value, list):
        for item in value:
            _reject_reasoning_fields(item)


def _fingerprint(prompt: str) -> str:
    payload = json.dumps(
        {"prompt": " ".join(prompt.split())},
        sort_keys=True,
        ensure_ascii=False,
        separators=(",", ":"),
    ).encode("utf-8")
    return hashlib.sha256(payload).hexdigest()


def _read_records(path: Path) -> list[dict[str, Any]]:
    records: list[dict[str, Any]] = []
    for line_no, raw in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
        if not raw.strip():
            continue
        try:
            record = json.loads(raw)
        except json.JSONDecodeError as exc:
            raise DatasetError(f"line {line_no}: invalid JSON: {exc.msg}") from exc
        if not isinstance(record, dict):
            raise DatasetError(f"line {line_no}: record must be a JSON object")
        record["_line_no"] = line_no
        records.append(record)
    if not records:
        raise DatasetError("input contains no records")
    return records


def validate_records(records: list[dict[str, Any]]) -> list[dict[str, Any]]:
    """Validate and return records in deterministic ID order.

    Both task keys and normalized prompt fingerprints must be disjoint across
    train/eval. Fingerprints catch whitespace-normalized exact duplicates,
    not semantic near-duplicates.
    """

    seen_ids: set[str] = set()
    seen_by_split: dict[str, dict[str, str]] = {"train": {}, "eval": {}}
    validated: list[dict[str, Any]] = []
    for record in records:
        record = dict(record)
        line_no = record.pop("_line_no", "?")
        _reject_reasoning_fields(record)
        missing = sorted(REQUIRED - record.keys())
        if missing:
            raise DatasetError(f"line {line_no}: missing fields: {', '.join(missing)}")
        if PRIVATE_KEYS.intersection(record):
            keys = sorted(PRIVATE_KEYS.intersection(record))
            raise DatasetError(f"line {line_no}: private reasoning field(s): {', '.join(keys)}")
        if not isinstance(record["id"], str) or not record["id"].strip():
            raise DatasetError(f"line {line_no}: id must be a non-empty string")
        if record["id"] in seen_ids:
            raise DatasetError(f"line {line_no}: duplicate id {record['id']!r}")
        seen_ids.add(record["id"])
        split = record["split"]
        if split not in ALLOWED_SPLITS:
            raise DatasetError(f"line {line_no}: split must be train or eval")
        for field in ("task_key", "prompt", "teacher_response", "teacher_model", "teacher_revision"):
            if not isinstance(record[field], str) or not record[field].strip():
                raise DatasetError(f"line {line_no}: {field} must be a non-empty string")
        if any(tag in record["teacher_response"].lower() for tag in ("<think", "</think")):
            raise DatasetError(f"line {line_no}: private reasoning marker detected")
        if record["quality_pass"] is not True:
            raise DatasetError(f"line {line_no}: quality_pass must be true")
        fp = _fingerprint(record["prompt"])
        if record["task_key"] in seen_by_split[split]:
            raise DatasetError(f"line {line_no}: duplicate task_key in {split}: {record['task_key']!r}")
        if fp in seen_by_split[split].values():
            raise DatasetError(f"line {line_no}: duplicate prompt in {split}")
        seen_by_split[split][record["task_key"]] = fp
        validated.append(record)

    train_tasks = {r["task_key"] for r in validated if r["split"] == "train"}
    eval_tasks = {r["task_key"] for r in validated if r["split"] == "eval"}
    if overlap := sorted(train_tasks & eval_tasks):
        raise DatasetError(f"train/eval task_key contamination: {', '.join(overlap)}")
    train_fp = {_fingerprint(r["prompt"]) for r in validated if r["split"] == "train"}
    eval_fp = {_fingerprint(r["prompt"]) for r in validated if r["split"] == "eval"}
    if train_fp & eval_fp:
        raise DatasetError("train/eval normalized prompt contamination")
    return sorted(validated, key=lambda r: r["id"])


def _student_record(record: dict[str, Any]) -> dict[str, Any]:
    """Drop producer-only fields and make an OpenAI-compatible SFT row."""

    return {
        "id": record["id"],
        "messages": [
            {"role": "user", "content": record["prompt"]},
            {"role": "assistant", "content": record["teacher_response"]},
        ],
        "metadata": {
            "task_key": record["task_key"],
            "teacher_model": record["teacher_model"],
            "teacher_revision": record["teacher_revision"],
        },
    }


def prepare(input_path: Path, output_dir: Path) -> dict[str, Any]:
    records = validate_records(_read_records(input_path))
    if any(not any(r["split"] == split for r in records) for split in ALLOWED_SPLITS):
        raise DatasetError("both train and eval splits must be non-empty")
    if output_dir.exists() and any(output_dir.iterdir()):
        raise DatasetError("output directory must be absent or empty; refusing overwrite")
    output_dir.mkdir(parents=True, exist_ok=True)
    counts: dict[str, int] = {}
    output_sha256: dict[str, str] = {}
    for split in sorted(ALLOWED_SPLITS):
        rows = [_student_record(r) for r in records if r["split"] == split]
        if not rows:
            raise DatasetError(f"split {split} is empty")
        destination = output_dir / f"{split}.jsonl"
        payload = "".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows)
        destination.write_text(payload, encoding="utf-8")
        counts[split] = len(rows)
        output_sha256[split] = hashlib.sha256(payload.encode("utf-8")).hexdigest()

    manifest = {
        "format": "openai-compatible-sft-messages",
        "source": str(input_path),
        "record_count": len(records),
        "counts": counts,
        "ids": [r["id"] for r in records],
        "output_sha256": output_sha256,
        "known_reasoning_fields_and_think_markers_rejected": True,
        "semantic_content_audited": False,
        "quality_pass_is_producer_assertion": True,
        "tool_execution": False,
    }
    (output_dir / "manifest.json").write_text(
        json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
        encoding="utf-8",
    )
    return manifest


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--input", type=Path, required=True)
    parser.add_argument("--output-dir", type=Path, required=True)
    args = parser.parse_args()
    try:
        manifest = prepare(args.input, args.output_dir)
    except (OSError, DatasetError) as exc:
        parser.error(str(exc))
    print(json.dumps(manifest, ensure_ascii=False, sort_keys=True))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())
