#!/usr/bin/env python3
"""Normalize released parquet files to the current Polish DynaWord schema.

This is intentionally conservative: it preserves row order and existing columns,
adds `license` from source metadata when missing, adds empty `author` when
missing, and recomputes release statistics directly from the parquet files.
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

import pyarrow as pa
import pyarrow.compute as pc
import pyarrow.parquet as pq

sys.path.insert(0, str(Path(__file__).resolve().parent))
from sources import SOURCES


ROOT = Path(__file__).resolve().parent.parent
SCHEMA = pa.schema(
    [
        ("id", pa.string()),
        ("text", pa.string()),
        ("source", pa.string()),
        ("added", pa.string()),
        ("created", pa.string()),
        ("token_count", pa.int64()),
        ("license", pa.string()),
        ("author", pa.string()),
    ]
)


def add_missing_columns(tbl: pa.Table, source: str, default_license: str) -> pa.Table:
    names = set(tbl.schema.names)
    if "license" not in names:
        tbl = tbl.append_column("license", pa.array([default_license] * tbl.num_rows, type=pa.string()))
    if "author" not in names:
        tbl = tbl.append_column("author", pa.array([""] * tbl.num_rows, type=pa.string()))
    return tbl.select(SCHEMA.names).cast(SCHEMA)


def string_len_sum(arr: pa.ChunkedArray) -> int:
    lengths = pc.utf8_length(arr)
    return int(pc.sum(lengths).as_py() or 0)


def value_counts(arr: pa.ChunkedArray) -> dict[str, int]:
    out: dict[str, int] = {}
    for chunk in arr.chunks:
        counted = pc.value_counts(chunk).to_pylist()
        for item in counted:
            value = "" if item["values"] is None else str(item["values"])
            out[value] = out.get(value, 0) + int(item["counts"])
    return out


def normalize_one(parquet_path: Path) -> dict:
    source = parquet_path.parent.name
    cfg = SOURCES[source]
    default_license = cfg.get("license", "")
    tmp_path = parquet_path.with_suffix(".parquet.tmp")
    writer: pq.ParquetWriter | None = None
    stats = {
        "read": 0,
        "kept": 0,
        "drop_short": 0,
        "drop_lang": 0,
        "drop_dup": 0,
        "drop_ocr": 0,
        "chars": 0,
        "tokens": 0,
        "licenses": {},
        "authors_with_value": 0,
        "license": default_license,
        "stats_recomputed_from_parquet": True,
    }

    pf = pq.ParquetFile(parquet_path)
    try:
        for batch in pf.iter_batches(batch_size=8192):
            tbl = add_missing_columns(pa.Table.from_batches([batch]), source, default_license)
            if writer is None:
                writer = pq.ParquetWriter(tmp_path, SCHEMA, compression="zstd")
            writer.write_table(tbl)

            n = tbl.num_rows
            stats["read"] += n
            stats["kept"] += n
            stats["chars"] += string_len_sum(tbl["text"])
            stats["tokens"] += int(pc.sum(tbl["token_count"]).as_py() or 0)
            stats["authors_with_value"] += int(pc.sum(pc.not_equal(tbl["author"], "")).as_py() or 0)
            for value, count in value_counts(tbl["license"]).items():
                stats["licenses"][value] = stats["licenses"].get(value, 0) + count
    finally:
        if writer is not None:
            writer.close()

    if writer is None:
        raise RuntimeError(f"empty parquet: {parquet_path}")
    tmp_path.replace(parquet_path)
    stats_path = parquet_path.with_name(f"{source}.stats.json")
    stats_path.write_text(json.dumps(stats, ensure_ascii=False, indent=2) + "\n")
    return stats


def main() -> None:
    total_docs = 0
    total_tokens = 0
    for parquet_path in sorted((ROOT / "data").glob("*/*.parquet")):
        source = parquet_path.parent.name
        if source not in SOURCES:
            print(f"skip unknown source {source}: {parquet_path}")
            continue
        stats = normalize_one(parquet_path)
        total_docs += stats["kept"]
        total_tokens += stats["tokens"]
        print(f"{source}: {stats['kept']:,} docs | {stats['tokens']:,} tokens")
    print(f"TOTAL: {total_docs:,} docs | {total_tokens:,} tokens")


if __name__ == "__main__":
    main()