"""Deterministic executor for official CLEVR functional programs."""

from __future__ import annotations

from collections.abc import Mapping, Sequence
from typing import Any

from ..dsl.ast import Arg, AstNode, Program
from ..sources.base import World
from .base import (
    AnswerValue,
    ExecutionResult,
    ExecutionStatus,
    ExecutorError,
    _InvalidReferent,
    _MissingInformation,
    _Trace,
    literal_value,
    serialize_answer,
)

NAME = "clevr_executor"
VERSION = "clevr_dsl_v1/1"
_ATTRIBUTES = frozenset({"color", "material", "shape", "size"})
_RELATIONS = frozenset({"left", "right", "front", "behind"})


class ClevrExecutor:
    """Evaluate a CLEVR AST over a normalized ``clevr_world_v1`` scene."""

    name = NAME
    version = VERSION

    def execute(self, program: Program, *, world: World) -> ExecutionResult:
        trace = _Trace()
        referent_cardinality: int | None = None
        status: ExecutionStatus
        try:
            if program.dsl != "clevr_dsl_v1" or program.compile_status != "compiled":
                raise ExecutorError("executor requires a compiled clevr_dsl_v1 program")
            if world.get("world_schema") != "clevr_world_v1":
                raise ExecutorError(
                    f"clevr executor cannot read world_schema {world.get('world_schema')!r}"
                )
            referent_cardinality = self._check_referent(program, world, trace)
            value = self._eval(program.program, world, trace)
            answer = self._project_answer(program.program, value)
            _steps, dependencies, trace_hash = trace.finish()
            return ExecutionResult(
                status="UNIQUE",
                answer_value=answer,
                answer_canonical=serialize_answer(
                    answer,
                    return_type=program.program.return_type,
                ),
                dependency_node_ids=dependencies,
                referent_cardinality=referent_cardinality,
                trace_sha256=trace_hash,
                executor_name=self.name,
                executor_version=self.version,
            )
        except _MissingInformation:
            status = "MISSING_INFORMATION"
        except _InvalidReferent:
            status = "INVALID_REFERENT"
        except ExecutorError:
            status = "ERROR"
        _steps, dependencies, trace_hash = trace.finish()
        return ExecutionResult(
            status=status,
            answer_value=None,
            answer_canonical=None,
            dependency_node_ids=dependencies,
            referent_cardinality=(
                referent_cardinality
                if referent_cardinality is not None
                else self._safe_referent_cardinality(program, world)
            ),
            trace_sha256=trace_hash,
            executor_name=self.name,
            executor_version=self.version,
        )

    def execute_selector(self, selector: AstNode, *, world: World) -> tuple[str, ...]:
        """Resolve an object/object-set selector without applying ``UNIQUE``."""

        trace = _Trace()
        if selector.op == "UNIQUE":
            if len(selector.args) != 1 or not isinstance(selector.args[0], AstNode):
                raise ExecutorError("UNIQUE selector is malformed")
            value = self._eval(selector.args[0], world, trace)
        else:
            value = self._eval(selector, world, trace)
        if isinstance(value, Mapping):
            node_id = value.get("id")
            return (str(node_id),) if node_id else ()
        if isinstance(value, tuple):
            return tuple(
                str(item["id"]) for item in value if isinstance(item, Mapping) and item.get("id")
            )
        raise ExecutorError(f"selector {selector.op!r} did not produce objects")

    def _check_referent(self, program: Program, world: World, trace: _Trace) -> int | None:
        selector = program.referent_selector
        required = program.required_referent_cardinality
        if selector is None:
            return None
        refs = self.execute_selector(selector, world=world)
        trace.record("REFERENT", refs, len(refs))
        if required is not None and len(refs) != required:
            raise _InvalidReferent(
                f"scalar referent cardinality {len(refs)} != required {required}"
            )
        return len(refs)

    def _safe_referent_cardinality(self, program: Program, world: World) -> int | None:
        if program.referent_selector is None:
            return None
        try:
            return len(self.execute_selector(program.referent_selector, world=world))
        except (ExecutorError, _MissingInformation, _InvalidReferent):
            return None

    def _eval(self, node: Arg, world: World, trace: _Trace) -> Any:
        if not isinstance(node, AstNode):
            raise ExecutorError(f"expected AST node, got {type(node).__name__}")
        op = node.op
        if op == "LITERAL":
            return literal_value(node)
        if op == "SCENE":
            objects = _objects(world)
            trace.record("SCENE", (), len(objects))
            return objects
        if op.startswith("FILTER_"):
            return self._filter(op.removeprefix("FILTER_").lower(), node, world, trace)
        if op == "UNIQUE":
            unique_values = _object_set(self._eval_arg(node, 0, world, trace), op)
            trace.record(op, unique_values, len(unique_values))
            if len(unique_values) != 1:
                raise _InvalidReferent(f"UNIQUE received {len(unique_values)} objects")
            return unique_values[0]
        if op == "RELATE":
            source = _object(self._eval_arg(node, 0, world, trace), op)
            relation = _string(self._eval_arg(node, 1, world, trace), op)
            related_values = _related(world, str(source["id"]), relation)
            trace.record(op, (source, *related_values), len(related_values))
            return related_values
        if op.startswith("SAME_"):
            attribute = op.removeprefix("SAME_").lower()
            source = _object(self._eval_arg(node, 0, world, trace), op)
            target = _attribute(source, attribute)
            same_values: list[Mapping[str, Any]] = []
            for candidate in _objects(world):
                if candidate.get("id") == source.get("id"):
                    continue
                if _attribute(candidate, attribute) == target:
                    same_values.append(candidate)
            same_result = _ordered(same_values)
            trace.record(op, (source, *same_result), len(same_result))
            return same_result
        if op in {"UNION", "INTERSECT"}:
            left = _object_set(self._eval_arg(node, 0, world, trace), op)
            right = _object_set(self._eval_arg(node, 1, world, trace), op)
            left_by_id = {str(item["id"]): item for item in left}
            right_by_id = {str(item["id"]): item for item in right}
            ids = (
                set(left_by_id).union(right_by_id)
                if op == "UNION"
                else set(left_by_id).intersection(right_by_id)
            )
            set_result = tuple((left_by_id | right_by_id)[node_id] for node_id in sorted(ids))
            trace.record(op, set_result, len(set_result))
            return set_result
        if op == "COUNT":
            count_values = _object_set(self._eval_arg(node, 0, world, trace), op)
            trace.record(op, count_values, len(count_values))
            return len(count_values)
        if op == "EXIST":
            exist_values = _object_set(self._eval_arg(node, 0, world, trace), op)
            exists = bool(exist_values)
            trace.record(op, exist_values, exists)
            return exists
        if op.startswith("QUERY_"):
            attribute = op.removeprefix("QUERY_").lower()
            obj = _object(self._eval_arg(node, 0, world, trace), op)
            value = _attribute(obj, attribute)
            trace.record(op, obj, value)
            return value
        if op.startswith("EQUAL_"):
            left = self._eval_arg(node, 0, world, trace)
            right = self._eval_arg(node, 1, world, trace)
            comparison = _comparable(left) == _comparable(right)
            trace.record(op, (), comparison)
            return comparison
        if op in {"LESS_THAN", "GREATER_THAN"}:
            left_integer = _integer(self._eval_arg(node, 0, world, trace), op)
            right_integer = _integer(self._eval_arg(node, 1, world, trace), op)
            comparison = (
                left_integer < right_integer if op == "LESS_THAN" else left_integer > right_integer
            )
            trace.record(op, (), comparison)
            return comparison
        raise ExecutorError(f"unsupported CLEVR op {op!r}")

    def _eval_arg(
        self,
        node: AstNode,
        position: int,
        world: World,
        trace: _Trace,
    ) -> Any:
        try:
            arg = node.args[position]
        except IndexError as exc:
            raise ExecutorError(f"{node.op} has no operand {position}") from exc
        if not isinstance(arg, AstNode):
            raise ExecutorError(f"{node.op} operand {position} is not an AST node")
        return self._eval(arg, world, trace)

    def _filter(
        self,
        attribute: str,
        node: AstNode,
        world: World,
        trace: _Trace,
    ) -> tuple[Mapping[str, Any], ...]:
        values = _object_set(self._eval_arg(node, 0, world, trace), node.op)
        wanted = _string(self._eval_arg(node, 1, world, trace), node.op)
        selected = tuple(item for item in values if _attribute(item, attribute) == wanted)
        trace.record(node.op, selected, len(selected))
        return selected

    def _project_answer(self, root: AstNode, value: Any) -> AnswerValue:
        if root.return_type == "integer":
            return _integer(value, root.op)
        if root.return_type == "boolean":
            return bool(value)
        if root.return_type == "string":
            return _string(value, root.op)
        raise ExecutorError(
            f"CLEVR root {root.op!r} has non-answer return type {root.return_type!r}"
        )


