"""A Victris 0.7 starter with a loopback default. Edit decide() to change its play."""
import asyncio
import json
from ipaddress import IPv4Address
import os
import signal
import ssl
import sys
from urllib.parse import urlsplit

from websockets.asyncio.client import connect
from websockets.exceptions import InvalidStatus, WebSocketException


class DirectConnect(connect):
    def process_redirect(self, exc):
        # Repository pins websockets 17.4. Always let its original status reach the caller.
        return exc


def distance(a, b):
    return max(abs(a[0] - b[0]), abs(a[1] - b[1]))


def decide(obs, rules):
    me, zone = obs["self"], obs["zone"]
    if me["state"] != "idle":
        return {}
    radius = zone["next_radius"] if zone["next_radius"] is not None else zone["radius"]

    def inside(tile):
        return distance(tile, zone["center"]) <= radius

    def danger(tile):
        return any(obs["tick"] <= d["tick"] <= obs["tick"] + 1 and tile == d["tile"] for d in obs["danger"])

    enemy = next(iter(obs["enemies"]), None)
    under_fire = danger(me["pos"])
    if not under_fire and inside(me["pos"]) and enemy:
        gap = distance(me["pos"], enemy["pos"])
        for attack in ("repulsor", "frostburst", "ranged"):
            if me["cooldowns"][attack] or gap > rules["attacks"][attack].get("range", float("inf")):
                continue
            aim = {} if attack == "repulsor" else {"target": enemy["pos"]}
            return {"attack": {"name": attack, **aim}}

    pads = [p for p in obs["pickups"] if p["kind"] == "health" and p["ready_in"] == 0 and inside(p["pos"])]
    goal = enemy["pos"] if enemy else zone["center"]
    if not inside(me["pos"]):
        goal = zone["center"]
    elif me["hp"] < me["max_hp"] and pads:
        goal = min(pads, key=lambda p: distance(me["pos"], p["pos"]))["pos"]

    def score(tile):
        return distance(tile, goal) + (0 if inside(tile) else 50) + (100 if danger(tile) else 0)

    choices = [(m["tile"], {"move": m["dir"]}) for m in obs["moves"]]
    if under_fire or not inside(me["pos"]):
        choices.extend((m["tile"], {"dash": m["dir"]}) for m in obs["dashes"])
    if choices:
        tile, action = min(choices, key=lambda choice: score(choice[0]))
        if score(tile) < score(me["pos"]):
            return action
    return {}


async def run():
    url = os.environ.get("ARENA_URL", "ws://127.0.0.1:8100/bot")
    target = urlsplit(url)
    try:
        host = IPv4Address(target.hostname or "")
    except ValueError:
        host = None
    local = target.scheme == "ws" and host is not None and host.is_loopback
    if ((target.scheme != "wss" and not local) or not target.hostname or target.path != "/bot"
            or target.username is not None or target.password is not None or target.query or target.fragment):
        raise ValueError("ARENA_URL must be a wss:// endpoint or a numeric IPv4 loopback ws:// endpoint ending in /bot, without credentials, query or fragment")
    tls = ssl.create_default_context() if target.scheme == "wss" else None
    token = os.environ.get("ARENA_TOKEN", "")
    if not token or any(c.isspace() for c in token):
        raise ValueError("Set ARENA_TOKEN to your bot token")
    count = os.environ.get("ARENA_MATCHES")
    if count is not None and (not count.isascii() or not count.isdecimal() or not int(count)):
        raise ValueError("ARENA_MATCHES must be a positive integer")
    ticket = {"type": "queue", "version": os.environ.get("ARENA_VERSION", "v1")}
    if os.environ.get("ARENA_LADDER"):
        ticket["ladder_id"] = os.environ["ARENA_LADDER"]
    fatal = {"missing_authorization", "invalid_token", "replaced", "retired", "suspended", "banned", "account_banned",
             "version_retired", "version_unknown", "unknown_ladder", "ladder_unavailable", "enrollment_required"}
    played, delay = 0, 1
    while True:
        try:
            async with DirectConnect(url, ssl=tls, proxy=None, additional_headers={"Authorization": "Bearer " + token},
                                     open_timeout=10, close_timeout=5, compression=None) as ws:
                await ws.send(json.dumps(ticket))
                rules = None
                async for raw in ws:
                    msg = json.loads(raw)
                    if msg["type"] == "hello":
                        rules, delay = msg["rules"], 1
                        await ws.send('{"type":"ready"}')
                    elif msg["type"] == "observation":
                        if rules is None:
                            raise ValueError("Observation arrived before hello")
                        await ws.send(json.dumps({"tick": msg["tick"], **decide(msg, rules)}))
                    elif msg["type"] == "end":
                        print(f"{msg['result']} ({msg['reason']}) {msg['match_id']}", flush=True)
                        played += 1
                        if count and played >= int(count):
                            return 0
                        rules = None
                        await ws.send(json.dumps(ticket))
                    elif msg["type"] == "error":
                        print("Arena error: " + str(msg["code"]), file=sys.stderr, flush=True)
                        if msg["code"] in fatal:
                            return 1
        except ssl.SSLCertVerificationError:
            raise ValueError("Arena TLS certificate verification failed") from None
        except InvalidStatus as exc:
            if 300 <= exc.response.status_code < 400:
                raise ValueError("Arena WebSocket redirects are refused") from None
        except (OSError, asyncio.TimeoutError, WebSocketException):
            pass
        print(f"Reconnecting in {delay} s", file=sys.stderr, flush=True)
        await asyncio.sleep(delay)
        delay = min(30, delay * 2)


async def main():
    loop = asyncio.get_running_loop()
    task = asyncio.create_task(run())
    def stop(_number, _frame):
        loop.call_soon_threadsafe(task.cancel)
    for number in (signal.SIGTERM, signal.SIGINT):
        signal.signal(number, stop)
    try:
        return await task
    except asyncio.CancelledError:
        return 0


if __name__ == "__main__":
    try:
        sys.exit(asyncio.run(main()))
    except (KeyboardInterrupt, ValueError) as exc:
        if isinstance(exc, ValueError):
            print(str(exc), file=sys.stderr)
            sys.exit(2)
