"""Python 3.10+: pip install requests; set ODDS_API_KEY, then run this file."""
import json
import math
import os
import sys
import time
from urllib.parse import quote

import requests

BASE = "https://api.odds-api.net/v1"
BOOKMAKERS = {"sportsbet", "ladbrokes"}
SHAPE = {"include_raw_payload": "false", "include_source": "true",
         "include_unavailable": "true"}
UNAVAILABLE = {"closed", "suspended", "removed", "inactive", "unavailable",
               "off", "settled", "finished", "cancelled", "abandoned"}


def number(value):
    try:
        value = float(value)
        return value if math.isfinite(value) else 0
    except (ValueError, TypeError):
        return 0


def active(row):
    status = str(row.get("runner_status") or row.get("status") or "").strip().lower()
    status = status.replace("-", "_").replace(" ", "_")
    return (status not in UNAVAILABLE | {"scratched", "withdrawn", "non_runner"}
            and str(row.get("is_scratched", "")).lower() not in {"true", "1", "yes"})


def fresh(book, now_ms, max_age_ms):
    stamp = number(book.get("updated_at_ts"))
    stamp = stamp * 1000 if stamp < 1e12 else stamp
    return stamp > 0 and -5000 <= now_ms - stamp <= max_age_ms and active(book)


def compare(books, now_ms, max_age_ms=30000):
    exchange = books.get("betfair", {})
    market = exchange.get("exchange_markets", {}).get("win", {})
    if not fresh(exchange, now_ms, max_age_ms) or not active(market):
        return []
    selections = {}
    for runner in exchange.get("runners", []):
        if runner.get("selection_id") and active(runner):
            selections.setdefault(str(runner["selection_id"]), []).append(runner)
    rows = []
    for bookmaker in sorted(BOOKMAKERS):
        book = books.get(bookmaker, {})
        if not fresh(book, now_ms, max_age_ms):
            continue
        for runner in book.get("runners", []):
            matches = selections.get(str(runner.get("selection_id") or ""), [])
            if not active(runner) or len(matches) != 1:
                continue
            win = matches[0].get("exchange", {}).get("win", {})
            back, lay, size = map(number, (runner.get("win_odds"),
                                          win.get("lay"), win.get("lay_size")))
            if back <= 1 or lay <= 1 or size <= 0:
                continue
            rows.append({"runner": runner.get("runner_name"),
                         "selection_id": str(runner["selection_id"]),
                         "bookmaker": bookmaker, "back": back, "lay": lay,
                         "lay_size": size,
                         "lay_currency": exchange.get("size_currency"),
                         # Price difference, before exchange commission.
                         "gap_pct": round((back / lay - 1) * 100, 2),
                         "bookmaker_updated_at": book["updated_at_ts"],
                         "betfair_updated_at": exchange["updated_at_ts"]})
    return rows


def apply_changes(books, changes):
    for change in changes:
        name = change.get("bookmaker_name")
        if name not in BOOKMAKERS | {"betfair"}:
            continue
        if change.get("op") == "remove":
            books.pop(name, None)
        elif change.get("op") == "upsert" and isinstance(change.get("snapshot"), dict):
            # A complete bookmaker replacement also removes vanished runners.
            books[name] = change["snapshot"]
        else:
            raise ValueError("Reload the snapshot after an unknown change.")


def sse(lines):
    event, data = "message", []
    for line in lines:
        if not line:
            if data:
                yield event, json.loads("\n".join(data))
            event, data = "message", []
        elif line.startswith("event:"):
            event = line[6:].strip()
        elif line.startswith("data:"):
            data.append(line[5:].lstrip(" "))


def main():
    headers = {"X-API-Key": os.environ["ODDS_API_KEY"]}

    def checked(response):
        if response.status_code in {401, 402, 403, 404}:
            raise SystemExit(f"API returned HTTP {response.status_code}.")
        response.raise_for_status()
        return response

    def get(path, params):
        with requests.get(BASE + path, headers=headers, params=params, timeout=20) as response:
            return checked(response).json()

    event_id = os.environ.get("RACE_EVENT_ID")
    if not event_id:
        events = get("/racing/events", {"race_type": "horse-racing", "race_country": "AU",
                     "status": "fetching", "start_from": int(time.time()), "limit": 50})
        if not events.get("items"):
            raise SystemExit("No upcoming race found. Set RACE_EVENT_ID to a current race.")
        event_id = events["items"][0]["event_id"]
    path = f"/racing/events/{quote(event_id, safe='')}/odds"

    while True:
        try:
            snapshot = get(path, SHAPE)
            if snapshot.get("event_id") != event_id:
                raise ValueError("Unexpected race in snapshot.")
            books = {item["bookmaker_name"]: item for item in snapshot.get("items", [])}
            resume = snapshot["resume"]
            print(json.dumps({"event_id": event_id, "rows": compare(books, time.time() * 1000)}), flush=True)
            with requests.get(BASE + path + "/stream", headers=headers,
                              params={**SHAPE, "since": resume, "catchup": "true"},
                              stream=True, timeout=(10, 30)) as response:
                checked(response)
                response.encoding = "utf-8"
                for event, message in sse(response.iter_lines(decode_unicode=True)):
                    if event == "resync":
                        break
                    if event == "delta":
                        if message.get("event_id") != event_id:
                            raise ValueError("Unexpected race in stream.")
                        apply_changes(books, message.get("changes", []))
                        resume = message.get("resume", resume)
                    # Heartbeats expire stale comparisons even without a delta.
                    print(json.dumps({"event_id": event_id, "rows": compare(books, time.time() * 1000)}), flush=True)
        except (requests.RequestException, ValueError, KeyError):
            print("Refreshing racing snapshot after a stream interruption.", file=sys.stderr)
        print(json.dumps({"event_id": event_id, "rows": [], "state": "reconnecting"}), flush=True)
        time.sleep(2)  # Reconnect from a fresh snapshot and its resume token.


if __name__ == "__main__":
    main()
