#!/usr/bin/env python3
"""Reference Qwen/LabOS inference runner for standardized benchmark outputs."""

from __future__ import annotations

import argparse
import json
import os
import subprocess
import sys
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

import torch
from peft import PeftModel
from qwen_vl_utils import process_vision_info
from transformers import AutoConfig, AutoProcessor, Qwen2_5_VLForConditionalGeneration

from lsvbench.io import BENCHMARK_ROOT, OutputLayout, merge_shards, write_json, write_jsonl
from lsvbench.tasks import get_task


DEFAULT_LSV_ROOT = BENCHMARK_ROOT
MODEL_ALIASES = {
    "labos-vlm7b": "Qwen/Qwen2.5-VL-7B-Instruct",
    "labos-vlm-7b": "Qwen/Qwen2.5-VL-7B-Instruct",
    "qwen25-7b": "Qwen/Qwen2.5-VL-7B-Instruct",
    "qwen2.5-7b": "Qwen/Qwen2.5-VL-7B-Instruct",
}
ADAPTER_ALIASES = {
    "labos-vlm7b": "cong-lab/labos-vlm-7b",
    "labos-vlm-7b": "cong-lab/labos-vlm-7b",
}
MODEL_FAMILY_ALIASES = {
    "auto": "auto",
    "qwen25": "qwen2.5-vl",
    "qwen25-vl": "qwen2.5-vl",
    "qwen2.5": "qwen2.5-vl",
    "qwen2.5-vl": "qwen2.5-vl",
}
QWEN25_VL_MODEL_TYPES = {"qwen2_5_vl"}
QWEN25_VL_ARCHITECTURES = {"Qwen2_5_VLForConditionalGeneration"}


def parse_gpus(value: str) -> list[str]:
    text = value.strip()
    if not text:
        return ["0"]
    if "-" in text and "," not in text:
        start, end = [int(part) for part in text.split("-", 1)]
        return [str(idx) for idx in range(start, end + 1)]
    return [part.strip() for part in text.split(",") if part.strip()]


def resolve_model(value: str) -> str:
    return MODEL_ALIASES.get(value, value)


def normalize_model_family(value: str) -> str:
    family = MODEL_FAMILY_ALIASES.get(value.strip().lower())
    if family is None:
        supported = ", ".join(sorted(MODEL_FAMILY_ALIASES))
        raise ValueError(f"Unsupported --model-family {value!r}. Supported values: {supported}")
    return family


def detect_model_family(model_name: str) -> str:
    config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
    model_type = str(getattr(config, "model_type", "") or "")
    architectures = {str(item) for item in (getattr(config, "architectures", None) or [])}
    if model_type in QWEN25_VL_MODEL_TYPES or architectures & QWEN25_VL_ARCHITECTURES:
        return "qwen2.5-vl"
    detail = f"model_type={model_type!r}, architectures={sorted(architectures)!r}"
    raise ValueError(
        "Could not infer a supported model family from model config "
        f"for {model_name!r} ({detail}). Only qwen2.5-vl is currently implemented. "
        "Pass --model-family qwen2.5-vl if this is a compatible Qwen2.5-VL checkpoint."
    )


def resolve_model_family(value: str, model_name: str) -> str:
    family = normalize_model_family(value)
    return detect_model_family(model_name) if family == "auto" else family


def adapter_value(value: str | None) -> str | None:
    if value is None:
        return None
    text = str(value).strip()
    return None if not text or text.lower() in {"none", "null", "base"} else text


def resolve_adapter(model_arg: str, adapter_arg: str | None) -> str | None:
    explicit = adapter_value(adapter_arg)
    return explicit if explicit is not None else ADAPTER_ALIASES.get(model_arg)


def load_model(args: argparse.Namespace) -> tuple[Any, Any]:
    model_name = resolve_model(args.model)
    model_family = resolve_model_family(args.model_family, model_name)
    if model_family != "qwen2.5-vl":
        raise ValueError(f"Unsupported model family {model_family!r}. Only qwen2.5-vl is currently implemented.")
    processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True)
    model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16,
        device_map={"": "cuda:0"},
        attn_implementation=args.attn_impl,
        trust_remote_code=True,
    )
    adapter = resolve_adapter(args.model, args.adapter)
    if adapter is not None:
        model = PeftModel.from_pretrained(model, adapter)
    model.eval()
    return model, processor


def normalize_video_kwargs(video_kwargs: dict[str, Any], batch_size: int) -> dict[str, Any]:
    out = dict(video_kwargs)
    for key, value in list(out.items()):
        if isinstance(value, list) and len(value) == 1 and batch_size == 1:
            out[key] = value[0]
    return out


