"""
Inspect locally-downloaded FineWeb2-HQ data.

The dataset is already on disk as parquet shards under:

    <data_root>/<language>/*.parquet

HuggingFace `datasets` (and `pyarrow`) read parquet directly, so there is no
need to re-download or transcode to JSONL. This script only verifies that the
shards exist and reports per-language statistics (shard count, row count,
text-length summary, optional sample preview).

Typical use:

    python prepare_data_local.py \
        --data-root /root/userdata/liangyan/routing_analysis/datasets/FineWeb2-HQ \
        --languages dan_Latn fas_Arab swe_Latn \
        --preview
"""

import argparse
from pathlib import Path

import pyarrow.parquet as pq


def list_shards(lang_dir: Path) -> list[Path]:
    """Return the parquet shards for a language, sorted by filename."""
    return sorted(lang_dir.glob("*.parquet"))


def summarize_language(
    lang: str,
    lang_dir: Path,
    sample_rows: int = 100,
    preview: bool = False,
):
    """Print shard count, row count, text-length stats, and optional preview."""
    print(f"\n{'=' * 60}")
    print(f"Language: {lang}")
    print(f"Path:     {lang_dir}")
    print(f"{'=' * 60}")

    if not lang_dir.is_dir():
        print("  [missing] directory does not exist")
        return

    shards = list_shards(lang_dir)
    if not shards:
        print(f"  [missing] no .parquet files in {lang_dir}")
        return

    # Row counts come from parquet metadata so this stays cheap even on huge data.
    total_bytes = sum(p.stat().st_size for p in shards)
    total_rows = 0
    schema = None
    for shard in shards:
        meta = pq.read_metadata(shard)
        total_rows += meta.num_rows
        if schema is None:
            schema = pq.read_schema(shard)

    print(f"  Shards:   {len(shards)}")
    print(f"  Rows:     {total_rows:,}")
    print(f"  Size:     {total_bytes / 1024 / 1024 / 1024:.2f} GB")
    print(f"  Columns:  {', '.join(schema.names)}")

    # Pull a small slice from the first shard to estimate text length.
    first_shard = shards[0]
    table = pq.read_table(first_shard, columns=["text"])
    sample = table.slice(0, sample_rows).column("text").to_pylist()
    lengths = [len(t) for t in sample if t]
    if lengths:
        avg_len = sum(lengths) / len(lengths)
        print(
            f"  Text len: avg={avg_len:.0f} "
            f"min={min(lengths)} max={max(lengths)} (first {len(lengths)} rows)"
        )

    if preview and sample:
        snippet = sample[0] or ""
        print("\n  --- preview (row 0, first 300 chars) ---")
        print("  " + snippet[:300].replace("\n", "\n  "))


def main():
    parser = argparse.ArgumentParser(
        description="Inspect locally-downloaded FineWeb2-HQ parquet data."
    )
    parser.add_argument(
        "--data-root",
        type=Path,
        default=Path(
            "/root/userdata/liangyan/routing_analysis/datasets/FineWeb2-HQ"
        ),
        help="Directory containing one subdirectory per language.",
    )
    parser.add_argument(
        "--languages",
        nargs="+",
        default=["dan_Latn", "fas_Arab", "swe_Latn"],
        help="Language codes (subdirectory names) to inspect.",
    )
    parser.add_argument(
        "--sample-rows",
        type=int,
        default=100,
        help="Rows to load from the first shard for text-length stats.",
    )
    parser.add_argument(
        "--preview",
        action="store_true",
        help="Print a short text snippet from the first row of each language.",
    )
    args = parser.parse_args()

    print("FineWeb2-HQ local data inspection")
    print(f"  data root: {args.data_root}")
    print(f"  languages: {', '.join(args.languages)}")

    for lang in args.languages:
        summarize_language(
            lang=lang,
            lang_dir=args.data_root / lang,
            sample_rows=args.sample_rows,
            preview=args.preview,
        )

    print(
        "\nDone. To load a language during training, point HuggingFace "
        "`datasets` at the parquet shards directly, e.g.:\n"
        "    from datasets import load_dataset\n"
        "    ds = load_dataset(\n"
        "        'parquet',\n"
        f"        data_files=f'{args.data_root}/<lang>/*.parquet',\n"
        "        split='train',\n"
        "        streaming=True,\n"
        "    )"
    )


if __name__ == "__main__":
    main()