src/explicit_learning/executors/gqa.py

"""Deterministic executor for native GQA-v1.2 semantic programs.

GQA questions carry a dependency-indexed list of semantic steps rather than a
tree-shaped DSL AST.  This module keeps that native representation immutable,
validates a deliberately compact operation subset, and executes it directly
against the released scene graph.  No image model or answer-derived repair is
used.

Supported operation families are ``select``, ``filter``, ``relate``, ``query``,
``exist``, ``verify``, ``choose``, ``count``, and ``compare``.  Native operation
qualifiers such as ``filter hposition`` and ``choose color`` are retained.
Anything outside this set is a typed compile rejection, never a guessed result.
"""

from __future__ import annotations

import re
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from typing import Any, Literal

from ..hashing import canonical_json_hash
from ..sources.base import World
from .base import (
    AnswerValue,
    ExecutionResult,
    ExecutorError,
    _InvalidReferent,
    _MissingInformation,
    _Trace,
    serialize_answer,
)

NAME = "gqa_semantic_executor"
VERSION = "gqa_semantic_v1/1"

GQA_WORLD_SCHEMA = "gqa_scene_graph_v1"
GQA_HIDDEN_OBJECTS_KEY = "_gqa_hidden_object_ids"

_SUPPORTED_FAMILIES = frozenset(
    {"select", "filter", "relate", "query", "exist", "verify", "choose", "count", "compare"}
)
_TERMINAL_FAMILIES = frozenset({"query", "exist", "verify", "choose", "count", "compare"})
_DIRECTIONS = {
    "s": "subject",
    "subject": "subject",
    "subj": "subject",
    "o": "object",
    "object": "object",
    "obj": "object",
}
_ENTITY = re.compile(r"^(?P<name>.*?)(?:\s*\((?P<object_id>[^()]+)\))?\s*$")

_COLORS = frozenset(
    {
        "beige",
        "black",
        "blond",
        "blue",
        "brown",
        "clear",
        "colorful",
        "cream",
        "gold",
        "golden",
        "gray",
        "green",
        "grey",
        "multicolored",
        "orange",
        "pink",
        "purple",
        "red",
        "silver",
        "tan",
        "transparent",
        "white",
        "yellow",
    }
)
_MATERIALS = frozenset(
    {
        "brick",
        "cardboard",
        "ceramic",
        "cloth",
        "concrete",
        "fabric",
        "glass",
        "leather",
        "metal",
        "metallic",
        "paper",
        "plastic",
        "porcelain",
        "rubber",
        "stone",
        "wood",
        "wooden",
    }
)
_SHAPES = frozenset(
    {
        "circular",
        "curved",
        "flat",
        "oval",
        "rectangular",
        "round",
        "square",
        "triangular",
    }
)
_SIZES = frozenset(
    {"big", "large", "little", "long", "narrow", "short", "small", "tall", "tiny", "wide"}
)
_ATTRIBUTE_CLASSES: dict[str, frozenset[str]] = {
    "color": _COLORS,
    "material": _MATERIALS,
    "shape": _SHAPES,
    "size": _SIZES,
}

type GQAValue = tuple[str, ...] | str | int | bool | _Scene


class GQASemanticError(ExecutorError):
    """A native GQA program or scene-graph value is outside the fixed subset."""


@dataclass(frozen=True)
class GQASemanticStep:
    """One normalized native GQA semantic step."""

    operation: str
    dependencies: tuple[int, ...]
    argument: str

    @property
    def family(self) -> str:
        return self.operation.split(maxsplit=1)[0]

    @property
    def qualifier(self) -> str:
        parts = self.operation.split(maxsplit=1)
        return parts[1] if len(parts) == 2 else ""

    def to_dict(self) -> dict[str, Any]:
        return {
            "operation": self.operation,
            "dependencies": list(self.dependencies),
            "argument": self.argument,
        }


