"""Grouped data and pinned-TRL contracts for EVI-PO.

EVI-PO never exposes intervention labels to the model.  The labels below are
loader-side relationships used to bind four independently rendered prompts:

``FULL(I0, a)``, ``CONTROL(Ic, a)``, and
``MISSING(Im, <UNANSWERABLE>)`` are mandatory. ``SUBSTITUTE(Id, a')`` is
optional because real-image sources such as GQA do not have a certified
answer-changing edit.

The evidence target is not a changed-pixel heuristic.  It is the executor's
dependency-node trace projected through the renderer's lossless node map.  The
trainer later projects that pixel ownership mask onto the processor's visual
token grid.
"""

from __future__ import annotations

import copy
import inspect
import json
from collections import defaultdict
from collections.abc import Iterable, Mapping
from dataclasses import dataclass
from pathlib import Path
from typing import Any

from ..certificates.build import certificate_id
from ..hashing import canonical_json_hash
from ..renderers.node_map import decode_uint32_png
from .answers import UNANSWERABLE_TOKEN
from .slots import ComparisonSlot
from .targets import ours_target, target_text

EVI_PO_ADAPTER_VERSION = "evi_po_on_trl_1.9.1_v1"
EVI_RELATION_ORDER = ("FULL", "CONTROL", "SUBSTITUTE", "MISSING")
EVI_REQUIRED_RELATIONS = ("FULL", "CONTROL", "MISSING")

_RELATION_CONTRACT = {
    "FULL": ("FULL", "POSITIVE"),
    "CONTROL": ("A_SAME", "CONTROL"),
    "SUBSTITUTE": ("A_CHANGED", "SUBSTITUTE"),
    "MISSING": ("U_MISSING", "TARGET_EVIDENCE"),
}


class EVIContractError(ValueError):
    """Raised when grouped data cannot support the registered EVI-PO loss."""


@dataclass(frozen=True)
class EVIGroupContract:
    """One complete, question-identical four-view EVI-PO relationship."""

    group_id: str
    base_id: str
    question: str
    answer_type: str
    choices: tuple[dict[str, Any], ...]
    full_answer: str
    substitute_answer: str | None
    relations: tuple[tuple[str, ComparisonSlot], ...]

    @property
    def candidates(self) -> tuple[str, ...]:
        """Finite candidate support used by the FULL/CONTROL JS term."""

        values = [self.full_answer]
        if self.substitute_answer is not None:
            values.append(self.substitute_answer)
        values.append(UNANSWERABLE_TOKEN)
        return tuple(values)

    def relation(self, name: str) -> ComparisonSlot:
        try:
            return dict(self.relations)[name]
        except KeyError:
            raise EVIContractError(f"group {self.group_id}: missing EVI relation {name}") from None


