import re import ast import os import time from da...

Question

import re
import ast
import os
import time
from dataclasses import dataclass
from typing import Optional, Dict, Any, Tuple
from datetime import datetime
from collections import deque
from pathlib import Path

import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import StaleElementReferenceException

from openpyxl import Workbook, load_workbook
from openpyxl.chart import LineChart, Reference

===================== CONFIG =====================

URL = "https://www.nowgoal.com/basketball"

POLL_SECONDS = 5
STAKE = 1.0
HEADLESS = True

✅ NEW: wait after FIRST halftime appears (to stabilize odds/lines)

HALFTIME_WAIT_SECONDS = 15

DIFF_BANDS = [
(20.0, 30.0, "20-30"),
(30.0, 40.0, "30-40"),
(40.0, 50.0, "40-50"),
(50.0, None, "50+"),
]

SCROLL_EVERY_N_LOOPS = 12

EXCEL_PATH = os.getenv("EXCEL_PATH", "nowgoal_monitor.xlsx")

TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "8025557030:AAHgZX_pCOvQu7Gmi33X3iqe0oY7Y67yBMA")
TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "6667940236")

====== WINDOWS-EXCEL SAFE SAVE + SNAPSHOTS ======

SNAPSHOT_DIR = "snapshots" # сюда будут писаться файлы, которые можно открывать в Excel
SNAPSHOT_EVERY_SECONDS = 60 # снимок раз в минуту (можешь поставить 30)
AUTOSAVE_SUFFIX = "_AUTOSAVE.xlsx" # если основной файл открыт -> сохраняем сюда
SAVE_RETRIES = 3
SAVE_RETRY_SLEEP = 1.0

_last_snapshot_ts = 0.0
_excel_lock_notified = False

===================== TELEGRAM =====================

def tg_ready() -> bool:
return bool(TELEGRAM_TOKEN and TELEGRAM_CHAT_ID)

def tg_send(text: str) -> None:
"""Отправка сообщения в Telegram + лог в консоль."""
print(f"[TG] -> {text.replace('\n', ' | ')}", flush=True)
if not tg_ready():
print("[TG] Token/ChatId не заданы (пропускаю отправку).", flush=True)
return

text
try:
    r = requests.post(
        f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage",
        data={"chat_id": TELEGRAM_CHAT_ID, "text": text, "disable_web_page_preview": True},
        timeout=10,
    )
    if not r.ok:
        print(f"[TG] Ошибка отправки: {r.status_code} {r.text[:300]}", flush=True)
except Exception as e:
    print(f"[TG] Exception: {e}", flush=True)

===================== MODELS =====================

@dataclass
class Team:
name: str
tag: Optional[str] = None

@dataclass
class LineOU:
total: Optional[float] = None
over_odds: Optional[float] = None # decimal
under_odds: Optional[float] = None # decimal

===================== HELPERS =====================

def now_ts() -> str:
return datetime.now().strftime("%H:%M:%S")

def now_dt() -> str:
return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def txt(el) -> str:
if el is None:
return ""
return (el.get_attribute("textContent") or "").strip()

def safe_float(x: Optional[str]) -> Optional[float]:
if not x:
return None
x = x.strip().replace(",", ".")
try:
return float(x)
except ValueError:
return None

def hk_to_decimal(odds: Optional[float]) -> Optional[float]:
# HK 0.83 -> Decimal 1.83
if odds is None:
return None
if odds >= 1.2:
return odds
return odds + 1.0

def read_odds_decimal(span) -> Optional[float]:
"""odds2 может быть текст 1.80, а может быть пусто, но есть data-o=0.80 (HK)."""
if span is None:
return None

text
t = (span.get_attribute("textContent") or "").strip()
v = safe_float(t)
if v is not None:
    return hk_to_decimal(v)

v2 = safe_float(span.get_attribute("data-o"))
if v2 is not None:
    return hk_to_decimal(v2)

return None

-------- Excel safe save + snapshots (Windows) --------

def safe_save(wb: Workbook, path: str) -> bool:
"""
Пытаемся сохранить в основной файл.
Если Excel держит лок (Windows) -> не падаем, сохраняем в AUTOSAVE.
"""
global _excel_lock_notified

text
for i in range(1, SAVE_RETRIES + 1):
    try:
        wb.save(path)
        # если раньше предупреждали про лок — сбросим флаг, т.к. снова всё ок
        _excel_lock_notified = False
        return True
    except PermissionError:
        print(f"[{now_ts()}] Excel LOCKED: {path} (try {i}/{SAVE_RETRIES})", flush=True)
        time.sleep(SAVE_RETRY_SLEEP)
    except OSError as e:
        print(f"[{now_ts()}] Save OSError: {e} (try {i}/{SAVE_RETRIES})", flush=True)
        time.sleep(SAVE_RETRY_SLEEP)

base, _ext = os.path.splitext(path)
fallback = base + AUTOSAVE_SUFFIX
try:
    wb.save(fallback)
    print(f"[{now_ts()}] Saved to AUTOSAVE: {fallback}", flush=True)

    # предупреждение в TG только один раз, чтобы не спамить
    if (not _excel_lock_notified) and tg_ready():
        tg_send(
            "⚠️ Excel-файл открыт и заблокирован.\n"
            f"Не могу записать в: {os.path.abspath(path)}\n"
            f"Сохраняю во временный: {os.path.abspath(fallback)}\n"
            f"И делаю snapshots в папку: {os.path.abspath(SNAPSHOT_DIR)}"
        )
        _excel_lock_notified = True

    return False
except Exception as e:
    print(f"[{now_ts()}] AUTOSAVE failed: {e}", flush=True)
    if tg_ready():
        tg_send(f"❌ Не могу сохранить Excel ни в основной, ни в AUTOSAVE: {e}")
    return False

def maybe_write_snapshot(wb: Workbook, base_path: str) -> None:
"""
Пишем снимок в отдельный файл с уникальным именем.
Такой файл можно держать открытым в Excel — бот не будет блокироваться.
"""
global _last_snapshot_ts
now = time.time()
if now - _last_snapshot_ts < SNAPSHOT_EVERY_SECONDS:
return
_last_snapshot_ts = now

text
try:
    Path(SNAPSHOT_DIR).mkdir(parents=True, exist_ok=True)
    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    snap_path = os.path.join(SNAPSHOT_DIR, f"nowgoal_{stamp}.xlsx")
    wb.save(snap_path)
    print(f"[{now_ts()}] Snapshot saved: {snap_path}", flush=True)
except Exception as e:
    print(f"[{now_ts()}] Snapshot save failed: {e}", flush=True)

OU_TOTAL_RE = re.compile(r"\b[OU]\s*([0-9]+(?:.[0-9]+)?)", re.IGNORECASE)

def read_total_from_cell(cell) -> Optional[float]:
"""Тотал берём из span.odds1, а если он пропал/пустой — выковыриваем из innerText."""
odds1 = cell.find_elements(By.CSS_SELECTOR, "span.odds1")
if odds1:
v = safe_float(txt(odds1[0]))
if v is not None:
return v

text
it = (cell.get_attribute("innerText") or "").strip()
m = OU_TOTAL_RE.search(it)
if m:
    return safe_float(m.group(1))

return None

def split_team_and_tag(s: str) -> Team:
s = (s or "").strip()
if s.endswith("]") and "[" in s:
i = s.rfind("[")
name = s[:i].strip()
tag = s[i + 1:-1].strip() or None
if name:
return Team(name=name, tag=tag)
return Team(name=s, tag=None)

def parse_analysis_onclick(onclick: str) -> Optional[Tuple[int, str, str, str]]:
if not onclick or "basketInPage.analysis" not in onclick:
return None
try:
args_str = onclick[onclick.find("(") + 1: onclick.rfind(")")]
args = ast.literal_eval("(" + args_str + ")")
return int(args[0]), str(args[1]), str(args[2]), str(args[3])
except Exception:
return None

def scroll_load_all(driver, max_rounds: int = 25, pause: float = 0.35):
last = 0
stable = 0
for _ in range(max_rounds):
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
time.sleep(pause)
cur = len(driver.find_elements(By.CSS_SELECTOR, 'td[onclick*="basketInPage.analysis("]'))
if cur == last:
stable += 1
if stable >= 3:
break
else:
stable = 0
last = cur
driver.execute_script("window.scrollTo(0, 0);")
time.sleep(0.15)

def pick_band(abs_diff: float) -> Optional[str]:
for lo, hi, label in DIFF_BANDS:
if abs_diff >= lo and (hi is None or abs_diff < hi):
return label
return None

def line_complete(line: LineOU) -> bool:
return (line.total is not None and line.over_odds is not None and line.under_odds is not None)

===================== STATUS =====================

LIVE_PAT = re.compile(r"\b\d+(?:st|nd|rd|th)\s+Qtr\b|\bOT\b|\bOvertime\b|\bLive\b", re.IGNORECASE)
TIME_PAT = re.compile(r"^\s*\d{1,2}:\d{2}\s*(?:AM|PM)?\s*$", re.IGNORECASE)

def is_finished(status: Optional[str]) -> bool:
return (status or "").strip().lower() in {"finished", "final", "ft", "ended"}

def is_halftime(status: Optional[str]) -> bool:
return "halftime" in (status or "").strip().lower()

def is_live(status: Optional[str]) -> bool:
s = (status or "").strip()
if not s:
return False
if is_finished(s) or is_halftime(s):
return True
return bool(LIVE_PAT.search(s))

def is_pregame(status: Optional[str]) -> bool:
"""
pregame = всё что НЕ live/halftime/finished и НЕ отменено/перенесено.
Pend. считаем pregame (игра задерживается).
"""
s = (status or "").strip()
if not s:
return True
if TIME_PAT.match(s):
return True
sl = s.lower()
if is_live(s) or is_halftime(s) or is_finished(s):
return False
if any(k in sl for k in ["postp", "cancel", "abandon", "void"]):
return False
if "pend" in sl:
return True
return True

def status_bucket(status: Optional[str]) -> str:
if is_halftime(status):
return "halftime"
if is_finished(status):
return "finished"
if is_live(status):
return "live"
if is_pregame(status):
return "pregame"
return "other"

def pick_best_line(current: LineOU, st_rec: Dict[str, Any], status: Optional[str]) -> LineOU:
"""
Если текущая линия неполная — берём последнюю полную из истории (или ещё более раннюю).
Приоритет: тот же bucket статуса.
"""
if line_complete(current):
return current

text
bucket = status_bucket(status)
hist = st_rec.get("line_hist")
if not hist:
    return current

for item in reversed(hist):
    if item["bucket"] == bucket and line_complete(item["line"]):
        return item["line"]

for item in reversed(hist):
    if line_complete(item["line"]):
        return item["line"]

return current

===================== STATS =====================

def empty_stats() -> Dict[str, Any]:
return {"bets": 0, "wins": 0, "losses": 0, "pushes": 0, "profit": 0.0}

def ensure_stats(d: Dict[str, Dict[str, Any]], key: str) -> Dict[str, Any]:
if key not in d:
d[key] = empty_stats()
return d[key]