@dataclass(frozen=True)
class GQASemanticProgram:
    """A validated, immutable GQA-v1.2 native semantic program."""

    question_id: str
    image_id: str
    steps: tuple[GQASemanticStep, ...]
    semantic_str: str
    canonical_program_sha256: str

    def to_dict(self) -> dict[str, Any]:
        return {
            "dsl": "gqa_semantic_v1",
            "question_id": self.question_id,
            "image_id": self.image_id,
            "semantic": [step.to_dict() for step in self.steps],
            "semantic_str": self.semantic_str,
            "canonical_program_sha256": self.canonical_program_sha256,
        }


@dataclass(frozen=True)
class _Scene:
    """Sentinel value used by native ``select: scene`` programs."""


_SCENE = _Scene()


def compile_gqa_program(
    question_id: str,
    row: Mapping[str, Any],
) -> GQASemanticProgram:
    """Validate and freeze one native GQA-v1.2 ``semantic`` list.

    Missing ``dependencies`` follow GQA's sequential shorthand: the first step
    has none and every later step depends on its immediate predecessor.  An
    explicit dependency must point strictly backwards.  Unsupported operations,
    malformed fields, and a non-terminal final operation are hard rejections.
    """

    qid = str(question_id).strip()
    image_id = str(row.get("imageId", "")).strip()
    if not qid:
        raise GQASemanticError("GQA question id must be non-empty")
    if not image_id:
        raise GQASemanticError(f"GQA/{qid}: imageId missing/empty")
    raw_steps = row.get("semantic")
    if not isinstance(raw_steps, list) or not raw_steps:
        raise GQASemanticError(f"GQA/{qid}: semantic must be a non-empty list")

    steps: list[GQASemanticStep] = []
    for index, raw in enumerate(raw_steps):
        if not isinstance(raw, Mapping):
            raise GQASemanticError(f"GQA/{qid}: semantic[{index}] must be an object")
        operation = " ".join(str(raw.get("operation", "")).strip().lower().split())
        if not operation:
            raise GQASemanticError(f"GQA/{qid}: semantic[{index}].operation missing")
        family = operation.split(maxsplit=1)[0]
        if family not in _SUPPORTED_FAMILIES:
            raise GQASemanticError(
                f"GQA/{qid}: unsupported semantic operation {operation!r} at step {index}"
            )
        argument_value = raw.get("argument", "")
        if argument_value is None:
            argument_value = ""
        if not isinstance(argument_value, (str, int, float, bool)):
            raise GQASemanticError(f"GQA/{qid}: semantic[{index}].argument must be scalar")
        argument = str(argument_value).strip()

        raw_dependencies = raw.get("dependencies")
        if raw_dependencies is None:
            dependencies = () if index == 0 else (index - 1,)
        else:
            if not isinstance(raw_dependencies, list) or any(
                not isinstance(dep, int) or isinstance(dep, bool) for dep in raw_dependencies
            ):
                raise GQASemanticError(
                    f"GQA/{qid}: semantic[{index}].dependencies must be integer indices"
                )
            dependencies = tuple(raw_dependencies)
        if len(set(dependencies)) != len(dependencies):
            raise GQASemanticError(f"GQA/{qid}: semantic[{index}] has duplicate dependencies")
        if any(dep < 0 or dep >= index for dep in dependencies):
            raise GQASemanticError(
                f"GQA/{qid}: semantic[{index}] dependency must point strictly backwards"
            )
        if family == "select" and dependencies:
            raise GQASemanticError(f"GQA/{qid}: select step {index} cannot have dependencies")
        if family != "select" and not dependencies:
            raise GQASemanticError(f"GQA/{qid}: {operation!r} step {index} requires a dependency")
        steps.append(
            GQASemanticStep(
                operation=operation,
                dependencies=dependencies,
                argument=argument,
            )
        )

    if steps[-1].family not in _TERMINAL_FAMILIES:
        raise GQASemanticError(
            f"GQA/{qid}: final semantic operation {steps[-1].operation!r} is not supported terminal"
        )
    semantic_str = str(row.get("semanticStr", "") or "")
    payload = {
        "dsl": "gqa_semantic_v1",
        "question_id": qid,
        "image_id": image_id,
        "semantic": [step.to_dict() for step in steps],
        "semantic_str": semantic_str,
    }
    return GQASemanticProgram(
        question_id=qid,
        image_id=image_id,
        steps=tuple(steps),
        semantic_str=semantic_str,
        canonical_program_sha256=canonical_json_hash(payload),
    )


