import asyncio

import sqlite3
import random
from datetime import datetime
from aiogram import Bot, Dispatcher, F, Router, types
from [Link] import Message, ReplyKeyboardMarkup, KeyboardButton,
InlineKeyboardMarkup, InlineKeyboardButton
from [Link] import Command
from [Link] import FSMContext
from [Link] import State, StatesGroup
from [Link] import MemoryStorage

# ===== CONFIGURATION =====

BOT_TOKEN = "8485404502:AAFvRJn3-SN5Zoymedroq80_-VP9WUcCgZw" # REPLACE WITH YOUR
ACTUAL TOKEN
ADMIN_CHAT_ID = "738679434"
ADMIN_PASSWORD = "50000"
MIN_BET = 100
MAX_BET = 120000
FREE_BET_MIN = 3000
FREE_BET_MAX = 15000

# ===== DATABASE FUNCTIONS =====

def init_db():
conn = [Link]('[Link]')
c = [Link]()
[Link]('''
CREATE TABLE IF NOT EXISTS matches (
id INTEGER PRIMARY KEY AUTOINCREMENT,
game_type TEXT,
team1 TEXT,
team2 TEXT,
win1_odds REAL,
draw_odds REAL,
win2_odds REAL,
total_goals REAL,
over_goals_odds REAL,
under_goals_odds REAL,
both_yes_odds REAL,
both_no_odds REAL,
total_fouls REAL,
over_fouls_odds REAL,
under_fouls_odds REAL,
total_corners REAL,
over_corners_odds REAL,
under_corners_odds REAL,
total_yellows REAL,
over_yellows_odds REAL,
under_yellows_odds REAL,
total_reds REAL,
over_reds_odds REAL,
under_reds_odds REAL,
start_time TEXT,
status TEXT DEFAULT 'scheduled'
)
''')
def update_user_balance(user_id, amount):
"""Add amount to user's balance (can be negative)"""
 conn = [Link]('[Link]')
c = [Link]()
[Link]("UPDATE users SET balance = balance + ? WHERE user_id = ?",
(amount, user_id))
[Link]()
[Link]()
def add_user(user_id, username):
conn = [Link]('[Link]')
c = [Link]()
[Link]("INSERT OR IGNORE INTO users (user_id, username) VALUES (?, ?)",
(user_id, username))
[Link]()
[Link]()

