# /// script
# requires-python = ">=3.10"
# dependencies = [
#   "datasets>=3.0.0",
#   "huggingface_hub>=0.24.0",
# ]
# ///

from __future__ import annotations

import argparse
import json
import os
import re
from collections import OrderedDict
from typing import Any

from datasets import Dataset, DatasetDict, load_dataset


PAGE_RE = re.compile(r"_(\d{3,})-")


DEFAULT_KEEP_COLUMNS = [
    "title",
    "barcode",
    "call_number",
    "location",
    "date_scanned",
    "scanned_by",
    "ld4p_id",
    "original_zip",
]


def normalize_value(value: Any) -> Any:
    """Make values safe and stable for Dataset.from_list."""
    if value is None:
        return None

    if isinstance(value, (str, int, float, bool)):
        return value

    try:
        return json.dumps(value, ensure_ascii=False, sort_keys=True)
    except TypeError:
        return str(value)


def parse_page_number(source_path: str | None) -> int | None:
    if not source_path:
        return None

    match = PAGE_RE.search(source_path)
    if match:
        return int(match.group(1))

    return None


def make_document_id(row: dict[str, Any], group_by: list[str]) -> str:
    values = [str(row.get(col, "")).strip() for col in group_by]
    return "::".join(values)


def reduce_split(
    ds: Dataset,
    *,
    group_by: list[str],
    keep_columns: list[str],
    markdown_column: str,
    source_path_column: str,
    inference_info_column: str,
    add_page_markers: bool,
) -> Dataset:
    missing_group_cols = [col for col in group_by if col not in ds.column_names]
    if missing_group_cols:
        raise ValueError(f"Missing grouping columns: {missing_group_cols}")

    if markdown_column not in ds.column_names:
        raise ValueError(f"Missing markdown column: {markdown_column}")

    if source_path_column not in ds.column_names:
        raise ValueError(f"Missing source path column: {source_path_column}")

    # Crucial: remove image/reference image columns before row iteration.
    # This avoids decoding or carrying image payloads into the reduced dataset.
    early_drop_columns = [col for col in ["image"] if col in ds.column_names]
    if early_drop_columns:
        ds = ds.remove_columns(early_drop_columns)

    keep_columns = [col for col in keep_columns if col in ds.column_names]

    documents: OrderedDict[tuple[Any, ...], dict[str, Any]] = OrderedDict()

    for row_index, row in enumerate(ds):
        key = tuple(normalize_value(row.get(col)) for col in group_by)

        if key not in documents:
            doc = {
                col: normalize_value(row.get(col))
                for col in keep_columns
            }

            doc["document_id"] = make_document_id(row, group_by)
            doc["_pages"] = []
            documents[key] = doc

        source_path = row.get(source_path_column)
        page_number = parse_page_number(source_path)

        documents[key]["_pages"].append(
            {
                "row_index": row_index,
                "page_number": page_number,
                "source_path": normalize_value(source_path),
                "markdown": row.get(markdown_column) or "",
                "inference_info": normalize_value(row.get(inference_info_column))
                if inference_info_column in ds.column_names
                else None,
            }
        )

    output_rows: list[dict[str, Any]] = []

    for doc in documents.values():
        pages = sorted(
            doc["_pages"],
            key=lambda p: (
                p["page_number"] is None,
                p["page_number"] if p["page_number"] is not None else 10**12,
                p["row_index"],
            ),
        )

        markdown_parts = []
        for idx, page in enumerate(pages, start=1):
            text = page["markdown"].strip()

            if add_page_markers:
                marker = f"<!-- page {idx}; source_path: {page['source_path']} -->"
                markdown_parts.append(f"{marker}\n\n{text}".strip())
            else:
                markdown_parts.append(text)

        source_paths = [p["source_path"] for p in pages]
        page_numbers = [p["page_number"] for p in pages]

        inference_infos = [
            p["inference_info"]
            for p in pages
            if p.get("inference_info") not in (None, "")
        ]

        doc.pop("_pages", None)

        doc[markdown_column] = "\n\n".join(part for part in markdown_parts if part)
        doc["page_count"] = len(pages)
        doc["source_paths"] = source_paths
        doc["page_numbers"] = page_numbers

        # Usually identical across pages; keep first value as document-level metadata.
        doc[inference_info_column] = inference_infos[0] if inference_infos else None

        output_rows.append(doc)

    return Dataset.from_list(output_rows)