class GQASemanticExecutor:
    """Execute the fixed native GQA semantic subset over a source scene graph."""

    name = NAME
    version = VERSION

    def execute(self, program: GQASemanticProgram, *, world: World) -> ExecutionResult:
        trace = _Trace()
        referent_cardinality: int | None = None
        try:
            self._validate_world(program, world)
            values: list[GQAValue] = []
            for step in program.steps:
                inputs = tuple(values[index] for index in step.dependencies)
                value, object_ids = self._eval(step, inputs, world)
                trace.record(step.operation.upper(), object_ids, _trace_value(value))
                values.append(value)
            final = values[-1]
            answer = _answer(final)
            if program.steps[-1].dependencies:
                last_input = values[program.steps[-1].dependencies[0]]
                if isinstance(last_input, tuple):
                    referent_cardinality = len(last_input)
            _steps, dependencies, trace_hash = trace.finish()
            return ExecutionResult(
                status="UNIQUE",
                answer_value=answer,
                answer_canonical=serialize_answer(answer),
                dependency_node_ids=dependencies,
                referent_cardinality=referent_cardinality,
                trace_sha256=trace_hash,
                executor_name=self.name,
                executor_version=self.version,
            )
        except _MissingInformation:
            return self._failure("MISSING_INFORMATION", trace, referent_cardinality)
        except _InvalidReferent:
            return self._failure("INVALID_REFERENT", trace, referent_cardinality)
        except (ExecutorError, KeyError, TypeError, ValueError):
            return self._failure("ERROR", trace, referent_cardinality)

    def _failure(
        self,
        status: Literal["MISSING_INFORMATION", "INVALID_REFERENT", "ERROR"],
        trace: _Trace,
        referent_cardinality: int | None,
    ) -> ExecutionResult:
        _steps, dependencies, trace_hash = trace.finish()
        return ExecutionResult(
            status=status,
            answer_value=None,
            answer_canonical=None,
            dependency_node_ids=dependencies,
            referent_cardinality=referent_cardinality,
            trace_sha256=trace_hash,
            executor_name=self.name,
            executor_version=self.version,
        )

    def _validate_world(self, program: GQASemanticProgram, world: World) -> None:
        if world.get("world_schema") != GQA_WORLD_SCHEMA:
            raise GQASemanticError(
                f"expected {GQA_WORLD_SCHEMA!r}, got {world.get('world_schema')!r}"
            )
        if str(world.get("image_id", "")) != program.image_id:
            raise GQASemanticError(
                f"program image {program.image_id!r} != world image {world.get('image_id')!r}"
            )
        if not isinstance(world.get("objects"), Mapping):
            raise GQASemanticError("GQA world objects must be a mapping")

    def _eval(
        self,
        step: GQASemanticStep,
        inputs: tuple[GQAValue, ...],
        world: World,
    ) -> tuple[GQAValue, tuple[str, ...]]:
        family = step.family
        if family == "select":
            return self._select(step.argument, world)
        if family == "filter":
            objects = _one_object_set(inputs, step.operation)
            return self._filter(objects, step.argument, step.qualifier, world)
        if family == "relate":
            objects = _one_object_set(inputs, step.operation)
            return self._relate(objects, step.argument, world)
        if family == "query":
            value = _one_input(inputs, step.operation)
            answer, ids = self._query(value, step.argument or step.qualifier, world)
            return answer, ids
        if family == "exist":
            objects = _one_object_set(inputs, step.operation)
            return bool(objects), objects
        if family == "verify":
            value = _one_input(inputs, step.operation)
            verified, ids = self._verify(value, step.argument, step.qualifier, world)
            return verified, ids
        if family == "choose":
            value = _one_input(inputs, step.operation)
            choice, ids = self._choose(value, step.argument, step.qualifier, world)
            return choice, ids
        if family == "count":
            objects = _one_object_set(inputs, step.operation)
            return len(objects), objects
        if family == "compare":
            compared, ids = self._compare(inputs, step.argument, step.qualifier, world)
            return compared, ids
        raise GQASemanticError(f"unsupported semantic operation {step.operation!r}")

    def _select(self, argument: str, world: World) -> tuple[GQAValue, tuple[str, ...]]:
        name, object_id = _parse_entity(argument)
        if name.casefold() == "scene" and object_id is None:
            return _SCENE, ()
        if not name:
            raise GQASemanticError("select requires an object name")
        if object_id is not None:
            obj = _object(world, object_id)
            if _name(obj) != name.casefold():
                raise _InvalidReferent(
                    f"grounded object {object_id!r} is {_name(obj)!r}, not {name!r}"
                )
            return (object_id,), (object_id,)

        matching: list[str] = []
        for candidate_id, obj in _objects(world).items():
            if _name(obj) != name.casefold():
                continue
            if _is_hidden(world, candidate_id):
                raise _MissingInformation(f"selected {name!r} object {candidate_id!r} is hidden")
            matching.append(candidate_id)
        result = tuple(sorted(matching))
        return result, result

    def _filter(
        self,
        objects: tuple[str, ...],
        argument: str,
        qualifier: str,
        world: World,
    ) -> tuple[tuple[str, ...], tuple[str, ...]]:
        if not argument:
            raise GQASemanticError("filter requires an argument")
        kept: list[str] = []
        for object_id in objects:
            obj = _object(world, object_id)
            if _has_property(obj, argument, qualifier, world):
                kept.append(object_id)
        return tuple(kept), objects

    def _relate(
        self,
        dependencies: tuple[str, ...],
        argument: str,
        world: World,
    ) -> tuple[tuple[str, ...], tuple[str, ...]]:
        entity_name, entity_id, relation, direction = _parse_relation(argument)
        dependency_set = frozenset(dependencies)
        for dependency_id in dependencies:
            _object(world, dependency_id)

        matched: set[str] = set()
        accessed: set[str] = set(dependencies)
        if direction == "subject":
            candidates = (
                ((entity_id, _object(world, entity_id)),)
                if entity_id is not None
                else tuple(
                    (object_id, obj)
                    for object_id, obj in _objects(world).items()
                    if _name(obj) == entity_name.casefold()
                )
            )
            for candidate_id, candidate in candidates:
                if _name(candidate) != entity_name.casefold():
                    continue
                if _is_hidden(world, candidate_id):
                    raise _MissingInformation(f"related subject {candidate_id!r} is hidden")
                accessed.add(candidate_id)
                targets = {
                    target
                    for rel_name, target in _relations(candidate)
                    if rel_name.casefold() == relation.casefold()
                }
                if targets & dependency_set:
                    matched.add(candidate_id)
        else:
            for source_id in dependencies:
                source = _object(world, source_id)
                for rel_name, target_id in _relations(source):
                    if rel_name.casefold() != relation.casefold():
                        continue
                    if entity_id is not None and target_id != entity_id:
                        continue
                    target = _object(world, target_id)
                    if _name(target) != entity_name.casefold():
                        continue
                    accessed.add(target_id)
                    matched.add(target_id)
        return tuple(sorted(matched)), tuple(sorted(accessed))

    def _query(
        self,
        value: GQAValue,
        category: str,
        world: World,
    ) -> tuple[str, tuple[str, ...]]:
        category = category.strip().casefold()
        if isinstance(value, _Scene):
            if category not in {"location", "weather"}:
                raise GQASemanticError(f"scene query {category!r} is unsupported")
            answer = world.get(category)
            if not isinstance(answer, str) or not answer.strip():
                raise _MissingInformation(f"scene {category} is absent")
            return answer.strip(), ()
        objects = _as_object_set(value, "query")
        if len(objects) != 1:
            raise _InvalidReferent(f"query requires one object, got {len(objects)}")
        object_id = objects[0]
        obj = _object(world, object_id)
        return _property_value(obj, category, world), (object_id,)

    def _verify(
        self,
        value: GQAValue,
        argument: str,
        qualifier: str,
        world: World,
    ) -> tuple[bool, tuple[str, ...]]:
        if isinstance(value, _Scene):
            category = qualifier.casefold()
            if category not in {"location", "weather"}:
                raise GQASemanticError(f"scene verify {category!r} is unsupported")
            actual = str(world.get(category, "")).strip().casefold()
            return actual == argument.strip().casefold(), ()
        objects = _as_object_set(value, "verify")
        if not objects:
            return False, ()
        return (
            all(
                _has_property(_object(world, object_id), argument, qualifier, world)
                for object_id in objects
            ),
            objects,
        )

    def _choose(
        self,
        value: GQAValue,
        argument: str,
        qualifier: str,
        world: World,
    ) -> tuple[str, tuple[str, ...]]:
        choices = tuple(part.strip() for part in argument.split("|"))
        if len(choices) != 2 or any(not choice for choice in choices):
            raise GQASemanticError("choose requires exactly two 'left|right' alternatives")
        if isinstance(value, _Scene):
            category = qualifier.casefold()
            if category not in {"location", "weather"}:
                raise GQASemanticError(f"scene choose {category!r} is unsupported")
            actual = str(world.get(category, "")).strip().casefold()
            matches = [choice for choice in choices if choice.casefold() == actual]
            ids: tuple[str, ...] = ()
        else:
            objects = _as_object_set(value, "choose")
            if len(objects) != 1:
                raise _InvalidReferent(f"choose requires one object, got {len(objects)}")
            obj = _object(world, objects[0])
            matches = [choice for choice in choices if _has_property(obj, choice, qualifier, world)]
            ids = objects
        if len(matches) != 1:
            raise _InvalidReferent(
                f"choose alternatives must have exactly one match, got {len(matches)}"
            )
        return matches[0], ids

    def _compare(
        self,
        inputs: tuple[GQAValue, ...],
        argument: str,
        qualifier: str,
        world: World,
    ) -> tuple[bool, tuple[str, ...]]:
        if len(inputs) == 1 and isinstance(inputs[0], tuple) and len(inputs[0]) == 2:
            left: GQAValue = (inputs[0][0],)
            right: GQAValue = (inputs[0][1],)
        elif len(inputs) == 2:
            left, right = inputs
        else:
            raise GQASemanticError("compare requires two dependencies (or one two-object set)")

        relation, category = _comparison_spec(argument, qualifier)
        ids = tuple(
            sorted(
                {
                    object_id
                    for value in (left, right)
                    if isinstance(value, tuple)
                    for object_id in value
                }
            )
        )
        if relation in {"more", "greater", "less", "fewer", "equal"}:
            left_number = _numeric_comparand(left)
            right_number = _numeric_comparand(right)
            if relation in {"more", "greater"}:
                return left_number > right_number, ids
            if relation in {"less", "fewer"}:
                return left_number < right_number, ids
            return left_number == right_number, ids

        left_value = _comparison_property(left, category, world)
        right_value = _comparison_property(right, category, world)
        same = left_value.casefold() == right_value.casefold()
        return (not same if relation == "different" else same), ids