def video_settings_for_task(task_name: str, args: argparse.Namespace) -> dict[str, Any]:
    if task_name == "pmd":
        return {
            "fps": args.pmd_fps,
            "min_frames": args.min_frames,
            "max_frames": args.pmd_max_frames,
            "min_pixels": args.min_pixels,
            "max_pixels": args.pmd_max_pixels,
        }
    return {
        "fps": args.fps,
        "min_frames": args.min_frames,
        "max_frames": args.max_frames,
        "min_pixels": args.min_pixels,
        "max_pixels": args.max_pixels,
    }


def prompt_for_row(task_name: str, row: dict[str, Any], args: argparse.Namespace) -> str:
    if task_name == "pmd":
        return Path(args.pmd_prompt).read_text(encoding="utf-8").strip()
    return str(row["prompt"])


def build_messages(task_name: str, row: dict[str, Any], args: argparse.Namespace) -> list[dict[str, Any]]:
    video = {
        "type": "video",
        "video": row["_video_abs"],
        **video_settings_for_task(task_name, args),
    }
    if task_name != "pmd":
        video["video_start"] = float(row["video_start"])
        video["video_end"] = float(row["video_end"])
    return [
        {
            "role": "user",
            "content": [
                video,
                {"type": "text", "text": prompt_for_row(task_name, row, args)},
            ],
        }
    ]


def generate_batch(model: Any, processor: Any, task_name: str, rows: list[dict[str, Any]], args: argparse.Namespace) -> list[str]:
    batch_messages = [build_messages(task_name, row, args) for row in rows]
    texts = [processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) for messages in batch_messages]
    image_inputs, video_inputs, video_kwargs = process_vision_info(batch_messages, return_video_kwargs=True)
    video_kwargs = normalize_video_kwargs(video_kwargs, len(rows))
    inputs = processor(
        text=texts,
        images=image_inputs,
        videos=video_inputs,
        padding=True,
        return_tensors="pt",
        **video_kwargs,
    ).to(model.device)
    with torch.inference_mode():
        generated = model.generate(
            **inputs,
            max_new_tokens=args.pmd_max_new_tokens if task_name == "pmd" else args.max_new_tokens,
            do_sample=False,
            temperature=None,
            top_p=None,
        )
    prompt_lens = inputs["attention_mask"].sum(dim=1).tolist()
    decoded: list[str] = []
    for idx, prompt_len in enumerate(prompt_lens):
        text = processor.decode(
            generated[idx, int(prompt_len) :],
            skip_special_tokens=True,
            clean_up_tokenization_spaces=False,
        )
        decoded.append(text.strip())
    return decoded


def safe_generate_batch(model: Any, processor: Any, task_name: str, rows: list[dict[str, Any]], args: argparse.Namespace) -> list[tuple[str, str | None]]:
    try:
        return [(text, None) for text in generate_batch(model, processor, task_name, rows, args)]
    except Exception as exc:
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
        if len(rows) == 1:
            return [("", f"{type(exc).__name__}: {exc}")]
        outputs: list[tuple[str, str | None]] = []
        for row in rows:
            outputs.extend(safe_generate_batch(model, processor, task_name, [row], args))
        return outputs


def chunks(rows: list[dict[str, Any]], size: int) -> list[list[dict[str, Any]]]:
    return [rows[idx : idx + size] for idx in range(0, len(rows), size)]


def record_for_output(task_name: str, row: dict[str, Any], raw: str, error: str | None, args: argparse.Namespace) -> dict[str, Any]:
    keep = {key: value for key, value in row.items() if not key.startswith("_")}
    keep.update(
        {
            "task": task_name,
            "raw_response": raw,
            "error": error,
            "shard_index": args.shard_index,
            "num_shards": args.num_shards,
        }
    )
    return keep


def run_worker(args: argparse.Namespace) -> None:
    os.environ.setdefault("FORCE_QWENVL_VIDEO_READER", "decord")
    task = get_task(args.task)
    video_root = BENCHMARK_ROOT if args.task == "pmd" else args.lsv_root
    rows = task.load_examples(
        benchmark_root=BENCHMARK_ROOT,
        manifest_path=args.manifest,
        video_root=video_root,
        num_shards=args.num_shards,
        shard_index=args.shard_index,
        limit=args.limit,
    )
    model, processor = load_model(args)
    layout = OutputLayout(args.output)
    result_path = layout.shard_path(args.task, args.shard_index)
    result_path.parent.mkdir(parents=True, exist_ok=True)
    records: list[dict[str, Any]] = []
    batch_size = args.pmd_batch_size if args.task == "pmd" else args.batch_size
    for batch in chunks(rows, batch_size):
        generated = safe_generate_batch(model, processor, args.task, batch, args)
        for row, (raw, error) in zip(batch, generated, strict=True):
            record = record_for_output(args.task, row, raw, error, args)
            records.append(record)
            print(json.dumps({"task": args.task, "id": row.get("eval_id") or row.get("video_id"), "error": error}), flush=True)
    write_jsonl(result_path, records)


