"""Deterministic Qwen3.5-VL prediction for frozen evaluation manifests.

GPU libraries remain lazy imports so manifest/scoring tests run on CPU-only
machines.  The runner is append-resumable by eval ID and never re-hashes model,
adapter, or image trees; paths are checked structurally when they are used.
"""

from __future__ import annotations

import copy
import json
import os
import time
from collections.abc import Mapping, Sequence
from pathlib import Path
from typing import Any

from ..hashing import canonical_json
from ..paths import repo_root
from ..training.answers import parse_answer
from .core import EvaluationError


def resolve_asset(root: Path, raw_path: str) -> Path:
    relative = Path(raw_path)
    if not raw_path or relative.is_absolute() or ".." in relative.parts or "\\" in raw_path:
        raise EvaluationError(f"unsafe evaluation image path: {raw_path!r}")
    resolved_root = root.resolve()
    resolved = (resolved_root / relative).resolve()
    try:
        resolved.relative_to(resolved_root)
    except ValueError as exc:
        raise EvaluationError(f"evaluation image escapes asset root: {raw_path!r}") from exc
    if not resolved.is_file():
        raise EvaluationError(f"evaluation image not found: {resolved}")
    return resolved


def _question_text(question: str, choices: Sequence[Mapping[str, Any]]) -> str:
    if not choices:
        return question
    rendered: list[str] = []
    for choice in choices:
        if "key" not in choice or "text" not in choice:
            raise EvaluationError("evaluation choice requires key and text")
        rendered.append(f"{choice['key']}. {choice['text']}")
    return question + "\n\nChoices:\n" + "\n".join(rendered)


def build_messages(
    row: Mapping[str, Any],
    *,
    images: Sequence[Any],
) -> list[dict[str, Any]]:
    question = row.get("question")
    choices = row.get("choices")
    if not isinstance(question, str) or not question:
        raise EvaluationError("evaluation row has no question")
    if not isinstance(choices, list) or any(not isinstance(choice, Mapping) for choice in choices):
        raise EvaluationError("evaluation row choices are malformed")
    prompt_path = repo_root() / "prompts" / "common_system.txt"
    try:
        system = prompt_path.read_text(encoding="utf-8").strip()
    except OSError as exc:
        raise EvaluationError(f"cannot read common system prompt: {exc}") from exc
    content = [{"type": "image", "image": image} for image in images]
    content.append({"type": "text", "text": _question_text(question, choices)})
    return [
        {"role": "system", "content": [{"type": "text", "text": system}]},
        {"role": "user", "content": content},
    ]


def _load_images(row: Mapping[str, Any], asset_root: Path) -> list[Any]:
    from PIL import Image

    raw_images = row.get("images")
    if not isinstance(raw_images, list):
        raise EvaluationError("evaluation row images must be a list")
    images: list[Any] = []
    for raw in raw_images:
        if not isinstance(raw, Mapping) or not isinstance(raw.get("path"), str):
            raise EvaluationError("evaluation image record is malformed")
        path = resolve_asset(asset_root, str(raw["path"]))
        try:
            with Image.open(path) as image:
                images.append(image.convert("RGB").copy())
        except (OSError, ValueError) as exc:
            raise EvaluationError(f"cannot decode evaluation image {path}: {exc}") from exc
    return images


def _load_model(base_model: Path, adapter: Path | None) -> tuple[Any, Any]:
    try:
        import torch
        from transformers import AutoModelForMultimodalLM, AutoProcessor
    except ImportError as exc:
        raise EvaluationError(f"GPU evaluation dependency is missing: {exc}") from exc
    if not base_model.is_dir():
        raise EvaluationError(f"base model directory not found: {base_model}")
    processor = AutoProcessor.from_pretrained(str(base_model))
    model = AutoModelForMultimodalLM.from_pretrained(
        str(base_model),
        dtype=torch.bfloat16,
        attn_implementation="flash_attention_2",
        device_map="auto",
    )
    if adapter is not None:
        if not adapter.is_dir():
            raise EvaluationError(f"adapter directory not found: {adapter}")
        try:
            from peft import PeftModel
        except ImportError as exc:
            raise EvaluationError(f"PEFT is required for adapter evaluation: {exc}") from exc
        model = PeftModel.from_pretrained(model, str(adapter), is_trainable=False)
    model.eval()
    return model, processor