def _objects(world: World) -> dict[str, Mapping[str, Any]]:
    raw = world.get("objects")
    if not isinstance(raw, Mapping):
        raise GQASemanticError("GQA world objects must be a mapping")
    out: dict[str, Mapping[str, Any]] = {}
    for object_id, obj in raw.items():
        if isinstance(obj, Mapping):
            out[str(object_id)] = obj
    return out


def _object(world: World, object_id: str) -> Mapping[str, Any]:
    objects = _objects(world)
    if object_id not in objects:
        raise _InvalidReferent(f"GQA object {object_id!r} is absent")
    if _is_hidden(world, object_id):
        raise _MissingInformation(f"GQA object {object_id!r} is hidden")
    return objects[object_id]


def _is_hidden(world: World, object_id: str) -> bool:
    hidden = world.get(GQA_HIDDEN_OBJECTS_KEY, ())
    return isinstance(hidden, (list, tuple, set, frozenset)) and object_id in {
        str(value) for value in hidden
    }


def _name(obj: Mapping[str, Any]) -> str:
    return str(obj.get("name", "")).strip().casefold()


def _attributes(obj: Mapping[str, Any]) -> tuple[str, ...]:
    raw = obj.get("attributes", ())
    if not isinstance(raw, (list, tuple)):
        raise GQASemanticError("GQA object attributes must be a sequence")
    return tuple(str(value).strip() for value in raw if str(value).strip())