def build_evi_group_contracts(
    slots: Iterable[ComparisonSlot],
) -> dict[str, EVIGroupContract]:
    """Group persisted comparison slots and enforce the EVI relationship.

    ``U_INVALID`` and any future independently scored views may remain in the
    comparison schedule, but they do not replace one of the four directional
    relationship members.
    """

    by_group: dict[str, list[ComparisonSlot]] = defaultdict(list)
    for slot in slots:
        by_group[slot.group_id].append(slot)
    if not by_group:
        raise EVIContractError("cannot build EVI groups from an empty slot sequence")

    grouped: dict[str, EVIGroupContract] = {}
    for group_id, group_slots in by_group.items():
        first = group_slots[0]
        relation_slots: dict[str, ComparisonSlot] = {}
        first_full_hash = canonical_json_hash(first.full_view)
        first_choices_hash = canonical_json_hash(list(first.choices))
        for slot in group_slots:
            if (
                slot.base_id != first.base_id
                or slot.question != first.question
                or slot.answer_type != first.answer_type
                or canonical_json_hash(list(slot.choices)) != first_choices_hash
                or canonical_json_hash(slot.full_view) != first_full_hash
                or target_text(slot.full_answer) != target_text(first.full_answer)
            ):
                raise EVIContractError(
                    f"group {group_id}: prompt, answer, or FULL-view identity drift"
                )
            state = str(slot.selected_view.get("state", ""))
            role = str(slot.selected_view.get("role", ""))
            for relation, expected in _RELATION_CONTRACT.items():
                if (state, role) != expected:
                    continue
                if relation in relation_slots:
                    raise EVIContractError(
                        f"group {group_id}: multiple {relation} relationship views"
                    )
                relation_slots[relation] = slot

        missing = [name for name in EVI_REQUIRED_RELATIONS if name not in relation_slots]
        if missing:
            raise EVIContractError(
                f"group {group_id}: incomplete EVI relationship; missing {', '.join(missing)}"
            )
        full_answer = target_text(first.full_answer)
        if ours_target(relation_slots["FULL"].selected_view, first.full_answer) != full_answer:
            raise EVIContractError(f"group {group_id}: FULL target differs from group answer")
        if ours_target(relation_slots["CONTROL"].selected_view, first.full_answer) != full_answer:
            raise EVIContractError(f"group {group_id}: CONTROL target differs from FULL")
        substitute_answer: str | None = None
        if "SUBSTITUTE" in relation_slots:
            substitute_answer = ours_target(
                relation_slots["SUBSTITUTE"].selected_view,
                first.full_answer,
            )
            if substitute_answer in {full_answer, UNANSWERABLE_TOKEN}:
                raise EVIContractError(
                    f"group {group_id}: SUBSTITUTE target is not a distinct concrete answer"
                )
        if (
            ours_target(relation_slots["MISSING"].selected_view, first.full_answer)
            != UNANSWERABLE_TOKEN
        ):
            raise EVIContractError(f"group {group_id}: MISSING target is not unanswerable")
        grouped[group_id] = EVIGroupContract(
            group_id=group_id,
            base_id=first.base_id,
            question=first.question,
            answer_type=first.answer_type,
            choices=tuple(copy.deepcopy(first.choices)),
            full_answer=full_answer,
            substitute_answer=substitute_answer,
            relations=tuple(
                (name, relation_slots[name])
                for name in EVI_RELATION_ORDER
                if name in relation_slots
            ),
        )
    return grouped


def _load_object(path: Path, label: str) -> dict[str, Any]:
    try:
        value = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError) as exc:
        raise EVIContractError(f"cannot read {label} {path}: {exc}") from exc
    if not isinstance(value, dict):
        raise EVIContractError(f"{label} must be an object: {path}")
    return value


def _inside(root: Path, path: Path, label: str) -> Path:
    resolved_root = root.resolve()
    resolved = path.resolve()
    try:
        resolved.relative_to(resolved_root)
    except ValueError as exc:
        raise EVIContractError(f"{label} escapes dataset root: {path}") from exc
    return resolved