def get_user(user_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT * FROM users WHERE user_id = ?", (user_id,))
user = [Link]()
[Link]()
return user

def update_balance(user_id, amount):

conn = [Link]('[Link]')
c = [Link]()
[Link]("UPDATE users SET balance = balance + ? WHERE user_id = ?",
(amount, user_id))
[Link]()
[Link]()

def mark_freebet_used(user_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("UPDATE users SET freebet_used = 1 WHERE user_id = ?", (user_id,))
[Link]()
[Link]()

def get_random_freebet():
return [Link](FREE_BET_MIN, FREE_BET_MAX)

# Alternative approach: Use a flag-based system

def get_active_matches():
"""Get matches where is_active = 1"""
conn = [Link]('[Link]')
c = [Link]()
# First check if is_active column exists
[Link]("PRAGMA table_info(matches)")
columns = [col[1] for col in [Link]()]

if 'is_active' in columns:
[Link]("SELECT id, team1, team2 FROM matches WHERE is_active = 1")
else:
# Fallback to status-based if column doesn't exist
[Link]("SELECT id, team1, team2 FROM matches WHERE status != 'ended'")
 matches = [Link]()
[Link]()
return matches

def create_user_if_not_exists(user_id, username):

"""Create user if not exists in database"""
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT id FROM users WHERE user_id = ?", (user_id,))
if not [Link]():
[Link]("INSERT INTO users (user_id, username) VALUES (?, ?)",
(user_id, username))
[Link]()
[Link]()

def get_user_balance(user_id):
"""Get current user balance (fixed version)"""
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT balance FROM users WHERE user_id = ?", (user_id,))
result = [Link]()
[Link]()
return result[0] if result else 0
def create_match(game_type, team1, team2, win1_odds, draw_odds, win2_odds,
total_goals, over_odds, under_odds, both_yes_odds, both_no_odds,
start_time):
conn = [Link]('[Link]')
c = [Link]()
[Link]('''INSERT INTO matches (
game_type, team1, team2, win1_odds, draw_odds, win2_odds,
total_goals, over_odds, under_odds, both_teams_yes_odds,
both_teams_no_odds, start_time)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
(game_type, team1, team2, win1_odds, draw_odds, win2_odds,
total_goals, over_odds, under_odds, both_yes_odds, both_no_odds,
start_time))
match_id = [Link]
[Link]()
[Link]()
return match_id

def publish_match(match_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("UPDATE matches SET published = 1 WHERE id = ?", (match_id,))
[Link]()
[Link]()

def get_match(match_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT * FROM matches WHERE id = ?", (match_id,))
match = [Link]()
[Link]()
return match

def get_all_matches():
 conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT * FROM matches")
matches = [Link]()
[Link]()
return matches

def start_match(match_id):
conn = [Link]('[Link]')
c = [Link]()
# Get current status first
[Link]("SELECT status FROM matches WHERE id = ?", (match_id,))
current_status = [Link]()[0] if [Link]() else None

# Only start if in scheduled state

if current_status == 'scheduled':
[Link]("UPDATE matches SET status = 'in_progress' WHERE id = ?",
(match_id,))
[Link]()
return True
return False

def end_match(match_id):
conn = [Link]('[Link]')
c = [Link]()
# Get current status first
[Link]("SELECT status FROM matches WHERE id = ?", (match_id,))
current_status = [Link]()[0] if [Link]() else None

# Only end if in progress

if current_status == 'in_progress':
[Link]("UPDATE matches SET status = 'ended' WHERE id = ?", (match_id,))
[Link]()
return True
return False

def record_goal(match_id, team):

conn = [Link]('[Link]')
c = [Link]()
if team == 1:
[Link]("UPDATE matches SET score_team1 = score_team1 + 1 WHERE id = ?",
(match_id,))
else:
[Link]("UPDATE matches SET score_team2 = score_team2 + 1 WHERE id = ?",
(match_id,))

# Record event
event_time = [Link]().strftime("%H:%M")
[Link]("INSERT INTO match_events (match_id, event_type, event_time) VALUES
(?, ?, ?)",
(match_id, f"Гол команды {team}", event_time))
[Link]()
[Link]()

def complete_match(match_id):
 conn = [Link]('[Link]')
c = [Link]()
[Link]("UPDATE matches SET completed = 1 WHERE id = ?", (match_id,))
[Link]()
[Link]()

def place_bet(user_id, match_id, bet_type, amount, odds):

conn = [Link]('[Link]')
c = [Link]()
[Link]('''INSERT INTO bets (user_id, match_id, bet_type, amount, odds)
VALUES (?, ?, ?, ?, ?)''',
(user_id, match_id, bet_type, amount, odds))
[Link]()
[Link]()

def get_match_bets(match_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT * FROM bets WHERE match_id = ?", (match_id,))
bets = [Link]()
[Link]()
return bets

def get_user_bets(user_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT * FROM bets WHERE user_id = ?", (user_id,))
bets = [Link]()
[Link]()
return bets

def update_bet_result(bet_id, won):

conn = [Link]('[Link]')
c = [Link]()
[Link]("UPDATE bets SET won = ?, processed = 1 WHERE id = ?", (won, bet_id))
[Link]()
[Link]()

def create_match_stats(match_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("INSERT INTO match_stats (match_id) VALUES (?)", (match_id,))
[Link]()
[Link]()

def get_match_stats(match_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT * FROM match_stats WHERE match_id = ?", (match_id,))
stats = [Link]()
[Link]()
return stats

def update_match_stats(match_id, stat_field, team):

conn = [Link]('[Link]')
 c = [Link]()

# Determine which team to update

team_suffix = "_team1" if team == 1 else "_team2"
field = stat_field + team_suffix

[Link](f"UPDATE match_stats SET {field} = {field} + 1 WHERE match_id = ?",

(match_id,))
[Link]()
[Link]()

# Add broadcast function

async def broadcast_new_match(bot: Bot, match_id: int):
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT user_id FROM users")
user_ids = [row[0] for row in [Link]()]
[Link]()

match = get_match(match_id)
if not match:
return

message = (
"🎉 Новый матч доступен для ставок!\n\n"
f" {match[2]} vs {match[3]}\n"
f"⏰ Начало: {match[25]}\n"
"➡️ Используйте команду /matches для просмотра"
)

for user_id in user_ids:

try:
await bot.send_message(user_id, message)
except:
continue

# ===== KEYBOARD FUNCTIONS =====

def main_keyboard():
return ReplyKeyboardMarkup(
keyboard=[
[KeyboardButton(text="Баланс"), KeyboardButton(text="Актуальные
матчи")]
],
resize_keyboard=True
)

def control_panel_keyboard(match_id, team1, team2):

conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT status FROM matches WHERE id = ?", (match_id,))
status = [Link]()[0] if [Link]() else 'unknown'
[Link]()

buttons = []
if status == 'scheduled':
[Link](InlineKeyboardButton(
text="▶️ Начать матч",
 callback_data=f"start_match_{match_id}"
))
elif status == 'in_progress':
[Link](InlineKeyboardButton(
text=" Завершить матч",
callback_data=f"end_match_{match_id}"
))
else:
[Link](InlineKeyboardButton(
text="✅ Матч завершен",
callback_data="no_action"
))

return InlineKeyboardMarkup(inline_keyboard=[buttons])
def game_selection_keyboard():
return ReplyKeyboardMarkup(
keyboard=[
[KeyboardButton(text="FC25")],
[KeyboardButton(text="CS2")],
[KeyboardButton(text="Другое")]
],
resize_keyboard=True,
one_time_keyboard=True
)

def match_action_keyboard():
return ReplyKeyboardMarkup(
keyboard=[
[KeyboardButton(text="Создать новый матч")],
[KeyboardButton(text="История матчей")]
],
resize_keyboard=True,
one_time_keyboard=True
)

def confirmation_keyboard():
return ReplyKeyboardMarkup(
keyboard=[
[KeyboardButton(text="Да, опубликовать")],
[KeyboardButton(text="Нет, изменить")]
],
resize_keyboard=True,
one_time_keyboard=True
)

def match_control_keyboard(match_id):
return InlineKeyboardMarkup(
inline_keyboard=[
[InlineKeyboardButton(text="Матч Стартовал!",
callback_data=f"start_{match_id}")],
[InlineKeyboardButton(text="Гол 1 команды",
callback_data=f"goal1_{match_id}"),
InlineKeyboardButton(text="Гол 2 команды",
callback_data=f"goal2_{match_id}")],
[InlineKeyboardButton(text="Матч Закончился!",
callback_data=f"end_{match_id}")]
 ]
)

def bet_options_keyboard(match_id):
return InlineKeyboardMarkup(inline_keyboard=[
[
InlineKeyboardButton(text="П1", callback_data=f"bet_win1_{match_id}"),
InlineKeyboardButton(text="X", callback_data=f"bet_draw_{match_id}"),
InlineKeyboardButton(text="П2", callback_data=f"bet_win2_{match_id}"),
],
[
InlineKeyboardButton(text="Тотал голов",
callback_data=f"bet_total_{match_id}"),
InlineKeyboardButton(text="Обе забьют",
callback_data=f"bet_both_{match_id}"),
],
[
InlineKeyboardButton(text="Фолы",
callback_data=f"bet_fouls_{match_id}"),
InlineKeyboardButton(text="Угловые",
callback_data=f"bet_corners_{match_id}"),
],
[
InlineKeyboardButton(text="Желтые карточки",
callback_data=f"bet_yellows_{match_id}"),
InlineKeyboardButton(text="Красные карточки",
callback_data=f"bet_reds_{match_id}"),
]
])

def advanced_match_control_keyboard(match_id):
return InlineKeyboardMarkup(
inline_keyboard=[
[InlineKeyboardButton(text="Фол команды 1",
callback_data=f"foul1_{match_id}"),
InlineKeyboardButton(text="Фол команды 2",
callback_data=f"foul2_{match_id}")],
[InlineKeyboardButton(text="Аут команды 1",
callback_data=f"out1_{match_id}"),
InlineKeyboardButton(text="Аут команды 2",
callback_data=f"out2_{match_id}")],
[InlineKeyboardButton(text="Удар от ворот 1",
callback_data=f"goalkick1_{match_id}"),
InlineKeyboardButton(text="Удар от ворот 2",
callback_data=f"goalkick2_{match_id}")],
[InlineKeyboardButton(text="Угловой команды 1",
callback_data=f"corner1_{match_id}"),
InlineKeyboardButton(text="Угловой команды 2",
callback_data=f"corner2_{match_id}")],
[InlineKeyboardButton(text="Пенальти команды 1",
callback_data=f"penalty1_{match_id}"),
InlineKeyboardButton(text="Пенальти команды 2",
callback_data=f"penalty2_{match_id}")],
[InlineKeyboardButton(text="Опасная атака 1",
callback_data=f"danger1_{match_id}"),
InlineKeyboardButton(text="Опасная атака 2",
callback_data=f"danger2_{match_id}")],
[InlineKeyboardButton(text="Желтая карточка 1",
callback_data=f"yellow1_{match_id}"),
 InlineKeyboardButton(text="Желтая карточка 2",
callback_data=f"yellow2_{match_id}")],
[InlineKeyboardButton(text="Красная карточка 1",
callback_data=f"red1_{match_id}"),
InlineKeyboardButton(text="Красная карточка 2",
callback_data=f"red2_{match_id}")],
[InlineKeyboardButton(text="Назад", callback_data=f"back_{match_id}")]
]
)

def penalty_outcome_keyboard(match_id, team):

return InlineKeyboardMarkup(
inline_keyboard=[
[InlineKeyboardButton(text="Гол забит",
callback_data=f"penalty_goal_{match_id}_{team}"),
InlineKeyboardButton(text="Гол не забит",
callback_data=f"penalty_miss_{match_id}_{team}")]
]
)

def extended_bet_options_keyboard(match_id):
return InlineKeyboardMarkup(
inline_keyboard=[
[InlineKeyboardButton(text="Победа команды 1",
callback_data=f"bet_win1_{match_id}"),
InlineKeyboardButton(text="Ничья",
callback_data=f"bet_draw_{match_id}"),
InlineKeyboardButton(text="Победа команды 2",
callback_data=f"bet_win2_{match_id}")],
[InlineKeyboardButton(text="Тотал больше",
callback_data=f"bet_over_{match_id}"),
InlineKeyboardButton(text="Тотал меньше",
callback_data=f"bet_under_{match_id}")],
[InlineKeyboardButton(text="Обе забьют: Да",
callback_data=f"bet_both_yes_{match_id}"),
InlineKeyboardButton(text="Обе забьют: Нет",
callback_data=f"bet_both_no_{match_id}")],
[InlineKeyboardButton(text="Дополнительные ставки",
callback_data=f"bet_extended_{match_id}")]
]
)

def extended_stats_bet_keyboard(match_id):
return InlineKeyboardMarkup(
inline_keyboard=[
[InlineKeyboardButton(text="Общее кол-во фолов",
callback_data=f"bet_total_fouls_{match_id}"),
InlineKeyboardButton(text="Общее кол-во угловых",
callback_data=f"bet_total_corners_{match_id}")],
[InlineKeyboardButton(text="Общее кол-во жёлтых карточек",
callback_data=f"bet_total_yellows_{match_id}"),
InlineKeyboardButton(text="Общее кол-во красных карточек",
callback_data=f"bet_total_reds_{match_id}")],
[InlineKeyboardButton(text="Назад",
callback_data=f"bet_back_{match_id}")]
]
)

# ===== UTILITY FUNCTIONS =====

def get_active_matches():
"""Get all active matches"""
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT id, team1, team2 FROM matches WHERE published = 1 AND
completed = 0")
matches = [Link]()
[Link]()
return matches

# Implement send_admin_control_panel function

async def send_admin_control_panel(bot: Bot, match_id: int, team1: str, team2:
str):
try:
await bot.send_message(
ADMIN_CHAT_ID,
f"⚙️ Панель управления матчем #{match_id}\n"
f"{team1} vs {team2}\n"
"Выберите действие:",
reply_markup=control_panel_keyboard(match_id)
)
except Exception as e:
print(f"Error sending control panel: {e}")
def freebet_keyboard():
return InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="🎁 Получить фрибет",
callback_data="claim_freebet")]
])
# ===== STATE MACHINES =====
class AdminStates(StatesGroup):
AUTHENTICATION = State()
GAME_SELECTION = State()
MATCH_ACTION = State()
TEAMS = State()
WIN_ODDS = State()
TOTAL_GOALS = State()
TOTAL_ODDS = State()
BOTH_TEAMS_SCORE_ODDS = State()
FOULS_TOTAL = State()
FOULS_ODDS = State()
CORNERS_TOTAL = State()
CORNERS_ODDS = State()
YELLOW_CARDS_TOTAL = State()
YELLOW_CARDS_ODDS = State()
RED_CARDS_TOTAL = State()
RED_CARDS_ODDS = State()
START_TIME = State()
CONFIRMATION = State()

class UserBetStates(StatesGroup):
SELECT_BET_TYPE = State()
ENTER_AMOUNT = State()
EXTENDED_BET = State()

# ===== ROUTER SETUP =====

router = Router() # This must be defined before handlers

# ===== HANDLERS =====

# User handlers (unchanged from previous version)
@[Link](Command("start"))
async def start_handler(message: Message):
user_id = message.from_user.id
username = message.from_user.username or message.from_user.first_name
create_user_if_not_exists(user_id, username)

# Get current balance from DB

balance = get_user_balance(user_id)

await [Link](
f"🎉 Привет, {username}! Добро пожаловать в BetBot! 🎉\n"
f"Ваш баланс: {balance} BC\n"
"Получите фрибет в разделе 'Баланс'",
reply_markup=main_keyboard()
)
@[Link](Command("matches"))
async def matches_command_handler(message: Message):
await active_matches_handler(message)

@[Link]([Link] == "Актуальные матчи")

async def active_matches_handler(message: Message):
# Direct database query without using problematic function
conn = [Link]('[Link]')
c = [Link]()

try:
# Use the new status-based system directly
[Link]("SELECT id, team1, team2 FROM matches WHERE status IN
('scheduled', 'in_progress')")
matches = [Link]()

if not matches:
await [Link]("ℹ️ Сейчас нет активных матчей для ставок.")
return

keyboard = InlineKeyboardMarkup(inline_keyboard=[])
for match in matches:
match_id = match[0]
team1 = match[1]
team2 = match[2]

if str(message.from_user.id) == ADMIN_CHAT_ID:
button = InlineKeyboardButton(
text=f"{team1} vs {team2} (ID: {match_id})",
callback_data=f"admin_panel_{match_id}"
)
else:
button = InlineKeyboardButton(
text=f"{team1} vs {team2}",
callback_data=f"match_detail_{match_id}"
)
keyboard.inline_keyboard.append([button])
 await [Link]("⚽ Активные матчи:", reply_markup=keyboard)

except [Link] as e:
# Handle potential schema issues gracefully
await [Link]("⚠️ Временная проблема с отображением матчей.
Пожалуйста, попробуйте позже.")
print(f"Database error: {str(e)}")
finally:
[Link]()

@[Link]([Link] == "Баланс")
async def balance_handler(message: Message):
user_id = message.from_user.id
user = get_user(user_id)

if not user:
await [Link]("❌ Пользователь не найден")
return

response = (
f"💰 Ваш баланс: {user[3]} BC\n"
f"💳 Минимальная ставка: {MIN_BET} BC\n"
f"💵 Максимальная ставка: {MAX_BET} BC"
)

# Check if freebet has been used (index 4 is freebet_used)

if not user[4]:
await [Link](response, reply_markup=freebet_keyboard())
else:
await [Link](response)

@router.callback_query([Link] == "claim_freebet")
async def claim_freebet_handler(callback: [Link]):
user_id = callback.from_user.id
if not get_user(user_id):
await [Link]("❌ Пользователь не найден")
return

freebet_amount = [Link](FREE_BET_MIN, FREE_BET_MAX)

update_user_balance(user_id, freebet_amount)
set_freebet_used(user_id) # Mark freebet as used

await [Link](f"🎉 Вы получили фрибет на {freebet_amount} BC!")

await [Link](f"💰 Ваш баланс теперь:
{get_user_balance(user_id)} BC")

# Add helper functions for freebet

def set_freebet_used(user_id):
conn = [Link]('[Link]')
c = [Link]()
[Link]("UPDATE users SET freebet_used = 1 WHERE user_id = ?", (user_id,))
[Link]()
[Link]()

@[Link]([Link] == "Актуальные матчи")

async def active_matches_handler(message: Message):
matches = get_active_matches()

if not matches:
await [Link]("ℹ️ Сейчас нет активных матчей для ставок.")
return

keyboard = InlineKeyboardMarkup(inline_keyboard=[])
for match in matches:
match_id = match[0] # First column is ID
team1 = match[1] # Second column is team1
team2 = match[2] # Third column is team2

if str(message.from_user.id) == ADMIN_CHAT_ID:
button = InlineKeyboardButton(
text=f"{team1} vs {team2} (ID: {match_id})",
callback_data=f"admin_panel_{match_id}"
)
else:
button = InlineKeyboardButton(
text=f"{team1} vs {team2}",
callback_data=f"match_detail_{match_id}"
)
keyboard.inline_keyboard.append([button])

await [Link]("⚽ Активные матчи:", reply_markup=keyboard)

@router.callback_query([Link]("match_detail_"))
async def match_detail_handler(callback: [Link]):
match_id = int([Link]("_")[2])
match = get_match(match_id)

if not match:
await [Link]("❌ Матч не найден!")
return [Link]()

# Format match details

status = "🚨 МАТЧ В ПРЯМОМ ЭФИРЕ! 🚨" if match[14] else "🕒 Матч еще не начался"
score = f"Текущий счет: {match[2]} {match[16]}-{match[17]} {match[3]}\n" if
match[14] else ""

details = (
f" Матч: {match[2]} vs {match[3]}\n"
f"🎮 Игра: {match[1]}\n"
f"⏰ Начало: {match[12]}\n"
f"{status}\n"
f"{score}\n"
f"📊 Коэффициенты:\n"
f" Победа {match[2]}: {match[4]}\n"
f" Ничья: {match[5]}\n"
f" Победа {match[3]}: {match[6]}\n"
f" Тотал больше {match[7]}: {match[8]}\n"
f" Тотал меньше {match[7]}: {match[9]}\n"
f" Обе забьют: Да - {match[10]}, Нет - {match[11]}"
)

# Add bet options if match hasn't started

if not match[14]:
 keyboard = bet_options_keyboard(match_id)
await [Link](details, reply_markup=keyboard)
else:
await [Link](details)

await [Link]()

@router.callback_query([Link]("bet_"))
async def bet_selection_handler(callback: [Link], state: FSMContext):
data = [Link]("_")
bet_type = data[1]
match_id = int(data[2])

# Get match details

match = get_match(match_id)
if not match:
await [Link]("❌ Матч не найден!")
return [Link]()

# Get odds based on bet type

bet_type_names = {
"win1": f"Победа {match[2]}",
"draw": "Ничья",
"win2": f"Победа {match[3]}",
"over": f"Тотал больше {match[7]}",
"under": f"Тотал меньше {match[7]}",
"both_yes": "Обе забьют: Да",
"both_no": "Обе забьют: Нет"
}

odds = {
"win1": match[4],
"draw": match[5],
"win2": match[6],
"over": match[8],
"under": match[9],
"both_yes": match[10],
"both_no": match[11]
}[bet_type]

# Save bet selection in state

await state.update_data(
match_id=match_id,
bet_type=bet_type,
bet_name=bet_type_names[bet_type],
odds=odds
)
await state.set_state(UserBetStates.ENTER_AMOUNT)

await [Link](
f"➡️ Вы выбрали: {bet_type_names[bet_type]}\n"
f"📈 Коэффициент: {odds}\n"
f"💳 Введите сумму ставки (от {MIN_BET} до {MAX_BET} BC):"
)
await [Link]()

@[Link](UserBetStates.ENTER_AMOUNT)
async def process_bet_amount(message: Message, state: FSMContext):
try:
amount = int([Link])
if amount < MIN_BET or amount > MAX_BET:
await [Link](f"❌ Сумма должна быть от {MIN_BET} до {MAX_BET}
BC!")
return

# Get user balance

user = get_user(message.from_user.id)
if not user:
await [Link]("❌ Пользователь не найден!")
return await [Link]()

if amount > user[3]:

await [Link]("❌ Недостаточно средств на балансе!")
return await [Link]()

# Get bet data from state

data = await state.get_data()

# Place bet
place_bet(
user_id=message.from_user.id,
match_id=data['match_id'],
bet_type=data['bet_type'],
amount=amount,
odds=data['odds']
)

# Update user balance

update_balance(message.from_user.id, -amount)

await [Link](
f"✅ Ставка принята!\n"
f"⚽ Матч: {get_match(data['match_id'])[2]} vs
{get_match(data['match_id'])[3]}\n"
f"📊 Ваша ставка: {data['bet_name']}\n"
f"💰 Сумма: {amount} BC\n"
f"📈 Коэффициент: {data['odds']}\n\n"
f"💵 Ваш новый баланс: {user[3] - amount} BC",
reply_markup=main_keyboard()
)

await [Link]()
except ValueError:
await [Link]("❌ Пожалуйста, введите число!")

# Admin authentication and game selection (unchanged)

@[Link](Command("admin"))
async def admin_start(message: Message, state: FSMContext):
await state.set_state([Link])
await [Link]("🔒 Введите пароль админа:")

@[Link]([Link])
async def authenticate(message: Message, state: FSMContext):
 if [Link] == ADMIN_PASSWORD:
await state.set_state(AdminStates.GAME_SELECTION)
await [Link](
"🎮 Выберите игру:",
reply_markup=game_selection_keyboard()
)
else:
await [Link]("❌ Неверный пароль. Попробуйте снова.")

@[Link](AdminStates.GAME_SELECTION)
async def game_selected(message: Message, state: FSMContext):
if [Link] in ["FC25", "CS2", "Другое"]:
await state.update_data(game_type=[Link])
await state.set_state(AdminStates.MATCH_ACTION)
await [Link](
"⚽ Что вы хотите сделать?",
reply_markup=match_action_keyboard()
)
else:
await [Link]("❌ Пожалуйста, выберите игру из списка")

# New match creation handlers

@[Link](AdminStates.MATCH_ACTION, [Link] == "Создать новый матч")
async def create_new_match(message: Message, state: FSMContext):
await state.set_state([Link])
await [Link](
"🏁 Введите названия команд (формат: Команда1, Команда2):",
reply_markup=[Link]()
)

@[Link]([Link])
async def process_teams(message: Message, state: FSMContext):
teams = [Link](',')
if len(teams) != 2:
await [Link]("❌ Неверный формат. Введите две команды через
запятую.")
return

team1 = teams[0].strip()
team2 = teams[1].strip()
await state.update_data(team1=team1, team2=team2)
await state.set_state(AdminStates.WIN_ODDS)
await [Link](
f"📊 Введите коэффициенты на победу (формат: Победа {team1}, Ничья, Победа
{team2}):"
)

@[Link](AdminStates.WIN_ODDS)
async def process_win_odds(message: Message, state: FSMContext):
odds = [Link](',')
if len(odds) != 3:
await [Link]("❌ Неверный формат. Введите три коэффициента через
запятую.")
return
 try:
win1_odds = float(odds[0].strip())
draw_odds = float(odds[1].strip())
win2_odds = float(odds[2].strip())
except ValueError:
await [Link]("❌ Неверный формат коэффициентов. Используйте числа.")
return

await state.update_data(win1_odds=win1_odds, draw_odds=draw_odds,

win2_odds=win2_odds)
await state.set_state(AdminStates.TOTAL_GOALS)
await [Link]("⚽ Введите тотал голов (например: 2.5):")

@[Link](AdminStates.TOTAL_GOALS)
async def process_total_goals(message: Message, state: FSMContext):
try:
total_goals = float([Link])
except ValueError:
await [Link]("❌ Неверный формат. Введите число (например: 2.5).")
return

await state.update_data(total_goals=total_goals)
await state.set_state(AdminStates.TOTAL_ODDS)
await [Link]("📊 Введите коэффициенты на тотал (формат: Тотал больше,
Тотал меньше):")

@[Link](AdminStates.TOTAL_ODDS)
async def process_total_odds(message: Message, state: FSMContext):
odds = [Link](',')
if len(odds) != 2:
await [Link]("❌ Неверный формат. Введите два коэффициента через
запятую.")
return

try:
over_odds = float(odds[0].strip())
under_odds = float(odds[1].strip())
except ValueError:
await [Link]("❌ Неверный формат коэффициентов. Используйте числа.")
return

await state.update_data(over_odds=over_odds, under_odds=under_odds)

await state.set_state(AdminStates.BOTH_TEAMS_SCORE_ODDS)
await [Link]("⚽ Введите коэффициенты на 'Обе забьют' (формат: Да,
Нет):")

# Enhanced match creation with extended bets

@[Link](AdminStates.BOTH_TEAMS_SCORE_ODDS)
async def process_both_teams_odds(message: Message, state: FSMContext):
odds = [Link](',')
if len(odds) != 2:
await [Link]("❌ Неверный формат. Введите два коэффициента через
запятую.")
return

try:
 both_yes_odds = float(odds[0].strip())
both_no_odds = float(odds[1].strip())
except ValueError:
await [Link]("❌ Неверный формат коэффициентов. Используйте числа.")
return

await state.update_data(both_yes_odds=both_yes_odds, both_no_odds=both_no_odds)

await state.set_state(AdminStates.FOULS_TOTAL)
await [Link]("⚖️ Введите тотал фолов (например: 25.5):")

@[Link](AdminStates.FOULS_TOTAL)
async def process_fouls_total(message: Message, state: FSMContext):
try:
fouls_total = float([Link])
except ValueError:
await [Link]("❌ Неверный формат. Введите число (например: 25.5).")
return

await state.update_data(fouls_total=fouls_total)
await state.set_state(AdminStates.FOULS_ODDS)
await [Link]("📊 Введите коэффициенты на тотал фолов (формат: Тотал
больше, Тотал меньше):")

@[Link](AdminStates.FOULS_ODDS)
async def process_fouls_odds(message: Message, state: FSMContext):
odds = [Link](',')
if len(odds) != 2:
await [Link]("❌ Неверный формат. Введите два коэффициента через
запятую.")
return

try:
fouls_over_odds = float(odds[0].strip())
fouls_under_odds = float(odds[1].strip())
except ValueError:
await [Link]("❌ Неверный формат коэффициентов. Используйте числа.")
return

await state.update_data(fouls_over_odds=fouls_over_odds,
fouls_under_odds=fouls_under_odds)
await state.set_state(AdminStates.CORNERS_TOTAL)
await [Link]("↗️ Введите тотал угловых (например: 10.5):")

@[Link](AdminStates.CORNERS_TOTAL)
async def process_corners_total(message: Message, state: FSMContext):
try:
corners_total = float([Link])
except ValueError:
await [Link]("❌ Неверный формат. Введите число (например: 10.5).")
return

await state.update_data(corners_total=corners_total)
await state.set_state(AdminStates.CORNERS_ODDS)
await [Link]("📊 Введите коэффициенты на тотал угловых (формат: Тотал
больше, Тотал меньше):")
@[Link](AdminStates.CORNERS_ODDS)
async def process_corners_odds(message: Message, state: FSMContext):
odds = [Link](',')
if len(odds) != 2:
await [Link]("❌ Неверный формат. Введите два коэффициента через
запятую.")
return

try:
corners_over_odds = float(odds[0].strip())
corners_under_odds = float(odds[1].strip())
except ValueError:
await [Link]("❌ Неверный формат коэффициентов. Используйте числа.")
return

await state.update_data(corners_over_odds=corners_over_odds,
corners_under_odds=corners_under_odds)
await state.set_state(AdminStates.YELLOW_CARDS_TOTAL)
await [Link]("🟨 Введите тотал желтых карточек (например: 4.5):")

@[Link](AdminStates.YELLOW_CARDS_TOTAL)
async def process_yellow_cards_total(message: Message, state: FSMContext):
try:
yellow_cards_total = float([Link])
except ValueError:
await [Link]("❌ Неверный формат. Введите число (например: 4.5).")
return

await state.update_data(yellow_cards_total=yellow_cards_total)
await state.set_state(AdminStates.YELLOW_CARDS_ODDS)
await [Link]("📊 Введите коэффициенты на тотал желтых карточек (формат:
Тотал больше, Тотал меньше):")

@[Link](AdminStates.YELLOW_CARDS_ODDS)
async def process_yellow_cards_odds(message: Message, state: FSMContext):
odds = [Link](',')
if len(odds) != 2:
await [Link]("❌ Неверный формат. Введите два коэффициента через
запятую.")
return

try:
yellow_cards_over_odds = float(odds[0].strip())
yellow_cards_under_odds = float(odds[1].strip())
except ValueError:
await [Link]("❌ Неверный формат коэффициентов. Используйте числа.")
return

await state.update_data(yellow_cards_over_odds=yellow_cards_over_odds,
yellow_cards_under_odds=yellow_cards_under_odds)
await state.set_state(AdminStates.RED_CARDS_TOTAL)
await [Link]("🟥 Введите тотал красных карточек (например: 0.5):")

@[Link](AdminStates.RED_CARDS_TOTAL)
async def process_red_cards_total(message: Message, state: FSMContext):
 try:
red_cards_total = float([Link])
except ValueError:
await [Link]("❌ Неверный формат. Введите число (например: 0.5).")
return

await state.update_data(red_cards_total=red_cards_total)
await state.set_state(AdminStates.RED_CARDS_ODDS)
await [Link]("📊 Введите коэффициенты на тотал красных карточек (формат:
Тотал больше, Тотал меньше):")

@[Link](AdminStates.RED_CARDS_ODDS)
async def process_red_cards_odds(message: Message, state: FSMContext):
odds = [Link](',')
if len(odds) != 2:
await [Link]("❌ Неверный формат. Введите два коэффициента через
запятую.")
return

try:
red_cards_over_odds = float(odds[0].strip())
red_cards_under_odds = float(odds[1].strip())
except ValueError:
await [Link]("❌ Неверный формат коэффициентов. Используйте числа.")
return

await state.update_data(red_cards_over_odds=red_cards_over_odds,
red_cards_under_odds=red_cards_under_odds)
await state.set_state(AdminStates.START_TIME)
await [Link]("⏰ Введите время начала матча (формат: ЧЧ:ММ):")

@[Link](AdminStates.START_TIME)
async def process_start_time(message: Message, state: FSMContext):
try:
# Validate time format
[Link]([Link], "%H:%M")
except ValueError:
await [Link]("❌ Неверный формат времени. Используйте ЧЧ:ММ
(например: 20:30).")
return

data = await state.get_data()

await state.update_data(start_time=[Link])

# Generate match summary with extended bets

summary = (
f" Матч: {data['team1']} vs {data['team2']}\n"
f"⏰ Старт: {[Link]}\n\n"
f"📊 Основные коэффициенты:\n"
f" Победа {data['team1']}: {data['win1_odds']}\n"
f" Ничья: {data['draw_odds']}\n"
f" Победа {data['team2']}: {data['win2_odds']}\n"
f" Тотал больше {data['total_goals']}: {data['over_odds']}\n"
f" Тотал меньше {data['total_goals']}: {data['under_odds']}\n"
f" Обе забьют: Да - {data['both_yes_odds']}, Нет - {data['both_no_odds']}\
n\n"
f"📈 Дополнительные ставки:\n"
 f" Фолы: Тотал {data['fouls_total']} | Больше: {data['fouls_over_odds']} |
Меньше: {data['fouls_under_odds']}\n"
f" Угловые: Тотал {data['corners_total']} | Больше:
{data['corners_over_odds']} | Меньше: {data['corners_under_odds']}\n"
f" Желтые карточки: Тотал {data['yellow_cards_total']} | Больше:
{data['yellow_cards_over_odds']} | Меньше: {data['yellow_cards_under_odds']}\n"
f" Красные карточки: Тотал {data['red_cards_total']} | Больше:
{data['red_cards_over_odds']} | Меньше: {data['red_cards_under_odds']}\n\n"
"✅ Все верно? Опубликовать матч?"
)

await state.set_state([Link])
await [Link](summary, reply_markup=confirmation_keyboard())

@[Link]([Link], [Link].in_(["Да, опубликовать", "Нет,

отменить"]))
async def process_confirmation(message: Message, state: FSMContext):
if [Link] == "Нет, отменить":
await [Link]()
await [Link]("❌ Создание матча отменено.",
reply_markup=main_keyboard())
return

try:
data = await state.get_data()
# Create match with status 'scheduled' by default
match_id = create_match(
data['game_type'],
data['team1'],
data['team2'],
data['win1_odds'],
data['draw_odds'],
data['win2_odds'],
data['total_goals'],
data['over_odds'],
data['under_odds'],
data['both_yes_odds'],
data['both_no_odds'],
data['total_fouls'],
data['over_fouls_odds'],
data['under_fouls_odds'],
data['total_corners'],
data['over_corners_odds'],
data['under_corners_odds'],
data['total_yellows'],
data['over_yellows_odds'],
data['under_yellows_odds'],
data['total_reds'],
data['over_reds_odds'],
data['under_reds_odds'],
data['start_time']
)

# Create match statistics

create_match_stats(match_id)

await [Link]()
await [Link]("✅ Матч успешно создан и опубликован!",
reply_markup=main_keyboard())

# Notify admin with control panel

team1 = data['team1']
team2 = data['team2']
keyboard = control_panel_keyboard(match_id, team1, team2)
await [Link](
f" Матч: {team1} vs {team2}\n"
"Панель управления:",
reply_markup=keyboard
)

# Broadcast new match to users

await broadcast_new_match(match_id, team1, team2, data['start_time'])

except Exception as e:
await [Link](f"❌ Ошибка при создании матча: {str(e)}")
print(f"Match creation error: {str(e)}")

# Match management commands

@[Link](Command("event"))
async def event_handler(message: Message):
matches = get_all_matches()

if not matches:
await [Link]("ℹ️ Нет доступных матчей.")
return

response = "📋 Список всех матчей:\n\n"

for match in matches:
status = "Опубликован" if match[13] else "Черновик"
response += f"ID: {match[0]} - {match[2]} vs {match[3]} ({status})\n"

response += "\nДля управления матчем введите /control [ID]"

await [Link](response)

@[Link](Command("control"))
async def control_handler(message: Message):
try:
match_id = int([Link]()[1])
match = get_match(match_id)

if not match:
await [Link]("❌ Матч с таким ID не найден.")
return

await [Link](
f"⚽ Управление матчем ID: {match_id}\n"
f"{match[2]} vs {match[3]}",
reply_markup=match_control_keyboard(match_id)
)
except (IndexError, ValueError):
await [Link]("❌ Неверный формат. Используйте: /control [ID матча]")

@router.callback_query([Link]("start_"))
async def start_match_callback(callback: [Link]):
 match_id = int([Link]("_")[-1])
start_match(match_id)
match = get_match(match_id)
# Check current match status
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT status FROM matches WHERE id = ?", (match_id,))
status = [Link]()

if not status:
await [Link]("Матч не найден")
return

if status[0] != 'scheduled':
await [Link]("⚠️ Матч уже начат или завершен!")
return

# Update status to 'in_progress'

[Link]("UPDATE matches SET status = 'in_progress' WHERE id = ?",
(match_id,))
[Link]()
[Link]()
# Notify all users
await [Link].send_message(
chat_id=[Link],
text=f"🚩 МАТЧ НАЧАЛСЯ!\n{match[2]} vs {match[3]}"
)
await [Link]()

@router.callback_query([Link]("goal_1_"))
async def goal1_callback(callback: [Link]):
match_id = int([Link]("_")[-1])
record_goal(match_id, 1)
match = get_match(match_id)

# Update all users

await [Link].send_message(
chat_id=[Link],
text=f"⚽ ГОООЛ! {match[2]} забивает!\nТекущий счет: {match[2]} {match[16]}-
{match[17]} {match[3]}"
)
await [Link]()

@router.callback_query([Link]("goal_2_"))
async def goal2_callback(callback: [Link]):
match_id = int([Link]("_")[-1])
record_goal(match_id, 2)
match = get_match(match_id)

# Update all users

await [Link].send_message(
chat_id=[Link],
text=f"⚽ ГОООЛ! {match[3]} забивает!\nТекущий счет: {match[2]} {match[16]}-
{match[17]} {match[3]}"
)
await [Link]()
@router.callback_query([Link]("end_"))
async def end_match_callback(callback: [Link]):
match_id = int([Link]("_")[1])
complete_match(match_id)
match = get_match(match_id)
# Check current match status
conn = [Link]('[Link]')
c = [Link]()
[Link]("SELECT status FROM matches WHERE id = ?", (match_id,))
status = [Link]()

if not status:
await [Link]("Матч не найден")
return

if status[0] != 'in_progress':
await [Link]("⚠️ Матч не начат или уже завершен!")
return

# Update status to 'ended'

[Link]("UPDATE matches SET status = 'ended' WHERE id = ?", (match_id,))
[Link]()
[Link]()
# Determine match outcome
team1 = match[2]
team2 = match[3]
score1 = match[16]
score2 = match[17]

if score1 > score2:

winner = team1
outcome = "win1"
elif score2 > score1:
winner = team2
outcome = "win2"
else:
winner = "Ничья"
outcome = "draw"

# Calculate total goals

total_goals = score1 + score2
total_line = match[7]

# Determine both teams scored

both_scored = "Да" if score1 > 0 and score2 > 0 else "Нет"

# Prepare match summary

summary = (
f"🏁 МАТЧ ЗАВЕРШЕН!\n"
f"⚽ {team1} {score1}-{score2} {team2}\n"
f"🏆 Победитель: {winner}\n"
f"🎯 Всего голов: {total_goals}\n"
f"👥 Обе команды забили: {both_scored}"
)

# Send summary to all users

await [Link].send_message(
chat_id=[Link],
 text=summary
)

# Process bets and notify users

await process_bets(match_id, outcome, total_goals, both_scored, [Link])

await [Link]()

async def process_bets(match_id, outcome, total_goals, both_scored, bot):

bets = get_match_bets(match_id)
match = get_match(match_id)

for bet in bets:

user_id = bet[1]
bet_type = bet[3]
amount = bet[4]
odds = bet[5]

# Determine if bet won

won = False

if bet_type == "win1" and outcome == "win1":

won = True
elif bet_type == "win2" and outcome == "win2":
won = True
elif bet_type == "draw" and outcome == "draw":
won = True
elif bet_type == "over" and total_goals > match[7]:
won = True
elif bet_type == "under" and total_goals < match[7]:
won = True
elif bet_type == "both_yes" and both_scored == "Да":
won = True
elif bet_type == "both_no" and both_scored == "Нет":
won = True

# Update bet status

update_bet_result(bet[0], won)

# Prepare message for user

if won:
winnings = int(amount * odds)
update_balance(user_id, winnings)
message = (
f"🎉 Ура, ваша ставка сыграла!\n"
f"💰 Вы выиграли: {winnings} BC\n"
f"💵 Ваш новый баланс: {get_user(user_id)[3]} BC"
)
else:
message = "😢 Ваша ставка не сыграла, в следующий раз повезет"

# Send notification to user

await bot.send_message(chat_id=user_id, text=message)

@router.callback_query([Link]("control_"))
async def control_handler(callback: [Link]):
match_id = int([Link]("_")[1])
 match = get_match(match_id)

if not match:
await [Link]("❌ Матч с таким ID не найден.")
return await [Link]()

if match[14]: # If match started

await [Link](
f"⚽ Управление матчем ID: {match_id}\n"
f"{match[2]} vs {match[3]}",
reply_markup=advanced_match_control_keyboard(match_id)
)
else:
await [Link](
f"⚽ Управление матчем ID: {match_id}\n"
f"{match[2]} vs {match[3]}",
reply_markup=match_control_keyboard(match_id)
)

await [Link]()

# Advanced event handlers

@router.callback_query([Link]("foul"))
async def foul_handler(callback: [Link]):
data = [Link]("_")
team = int(data[0][-1]) # foul1 or foul2
match_id = int(data[1])

update_match_stats(match_id, "fouls", team)

match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](f"⚖️ Фол! Нарушение правил командой {team_name}")

await [Link]()

@router.callback_query([Link]("out"))
async def out_handler(callback: [Link]):
data = [Link]("_")
team = int(data[0][-1]) # out1 or out2
match_id = int(data[1])

update_match_stats(match_id, "corners", team) # Out often leads to corner

match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](f"↗️ Аут! Мяч ушел за пределы поля от команды

{team_name}")
await [Link]()

@router.callback_query([Link]("goalkick"))
async def goal_kick_handler(callback: [Link]):
data = [Link]("_")
team = int(data[0][-1]) # goalkick1 or goalkick2
match_id = int(data[1])

update_match_stats(match_id, "goal_kicks", team)

 match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](f"🥅 Удар от ворот! {team_name} наносит удар, но

мяч пролетает мимо створа")
await [Link]()

@router.callback_query([Link]("corner"))
async def corner_handler(callback: [Link]):
data = [Link]("_")
team = int(data[0][-1]) # corner1 or corner2
match_id = int(data[1])

update_match_stats(match_id, "corners", team)

match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](f"↗️ Угловой! Подает команда {team_name}")

await [Link]()

@router.callback_query([Link]("penalty"))
async def penalty_handler(callback: [Link]):
data = [Link]("_")
team = int(data[0][-1]) # penalty1 or penalty2
match_id = int(data[1])
match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](
f"‼️Пенальти! Команде {team_name} назначен 11-метровый удар",
reply_markup=penalty_outcome_keyboard(match_id, team)
)
await [Link]()

@router.callback_query([Link]("penalty_goal_"))
async def penalty_goal_handler(callback: [Link]):
data = [Link]("_")
match_id = int(data[3])
team = int(data[4])
record_goal(match_id, team, penalty=True)
match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](f"⚽ ГОООООЛ! {team_name} забивает гол с

пенальти!")
await [Link]()

@router.callback_query([Link]("penalty_miss_"))
async def penalty_miss_handler(callback: [Link]):
data = [Link]("_")
match_id = int(data[3])
team = int(data[4])
match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]
 await [Link](f"😱 {team_name} не реализует пенальти! Эх, а
такая возможность была!")
await [Link]()

@router.callback_query([Link]("danger"))
async def dangerous_attack_handler(callback: [Link]):
data = [Link]("_")
team = int(data[0][-1]) # danger1 or danger2
match_id = int(data[1])
update_match_stats(match_id, "dangerous_attacks", team)
match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](f"🔥 Опасная атака! Команда {team_name} создает

угрозу у ворот соперника")
await [Link]()

@router.callback_query([Link]("yellow"))
async def yellow_card_handler(callback: [Link]):
data = [Link]("_")
team = int(data[0][-1]) # yellow1 or yellow2
match_id = int(data[1])
update_match_stats(match_id, "yellow_cards", team)
match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](f"🟨 Желтая карточка! Игрок команды {team_name}

получает горчичник")
await [Link]()

@router.callback_query([Link]("red"))
async def red_card_handler(callback: [Link]):
data = [Link]("_")
team = int(data[0][-1]) # red1 or red2
match_id = int(data[1])
update_match_stats(match_id, "red_cards", team)
match = get_match(match_id)
team_name = match[2] if team == 1 else match[3]

await [Link](f"🟥 Красная карточка! Игрок команды {team_name}

удален с поля!")
await [Link]()

@router.callback_query([Link]("back_"))
async def back_handler(callback: [Link]):
match_id = int([Link]("_")[1])
match = get_match(match_id)

await [Link](
f"⚽ Управление матчем ID: {match_id}\n"
f"{match[2]} vs {match[3]}",
reply_markup=match_control_keyboard(match_id)
)
await [Link]()
# Extended bet handlers
@router.callback_query([Link]("bet_extended_"))
async def extended_bet_handler(callback: [Link]):
match_id = int([Link]("_")[2])

await [Link](
"📊 Выберите тип дополнительной ставки:",
reply_markup=extended_stats_bet_keyboard(match_id)
)
await [Link]()

@router.callback_query([Link]("bet_total_"))
async def total_stat_bet_handler(callback: [Link], state: FSMContext):
data = [Link]("_")
stat_type = data[2] # fouls, corners, yellows, reds
match_id = int(data[3])

stat_names = {
"fouls": "общее количество фолов",
"corners": "общее количество угловых",
"yellows": "общее количество желтых карточек",
"reds": "общее количество красных карточек"
}

await state.update_data(
match_id=match_id,
bet_type=f"total_{stat_type}",
bet_name=f"Общее кол-во {stat_names[stat_type]}"
)
await state.set_state(UserBetStates.EXTENDED_BET)

await [Link](
f"➡️ Вы выбрали: Общее кол-во {stat_names[stat_type]}\n"
f"📊 Введите тотал (например: 10.5):"
)
await [Link]()

@[Link](UserBetStates.EXTENDED_BET)
async def process_extended_bet(message: Message, state: FSMContext):
try:
total_line = float([Link])
data = await state.get_data()
await state.update_data(total_line=total_line)

await [Link](
f"📊 Введите коэффициент для тотала {total_line}:"
)
await state.set_state(UserBetStates.ENTER_AMOUNT)
except ValueError:
await [Link]("❌ Пожалуйста, введите число!")

# Update match detail handler to show extended stats

@router.callback_query([Link]("match_detail_"))
async def match_detail_handler(callback: [Link]):
match_id = int([Link]("_")[-1])
 match = get_match(match_id)

if not match:
await [Link]("Матч не найден")
return

# Extract match details using correct indices

team1 = match[2] # team1 is at index 2
team2 = match[3] # team2 is at index 3
start_time = match[24] # start_time is at index 24

# Build detailed match view

details = (
f"⚽ Матч: {team1} vs {team2}\n"
f"⏰ Начало: {start_time}\n"
f"📊 Основные коэффициенты:\n"
f" Победа {team1}: {match[4]}\n"
f" Ничья: {match[5]}\n"
f" Победа {team2}: {match[6]}\n"
f" Тотал больше {match[7]}: {match[8]}\n"
f" Тотал меньше {match[7]}: {match[9]}\n"
f" Обе забьют: Да - {match[10]}, Нет - {match[11]}\n\n"
f"📈 Дополнительные ставки:\n"
f" Фолы: Тотал {match[12]} | >: {match[13]} | <: {match[14]}\n"
f" Угловые: Тотал {match[15]} | >: {match[16]} | <: {match[17]}\n"
f" Желтые карточки: Тотал {match[18]} | >: {match[19]} | <: {match[20]}\n"
f" Красные карточки: Тотал {match[21]} | >: {match[22]} | <: {match[23]}\
n\n"
"💵 Выберите тип ставки:"
)

await [Link](details,
reply_markup=bet_options_keyboard(match_id))

# Update create_match function to include extended bets

def create_match(
game_type, team1, team2,
win1_odds, draw_odds, win2_odds,
total_goals, over_goals_odds, under_goals_odds, # Corrected parameter names
both_yes_odds, both_no_odds,
total_fouls, over_fouls_odds, under_fouls_odds,
total_corners, over_corners_odds, under_corners_odds,
total_yellows, over_yellows_odds, under_yellows_odds,
total_reds, over_reds_odds, under_reds_odds,
start_time
):
conn = [Link]('[Link]')
c = [Link]()
[Link]('''
INSERT INTO matches (
game_type, team1, team2,
win1_odds, draw_odds, win2_odds,
total_goals, over_goals_odds, under_goals_odds,
both_yes_odds, both_no_odds,
total_fouls, over_fouls_odds, under_fouls_odds,
total_corners, over_corners_odds, under_corners_odds,
total_yellows, over_yellows_odds, under_yellows_odds,
total_reds, over_reds_odds, under_reds_odds,
start_time
 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
?, ?)
''', (
game_type, team1, team2,
win1_odds, draw_odds, win2_odds,
total_goals, over_goals_odds, under_goals_odds,
both_yes_odds, both_no_odds,
total_fouls, over_fouls_odds, under_fouls_odds,
total_corners, over_corners_odds, under_corners_odds,
total_yellows, over_yellows_odds, under_yellows_odds,
total_reds, over_reds_odds, under_reds_odds,
start_time
))
match_id = [Link]
[Link]()
[Link]()
return match_id

# ===== MAIN FUNCTION =====

async def main():
# Initialize database
init_db()

# Initialize bot
bot = Bot(token=BOT_TOKEN)
storage = MemoryStorage()
dp = Dispatcher(storage=storage)
dp.include_router(router)

# Start polling
await dp.start_polling(bot)

if __name__ == "__main__":
[Link](main())