from fastapi import FastAPI
from fastapi.responses import Response, HTMLResponse
from fastapi import HTTPException
from fastapi import Request
from contextlib import asynccontextmanager
import requests
import threading
import time
import queue
import argparse
import uvicorn
import os
import pandas as pd
import json
from datetime import datetime, time as dtime, timedelta
from fastapi.responses import Response
import logging
import logging.config
import platform
import socket

# передадим параметры через аргументы или глобальные переменные

parser = argparse.ArgumentParser()
parser = argparse.ArgumentParser()
parser.add_argument("--league", default="vtb")
parser.add_argument("--team", required=True)
parser.add_argument("--lang", default="en")
args = parser.parse_args()

MYHOST = platform.node()
user_name = socket.gethostname()

if not os.path.exists("logs"):
    os.makedirs("logs")

telegram_bot_token = "7639240596:AAH0YtdQoWZSC-_R_EW4wKAHHNLIA0F_ARY"
# telegram_chat_id = 228977654
telegram_chat_id = -4803699526
log_config = {
    "version": 1,
    "handlers": {
        "telegram": {
            "class": "telegram_handler.TelegramHandler",
            "level": "INFO",
            "token": telegram_bot_token,
            "chat_id": telegram_chat_id,
            "formatter": "telegram",
        },
        "console": {
            "class": "logging.StreamHandler",
            "level": "INFO",
            "formatter": "simple",
            "stream": "ext://sys.stdout",
        },
        "file": {
            "class": "logging.FileHandler",
            "level": "DEBUG",
            "formatter": "simple",
            "filename": f"logs/GFX_{MYHOST}.log",
            "encoding": "utf-8",
        },
    },
    "loggers": {
        __name__: {"handlers": ["console", "file", "telegram"], "level": "DEBUG"},
    },
    "formatters": {
        "telegram": {
            "class": "telegram_handler.HtmlFormatter",
            "format": f"%(levelname)s <b>[{MYHOST.upper()}] [{user_name}]</b>\n%(message)s",
            "use_emoji": "True",
        },
        "simple": {
            "class": "logging.Formatter",
            "format": "%(asctime)s %(levelname)-8s %(funcName)s() - %(message)s",
            "datefmt": "%d.%m.%Y %H:%M:%S",
        },
    },
}

logging.config.dictConfig(log_config)
logger = logging.getLogger(__name__)
logger.handlers[2].formatter.use_emoji = True


LEAGUE = args.league
TEAM = args.team
LANG = args.lang
HOST = "https://pro.russiabasket.org"
STATUS = False
GAME_ID = None
SEASON = None
GAME_START_DT = None  # datetime начала матча (локальная из календаря)
GAME_TODAY = False  # флаг: игра сегодня
GAME_SOON = False  # флаг: игра сегодня и скоро (<1 часа)
OFFLINE_SWITCH_AT = None  # timestamp, когда надо уйти в оффлайн
OFFLINE_DELAY_SEC = 600  # 10 минут

# общая очередь
results_q = queue.Queue()
# тут будем хранить последние данные
latest_data = {}
# событие для остановки потоков
stop_event = threading.Event()

# отдельные события для разных наборов потоков
stop_event_live = threading.Event()
stop_event_offline = threading.Event()

# чтобы из consumer можно было их гасить
threads_live = []
threads_offline = []

# какой режим сейчас запущен: "live" / "offline" / None
CURRENT_THREADS_MODE = None


URLS = {
    "seasons": "{host}/api/abc/comps/seasons?Tag={league}",
    "actual-standings": "{host}/api/abc/comps/actual-standings?tag={league}&season={season}&lang={lang}",
    "calendar": "{host}/api/abc/comps/calendar?Tag={league}&Season={season}&Lang={lang}&MaxResultCount=1000",
    "game": "{host}/api/abc/games/game?Id={game_id}&Lang={lang}",
    "pregame": "{host}/api/abc/games/pregame?tag={league}&season={season}&id={game_id}&lang={lang}",
    "pregame-full-stats": "{host}/api/abc/games/pregame-full-stats?tag={league}&season={season}&id={game_id}&lang={lang}",
    "live-status": "{host}/api/abc/games/live-status?id={game_id}",
    "box-score": "{host}/api/abc/games/box-score?id={game_id}",
    "play-by-play": "{host}/api/abc/games/play-by-play?id={game_id}",
}


def start_offline_threads(season, game_id):
    """Запускаем редкие запросы, когда матча нет или он уже сыгран."""
    global threads_offline, CURRENT_THREADS_MODE, stop_event_offline, latest_data

    if CURRENT_THREADS_MODE == "offline":
        logger.debug("[threads] already in OFFLINE mode → skip start_offline_threads")
        return

    stop_live_threads()
    logger.info("[threads] switching to OFFLINE mode ...")
    # 🔹 очищаем latest_data безопасно, чтобы не ломать структуру
    keep_keys = {
        "game",
        "pregame",
        "pregame-full-stats",
        "actual-standings",
        "calendar",
    }
    for key in list(latest_data.keys()):
        if key not in keep_keys:
            del latest_data[key]

    stop_event_offline.clear()

    threads_offline = [
        threading.Thread(
            target=get_data_from_API,
            args=(
                "game",
                URLS["game"].format(host=HOST, game_id=game_id, lang=LANG),
                300,  # опрашиваем раз в секунду/реже
                stop_event_offline,
            ),
            daemon=True,
        ),
    ]
    for t in threads_offline:
        t.start()

    CURRENT_THREADS_MODE = "offline"
    logger.info("[threads] OFFLINE threads started (data cleaned)")


def start_live_threads(season, game_id):
    """Запускаем частые онлайн-запросы, когда матч идёт/вот-вот."""
    global threads_live, CURRENT_THREADS_MODE, stop_event_live

    # если уже в лайве — не дублируем
    if CURRENT_THREADS_MODE == "live":
        return

    # на всякий случай гасим офлайн
    stop_offline_threads()

    stop_event_live.clear()
    threads_live = [
        threading.Thread(
            target=get_data_from_API,
            args=(
                "pregame",
                URLS["pregame"].format(
                    host=HOST, league=LEAGUE, season=season, game_id=game_id, lang=LANG
                ),
                600,
                stop_event_live,
                True,
            ),
            daemon=True,
        ),
        threading.Thread(
            target=get_data_from_API,
            args=(
                "pregame-full-stats",
                URLS["pregame-full-stats"].format(
                    host=HOST, league=LEAGUE, season=season, game_id=game_id, lang=LANG
                ),
                600,
                stop_event_live,
                True,
            ),
            daemon=True,
        ),
        threading.Thread(
            target=get_data_from_API,
            args=(
                "actual-standings",
                URLS["actual-standings"].format(
                    host=HOST, league=LEAGUE, season=season, lang=LANG
                ),
                600,
                stop_event_live,
            ),
            daemon=True,
        ),
        threading.Thread(
            target=get_data_from_API,
            args=(
                "game",
                URLS["game"].format(host=HOST, game_id=game_id, lang=LANG),
                300,  # часто
                stop_event_live,
                True,
            ),
            daemon=True,
        ),
        threading.Thread(
            target=get_data_from_API,
            args=(
                "live-status",
                URLS["live-status"].format(host=HOST, game_id=game_id),
                0.5,
                stop_event_live,
            ),
            daemon=True,
        ),
        threading.Thread(
            target=get_data_from_API,
            args=(
                "box-score",
                URLS["box-score"].format(host=HOST, game_id=game_id),
                0.5,
                stop_event_live,
            ),
            daemon=True,
        ),
        threading.Thread(
            target=get_data_from_API,
            args=(
                "play-by-play",
                URLS["play-by-play"].format(host=HOST, game_id=game_id),
                1,
                stop_event_live,
            ),
            daemon=True,
        ),
    ]
    for t in threads_live:
        t.start()

    CURRENT_THREADS_MODE = "live"
    logger.info("[threads] LIVE threads started")


def stop_live_threads():
    """Гасим только live-треды."""
    global threads_live
    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
    if not threads_live:
        logger.info("[threads] LIVE threads stopped (nothing to stop)")
        return

    logger.info(f"[threads] Stopping {len(threads_live)} LIVE thread(s)...")
    stop_event_live.set()

    still_alive = []
    for t in threads_live:
        t.join(timeout=2)
        if t.is_alive():
            logger.warning(
                f"[{current_time}] [threads] LIVE thread is still alive: {t.name}"
            )
            still_alive.append(t.name)

    threads_live = []
    if still_alive:
        logger.warning(
            f"[{current_time}] [threads] Some LIVE threads did not stop: {still_alive}"
        )
    else:
        logger.info("[threads] LIVE threads stopped")


def stop_offline_threads():
    """Гасим только offline-треды."""
    global threads_offline
    if not threads_offline:
        return
    stop_event_offline.set()
    for t in threads_offline:
        t.join(timeout=1)
    threads_offline = []
    logger.info("[threads] OFFLINE threads stopped")


def has_full_game_ready() -> bool:
    game = latest_data.get("game")
    if not game:
        return False
    payload = game.get("data", game)
    return (
        isinstance(payload, dict)
        and isinstance(payload.get("data"), dict)
        and isinstance(payload["data"].get("result"), dict)
        and "teams" in payload["data"]["result"]
    )

