from __future__ import annotations

import argparse
import json
import os

from .evaluate import evaluate_mme_cof, evaluate_vwg, parse_seeds
from .external import prepare_ruler, prepare_vreason
from .io import write_json
from .metrics import summarize_mme, summarize_vwg
from .validate import validate_dataset


def add_common_video_arguments(parser: argparse.ArgumentParser) -> None:
    parser.add_argument("--videos-dir", required=True)
    parser.add_argument("--seeds", default="0,1,2")
    parser.add_argument(
        "--filename-template",
        default="{id}_seed{seed}.mp4",
        help="Available placeholders: {id}, {id06}, {seed}",
    )


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(prog="vwg-bench")
    subparsers = parser.add_subparsers(dest="command", required=True)

    validate = subparsers.add_parser("validate-data")
    validate.add_argument("--dataset-root", required=True)
    validate.add_argument("--skip-hashes", action="store_true")

    evaluate = subparsers.add_parser("evaluate")
    evaluate.add_argument("--dataset-root", required=True)
    add_common_video_arguments(evaluate)
    evaluate.add_argument("--output", required=True)
    evaluate.add_argument(
        "--model",
        default=os.getenv("VWG_JUDGE_MODEL", "gemini-2.5-pro"),
    )
    evaluate.add_argument("--workers", type=int, default=4)
    evaluate.add_argument("--max-frames", type=int, default=16)
    evaluate.add_argument("--limit", type=int)
    evaluate.add_argument("--strict-missing", action="store_true")

    summarize = subparsers.add_parser("summarize")
    summarize.add_argument("--dataset-root", required=True)
    summarize.add_argument("--results", required=True)
    summarize.add_argument("--output")

    mme = subparsers.add_parser("evaluate-mme-cof")
    mme.add_argument("--metadata-json", required=True)
    add_common_video_arguments(mme)
    mme.add_argument("--output", required=True)
    mme.add_argument(
        "--model",
        default=os.getenv("VWG_JUDGE_MODEL", "gemini-2.5-pro"),
    )
    mme.add_argument("--workers", type=int, default=4)
    mme.add_argument("--max-frames", type=int, default=16)

    mme_summary = subparsers.add_parser("summarize-mme-cof")
    mme_summary.add_argument("--results", required=True)
    mme_summary.add_argument("--output")

    ruler = subparsers.add_parser("prepare-ruler")
    ruler.add_argument("--metadata-json", required=True)
    add_common_video_arguments(ruler)
    ruler.add_argument("--output-dir", required=True)

    vreason = subparsers.add_parser("prepare-vreason")
    vreason.add_argument("--metadata-json", required=True)
    add_common_video_arguments(vreason)
    vreason.add_argument("--output-dir", required=True)
    vreason.add_argument("--model-name", required=True)

    return parser


def emit(value: dict, output: str | None = None) -> None:
    if output:
        write_json(output, value)
    print(json.dumps(value, ensure_ascii=False, indent=2))


def main(argv: list[str] | None = None) -> int:
    args = build_parser().parse_args(argv)
    if args.command == "validate-data":
        report = validate_dataset(args.dataset_root, verify_hashes=not args.skip_hashes)
        emit(report)
        return 0 if report["ok"] else 1
    if args.command == "evaluate":
        emit(
            evaluate_vwg(
                dataset_root=args.dataset_root,
                videos_dir=args.videos_dir,
                output_path=args.output,
                seeds=parse_seeds(args.seeds),
                model=args.model,
                filename_template=args.filename_template,
                workers=args.workers,
                max_frames=args.max_frames,
                limit=args.limit,
                strict_missing=args.strict_missing,
            )
        )
        return 0
    if args.command == "summarize":
        emit(summarize_vwg(args.dataset_root, args.results), args.output)
        return 0
    if args.command == "evaluate-mme-cof":
        emit(
            evaluate_mme_cof(
                metadata_json=args.metadata_json,
                videos_dir=args.videos_dir,
                output_path=args.output,
                seeds=parse_seeds(args.seeds),
                model=args.model,
                filename_template=args.filename_template,
                workers=args.workers,
                max_frames=args.max_frames,
            )
        )
        return 0
    if args.command == "summarize-mme-cof":
        emit(summarize_mme(args.results), args.output)
        return 0
    if args.command == "prepare-ruler":
        emit(
            prepare_ruler(
                metadata_json=args.metadata_json,
                videos_dir=args.videos_dir,
                output_dir=args.output_dir,
                seeds=parse_seeds(args.seeds),
                filename_template=args.filename_template,
            )
        )
        return 0
    if args.command == "prepare-vreason":
        emit(
            prepare_vreason(
                metadata_json=args.metadata_json,
                videos_dir=args.videos_dir,
                output_dir=args.output_dir,
                seeds=parse_seeds(args.seeds),
                model_name=args.model_name,
                filename_template=args.filename_template,
            )
        )
        return 0
    raise AssertionError(args.command)


if __name__ == "__main__":
    raise SystemExit(main())