#!/usr/bin/env python3

from __future__ import annotations

import argparse
import json
import re
import unicodedata
from collections import defaultdict
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq


INVALID_FILENAME_CHARS = r'[/\\:*?"<>|\n\r\t]'


def normalize_text(value: str) -> str:
    return unicodedata.normalize("NFC", str(value).strip())


def safe_filename(name: str, max_len: int = 180) -> str:
    name = normalize_text(name)
    name = re.sub(INVALID_FILENAME_CHARS, "_", name)
    name = re.sub(r"\s+", " ", name).strip()
    if not name:
        name = "untitled"
    if len(name) > max_len:
        name = name[:max_len].rstrip()
    return name


def load_prompt_index(prompts_dir: Path) -> dict[str, dict[str, dict[str, object]]]:
    prompt_index: dict[str, dict[str, dict[str, object]]] = defaultdict(dict)
    duplicates: list[tuple[str, str]] = []

    for prompt_file in sorted(prompts_dir.glob("*.json")):
        category = prompt_file.stem
        records = json.loads(prompt_file.read_text(encoding="utf-8"))
        for prompt_id, record in enumerate(records):
            content = normalize_text(record["content"])
            key = safe_filename(content)
            if key in prompt_index[category]:
                duplicates.append((category, key))
            prompt_index[category][key] = {
                "content": content,
                "prompt": normalize_text(record["prompt"]),
                "prompt_id": prompt_id,
            }

    if duplicates:
        duplicate_lines = "\n".join(f"- {category}: {key}" for category, key in duplicates[:20])
        raise ValueError(f"Duplicate prompt filenames detected:\n{duplicate_lines}")

    return prompt_index


def build_rows(repo_root: Path) -> list[dict[str, object]]:
    prompt_index = load_prompt_index(repo_root / "prompts")
    rows: list[dict[str, object]] = []

    for video_path in sorted(repo_root.glob("*/*/*.mp4")):
        model = video_path.parts[-3]
        category = video_path.parts[-2]
        filename = normalize_text(video_path.stem)
        prompt_record = prompt_index.get(category, {}).get(filename)
        rel_path = video_path.relative_to(repo_root).as_posix()

        rows.append(
            {
                "file_name": rel_path,
                "model": model,
                "category": category,
                "content": prompt_record["content"] if prompt_record else filename,
                "prompt": prompt_record["prompt"] if prompt_record else None,
                "prompt_id": prompt_record["prompt_id"] if prompt_record else None,
                "matched_prompt": prompt_record is not None,
            }
        )

    return rows


def write_parquet(rows: list[dict[str, object]], output_path: Path) -> None:
    table = pa.Table.from_pylist(rows)
    pq.write_table(table, output_path)


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Build metadata.parquet for Hugging Face Dataset Viewer."
    )
    parser.add_argument(
        "--repo-root",
        type=Path,
        default=Path(__file__).resolve().parents[1],
        help="Path to the dataset repository root.",
    )
    parser.add_argument(
        "--output",
        type=Path,
        default=None,
        help="Output parquet path. Defaults to <repo-root>/metadata.parquet.",
    )
    args = parser.parse_args()

    repo_root = args.repo_root.resolve()
    output_path = args.output.resolve() if args.output else repo_root / "metadata.parquet"

    rows = build_rows(repo_root)
    if not rows:
        raise ValueError(f"No MP4 files found under {repo_root}")

    write_parquet(rows, output_path)

    matched = sum(1 for row in rows if row["matched_prompt"])
    print(f"Wrote {len(rows)} rows to {output_path}")
    print(f"Matched prompts: {matched}/{len(rows)}")


if __name__ == "__main__":
    main()