def ensure_nested_stats(d: Dict[str, Dict[str, Dict[str, Any]]], k1: str, k2: str) -> Dict[str, Any]:
if k1 not in d:
d[k1] = {}
if k2 not in d[k1]:
d[k1][k2] = empty_stats()
return d[k1][k2]

def bet_profit(decimal_odds: float, stake: float, result: str) -> float:
if result == "push":
return 0.0
if result == "loss":
return -stake
return (decimal_odds - 1.0) * stake

def stats_line(s: Dict[str, Any]) -> str:
return f"Bets={s['bets']} W={s['wins']} L={s['losses']} P={s['pushes']} Profit={s['profit']:+.2f}"

def stats_block_extended(
stats_total: Dict[str, Any],
stats_by_band: Dict[str, Dict[str, Any]],
stats_by_league: Dict[str, Dict[str, Any]],
stats_by_league_band: Dict[str, Dict[str, Dict[str, Any]]],
focus_league: Optional[str] = None,
focus_band: Optional[str] = None,
) -> str:
lines = []
lines.append(f"TOTAL: {stats_line(stats_total)}")
for _, _, label in DIFF_BANDS:
lines.append(f"{label}: {stats_line(stats_by_band[label])}")

text
if focus_league:
    ls = ensure_stats(stats_by_league, focus_league)
    lines.append("")
    lines.append(f"LEAGUE: {focus_league}")
    lines.append(stats_line(ls))
    if focus_band:
        lbs = ensure_nested_stats(stats_by_league_band, focus_league, focus_band)
        lines.append(f"LEAGUE×BAND ({focus_band}): {stats_line(lbs)}")

return "\n".join(lines)

===================== EXCEL STORAGE =====================

BETS_HEADERS = [
"bet_uid", "match_id",
"league", "home", "away",
"band", "side",
"pre_total", "half_total", "diff", "abs_diff",
"odds", "stake",
"placed_at", "status_at_bet",
"final_total", "result", "profit", "settled_at",
]

def excel_open_or_create(path: str):
if os.path.exists(path):
wb = load_workbook(path)
else:
wb = Workbook()

text
# Bets sheet
if "Bets" not in wb.sheetnames:
    ws = wb.active
    ws.title = "Bets"
    ws.append(BETS_HEADERS)
else:
    ws = wb["Bets"]
    if ws.max_row < 1:
        ws.append(BETS_HEADERS)
    else:
        header = [ws.cell(row=1, column=c).value for c in range(1, ws.max_column + 1)]
        if header[: len(BETS_HEADERS)] != BETS_HEADERS:
            for i, h in enumerate(BETS_HEADERS, start=1):
                ws.cell(row=1, column=i).value = h

# Ensure other sheets
for sname in ["Stats_Total", "Stats_Band", "Stats_League", "Stats_League_Band", "Monthly"]:
    if sname not in wb.sheetnames:
        wb.create_sheet(sname)

# mapping bet_uid -> row
ws_bets = wb["Bets"]
uid_to_row: Dict[str, int] = {}
for r in range(2, ws_bets.max_row + 1):
    uid = ws_bets.cell(row=r, column=1).value
    if uid:
        uid_to_row[str(uid)] = r

safe_save(wb, path)
return wb, uid_to_row

def excel_append_bet(wb: Workbook, uid_to_row: Dict[str, int], path: str, row: Dict[str, Any]) -> None:
ws = wb["Bets"]
values = [row.get(h) for h in BETS_HEADERS]
ws.append(values)
uid_to_row[str(row["bet_uid"])] = ws.max_row
safe_save(wb, path)

def excel_update_settle(
wb: Workbook,
uid_to_row: Dict[str, int],
path: str,
bet_uid: str,
final_total: int,
result: str,
profit: float,
settled_at: str,
) -> None:
ws = wb["Bets"]
r = uid_to_row.get(str(bet_uid))
if not r:
return
ws.cell(row=r, column=16).value = int(final_total)
ws.cell(row=r, column=17).value = str(result)
ws.cell(row=r, column=18).value = float(profit)
ws.cell(row=r, column=19).value = str(settled_at)
safe_save(wb, path)

def _clear_sheet_keep_header(ws, headers: Optional[list] = None):
ws.delete_rows(1, ws.max_row)
if headers:
ws.append(headers)

def excel_write_stats(
wb: Workbook,
path: str,
stats_total: Dict[str, Any],
stats_by_band: Dict[str, Dict[str, Any]],
stats_by_league: Dict[str, Dict[str, Any]],
stats_by_league_band: Dict[str, Dict[str, Dict[str, Any]]],
):
ws = wb["Stats_Total"]
_clear_sheet_keep_header(ws, ["metric", "value"])
for k in ["bets", "wins", "losses", "pushes", "profit"]:
ws.append([k, stats_total[k]])

text
ws = wb["Stats_Band"]
_clear_sheet_keep_header(ws, ["band", "bets", "wins", "losses", "pushes", "profit"])
for _, _, band in DIFF_BANDS:
    s = stats_by_band[band]
    ws.append([band, s["bets"], s["wins"], s["losses"], s["pushes"], float(s["profit"])])

ws = wb["Stats_League"]
_clear_sheet_keep_header(ws, ["league", "bets", "wins", "losses", "pushes", "profit"])
for league, s in sorted(stats_by_league.items(), key=lambda kv: (-kv[1]["bets"], kv[0])):
    ws.append([league, s["bets"], s["wins"], s["losses"], s["pushes"], float(s["profit"])])

ws = wb["Stats_League_Band"]
_clear_sheet_keep_header(ws, ["league", "band", "bets", "wins", "losses", "pushes", "profit"])
rows = []
for league, bands in stats_by_league_band.items():
    for band, s in bands.items():
        rows.append((league, band, s))
for league, band, s in sorted(rows, key=lambda x: (-x[2]["bets"], x[0], x[1])):
    ws.append([league, band, s["bets"], s["wins"], s["losses"], s["pushes"], float(s["profit"])])

safe_save(wb, path)

def excel_write_monthly(wb: Workbook, path: str) -> None:
ws_bets = wb["Bets"]
ws_m = wb["Monthly"]

text
ws_m.delete_rows(1, ws_m.max_row)
ws_m.append(["month", "bets_settled", "profit", "cum_profit"])

header = [ws_bets.cell(row=1, column=c).value for c in range(1, ws_bets.max_column + 1)]

def col_idx(name: str) -> int:
    return header.index(name) + 1

try:
    c_profit = col_idx("profit")
    c_settled_at = col_idx("settled_at")
except ValueError:
    safe_save(wb, path)
    return

monthly_profit: Dict[str, float] = {}
monthly_bets: Dict[str, int] = {}

for r in range(2, ws_bets.max_row + 1):
    settled_at = ws_bets.cell(row=r, column=c_settled_at).value
    prof = ws_bets.cell(row=r, column=c_profit).value
    if not settled_at or prof is None:
        continue

    month = str(settled_at)[:7]
    monthly_profit[month] = monthly_profit.get(month, 0.0) + float(prof)
    monthly_bets[month] = monthly_bets.get(month, 0) + 1

cum = 0.0
for month in sorted(monthly_profit.keys()):
    p = float(monthly_profit[month])
    b = int(monthly_bets.get(month, 0))
    cum += p
    ws_m.append([month, b, p, cum])

ws_m._charts = []

if ws_m.max_row >= 2:
    chart = LineChart()
    chart.title = "Monthly Profit Trend"
    chart.y_axis.title = "Profit"
    chart.x_axis.title = "Month"

    data = Reference(ws_m, min_col=3, max_col=4, min_row=1, max_row=ws_m.max_row)
    cats = Reference(ws_m, min_col=1, min_row=2, max_row=ws_m.max_row)
    chart.add_data(data, titles_from_data=True)
    chart.set_categories(cats)

    ws_m.add_chart(chart, "F2")

safe_save(wb, path)

===================== DRIVER =====================

def make_driver(headless: bool = True):
options = webdriver.ChromeOptions()
if headless:
options.add_argument("--headless=new")
options.add_argument("--window-size=1400,900")
options.add_argument("--disable-gpu")
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")
options.add_argument("--disable-blink-features=AutomationControlled")
options.add_argument(
"user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
"(KHTML, like Gecko) Chrome/126.0 Safari/537.36"
)
return webdriver.Chrome(options=options)

===================== SNAPSHOT PARSER =====================

def _parse_ou_for_mid(driver, mid: int) -> LineOU:
over_total = under_total = None
over_odds = under_odds = None

text
cells = []
ht = driver.find_elements(By.ID, f"ht_{mid}")
gt = driver.find_elements(By.ID, f"gt_{mid}")
if ht:
    cells.append(ht[0])
if gt:
    cells.append(gt[0])

if not cells:
    cells = driver.find_elements(By.CSS_SELECTOR, f'td.ouOdds[onclick*="oddscomp({mid}"]')

for cell in cells:
    raw = (cell.get_attribute("innerText") or txt(cell)).strip().upper()
    odds2 = cell.find_elements(By.CSS_SELECTOR, "span.odds2")

    total_val = read_total_from_cell(cell)
    odds_val = read_odds_decimal(odds2[0]) if odds2 else None

    if raw.startswith("O"):
        over_total = total_val
        over_odds = odds_val
    elif raw.startswith("U"):
        under_total = total_val
        under_odds = odds_val

line = LineOU(over_odds=over_odds, under_odds=under_odds)

if over_total is not None and under_total is not None:
    if abs(over_total - under_total) < 1e-9:
        line.total = over_total
    else:
        line.total = (over_total + under_total) / 2.0
else:
    line.total = over_total if over_total is not None else under_total

return line

def _get_snapshot_once(driver, do_scroll: bool) -> Dict[int, Dict[str, Any]]:
wait = WebDriverWait(driver, 30)
wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, 'td[onclick*="basketInPage.analysis("]')))
if do_scroll:
scroll_load_all(driver)

text
games: Dict[int, Dict[str, Any]] = {}
analysis_tds = driver.find_elements(By.CSS_SELECTOR, 'td[onclick*="basketInPage.analysis("]')

for td in analysis_tds:
    parsed = parse_analysis_onclick(td.get_attribute("onclick") or "")
    if not parsed:
        continue
    mid, home_s, away_s, league_s = parsed
    games[mid] = {
        "match_id": mid,
        "league": league_s,
        "home": split_team_and_tag(home_s),
        "away": split_team_and_tag(away_s),
        "status": None,
        "line": LineOU(),
        "home_score": None,
        "away_score": None,
    }

for mid in list(games.keys()):
    status_els = driver.find_elements(By.ID, f"zt_{mid}")
    if status_els:
        games[mid]["status"] = txt(status_els[0]) or None

    games[mid]["line"] = _parse_ou_for_mid(driver, mid)

    h_els = driver.find_elements(By.ID, f"hzf_{mid}")
    g_els = driver.find_elements(By.ID, f"gzf_{mid}")
    if h_els and g_els:
        hs = safe_float(txt(h_els[0]))
        gs = safe_float(txt(g_els[0]))
        games[mid]["home_score"] = int(hs) if hs is not None else None
        games[mid]["away_score"] = int(gs) if gs is not None else None

return games

