from __future__ import annotations

import json
import os
import re
from dataclasses import dataclass
from pathlib import Path


def parse_json_object(text: str) -> dict:
    cleaned = text.strip()
    cleaned = re.sub(r"^```(?:json)?\s*", "", cleaned, flags=re.IGNORECASE)
    cleaned = re.sub(r"\s*```$", "", cleaned)
    try:
        value = json.loads(cleaned)
    except json.JSONDecodeError:
        start = cleaned.find("{")
        end = cleaned.rfind("}")
        if start < 0 or end <= start:
            raise ValueError(f"Judge response does not contain a JSON object: {text[:300]}")
        value = json.loads(cleaned[start : end + 1])
    if not isinstance(value, dict):
        raise ValueError("Judge response must be a JSON object")
    return value


def validate_scores(result: dict, metric_names: list[str], minimum: int, maximum: int) -> dict:
    validated = dict(result)
    for metric in metric_names:
        if metric in result:
            key = metric
        else:
            key = metric if metric.endswith("_score") else f"{metric}_score"
        if key not in result:
            raise ValueError(f"Judge response is missing {key}")
        value = int(result[key])
        if not minimum <= value <= maximum:
            raise ValueError(f"{key}={value} is outside [{minimum}, {maximum}]")
        validated[key] = value
    return validated


def sample_video_frames(video_path: str | Path, max_frames: int = 16) -> list[bytes]:
    try:
        import cv2
        import numpy as np
    except ImportError as exc:
        raise RuntimeError("Install the package dependencies to read videos") from exc

    capture = cv2.VideoCapture(str(video_path))
    if not capture.isOpened():
        raise ValueError(f"Cannot open video: {video_path}")
    total = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
    if total <= 0:
        capture.release()
        raise ValueError(f"Video contains no readable frames: {video_path}")
    indices = np.linspace(0, total - 1, num=min(max_frames, total), dtype=int)
    frames = []
    for index in indices:
        capture.set(cv2.CAP_PROP_POS_FRAMES, int(index))
        ok, frame = capture.read()
        if not ok:
            continue
        ok, encoded = cv2.imencode(".jpg", frame)
        if ok:
            frames.append(encoded.tobytes())
    capture.release()
    if not frames:
        raise ValueError(f"No frames could be decoded from {video_path}")
    return frames


@dataclass
class GeminiJudge:
    model: str
    api_key: str | None = None

    def __post_init__(self) -> None:
        try:
            from google import genai
        except ImportError as exc:
            raise RuntimeError("Install google-genai before running evaluation") from exc
        key = self.api_key or os.getenv("GEMINI_API_KEY")
        if not key:
            raise RuntimeError("Set GEMINI_API_KEY; credentials are never read from source files")
        self._genai = genai
        self._client = genai.Client(api_key=key)

    def _generate(self, prompt: str, images: list[bytes]) -> dict:
        from google.genai import types

        parts = [
            types.Part.from_bytes(data=image, mime_type="image/jpeg")
            for image in images
        ]
        parts.append(types.Part.from_text(text=prompt))
        response = self._client.models.generate_content(
            model=self.model,
            contents=[types.Content(role="user", parts=parts)],
            config=types.GenerateContentConfig(
                temperature=0,
                response_mime_type="application/json",
            ),
        )
        text = getattr(response, "text", None)
        if not text:
            candidates = getattr(response, "candidates", []) or []
            chunks = []
            for candidate in candidates:
                content = getattr(candidate, "content", None)
                for part in getattr(content, "parts", []) or []:
                    if getattr(part, "text", None) and not getattr(part, "thought", False):
                        chunks.append(part.text)
            text = "\n".join(chunks)
        if not text:
            raise ValueError("Judge returned no textual response")
        return parse_json_object(text)

    def evaluate_frames(self, prompt: str, frames: list[bytes]) -> dict:
        return self._generate(prompt, frames)