def parse_csv_arg(value: str) -> list[str]:
    return [part.strip() for part in value.split(",") if part.strip()]


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Consolidate page-level OCR rows into document-level OCR rows."
    )

    parser.add_argument(
        "--input-dataset",
        required=True,
        help="Input Hugging Face dataset repo ID, e.g. username/page-level-ocr",
    )

    parser.add_argument(
        "--output-dataset",
        required=True,
        help="Output Hugging Face dataset repo ID, e.g. username/document-level-ocr",
    )

    parser.add_argument(
        "--config",
        default=None,
        help="Optional dataset config/subset name.",
    )

    parser.add_argument(
        "--split",
        default=None,
        help="Optional split to process. If omitted, all splits are processed.",
    )

    parser.add_argument(
        "--group-by",
        default="barcode",
        help="Comma-separated grouping columns. Default: barcode",
    )

    parser.add_argument(
        "--keep-columns",
        default=",".join(DEFAULT_KEEP_COLUMNS),
        help="Comma-separated metadata columns to preserve.",
    )

    parser.add_argument(
        "--markdown-column",
        default="markdown",
        help="OCR text column to concatenate. Default: markdown",
    )

    parser.add_argument(
        "--source-path-column",
        default="source_path",
        help="Column used to infer page order. Default: source_path",
    )

    parser.add_argument(
        "--inference-info-column",
        default="inference_info",
        help="Column containing OCR inference metadata. Default: inference_info",
    )

    parser.add_argument(
        "--no-page-markers",
        action="store_true",
        help="Do not insert HTML page markers into the consolidated markdown.",
    )

    parser.add_argument(
        "--private",
        action="store_true",
        help="Create the output dataset as private if it does not already exist.",
    )

    parser.add_argument(
        "--token",
        default=os.environ.get("HF_TOKEN"),
        help="Hugging Face token. Defaults to HF_TOKEN environment variable.",
    )

    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Print a summary instead of pushing to the Hub.",
    )

    args = parser.parse_args()

    group_by = parse_csv_arg(args.group_by)
    keep_columns = parse_csv_arg(args.keep_columns)

    load_kwargs: dict[str, Any] = {
        "path": args.input_dataset,
    }

    if args.config:
        load_kwargs["name"] = args.config

    if args.split:
        load_kwargs["split"] = args.split

    if args.token:
        load_kwargs["token"] = args.token

    loaded = load_dataset(**load_kwargs)

    reduce_kwargs = {
        "group_by": group_by,
        "keep_columns": keep_columns,
        "markdown_column": args.markdown_column,
        "source_path_column": args.source_path_column,
        "inference_info_column": args.inference_info_column,
        "add_page_markers": not args.no_page_markers,
    }

    if isinstance(loaded, DatasetDict):
        reduced = DatasetDict(
            {
                split_name: reduce_split(split_ds, **reduce_kwargs)
                for split_name, split_ds in loaded.items()
            }
        )
    else:
        reduced = reduce_split(loaded, **reduce_kwargs)

    if args.dry_run:
        if isinstance(reduced, DatasetDict):
            for split_name, split_ds in reduced.items():
                print(f"{split_name}: {split_ds.num_rows} consolidated documents")
                print(split_ds[0] if split_ds.num_rows else "No rows")
        else:
            print(f"{reduced.num_rows} consolidated documents")
            print(reduced[0] if reduced.num_rows else "No rows")
        return

    push_kwargs: dict[str, Any] = {
        "repo_id": args.output_dataset,
        "private": args.private,
    }

    if args.token:
        push_kwargs["token"] = args.token

    reduced.push_to_hub(**push_kwargs)

    print(f"Pushed consolidated dataset to: {args.output_dataset}")


if __name__ == "__main__":
    main()