def get_snapshot(driver, do_scroll: bool, retries: int = 3) -> Dict[int, Dict[str, Any]]:
for attempt in range(1, retries + 1):
try:
return _get_snapshot_once(driver, do_scroll=do_scroll)
except StaleElementReferenceException:
print(f"[{now_ts()}] snapshot stale -> retry {attempt}/{retries}", flush=True)
time.sleep(0.25)
return _get_snapshot_once(driver, do_scroll=do_scroll)

===================== MAIN LOOP =====================

def main():
print(f"[{now_ts()}] Starting monitor. poll={POLL_SECONDS}s stake={STAKE}", flush=True)
print(f"[{now_ts()}] Bands: " + ", ".join([lbl for _, _, lbl in DIFF_BANDS]), flush=True)
print(f"[{now_ts()}] Excel: {os.path.abspath(EXCEL_PATH)}", flush=True)
print(f"[{now_ts()}] Snapshots dir: {os.path.abspath(SNAPSHOT_DIR)} every {SNAPSHOT_EVERY_SECONDS}s", flush=True)
print(f"[{now_ts()}] Halftime wait: {HALFTIME_WAIT_SECONDS}s (first halftime only)", flush=True)

text
wb, uid_to_row = excel_open_or_create(EXCEL_PATH)

tg_send(
    "🟢 NowGoal monitor STARTED\n"
    f"poll={POLL_SECONDS}s | stake={STAKE}\n"
    f"bands: " + ", ".join([lbl for _, _, lbl in DIFF_BANDS]) + "\n"
    f"halftime_wait={HALFTIME_WAIT_SECONDS}s (first halftime only)\n"
    f"time={now_dt()}\n"
    f"excel(main)={os.path.abspath(EXCEL_PATH)}\n"
    f"snapshots={os.path.abspath(SNAPSHOT_DIR)}"
)

driver = make_driver(headless=HEADLESS)
state: Dict[int, Dict[str, Any]] = {}

# stats (начинаются с нуля — как ты и сказал)
stats_total = empty_stats()
stats_by_band = {label: empty_stats() for _, _, label in DIFF_BANDS}
stats_by_league: Dict[str, Dict[str, Any]] = {}
stats_by_league_band: Dict[str, Dict[str, Dict[str, Any]]] = {}

loop_n = 0
try:
    driver.get(URL)
    WebDriverWait(driver, 30).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, 'td[onclick*="basketInPage.analysis("]'))
    )

    while True:
        loop_n += 1
        t0 = time.time()

        do_scroll = (loop_n == 1) or (loop_n % SCROLL_EVERY_N_LOOPS == 0)

        try:
            driver.refresh()
            time.sleep(0.35)
        except Exception as e:
            print(f"[{now_ts()}] refresh error: {e} -> reopen", flush=True)
            driver.get(URL)

        try:
            snap = get_snapshot(driver, do_scroll=do_scroll, retries=3)
        except Exception as e:
            print(f"[{now_ts()}] snapshot error: {e}", flush=True)
            time.sleep(POLL_SECONDS)
            continue

        # summary counts
        cnt_total = len(snap)
        cnt_live = cnt_half = cnt_finished = 0
        for g in snap.values():
            st = g.get("status")
            if is_finished(st):
                cnt_finished += 1
            elif is_halftime(st):
                cnt_half += 1
            elif is_live(st):
                cnt_live += 1

        print(
            f"[{now_ts()}] loop={loop_n} games={cnt_total} live={cnt_live} halftime={cnt_half} finished={cnt_finished} "
            f"| TOTAL profit={stats_total['profit']:+.2f} bets={stats_total['bets']}",
            flush=True
        )

        for mid, g in snap.items():
            st_rec = state.setdefault(mid, {
                "league": g["league"],
                "home": g["home"],
                "away": g["away"],

                "pregame_total_last": None,
                "pregame_total_frozen": None,

                "bet": None,
                "bet_uid": None,
                "settled": False,

                "last_status": None,
                "line_hist": deque(maxlen=10),

                # ✅ NEW: halftime tracking
                "halftime_count": 0,           # сколько раз вошли в halftime (переходом)
                "halftime_first_ts": None,     # time.time() первого появления halftime
            })

            status = g.get("status")
            line_raw: LineOU = g.get("line", LineOU())
            line = pick_best_line(line_raw, st_rec, status)

            if line_complete(line):
                st_rec["line_hist"].append({
                    "ts": now_dt(),
                    "bucket": status_bucket(status),
                    "line": LineOU(line.total, line.over_odds, line.under_odds),
                })

            # keep previous status for transitions
            prev_status = st_rec["last_status"]

            if status != prev_status:
                st_rec["last_status"] = status
                if status:
                    parts = []
                    if line.total is not None:
                        parts.append(f"OU={line.total:g}")
                    if line.over_odds is not None:
                        parts.append(f"O@{line.over_odds:.2f}")
                    if line.under_odds is not None:
                        parts.append(f"U@{line.under_odds:.2f}")
                    line_str = " | " + (" ".join(parts) if parts else "OU=-")
                    print(
                        f"  [{now_ts()}] status id={mid} | {st_rec['home'].name} vs {st_rec['away'].name} | {status}{line_str}",
                        flush=True
                    )

            # ✅ NEW: detect FIRST entry into halftime (transition into halftime)
            if is_halftime(status) and not is_halftime(prev_status):
                st_rec["halftime_count"] += 1
                if st_rec["halftime_count"] == 1:
                    st_rec["halftime_first_ts"] = time.time()
                    print(
                        f"  [{now_ts()}] FIRST HALFTIME detected id={mid} -> waiting {HALFTIME_WAIT_SECONDS}s for odds to stabilize",
                        flush=True
                    )
                else:
                    # second+ halftime (often OT) -> ignore for betting logic
                    print(
                        f"  [{now_ts()}] HALFTIME повторно (#{st_rec['halftime_count']}) id={mid} -> IGNORE (OT/extra break)",
                        flush=True
                    )

            # 1) pregame -> сохраняем последний pregame total
            if is_pregame(status):
                if line.total is not None:
                    st_rec["pregame_total_last"] = float(line.total)

            # 2) first live -> freeze pregame total
            if is_live(status) and st_rec["pregame_total_frozen"] is None and st_rec["pregame_total_last"] is not None:
                st_rec["pregame_total_frozen"] = float(st_rec["pregame_total_last"])
                print(f"  [{now_ts()}] pregame frozen id={mid} pre_total={st_rec['pregame_total_frozen']:g}", flush=True)

            # 3) halftime -> bet (✅ only on FIRST halftime + ✅ wait 15s)
            if (
                is_halftime(status)
                and st_rec["bet"] is None
                and st_rec["pregame_total_frozen"] is not None
                and st_rec["halftime_count"] == 1   # ✅ only first halftime
            ):
                # ✅ wait after first halftime appears
                ht_ts = st_rec.get("halftime_first_ts")
                if ht_ts is None:
                    st_rec["halftime_first_ts"] = time.time()
                    ht_ts = st_rec["halftime_first_ts"]

                if (time.time() - float(ht_ts)) < HALFTIME_WAIT_SECONDS:
                    continue

                pre_total = float(st_rec["pregame_total_frozen"])
                half_total = line.total
                if half_total is None:
                    continue

                diff = float(half_total) - pre_total
                abs_diff = abs(diff)

                band = pick_band(abs_diff)
                if band is None:
                    continue

                if diff > 0:
                    side = "UNDER"
                    odds = line.under_odds
                else:
                    side = "OVER"
                    odds = line.over_odds

                if odds is None:
                    continue

                bet_uid = f"{mid}-{int(time.time()*1000)}"
                st_rec["bet_uid"] = bet_uid

                st_rec["bet"] = {
                    "band": band,
                    "side": side,
                    "line": float(half_total),
                    "odds": float(odds),
                    "stake": float(STAKE),
                    "pre_total": float(pre_total),
                    "half_total": float(half_total),
                    "diff": float(diff),
                    "abs_diff": float(abs_diff),
                    "placed_at": now_dt(),
                    "status_at_bet": status,
                }

                league = st_rec["league"]
                stats_total["bets"] += 1
                stats_by_band[band]["bets"] += 1
                ensure_stats(stats_by_league, league)["bets"] += 1
                ensure_nested_stats(stats_by_league_band, league, band)["bets"] += 1

                excel_append_bet(
                    wb, uid_to_row, EXCEL_PATH,
                    {
                        "bet_uid": bet_uid,
                        "match_id": mid,
                        "league": league,
                        "home": st_rec["home"].name,
                        "away": st_rec["away"].name,
                        "band": band,
                        "side": side,
                        "pre_total": float(pre_total),
                        "half_total": float(half_total),
                        "diff": float(diff),
                        "abs_diff": float(abs_diff),
                        "odds": float(odds),
                        "stake": float(STAKE),
                        "placed_at": st_rec["bet"]["placed_at"],
                        "status_at_bet": status,
                        "final_total": None,
                        "result": None,
                        "profit": None,
                        "settled_at": None,
                    }
                )
                excel_write_stats(wb, EXCEL_PATH, stats_total, stats_by_band, stats_by_league, stats_by_league_band)
                excel_write_monthly(wb, EXCEL_PATH)

                print(
                    f"  [{now_ts()}] BET PLACED [{band}] id={mid} {side} {half_total:g} @ {odds:.2f} "
                    f"(pre {pre_total:g}, diff {diff:+g})",
                    flush=True
                )

                block = stats_block_extended(
                    stats_total, stats_by_band, stats_by_league, stats_by_league_band,
                    focus_league=league, focus_band=band
                )

                tg_send(
                    f"✅ BET PLACED (TOTAL #{stats_total['bets']}) [{band}]\n"
                    f"{league}\n"
                    f"{st_rec['home'].name} vs {st_rec['away'].name}\n"
                    f"Status: {status}\n"
                    f"(waited {HALFTIME_WAIT_SECONDS}s after first halftime)\n"
                    f"Pre total: {pre_total:g}\n"
                    f"Halftime line: {half_total:g} (diff {diff:+g})\n"
                    f"BET: {side} {half_total:g} @ {float(odds):.2f}\n"
                    f"Stake: {STAKE}\n"
                    f"\n📊 STATS\n{block}\n"
                    f"id={mid}\n"
                    f"bet_uid={bet_uid}"
                )

            # 4) finished -> settle bet
            if is_finished(status) and st_rec["bet"] is not None and not st_rec["settled"]:
                hs = g.get("home_score")
                gs = g.get("away_score")
                if hs is None or gs is None:
                    continue

                final_total = int(hs) + int(gs)

                band = st_rec["bet"]["band"]
                league = st_rec["league"]
                side = st_rec["bet"]["side"]
                line_bet = float(st_rec["bet"]["line"])
                odds = float(st_rec["bet"]["odds"])
                stake = float(st_rec["bet"]["stake"])

                if abs(final_total - line_bet) < 1e-9:
                    result = "push"
                    stats_total["pushes"] += 1
                    stats_by_band[band]["pushes"] += 1
                    ensure_stats(stats_by_league, league)["pushes"] += 1
                    ensure_nested_stats(stats_by_league_band, league, band)["pushes"] += 1
                else:
                    win = (final_total < line_bet) if side == "UNDER" else (final_total > line_bet)
                    if win:
                        result = "win"
                        stats_total["wins"] += 1
                        stats_by_band[band]["wins"] += 1
                        ensure_stats(stats_by_league, league)["wins"] += 1
                        ensure_nested_stats(stats_by_league_band, league, band)["wins"] += 1
                    else:
                        result = "loss"
                        stats_total["losses"] += 1
                        stats_by_band[band]["losses"] += 1
                        ensure_stats(stats_by_league, league)["losses"] += 1
                        ensure_nested_stats(stats_by_league_band, league, band)["losses"] += 1

                prof = bet_profit(odds, stake, result)
                stats_total["profit"] += prof
                stats_by_band[band]["profit"] += prof
                ensure_stats(stats_by_league, league)["profit"] += prof
                ensure_nested_stats(stats_by_league_band, league, band)["profit"] += prof

                st_rec["settled"] = True

                bet_uid = st_rec.get("bet_uid")
                if bet_uid:
                    excel_update_settle(
                        wb, uid_to_row, EXCEL_PATH,
                        bet_uid, final_total, result.upper(), float(prof), now_dt()
                    )
                excel_write_stats(wb, EXCEL_PATH, stats_total, stats_by_band, stats_by_league, stats_by_league_band)
                excel_write_monthly(wb, EXCEL_PATH)

                block = stats_block_extended(
                    stats_total, stats_by_band, stats_by_league, stats_by_league_band,
                    focus_league=league, focus_band=band
                )

                print(
                    f"  [{now_ts()}] BET SETTLED [{band}] id={mid} {result.upper()} final_total={final_total} "
                    f"bet={side} {line_bet:g} @ {odds:.2f} P/L={prof:+.2f}\n{block}",
                    flush=True
                )

                tg_send(
                    f"🏁 BET RESULT: {result.upper()} [{band}]\n"
                    f"{league}\n"
                    f"{st_rec['home'].name} {hs} : {gs} {st_rec['away'].name}\n"
                    f"Final total: {final_total}\n"
                    f"Bet: {side} {line_bet:g} @ {odds:.2f} | stake {stake}\n"
                    f"P/L: {prof:+.2f}\n\n"
                    f"📊 STATS\n{block}\n"
                    f"id={mid}\n"
                    f"bet_uid={bet_uid}"
                )

        # делаем snapshot раз в SNAPSHOT_EVERY_SECONDS (можно смотреть в Excel без блокировок)
        maybe_write_snapshot(wb, EXCEL_PATH)

        elapsed = time.time() - t0
        time.sleep(max(0.2, POLL_SECONDS - elapsed))

