"""Official CLEVR Blender 2.79/Cycles release renderer.

The release renderer reconstructs a normalized CLEVR world with the official
``base_scene.blend``, shape meshes, material library, and ``utils.py`` loader.
The same Cycles invocation emits both the RGB observation and the Object Index
pass used as the semantic node map.  The lightweight Pillow renderer remains a
unit-test helper; it is not an allowed production release backend.
"""

from __future__ import annotations

import io
import os
import struct
import subprocess
import tempfile
from dataclasses import dataclass
from pathlib import Path
from typing import Any

from ..hashing import canonical_json, canonical_json_hash, sha256_bytes
from ..sources.base import World
from ..sources.world_ops import hidden_nodes, world_sha256
from .base import (
    RenderedAssets,
    RenderError,
    _encode_uint32_png,
    validate_rendered_assets,
)


class ClevrBlenderVisibilityError(RenderError):
    """A structurally valid CLEVR world is not fully observable in the render."""


_BLENDER_TIMEOUT_RETRIES = 2


@dataclass(frozen=True)
class ClevrBlenderConfig:
    blender_executable: Path
    dataset_gen_root: Path
    dataset_gen_revision: str | None = None
    runtime_library_dir: Path | None = None
    bridge_script: Path | None = None
    samples: int = 32
    timeout_seconds: int = 300

    @property
    def image_generation_dir(self) -> Path:
        return self.dataset_gen_root / "image_generation"

    @property
    def base_scene_blendfile(self) -> Path:
        return self.image_generation_dir / "data" / "base_scene.blend"

    @property
    def shape_dir(self) -> Path:
        return self.image_generation_dir / "data" / "shapes"

    @property
    def material_dir(self) -> Path:
        return self.image_generation_dir / "data" / "materials"

    def resolved_bridge_script(self) -> Path:
        if self.bridge_script is not None:
            return self.bridge_script
        return Path(__file__).resolve().parents[3] / "scripts" / "render_clevr_scene_blender.py"


@dataclass(frozen=True)
class ClevrBlenderResult:
    rgba_png: bytes
    node_map_png: bytes
    node_table: tuple[str, ...]
    node_pixel_counts: dict[str, int]
    renderer_spec: dict[str, Any]
    invocation_sha256: str

    @property
    def rgba_sha256(self) -> str:
        return sha256_bytes(self.rgba_png)

    @property
    def node_map_sha256(self) -> str:
        return sha256_bytes(self.node_map_png)


def blender_renderer_spec(config: ClevrBlenderConfig) -> dict[str, Any]:
    """Return the pinned-input contract recorded alongside a Blender render."""

    return {
        "renderer_name": "clevr_official_blender_bridge",
        "renderer_version": "2",
        "backend": "blender_2_79",
        "observation_output": "rgba_png",
        "node_map_authority": "cycles_object_index_pass",
        "blender_release": "2.79b-linux-glibc219-x86_64",
        "dataset_gen_repository": "facebookresearch/clevr-dataset-gen",
        "dataset_gen_revision": config.dataset_gen_revision,
        "base_scene_blendfile": "image_generation/data/base_scene.blend",
        "shape_dir": "image_generation/data/shapes",
        "material_dir": "image_generation/data/materials",
        "bridge_script": "scripts/render_clevr_scene_blender.py",
        "samples": config.samples,
    }


def _blender_seed(seed: int) -> int:
    """Map stable unsigned item seeds into Blender 2.79's signed IntProperty."""

    return seed & 0x7FFFFFFF


