#!/usr/bin/env -S uv run
"""
Validate Parquet files by comparing with original CoNLL-U data.

This script is a wrapper around the ud-hf-parquet-tools library.
For the actual implementation, see: https://github.com/bot-zen/ud-hf-parquet-tools

This script can validate both:
- Remote: Downloaded from HuggingFace Hub
- Local: Local parquet files in ../parquet/

Repository: commul/universal_dependencies

Usage:
    python 05_validate_parquet.py [OPTIONS]

Options:
    --ud-ver VERSION            UD version context for metadata/revision defaults (default: 2.17)
    --test                      Only validate 3 test treebanks (fr_gsd, en_ewt, it_isdt)
    --treebanks NAMES           Comma-separated list of treebank names to validate
    --blocked-treebanks FILE    Path to blocked treebanks YAML file (default: tools/blocked_treebanks.yaml)
    --revision BRANCH           HuggingFace Hub revision/branch (default: --ud-ver)
    --local                     Validate local parquet files instead of HuggingFace Hub
    --parquet-dir DIR           Path to local parquet directory (implies --local)
    -v, --verbose               Print progress messages (default: True)
    -vv, --very-verbose         Show all differences
    -q, --quiet                 Suppress progress messages

Examples:
    # Validate 3 test treebanks from local files
    python 05_validate_parquet.py --test --local

    # Validate specific treebanks from HuggingFace Hub
    python 05_validate_parquet.py --treebanks fr_gsd,en_ewt --revision 2.17

    # Validate all treebanks from main branch
    python 05_validate_parquet.py --revision main

Note for developers:
    If you're modifying the ud-hf-parquet-tools library locally, run this script
    with 'python' directly instead of relying on the shebang, to ensure it uses
    your local editable install rather than the PyPI version:

        python tools/05_validate_parquet.py [options]
"""

import argparse
import json
import os
import sys
from pathlib import Path

from dotenv import load_dotenv
import yaml

from _ud_hfp_wrapper import (
    append_common_verbosity_args,
    get_repo_paths,
    run_ud_tools,
)


# Load environment variables from tools/.env
load_dotenv(Path(__file__).with_name(".env"))
UD_VER = os.getenv("UD_VER", "2.17")

# Project paths
PATHS = get_repo_paths(__file__)


def _load_metadata_treebanks(metadata_path: str) -> list[str]:
    with open(metadata_path, "r", encoding="utf-8") as f:
        metadata = json.load(f)
    return sorted(metadata.keys())


def _load_blocked_treebanks(blocked_treebanks_path: str) -> set[str]:
    blocked_file = Path(blocked_treebanks_path)
    if not blocked_file.exists():
        return set()

    with open(blocked_file, "r", encoding="utf-8") as f:
        blocked_data = yaml.safe_load(f) or {}
    return set(blocked_data.keys())


def _select_treebanks(args, metadata_treebanks: list[str]) -> list[str]:
    if args.test:
        return [t for t in ["fr_gsd", "en_ewt", "it_isdt"] if t in metadata_treebanks]
    if args.treebanks:
        return [t.strip() for t in args.treebanks.split(",") if t.strip()]
    return metadata_treebanks


def main():
    """Main entry point - wrapper around ud-hf-parquet-tools."""
    parser = argparse.ArgumentParser(
        description="Validate Parquet files by comparing with original CoNLL-U data"
    )
    parser.add_argument("--test", action="store_true", help="Test mode: validate 3 treebanks only")
    parser.add_argument("--treebanks", help="Comma-separated list of treebank names")
    parser.add_argument(
        "--ud-ver",
        default=UD_VER,
        help="UD version context for local metadata defaults (default: UD_VER from env or 2.17)",
    )
    parser.add_argument("--blocked-treebanks", help="Path to blocked treebanks YAML file")
    parser.add_argument("--revision", help="HuggingFace Hub revision/branch (default: --ud-ver)")
    parser.add_argument("--local", action="store_true", help="Validate local parquet files")
    parser.add_argument("--parquet-dir", help="Path to local parquet directory (implies --local)")
    parser.add_argument("--metadata", help="Path to metadata file (overrides default)")
    parser.add_argument("-v", "--verbose", action="store_true", default=True, help="Verbose output")
    parser.add_argument("-vv", "--very-verbose", action="store_true", help="Show all differences")
    parser.add_argument("-q", "--quiet", action="store_true", help="Quiet mode")

    args = parser.parse_args()
    ud_ver = args.ud_ver
    revision = args.revision or ud_ver
    versioned_metadata = Path(__file__).resolve().parent / f"metadata-{ud_ver}.json"
    default_metadata = versioned_metadata if versioned_metadata.exists() else PATHS.metadata_file
    metadata_path = args.metadata or str(default_metadata)
    blocked_treebanks_path = args.blocked_treebanks or str(PATHS.blocked_treebanks_file)

    metadata_treebanks = _load_metadata_treebanks(metadata_path)
    selected_treebanks = _select_treebanks(args, metadata_treebanks)
    blocked_treebanks = _load_blocked_treebanks(blocked_treebanks_path)
    ignored_blocked = [t for t in selected_treebanks if t in blocked_treebanks]
    treebanks_to_validate = [t for t in selected_treebanks if t not in blocked_treebanks]

    if not args.quiet:
        print(
            f"Ignored blocked treebanks ({len(ignored_blocked)}) "
            f"from {blocked_treebanks_path}"
        )
        if args.verbose and ignored_blocked:
            print(f"  {', '.join(sorted(ignored_blocked))}")

    if not treebanks_to_validate:
        if not args.quiet:
            print("No treebanks to validate after blocked filtering.")
        return 0

    # Build arguments for ud-hf-parquet-tools
    tool_args = [
        "ud-hfp-tools",
        "validate",
        "--metadata",
        metadata_path,
        "--ud-repos-dir",
        str(PATHS.ud_repos_dir),
        "--treebanks",
        ",".join(treebanks_to_validate),
    ]

    # Handle parquet directory
    if args.parquet_dir:
        tool_args.extend(["--parquet-dir", args.parquet_dir])
    elif args.local:
        tool_args.extend(["--parquet-dir", str(PATHS.parquet_dir)])
    else:
        # Remote validation
        tool_args.extend(["--revision", revision])

    append_common_verbosity_args(args, tool_args)
    return run_ud_tools(tool_args)


if __name__ == "__main__":
    sys.exit(main())