finally:
    driver.quit()
    print(f"[{now_ts()}] Driver closed.", flush=True)

if name == "main":
main() по работе этого кода у меня такой вот результат, excel файл, нудно изучить этот файл, найти проблемные зоны в ставках где я минусую, найти хорошие зоны где есть профит, и переделать код, так чтобы он делал ставки только по плюсовой стратегии

Answer 1

Я открыл твой Excel /mnt/data/nowgoal_20260114_082711.xlsx (лист Bets, 251 ставка — все рассчитаны/settled) и посчитал, где именно ты «льёшь», а где есть плюс.

Download the analysis report

1) Что по результату в целом

251 ставок
Profit: −16.12
ROI: −6.42%
Win/Loss: 128 / 123 (push = 0)

2) Проблемные зоны (где основной минус)

По твоим текущим “зонам” (band × side)

Band	Side	Bets	Profit	ROI
20-30	OVER	91	−15.67	−17.22%
30-40	UNDER	26	−4.10	−15.77%
40-50	UNDER	6	−0.45	−7.50%
40-50	OVER	2	−0.17	−8.50%

Ключевое: OVER почти полностью убивает итог (−13.50 по всем OVER), UNDER около нуля (−2.62).

Самая “ядовитая” подзона внутри 20–30 (по abs_diff)

Если разбить abs_diff 20–30 на поддиапазоны по 2 пункта:

24–26: 36 ставок, −12.22 (очень плохо)
22–24: 51 ставка, −5.11
20–22: 69 ставок, +2.67
28–30: 20 ставок, +2.12 (26–28 около нуля суммарно, но там OVER тянет вниз)

👉 То есть у тебя не просто “band 20-30”, а внутри него есть дыра 22–26, которая даёт основной минус.

3) Хорошие зоны (где реально есть плюс)

Самое “стабильное” по объёму

20-30 + UNDER: 110 ставок, +1.93 (ROI +1.75%) — небольшой, но плюс.

Самая плюсовая (по этому файлу) — с фильтром по abs_diff

Если делать только UNDER и убрать abs_diff 22–26, оставив:

abs_diff ∈ [20,22) ИЛИ [26,30)

то на твоей истории получается:

61 ставка, +10.66 (ROI +17.5%)

⚠️ Это бэктест по тем же данным → есть риск переобучения, но по цифрам видно, что дырка 22–26 статистически токсичная, и её логично вырезать уже сейчас.

4) Правка кода: ставить только по плюсовой стратегии

Ниже минимальная и безопасная переделка: добавляем правила стратегии и проверку перед размещением ставки.

A) Добавь в CONFIG (вверху файла)

python
# ===================== STRATEGY FILTER =====================
USE_STRATEGY_FILTER = True

# Плюсовая стратегия по твоему Excel:
# ставим ТОЛЬКО UNDER в band 20-30 и только если abs_diff в [20,22) или [26,30)
STRATEGY_RULES = [
    {"band": "20-30", "side": "UNDER", "abs_min": 20.0, "abs_max": 22.0},
    {"band": "20-30", "side": "UNDER", "abs_min": 26.0, "abs_max": 30.0},
]

B) Добавь функцию-проверку (где-нибудь в HELPERS, после pick_band например)

python
def strategy_allows(league: str, band: str, side: str, abs_diff: float) -> bool:
    """
    True = ставку можно делать, False = пропускаем.
    abs_max считается как верхняя граница EXCLUSIVE (abs_diff < abs_max).
    """
    if not USE_STRATEGY_FILTER:
        return True

    for r in STRATEGY_RULES:
        if r.get("band") and band != r["band"]:
            continue
        if r.get("side") and side != r["side"]:
            continue

        # опционально, если захочешь правила под конкретные лиги:
        # if r.get("league_re") and not re.search(r["league_re"], league or "", re.I):
        #     continue

        abs_min = r.get("abs_min")
        abs_max = r.get("abs_max")
        if abs_min is not None and abs_diff < float(abs_min):
            continue
        if abs_max is not None and abs_diff >= float(abs_max):
            continue

        return True

    return False

C) Вставь фильтр прямо перед созданием bet (в блоке `# 3) halftime -> bet`)

Найди место после вычисления band, side, odds — и добавь:

python
league = st_rec["league"]

# ✅ Strategy filter: ставим только если правило разрешает
if not strategy_allows(league, band, side, abs_diff):
    # можно залогировать, но без TG (чтобы не спамить)
    print(
        f"  [{now_ts()}] SKIP (strategy) id={mid} {league} [{band}] {side} abs_diff={abs_diff:g}",
        flush=True
    )
    continue

После этого бот перестанет ставить:

все OVER
весь 30-40 UNDER
и самое важное: UNDER в abs_diff 22–26, который у тебя даёт основной провал

Важное (без морали, чисто практика)

Ты засветил TELEGRAM_TOKEN в коде (он прямо в тексте). Лучше сразу перевыпустить токен у BotFather и оставить только env-переменные (без дефолта в коде), иначе его могут утащить.

Если хочешь, я могу сделать ещё более “устойчиво”:

авто-обучение whitelist правил из Excel при старте (с минимумом ставок на правило, чтобы не ловить шум),
и/или “rolling window” только по последним N ставкам, чтобы стратегия адаптировалась.

Answer 2

Потому что в твоём файле почти все лиги имеют слишком маленькую выборку (1–3 ставки), и “по лигам” получается много шума: одна-две случайные победы/поражения резко переворачивают ROI. Поэтому я сначала резал по band/side/abs_diff — там выборка намного плотнее, и видно реальную “дыру” (22–26).

Но по лигам я всё равно разделил — вот что выходит на твоём Excel.

1) Разбивка по лигам (только где есть нормальный объём)

В этом файле только 2 лиги имеют ≥10 ставок:

National Committee Association America (NCAA Men) — 33 ставки, Profit −3.07, ROI −9.3%
National Committee Association America W (NCAA Women) — 11 ставок, Profit −3.74, ROI −34.0% ← это реально плохой сигнал

Если взять порог ≥5 ставок, добавляются ещё несколько лиг, но там всё равно выборки маленькие (5–9 ставок): NBA (9), China NBL (5), Italy Serie B (5), Argentina La Liga (5), Angola (5, плюс).

Что важно по смыслу

Даже в NCAA Men общий минус почти целиком создаётся твоей “плохой зоной” 20–30 + OVER:

NCAA Men, 20–30 OVER: 14 ставок, Profit −4.73
NCAA Men, 20–30 UNDER: 15 ставок, Profit +3.76

То есть лигой “лечить” тут не надо — лечится стороной (не брать OVER) и фильтром по abs_diff.

А вот NCAA Women действительно выглядит кандидатом на исключение: ROI −34% на 11 ставках — это уже не “случайность на 2 играх”.

2) Лиги внутри “плюсовой стратегии”, которую мы вырезали из твоих данных

Напомню стратегию, которую я предложил по твоему файлу:

Только UNDER, band 20–30, и abs_diff ∈ [20,22) или [26,30)
(убираем токсичную яму 22–26)

По этой стратегии у тебя: 61 ставка, +10.66, ROI +17.5%.

По лигам там картина такая:

NCAA Men: 10 ставок, +5.00, ROI +50% (лучший “доказательный” кусок, потому что объём есть)
Остальные лиги в этой стратегии в основном по 2–3 ставки — там я бы не делал выводов (например, Finland Division 1A −2.00 на 2 ставках — слишком мало, чтобы банить лигу навсегда).

Вывод: если добавлять лиговый фильтр прямо сейчас — то только один очевидный кандидат: NCAA Women.

3) Стоит ли убирать лиги?

Я бы сделал так (прагматично, без переобучения):

Оставить фильтр по стратегии (UNDER + abs_diff зоны) — это главный источник улучшения.
Добавить blacklist только для NCAA Women (потому что там 11 ставок и сильный минус).
Остальные лиги не банить, пока не накопится хотя бы 8–12 ставок на лигу именно внутри твоей стратегии.

4) Как добавить фильтр по лигам в код (минимальная правка)

A) В CONFIG добавь:

python
# ===== LEAGUE FILTER =====
LEAGUE_BLACKLIST_RE = [
    r"\bNational Committee Association America W\b",  # NCAA Women (по твоему Excel)
]

# если захочешь наоборот "белый список", можно включить:
LEAGUE_WHITELIST_RE = []   # например: [r"NCAA", r"Japan", ...]

B) Добавь helper:

python
def league_allowed(league: str) -> bool:
    lg = league or ""

    # whitelist (если задан) — разрешаем только то, что матчится
    if LEAGUE_WHITELIST_RE:
        ok = any(re.search(p, lg, re.I) for p in LEAGUE_WHITELIST_RE)
        if not ok:
            return False

    # blacklist — запрещаем
    if any(re.search(p, lg, re.I) for p in LEAGUE_BLACKLIST_RE):
        return False

    return True