def _relations(obj: Mapping[str, Any]) -> tuple[tuple[str, str], ...]:
    raw = obj.get("relations", ())
    values = raw.values() if isinstance(raw, Mapping) else raw
    if not isinstance(values, Sequence) and not isinstance(raw, Mapping):
        raise GQASemanticError("GQA object relations must be a sequence or mapping")
    out: list[tuple[str, str]] = []
    for relation in values:
        if not isinstance(relation, Mapping):
            raise GQASemanticError("GQA relation must be an object")
        name = str(relation.get("name", "")).strip()
        target = str(relation.get("object", "")).strip()
        if not name or not target:
            raise GQASemanticError("GQA relation requires name and object")
        out.append((name, target))
    return tuple(out)


def _parse_entity(argument: str) -> tuple[str, str | None]:
    match = _ENTITY.fullmatch(argument.strip())
    if match is None:
        raise GQASemanticError(f"malformed GQA entity argument {argument!r}")
    name = match.group("name").strip()
    object_id = match.group("object_id")
    return name, object_id.strip() if object_id else None


def _parse_relation(argument: str) -> tuple[str, str | None, str, str]:
    parts = [part.strip() for part in argument.split(",")]
    if len(parts) != 3:
        raise GQASemanticError(f"relate requires three comma-separated fields, got {argument!r}")
    if parts[1].casefold() in _DIRECTIONS:
        relation = parts[0]
        direction = _DIRECTIONS[parts[1].casefold()]
        entity_raw = parts[2]
    elif parts[2].split(maxsplit=1)[0].casefold() in _DIRECTIONS:
        entity_raw = parts[0]
        relation = parts[1]
        direction_token, *suffix = parts[2].split(maxsplit=1)
        direction = _DIRECTIONS[direction_token.casefold()]
        if suffix:
            entity_raw = f"{entity_raw} {suffix[0]}"
    else:
        raise GQASemanticError(f"relate direction is unsupported in {argument!r}")
    entity_name, object_id = _parse_entity(entity_raw)
    if not entity_name or not relation:
        raise GQASemanticError(f"malformed relate argument {argument!r}")
    return entity_name, object_id, relation, direction