# Функция запускаемая в потоках
def get_data_from_API(
    name: str,
    url: str,
    sleep_time: float,
    stop_event: threading.Event,
    stop_when_live=False,
):
    did_first_fetch = False
    while not stop_event.is_set():
        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
        if stop_when_live and globals().get("STATUS") == "live" and has_full_game_ready():
            logger.info(f"{[{current_time}]} [{name}] stopping because STATUS='live' and full game is ready")
            break
        
        try:
            value = requests.get(url, timeout=5).json()
            did_first_fetch = True  # помечаем, что один заход сделали
        except json.JSONDecodeError as json_err:
            logger.warning(
                f"[{current_time}] [{name}] Ошибка парсинга JSON: {json_err}"
            )
            value = {"error": f"JSON decode error: {json_err}"}
        except requests.exceptions.Timeout:
            logger.warning(f"[{current_time}] [{name}] Таймаут при запросе {url}")
            value = {"error": "timeout"}
        except requests.exceptions.RequestException as req_err:
            logger.warning(f"[{current_time}] [{name}] Ошибка запроса: {req_err}")
            value = {"error": str(req_err)}
        except Exception as ex:
            logger.warning(f"[{current_time}] [{name}] Неизвестная ошибка: {ex}")
            value = {"error": str(ex)}

        # Проверяем, нет ли явного статуса ошибки в JSON
        if isinstance(value, dict) and str(value.get("status", "")).lower() in (
            "error",
            "fail",
            "no-status",
        ):
            logger.warning(
                f"[{current_time}] [{name}] API вернул статус '{value.get('status')}'"
            )

        ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
        results_q.put({"source": name, "ts": ts, "data": value})
        logger.debug(f"[{ts}] name: {name}, status: {value.get('status', 'no-status')}")

        # сколько уже заняло
        # elapsed = time.time() - start
        # сколько надо доспать, чтобы в сумме вышла нужная частота
        # to_sleep = sleep_time - elapsed
        # print(to_sleep)
        # if to_sleep > 0:
        # умное ожидание с быстрым выходом при live
        slept = 0
        while slept < sleep_time:
            if stop_event.is_set():
                break
            if stop_when_live and globals().get("STATUS") == "live" and has_full_game_ready():
                logger.info(f"[{name}] stopping during sleep because STATUS='live' and full game is ready")
                return

            time.sleep(1)
            slept += 1
        # если запрос занял дольше — просто сразу следующую итерацию


# Получение результатов из всех запущенных потоков
def results_consumer():
    while not stop_event.is_set():
        # ⬇️ проверяем, не пора ли в оффлайн (отложенный переход)
        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
        off_at = globals().get("OFFLINE_SWITCH_AT")
        if off_at is not None and time.time() >= off_at:
            # делаем переход ТОЛЬКО если ещё не оффлайн
            if globals().get("CURRENT_THREADS_MODE") != "offline":
                logger.info("[status] switching to OFFLINE (delayed)")
                stop_live_threads()
                start_offline_threads(SEASON, GAME_ID)
            # чтобы не повторять
            globals()["OFFLINE_SWITCH_AT"] = None
        try:
            msg = results_q.get(timeout=0.5)
        except queue.Empty:
            continue

        try:
            source = msg.get("source")
            payload = msg.get("data") or {}

            # универсальный статус (может не быть)
            incoming_status = payload.get("status")  # может быть None
            # print(source, incoming_status)
            if source == "game":
                # обработка ТОЛЬКО в спец-ветке ниже
                pass
            else:
                latest_data[source] = {
                    "ts": msg["ts"],
                    "data": incoming_status if incoming_status is not None else payload,
                }
            # 1) play-by-play
            if "play-by-play" in source:
                game = latest_data.get("game")
                # если игра уже нормальная — приклеиваем плейи
                if (
                    game
                    and isinstance(game, dict)
                    and "data" in game
                    and "result" in game["data"]
                ):
                    # у pbp тоже может не быть data/result
                    if "result" in payload:
                        game["data"]["result"]["plays"] = payload["result"]

                # а вот статус у play-by-play иногда просто "no-status"

            # 2) box-score
            elif "box-score" in source:
                game = latest_data.get("game")
                if (
                    game
                    and "data" in game
                    and "result" in game["data"]
                    and "teams" in game["data"]["result"]
                    and "result" in payload
                    and "teams" in payload["result"]
                ):
                    # обновляем команды
                    game["data"]["result"]["game"]["fullScore"] = payload["result"][
                        "fullScore"
                    ]
                    game["data"]["result"]["game"][
                        "score"
                    ] = f'{payload["result"]["teams"][0]["total"]["points"]}:{payload["result"]["teams"][1]["total"]["points"]}'
                    for team in game["data"]["result"]["teams"]:
                        if team["teamNumber"] != 0:
                            box_team = [
                                t
                                for t in payload["result"]["teams"]
                                if t["teamNumber"] == team["teamNumber"]
                            ]
                            if not box_team:
                                print("ERROR: box-score team not found")
                                continue
                            box_team = box_team[0]

                            for player in team["starts"]:
                                box_player = [
                                    p
                                    for p in box_team["starts"]
                                    if p["startNum"] == player["startNum"]
                                ]
                                if box_player:
                                    player["stats"] = box_player[0]

                            team["total"] = box_team["total"]
                            team["startTotal"] = box_team["startTotal"]
                            team["benchTotal"] = box_team["benchTotal"]
                            team["maxLeading"] = box_team["maxLeading"]
                            team["pointsInRow"] = box_team["pointsInRow"]
                            team["maxPointsInRow"] = box_team["maxPointsInRow"]

            elif "live-status" in source:
                latest_data[source] = {
                    "ts": msg["ts"],
                    "data": payload,
                }

                try:
                    ls_data = payload.get("result") or payload
                    raw_ls_status = (
                        ls_data.get("status")
                        or ls_data.get("gameStatus")
                        or ls_data.get("state")
                    )

                    if raw_ls_status:
                        raw_ls_status_low = str(raw_ls_status).lower()

                        finished_markers = [
                            "finished",
                            "result",
                            "resultconfirmed",
                            "ended",
                            "final",
                            "game over",
                        ]

                        # 1) матч ЗАКОНЧЕН → запускаем ОТСРОЧЕННЫЙ переход
                        if any(m in raw_ls_status_low for m in finished_markers):
                            now_ts = time.time()
                            # если ещё не назначали переход — назначим
                            if globals().get("OFFLINE_SWITCH_AT") is None:
                                switch_at = now_ts + globals().get(
                                    "OFFLINE_DELAY_SEC", 600
                                )
                                globals()["OFFLINE_SWITCH_AT"] = switch_at

                                # статус тоже обозначим, что он завершён, но ждёт
                                if (
                                    GAME_START_DT
                                    and GAME_START_DT.date() == datetime.now().date()
                                ):
                                    globals()["STATUS"] = "finished_wait"
                                else:
                                    globals()["STATUS"] = "finished_wait"

                                human_time = datetime.fromtimestamp(switch_at).strftime(
                                    "%H:%M:%S"
                                )
                                logger.info(
                                    f"[status] match finished → will switch to OFFLINE at {human_time} "
                                    f"(in {globals().get('OFFLINE_DELAY_SEC', 600)}s)"
                                )
                            else:
                                # уже ждём — можно в debug
                                logger.debug(
                                    "[status] match finished → OFFLINE already scheduled"
                                )

                        # 2) матч снова стал онлайном → СБРАСЫВАЕМ отложенный переход
                        elif (
                            "online" in raw_ls_status_low or "live" in raw_ls_status_low
                        ):
                            # если до этого стояла отложка — уберём
                            if globals().get("OFFLINE_SWITCH_AT") is not None:
                                logger.info(
                                    "[status] match back to LIVE → cancel scheduled OFFLINE"
                                )
                                globals()["OFFLINE_SWITCH_AT"] = None

                            if globals().get("STATUS") != "live":
                                logger.info(
                                    "[status] match became LIVE → switch to LIVE threads"
                                )
                                globals()["STATUS"] = "live"
                                start_live_threads(SEASON, GAME_ID)

                except Exception as e:
                    logger.warning(
                        f"[{current_time}] results_consumer: live-status postprocess error: {e}"
                    )

            else:
                if source == "game":
                    has_game_already = "game" in latest_data and isinstance(latest_data.get("game"), dict)

                    # Полная структура?
                    is_full = (
                        isinstance(payload, dict)
                        and "data" in payload
                        and isinstance(payload["data"], dict)
                        and "result" in payload["data"]
                        and "teams" in payload["data"]["result"]
                    )

                    # ⚙️ ЛОГИКА:
                    # 1) Пока матч НЕ online (STATUS != 'live'): обновляем всегда,
                    #    чтобы /status видел "живость" раз в 5 минут независимо от полноты JSON.
                    if globals().get("STATUS") != "live":
                        latest_data["game"] = {"ts": msg["ts"], "data": payload}
                        logger.debug("results_consumer: pre-live game → updated (full=%s)", is_full)
                    else:
                        # ✅ если игры ещё НЕТ в кэше — примем ПЕРВЫЙ game даже неполный,
                        #    чтобы box-score/play-by-play могли его дорастить
                        if is_full or not has_game_already:
                            latest_data["game"] = {"ts": msg["ts"], "data": payload}
                            logger.debug("results_consumer: LIVE → stored (full=%s, had=%s)", is_full, has_game_already)
                        else:
                            logger.debug("results_consumer: LIVE & partial game → keep previous one")

                    # 2) Когда матч УЖЕ online (STATUS == 'live'):
                    #    - поток 'game' в live-режиме погаснет сам (stop_when_live=True),
                    #      но если вдруг что-то долетит, кладём только полный JSON.
                    continue
                        # # game неполный
                        # if not has_game_already:
                        #     # 👉 раньше game вообще не было — лучше положить хоть что-то
                        #     latest_data["game"] = {
                        #         "ts": msg["ts"],
                        #         "data": payload,
                        #     }
                        # else:
                        #     # 👉 уже есть какой-то game — неполным НЕ затираем
                        #     logger.debug(
                        #         "results_consumer: got partial game, keeping previous one"
                        #     )

                    # и обязательно continue/return из этого elif/if
                else:
                    latest_data[source] = {
                        "ts": msg["ts"],
                        "data": payload,
                    }
                continue

                # ... остальная обработка ...
        except Exception as e:
            logger.warning(f"[{current_time}] results_consumer error: {repr(e)}")
            continue