C) И прямо перед размещением ставки (там где ты уже вычислил `league`, `band`, `side`, `abs_diff`) вставь:

python
if not league_allowed(league):
    print(f"  [{now_ts()}] SKIP (league blacklist) id={mid} league={league}", flush=True)
    continue

Если хочешь, я могу сделать вариант “умнее”: при старте читать твой Bets-лист и автоматически собирать blacklist для лиг, где (например) >=12 ставок и ROI < −5% в рамках выбранной стратегии. Это будет гораздо устойчивее, чем вручную банить лиги на 2–3 играх.

Answer 3

Причин, почему не пришло стартовое сообщение в Telegram у твоего скрипта, обычно 3:

Неверный token/chat_id (или токен уже “сгорел”).
Бот не имеет права писать в чат: в личке нужно открыть бота и нажать Start (/start); в группе — добавить бота и дать права.
Запрос к Telegram падает (интернет/файрвол/timeout) — в твоей версии это могло пройти “тихо”, потому что ты смотришь только r.ok и печатаешь урезанный текст.

Ниже — полный переделанный код под плюсовую стратегию из твоего Excel + улучшенная отправка в Telegram (ретраи + подробный лог + ранний “startup ping”) + новый Excel-файл (по умолчанию отдельный, чтобы не смешивать со старым).

Что делает “плюсовая стратегия” в этом коде

Ставит только:

UNDER
band = 20–30
abs_diff ∈ [20,22) или [26,30)
И дополнительно (по желанию) банит NCAA Women (как кандидат на исключение из твоих данных).

Полный код (готовый файл)

ВАЖНО: я не вставляю токен в код (он секретный). Задай переменные окружения TELEGRAM_TOKEN и TELEGRAM_CHAT_ID.
Пример (Windows PowerShell):
setx TELEGRAM_TOKEN "123:ABC"
setx TELEGRAM_CHAT_ID "6667940236"

python
import re
import ast
import os
import time
from dataclasses import dataclass
from typing import Optional, Dict, Any, Tuple
from datetime import datetime
from collections import deque
from pathlib import Path

import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import StaleElementReferenceException

from openpyxl import Workbook, load_workbook
from openpyxl.chart import LineChart, Reference


# ===================== CONFIG =====================
URL = "https://www.nowgoal.com/basketball"

POLL_SECONDS = 5
STAKE = 1.0
HEADLESS = True

# Wait after FIRST halftime appears (to stabilize odds/lines)
HALFTIME_WAIT_SECONDS = 15

DIFF_BANDS = [
    (20.0, 30.0, "20-30"),
    (30.0, 40.0, "30-40"),
    (40.0, 50.0, "40-50"),
    (50.0, None, "50+"),
]

SCROLL_EVERY_N_LOOPS = 12

# ✅ NEW: separate output file by default (so you don't mix with old runs)
RUN_TAG = os.getenv("RUN_TAG", datetime.now().strftime("%Y%m%d"))
EXCEL_PATH = os.getenv("EXCEL_PATH", f"nowgoal_monitor_PLUS_{RUN_TAG}.xlsx")

# ✅ Telegram from env only (safer)
TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "").strip()
TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "").strip()

TG_TIMEOUT = 15
TG_RETRIES = 3
TG_RETRY_SLEEP = 2.0
TG_DEBUG = True  # show detailed Telegram errors in console

# ====== WINDOWS-EXCEL SAFE SAVE + SNAPSHOTS ======
SNAPSHOT_DIR = "snapshots"
SNAPSHOT_EVERY_SECONDS = 60
AUTOSAVE_SUFFIX = "_AUTOSAVE.xlsx"
SAVE_RETRIES = 3
SAVE_RETRY_SLEEP = 1.0

_last_snapshot_ts = 0.0
_excel_lock_notified = False

# ===================== STRATEGY (PLUS) =====================
# Based on your historical excel:
# - only UNDER
# - only band 20-30
# - abs_diff in [20,22) or [26,30)
USE_STRATEGY_FILTER = True
STRATEGY_RULES = [
    {"band": "20-30", "side": "UNDER", "abs_min": 20.0, "abs_max": 22.0},
    {"band": "20-30", "side": "UNDER", "abs_min": 26.0, "abs_max": 30.0},
]

# Optional: league blacklist (from your sample: NCAA Women looked bad)
LEAGUE_BLACKLIST_RE = [
    r"\bNational Committee Association America W\b",  # NCAA Women
]
LEAGUE_WHITELIST_RE = []  # keep empty unless you want strict allow-only


# ===================== TELEGRAM =====================
def tg_ready() -> bool:
    return bool(TELEGRAM_TOKEN) and bool(TELEGRAM_CHAT_ID)


def tg_send(text: str) -> bool:
    """
    Telegram send with retries + detailed logging.
    Returns True if sent.
    """
    print(f"[TG] -> {text.replace('\n', ' | ')}", flush=True)

    if not tg_ready():
        print("[TG] SKIP: TELEGRAM_TOKEN / TELEGRAM_CHAT_ID not set.", flush=True)
        return False

    url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
    payload = {
        "chat_id": TELEGRAM_CHAT_ID,
        "text": text,
        "disable_web_page_preview": True,
    }

    last_err = None
    for attempt in range(1, TG_RETRIES + 1):
        try:
            r = requests.post(url, data=payload, timeout=TG_TIMEOUT)
            if r.ok:
                return True

            # Telegram returned error
            last_err = f"HTTP {r.status_code}: {r.text}"
            if TG_DEBUG:
                print(f"[TG] ERROR attempt {attempt}/{TG_RETRIES}: {last_err}", flush=True)
        except Exception as e:
            last_err = repr(e)
            if TG_DEBUG:
                print(f"[TG] EXCEPTION attempt {attempt}/{TG_RETRIES}: {last_err}", flush=True)

        time.sleep(TG_RETRY_SLEEP)

    print(f"[TG] FAILED after {TG_RETRIES} tries: {last_err}", flush=True)
    return False


def tg_startup_ping() -> None:
    """
    Send a minimal startup ping immediately, before webdriver/excel heavy ops.
    Helps detect token/chat_id issues early.
    """
    tg_send(f"🟢 START ping | time={now_dt()} | excel={os.path.abspath(EXCEL_PATH)}")


# ===================== MODELS =====================
@dataclass
class Team:
    name: str
    tag: Optional[str] = None


@dataclass
class LineOU:
    total: Optional[float] = None
    over_odds: Optional[float] = None   # decimal
    under_odds: Optional[float] = None  # decimal


# ===================== HELPERS =====================
def now_ts() -> str:
    return datetime.now().strftime("%H:%M:%S")


def now_dt() -> str:
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


def txt(el) -> str:
    if el is None:
        return ""
    return (el.get_attribute("textContent") or "").strip()


def safe_float(x: Optional[str]) -> Optional[float]:
    if not x:
        return None
    x = x.strip().replace(",", ".")
    try:
        return float(x)
    except ValueError:
        return None


def hk_to_decimal(odds: Optional[float]) -> Optional[float]:
    # HK 0.83 -> Decimal 1.83
    if odds is None:
        return None
    if odds >= 1.2:
        return odds
    return odds + 1.0


def read_odds_decimal(span) -> Optional[float]:
    """odds2 может быть текст 1.80, а может быть пусто, но есть data-o=0.80 (HK)."""
    if span is None:
        return None

    t = (span.get_attribute("textContent") or "").strip()
    v = safe_float(t)
    if v is not None:
        return hk_to_decimal(v)

    v2 = safe_float(span.get_attribute("data-o"))
    if v2 is not None:
        return hk_to_decimal(v2)

    return None


# -------- Excel safe save + snapshots (Windows) --------
def safe_save(wb: Workbook, path: str) -> bool:
    """
    Try to save to main file.
    If locked by Excel (Windows) -> save to AUTOSAVE and notify once in TG.
    """
    global _excel_lock_notified

    for i in range(1, SAVE_RETRIES + 1):
        try:
            wb.save(path)
            _excel_lock_notified = False
            return True
        except PermissionError:
            print(f"[{now_ts()}] Excel LOCKED: {path} (try {i}/{SAVE_RETRIES})", flush=True)
            time.sleep(SAVE_RETRY_SLEEP)
        except OSError as e:
            print(f"[{now_ts()}] Save OSError: {e} (try {i}/{SAVE_RETRIES})", flush=True)
            time.sleep(SAVE_RETRY_SLEEP)

    base, _ext = os.path.splitext(path)
    fallback = base + AUTOSAVE_SUFFIX
    try:
        wb.save(fallback)
        print(f"[{now_ts()}] Saved to AUTOSAVE: {fallback}", flush=True)

        if (not _excel_lock_notified) and tg_ready():
            tg_send(
                "⚠️ Excel-файл открыт и заблокирован.\n"
                f"Не могу записать в: {os.path.abspath(path)}\n"
                f"Сохраняю во временный: {os.path.abspath(fallback)}\n"
                f"И делаю snapshots в папку: {os.path.abspath(SNAPSHOT_DIR)}"
            )
            _excel_lock_notified = True

        return False
    except Exception as e:
        print(f"[{now_ts()}] AUTOSAVE failed: {e}", flush=True)
        if tg_ready():
            tg_send(f"❌ Не могу сохранить Excel ни в основной, ни в AUTOSAVE: {e}")
        return False


def maybe_write_snapshot(wb: Workbook, base_path: str) -> None:
    global _last_snapshot_ts
    now = time.time()
    if now - _last_snapshot_ts < SNAPSHOT_EVERY_SECONDS:
        return
    _last_snapshot_ts = now

    try:
        Path(SNAPSHOT_DIR).mkdir(parents=True, exist_ok=True)
        stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        snap_path = os.path.join(SNAPSHOT_DIR, f"nowgoal_PLUS_{stamp}.xlsx")
        wb.save(snap_path)
        print(f"[{now_ts()}] Snapshot saved: {snap_path}", flush=True)
    except Exception as e:
        print(f"[{now_ts()}] Snapshot save failed: {e}", flush=True)


OU_TOTAL_RE = re.compile(r"\b[OU]\s*([0-9]+(?:\.[0-9]+)?)", re.IGNORECASE)


def read_total_from_cell(cell) -> Optional[float]:
    odds1 = cell.find_elements(By.CSS_SELECTOR, "span.odds1")
    if odds1:
        v = safe_float(txt(odds1[0]))
        if v is not None:
            return v

    it = (cell.get_attribute("innerText") or "").strip()
    m = OU_TOTAL_RE.search(it)
    if m:
        return safe_float(m.group(1))

    return None


def split_team_and_tag(s: str) -> Team:
    s = (s or "").strip()
    if s.endswith("]") and "[" in s:
        i = s.rfind("[")
        name = s[:i].strip()
        tag = s[i + 1:-1].strip() or None
        if name:
            return Team(name=name, tag=tag)
    return Team(name=s, tag=None)


def parse_analysis_onclick(onclick: str) -> Optional[Tuple[int, str, str, str]]:
    if not onclick or "basketInPage.analysis" not in onclick:
        return None
    try:
        args_str = onclick[onclick.find("(") + 1: onclick.rfind(")")]
        args = ast.literal_eval("(" + args_str + ")")
        return int(args[0]), str(args[1]), str(args[2]), str(args[3])
    except Exception:
        return None