def _one_input(inputs: tuple[GQAValue, ...], operation: str) -> GQAValue:
    if len(inputs) != 1:
        raise GQASemanticError(f"{operation!r} requires one dependency, got {len(inputs)}")
    return inputs[0]


def _one_object_set(inputs: tuple[GQAValue, ...], operation: str) -> tuple[str, ...]:
    return _as_object_set(_one_input(inputs, operation), operation)


def _as_object_set(value: GQAValue, operation: str) -> tuple[str, ...]:
    if not isinstance(value, tuple):
        raise GQASemanticError(f"{operation!r} requires an object-set dependency")
    return value


def _has_property(
    obj: Mapping[str, Any],
    expected: str,
    qualifier: str,
    world: World,
) -> bool:
    value = expected.strip().casefold()
    category = qualifier.strip().casefold()
    if category in {"name", "category", "object"}:
        return _name(obj) == value
    attributes = {attribute.casefold() for attribute in _attributes(obj)}
    if value in attributes:
        return True
    if category == "hposition" or value in {"left", "right", "center"}:
        return _horizontal_position(obj, world) == value
    if category == "vposition" or value in {"top", "bottom", "middle"}:
        return _vertical_position(obj, world) == value
    return _name(obj) == value


def _property_value(obj: Mapping[str, Any], category: str, world: World) -> str:
    if category in {"name", "category", "object"}:
        value = str(obj.get("name", "")).strip()
        if not value:
            raise _MissingInformation("object name is absent")
        return value
    if category == "hposition":
        return _horizontal_position(obj, world)
    if category == "vposition":
        return _vertical_position(obj, world)
    candidates = _ATTRIBUTE_CLASSES.get(category)
    attributes = _attributes(obj)
    if candidates is None:
        if len(attributes) == 1:
            return attributes[0]
        raise GQASemanticError(f"query attribute class {category!r} is unsupported")
    matched = [attribute for attribute in attributes if attribute.casefold() in candidates]
    if len(matched) != 1:
        raise _InvalidReferent(
            f"query {category!r} requires one matching attribute, got {len(matched)}"
        )
    return matched[0]