def launch_workers(args: argparse.Namespace) -> None:
    gpus = parse_gpus(args.gpus)
    args.output.mkdir(parents=True, exist_ok=True)
    write_json(
        args.output / "run_config.json",
        {
            "model": resolve_model(args.model),
            "model_arg": args.model,
            "model_family": resolve_model_family(args.model_family, resolve_model(args.model)),
            "adapter": resolve_adapter(args.model, args.adapter),
            "tasks": args.tasks.split(","),
            "created_at": datetime.now(timezone.utc).isoformat(),
            "gpus": gpus,
            "fps": args.fps,
            "max_frames": args.max_frames,
            "max_pixels": args.max_pixels,
            "pmd_fps": args.pmd_fps,
            "pmd_max_frames": args.pmd_max_frames,
            "pmd_max_pixels": args.pmd_max_pixels,
        },
    )
    for task_name in [task.strip() for task in args.tasks.split(",") if task.strip()]:
        procs: list[subprocess.Popen[Any]] = []
        for shard_index, gpu in enumerate(gpus):
            cmd = [
                sys.executable,
                str(Path(__file__).resolve()),
                "--worker",
                "--task",
                task_name,
                "--model",
                args.model,
                "--model-family",
                args.model_family,
                "--output",
                str(args.output),
                "--gpus",
                gpu,
                "--num-shards",
                str(len(gpus)),
                "--shard-index",
                str(shard_index),
                "--batch-size",
                str(args.batch_size),
                "--pmd-batch-size",
                str(args.pmd_batch_size),
                "--max-new-tokens",
                str(args.max_new_tokens),
                "--pmd-max-new-tokens",
                str(args.pmd_max_new_tokens),
                "--attn-impl",
                args.attn_impl,
                "--lsv-root",
                str(args.lsv_root),
            ]
            effective_adapter = resolve_adapter(args.model, args.adapter)
            if effective_adapter:
                cmd.extend(["--adapter", effective_adapter])
            if args.limit is not None:
                cmd.extend(["--limit", str(args.limit)])
            env = os.environ.copy()
            env["CUDA_VISIBLE_DEVICES"] = gpu
            env.setdefault("PYTHONPATH", str(BENCHMARK_ROOT))
            env["PYTHONPATH"] = f"{BENCHMARK_ROOT}:{env['PYTHONPATH']}"
            procs.append(subprocess.Popen(cmd, cwd=str(BENCHMARK_ROOT), env=env))
        failures = [proc.wait() for proc in procs]
        if any(code != 0 for code in failures):
            raise SystemExit(f"Task {task_name} failed with exit codes: {failures}")
        merge_shards(OutputLayout(args.output).task_dir(task_name), sort_key=get_task(task_name).sort_key)


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--model", required=True, help="Base or merged model as a Hugging Face repo ID, local path, or alias such as qwen25-7b.")
    parser.add_argument(
        "--model-family",
        default="auto",
        help="Inference backend to use: auto or qwen2.5-vl. Auto reads the model config from a Hugging Face repo ID or local path.",
    )
    parser.add_argument("--adapter", help="Optional PEFT/LoRA adapter as a Hugging Face repo ID or local path.")
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--tasks", default="monitoring_step,monitor_next_step,pmd")
    parser.add_argument("--task", choices=sorted(["monitoring_step", "monitor_next_step", "pmd"]))
    parser.add_argument("--manifest", type=Path)
    parser.add_argument("--gpus", default="0")
    parser.add_argument("--worker", action="store_true")
    parser.add_argument("--num-shards", type=int, default=1)
    parser.add_argument("--shard-index", type=int, default=0)
    parser.add_argument("--limit", type=int)
    parser.add_argument("--lsv-root", type=Path, default=DEFAULT_LSV_ROOT)
    parser.add_argument("--batch-size", type=int, default=4)
    parser.add_argument("--pmd-batch-size", type=int, default=4)
    parser.add_argument("--fps", type=float, default=2.0)
    parser.add_argument("--pmd-fps", type=float, default=8.0)
    parser.add_argument("--min-frames", type=int, default=4)
    parser.add_argument("--max-frames", type=int, default=128)
    parser.add_argument("--pmd-max-frames", type=int, default=512)
    parser.add_argument("--min-pixels", type=int, default=50176)
    parser.add_argument("--max-pixels", type=int, default=100352)
    parser.add_argument("--pmd-max-pixels", type=int, default=200704)
    parser.add_argument("--max-new-tokens", type=int, default=2048)
    parser.add_argument("--pmd-max-new-tokens", type=int, default=64)
    parser.add_argument("--attn-impl", default="flash_attention_3")
    parser.add_argument("--pmd-prompt", type=Path, default=BENCHMARK_ROOT / "lsvbench" / "tasks" / "prompts" / "pmd.md")
    args = parser.parse_args()

    if args.worker:
        if not args.task:
            raise SystemExit("--worker requires --task")
        run_worker(args)
    else:
        launch_workers(args)


if __name__ == "__main__":
    main()