def _model_device(model: Any) -> Any:
    device = getattr(model, "device", None)
    if device is not None:
        return device
    try:
        return next(model.parameters()).device
    except (AttributeError, StopIteration) as exc:
        raise EvaluationError("cannot determine evaluation model device") from exc


def _predict_one(
    row: Mapping[str, Any],
    *,
    asset_root: Path,
    model: Any,
    processor: Any,
    max_prompt_tokens: int,
    max_new_tokens: int,
    image_row: Mapping[str, Any] | None = None,
    question_only: bool = False,
) -> dict[str, Any]:
    try:
        import torch
        from qwen_vl_utils import process_vision_info
    except ImportError as exc:
        raise EvaluationError(f"GPU evaluation dependency is missing: {exc}") from exc
    images = [] if question_only else _load_images(image_row or row, asset_root)
    messages = build_messages(row, images=images)
    rendered = processor.apply_chat_template(
        copy.deepcopy(messages),
        tokenize=False,
        add_generation_prompt=True,
        enable_thinking=False,
    )
    image_inputs, video_inputs = process_vision_info(messages)
    processor_kwargs: dict[str, Any] = {
        "text": [rendered],
        "padding": True,
        "return_tensors": "pt",
    }
    if image_inputs:
        processor_kwargs["images"] = image_inputs
    if video_inputs:
        processor_kwargs["videos"] = video_inputs
    encoded = processor(**processor_kwargs)
    prompt_tokens = int(encoded["input_ids"].shape[-1])
    if prompt_tokens > max_prompt_tokens:
        raise EvaluationError(
            f"{row.get('eval_id')}: prompt has {prompt_tokens} tokens, limit is {max_prompt_tokens}"
        )
    encoded = encoded.to(_model_device(model))
    started = time.monotonic()
    with torch.inference_mode():
        generated = model.generate(
            **encoded,
            do_sample=False,
            max_new_tokens=max_new_tokens,
            stop_strings=["</answer>"],
            tokenizer=getattr(processor, "tokenizer", processor),
        )
    elapsed = time.monotonic() - started
    completion_ids = generated[:, encoded["input_ids"].shape[-1] :]
    response = processor.batch_decode(
        completion_ids,
        skip_special_tokens=True,
        clean_up_tokenization_spaces=False,
    )[0]
    token_count = int(completion_ids.shape[-1])
    parsed = parse_answer(response)
    return {
        "response": response,
        "prompt_tokens": prompt_tokens,
        "completion_tokens": token_count,
        "prompt_truncated": False,
        "completion_truncated": bool(token_count >= max_new_tokens and not parsed.valid),
        "latency_seconds": elapsed,
    }


def _existing_predictions(path: Path, *, run_id: str) -> dict[str, dict[str, Any]]:
    if not path.exists():
        return {}
    rows: dict[str, dict[str, Any]] = {}
    try:
        with path.open("r", encoding="utf-8") as handle:
            for line_number, line in enumerate(handle, start=1):
                if not line.strip():
                    continue
                value = json.loads(line)
                if not isinstance(value, dict):
                    raise EvaluationError(f"{path}:{line_number}: prediction is not an object")
                if value.get("run_id") != run_id:
                    raise EvaluationError(f"{path}: existing predictions belong to another run")
                eval_id = value.get("eval_id")
                if not isinstance(eval_id, str) or not eval_id or eval_id in rows:
                    raise EvaluationError(f"{path}: duplicate or empty existing eval_id")
                rows[eval_id] = value
    except (OSError, json.JSONDecodeError) as exc:
        raise EvaluationError(f"cannot resume prediction file {path}: {exc}") from exc
    return rows


