src/explicit_learning/sources/geometry3k.py

"""Geometry3K C1 source adapter (``docs/02`` §6).

Geometry3K (``lupantech/InterGPS`` @ ``99e6b52``) ships 3,002 high-school
geometry problems across ``train`` / ``validation`` / ``test``. Each problem has
a released ``data.json`` (problem text, four choices, answer letter, diagram
image) and an **annotated** logic form; the global ``logic_forms.zip`` holds the
authoritative annotated text/diagram logic forms keyed by integer ``id``. C1 uses
the annotated forms only — predicted diagram-parser output is excluded
(``docs/02`` §6.1).

P1 scope: deterministic ingest + ``normalize`` to a schema-conforming
:class:`NormalizedItem`, a structural ``geometry_world_v1`` builder with channel
provenance, and the released ``official_answer``. The typed DSL AST (P2) and the
6-check solver acceptance (P3) are deferred.
"""

from __future__ import annotations

import json
import re
from collections.abc import Iterator, Mapping
from pathlib import Path
from typing import Any

from ..dsl.ast import Program
from ..hashing import sha256_bytes
from ..ingest.base import (
    ImageStore,
    IngestError,
    NormalizedItem,
    Policy,
    make_item,
    mc_choices,
)
from .base import (
    AdapterError,
    CertificateTier,
    Channel,
    RawItem,
    World,
    extract_zip,
    github_raw_url,
    http_download,
    store_images,
)

SOURCE = "geometry3k"
WORLD_SCHEMA = "geometry_world_v1"

# The release names its split archive/directory ``val``; the resources manifest
# records the conventional ``validation``. Accept either.
_SPLIT_ALIAS: dict[str, str] = {"validation": "val"}
_VALID_SPLITS = frozenset({"train", "validation", "test"})
_MC_KEYS = ("A", "B", "C", "D")

# Archives fetched from the pinned revision. ``symbols.zip`` (predicted diagram
# symbols) is intentionally excluded — C1 uses annotated forms only (§6.1).
_ARCHIVES = ("train.zip", "val.zip", "test.zip", "logic_forms.zip")

# Annotated logic-form files inside ``logic_forms.zip``, keyed by integer id.
_TEXT_LOGIC_FORMS = "text_logic_forms_annot.json"
_TEXT_LOGIC_FORMS_DISSOLVED = "text_logic_forms_annot_dissolved.json"
_DIAGRAM_LOGIC_FORMS = "diagram_logic_forms_annot.json"