def _horizontal_position(obj: Mapping[str, Any], world: World) -> str:
    width = _positive_number(world.get("width"), "world width")
    center = _number(obj.get("x"), "object x") + _number(obj.get("w"), "object w") / 2
    if center < width / 3:
        return "left"
    if center > 2 * width / 3:
        return "right"
    return "center"


def _vertical_position(obj: Mapping[str, Any], world: World) -> str:
    height = _positive_number(world.get("height"), "world height")
    center = _number(obj.get("y"), "object y") + _number(obj.get("h"), "object h") / 2
    if center < height / 3:
        return "top"
    if center > 2 * height / 3:
        return "bottom"
    return "middle"


def _number(value: Any, label: str) -> float:
    if isinstance(value, bool):
        raise GQASemanticError(f"{label} must be numeric")
    try:
        return float(value)
    except (TypeError, ValueError) as exc:
        raise GQASemanticError(f"{label} must be numeric") from exc


def _positive_number(value: Any, label: str) -> float:
    number = _number(value, label)
    if number <= 0:
        raise GQASemanticError(f"{label} must be positive")
    return number


def _comparison_spec(argument: str, qualifier: str) -> tuple[str, str]:
    tokens = [
        token
        for token in re.split(r"[\s,|]+", f"{qualifier} {argument}".strip().casefold())
        if token
    ]
    relation = next(
        (
            token
            for token in tokens
            if token in {"same", "different", "more", "greater", "less", "fewer", "equal"}
        ),
        "same",
    )
    category = next(
        (
            token
            for token in tokens
            if token
            not in {"same", "different", "more", "greater", "less", "fewer", "equal", "than"}
        ),
        "name",
    )
    return relation, category


def _numeric_comparand(value: GQAValue) -> int:
    if isinstance(value, bool):
        return int(value)
    if isinstance(value, int):
        return value
    if isinstance(value, tuple):
        return len(value)
    raise GQASemanticError("numeric compare requires counts or object sets")


def _comparison_property(value: GQAValue, category: str, world: World) -> str:
    objects = _as_object_set(value, "compare")
    if len(objects) != 1:
        raise _InvalidReferent(f"property compare requires one object, got {len(objects)}")
    return _property_value(_object(world, objects[0]), category, world)


def _answer(value: GQAValue) -> AnswerValue:
    if isinstance(value, (str, int, bool)):
        return value
    raise GQASemanticError("final GQA semantic step did not produce a scalar answer")


def _trace_value(value: GQAValue) -> str | int | bool:
    if isinstance(value, tuple):
        return "[" + ",".join(value) + "]"
    if isinstance(value, _Scene):
        return "scene"
    return value


__all__ = [
    "GQA_HIDDEN_OBJECTS_KEY",
    "GQA_WORLD_SCHEMA",
    "GQASemanticError",
    "GQASemanticExecutor",
    "GQASemanticProgram",
    "GQASemanticStep",
    "compile_gqa_program",
]