from __future__ import annotations

import base64
import hashlib
import io
import random
from pathlib import Path
from typing import Any

from .models import BenchCase


def _png_data(image: Any) -> tuple[str, str, bytes]:
    stream = io.BytesIO()
    image.save(stream, format="PNG")
    data = stream.getvalue()
    digest = hashlib.sha256(data).hexdigest()
    return "data:image/png;base64," + base64.b64encode(data).decode("ascii"), digest, data


def _message(prompt: str, images: list[str]) -> list[dict[str, Any]]:
    content: list[dict[str, Any]] = [{"type": "text", "text": prompt}]
    content.extend({"type": "image_url", "image_url": {"url": value}} for value in images)
    return [
        {"role": "system", "content": "Inspect every supplied image and return only bare JSON."},
        {"role": "user", "content": content},
    ]


def generate_vision_cases(output_dir: Path, seeds: list[int]) -> list[BenchCase]:
    try:
        from PIL import Image, ImageDraw, ImageFont
    except ImportError as exc:
        raise RuntimeError("Install shiftedx-bench[vision] to generate vision fixtures") from exc
    output_dir.mkdir(parents=True, exist_ok=True)
    font = ImageFont.load_default(size=28)
    cases = []
    for seed in seeds:
        rng = random.Random(seed)
        code = f"SX-{rng.randrange(1000,9999)}-{rng.choice(['OPAL','RAVEN','CEDAR'])}"
        image = Image.new("RGB", (900, 300), "#f5f1e8")
        draw = ImageDraw.Draw(image)
        draw.rectangle((40, 35, 860, 265), outline="#111111", width=5)
        draw.text((90, 115), code, fill="#111111", font=font)
        uri, digest, data = _png_data(image)
        (output_dir / f"ocr-s{seed}.png").write_bytes(data)
        cases.append(
            BenchCase(
                case_id=f"ocr__s{seed}", suite_id="shiftedx-vision-v1", lane="vision",
                messages=_message("Read the boxed identifier. Return JSON with key identifier.", [uri]),
                scorer="strict_json_exact", expected={"identifier": code}, max_output_tokens=1024,
                metadata={"family": "ocr", "fixture_sha256": [digest]},
            )
        )

        values = [rng.randrange(2, 10) for _ in range(4)]
        labels = ["A", "B", "C", "D"]
        chart = Image.new("RGB", (900, 550), "white")
        draw = ImageDraw.Draw(chart)
        colors = ["#e63946", "#457b9d", "#2a9d8f", "#f4a261"]
        for index, (label, value) in enumerate(zip(labels, values)):
            x0 = 100 + index * 190
            draw.rectangle((x0, 470 - value * 38, x0 + 100, 470), fill=colors[index])
            draw.text((x0 + 35, 480), label, fill="black", font=font)
            draw.text((x0 + 35, 430 - value * 38), str(value), fill="black", font=font)
        uri, digest, data = _png_data(chart)
        (output_dir / f"chart-s{seed}.png").write_bytes(data)
        maximum = max(values)
        cases.append(
            BenchCase(
                case_id=f"chart__s{seed}", suite_id="shiftedx-vision-v1", lane="vision",
                messages=_message(
                    "Return bare JSON with exactly two keys: tallest (the tallest bar's label) and sum "
                    "(the sum of all four values).",
                    [uri],
                ),
                scorer="strict_json_exact",
                expected={"tallest": labels[values.index(maximum)], "sum": sum(values)}, max_output_tokens=1024,
                metadata={"family": "chart", "fixture_sha256": [digest]},
            )
        )

        spatial = Image.new("RGB", (900, 360), "#eeeeee")
        draw = ImageDraw.Draw(spatial)
        order = ["red", "green", "blue"]
        rng.shuffle(order)
        color_values = {"red": "#d62828", "green": "#2a9d4b", "blue": "#2463eb"}
        for index, color in enumerate(order):
            x = 170 + index * 280
            draw.ellipse((x - 70, 110, x + 70, 250), fill=color_values[color])
        uri, digest, data = _png_data(spatial)
        (output_dir / f"spatial-s{seed}.png").write_bytes(data)
        cases.append(
            BenchCase(
                case_id=f"spatial__s{seed}", suite_id="shiftedx-vision-v1", lane="vision",
                messages=_message("List the circle colors from left to right as a JSON array.", [uri]),
                scorer="strict_json_exact", expected=order, max_output_tokens=1024,
                metadata={"family": "spatial", "fixture_sha256": [digest]},
            )
        )

        before = Image.new("RGB", (500, 240), "white")
        after = Image.new("RGB", (500, 240), "white")
        for canvas, status in ((before, "PENDING"), (after, "COMPLETE")):
            draw = ImageDraw.Draw(canvas)
            draw.rectangle((30, 30, 470, 210), outline="black", width=4)
            draw.text((90, 100), f"JOB {seed}: {status}", fill="black", font=font)
        uri_a, digest_a, data_a = _png_data(before)
        uri_b, digest_b, data_b = _png_data(after)
        (output_dir / f"multi-before-s{seed}.png").write_bytes(data_a)
        (output_dir / f"multi-after-s{seed}.png").write_bytes(data_b)
        cases.append(
            BenchCase(
                case_id=f"multi_image__s{seed}", suite_id="shiftedx-vision-v1", lane="vision",
                messages=_message(
                    "Compare image one with image two. Return bare JSON with exactly three keys: job "
                    "(the numeric job number), from (the first status), and to (the second status).",
                    [uri_a, uri_b],
                ),
                scorer="strict_json_exact", expected={"job": seed, "from": "PENDING", "to": "COMPLETE"},
                max_output_tokens=1024,
                metadata={"family": "multi-image", "fixture_sha256": [digest_a, digest_b]},
            )
        )
    return cases