class Geometry3KAdapter:
    """C1 adapter for Geometry3K."""

    def __init__(self, raw_dir: Path, store: ImageStore, *, revision: str) -> None:
        self.raw_dir = Path(raw_dir)
        self.store = store
        self.revision = revision
        self._logic_forms: dict[str, dict[int, Any]] | None = None

    # --- fetch -----------------------------------------------------------

    @classmethod
    def fetch(
        cls,
        raw_dir: Path,
        *,
        repo_id: str,
        revision: str,
        data_path: str,
        expected_sha256: Mapping[str, str] | None = None,
    ) -> Path:
        """Download + extract the Geometry3K archives into ``raw_dir``.

        Idempotent: existing verified archives are kept. ``expected_sha256`` maps
        archive name to a known-good digest when available; absent entries
        download without verification (the git revision is the pin) but the
        computed digest is still recorded by the caller's manifest.
        """
        raw_dir = Path(raw_dir)
        raw_dir.mkdir(parents=True, exist_ok=True)
        for archive in _ARCHIVES:
            url = github_raw_url(repo_id, revision, f"{data_path}/{archive}")
            dst = raw_dir / archive
            digest = (expected_sha256 or {}).get(archive)
            http_download(url, dst, expected_sha256=digest)
            extract_zip(dst, raw_dir)
        return raw_dir

    @classmethod
    def is_materialized(cls, raw_dir: Path, split: str) -> bool:
        """True when the split dir and annotated logic forms are on disk."""
        if split not in _VALID_SPLITS:
            return False
        raw_dir = Path(raw_dir)
        dir_name = _SPLIT_ALIAS.get(split, split)
        split_present = (raw_dir / dir_name).is_dir()
        logic_forms_present = (raw_dir / "logic_forms").is_dir() or (
            raw_dir / _TEXT_LOGIC_FORMS
        ).exists()
        return split_present and logic_forms_present

    @classmethod
    def materialize(
        cls,
        raw_dir: Path,
        split: str,
        *,
        source_config: Mapping[str, Any],
        expected_sha256: Mapping[str, str] | None = None,
    ) -> Path:
        """Fetch all Geometry3K archives git-pinned via the resources config.

        ``source_config`` carries ``repo_id``, ``revision``, and ``data_path``
        from ``resources.structured_sources.geometry3k``. Fetch grabs every split
        archive (idempotent), so ``split`` only gates ``is_materialized``.
        """
        repo_id = source_config.get("repo_id")
        revision = source_config.get("revision")
        data_path = source_config.get("data_path")
        if not (
            isinstance(repo_id, str) and isinstance(revision, str) and isinstance(data_path, str)
        ):
            raise AdapterError(
                f"{SOURCE}: materialize requires repo_id, revision, data_path in resources config"
            )
        return cls.fetch(
            raw_dir,
            repo_id=repo_id,
            revision=revision,
            data_path=data_path,
            expected_sha256=expected_sha256,
        )

    # --- iter ------------------------------------------------------------

    def _load_logic_forms(self) -> dict[str, dict[int, Any]]:
        if self._logic_forms is not None:
            return self._logic_forms
        root = self.raw_dir / "logic_forms"
        if not root.is_dir():
            # Some extractions place the three json files directly under raw_dir.
            root = self.raw_dir
        loaded: dict[str, dict[int, Any]] = {}
        for fname in (_TEXT_LOGIC_FORMS, _TEXT_LOGIC_FORMS_DISSOLVED, _DIAGRAM_LOGIC_FORMS):
            path = root / fname
            if not path.exists():
                raise AdapterError(f"missing annotated logic-form file: {path}")
            data = json.loads(path.read_text(encoding="utf-8"))
            # The release keys these by integer id (stringified in JSON).
            keyed = {int(k): v for k, v in data.items()}
            loaded[fname] = keyed
        self._logic_forms = loaded
        return loaded

    def iter_base_items(self, split: str) -> Iterator[RawItem]:
        if split not in _VALID_SPLITS:
            raise AdapterError(f"{SOURCE}: unsupported split {split!r}")
        dir_name = _SPLIT_ALIAS.get(split, split)
        split_dir = self.raw_dir / dir_name
        if not split_dir.is_dir():
            raise AdapterError(f"{SOURCE}: split directory not found: {split_dir}")
        logic = self._load_logic_forms()
        text_forms = logic[_TEXT_LOGIC_FORMS_DISSOLVED] or logic[_TEXT_LOGIC_FORMS]
        diagram_forms = logic[_DIAGRAM_LOGIC_FORMS]

        ids = sorted(int(p.name) for p in split_dir.iterdir() if p.is_dir() and p.name.isdigit())
        for pid in ids:
            problem_dir = split_dir / str(pid)
            data_path = problem_dir / "data.json"
            if not data_path.exists():
                raise AdapterError(f"{SOURCE}/{pid}: missing data.json")
            data = json.loads(data_path.read_text(encoding="utf-8"))
            img_path = problem_dir / "img_diagram.png"
            if not img_path.exists():
                raise AdapterError(f"{SOURCE}/{pid}: missing img_diagram.png")
            images = {"diagram": img_path.read_bytes()}
            text_lf = text_forms.get(pid)
            diagram_lf = diagram_forms.get(pid)
            if text_lf is None or diagram_lf is None:
                # A problem without annotated forms cannot be a C1 candidate.
                raise AdapterError(f"{SOURCE}/{pid}: missing annotated logic forms")
            payload = {
                "id": pid,
                **data,
                "text_logic_form": text_lf,
                "diagram_logic_form": diagram_lf,
            }
            yield RawItem(
                source=SOURCE,
                split=split,
                source_revision=self.revision,
                native_id=str(pid),
                payload=payload,
                images=images,
            )

    # --- normalize -------------------------------------------------------

    def normalize(self, raw: RawItem) -> NormalizedItem:
        data = raw.payload
        problem_text = data.get("problem_text")
        if not isinstance(problem_text, str) or not problem_text.strip():
            raise IngestError(f"{SOURCE}/{raw.native_id}: problem_text missing/empty")
        choice_texts = data.get("choices")
        if not isinstance(choice_texts, list) or len(choice_texts) != len(_MC_KEYS):
            raise IngestError(f"{SOURCE}/{raw.native_id}: choices must be {len(_MC_KEYS)} strings")
        choices = mc_choices([str(c) for c in choice_texts], keys=list(_MC_KEYS))
        answer = data.get("answer")
        if not isinstance(answer, str) or answer not in _MC_KEYS:
            raise IngestError(
                f"{SOURCE}/{raw.native_id}: answer must be a letter A-D, got {answer!r}"
            )
        if not raw.images:
            raise IngestError(f"{SOURCE}/{raw.native_id}: diagram image missing")
        paths, shas = store_images(self.store, raw.images)

        graph_types = data.get("problem_type_graph") or []
        subject = (
            str(graph_types[0]) if isinstance(graph_types, list) and graph_types else "geometry"
        )
        policy: Policy = (
            "c1_train_candidate"
            if raw.split in ("train", "validation")
            else "c1_certified_eval_candidate"
        )
        goal = data.get("problem_type_goal")
        channel_map = _channel_map(data.get("text_logic_form"), data.get("diagram_logic_form"))
        extra = {
            "annotated_text_logic_form": data.get("text_logic_form"),
            "annotated_diagram_logic_form": data.get("diagram_logic_form"),
            "channel_map": channel_map,
            "goal": goal,
            "problem_type_goal": goal,
            "raw_payload_sha256": sha256_bytes(
                json.dumps(data, sort_keys=True, separators=(",", ":")).encode("utf-8")
            ),
        }
        return make_item(
            source=SOURCE,
            source_revision=raw.source_revision,
            source_config="default",
            source_split=raw.split,
            source_native_id=raw.native_id,
            question=problem_text,
            choices=choices,
            answer_raw=answer,
            answer_canonical=answer,
            answer_type="multiple_choice",
            image_paths=paths,
            image_sha256=shas,
            policy=policy,
            native_row=data,
            subject=subject,
            extra_provenance=extra,
        )

    # --- world / answer / tier ------------------------------------------

    def build_world(self, item: NormalizedItem) -> World:
        prov = item.provenance
        text_lf = _as_logic_lines(prov.get("annotated_text_logic_form"))
        diagram_lf = _as_logic_lines(prov.get("annotated_diagram_logic_form"))
        channel_map = prov.get("channel_map") or {}
        entities: dict[str, dict[str, Any]] = {}
        constraints: list[dict[str, Any]] = []
        for line in text_lf:
            pred = _parse_predicate(line)
            if pred is not None:
                constraints.append({**pred, "channel": channel_map.get(line, "text")})
                _collect_entities(pred, entities)
        for line in diagram_lf:
            pred = _parse_predicate(line)
            if pred is not None:
                constraints.append({**pred, "channel": channel_map.get(line, "visual")})
                _collect_entities(pred, entities)
        return {
            "world_schema": WORLD_SCHEMA,
            "entities": [{"id": eid, **body} for eid, body in sorted(entities.items())],
            "constraints": constraints,
            "goal": prov.get("goal"),
            "provenance": {
                "source": item.source,
                "source_native_id": item.source_native_id,
                "channels": sorted(set(channel_map.values()) or {"text", "visual"}),
            },
        }

    def get_or_compile_program(self, item: NormalizedItem) -> Program:
        """Compile the typed ``geometry_dsl_v1`` program for ``item`` (P2).

        Builds the world, hands it to the compiler, and returns a
        :class:`Program` (``compiled`` or ``unsupported``) with constraint
        channel provenance on the envelope. No execution, no model calls — P3/P4.
        """
        from ..dsl.geometrydsl import compile_geometry3k

        return compile_geometry3k(item, self.build_world(item))

    def official_answer(self, item: NormalizedItem) -> str:
        return str(item.answer_canonical)

    def source_certificate_tier(self, item: NormalizedItem) -> CertificateTier:
        return "C1_SOURCE_NATIVE"