def _objects(world: World) -> tuple[Mapping[str, Any], ...]:
    raw = world.get("objects")
    if not isinstance(raw, list):
        raise ExecutorError("CLEVR world objects is not an array")
    values: list[Mapping[str, Any]] = []
    seen: set[str] = set()
    for item in raw:
        if not isinstance(item, Mapping) or not item.get("id"):
            raise ExecutorError("CLEVR world contains an object without an id")
        node_id = str(item["id"])
        if node_id in seen:
            raise ExecutorError(f"CLEVR world has duplicate object id {node_id!r}")
        seen.add(node_id)
        values.append(item)
    return _ordered(values)


def _ordered(values: Sequence[Mapping[str, Any]]) -> tuple[Mapping[str, Any], ...]:
    return tuple(sorted(values, key=lambda item: str(item.get("id", ""))))


def _object_set(value: Any, op: str) -> tuple[Mapping[str, Any], ...]:
    if not isinstance(value, tuple) or any(not isinstance(item, Mapping) for item in value):
        raise ExecutorError(f"{op} expected an object set")
    return _ordered(value)


def _object(value: Any, op: str) -> Mapping[str, Any]:
    if not isinstance(value, Mapping) or not value.get("id"):
        raise ExecutorError(f"{op} expected one object")
    return value