def scroll_load_all(driver, max_rounds: int = 25, pause: float = 0.35):
    last = 0
    stable = 0
    for _ in range(max_rounds):
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        time.sleep(pause)
        cur = len(driver.find_elements(By.CSS_SELECTOR, 'td[onclick*="basketInPage.analysis("]'))
        if cur == last:
            stable += 1
            if stable >= 3:
                break
        else:
            stable = 0
            last = cur
    driver.execute_script("window.scrollTo(0, 0);")
    time.sleep(0.15)


def pick_band(abs_diff: float) -> Optional[str]:
    for lo, hi, label in DIFF_BANDS:
        if abs_diff >= lo and (hi is None or abs_diff < hi):
            return label
    return None


def line_complete(line: LineOU) -> bool:
    return (line.total is not None and line.over_odds is not None and line.under_odds is not None)


# ===================== STATUS =====================
LIVE_PAT = re.compile(r"\b\d+(?:st|nd|rd|th)\s+Qtr\b|\bOT\b|\bOvertime\b|\bLive\b", re.IGNORECASE)
TIME_PAT = re.compile(r"^\s*\d{1,2}:\d{2}\s*(?:AM|PM)?\s*$", re.IGNORECASE)


def is_finished(status: Optional[str]) -> bool:
    return (status or "").strip().lower() in {"finished", "final", "ft", "ended"}


def is_halftime(status: Optional[str]) -> bool:
    return "halftime" in (status or "").strip().lower()


def is_live(status: Optional[str]) -> bool:
    s = (status or "").strip()
    if not s:
        return False
    if is_finished(s) or is_halftime(s):
        return True
    return bool(LIVE_PAT.search(s))


def is_pregame(status: Optional[str]) -> bool:
    s = (status or "").strip()
    if not s:
        return True
    if TIME_PAT.match(s):
        return True
    sl = s.lower()
    if is_live(s) or is_halftime(s) or is_finished(s):
        return False
    if any(k in sl for k in ["postp", "cancel", "abandon", "void"]):
        return False
    if "pend" in sl:
        return True
    return True


def status_bucket(status: Optional[str]) -> str:
    if is_halftime(status):
        return "halftime"
    if is_finished(status):
        return "finished"
    if is_live(status):
        return "live"
    if is_pregame(status):
        return "pregame"
    return "other"


def pick_best_line(current: LineOU, st_rec: Dict[str, Any], status: Optional[str]) -> LineOU:
    if line_complete(current):
        return current

    bucket = status_bucket(status)
    hist = st_rec.get("line_hist")
    if not hist:
        return current

    for item in reversed(hist):
        if item["bucket"] == bucket and line_complete(item["line"]):
            return item["line"]

    for item in reversed(hist):
        if line_complete(item["line"]):
            return item["line"]

    return current


# ===================== STRATEGY FILTERS =====================
def league_allowed(league: str) -> bool:
    lg = league or ""

    if LEAGUE_WHITELIST_RE:
        ok = any(re.search(p, lg, re.I) for p in LEAGUE_WHITELIST_RE)
        if not ok:
            return False

    if any(re.search(p, lg, re.I) for p in LEAGUE_BLACKLIST_RE):
        return False

    return True


def strategy_allows(league: str, band: str, side: str, abs_diff: float) -> bool:
    if not USE_STRATEGY_FILTER:
        return True

    # league gate first
    if not league_allowed(league):
        return False

    for r in STRATEGY_RULES:
        if r.get("band") and band != r["band"]:
            continue
        if r.get("side") and side != r["side"]:
            continue

        abs_min = r.get("abs_min")
        abs_max = r.get("abs_max")
        if abs_min is not None and abs_diff < float(abs_min):
            continue
        if abs_max is not None and abs_diff >= float(abs_max):
            continue

        return True

    return False


# ===================== STATS =====================
def empty_stats() -> Dict[str, Any]:
    return {"bets": 0, "wins": 0, "losses": 0, "pushes": 0, "profit": 0.0}


def ensure_stats(d: Dict[str, Dict[str, Any]], key: str) -> Dict[str, Any]:
    if key not in d:
        d[key] = empty_stats()
    return d[key]


def ensure_nested_stats(d: Dict[str, Dict[str, Dict[str, Any]]], k1: str, k2: str) -> Dict[str, Any]:
    if k1 not in d:
        d[k1] = {}
    if k2 not in d[k1]:
        d[k1][k2] = empty_stats()
    return d[k1][k2]


def bet_profit(decimal_odds: float, stake: float, result: str) -> float:
    if result == "push":
        return 0.0
    if result == "loss":
        return -stake
    return (decimal_odds - 1.0) * stake


def stats_line(s: Dict[str, Any]) -> str:
    return f"Bets={s['bets']} W={s['wins']} L={s['losses']} P={s['pushes']} Profit={s['profit']:+.2f}"


def stats_block_extended(
    stats_total: Dict[str, Any],
    stats_by_band: Dict[str, Dict[str, Any]],
    stats_by_league: Dict[str, Dict[str, Any]],
    stats_by_league_band: Dict[str, Dict[str, Dict[str, Any]]],
    focus_league: Optional[str] = None,
    focus_band: Optional[str] = None,
) -> str:
    lines = []
    lines.append(f"TOTAL: {stats_line(stats_total)}")
    for _, _, label in DIFF_BANDS:
        lines.append(f"{label}: {stats_line(stats_by_band[label])}")

    if focus_league:
        ls = ensure_stats(stats_by_league, focus_league)
        lines.append("")
        lines.append(f"LEAGUE: {focus_league}")
        lines.append(stats_line(ls))
        if focus_band:
            lbs = ensure_nested_stats(stats_by_league_band, focus_league, focus_band)
            lines.append(f"LEAGUE×BAND ({focus_band}): {stats_line(lbs)}")

    return "\n".join(lines)


# ===================== EXCEL STORAGE =====================
BETS_HEADERS = [
    "bet_uid", "match_id",
    "league", "home", "away",
    "band", "side",
    "pre_total", "half_total", "diff", "abs_diff",
    "odds", "stake",
    "placed_at", "status_at_bet",
    "final_total", "result", "profit", "settled_at",
]


def excel_open_or_create(path: str):
    if os.path.exists(path):
        wb = load_workbook(path)
    else:
        wb = Workbook()

    if "Bets" not in wb.sheetnames:
        ws = wb.active
        ws.title = "Bets"
        ws.append(BETS_HEADERS)
    else:
        ws = wb["Bets"]
        if ws.max_row < 1:
            ws.append(BETS_HEADERS)
        else:
            header = [ws.cell(row=1, column=c).value for c in range(1, ws.max_column + 1)]
            if header[: len(BETS_HEADERS)] != BETS_HEADERS:
                for i, h in enumerate(BETS_HEADERS, start=1):
                    ws.cell(row=1, column=i).value = h

    for sname in ["Stats_Total", "Stats_Band", "Stats_League", "Stats_League_Band", "Monthly"]:
        if sname not in wb.sheetnames:
            wb.create_sheet(sname)

    ws_bets = wb["Bets"]
    uid_to_row: Dict[str, int] = {}
    for r in range(2, ws_bets.max_row + 1):
        uid = ws_bets.cell(row=r, column=1).value
        if uid:
            uid_to_row[str(uid)] = r

    safe_save(wb, path)
    return wb, uid_to_row


def excel_append_bet(wb: Workbook, uid_to_row: Dict[str, int], path: str, row: Dict[str, Any]) -> None:
    ws = wb["Bets"]
    values = [row.get(h) for h in BETS_HEADERS]
    ws.append(values)
    uid_to_row[str(row["bet_uid"])] = ws.max_row
    safe_save(wb, path)


def excel_update_settle(
    wb: Workbook,
    uid_to_row: Dict[str, int],
    path: str,
    bet_uid: str,
    final_total: int,
    result: str,
    profit: float,
    settled_at: str,
) -> None:
    ws = wb["Bets"]
    r = uid_to_row.get(str(bet_uid))
    if not r:
        return
    ws.cell(row=r, column=16).value = int(final_total)
    ws.cell(row=r, column=17).value = str(result)
    ws.cell(row=r, column=18).value = float(profit)
    ws.cell(row=r, column=19).value = str(settled_at)
    safe_save(wb, path)


def _clear_sheet_keep_header(ws, headers: Optional[list] = None):
    ws.delete_rows(1, ws.max_row)
    if headers:
        ws.append(headers)


def excel_write_stats(
    wb: Workbook,
    path: str,
    stats_total: Dict[str, Any],
    stats_by_band: Dict[str, Dict[str, Any]],
    stats_by_league: Dict[str, Dict[str, Any]],
    stats_by_league_band: Dict[str, Dict[str, Dict[str, Any]]],
):
    ws = wb["Stats_Total"]
    _clear_sheet_keep_header(ws, ["metric", "value"])
    for k in ["bets", "wins", "losses", "pushes", "profit"]:
        ws.append([k, stats_total[k]])

    ws = wb["Stats_Band"]
    _clear_sheet_keep_header(ws, ["band", "bets", "wins", "losses", "pushes", "profit"])
    for _, _, band in DIFF_BANDS:
        s = stats_by_band[band]
        ws.append([band, s["bets"], s["wins"], s["losses"], s["pushes"], float(s["profit"])])

    ws = wb["Stats_League"]
    _clear_sheet_keep_header(ws, ["league", "bets", "wins", "losses", "pushes", "profit"])
    for league, s in sorted(stats_by_league.items(), key=lambda kv: (-kv[1]["bets"], kv[0])):
        ws.append([league, s["bets"], s["wins"], s["losses"], s["pushes"], float(s["profit"])])

    ws = wb["Stats_League_Band"]
    _clear_sheet_keep_header(ws, ["league", "band", "bets", "wins", "losses", "pushes", "profit"])
    rows = []
    for league, bands in stats_by_league_band.items():
        for band, s in bands.items():
            rows.append((league, band, s))
    for league, band, s in sorted(rows, key=lambda x: (-x[2]["bets"], x[0], x[1])):
        ws.append([league, band, s["bets"], s["wins"], s["losses"], s["pushes"], float(s["profit"])])

    safe_save(wb, path)


