#!/usr/bin/env python3
import argparse
import json
import random
from pathlib import Path
from typing import Dict, List


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Prepare SciTLDR Unsloth chat-format dataset with balanced A/AIC/FullText."
    )
    parser.add_argument(
        "--scitldr-root",
        type=Path,
        default=Path("/d/hpc/projects/FRI/DL/Scholar/raw_downloads/scitldr"),
    )
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=Path("/d/hpc/projects/FRI/DL/Scholar/prepared_datasets/scitldr_unsloth"),
    )
    parser.add_argument(
        "--target-policy",
        choices=["first", "all"],
        default="first",
        help="Use first target per paper, or create one sample per target.",
    )
    parser.add_argument("--seed", type=int, default=42)
    return parser.parse_args()


def read_jsonl(path: Path) -> List[Dict]:
    rows: List[Dict] = []
    with path.open("r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            rows.append(json.loads(line))
    return rows


def build_user_text(title: str, source_sentences: List[str]) -> str:
    content = "\n".join(s.strip() for s in source_sentences if isinstance(s, str) and s.strip())
    return (
        "Write a concise one-sentence TLDR summary of the scientific paper content below.\n\n"
        f"Title: {title}\n\n"
        f"Paper content:\n{content}"
    )


def make_rows(split: str, variant: str, records: List[Dict], target_policy: str) -> List[Dict]:
    out: List[Dict] = []
    for rec in records:
        targets = rec.get("target", []) or []
        if not targets:
            continue
        title = rec.get("title", "")
        source = rec.get("source", []) or []
        base_user = build_user_text(title=title, source_sentences=source)
        if target_policy == "first":
            target_items = [(0, targets[0])]
        else:
            target_items = list(enumerate(targets))

        for target_idx, target_text in target_items:
            out.append(
                {
                    "messages": [
                        {"role": "user", "content": [{"type": "text", "text": base_user}]},
                        {"role": "assistant", "content": [{"type": "text", "text": target_text.strip()}]},
                    ],
                    "meta": {
                        "dataset": "scitldr",
                        "split": split,
                        "source_variant": variant,
                        "paper_id": rec.get("paper_id", ""),
                        "target_index": target_idx,
                        "num_targets": len(targets),
                        "ic": bool(rec.get("ic", False)),
                    },
                }
            )
    return out


def balanced_sample(rows_by_variant: Dict[str, List[Dict]], seed: int) -> List[Dict]:
    rng = random.Random(seed)
    min_len = min(len(v) for v in rows_by_variant.values())
    selected: List[Dict] = []
    for variant, rows in rows_by_variant.items():
        rows_copy = rows[:]
        rng.shuffle(rows_copy)
        selected.extend(rows_copy[:min_len])
    rng.shuffle(selected)
    return selected


def write_jsonl(path: Path, rows: List[Dict]) -> None:
    with path.open("w", encoding="utf-8") as f:
        for r in rows:
            f.write(json.dumps(r, ensure_ascii=False) + "\n")


def counts_by_variant(rows: List[Dict]) -> Dict[str, int]:
    variants = ["A", "AIC", "FullText"]
    return {v: sum(1 for r in rows if r["meta"]["source_variant"] == v) for v in variants}


def main() -> None:
    args = parse_args()
    args.output_dir.mkdir(parents=True, exist_ok=True)

    variants = ["A", "AIC", "FullText"]
    train_rows_by_variant: Dict[str, List[Dict]] = {}
    val_rows_by_variant: Dict[str, List[Dict]] = {}

    for variant in variants:
        train_in = args.scitldr_root / variant / "train.jsonl"
        dev_in = args.scitldr_root / variant / "dev.jsonl"
        train_records = read_jsonl(train_in)
        dev_records = read_jsonl(dev_in)
        train_rows_by_variant[variant] = make_rows("train", variant, train_records, args.target_policy)
        val_rows_by_variant[variant] = make_rows("validation", variant, dev_records, args.target_policy)

    train_rows = balanced_sample(train_rows_by_variant, seed=args.seed)
    val_rows = balanced_sample(val_rows_by_variant, seed=args.seed)

    train_out = args.output_dir / "train.jsonl"
    val_out = args.output_dir / "validation.jsonl"
    stats_out = args.output_dir / "stats.json"
    write_jsonl(train_out, train_rows)
    write_jsonl(val_out, val_rows)

    stats = {
        "seed": args.seed,
        "target_policy": args.target_policy,
        "train": {
            "rows": len(train_rows),
            "variant_counts": counts_by_variant(train_rows),
            "pre_balance_variant_rows": {k: len(v) for k, v in train_rows_by_variant.items()},
        },
        "validation": {
            "rows": len(val_rows),
            "variant_counts": counts_by_variant(val_rows),
            "pre_balance_variant_rows": {k: len(v) for k, v in val_rows_by_variant.items()},
        },
        "paths": {
            "train_jsonl": str(train_out),
            "validation_jsonl": str(val_out),
            "stats_json": str(stats_out),
        },
    }
    with stats_out.open("w", encoding="utf-8") as f:
        json.dump(stats, f, ensure_ascii=False, indent=2)
    print(json.dumps(stats, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()