def get_items(data: dict) -> list:
    """
    Мелкий хелпер: берём первый список в ответе API.
    Многие ручки отдают {"result":[...]} или {"seasons":[...]}.
    Если находим список — возвращаем его.
    Если нет — возвращаем None (значит, нужно брать весь dict).
    """
    for k, v in data.items():
        if isinstance(v, list):
            return data[k]
    return None


def pick_game_for_team(calendar_json):
    """
    Возвращает:
        game_id: str | None
        game_dt: datetime | None
        is_today: bool
        cal_status: str | None   # Scheduled / Online / Result / ResultConfirmed

    Логика:
    1. если в календаре есть игра КОМАНДЫ на сегодня — берём ЕЁ и возвращаем её gameStatus
    2. иначе — берём последнюю прошедшую и тоже возвращаем её gameStatus
    """
    items = get_items(calendar_json)
    if not items:
        return None, None, False, None

    today = datetime.now().date()

    # 1) сначала — сегодняшняя
    for game in reversed(items):
        if game["team1"]["name"].lower() != TEAM.lower():
            continue

        gdt = extract_game_datetime(game)
        gdate = (
            gdt.date()
            if gdt
            else datetime.strptime(game["game"]["localDate"], "%d.%m.%Y").date()
        )

        if gdate == today:
            cal_status = game["game"].get("gameStatus")
            return game["game"]["id"], gdt, True, cal_status

    # 2) если на сегодня нет — берём последнюю прошедшую
    last_id = None
    last_dt = None
    last_status = None

    for game in reversed(items):
        if game["team1"]["name"].lower() != TEAM.lower():
            continue

        gdt = extract_game_datetime(game)
        gdate = (
            gdt.date()
            if gdt
            else datetime.strptime(game["game"]["localDate"], "%d.%m.%Y").date()
        )

        if gdate <= today:
            last_id = game["game"]["id"]
            last_dt = gdt
            last_status = game["game"].get("gameStatus")
            break

    return last_id, last_dt, False, last_status


def extract_game_datetime(game_item: dict) -> datetime | None:
    """
    Из элемента календаря достаём datetime матча.
    В календаре есть localDate и часто localTime. Если localTime нет — берём 00:00.
    """
    try:
        date_str = game_item["game"]["localDate"]  # '31.10.2025'
        dt_date = datetime.strptime(date_str, "%d.%m.%Y").date()
        time_str = game_item["game"].get("defaultZoneTime")  # '19:30'
        if time_str:
            hh, mm = map(int, time_str.split(":"))
            dt_time = dtime(hour=hh, minute=mm)
        else:
            dt_time = dtime(hour=0, minute=0)
        return datetime.combine(dt_date, dt_time)
    except Exception:
        return None


def build_pretty_status_message():
    """
    Собирает одно красивое сообщение про текущее состояние онлайна.
    Если game ещё нет — шлём хотя бы статусы источников.
    """
    lines = []
    lines.append(f"🏀 <b>{LEAGUE.upper()}</b> • {TEAM}")
    lines.append(f"📌 Game ID: <code>{GAME_ID}</code>")
    lines.append(f"🕒 {GAME_START_DT}")

    # сначала попробуем собрать нормальный game
    game_wrap = latest_data.get("game")
    has_game = False
    if game_wrap:
        raw = game_wrap.get("data") if isinstance(game_wrap, dict) else game_wrap

        # raw может быть: dict (полный payload) | dict (уже result) | str ("ok"/"no-status")
        result = {}
        if isinstance(raw, dict):
            # ваш нормальный полный ответ по game имеет структуру: {"data": {"result": {...}}}
            # но на всякий случай поддержим и вариант, где сразу {"result": {...}} или уже {"game": ...}
            result = (
                raw.get("data", {}).get("result", {})
                if "data" in raw
                else (raw.get("result") or raw)
            )
        else:
            result = {}

        game_info = result.get("game") or {}

        team1_name = (result.get("team1") or {}).get("name", "Team 1")
        team2_name = (result.get("team2") or {}).get("name", "Team 2")

        lines.append(f"👥 {team1_name} vs {team2_name}")

        score_now = game_info.get("score") or ""
        full_score = game_info.get("fullScore") or ""

        if score_now:
            lines.append(f"🔢 Score: <b>{score_now}</b>")

        if isinstance(full_score, str) and full_score:
            quarters = full_score.split(",")
            q_text = " | ".join(f"Q{i+1} {q}" for i, q in enumerate(quarters) if q)
            if q_text:
                lines.append(f"🧱 By quarters: {q_text}")

        has_game = bool(result)
    # live-status отдельно
    # ls = latest_data.get("live-status", {})
    # ls_raw = ls.get("data") or {}
    # ls_status = (
    #     ls_raw.get("status") or ls_raw.get("gameStatus") or ls_raw.get("state") or "—"
    # )
    # lines.append(f"🟢 LIVE status: <b>{ls_status}</b>")

    ls_wrap = latest_data.get("live-status")
    ls_status = "—"
    if ls_wrap:
        raw = ls_wrap.get("data")
        if isinstance(raw, dict):
            ls_dict = raw.get("result") or raw
            ls_status = (
                ls_dict.get("status")
                or ls_dict.get("gameStatus")
                or ls_dict.get("state")
                or "—"
            )
        elif isinstance(raw, str):
            # API/consumer могли положить просто строку статуса: "ok", "no-status", "error"
            ls_status = raw

    lines.append(f"🟢 LIVE status: <b>{ls_status}</b>")

    # добавим блок по источникам — это как раз “состояние запросов”
    sort_order = ["game", "live-status", "box-score", "play-by-play"]
    keys = [k for k in sort_order if k in latest_data] + sorted(
        [k for k in latest_data if k not in sort_order]
    )
    src_lines = []
    for k in keys:
        d = latest_data.get(k) or {}
        ts = d.get("ts", "—")
        dat = d.get("data")
        if isinstance(dat, dict) and "status" in dat:
            st = str(dat["status"]).lower()
        else:
            st = str(dat).lower()

        # Эмодзи-кружки для статусов
        if any(x in st for x in ["ok", "success", "live", "online"]):
            emoji = "🟢"
        elif any(x in st for x in ["error", "fail", "no-status", "none", "timeout"]):
            emoji = "🔴"
        else:
            emoji = "🟡"

        src_lines.append(f"{emoji} <b>{k}</b>: {st} ({ts})")

    if src_lines:
        lines.append("📡 Sources:")
        lines.extend(src_lines)

    # даже если game не успел — мы всё равно что-то вернём
    return "\n".join(lines)


def status_broadcaster():
    """
    Если матч live — сразу шлём статус.
    Потом — раз в 5 минут.
    Если матч не live — ждём и проверяем снова.
    """
    INTERVAL = 300  # 5 минут
    last_text = None
    first_live_sent = False

    while not stop_event.is_set():
        # если игра не идёт — спим по чуть-чуть и крутимся
        if STATUS not in ("live", "live_soon"):
            first_live_sent = False  # чтобы при новом лайве снова сразу отправить
            time.sleep(5)
            continue

        # сюда попадаем только если live
        text = build_pretty_status_message()
        if text and text != last_text:
            logger.info(text)
            last_text = text
            first_live_sent = True

        # после первого лайва ждём 5 минут, а до него — 10 секунд
        wait_sec = INTERVAL if first_live_sent else 10
        for _ in range(wait_sec):
            if stop_event.is_set():
                break
            time.sleep(1)


def start_prestart_watcher(game_dt: datetime | None):
    """
    Следит за временем начала игры.
    Как только до матча остаётся <= 1ч10м — включает live-треды.
    Работает только для "игра сегодня".
    """
    if not game_dt:
        return  # нечего ждать

    def _runner():
        global STATUS
        # за сколько включать live
        lead = timedelta(hours=1, minutes=10)
        switch_at = game_dt - lead

        while not stop_event.is_set():
            now = datetime.now()

            # если игра уже live/finished — не мешаем
            if STATUS in ("live", "finished", "finished_wait", "finished_today"):
                break

            # если время подошло — включаем live и выходим
            if now >= switch_at:
                logger.info(
                    f"[prestart] it's {now}, game at {game_dt}, enabling LIVE threads (1h10m rule)"
                )
                STATUS = "live_soon"
                # сначала гасим оффлайн, если он крутится
                stop_offline_threads()
                # а потом включаем live
                start_live_threads(SEASON, GAME_ID)
                break

            # иначе спим немного и проверяем снова
            time.sleep(30)  # можно 15–60 сек

    t = threading.Thread(target=_runner, daemon=True)
    t.start()