def render_clevr_blender_rgba(
    world: World,
    *,
    config: ClevrBlenderConfig,
    seed: int,
    width: int = 480,
    height: int = 320,
) -> ClevrBlenderResult:
    """Render observation and semantic ownership through official CLEVR assets."""

    if world.get("world_schema") != "clevr_world_v1":
        raise RenderError("Blender bridge requires clevr_world_v1")
    _validate_config(config)
    backend_seed = _blender_seed(seed)
    invocation = {
        "world_sha256": canonical_json_hash(world),
        "seed": seed,
        "backend_seed": backend_seed,
        "width": width,
        "height": height,
        "renderer_spec": blender_renderer_spec(config),
    }
    with tempfile.TemporaryDirectory(prefix="explicit-clevr-blender-") as temp:
        temp_dir = Path(temp)
        world_path = temp_dir / "world.json"
        output_path = temp_dir / "rgba.png"
        node_map_raw_path = temp_dir / "node-map.uint32.raw"
        world_path.write_text(canonical_json(world), encoding="utf-8")
        command = [
            str(config.blender_executable),
            "--background",
            "--python",
            str(config.resolved_bridge_script()),
            "--",
            "--world-json",
            str(world_path),
            "--output",
            str(output_path),
            "--node-map-raw",
            str(node_map_raw_path),
            "--image-generation-dir",
            str(config.image_generation_dir),
            "--base-scene",
            str(config.base_scene_blendfile),
            "--shape-dir",
            str(config.shape_dir),
            "--material-dir",
            str(config.material_dir),
            "--seed",
            str(backend_seed),
            "--width",
            str(width),
            "--height",
            str(height),
            "--samples",
            str(config.samples),
        ]
        env = dict(os.environ)
        if config.runtime_library_dir is not None:
            existing = env.get("LD_LIBRARY_PATH")
            env["LD_LIBRARY_PATH"] = (
                f"{config.runtime_library_dir}{os.pathsep}{existing}"
                if existing
                else str(config.runtime_library_dir)
            )
        completed = _run_blender_command(
            command,
            env=env,
            timeout_seconds=config.timeout_seconds,
        )
        if completed.returncode != 0:
            stderr = completed.stderr.decode("utf-8", errors="replace")[-4000:]
            raise RenderError(f"CLEVR Blender bridge exited {completed.returncode}: {stderr}")
        if not output_path.is_file():
            logs = (
                completed.stdout.decode("utf-8", errors="replace")
                + completed.stderr.decode("utf-8", errors="replace")
            )[-4000:]
            raise RenderError(f"CLEVR Blender bridge produced no rgba.png: {logs}")
        rgba_png = output_path.read_bytes()
        if not rgba_png.startswith(b"\x89PNG\r\n\x1a\n"):
            raise RenderError("CLEVR Blender bridge output is not a PNG")
        rgba_png = _canonical_rgba_png(rgba_png, width=width, height=height)
        node_map_png, node_table, node_pixel_counts = _load_node_map(
            node_map_raw_path,
            world=world,
            width=width,
            height=height,
        )
    return ClevrBlenderResult(
        rgba_png=rgba_png,
        node_map_png=node_map_png,
        node_table=node_table,
        node_pixel_counts=node_pixel_counts,
        renderer_spec=blender_renderer_spec(config),
        invocation_sha256=canonical_json_hash(invocation),
    )


def _run_blender_command(
    command: list[str],
    *,
    env: dict[str, str],
    timeout_seconds: int,
) -> subprocess.CompletedProcess[bytes]:
    """Retry legacy Blender futex timeouts without changing the render input.

    Blender 2.79 occasionally remains asleep in a futex wait after many
    successful background invocations.  ``subprocess.run`` kills and reaps the
    timed-out process, so retrying the exact command in a fresh process
    preserves the deterministic candidate and renderer inputs.  Other launch
    failures remain immediate hard failures, and persistent timeouts still fail
    the release instead of silently changing the selected dataset.
    """

    timeout: subprocess.TimeoutExpired | None = None
    for _attempt in range(_BLENDER_TIMEOUT_RETRIES + 1):
        try:
            return subprocess.run(
                command,
                env=env,
                check=False,
                capture_output=True,
                timeout=timeout_seconds,
            )
        except subprocess.TimeoutExpired as exc:
            timeout = exc
        except OSError as exc:
            raise RenderError(f"CLEVR Blender bridge failed to start: {exc}") from exc
    assert timeout is not None
    raise RenderError(
        f"CLEVR Blender bridge timed out after {_BLENDER_TIMEOUT_RETRIES + 1} attempts: {timeout}"
    ) from timeout


def _canonical_rgba_png(payload: bytes, *, width: int, height: int) -> bytes:
    """Strip Blender metadata and encode only the observed RGBA pixels."""

    from PIL import Image

    try:
        with Image.open(io.BytesIO(payload)) as image:
            rgba = image.convert("RGBA")
            rgba.load()
    except (OSError, ValueError) as exc:
        raise RenderError(f"CLEVR Blender observation cannot be decoded: {exc}") from exc
    if rgba.size != (width, height):
        raise RenderError(
            f"CLEVR Blender observation dimensions differ: {rgba.size} != {(width, height)}"
        )
    output = io.BytesIO()
    rgba.save(
        output,
        format="PNG",
        optimize=False,
        compress_level=9,
    )
    return output.getvalue()