def predict_run(
    rows: Sequence[Mapping[str, Any]],
    *,
    run_id: str,
    base_model: Path,
    adapter: Path | None,
    asset_root: Path,
    output_path: Path,
    max_prompt_tokens: int = 4096,
    max_new_tokens: int = 256,
    limit: int | None = None,
    input_mode: str = "standard",
    constant_answer: str | None = None,
) -> dict[str, Any]:
    """Generate one exact, resumable prediction row per evaluation view."""

    if not run_id:
        raise EvaluationError("run_id must be non-empty")
    if max_prompt_tokens <= 0 or max_new_tokens <= 0:
        raise EvaluationError("evaluation token limits must be positive")
    if input_mode not in {"standard", "question_only", "full_image_control"}:
        raise EvaluationError(f"unsupported evaluation input mode: {input_mode!r}")
    if constant_answer is not None and not parse_answer(
        f"<answer>{constant_answer}</answer>"
    ).valid:
        raise EvaluationError("constant answer cannot be encoded by the public answer schema")
    selected = list(rows[:limit] if limit is not None else rows)
    existing = _existing_predictions(output_path, run_id=run_id)
    if any(row.get("input_mode", "standard") != input_mode for row in existing.values()):
        raise EvaluationError("existing predictions use another input mode")
    expected_ids = {str(row.get("eval_id", "")) for row in selected}
    if not set(existing).issubset(expected_ids):
        raise EvaluationError("existing prediction file contains IDs outside this evaluation")
    pending = [row for row in selected if str(row.get("eval_id", "")) not in existing]
    model: Any | None = None
    processor: Any | None = None
    if pending and constant_answer is None:
        model, processor = _load_model(base_model, adapter)
    full_by_group: dict[str, Mapping[str, Any]] = {}
    if input_mode == "full_image_control":
        for row in selected:
            if row.get("state") == "FULL":
                full_by_group[str(row.get("group_id", ""))] = row
        missing_full = sorted(
            {
                str(row.get("group_id", ""))
                for row in selected
                if str(row.get("group_id", "")) not in full_by_group
            }
        )
        if missing_full:
            raise EvaluationError(
                f"full-image control lacks FULL rows for groups: {missing_full[:5]}"
            )
    output_path.parent.mkdir(parents=True, exist_ok=True)
    with output_path.open("a", encoding="utf-8") as handle:
        for index, row in enumerate(pending, start=1):
            if constant_answer is None:
                assert model is not None and processor is not None
                prediction = _predict_one(
                    row,
                    asset_root=asset_root,
                    model=model,
                    processor=processor,
                    max_prompt_tokens=max_prompt_tokens,
                    max_new_tokens=max_new_tokens,
                    image_row=full_by_group.get(str(row.get("group_id", ""))),
                    question_only=input_mode == "question_only",
                )
            else:
                prediction = {
                    "response": f"<answer>{constant_answer}</answer>",
                    "prompt_tokens": 0,
                    "completion_tokens": 0,
                    "prompt_truncated": False,
                    "completion_truncated": False,
                    "latency_seconds": 0.0,
                }
            value = {
                "schema_version": 1,
                "run_id": run_id,
                "eval_id": str(row["eval_id"]),
                "input_mode": input_mode,
                **prediction,
            }
            handle.write(canonical_json(value) + "\n")
            handle.flush()
            if index % 32 == 0:
                os.fsync(handle.fileno())
        if pending:
            os.fsync(handle.fileno())
    all_rows = _existing_predictions(output_path, run_id=run_id)
    truncated = sum(bool(row.get("completion_truncated")) for row in all_rows.values())
    return {
        "run_id": run_id,
        "output": str(output_path.resolve()),
        "expected": len(selected),
        "predicted": len(all_rows),
        "new_predictions": len(pending),
        "completion_truncation_count": truncated,
        "input_mode": input_mode,
        "constant_answer": constant_answer,
        "complete": len(all_rows) == len(selected),
    }