@asynccontextmanager
async def lifespan(app: FastAPI):
    global STATUS, GAME_ID, SEASON, GAME_START_DT, GAME_TODAY, GAME_SOON

    # 1. проверяем API: seasons
    try:
        seasons_resp = requests.get(
            URLS["seasons"].format(host=HOST, league=LEAGUE)
        ).json()
        season = seasons_resp["items"][0]["season"]
    except Exception:
        now = datetime.now()
        if now.month > 9:
            season = now.year + 1
        else:
            season = now.year
        logger.info(f"предположили номер сезона: {season}")
    SEASON = season

    # 2. берём календарь
    try:
        calendar = requests.get(
            URLS["calendar"].format(host=HOST, league=LEAGUE, season=season, lang=LANG)
        ).json()
    except Exception as ex:
        logger.error(f"не получилось проверить работу API. код ошибки: {ex}")
        # тут можно вообще не запускать сервер, но оставим как есть
        calendar = None

    # 3. определяем игру
    game_id, game_dt, is_today, cal_status = (
        pick_game_for_team(calendar) if calendar else (None, None, False, None)
    )
    GAME_ID = game_id
    GAME_START_DT = game_dt
    GAME_TODAY = is_today

    logger.info(
        f"Лига: {LEAGUE}\nСезон: {season}\nКоманда: {TEAM}\nGame ID: {game_id}"
    )

    # 4. запускаем "длинные" потоки (они у тебя и так всегда)
    thread_result_consumer = threading.Thread(
        target=results_consumer,
        daemon=True,
    )
    thread_result_consumer.start()

    thread_status_broadcaster = threading.Thread(
        target=status_broadcaster,
        daemon=True,
    )
    thread_status_broadcaster.start()

    # 5. решаем, что запускать
    if not is_today:
        STATUS = "no_game_today"
        start_offline_threads(SEASON, GAME_ID)
    else:
        # игра сегодня
        # в любом случае запускаем сторож, если знаем время игры
        start_prestart_watcher(game_dt)

        if cal_status is None:
            STATUS = "today_not_started"
            start_offline_threads(SEASON, GAME_ID)

        elif cal_status == "Scheduled":
            if game_dt:
                delta = game_dt - datetime.now()
                # если мы уже МЕНЬШЕ чем за 1:10 до игры — сразу в live
                if delta <= timedelta(hours=1, minutes=10):
                    STATUS = "live_soon"
                    start_live_threads(SEASON, GAME_ID)
                else:
                    STATUS = "today_not_started"
                    start_offline_threads(SEASON, GAME_ID)
            else:
                STATUS = "today_not_started"
                start_offline_threads(SEASON, GAME_ID)

        elif cal_status == "Online":
            STATUS = "live"
            start_live_threads(SEASON, GAME_ID)

        elif cal_status in ["Result", "ResultConfirmed"]:
            STATUS = "finished_today"
            start_offline_threads(SEASON, GAME_ID)
        else:
            STATUS = "today_not_started"
            start_offline_threads(SEASON, GAME_ID)
    yield

    # -------- shutdown --------
    stop_event.set()
    stop_live_threads()
    stop_offline_threads()
    thread_result_consumer.join(timeout=1)
    thread_status_broadcaster.join(timeout=1)


app = FastAPI(lifespan=lifespan)


def format_time(seconds: float | int) -> str:
    """
    Удобный формат времени для игроков:
    71 -> "1:11"
    0  -> "0:00"
    Любые кривые значения -> "0:00".
    """
    try:
        total_seconds = int(float(seconds))
        minutes = total_seconds // 60
        sec = total_seconds % 60
        return f"{minutes}:{sec:02}"
    except (ValueError, TypeError):
        return "0:00"


@app.get("/team1")
async def team1():
    game = get_latest_game_safe("game")
    if not game:
        raise HTTPException(status_code=503, detail="game data not ready")
    return await team("team1")


@app.get("/team2")
async def team2():
    game = get_latest_game_safe("game")
    if not game:
        raise HTTPException(status_code=503, detail="game data not ready")
    return await team("team2")


@app.get("/top_team1")
async def top_team1():
    data = await team("team1")
    return await top_sorted_team(data)


@app.get("/top_team2")
async def top_team2():
    data = await team("team2")
    return await top_sorted_team(data)


@app.get("/started_team1")
async def started_team1():
    data = await team("team1")
    return await started_team(data)


@app.get("/started_team2")
async def started_team2():
    data = await team("team2")
    return await started_team(data)


@app.get("/game")
async def game():
    return latest_data["game"]


@app.get("/status")
async def status(request: Request):
    global STATUS  # будем его править, если live-status свежее

    def color_for_status(status_value: str) -> str:
        """Подбор цвета статуса в HEX"""
        status_value = str(status_value).lower()
        if status_value in ["ok", "success", "live", "live_soon", "online"]:
            return "#00FF00"  # зелёный
        elif status_value in ["scheduled", "today_not_started", "upcoming"]:
            return "#FFFF00"  # жёлтый
        elif status_value in [
            "result",
            "resultconfirmed",
            "finished",
            "finished_today",
        ]:
            return "#FF0000"  # красный
        elif status_value in ["no_game_today", "unknown", "none"]:
            return "#FFFFFF"  # белый
        else:
            return "#FF7700"  # серый (неизвестный статус)

    # ✳️ сортируем latest_data в нужном порядке
    sort_order = ["game", "live-status", "box-score", "play-by-play"]
    sorted_keys = [k for k in sort_order if k in latest_data] + sorted(
        [k for k in latest_data if k not in sort_order]
    )
    data = {
        "league": LEAGUE,
        "team": TEAM,
        "game_id": GAME_ID,
        "game_status": STATUS,
        "statuses": [
            {
                "name": TEAM,
                "status": STATUS,
                "ts": (
                    GAME_START_DT.strftime("%Y-%m-%d %H:%M") if GAME_START_DT else "N/A"
                ),
                "link": LEAGUE,
                "color": color_for_status(STATUS),
            }
        ]
        + [
            {
                "name": item,
                "status": (
                    latest_data[item]["data"]["status"]
                    if isinstance(latest_data[item]["data"], dict)
                    and "status" in latest_data[item]["data"]
                    else latest_data[item]["data"]
                ),
                "ts": latest_data[item]["ts"],
                "link": URLS[item].format(
                    host=HOST,
                    league=LEAGUE,
                    season=SEASON,
                    lang=LANG,
                    game_id=GAME_ID,
                ),
                "color": color_for_status(
                    latest_data[item]["data"]["status"]
                    if isinstance(latest_data[item]["data"], dict)
                    and "status" in latest_data[item]["data"]
                    else latest_data[item]["data"]
                ),
            }
            for item in sorted_keys  # ← используем отсортированный порядок
        ],
    }
    accept = request.headers.get("accept", "")
    if "text/html" in accept:
        status_raw = str(STATUS).lower()
        # print(status_raw)
        if status_raw in ["live", "online"]:
            gs_class = "live"
            gs_text = "🟢 LIVE"
        elif status_raw in ["live_soon", "today_not_started"]:
            gs_class = "live"
            gs_text = "🟢 GAME TODAY (soon)"
        elif status_raw in ["finished_wait"]:
            gs_class = "upcoming"
            # покажем, что он ДОЖИДАЕТСЯ оффлайна
            off_at = OFFLINE_SWITCH_AT
            if off_at:
                human = datetime.fromtimestamp(off_at).strftime("%H:%M:%S")
                gs_text = f"🟡 Game finished, cooling down → OFFLINE at {human}"
            else:
                human = "N/A"
                gs_text = "🟡 Game finished, cooling down"
        elif status_raw in ["finished_today", "finished"]:
            gs_class = "finished"
            gs_text = "🔴 Game finished"
        else:
            gs_class = status_raw
            gs_text = "⚪ Unknown"

        html = f"""
        <html>
        <head>
            <meta http-equiv="refresh" content="1">
            <style>
                body {{
                    font-family: "Segoe UI", Roboto, monospace;
                    background: #0f0f0f;
                    color: #eee;
                    padding: 20px;
                }}
                table {{
                    border-collapse: collapse;
                    width: 100%;
                    margin-top: 10px;
                }}
                th, td {{
                    border: 1px solid #333;
                    padding: 6px 10px;
                    text-align: left;
                }}
                th {{
                    background: #222;
                    color: #ccc;
                }}
                tr:nth-child(even) {{ background-color: #1a1a1a; }}
                .ok {{ color: #00ff7f; font-weight: bold; }}
                .fail {{ color: #ff4d4d; font-weight: bold; }}
                .live {{ color: #00ff7f; font-weight: bold; }}
                .finished {{ color: #ff4d4d; font-weight: bold; }}
                .unknown {{ color: #cccccc; font-weight: bold; }}
                a {{
                    color: #66b3ff;
                    text-decoration: none;
                }}
                a:hover {{ text-decoration: underline; }}
                h2 {{ margin-bottom: 5px; }}
                .header-info p {{ margin: 2px 0; }}
            </style>
        </head>
        <body>
            <h2>📊 Game Status Monitor</h2>
            <div class="header-info">
                <p><b>League:</b> {LEAGUE}</p>
                <p><b>Team:</b> {TEAM}</p>
                <p><b>Game ID:</b> {GAME_ID}</p>
                <p><b>Game Status:</b> <span class="{gs_class}">{gs_text}</span></p>
            </div>

            <table>
                <tr><th>Name</th><th>Status</th><th>Timestamp</th><th>Link</th></tr>
        """

        for s in data["statuses"]:
            status_text = str(s["status"]).strip().lower()

            if any(
                x in status_text
                for x in ["ok", "success", "live", "live_soon", "online"]
            ):
                color_class = "ok"
            elif any(
                x in status_text for x in ["scheduled", "today_not_started", "upcoming"]
            ):
                color_class = "warn"
            elif any(
                x in status_text
                for x in ["result", "resultconfirmed", "finished", "finished_today"]
            ):
                color_class = "fail"
            else:
                color_class = "unknown"
            html += f"""
                <tr>
                    <td>{s["name"]}</td>
                    <td class="{color_class}">{status_text}</td>
                    <td>{s["ts"]}</td>
                    <td><a href="{s["link"]}" target="_blank">{s["link"]}</a></td>
                </tr>
            """

        html += """
            </table>
        </body>
        </html>
        """
        return HTMLResponse(content=html, media_type="text/html")
    # JSON для API (красиво отформатированный)
    formatted = json.dumps(data, indent=4, ensure_ascii=False)
    response = Response(content=formatted, media_type="application/json")
    response.headers["Refresh"] = "1"
    return response


@app.get("/scores")
async def scores():
    game = get_latest_game_safe("game")
    if not game:
        # игры ещё нет или пришёл только частичный ответ
        # отдаём пустую структуру, чтобы фронт не падал
        return [
            {"Q": "Q1", "score1": "", "score2": ""},
            {"Q": "Q2", "score1": "", "score2": ""},
            {"Q": "Q3", "score1": "", "score2": ""},
            {"Q": "Q4", "score1": "", "score2": ""},
        ]

    game_data = game["data"] if "data" in game else game
    result = game_data.get("result", {})
    game_info = result.get("game", {})

    full_score = game_info.get("fullScore")
    if not full_score:
        # поле есть, но ещё пустое/None
        return [
            {"Q": "Q1", "score1": "", "score2": ""},
            {"Q": "Q2", "score1": "", "score2": ""},
            {"Q": "Q3", "score1": "", "score2": ""},
            {"Q": "Q4", "score1": "", "score2": ""},
        ]

    quarters = ["Q1", "Q2", "Q3", "Q4", "OT1", "OT2", "OT3", "OT4"]
    score_by_quarter = [{"Q": q, "score1": "", "score2": ""} for q in quarters]

    full_score_list = full_score.split(",")

    for i, score_str in enumerate(full_score_list[: len(score_by_quarter)]):
        parts = score_str.split(":")
        if len(parts) == 2:
            score_by_quarter[i]["score1"] = parts[0]
            score_by_quarter[i]["score2"] = parts[1]

    return score_by_quarter