def _attribute(obj: Mapping[str, Any], attribute: str) -> str:
    if attribute not in _ATTRIBUTES:
        raise ExecutorError(f"unknown CLEVR attribute {attribute!r}")
    value = obj.get(attribute)
    if value is None:
        raise _MissingInformation(f"object {obj.get('id')} {attribute} is hidden")
    if not isinstance(value, str) or not value:
        raise ExecutorError(f"object {obj.get('id')} has invalid {attribute}")
    return value


def _related(
    world: World,
    source_id: str,
    relation: str,
) -> tuple[Mapping[str, Any], ...]:
    if relation not in _RELATIONS:
        raise ExecutorError(f"unknown CLEVR relation {relation!r}")
    relationships = world.get("relationships")
    if not isinstance(relationships, Mapping):
        raise ExecutorError("CLEVR relationships is not an object")
    relation_map = relationships.get(relation)
    if not isinstance(relation_map, Mapping):
        raise ExecutorError(f"CLEVR relationship {relation!r} is missing")
    raw_targets = relation_map.get(source_id, [])
    if not isinstance(raw_targets, list):
        raise ExecutorError(f"CLEVR relationship {relation!r}/{source_id!r} is malformed")
    by_id = {str(item["id"]): item for item in _objects(world)}
    targets: list[Mapping[str, Any]] = []
    for node_id in raw_targets:
        target = by_id.get(str(node_id))
        if target is None:
            raise ExecutorError(
                f"CLEVR relationship {relation!r} references absent object {node_id!r}"
            )
        targets.append(target)
    return _ordered(targets)


def _string(value: Any, op: str) -> str:
    if not isinstance(value, str):
        raise ExecutorError(f"{op} expected a string, got {type(value).__name__}")
    return value


def _integer(value: Any, op: str) -> int:
    if isinstance(value, bool) or not isinstance(value, int):
        raise ExecutorError(f"{op} expected an integer, got {type(value).__name__}")
    return int(value)


def _comparable(value: Any) -> Any:
    if isinstance(value, Mapping):
        node_id = value.get("id")
        if not node_id:
            raise ExecutorError("object comparison received an object without an id")
        return ("object", str(node_id))
    if isinstance(value, (str, int, bool)):
        return value
    raise ExecutorError(f"value {value!r} is not comparable")


__all__ = ["ClevrExecutor"]