# --- logic-form parsing helpers -------------------------------------------

_PRED_RE = re.compile(r"^([A-Za-z_]+)\((.*)\)$")


def _as_logic_lines(value: Any) -> list[str]:
    """Normalize an annotated logic-form value to a list of predicate strings."""
    if value is None:
        return []
    if isinstance(value, str):
        return [ln.strip() for ln in value.splitlines() if ln.strip()]
    if isinstance(value, list):
        return [str(ln).strip() for ln in value if str(ln).strip()]
    return []


def _parse_predicate(line: str) -> dict[str, Any] | None:
    match = _PRED_RE.match(line.strip())
    if match is None:
        return None
    predicate, raw_args = match.groups()
    args = [a.strip() for a in raw_args.split(",")] if raw_args else []
    return {"predicate": predicate, "args": args}


def _collect_entities(pred: Mapping[str, Any], entities: dict[str, dict[str, Any]]) -> None:
    """Record referenced entity ids (``point:A``, ``segment:A:B``, ...) from args."""
    for arg in pred["args"]:
        if isinstance(arg, str) and ":" in arg:
            eid, _, body = arg.partition(":")
            full = arg
            etype = eid.capitalize() if eid else "Entity"
            if full not in entities:
                entities[full] = {"type": etype, "args": []}
            if body and body not in entities[full]["args"]:
                entities[full]["args"].append(body)


def _channel_map(text_lf: Any, diagram_lf: Any) -> dict[str, Channel]:
    """Tag each predicate string with its provenance channel (§6.2).

    A fact present in both text and diagram is ``redundant``; text-only is
    ``text``; diagram-only is ``visual``. Interventions alter only ``visual``.
    """
    text_set = set(_as_logic_lines(text_lf))
    diagram_set = set(_as_logic_lines(diagram_lf))
    channel_map: dict[str, Channel] = {}
    for line in text_set & diagram_set:
        channel_map[line] = "redundant"
    for line in text_set - diagram_set:
        channel_map[line] = "text"
    for line in diagram_set - text_set:
        channel_map[line] = "visual"
    return channel_map


__all__ = ["Geometry3KAdapter", "SOURCE", "WORLD_SCHEMA"]