def render_clevr_blender_assets(
    world: World,
    *,
    config: ClevrBlenderConfig,
    renderer_id: str,
    seed: int,
    width: int = 480,
    height: int = 320,
) -> RenderedAssets:
    """Return the repository's standard asset contract from one Blender render."""

    result = render_clevr_blender_rgba(
        world,
        config=config,
        seed=seed,
        width=width,
        height=height,
    )
    visible = list(result.node_table[1:])
    hidden = sorted(hidden_nodes(world))
    spec = result.renderer_spec
    manifest = {
        "renderer_id": renderer_id,
        "renderer_name": str(spec["renderer_name"]),
        "renderer_version": str(spec["renderer_version"]),
        "backend": str(spec["backend"]),
        "backend_version": "2.79b",
        "font_name": None,
        "font_sha256": None,
        "locale": "C",
        "seed": seed,
        "backend_seed": _blender_seed(seed),
        "width": width,
        "height": height,
        "world_sha256": world_sha256(world),
        "rgba_sha256": result.rgba_sha256,
        "node_map_sha256": result.node_map_sha256,
        "node_table": list(result.node_table),
        "visible_node_ids": visible,
        "hidden_node_ids": hidden,
        "node_map_coverage": {node_id: result.node_pixel_counts[node_id] for node_id in visible},
        "text_glyph_count": 0,
        "official_clevr_assets": {
            "base_scene": str(spec["base_scene_blendfile"]),
            "shape_dir": str(spec["shape_dir"]),
            "material_dir": str(spec["material_dir"]),
            "samples": int(spec["samples"]),
            "node_map_pass": str(spec["node_map_authority"]),
        },
        "invocation_sha256": result.invocation_sha256,
    }
    assets = RenderedAssets(
        rgba_png=result.rgba_png,
        node_map_png=result.node_map_png,
        render_manifest=manifest,
        text_manifest={"world_sha256": world_sha256(world), "glyphs": []},
    )
    validate_rendered_assets(assets)
    return assets


def _load_node_map(
    path: Path,
    *,
    world: World,
    width: int,
    height: int,
) -> tuple[bytes, tuple[str, ...], dict[str, int]]:
    import numpy as np

    try:
        payload = path.read_bytes()
    except OSError as exc:
        raise RenderError(f"CLEVR Blender node-map pass is missing: {exc}") from exc
    if len(payload) < 8:
        raise RenderError("CLEVR Blender node-map pass is truncated")
    raw_width, raw_height = struct.unpack("<II", payload[:8])
    expected_bytes = 8 + raw_width * raw_height * 4
    if (raw_width, raw_height) != (width, height) or len(payload) != expected_bytes:
        raise RenderError(
            "CLEVR Blender node-map dimensions/bytes differ from the requested render"
        )
    owners = np.frombuffer(payload, dtype="<u4", offset=8).reshape((height, width))
    owners = np.flipud(owners).copy()
    hidden = hidden_nodes(world)
    objects = world.get("objects")
    if not isinstance(objects, list):
        raise RenderError("CLEVR Blender world objects must be an array")
    visible_ids = tuple(
        sorted(
            str(item["id"])
            for item in objects
            if isinstance(item, dict)
            and isinstance(item.get("id"), str)
            and item["id"] not in hidden
        )
    )
    node_table = ("__background__", *visible_ids)
    if owners.size and int(owners.max()) >= len(node_table):
        raise RenderError("CLEVR Blender node map references an unknown semantic object")
    counts = {
        node_id: int(np.count_nonzero(owners == index))
        for index, node_id in enumerate(node_table[1:], start=1)
    }
    missing = [node_id for node_id, count in counts.items() if count <= 0]
    if missing:
        raise ClevrBlenderVisibilityError(
            f"CLEVR Blender render fully occluded semantic objects: {missing}"
        )
    return _encode_uint32_png(owners), node_table, counts


def _validate_config(config: ClevrBlenderConfig) -> None:
    required = (
        ("blender executable", config.blender_executable),
        ("image generation directory", config.image_generation_dir),
        ("base scene", config.base_scene_blendfile),
        ("shape directory", config.shape_dir),
        ("material directory", config.material_dir),
        ("bridge script", config.resolved_bridge_script()),
    )
    missing = [f"{label}: {path}" for label, path in required if not path.exists()]
    if missing:
        raise RenderError("CLEVR Blender bridge inputs missing: " + "; ".join(missing))
    if config.samples < 1:
        raise RenderError("CLEVR Blender samples must be positive")
    if config.dataset_gen_revision is not None and (
        len(config.dataset_gen_revision) != 40
        or any(char not in "0123456789abcdef" for char in config.dataset_gen_revision)
    ):
        raise RenderError("CLEVR dataset-gen revision must be full 40-hex")


__all__ = [
    "ClevrBlenderConfig",
    "ClevrBlenderResult",
    "ClevrBlenderVisibilityError",
    "blender_renderer_spec",
    "render_clevr_blender_assets",
    "render_clevr_blender_rgba",
]