#!/usr/bin/env python3
"""Embedda oracle worker TEMPLATE — a skeleton, and it says so.

Speaks the frozen oracle wire v1 (`libs/swarm/nexus-oracle-wire`, golden
fixtures in that crate's tests/fixtures/, hashes in contracts/FROZEN.sha256):

    POST /infer   body = JSON OracleRequest  ->  200 + JSON OracleResponse

This template implements the CONTRACT — versioned parse, honest errors — and
deliberately answers **501 unsupported** for every query: it runs no model,
so per the wire's honesty rule it must never invent boxes or claim an empty
region (`none=true` is a *model's* statement, not a skeleton's).

To build a real worker: implement `handle()` and return an OracleResponse
dict. The reference REAL worker is the Modal deployment in
`deploy/cloud/modal/` (see its oracle_wire.py + nexus_cloud_node.py) — link,
not copy. Validate yours with `sdk/oracle/conformance.sh <url>`.

Stdlib only. Run: python3 worker.py [--port 9110]
"""

import json
import sys
from http.server import BaseHTTPRequestHandler, HTTPServer

ORACLE_WIRE_V = 1
QUERY_KINDS = {"detect", "ground", "verify"}


def parse_request(body: bytes):
    """Validate an incoming OracleRequest against the v1 wire.

    Returns (request_dict, None) or (None, (http_status, reason)).
    Rejections are explicit and specific — a worker must never mis-parse
    silently (`v` gate) nor guess at malformed queries.
    """
    try:
        req = json.loads(body)
    except ValueError as exc:
        return None, (400, f"body is not JSON: {exc}")
    if not isinstance(req, dict):
        return None, (400, "body must be a JSON object (OracleRequest)")
    v = req.get("v")
    if v != ORACLE_WIRE_V:
        return None, (400, f"oracle wire version {v!r} unsupported (want {ORACLE_WIRE_V})")
    image = req.get("image")
    if not isinstance(image, dict) or image.get("kind") not in {"crop", "frame_ref"}:
        return None, (400, "image must be a tagged OracleImage (crop | frame_ref)")
    queries = req.get("queries")
    if not isinstance(queries, list) or not queries:
        return None, (400, "queries must be a non-empty list")
    for q in queries:
        if not isinstance(q, dict) or q.get("kind") not in QUERY_KINDS:
            return None, (400, f"query kind must be one of {sorted(QUERY_KINDS)}: {q!r}")
    if not isinstance(req.get("budget_ms"), int):
        return None, (400, "budget_ms must be an integer")
    if not isinstance(req.get("provenance"), dict):
        return None, (400, "provenance is required")
    return req, None


def handle(request: dict):
    """YOUR model goes here.

    Return an OracleResponse dict (see the golden response fixtures) to serve
    the request, or None to answer honest-unsupported (501). This template
    returns None for everything: it is a skeleton and it says so.
    """
    _ = request
    return None


UNSUPPORTED_REASON = (
    "unsupported: this is the embedda oracle worker-template skeleton — it runs "
    "no model and will not invent results. Implement handle() (see the README "
    "and the real Modal worker in deploy/cloud/modal/)."
)


class OracleTemplateHandler(BaseHTTPRequestHandler):
    server_version = "EmbeddaOracleTemplate/1.0"

    def _reply(self, status: int, payload: dict) -> None:
        data = json.dumps(payload).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

    def do_POST(self) -> None:  # noqa: N802 (stdlib naming)
        if self.path != "/infer":
            self._reply(404, {"error": f"unknown path {self.path!r} (POST /infer)"})
            return
        length = int(self.headers.get("Content-Length") or 0)
        body = self.rfile.read(length) if length else b""
        request, err = parse_request(body)
        if err is not None:
            status, reason = err
            self._reply(status, {"error": reason})
            return
        response = handle(request)
        if response is None:
            self._reply(501, {"error": UNSUPPORTED_REASON})
            return
        self._reply(200, response)

    def do_GET(self) -> None:  # noqa: N802
        if self.path == "/healthz":
            self._reply(
                200,
                {
                    "ok": True,
                    "template": True,
                    "wire_v": ORACLE_WIRE_V,
                    "note": "skeleton worker: every /infer answers 501 unsupported",
                },
            )
            return
        self._reply(404, {"error": "GET /healthz or POST /infer"})

    def log_message(self, fmt, *args):  # keep stdout clean; stderr on demand
        sys.stderr.write("[worker-template] " + fmt % args + "\n")


def main() -> None:
    port = 9110
    if "--port" in sys.argv:
        port = int(sys.argv[sys.argv.index("--port") + 1])
    server = HTTPServer(("127.0.0.1", port), OracleTemplateHandler)
    print(f"[worker-template] listening on http://127.0.0.1:{port}/infer (skeleton: all 501)")
    server.serve_forever()


if __name__ == "__main__":
    main()