def excel_write_monthly(wb: Workbook, path: str) -> None:
    ws_bets = wb["Bets"]
    ws_m = wb["Monthly"]

    ws_m.delete_rows(1, ws_m.max_row)
    ws_m.append(["month", "bets_settled", "profit", "cum_profit"])

    header = [ws_bets.cell(row=1, column=c).value for c in range(1, ws_bets.max_column + 1)]

    def col_idx(name: str) -> int:
        return header.index(name) + 1

    try:
        c_profit = col_idx("profit")
        c_settled_at = col_idx("settled_at")
    except ValueError:
        safe_save(wb, path)
        return

    monthly_profit: Dict[str, float] = {}
    monthly_bets: Dict[str, int] = {}

    for r in range(2, ws_bets.max_row + 1):
        settled_at = ws_bets.cell(row=r, column=c_settled_at).value
        prof = ws_bets.cell(row=r, column=c_profit).value
        if not settled_at or prof is None:
            continue

        month = str(settled_at)[:7]
        monthly_profit[month] = monthly_profit.get(month, 0.0) + float(prof)
        monthly_bets[month] = monthly_bets.get(month, 0) + 1

    cum = 0.0
    for month in sorted(monthly_profit.keys()):
        p = float(monthly_profit[month])
        b = int(monthly_bets.get(month, 0))
        cum += p
        ws_m.append([month, b, p, cum])

    ws_m._charts = []

    if ws_m.max_row >= 2:
        chart = LineChart()
        chart.title = "Monthly Profit Trend"
        chart.y_axis.title = "Profit"
        chart.x_axis.title = "Month"

        data = Reference(ws_m, min_col=3, max_col=4, min_row=1, max_row=ws_m.max_row)
        cats = Reference(ws_m, min_col=1, min_row=2, max_row=ws_m.max_row)
        chart.add_data(data, titles_from_data=True)
        chart.set_categories(cats)

        ws_m.add_chart(chart, "F2")

    safe_save(wb, path)


# ===================== DRIVER =====================
def make_driver(headless: bool = True):
    options = webdriver.ChromeOptions()
    if headless:
        options.add_argument("--headless=new")
    options.add_argument("--window-size=1400,900")
    options.add_argument("--disable-gpu")
    options.add_argument("--no-sandbox")
    options.add_argument("--disable-dev-shm-usage")
    options.add_argument("--disable-blink-features=AutomationControlled")
    options.add_argument(
        "user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
        "(KHTML, like Gecko) Chrome/126.0 Safari/537.36"
    )
    return webdriver.Chrome(options=options)


# ===================== SNAPSHOT PARSER =====================
def _parse_ou_for_mid(driver, mid: int) -> LineOU:
    over_total = under_total = None
    over_odds = under_odds = None

    cells = []
    ht = driver.find_elements(By.ID, f"ht_{mid}")
    gt = driver.find_elements(By.ID, f"gt_{mid}")
    if ht:
        cells.append(ht[0])
    if gt:
        cells.append(gt[0])

    if not cells:
        cells = driver.find_elements(By.CSS_SELECTOR, f'td.ouOdds[onclick*="oddscomp({mid}"]')

    for cell in cells:
        raw = (cell.get_attribute("innerText") or txt(cell)).strip().upper()
        odds2 = cell.find_elements(By.CSS_SELECTOR, "span.odds2")

        total_val = read_total_from_cell(cell)
        odds_val = read_odds_decimal(odds2[0]) if odds2 else None

        if raw.startswith("O"):
            over_total = total_val
            over_odds = odds_val
        elif raw.startswith("U"):
            under_total = total_val
            under_odds = odds_val

    line = LineOU(over_odds=over_odds, under_odds=under_odds)

    if over_total is not None and under_total is not None:
        if abs(over_total - under_total) < 1e-9:
            line.total = over_total
        else:
            line.total = (over_total + under_total) / 2.0
    else:
        line.total = over_total if over_total is not None else under_total

    return line


def _get_snapshot_once(driver, do_scroll: bool) -> Dict[int, Dict[str, Any]]:
    wait = WebDriverWait(driver, 30)
    wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, 'td[onclick*="basketInPage.analysis("]')))
    if do_scroll:
        scroll_load_all(driver)

    games: Dict[int, Dict[str, Any]] = {}
    analysis_tds = driver.find_elements(By.CSS_SELECTOR, 'td[onclick*="basketInPage.analysis("]')

    for td in analysis_tds:
        parsed = parse_analysis_onclick(td.get_attribute("onclick") or "")
        if not parsed:
            continue
        mid, home_s, away_s, league_s = parsed
        games[mid] = {
            "match_id": mid,
            "league": league_s,
            "home": split_team_and_tag(home_s),
            "away": split_team_and_tag(away_s),
            "status": None,
            "line": LineOU(),
            "home_score": None,
            "away_score": None,
        }

    for mid in list(games.keys()):
        status_els = driver.find_elements(By.ID, f"zt_{mid}")
        if status_els:
            games[mid]["status"] = txt(status_els[0]) or None

        games[mid]["line"] = _parse_ou_for_mid(driver, mid)

        h_els = driver.find_elements(By.ID, f"hzf_{mid}")
        g_els = driver.find_elements(By.ID, f"gzf_{mid}")
        if h_els and g_els:
            hs = safe_float(txt(h_els[0]))
            gs = safe_float(txt(g_els[0]))
            games[mid]["home_score"] = int(hs) if hs is not None else None
            games[mid]["away_score"] = int(gs) if gs is not None else None

    return games


def get_snapshot(driver, do_scroll: bool, retries: int = 3) -> Dict[int, Dict[str, Any]]:
    for attempt in range(1, retries + 1):
        try:
            return _get_snapshot_once(driver, do_scroll=do_scroll)
        except StaleElementReferenceException:
            print(f"[{now_ts()}] snapshot stale -> retry {attempt}/{retries}", flush=True)
            time.sleep(0.25)
    return _get_snapshot_once(driver, do_scroll=do_scroll)