def evidence_spec_for_view(
    view: Mapping[str, Any],
    *,
    dataset_root: str | Path,
) -> dict[str, Any]:
    """Resolve and verify the certificate/node-map inputs for evidence loss.

    Every returned spec carries ``evidence_available``: ``True`` when the
    certified trace projects to at least one source pixel, ``False`` when the
    artifacts are well-formed but the dependency node has no visible footprint
    (a structural property of some GQA/CLEVR renders — the executor depends on
    a node that occupies zero pixels in the lossless node map). A spec with
    ``evidence_available=False`` is a graceful per-group skip signal: the
    trainer drops that group's evidence term while keeping its answer and
    direction terms, so every arm still trains on the same slot set.

    A *total* absence of evidence artifacts (no node map, no source mask, no
    annotation boxes) still fails closed — that is a data defect, not a
    renderable-but-empty trace.
    """

    root = Path(dataset_root).resolve()
    images = view.get("images")
    if not isinstance(images, list) or len(images) != 1 or not isinstance(images[0], Mapping):
        raise EVIContractError("EVI evidence projection requires exactly one image per view")
    raw_image = images[0].get("path")
    if not isinstance(raw_image, str) or not raw_image:
        raise EVIContractError("EVI view image path is missing")
    relative = Path(raw_image)
    if relative.is_absolute() or ".." in relative.parts or "\\" in raw_image:
        raise EVIContractError(f"unsafe EVI image path: {raw_image!r}")
    image_path = _inside(root, root / relative, "EVI image")
    if not image_path.is_file():
        raise EVIContractError(f"EVI image is missing: {image_path}")
    image_width = int(images[0].get("width", 0))
    image_height = int(images[0].get("height", 0))
    if image_width <= 0 or image_height <= 0:
        raise EVIContractError("EVI image dimensions are invalid")

    artifact_dir = image_path.parent
    certificate_path = _inside(root, artifact_dir / "certificate.json", "certificate")
    manifest_path = _inside(root, artifact_dir / "render_manifest.json", "render manifest")
    node_map_path = _inside(root, artifact_dir / "node_map.uint32.png", "node map")
    structured_paths = (certificate_path, manifest_path, node_map_path)
    if all(path.is_file() for path in structured_paths):
        certificate = _load_object(certificate_path, "certificate")
        manifest = _load_object(manifest_path, "render manifest")
        if (
            certificate.get("certificate_id") != view.get("certificate_id")
            or certificate_id(certificate) != certificate.get("certificate_id")
            or certificate.get("view_id") != view.get("view_id")
        ):
            raise EVIContractError(f"view {view.get('view_id')}: certificate identity mismatch")
        program = certificate.get("program")
        dependency_ids = (
            program.get("dependency_node_ids") if isinstance(program, Mapping) else None
        )
        if (
            not isinstance(dependency_ids, list)
            or not dependency_ids
            or any(not isinstance(node_id, str) or not node_id for node_id in dependency_ids)
        ):
            raise EVIContractError(
                f"view {view.get('view_id')}: certificate has no executor dependency trace"
            )
        node_table = manifest.get("node_table")
        if (
            not isinstance(node_table, list)
            or not node_table
            or node_table[0] != "__background__"
            or any(not isinstance(node_id, str) for node_id in node_table)
        ):
            raise EVIContractError(f"view {view.get('view_id')}: malformed node table")

        try:
            owners = decode_uint32_png(node_map_path.read_bytes())
            import numpy as np

            owner_indices = [
                node_table.index(node_id) for node_id in dependency_ids if node_id in node_table
            ]
            evidence_pixels = int(np.isin(owners, owner_indices).sum()) if owner_indices else 0
            height, width = (int(value) for value in owners.shape)
        except (OSError, TypeError, ValueError) as exc:
            raise EVIContractError(
                f"view {view.get('view_id')}: cannot decode executor evidence mask: {exc}"
            ) from exc
        if (
            (width, height) != (image_width, image_height)
            or manifest.get("width") != width
            or manifest.get("height") != height
        ):
            raise EVIContractError(f"view {view.get('view_id')}: node-map/image dimensions differ")
        return {
            "schema_version": 1,
            "source": "executor_dependency_nodes_projected_through_node_map",
            "certificate_path": str(certificate_path),
            "certificate_id": str(certificate["certificate_id"]),
            "render_manifest_path": str(manifest_path),
            "render_manifest_sha256": view.get("render_manifest_sha256"),
            "node_map_path": str(node_map_path),
            "node_map_sha256": manifest.get("node_map_sha256"),
            "dependency_node_ids": list(dependency_ids),
            "node_table": list(node_table),
            "width": width,
            "height": height,
            "positive_pixel_count": evidence_pixels,
            "evidence_available": evidence_pixels > 0,
        }
    if any(path.exists() for path in structured_paths):
        raise EVIContractError(
            f"view {view.get('view_id')}: structured evidence artifacts are incomplete"
        )

    # Real-image sources can carry a source-native binary evidence mask.
    raw_mask_path = view.get("evidence_mask_path", images[0].get("evidence_mask_path"))
    raw_mask_sha = view.get("evidence_mask_sha256", images[0].get("evidence_mask_sha256"))
    if isinstance(raw_mask_path, str) and raw_mask_path:
        relative_mask = Path(raw_mask_path)
        if relative_mask.is_absolute() or ".." in relative_mask.parts or "\\" in raw_mask_path:
            raise EVIContractError(f"unsafe evidence-mask path: {raw_mask_path!r}")
        mask_path = _inside(root, root / relative_mask, "evidence mask")
        if not mask_path.is_file():
            raise EVIContractError(f"view {view.get('view_id')}: evidence mask is missing")
        try:
            import numpy as np
            from PIL import Image

            with Image.open(mask_path) as mask_image:
                mask = np.asarray(mask_image.convert("L")) > 0
            height, width = (int(value) for value in mask.shape)
            evidence_pixels = int(mask.sum())
        except (OSError, TypeError, ValueError) as exc:
            raise EVIContractError(
                f"view {view.get('view_id')}: cannot decode explicit evidence mask: {exc}"
            ) from exc
        if (width, height) != (image_width, image_height):
            raise EVIContractError(
                f"view {view.get('view_id')}: evidence-mask/image dimensions differ"
            )
        return {
            "schema_version": 1,
            "source": "source_annotation_explicit_mask",
            "mask_path": str(mask_path),
            "mask_sha256": raw_mask_sha,
            "width": width,
            "height": height,
            "positive_pixel_count": evidence_pixels,
            "evidence_available": evidence_pixels > 0,
        }

    # Or it can carry one or more source-annotation boxes in source pixels.
    raw_regions = view.get("regions")
    annotation_regions: list[dict[str, Any]] = []
    width = image_width
    height = image_height
    if isinstance(raw_regions, list):
        for region in raw_regions:
            if not isinstance(region, Mapping) or region.get("source") != "source_annotation":
                continue
            bbox = region.get("bbox_xyxy")
            if (
                region.get("image_index") != 0
                or not isinstance(bbox, list)
                or len(bbox) != 4
                or any(
                    isinstance(value, bool) or not isinstance(value, int | float) for value in bbox
                )
            ):
                raise EVIContractError(
                    f"view {view.get('view_id')}: malformed source evidence region"
                )
            x0, y0, x1, y1 = (float(value) for value in bbox)
            if not (0 <= x0 < x1 <= width and 0 <= y0 < y1 <= height):
                raise EVIContractError(
                    f"view {view.get('view_id')}: source evidence region is out of bounds"
                )
            annotation_regions.append(
                {
                    "region_id": str(region.get("region_id", "")),
                    "bbox_xyxy": [x0, y0, x1, y1],
                }
            )
    if annotation_regions:
        evidence_pixels = int(
            sum(
                (region["bbox_xyxy"][2] - region["bbox_xyxy"][0])
                * (region["bbox_xyxy"][3] - region["bbox_xyxy"][1])
                for region in annotation_regions
            )
        )
        return {
            "schema_version": 1,
            "source": "source_annotation_bboxes",
            "regions": annotation_regions,
            "width": width,
            "height": height,
            "positive_pixel_count": evidence_pixels,
            "evidence_available": evidence_pixels > 0,
        }
    raise EVIContractError(
        f"view {view.get('view_id')}: no executor node map or source-annotation evidence"
    )


def validate_trl_parent_contract(grpo_trainer_class: Any) -> None:
    """Fail when the private TRL methods used by the adapter have drifted."""

    loss_parameters = tuple(inspect.signature(grpo_trainer_class._compute_loss).parameters)
    if loss_parameters != ("self", "model", "inputs"):
        raise RuntimeError(f"unsupported GRPOTrainer._compute_loss signature: {loss_parameters}")
    generation_parameters = tuple(
        inspect.signature(grpo_trainer_class._generate_and_score_completions).parameters
    )
    if generation_parameters != ("self", "inputs"):
        raise RuntimeError(
            "unsupported GRPOTrainer._generate_and_score_completions signature: "
            f"{generation_parameters}"
        )
    preparation_parameters = tuple(inspect.signature(grpo_trainer_class._prepare_inputs).parameters)
    if preparation_parameters != ("self", "generation_batch"):
        raise RuntimeError(
            f"unsupported GRPOTrainer._prepare_inputs signature: {preparation_parameters}"
        )