async def top_sorted_team(data):
    top_sorted_team = sorted(
        (p for p in data if p.get("startRole") in ["Player", ""]),
        key=lambda x: (
            x.get("pts", 0),
            x.get("dreb", 0) + x.get("oreb", 0),
            x.get("ast", 0),
            x.get("stl", 0),
            x.get("blk", 0),
            x.get("time", "0:00"),
        ),
        reverse=True,
    )

    # пустые строки не должны ломать UI процентами фолов/очков
    for player in top_sorted_team:
        if player.get("num", "") == "":
            player["pts"] = ""
            player["foul"] = ""

    return top_sorted_team


def get_latest_game_safe(name:str):
    """
    Безопасно достаём актуальный game из latest_data.
    Возвращаем None, если структура ещё не готова или прилетел "плохой" game
    (например, с {"status": "no-status"} без data/result).
    """
    game = latest_data.get(name)
    if not game:
        return None

    # у нас в latest_data["game"] лежит {"ts": ..., "data": {...}} или сразу {...}
    # в consumer мы клали {"ts": ..., "data": payload}, так что берём .get("data")
    if "data" in game:
        game_data = game["data"]
    else:
        # на всякий случай, если где-то клали сразу payload
        game_data = game

    if not isinstance(game_data, dict):
        return None

    result = game_data.get("result")
    if not result:
        return None

    # если всё ок — вернём в исходном виде (с ts и т.п.)
    return game


def format_time(seconds: float | int) -> str:
    """
    Форматирует время в секундах в строку "M:SS".

    Args:
        seconds (float | int): Количество секунд.

    Returns:
        str: Время в формате "M:SS".
    """
    try:
        total_seconds = int(float(seconds))
        minutes = total_seconds // 60
        sec = total_seconds % 60
        return f"{minutes}:{sec:02}"
    except (ValueError, TypeError):
        return "0:00"


def _pick_last_avg_and_sum(stats_list: list) -> tuple[dict, dict]:
    """Возвращает (season_sum, season_avg) из seasonStats. Безопасно при пустых данных."""
    if not isinstance(stats_list, list) or len(stats_list) == 0:
        return {}, {}
    # В JSON конец массива: ... {"class":"Sum"}, {"class":"Avg"}
    last = stats_list[-1] if stats_list else None
    prev = stats_list[-2] if len(stats_list) >= 2 else None

    season_avg = last.get("stats", {}) if isinstance(last, dict) and str(last.get("class")).lower() == "avg" else {}
    season_sum = prev.get("stats", {}) if isinstance(prev, dict) and str(prev.get("class")).lower() == "sum" else {}

    # Бывают инверсии порядка (на всякий случай): попробуем найти явно
    if not season_avg or not season_sum:
        for x in reversed(stats_list):
            if isinstance(x, dict) and str(x.get("class")).lower() == "avg" and not season_avg:
                season_avg = x.get("stats", {}) or {}
            if isinstance(x, dict) and str(x.get("class")).lower() == "sum" and not season_sum:
                season_sum = x.get("stats", {}) or {}
            if season_avg and season_sum:
                break
    return season_sum, season_avg


def _pick_career_sum_and_avg(carrier_list: list) -> tuple[dict, dict]:
    """Возвращает (career_sum, career_avg) из carrier. В API встречаются блоки с class: Normal/Sum/Avg."""
    if not isinstance(carrier_list, list) or len(carrier_list) == 0:
        return {}, {}
    career_sum, career_avg = {}, {}
    # Ищем явные «Sum» и «Avg»
    for x in reversed(carrier_list):
        if isinstance(x, dict):
            cls = str(x.get("class", "")).lower()
            stats = x.get("stats", {}) or {}
            if cls == "sum" and not career_sum:
                career_sum = stats
            elif cls == "avg" and not career_avg:
                career_avg = stats
        if career_sum and career_avg:
            break
    # Если «Avg» нет (часто для карьеры бывает только Normal/Sum) — ок, оставим пустым
    return career_sum, career_avg


def _as_int(v, default=0):
    try:
        # в JSON часто строки; пустые строки -> 0
        if v in ("", None):
            return default
        return int(float(v))
    except Exception:
        return default


def _safe(d: dict) -> dict:
    return d if isinstance(d, dict) else {}