# ===================== MAIN LOOP =====================
def main():
    print(f"[{now_ts()}] Starting monitor PLUS. poll={POLL_SECONDS}s stake={STAKE}", flush=True)
    print(f"[{now_ts()}] Bands: " + ", ".join([lbl for _, _, lbl in DIFF_BANDS]), flush=True)
    print(f"[{now_ts()}] Excel: {os.path.abspath(EXCEL_PATH)}", flush=True)
    print(f"[{now_ts()}] Snapshots dir: {os.path.abspath(SNAPSHOT_DIR)} every {SNAPSHOT_EVERY_SECONDS}s", flush=True)
    print(f"[{now_ts()}] Halftime wait: {HALFTIME_WAIT_SECONDS}s (first halftime only)", flush=True)
    print(f"[{now_ts()}] Strategy: ONLY UNDER, band 20-30, abs_diff in [20,22) or [26,30)", flush=True)
    if LEAGUE_BLACKLIST_RE:
        print(f"[{now_ts()}] League blacklist enabled: {LEAGUE_BLACKLIST_RE}", flush=True)

    # ✅ Send ping immediately (so you know TG works)
    tg_startup_ping()

    wb, uid_to_row = excel_open_or_create(EXCEL_PATH)

    tg_send(
        "🟢 NowGoal monitor PLUS STARTED\n"
        f"poll={POLL_SECONDS}s | stake={STAKE}\n"
        f"strategy=UNDER only; band 20-30; abs_diff [20,22) or [26,30)\n"
        f"halftime_wait={HALFTIME_WAIT_SECONDS}s (first halftime only)\n"
        f"time={now_dt()}\n"
        f"excel(main)={os.path.abspath(EXCEL_PATH)}\n"
        f"snapshots={os.path.abspath(SNAPSHOT_DIR)}"
    )

    driver = make_driver(headless=HEADLESS)
    state: Dict[int, Dict[str, Any]] = {}

    stats_total = empty_stats()
    stats_by_band = {label: empty_stats() for _, _, label in DIFF_BANDS}
    stats_by_league: Dict[str, Dict[str, Any]] = {}
    stats_by_league_band: Dict[str, Dict[str, Dict[str, Any]]] = {}

    loop_n = 0
    try:
        driver.get(URL)
        WebDriverWait(driver, 30).until(
            EC.presence_of_element_located((By.CSS_SELECTOR, 'td[onclick*="basketInPage.analysis("]'))
        )

        while True:
            loop_n += 1
            t0 = time.time()

            do_scroll = (loop_n == 1) or (loop_n % SCROLL_EVERY_N_LOOPS == 0)

            try:
                driver.refresh()
                time.sleep(0.35)
            except Exception as e:
                print(f"[{now_ts()}] refresh error: {e} -> reopen", flush=True)
                driver.get(URL)

            try:
                snap = get_snapshot(driver, do_scroll=do_scroll, retries=3)
            except Exception as e:
                print(f"[{now_ts()}] snapshot error: {e}", flush=True)
                time.sleep(POLL_SECONDS)
                continue

            cnt_total = len(snap)
            cnt_live = cnt_half = cnt_finished = 0
            for g in snap.values():
                st = g.get("status")
                if is_finished(st):
                    cnt_finished += 1
                elif is_halftime(st):
                    cnt_half += 1
                elif is_live(st):
                    cnt_live += 1

            print(
                f"[{now_ts()}] loop={loop_n} games={cnt_total} live={cnt_live} halftime={cnt_half} finished={cnt_finished} "
                f"| TOTAL profit={stats_total['profit']:+.2f} bets={stats_total['bets']}",
                flush=True
            )

            for mid, g in snap.items():
                st_rec = state.setdefault(mid, {
                    "league": g["league"],
                    "home": g["home"],
                    "away": g["away"],

                    "pregame_total_last": None,
                    "pregame_total_frozen": None,

                    "bet": None,
                    "bet_uid": None,
                    "settled": False,

                    "last_status": None,
                    "line_hist": deque(maxlen=10),

                    "halftime_count": 0,
                    "halftime_first_ts": None,
                })

                status = g.get("status")
                line_raw: LineOU = g.get("line", LineOU())
                line = pick_best_line(line_raw, st_rec, status)

                if line_complete(line):
                    st_rec["line_hist"].append({
                        "ts": now_dt(),
                        "bucket": status_bucket(status),
                        "line": LineOU(line.total, line.over_odds, line.under_odds),
                    })

                prev_status = st_rec["last_status"]

                if status != prev_status:
                    st_rec["last_status"] = status
                    if status:
                        parts = []
                        if line.total is not None:
                            parts.append(f"OU={line.total:g}")
                        if line.over_odds is not None:
                            parts.append(f"O@{line.over_odds:.2f}")
                        if line.under_odds is not None:
                            parts.append(f"U@{line.under_odds:.2f}")
                        line_str = " | " + (" ".join(parts) if parts else "OU=-")
                        print(
                            f"  [{now_ts()}] status id={mid} | {st_rec['home'].name} vs {st_rec['away'].name} | {status}{line_str}",
                            flush=True
                        )

                # FIRST halftime transition
                if is_halftime(status) and not is_halftime(prev_status):
                    st_rec["halftime_count"] += 1
                    if st_rec["halftime_count"] == 1:
                        st_rec["halftime_first_ts"] = time.time()
                        print(
                            f"  [{now_ts()}] FIRST HALFTIME detected id={mid} -> waiting {HALFTIME_WAIT_SECONDS}s",
                            flush=True
                        )
                    else:
                        print(
                            f"  [{now_ts()}] HALFTIME повторно (#{st_rec['halftime_count']}) id={mid} -> IGNORE",
                            flush=True
                        )

                # pregame -> remember last pregame total
                if is_pregame(status):
                    if line.total is not None:
                        st_rec["pregame_total_last"] = float(line.total)

                # first live -> freeze pregame total
                if is_live(status) and st_rec["pregame_total_frozen"] is None and st_rec["pregame_total_last"] is not None:
                    st_rec["pregame_total_frozen"] = float(st_rec["pregame_total_last"])
                    print(f"  [{now_ts()}] pregame frozen id={mid} pre_total={st_rec['pregame_total_frozen']:g}", flush=True)

                # halftime -> bet (only first halftime + wait + PLUS filters)
                if (
                    is_halftime(status)
                    and st_rec["bet"] is None
                    and st_rec["pregame_total_frozen"] is not None
                    and st_rec["halftime_count"] == 1
                ):
                    ht_ts = st_rec.get("halftime_first_ts")
                    if ht_ts is None:
                        st_rec["halftime_first_ts"] = time.time()
                        ht_ts = st_rec["halftime_first_ts"]

                    if (time.time() - float(ht_ts)) < HALFTIME_WAIT_SECONDS:
                        continue

                    pre_total = float(st_rec["pregame_total_frozen"])
                    half_total = line.total
                    if half_total is None:
                        continue

                    diff = float(half_total) - pre_total
                    abs_diff = abs(diff)

                    band = pick_band(abs_diff)
                    if band is None:
                        continue

                    if diff > 0:
                        side = "UNDER"
                        odds = line.under_odds
                    else:
                        side = "OVER"
                        odds = line.over_odds

                    if odds is None:
                        continue

                    league = st_rec["league"]

                    # ✅ PLUS STRATEGY GATE (main change)
                    if not strategy_allows(league, band, side, abs_diff):
                        print(
                            f"  [{now_ts()}] SKIP (PLUS strategy) id={mid} league={league} [{band}] {side} abs_diff={abs_diff:g}",
                            flush=True
                        )
                        continue

                    bet_uid = f"{mid}-{int(time.time()*1000)}"
                    st_rec["bet_uid"] = bet_uid

                    st_rec["bet"] = {
                        "band": band,
                        "side": side,
                        "line": float(half_total),
                        "odds": float(odds),
                        "stake": float(STAKE),
                        "pre_total": float(pre_total),
                        "half_total": float(half_total),
                        "diff": float(diff),
                        "abs_diff": float(abs_diff),
                        "placed_at": now_dt(),
                        "status_at_bet": status,
                    }

                    stats_total["bets"] += 1
                    stats_by_band[band]["bets"] += 1
                    ensure_stats(stats_by_league, league)["bets"] += 1
                    ensure_nested_stats(stats_by_league_band, league, band)["bets"] += 1

                    excel_append_bet(
                        wb, uid_to_row, EXCEL_PATH,
                        {
                            "bet_uid": bet_uid,
                            "match_id": mid,
                            "league": league,
                            "home": st_rec["home"].name,
                            "away": st_rec["away"].name,
                            "band": band,
                            "side": side,
                            "pre_total": float(pre_total),
                            "half_total": float(half_total),
                            "diff": float(diff),
                            "abs_diff": float(abs_diff),
                            "odds": float(odds),
                            "stake": float(STAKE),
                            "placed_at": st_rec["bet"]["placed_at"],
                            "status_at_bet": status,
                            "final_total": None,
                            "result": None,
                            "profit": None,
                            "settled_at": None,
                        }
                    )
                    excel_write_stats(wb, EXCEL_PATH, stats_total, stats_by_band, stats_by_league, stats_by_league_band)
                    excel_write_monthly(wb, EXCEL_PATH)

                    print(
                        f"  [{now_ts()}] BET PLACED PLUS [{band}] id={mid} {side} {half_total:g} @ {odds:.2f} "
                        f"(pre {pre_total:g}, diff {diff:+g}, abs {abs_diff:g})",
                        flush=True
                    )

                    block = stats_block_extended(
                        stats_total, stats_by_band, stats_by_league, stats_by_league_band,
                        focus_league=league, focus_band=band
                    )

                    tg_send(
                        f"✅ BET PLACED (PLUS) (TOTAL #{stats_total['bets']}) [{band}]\n"
                        f"{league}\n"
                        f"{st_rec['home'].name} vs {st_rec['away'].name}\n"
                        f"Status: {status}\n"
                        f"(waited {HALFTIME_WAIT_SECONDS}s after first halftime)\n"
                        f"Pre total: {pre_total:g}\n"
                        f"Halftime line: {half_total:g} (diff {diff:+g}, abs {abs_diff:g})\n"
                        f"BET: {side} {half_total:g} @ {float(odds):.2f}\n"
                        f"Stake: {STAKE}\n"
                        f"\n📊 STATS\n{block}\n"
                        f"id={mid}\n"
                        f"bet_uid={bet_uid}"
                    )

                # finished -> settle
                if is_finished(status) and st_rec["bet"] is not None and not st_rec["settled"]:
                    hs = g.get("home_score")
                    gs = g.get("away_score")
                    if hs is None or gs is None:
                        continue

                    final_total = int(hs) + int(gs)

                    band = st_rec["bet"]["band"]
                    league = st_rec["league"]
                    side = st_rec["bet"]["side"]
                    line_bet = float(st_rec["bet"]["line"])
                    odds = float(st_rec["bet"]["odds"])
                    stake = float(st_rec["bet"]["stake"])

                    if abs(final_total - line_bet) < 1e-9:
                        result = "push"
                        stats_total["pushes"] += 1
                        stats_by_band[band]["pushes"] += 1
                        ensure_stats(stats_by_league, league)["pushes"] += 1
                        ensure_nested_stats(stats_by_league_band, league, band)["pushes"] += 1
                    else:
                        win = (final_total < line_bet) if side == "UNDER" else (final_total > line_bet)
                        if win:
                            result = "win"
                            stats_total["wins"] += 1
                            stats_by_band[band]["wins"] += 1
                            ensure_stats(stats_by_league, league)["wins"] += 1
                            ensure_nested_stats(stats_by_league_band, league, band)["wins"] += 1
                        else:
                            result = "loss"
                            stats_total["losses"] += 1
                            stats_by_band[band]["losses"] += 1
                            ensure_stats(stats_by_league, league)["losses"] += 1
                            ensure_nested_stats(stats_by_league_band, league, band)["losses"] += 1

                    prof = bet_profit(odds, stake, result)
                    stats_total["profit"] += prof
                    stats_by_band[band]["profit"] += prof
                    ensure_stats(stats_by_league, league)["profit"] += prof
                    ensure_nested_stats(stats_by_league_band, league, band)["profit"] += prof

                    st_rec["settled"] = True

                    bet_uid = st_rec.get("bet_uid")
                    if bet_uid:
                        excel_update_settle(
                            wb, uid_to_row, EXCEL_PATH,
                            bet_uid, final_total, result.upper(), float(prof), now_dt()
                        )
                    excel_write_stats(wb, EXCEL_PATH, stats_total, stats_by_band, stats_by_league, stats_by_league_band)
                    excel_write_monthly(wb, EXCEL_PATH)

                    block = stats_block_extended(
                        stats_total, stats_by_band, stats_by_league, stats_by_league_band,
                        focus_league=league, focus_band=band
                    )

                    print(
                        f"  [{now_ts()}] BET SETTLED PLUS [{band}] id={mid} {result.upper()} final_total={final_total} "
                        f"bet={side} {line_bet:g} @ {odds:.2f} P/L={prof:+.2f}\n{block}",
                        flush=True
                    )

                    tg_send(
                        f"🏁 BET RESULT (PLUS): {result.upper()} [{band}]\n"
                        f"{league}\n"
                        f"{st_rec['home'].name} {hs} : {gs} {st_rec['away'].name}\n"
                        f"Final total: {final_total}\n"
                        f"Bet: {side} {line_bet:g} @ {odds:.2f} | stake {stake}\n"
                        f"P/L: {prof:+.2f}\n\n"
                        f"📊 STATS\n{block}\n"
                        f"id={mid}\n"
                        f"bet_uid={bet_uid}"
                    )

            maybe_write_snapshot(wb, EXCEL_PATH)

            elapsed = time.time() - t0
            time.sleep(max(0.2, POLL_SECONDS - elapsed))

    finally:
        driver.quit()
        print(f"[{now_ts()}] Driver closed.", flush=True)


if __name__ == "__main__":
    main()

Если после этого всё равно нет сообщений в TG

С этим кодом в консоль будет выведена реальная причина (например: 401 Unauthorized, 400 Bad Request: chat not found, bot was blocked by the user, etc.).

Самые частые фиксы:

В личке: открыть бота и нажать Start (или отправить /start).
Проверить TELEGRAM_CHAT_ID (в группе он обычно отрицательный).
Если видишь 401 Unauthorized — токен неверный/отозван → перевыпустить.

Если хочешь — скинь сюда ровно строку ошибки, которую выведет консоль ([TG] ERROR ...), и я точечно скажу что именно не так (chat_id vs токен vs права).

Question

===================== CONFIG =====================

✅ NEW: wait after FIRST halftime appears (to stabilize odds/lines)

====== WINDOWS-EXCEL SAFE SAVE + SNAPSHOTS ======

===================== TELEGRAM =====================

===================== MODELS =====================

===================== HELPERS =====================

-------- Excel safe save + snapshots (Windows) --------

===================== STATUS =====================

===================== STATS =====================

===================== EXCEL STORAGE =====================

===================== DRIVER =====================

===================== SNAPSHOT PARSER =====================

===================== MAIN LOOP =====================

Thought

Creating summary and providing a download link

Refining betting strategy and stats handling

Implementing strategy rules and clarifications

Proposing security update and configuration options

Answer

1) Что по результату в целом

2) Проблемные зоны (где основной минус)

По твоим текущим “зонам” (band × side)

Самая “ядовитая” подзона внутри 20–30 (по abs_diff)

3) Хорошие зоны (где реально есть плюс)

Самое “стабильное” по объёму

Самая плюсовая (по этому файлу) — с фильтром по abs_diff

4) Правка кода: ставить только по плюсовой стратегии

A) Добавь в CONFIG (вверху файла)

B) Добавь функцию-проверку (где-нибудь в HELPERS, после pick_band например)

C) Вставь фильтр прямо перед созданием bet (в блоке # 3) halftime -> bet)

Важное (без морали, чисто практика)

Question

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Python

Thought

Refining the strategy and league blacklisting options

Handling history and league exclusions

Providing analysis with disclaimers and tables

League summary with numeric details

Filtered strategy and league recommendations

Answer

1) Разбивка по лигам (только где есть нормальный объём)

Что важно по смыслу

2) Лиги внутри “плюсовой стратегии”, которую мы вырезали из твоих данных

3) Стоит ли убирать лиги?

Я бы сделал так (прагматично, без переобучения):

4) Как добавить фильтр по лигам в код (минимальная правка)

A) В CONFIG добавь:

B) Добавь helper:

C) И прямо перед размещением ставки (там где ты уже вычислил league, band, side, abs_diff) вставь:

Question

===================== CONFIG =====================

✅ NEW: wait after FIRST halftime appears (to stabilize odds/lines)

====== WINDOWS-EXCEL SAFE SAVE + SNAPSHOTS ======

===================== TELEGRAM =====================

===================== MODELS =====================

===================== HELPERS =====================

-------- Excel safe save + snapshots (Windows) --------

===================== STATUS =====================

===================== STATS =====================

===================== EXCEL STORAGE =====================

===================== DRIVER =====================

C) Вставь фильтр прямо перед созданием bet (в блоке `# 3) halftime -> bet`)

C) И прямо перед размещением ставки (там где ты уже вычислил `league`, `band`, `side`, `abs_diff`) вставь: