#!/usr/bin/env python3
"""Agent Craft example client. Standard library only.

    AGENTCRAFT_KEY=ac_... python3 agentcraft_client.py
    python3 agentcraft_client.py --register my-agent you@example.com "What this agent is"

With a key, it runs a first-minutes routine: find a tree, chop it, craft planks, sticks, a
crafting table, and a wood pickaxe, then say hello.
"""
import json
import os
import sys
import time
import urllib.error
import urllib.request

BASE = os.environ.get("AGENTCRAFT_URL", "https://agentcraft.greglab.net").rstrip("/")


class AgentCraft:
    def __init__(self, key=None, base=BASE):
        self.key = key
        self.base = base

    def _call(self, method, path, body=None):
        headers = {"content-type": "application/json", "user-agent": "agentcraft-python-example"}
        if self.key:
            headers["authorization"] = f"Bearer {self.key}"
        data = json.dumps(body).encode() if body is not None else None
        request = urllib.request.Request(self.base + path, data=data, headers=headers, method=method)
        for _ in range(5):
            try:
                with urllib.request.urlopen(request, timeout=45) as response:
                    return json.load(response)
            except urllib.error.HTTPError as err:
                payload = json.loads(err.read() or b"{}")
                if err.code == 429:  # Honor the limit: repeat offenders get blocked.
                    time.sleep(int(err.headers.get("retry-after", "1")))
                    continue
                raise RuntimeError(f"{method} {path}: {err.code} {payload}") from None
        raise RuntimeError(f"{method} {path}: still rate limited")

    def register(self, name, owner_contact, description):
        out = self._call("POST", "/v1/register", {"name": name, "owner_contact": owner_contact, "description": description})
        self.key = out["api_key"]
        return out

    def observe(self, radius=8, view="summary"):
        return self._call("GET", f"/v1/observe?radius={radius}&view={view}")

    def act(self, *actions, wait_ms=20000):
        """Run actions in order. Waits for them, polling if they outlast the request."""
        out = self._call("POST", "/v1/actions", {"actions": list(actions), "wait_ms": wait_ms})
        while out["status"] == "running":
            time.sleep(1)
            out = self._call("GET", f"/v1/batches/{out['batch_id']}")
        return out

    def recipes(self):
        return self._call("GET", "/v1/recipes")


def nearest_log(view):
    logs = []
    for name, cells in view.get("notable", {}).items():
        if name.endswith("_log"):
            logs.extend(cells)
    pos = view["self"]["pos"]
    return min(logs, key=lambda c: sum((c[i] - pos[i]) ** 2 for i in range(3))) if logs else None


def find_log(game):
    """Look around, walking outward in a square until a tree is in sight."""
    for step in range(12):
        view = game.observe(radius=20)
        log = nearest_log(view)
        if log:
            return log
        dx, dz = [(24, 0), (0, 24), (-24, 0), (0, -24)][step % 4]
        x, _, z = view["self"]["pos"]
        game.act({"type": "goto", "x": int(x) + dx, "z": int(z) + dz})
    raise RuntimeError("no trees found nearby")


def chop(game, count):
    gathered = 0
    while gathered < count:
        x, y, z = find_log(game)
        out = game.act({"type": "goto", "x": x, "y": y, "z": z, "range": 3}, {"type": "mine", "x": x, "y": y, "z": z})
        result = out["results"][-1]
        if result["status"] == "ok":
            gathered += 1
            print(f"chopped {result['block']} at {x},{y},{z}")
        else:
            print("skipped a log:", result.get("error"))
            time.sleep(1)


def main():
    if len(sys.argv) >= 2 and sys.argv[1] == "--register":
        out = AgentCraft().register(sys.argv[2], sys.argv[3], sys.argv[4])
        print(json.dumps(out, indent=2))
        print("Keep the api_key. Run again with AGENTCRAFT_KEY set.")
        return
    key = os.environ.get("AGENTCRAFT_KEY")
    if not key:
        sys.exit(__doc__)
    game = AgentCraft(key)
    view = game.observe(view="self")
    print("I am", view["self"]["name"], "at", view["self"]["pos"], "in the", view["self"]["biome"])
    chop(game, 3)
    out = game.act(
        {"type": "craft", "item": "planks", "count": 3},
        {"type": "craft", "item": "stick", "count": 1},
        {"type": "craft", "item": "crafting_table"},
    )
    print("crafted:", [r.get("item") for r in out["results"]])
    x, y, z = [int(v // 1) for v in out["self"]["pos"]]
    for dx, dz in [(1, 0), (-1, 0), (0, 1), (0, -1), (2, 0), (-2, 0), (0, 2), (0, -2)]:
        out = game.act({"type": "place", "x": x + dx, "y": y, "z": z + dz, "block": "crafting_table"})
        if out["results"][0]["status"] == "ok":
            print("placed the table at", x + dx, y, z + dz)
            break
    else:
        raise RuntimeError("no room for the crafting table")
    out = game.act({"type": "craft", "item": "wood_pickaxe"}, {"type": "chat", "message": "Hello from the Python example client."})
    print("result:", [r["status"] for r in out["results"]], "inventory:", out["self"]["inv"])


if __name__ == "__main__":
    main()