async def team(who: str):
    """
    Возвращает данные по команде (team1 / team2) из актуального game.
    Защищена от ситуации, когда latest_data["game"] ещё не прогрелся
    или в него прилетел "плохой" ответ от API.
    """
    game = get_latest_game_safe("game")
    if not game:
        # игра ещё не подгружена или структура кривоватая
        raise HTTPException(status_code=503, detail="game data not ready")
    
    full_stat = get_latest_game_safe("pregame-full-stats")
    if not full_stat:
        # ⚠️ full_stat_data отсутствует — работаем только с game_data
        logger.debug(f"[{who}] full_stat_data not found → continuing with game_data only")
        full_stat_data = {}
    else:
        full_stat_data = full_stat["data"] if "data" in full_stat else full_stat

    # нормализуем доступ к данным
    game_data = game["data"] if "data" in game else game
    result = game_data[
        "result"
    ]  # здесь уже безопасно, мы проверили в get_latest_game_safe
    result_full = full_stat_data.get("result", {}) if full_stat_data else {}
    
    # в result ожидаем "teams"
    teams = result.get("teams")

    if not teams:
        raise HTTPException(status_code=503, detail="game teams not ready")

    # выбираем команду
    if who == "team1":
        payload = next((t for t in teams if t.get("teamNumber") == 1), None)
        payload_full = result_full.get("team1PlayersStats") if result_full else []
    else:
        payload = next((t for t in teams if t.get("teamNumber") == 2), None)
        payload_full = result_full.get("team2PlayersStats") if result_full else []

    if payload is None:
        raise HTTPException(status_code=404, detail=f"{who} not found in game data")

    # дальше — твоя исходная логика формирования ответа по команде
    # я не знаю весь твой оригинальный код ниже, поэтому вставляю каркас
    # и показываю, где нужно аккуратно брать plays/box-score из latest_data
    role_list = [
        ("Center", "C"),
        ("Guard", "G"),
        ("Forward", "F"),
        ("Power Forward", "PF"),
        ("Small Forward", "SF"),
        ("Shooting Guard", "SG"),
        ("Point Guard", "PG"),
        ("Forward-Center", "FC"),
    ]
    starts = payload.get("starts", [])
    
    team_rows = []
    for item in starts:
        stats = item.get("stats") or {}
        pid = str(item.get("personId"))
        full_obj = next((p for p in (payload_full or []) if str(p.get("personId")) == pid), None)

        season_sum = season_avg = career_sum = career_avg = {}
        if full_obj:
            # сезон
            season_sum, season_avg = _pick_last_avg_and_sum(full_obj.get("seasonStats") or [])
            # карьера
            career_sum, career_avg = _pick_career_sum_and_avg(full_obj.get("carrier") or [])
        
        season_sum = _safe(season_sum)
        season_avg = _safe(season_avg)
        career_sum = _safe(career_sum)
        career_avg = _safe(career_avg)
        
        # Полезные числа для Totals+Live
        # live-поля в box-score называются goal1/2/3, shot1/2/3, defReb/offReb и т.п.
        g1  = _as_int(stats.get("goal1"))
        s1  = _as_int(stats.get("shot1"))
        g2  = _as_int(stats.get("goal2"))
        s2  = _as_int(stats.get("shot2"))
        g3  = _as_int(stats.get("goal3"))
        s3  = _as_int(stats.get("shot3"))

        # Сезонные суммы из pregame-full-stats
        ss_pts  = _as_int(season_sum.get("points"))
        ss_ast  = _as_int(season_sum.get("assist"))
        ss_blk  = _as_int(season_sum.get("blockShot"))
        ss_dreb = _as_int(season_sum.get("defRebound"))
        ss_oreb = _as_int(season_sum.get("offRebound"))
        ss_reb  = _as_int(season_sum.get("rebound"))
        ss_stl  = _as_int(season_sum.get("steal"))
        ss_to   = _as_int(season_sum.get("turnover"))
        ss_foul = _as_int(season_sum.get("foul"))
        ss_sec  = _as_int(season_sum.get("second"))
        ss_gms  = _as_int(season_sum.get("games"))
        ss_st   = _as_int(season_sum.get("isStarts"))
        ss_g1   = _as_int(season_sum.get("goal1"))
        ss_s1   = _as_int(season_sum.get("shot1"))
        ss_g2   = _as_int(season_sum.get("goal2"))
        ss_s2   = _as_int(season_sum.get("shot2"))
        ss_g3   = _as_int(season_sum.get("goal3"))
        ss_s3   = _as_int(season_sum.get("shot3"))
        
        # Карьерные суммы из pregame-full-stats
        car_ss_pts  = _as_int(career_sum.get("points"))
        car_ss_ast  = _as_int(career_sum.get("assist"))
        car_ss_blk  = _as_int(career_sum.get("blockShot"))
        car_ss_dreb = _as_int(career_sum.get("defRebound"))
        car_ss_oreb = _as_int(career_sum.get("offRebound"))
        car_ss_reb  = _as_int(career_sum.get("rebound"))
        car_ss_stl  = _as_int(career_sum.get("steal"))
        car_ss_to   = _as_int(career_sum.get("turnover"))
        car_ss_foul = _as_int(career_sum.get("foul"))
        car_ss_sec  = _as_int(career_sum.get("second"))
        car_ss_gms  = _as_int(career_sum.get("games"))
        car_ss_st   = _as_int(career_sum.get("isStarts"))
        car_ss_g1   = _as_int(career_sum.get("goal1"))
        car_ss_s1   = _as_int(career_sum.get("shot1"))
        car_ss_g2   = _as_int(career_sum.get("goal2"))
        car_ss_s2   = _as_int(career_sum.get("shot2"))
        car_ss_g3   = _as_int(career_sum.get("goal3"))
        car_ss_s3   = _as_int(career_sum.get("shot3"))

        # Totals по сезону, «с учётом текущего матча»:
        T_points = ss_pts + _as_int(stats.get("points"))
        T_assist = ss_ast + _as_int(stats.get("assist"))
        T_block  = ss_blk + _as_int(stats.get("block"))
        T_dreb   = ss_dreb + _as_int(stats.get("defReb"))
        T_oreb   = ss_oreb + _as_int(stats.get("offReb"))
        T_reb    = ss_reb + (_as_int(stats.get("defReb")) + _as_int(stats.get("offReb")))
        T_steal  = ss_stl + _as_int(stats.get("steal"))
        T_turn   = ss_to  + _as_int(stats.get("turnover"))
        T_foul   = ss_foul + _as_int(stats.get("foul"))
        T_sec    = ss_sec + _as_int(stats.get("second"))
        T_gms    = ss_gms + (1 if _as_int(stats.get("second")) > 0 else 0)
        T_starts = ss_st  + (1 if bool(stats.get("isStart")) else 0)

        T_g1 = ss_g1 + g1
        T_s1 = ss_s1 + s1
        T_g2 = ss_g2 + g2
        T_s2 = ss_s2 + s2
        T_g3 = ss_g3 + g3
        T_s3 = ss_s3 + s3
        
        # Totals по карьере, «с учётом текущего матча»:
        car_T_points = car_ss_pts + _as_int(stats.get("points"))
        car_T_assist = car_ss_ast + _as_int(stats.get("assist"))
        car_T_block  = car_ss_blk + _as_int(stats.get("block"))
        car_T_dreb   = car_ss_dreb + _as_int(stats.get("defReb"))
        car_T_oreb   = car_ss_oreb + _as_int(stats.get("offReb"))
        car_T_reb    = car_ss_reb + (_as_int(stats.get("defReb")) + _as_int(stats.get("offReb")))
        car_T_steal  = car_ss_stl + _as_int(stats.get("steal"))
        car_T_turn   = car_ss_to  + _as_int(stats.get("turnover"))
        car_T_foul   = car_ss_foul + _as_int(stats.get("foul"))
        car_T_sec    = car_ss_sec + _as_int(stats.get("second"))
        car_T_gms    = car_ss_gms + (1 if _as_int(stats.get("second")) > 0 else 0)
        car_T_starts = car_ss_st  + (1 if bool(stats.get("isStart")) else 0)

        car_T_g1 = car_ss_g1 + g1
        car_T_s1 = car_ss_s1 + s1
        car_T_g2 = car_ss_g2 + g2
        car_T_s2 = car_ss_s2 + s2
        car_T_g3 = car_ss_g3 + g3
        car_T_s3 = car_ss_s3 + s3

        # Проценты (без деления на 0)
        def _pct(goal, shot):
            return f"{round(goal*100/shot, 1)}%" if shot else "0.0%"

        # Для «23» используем сумму 2-х и 3-х
        T_g23 = T_g2 + T_g3
        T_s23 = T_s2 + T_s3        
        car_T_g23 = car_T_g2 + car_T_g3
        car_T_s23 = car_T_s2 + car_T_s3        
        # print(avg_season, total_season)
        row = {
            "id": item.get("personId") or "",
            "num": item.get("displayNumber"),
            "startRole": item.get("startRole"),
            "role": item.get("positionName"),
            "roleShort": (
                [
                    r[1]
                    for r in role_list
                    if r[0].lower() == (item.get("positionName") or "").lower()
                ][0]
                if any(
                    r[0].lower() == (item.get("positionName") or "").lower()
                    for r in role_list
                )
                else ""
            ),
            "NameGFX": (
                f"{(item.get('firstName') or '').strip()} {(item.get('lastName') or '').strip()}".strip()
                if item.get("firstName") is not None
                and item.get("lastName") is not None
                else "Команда"
            ),
            "Name1GFX": (item.get('firstName') or '').strip(),
            "Name2GFX": (item.get('lastName') or '').strip(),
            "captain": item.get("isCapitan", False),
            "age": item.get("age") or 0,
            "height": f"{item.get('height')} cm" if item.get("height") else 0,
            "weight": f"{item.get('weight')} kg" if item.get("weight") else 0,
            "isStart": stats.get("isStart", False),
            "isOn": "🏀" if stats.get("isOnCourt") is True else "",
            "isOnCourt": stats.get("isOnCourt", False),
            "flag": (
                "https://flagicons.lipis.dev/flags/4x3/"
                + (
                    "ru"
                    if item.get("countryId") is None
                    and item.get("countryName") == "Russia"
                    else (
                        ""
                        if item.get("countryId") is None
                        else (
                            (item.get("countryId") or "").lower()
                            if item.get("countryName") is not None
                            else ""
                        )
                    )
                )
                + ".svg"
            ),
            "photoGFX": (
                os.path.join(
                    "D:\\Photos",
                    result["league"]["abcName"],
                    result[who]["name"],
                    f"{item.get('displayNumber')}.png",
                )
                if item.get("startRole") == "Player"
                else ""
            ),
        # live-стата
        "pts": _as_int(stats.get("points")),
        "pt-2": f"{g2}/{s2}",
        "pt-3": f"{g3}/{s3}",
        "pt-1": f"{g1}/{s1}",
        "fg":   f"{g2+g3}/{s2+s3}",
        "ast": _as_int(stats.get("assist")),
        "stl": _as_int(stats.get("steal")),
        "blk": _as_int(stats.get("block")),
        "blkVic": _as_int(stats.get("blocked")),
        "dreb": _as_int(stats.get("defReb")),
        "oreb": _as_int(stats.get("offReb")),
        "reb":  _as_int(stats.get("defReb")) + _as_int(stats.get("offReb")),
        "to": _as_int(stats.get("turnover")),
        "foul": _as_int(stats.get("foul")),
        "foulT": _as_int(stats.get("foulT")),
        "foulD": _as_int(stats.get("foulD")),
        "foulC": _as_int(stats.get("foulC")),
        "foulB": _as_int(stats.get("foulB")),
        "fouled": _as_int(stats.get("foulsOn")),
        "plusMinus": _as_int(stats.get("plusMinus")),
        "dunk": _as_int(stats.get("dunk")),
        "kpi": (
            _as_int(stats.get("points"))
            + _as_int(stats.get("defReb")) + _as_int(stats.get("offReb"))
            + _as_int(stats.get("assist")) + _as_int(stats.get("steal")) + _as_int(stats.get("block"))
            + _as_int(stats.get("foulsOn"))
            + (g1 - s1) + (g2 - s2) + (g3 - s3)
            - _as_int(stats.get("turnover")) - _as_int(stats.get("foul"))
        ),
        "time": format_time(_as_int(stats.get("second"))),

        # сезон — средние (из последнего Avg)
        "AvgPoints":       season_avg.get("points") or "0.0",
        "AvgAssist":       season_avg.get("assist") or "0.0",
        "AvgBlocks":       season_avg.get("blockShot") or "0.0",
        "AvgDefRebound":   season_avg.get("defRebound") or "0.0",
        "AvgOffRebound":   season_avg.get("offRebound") or "0.0",
        "AvgRebound":      season_avg.get("rebound") or "0.0",
        "AvgSteal":        season_avg.get("steal") or "0.0",
        "AvgTurnover":     season_avg.get("turnover") or "0.0",
        "AvgFoul":         season_avg.get("foul") or "0.0",
        "AvgOpponentFoul": season_avg.get("foulsOnPlayer") or "0.0",
        "AvgDunk":         season_avg.get("dunk") or "0.0",
        "AvgPlayedTime":   season_avg.get("playedTime") or "0:00",
        "Shot1Percent":    season_avg.get("shot1Percent") or "0.0%",
        "Shot2Percent":    season_avg.get("shot2Percent") or "0.0%",
        "Shot3Percent":    season_avg.get("shot3Percent") or "0.0%",
        "Shot23Percent":   season_avg.get("shot23Percent") or "0.0%",

        # сезон — Totals (суммы из Sum + live)
        "TPoints": T_points,
        "TShots1": f"{T_g1}/{T_s1}",
        "TShots2": f"{T_g2}/{T_s2}",
        "TShots3": f"{T_g3}/{T_s3}",
        "TShots23": f"{T_g23}/{T_s23}",
        "TShot1Percent": _pct(T_g1, T_s1),
        "TShot2Percent": _pct(T_g2, T_s2),
        "TShot3Percent": _pct(T_g3, T_s3),
        "TShot23Percent": _pct(T_g23, T_s23),
        "TAssist": T_assist,
        "TBlocks": T_block,
        "TDefRebound": T_dreb,
        "TOffRebound": T_oreb,
        "TRebound": T_reb,
        "TSteal": T_steal,
        "TTurnover": T_turn,
        "TFoul": T_foul,
        "TPlayedTime": format_time(T_sec),
        "TGameCount": T_gms,
        "TStartCount": T_starts,
        
        # карьера — средние (из последнего Avg)
        "Career_AvgPoints":       career_avg.get("points") or "0.0",
        "Career_AvgAssist":       career_avg.get("assist") or "0.0",
        "Career_AvgBlocks":       career_avg.get("blockShot") or "0.0",
        "Career_AvgDefRebound":   career_avg.get("defRebound") or "0.0",
        "Career_AvgOffRebound":   career_avg.get("offRebound") or "0.0",
        "Career_AvgRebound":      career_avg.get("rebound") or "0.0",
        "Career_AvgSteal":        career_avg.get("steal") or "0.0",
        "Career_AvgTurnover":     career_avg.get("turnover") or "0.0",
        "Career_AvgFoul":         career_avg.get("foul") or "0.0",
        "Career_AvgOpponentFoul": career_avg.get("foulsOnPlayer") or "0.0",
        "Career_AvgDunk":         career_avg.get("dunk") or "0.0",
        "Career_AvgPlayedTime":   career_avg.get("playedTime") or "0:00",
        "Career_Shot1Percent":    career_avg.get("shot1Percent") or "0.0%",
        "Career_Shot2Percent":    career_avg.get("shot2Percent") or "0.0%",
        "Career_Shot3Percent":    career_avg.get("shot3Percent") or "0.0%",
        "Career_Shot23Percent":   career_avg.get("shot23Percent") or "0.0%",

        # карьера — Totals (суммы из Sum + live)
        "Career_TPoints": car_T_points,
        "Career_TShots1": f"{car_T_g1}/{car_T_s1}",
        "Career_TShots2": f"{car_T_g2}/{car_T_s2}",
        "Career_TShots3": f"{car_T_g3}/{car_T_s3}",
        "Career_TShots23": f"{car_T_g23}/{car_T_s23}",
        "Career_TShot1Percent": _pct(car_T_g1, car_T_s1),
        "Career_TShot2Percent": _pct(car_T_g2, car_T_s2),
        "Career_TShot3Percent": _pct(car_T_g3, car_T_s3),
        "Career_TShot23Percent": _pct(car_T_g23, car_T_s23),
        "Career_TAssist": car_T_assist,
        "Career_TBlocks": car_T_block,
        "Career_TDefRebound": car_T_dreb,
        "Career_TOffRebound": car_T_oreb,
        "Career_TRebound": car_T_reb,
        "Career_TSteal": car_T_steal,
        "Career_TTurnover": car_T_turn,
        "Career_TFoul": car_T_foul,
        "Career_TPlayedTime": format_time(car_T_sec),
        "Career_TGameCount": car_T_gms,
        "Career_TStartCount": car_T_starts,

    }
        team_rows.append(row)
    
    # добиваем до 12 строк, чтобы UI был ровный
    count_player = sum(1 for x in team_rows if x["startRole"] == "Player")
    if count_player < 12 and team_rows:
        filler_count = (4 if count_player <= 4 else 12) - count_player
        template_keys = list(team_rows[0].keys())

        for _ in range(filler_count):
            empty_row = {}
            for key in template_keys:
                if key in ["captain", "isStart", "isOnCourt"]:
                    empty_row[key] = False
                elif key in [
                    "id",
                    "pts",
                    "weight",
                    "height",
                    "age",
                    "ast",
                    "stl",
                    "blk",
                    "blkVic",
                    "dreb",
                    "oreb",
                    "reb",
                    "to",
                    "foul",
                    "foulT",
                    "foulD",
                    "foulC",
                    "foulB",
                    "fouled",
                    "plusMinus",
                    "dunk",
                    "kpi",
                ]:
                    empty_row[key] = 0
                else:
                    empty_row[key] = ""
            team_rows.append(empty_row)

    # сортируем игроков по типу роли: сначала "Player", потом "", потом "Coach" и т.д.
    role_priority = {
        "Player": 0,
        "": 1,
        "Coach": 2,
        "Team": 3,
        None: 4,
        "Other": 5,
    }
    sorted_team = sorted(
        team_rows,
        key=lambda x: role_priority.get(x.get("startRole", 99), 99),
    )

    return sorted_team


async def started_team(data):
    started_team = sorted(
        (
            p
            for p in data
            if p.get("startRole") == "Player" and p.get("isOnCourt") is True
        ),
        key=lambda x: int(x.get("num") or 0),
    )
    return started_team


def add_new_team_stat(
    data: dict,
    avg_age: float,
    points,
    avg_height: float,
    timeout_str: str,
    timeout_left: int,
) -> dict:
    """
    Берёт словарь total по команде (очки, подборы, броски и т.д.),
    добавляет:
      - проценты попаданий
      - средний возраст / рост
      - очки старт / бенч
      - информацию по таймаутам
    и всё приводит к строкам (для UI, чтобы не ловить типы).

    Возвращает обновлённый словарь.
    """

    def safe_int(v):
        try:
            return int(v)
        except (ValueError, TypeError):
            return 0

    def format_percent(goal, shot):
        goal, shot = safe_int(goal), safe_int(shot)
        return f"{round(goal * 100 / shot)}%" if shot else "0%"

    goal1, shot1 = safe_int(data.get("goal1")), safe_int(data.get("shot1"))
    goal2, shot2 = safe_int(data.get("goal2")), safe_int(data.get("shot2"))
    goal3, shot3 = safe_int(data.get("goal3")), safe_int(data.get("shot3"))

    def_reb = safe_int(data.get("defReb"))
    off_reb = safe_int(data.get("offReb"))

    data.update(
        {
            "pt-1": f"{goal1}/{shot1}",
            "pt-2": f"{goal2}/{shot2}",
            "pt-3": f"{goal3}/{shot3}",
            "fg": f"{goal2 + goal3}/{shot2 + shot3}",
            "pt-1_pro": format_percent(goal1, shot1),
            "pt-2_pro": format_percent(goal2, shot2),
            "pt-3_pro": format_percent(goal3, shot3),
            "fg_pro": format_percent(goal2 + goal3, shot2 + shot3),
            "Reb": str(def_reb + off_reb),
            "avgAge": str(avg_age),
            "ptsStart": str(points[0]),
            "ptsStart_pro": str(points[1]),
            "ptsBench": str(points[2]),
            "ptsBench_pro": str(points[3]),
            "avgHeight": f"{avg_height} cm",
            "timeout_left": str(timeout_left),
            "timeout_str": str(timeout_str),
        }
    )

    for k in data:
        data[k] = str(data[k])

    return data


def time_outs_func(data_pbp):
    """
    Считает таймауты для обеих команд и формирует читабельные строки вида:
    "2 Time-outs left in 2nd half"

    Возвращает:
      (строка_для_команды1, остаток1, строка_для_команды2, остаток2)
    """
    timeout1 = []
    timeout2 = []

    for event in data_pbp:
        if event.get("play") == 23:  # 23 == таймаут
            if event.get("startNum") == 1:
                timeout1.append(event)
            elif event.get("startNum") == 2:
                timeout2.append(event)

    def timeout_status(timeout_list, last_event: dict):
        period = last_event.get("period", 0)
        sec = last_event.get("sec", 0)

        if period < 3:
            timeout_max = 2
            count = sum(1 for t in timeout_list if t.get("period", 0) <= period)
            quarter = "1st half"
        elif period < 5:
            count = sum(1 for t in timeout_list if 3 <= t.get("period", 0) <= period)
            quarter = "2nd half"
            if period == 4 and sec >= 4800 and count in (0, 1):
                timeout_max = 2
            else:
                timeout_max = 3
        else:
            timeout_max = 1
            count = sum(1 for t in timeout_list if t.get("period", 0) == period)
            quarter = f"OverTime {period - 4}"

        left = max(0, timeout_max - count)
        word = "Time-outs" if left != 1 else "Time-out"
        text = f"{left if left != 0 else 'No'} {word} left in {quarter}"
        return text, left

    if not data_pbp:
        return "", 0, "", 0

    last_event = data_pbp[-1]
    t1_str, t1_left = timeout_status(timeout1, last_event)
    t2_str, t2_left = timeout_status(timeout2, last_event)

    return t1_str, t1_left, t2_str, t2_left


def add_data_for_teams(new_data):
    """
    Считает командные агрегаты:
      - средний возраст
      - очки со старта vs со скамейки, + их проценты
      - средний рост

    Возвращает кортеж:
      (avg_age, [start_pts, start%, bench_pts, bench%], avg_height_cm)
    """
    players = [item for item in new_data if item["startRole"] == "Player"]

    points_start = 0
    points_bench = 0
    total_age = 0
    total_height = 0
    player_count = len(players)

    for player in players:
        # print(player)
        stats = player["stats"]
        if stats:
            # print(stats)
            if stats["isStart"] is True:
                points_start += stats["points"]
            elif stats["isStart"] is False:
                points_bench += stats["points"]

        total_age += player["age"]
        total_height += player["height"]
    total_points = points_start + points_bench
    points_start_pro = (
        f"{round(points_start * 100 / total_points)}%" if total_points else "0%"
    )
    points_bench_pro = (
        f"{round(points_bench * 100 / total_points)}%" if total_points else "0%"
    )

    avg_age = round(total_age / player_count, 1) if player_count else 0
    avg_height = round(total_height / player_count, 1) if player_count else 0

    points = [points_start, points_start_pro, points_bench, points_bench_pro]
    return avg_age, points, avg_height


stat_name_list = [
    ("points", "Очки", "points"),
    ("pt-1", "Штрафные", "free throws"),
    ("pt-1_pro", "штрафные, процент", "free throws pro"),
    ("pt-2", "2-очковые", "2-points"),
    ("pt-2_pro", "2-очковые, процент", "2-points pro"),
    ("pt-3", "3-очковые", "3-points"),
    ("pt-3_pro", "3-очковые, процент", "3-points pro"),
    ("fg", "очки с игры", "field goals"),
    ("fg_pro", "Очки с игры, процент", "field goals pro"),
    ("assist", "Передачи", "assists"),
    ("pass", "", ""),
    ("defReb", "подборы в защите", ""),
    ("offReb", "подборы в нападении", ""),
    ("Reb", "Подборы", "rebounds"),
    ("steal", "Перехваты", "steals"),
    ("block", "Блокшоты", "blocks"),
    ("blocked", "", ""),
    ("turnover", "Потери", "turnovers"),
    ("foul", "Фолы", "fouls"),
    ("foulsOn", "", ""),
    ("foulT", "", ""),
    ("foulD", "", ""),
    ("foulC", "", ""),
    ("foulB", "", ""),
    ("second", "секунды", "seconds"),
    ("dunk", "данки", "dunks"),
    ("fastBreak", "", "fast breaks"),
    ("plusMinus", "+/-", "+/-"),
    ("avgAge", "", "avg Age"),
    ("ptsBench", "", "Bench PTS"),
    ("ptsBench_pro", "", "Bench PTS, %"),
    ("ptsStart", "", "Start PTS"),
    ("ptsStart_pro", "", "Start PTS, %"),
    ("avgHeight", "", "avg height"),
    ("timeout_left", "", "timeout left"),
    ("timeout_str", "", "timeout str"),
]


@app.get("/team_stats")
async def team_stats():
    teams = latest_data["game"]["data"]["result"]["teams"]
    plays = latest_data["game"]["data"]["result"]["plays"]

    team_1 = next((t for t in teams if t["teamNumber"] == 1), None)
    team_2 = next((t for t in teams if t["teamNumber"] == 2), None)

    timeout_str1, timeout_left1, timeout_str2, timeout_left2 = time_outs_func(plays)

    avg_age_1, points_1, avg_height_1 = add_data_for_teams(team_1["starts"])
    avg_age_2, points_2, avg_height_2 = add_data_for_teams(team_2["starts"])

    total_1 = add_new_team_stat(
        team_1["total"],
        avg_age_1,
        points_1,
        avg_height_1,
        timeout_str1,
        timeout_left1,
    )
    total_2 = add_new_team_stat(
        team_2["total"],
        avg_age_2,
        points_2,
        avg_height_2,
        timeout_str2,
        timeout_left2,
    )

    result_json = []
    for key in total_1:
        val1 = total_1[key]
        val2 = total_2[key]

        stat_rus = ""
        stat_eng = ""
        for metric_name, rus, eng in stat_name_list:
            if metric_name == key:
                stat_rus, stat_eng = rus, eng
                break

        result_json.append(
            {
                "name": key,
                "nameGFX_rus": stat_rus,
                "nameGFX_eng": stat_eng,
                "val1": val1,
                "val2": val2,
            }
        )
    return result_json


@app.get("/referee")
async def referee():
    desired_order = [
        "Crew chief",
        "Referee 1",
        "Referee 2",
        "Commissioner",
        "Ст.судья",
        "Судья 1",
        "Судья 2",
        "Комиссар",
    ]

    # Найти судей (teamNumber == 0)
    team_ref = next(
        (
            t
            for t in latest_data["game"]["data"]["result"]["teams"]
            if t["teamNumber"] == 0
        ),
        None,
    )

    referees_raw = team_ref.get("starts", [])
    referees = []

    for r in referees_raw:
        flag_code = r.get("countryId", "").lower() if r.get("countryName") else ""
        referees.append(
            {
                "displayNumber": r.get("displayNumber", ""),
                "positionName": r.get("positionName", ""),
                "lastNameGFX": f"{r.get('firstName', '')} {r.get('lastName', '')}".strip(),
                "secondName": r.get("secondName", ""),
                "birthday": r.get("birthday", ""),
                "age": r.get("age", 0),
                "flag": f"https://flagicons.lipis.dev/flags/4x3/{flag_code}.svg",
            }
        )

    # Сортировка по позиции
    referees = sorted(
        referees,
        key=lambda x: (
            desired_order.index(x["positionName"])
            if x["positionName"] in desired_order
            else len(desired_order)
        ),
    )
    return referees


@app.get("/team_comparison")
async def team_comparison():
    if STATUS not in ["no_game_today", "finished_today"]:
        data = latest_data["pregame"]["data"]["result"]
        teams = []
        for data_team in (data["teamStats1"], data["teamStats2"]):
            temp_team = {
                "team": data_team["team"]["name"],
                "games": data_team["games"],
                "points": round(
                    (data_team["totalStats"]["points"] / data_team["games"]), 1
                ),
                "points_2": round(
                    (
                        data_team["totalStats"]["goal2"]
                        * 100
                        / data_team["totalStats"]["shot2"]
                    ),
                    1,
                ),
                "points_3": round(
                    (
                        data_team["totalStats"]["goal3"]
                        * 100
                        / data_team["totalStats"]["shot3"]
                    ),
                    1,
                ),
                "points_23": round(
                    (
                        data_team["totalStats"]["goal23"]
                        * 100
                        / data_team["totalStats"]["shot23"]
                    ),
                    1,
                ),
                "points_1": round(
                    (
                        data_team["totalStats"]["goal1"]
                        * 100
                        / data_team["totalStats"]["shot1"]
                    ),
                    1,
                ),
                "assists": round(
                    (data_team["totalStats"]["assist"] / data_team["games"]), 1
                ),
                "rebounds": round(
                    (
                        (
                            data_team["totalStats"]["defRebound"]
                            + data_team["totalStats"]["offRebound"]
                        )
                        / data_team["games"]
                    ),
                    1,
                ),
                "steals": round(
                    (data_team["totalStats"]["steal"] / data_team["games"]), 1
                ),
                "turnovers": round(
                    (data_team["totalStats"]["turnover"] / data_team["games"]), 1
                ),
                "blocks": round(
                    (data_team["totalStats"]["blockShot"] / data_team["games"]), 1
                ),
                "fouls": round(
                    (data_team["totalStats"]["foul"] / data_team["games"]), 1
                ),
            }
            teams.append(temp_team)
        return teams
    else:
        return [{"Данных о сравнении команд нет!"}]


@app.get("/standings")
async def regular_standings():
    data = latest_data["actual-standings"]["data"]["items"]
    for item in data:
        # if item["comp"]["name"] == "Regular Season":
        if item.get("standings"):
            standings_rows = item["standings"]

            df = pd.json_normalize(standings_rows)

            if "scores" in df.columns:
                df = df.drop(columns=["scores"])

            if (
                "totalWin" in df.columns
                and "totalDefeat" in df.columns
                and "totalGames" in df.columns
                and "totalGoalPlus" in df.columns
                and "totalGoalMinus" in df.columns
            ):
                tw = (
                    pd.to_numeric(df["totalWin"], errors="coerce").fillna(0).astype(int)
                )
                td = (
                    pd.to_numeric(df["totalDefeat"], errors="coerce")
                    .fillna(0)
                    .astype(int)
                )

                df["w_l"] = tw.astype(str) + " / " + td.astype(str)

                def calc_percent(row):
                    win = row.get("totalWin", 0)
                    games = row.get("totalGames", 0)

                    # гарантируем числа
                    try:
                        win = int(win)
                    except (TypeError, ValueError):
                        win = 0
                    try:
                        games = int(games)
                    except (TypeError, ValueError):
                        games = 0

                    if games == 0 or row["w_l"] == "0 / 0":
                        return 0

                    return round(win * 100 / games + 0.000005)

                df["procent"] = df.apply(calc_percent, axis=1)

                tg_plus = (
                    pd.to_numeric(df["totalGoalPlus"], errors="coerce")
                    .fillna(0)
                    .astype(int)
                )
                tg_minus = (
                    pd.to_numeric(df["totalGoalMinus"], errors="coerce")
                    .fillna(0)
                    .astype(int)
                )

                df["plus_minus"] = tg_plus - tg_minus

            standings_payload = df.to_dict(orient="records")
            return standings_payload


@app.get("/live_status")
async def live_status():
    # если матч реально идёт/вот-вот — пытаемся отдать то, что есть
    if STATUS in ["live", "live_soon"]:
        ls = latest_data.get("live-status")

        if not ls:
            # live-status ещё не прилетел
            return [{"foulsA": 0, "foulsB": 0}]

        raw = ls.get("data")

        # 1) если это уже готовый dict и в нём есть result → как было раньше
        if isinstance(raw, dict):
            # иногда API кладёт всё прямо в root, иногда внутрь result
            if "result" in raw and isinstance(raw["result"], dict):
                return [raw["result"]]
            else:
                # отдадим как есть, но в списке, чтобы фронт не сломать
                return [raw]

        # 2) если это просто строка статуса ("ok" / "no-status" / "error")
        if isinstance(raw, str):
            return [{"status": raw}]

        # fallback
        return [{"foulsA": 0, "foulsB": 0}]
    else:
        # матч не идёт — как у тебя было
        return [{"foulsA": 0, "foulsB": 0}]


@app.get("/info")
async def info():
    data = latest_data["game"]["data"]["result"]
    team1_name = data["team1"]["name"]
    team2_name = data["team2"]["name"]
    team1_logo = data["team1"]["logo"]
    team2_logo = data["team2"]["logo"]
    arena = data["arena"]["name"]
    arena_short = data["arena"]["shortName"]
    region = data["region"]["name"]
    date_obj = datetime.strptime(data["game"]["localDate"], "%d.%m.%Y")
    league = data["league"]["abcName"]
    league_full = data["league"]["name"]
    season = f'{str(data["league"]["season"]-1)}/{str(data["league"]["season"])[2:]}'
    stadia = data["comp"]["name"]
    try:
        full_format = date_obj.strftime("%A, %-d %B %Y")
        short_format = date_obj.strftime("%A, %-d %b")
    except ValueError:
        full_format = date_obj.strftime("%A, %#d %B %Y")
        short_format = date_obj.strftime("%A, %#d %b")
        
    
    return [
        {
            "team1": team1_name,
            "team2": team2_name,
            "logo1": team1_logo,
            "logo2": team2_logo,
            "arena": arena,
            "short_arena": arena_short,
            "region": region,
            "league": league,
            "league_full": league_full,
            "season": season,
            "stadia": stadia,
            "date1": str(full_format),
            "date2": str(short_format),
        }
    ]


if __name__ == "__main__":
    uvicorn.run(
        "get_data:app", host="0.0.0.0", port=8000, reload=True, log_level="debug"
    )