bot.py

import asyncio
import logging
import os
import re
import textwrap
from datetime import datetime, timedelta, timezone
from typing import Optional, List, Dict, Any

import aiosqlite
from aiogram import Bot, Dispatcher, types
from aiogram.filters import Command, CommandStart
from aiogram.types import (
    InlineKeyboardMarkup,
    InlineKeyboardButton,
    ReplyKeyboardMarkup,
    KeyboardButton,
    ReplyKeyboardRemove,
)
from aiogram.utils.keyboard import InlineKeyboardBuilder, ReplyKeyboardBuilder

from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.date import DateTrigger

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

BOT_TOKEN = os.getenv("BOT_TOKEN")
if not BOT_TOKEN:
    raise RuntimeError("BOT_TOKEN env var is required")

ADMIN_USERNAME = "@nameofbless"

DB_PATH = os.getenv("DB_PATH", "bot.db")

# ---- PROMO / CHANNEL LOCK SETTINGS ----
# Admin will set these via /set_promo_channel command after deployment
# Stored in DB table bot_settings

# ---- AI CHAT / PROVIDERS ----
# Admin defines AI profiles with:
#  - name
#  - api_base (e.g. https://api.openai.com/v1)
#  - api_key  (stored securely in DB, not printed)
#  - model (e.g. gpt-4o-mini)
#  - system_prompt
# We implement a simple "OpenAI-compatible" /chat/completions-style call.
import aiohttp

scheduler = AsyncIOScheduler(timezone=timezone.utc)


# ============ DB INIT ============

CREATE_TABLES_SQL = """
PRAGMA journal_mode=WAL;

CREATE TABLE IF NOT EXISTS bot_settings (
    key TEXT PRIMARY KEY,
    value TEXT
);

CREATE TABLE IF NOT EXISTS users (
    user_id INTEGER PRIMARY KEY,
    username TEXT,
    first_name TEXT,
    last_name TEXT
);

-- AI profiles managed by admin
CREATE TABLE IF NOT EXISTS ai_profiles (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL UNIQUE,
    api_base TEXT NOT NULL,
    api_key TEXT NOT NULL,
    model TEXT NOT NULL,
    system_prompt TEXT NOT NULL,
    description TEXT DEFAULT '',
    active INTEGER DEFAULT 1
);

-- Conversation history (20 messages max per (user, profile))
CREATE TABLE IF NOT EXISTS ai_conversations (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL,
    profile_id INTEGER NOT NULL,
    role TEXT NOT NULL,   -- 'user' or 'assistant'
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Quiz files (text) stored by Telegram file_id
CREATE TABLE IF NOT EXISTS quiz_files (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    file_id TEXT NOT NULL,
    subject TEXT NOT NULL,
    title TEXT NOT NULL,
    added_by INTEGER NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Questions parsed from quiz_files
CREATE TABLE IF NOT EXISTS questions (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    quiz_file_id INTEGER NOT NULL,
    question TEXT NOT NULL,
    option_a TEXT NOT NULL,
    option_b TEXT NOT NULL,
    option_c TEXT NOT NULL,
    option_d TEXT NOT NULL,
    correct_option TEXT NOT NULL, -- 'A','B','C','D'
    explanation TEXT NOT NULL,
    hint TEXT DEFAULT '',
    FOREIGN KEY (quiz_file_id) REFERENCES quiz_files(id) ON DELETE CASCADE
);

-- GIF / video timer resources
CREATE TABLE IF NOT EXISTS timer_videos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    file_id TEXT NOT NULL,
    duration_seconds INTEGER NOT NULL,
    scope TEXT NOT NULL CHECK(scope IN ('single','multi','tournament')),
    label TEXT NOT NULL
);

-- Reference books (PDFs etc) by file_id
CREATE TABLE IF NOT EXISTS reference_books (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    file_id TEXT NOT NULL,
    title TEXT NOT NULL,
    added_by INTEGER NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Single-player quiz sessions
CREATE TABLE IF NOT EXISTS single_sessions (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL,
    quiz_file_id INTEGER NOT NULL,
    current_question_index INTEGER NOT NULL DEFAULT 0,
    correct_count INTEGER NOT NULL DEFAULT 0,
    total_time_seconds INTEGER NOT NULL DEFAULT 0,
    started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    ended_at TIMESTAMP,
    active INTEGER DEFAULT 1,
    timer_video_id INTEGER,
    FOREIGN KEY (quiz_file_id) REFERENCES quiz_files(id),
    FOREIGN KEY (timer_video_id) REFERENCES timer_videos(id)
);

CREATE TABLE IF NOT EXISTS single_answers (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    session_id INTEGER NOT NULL,
    question_id INTEGER NOT NULL,
    chosen_option TEXT,
    is_correct INTEGER NOT NULL DEFAULT 0,
    time_spent_seconds INTEGER NOT NULL DEFAULT 0,
    FOREIGN KEY (session_id) REFERENCES single_sessions(id),
    FOREIGN KEY (question_id) REFERENCES questions(id)
);

-- Multiplayer rooms
CREATE TABLE IF NOT EXISTS multi_rooms (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    code TEXT NOT NULL UNIQUE,
    host_user_id INTEGER NOT NULL,
    chat_id INTEGER NOT NULL,
    quiz_file_id INTEGER NOT NULL,
    timer_video_id INTEGER,
    status TEXT NOT NULL DEFAULT 'lobby', -- 'lobby','running','finished'
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    started_at TIMESTAMP,
    ended_at TIMESTAMP,
    FOREIGN KEY (quiz_file_id) REFERENCES quiz_files(id),
    FOREIGN KEY (timer_video_id) REFERENCES timer_videos(id)
);

CREATE TABLE IF NOT EXISTS multi_players (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    room_id INTEGER NOT NULL,
    user_id INTEGER NOT NULL,
    score INTEGER NOT NULL DEFAULT 0,
    total_time_seconds INTEGER NOT NULL DEFAULT 0,
    joined_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    UNIQUE(room_id, user_id),
    FOREIGN KEY (room_id) REFERENCES multi_rooms(id)
);

CREATE TABLE IF NOT EXISTS multi_answers (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    room_id INTEGER NOT NULL,
    user_id INTEGER NOT NULL,
    question_id INTEGER NOT NULL,
    chosen_option TEXT,
    is_correct INTEGER NOT NULL DEFAULT 0,
    time_spent_seconds INTEGER NOT NULL DEFAULT 0,
    FOREIGN KEY (room_id) REFERENCES multi_rooms(id),
    FOREIGN KEY (question_id) REFERENCES questions(id)
);

-- Tournament
CREATE TABLE IF NOT EXISTS tournaments (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    code TEXT NOT NULL UNIQUE,
    admin_user_id INTEGER NOT NULL,
    group_chat_id INTEGER NOT NULL,
    quiz_file_id INTEGER NOT NULL,
    timer_video_id INTEGER,
    status TEXT NOT NULL DEFAULT 'scheduled', -- 'scheduled','running','finished'
    scheduled_start TIMESTAMP NOT NULL,
    started_at TIMESTAMP,
    ended_at TIMESTAMP,
    FOREIGN KEY (quiz_file_id) REFERENCES quiz_files(id),
    FOREIGN KEY (timer_video_id) REFERENCES timer_videos(id)
);

CREATE TABLE IF NOT EXISTS tournament_players (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    tournament_id INTEGER NOT NULL,
    user_id INTEGER NOT NULL,
    score INTEGER NOT NULL DEFAULT 0,
    total_time_seconds INTEGER NOT NULL DEFAULT 0,
    joined_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    UNIQUE(tournament_id, user_id),
    FOREIGN KEY (tournament_id) REFERENCES tournaments(id)
);

CREATE TABLE IF NOT EXISTS tournament_answers (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    tournament_id INTEGER NOT NULL,
    user_id INTEGER NOT NULL,
    question_id INTEGER NOT NULL,
    chosen_option TEXT,
    is_correct INTEGER NOT NULL DEFAULT 0,
    time_spent_seconds INTEGER NOT NULL DEFAULT 0,
    FOREIGN KEY (tournament_id) REFERENCES tournaments(id),
    FOREIGN KEY (question_id) REFERENCES questions(id)
);
"""


async def init_db():
    async with aiosqlite.connect(DB_PATH) as db:
        await db.executescript(CREATE_TABLES_SQL)
        await db.commit()


# ============ HELPERS ============

async def get_db():
    return await aiosqlite.connect(DB_PATH)


def is_admin(user: types.User) -> bool:
    return user.username and f"@{user.username}" == ADMIN_USERNAME


async def get_setting(db: aiosqlite.Connection, key: str) -> Optional[str]:
    cursor = await db.execute("SELECT value FROM bot_settings WHERE key = ?", (key,))
    row = await cursor.fetchone()
    await cursor.close()
    return row[0] if row else None


async def set_setting(db: aiosqlite.Connection, key: str, value: str):
    await db.execute(
        "INSERT INTO bot_settings(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value",
        (key, value),
    )
    await db.commit()


async def ensure_user(db: aiosqlite.Connection, user: types.User):
    await db.execute(
        """
        INSERT INTO users(user_id, username, first_name, last_name)
        VALUES(?,?,?,?)
        ON CONFLICT(user_id) DO UPDATE SET
            username=excluded.username,
            first_name=excluded.first_name,
            last_name=excluded.last_name
        """,
        (user.id, user.username, user.first_name, user.last_name),
    )
    await db.commit()


async def check_promo_membership(bot: Bot, db: aiosqlite.Connection, user: types.User) -> bool:
    promo_channel_id = await get_setting(db, "promo_channel_id")
    promo_channel_link = await get_setting(db, "promo_channel_link")
    if not promo_channel_id:
        return True  # no lock set

    try:
        member = await bot.get_chat_member(int(promo_channel_id), user.id)
        if member.status in ("member", "administrator", "creator"):
            return True
    except Exception as e:
        logger.warning("Failed to check promo membership: %s", e)

    # Not a member: send join message
    kb = InlineKeyboardBuilder()
    if promo_channel_link:
        kb.button(text="📢 Join Channel", url=promo_channel_link)
    kb.button(text="✅ I Joined", callback_data="promo_recheck")
    await bot.send_message(
        user.id,
        "🚫 To use this bot you must join our promotion channel first.",
        reply_markup=kb.as_markup(),
    )
    return False


def main_menu_kb() -> ReplyKeyboardMarkup:
    kb = ReplyKeyboardBuilder()
    kb.button(text="🎮 Single Quiz")
    kb.button(text="👥 Multiplayer")
    kb.button(text="🏆 Tournament")
    kb.button(text="📚 Reference Books")
    kb.button(text="🤖 Ask AI")
    return kb.as_markup(resize_keyboard=True)


def medal_for_position(idx: int) -> str:
    if idx == 0:
        return "🥇"
    if idx == 1:
        return "🥈"
    if idx == 2:
        return "🥉"
    return f"{idx+1}."


# ============ QUIZ PARSING (FROM TEXT FILE) ============

QUIZ_BLOCK_RE = re.compile(
    r"Question:\s*(?P<q>.+?)\n"
    r"A\)\s*(?P<a>.+?)\n"
    r"B\)\s*(?P<b>.+?)\n"
    r"C\)\s*(?P<c>.+?)\n"
    r"D\)\s*(?P<d>.+?)\n"
    r"Answer:\s*(?P<ans>[ABCD])\s*\n"
    r"Explanation:\s*(?P<exp>.+?)\n"
    r"Hint:\s*(?P<hint>.+?)\n?",
    re.DOTALL | re.IGNORECASE,
)


async def parse_and_store_quiz(
    db: aiosqlite.Connection,
    file_id: str,
    text: str,
    subject: str,
    title: str,
    admin_id: int,
) -> int:
    cursor = await db.execute(
        """
        INSERT INTO quiz_files(file_id,subject,title,added_by)
        VALUES(?,?,?,?)
        """,
        (file_id, subject.strip(), title.strip(), admin_id),
    )
    quiz_file_id = cursor.lastrowid

    matches = list(QUIZ_BLOCK_RE.finditer(text))
    if not matches:
        raise ValueError("No questions found in file. Make sure format is correct.")

    for m in matches:
        q = m.group("q").strip()
        a = m.group("a").strip()
        b = m.group("b").strip()
        c = m.group("c").strip()
        d = m.group("d").strip()
        ans = m.group("ans").strip().upper()
        exp = m.group("exp").strip()
        hint = m.group("hint").strip()
        await db.execute(
            """
            INSERT INTO questions(quiz_file_id,question,option_a,option_b,option_c,option_d,correct_option,explanation,hint)
            VALUES(?,?,?,?,?,?,?,?,?)
            """,
            (quiz_file_id, q, a, b, c, d, ans, exp, hint),
        )

    await db.commit()
    return quiz_file_id


# ============ AI CHAT ============

async def list_ai_profiles(db: aiosqlite.Connection) -> List[Dict[str, Any]]:
    cur = await db.execute(
        "SELECT id,name,description,active FROM ai_profiles ORDER BY id"
    )
    rows = await cur.fetchall()
    await cur.close()
    return [
        {
            "id": r[0],
            "name": r[1],
            "description": r[2],
            "active": bool(r[3]),
        }
        for r in rows
    ]


async def get_ai_profile(db: aiosqlite.Connection, profile_id: int) -> Optional[Dict[str, Any]]:
    cur = await db.execute(
        """
        SELECT id,name,api_base,api_key,model,system_prompt,description,active
        FROM ai_profiles WHERE id=?
        """,
        (profile_id,),
    )
    row = await cur.fetchone()
    await cur.close()
    if not row:
        return None
    return {
        "id": row[0],
        "name": row[1],
        "api_base": row[2],
        "api_key": row[3],
        "model": row[4],
        "system_prompt": row[5],
        "description": row[6],
        "active": bool(row[7]),
    }


async def get_conversation_history(
    db: aiosqlite.Connection, user_id: int, profile_id: int
) -> List[Dict[str, str]]:
    cur = await db.execute(
        """
        SELECT role,content FROM ai_conversations
        WHERE user_id=? AND profile_id=?
        ORDER BY id ASC
        """,
        (user_id, profile_id),
    )
    rows = await cur.fetchall()
    await cur.close()
    return [{"role": r[0], "content": r[1]} for r in rows]


async def append_message(
    db: aiosqlite.Connection,
    user_id: int,
    profile_id: int,
    role: str,
    content: str,
):
    await db.execute(
        """
        INSERT INTO ai_conversations(user_id,profile_id,role,content)
        VALUES(?,?,?,?)
        """,
        (user_id, profile_id, role, content),
    )
    # keep only last 20 messages
    await db.execute(
        """
        DELETE FROM ai_conversations
        WHERE id IN (
          SELECT id FROM ai_conversations
          WHERE user_id=? AND profile_id=?
          ORDER BY id ASC
          LIMIT (
            SELECT MAX(COUNT(*)-20,0)
            FROM ai_conversations
            WHERE user_id=? AND profile_id=?
          )
        )
        """,
        (user_id, profile_id, user_id, profile_id),
    )
    await db.commit()


async def call_ai(profile: Dict[str, Any], messages: List[Dict[str, str]]) -> str:
    # OpenAI-compatible /chat/completions style
    url = profile["api_base"].rstrip("/") + "/chat/completions"
    headers = {
        "Authorization": f"Bearer {profile['api_key']}",
        "Content-Type": "application/json",
    }
    body = {
        "model": profile["model"],
        "messages": [{"role": "system", "content": profile["system_prompt"]}]
        + messages,
    }
    async with aiohttp.ClientSession() as session:
        async with session.post(url, json=body, headers=headers, timeout=120) as resp:
            if resp.status != 200:
                txt = await resp.text()
                logger.error("AI error %s: %s", resp.status, txt)
                raise RuntimeError("AI API error")
            data = await resp.json()
            return data["choices"][0]["message"]["content"]


# ============ BOT SETUP ============

bot = Bot(token=BOT_TOKEN, parse_mode="HTML")
dp = Dispatcher()


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

@dp.message(CommandStart())
async def cmd_start(message: types.Message):
    async with await get_db() as db:
        await ensure_user(db, message.from_user)
        if not await check_promo_membership(bot, db, message.from_user):
            return

    text = (
        "👋 Welcome to the Quiz & AI Bot!\n\n"
        "Use the menu below to start:\n"
        "🎮 Single Quiz\n"
        "👥 Multiplayer\n"
        "🏆 Tournament\n"
        "📚 Reference Books\n"
        "🤖 Ask AI"
    )
    await message.answer(text, reply_markup=main_menu_kb())


@dp.message(Command("menu"))
async def cmd_menu(message: types.Message):
    await message.answer("📋 Main menu:", reply_markup=main_menu_kb())


# ----- PROMO CHANNEL SETUP (ADMIN) -----

@dp.message(Command("set_promo_channel"))
async def cmd_set_promo_channel(message: types.Message):
    if not is_admin(message.from_user):
        return
    parts = message.text.split()
    if len(parts) < 3:
        await message.answer(
            "Usage:\n"
            "<code>/set_promo_channel &lt;channel_id&gt; &lt;channel_link&gt;</code>\n"
            "Example:\n"
            "<code>/set_promo_channel -1001234567890 https://t.me/yourchannel</code>"
        )
        return
    channel_id = parts[1]
    channel_link = parts[2]
    async with await get_db() as db:
        await set_setting(db, "promo_channel_id", channel_id)
        await set_setting(db, "promo_channel_link", channel_link)
    await message.answer(
        f"✅ Promotion channel set.\nID: <code>{channel_id}</code>\nLink: {channel_link}"
    )


# ----- ADMIN: ADD QUIZ FROM TEXT FILE -----

@dp.message(Command("add_quiz"))
async def cmd_add_quiz(message: types.Message):
    if not is_admin(message.from_user):
        return

    await message.answer(
        "📄 Send me a TEXT FILE with your quiz in this format:\n\n"
        "Question: ...\n"
        "A) ...\nB) ...\nC) ...\nD) ...\n"
        "Answer: A\n"
        "Explanation: ...\n"
        "Hint: ...\n\n"
        "Send the file now."
    )


@dp.message(lambda m: m.document and m.caption and m.caption.startswith("quiz:"))
async def handle_quiz_file(message: types.Message):
    # Admin sends text file with caption: quiz: Subject | Title
    if not is_admin(message.from_user):
        return

    doc = message.document
    caption = message.caption[len("quiz:") :].strip()
    try:
        subject, title = [x.strip() for x in caption.split("|", 1)]
    except ValueError:
        await message.answer(
            "❌ Caption format invalid.\nUse: <code>quiz: Subject | Title</code>"
        )
        return

    file = await bot.get_file(doc.file_id)
    file_bytes = await bot.download_file(file.file_path)
    text = file_bytes.read().decode("utf-8", errors="ignore")

    async with await get_db() as db:
        try:
            quiz_file_id = await parse_and_store_quiz(
                db=db,
                file_id=doc.file_id,
                text=text,
                subject=subject,
                title=title,
                admin_id=message.from_user.id,
            )
        except Exception as e:
            logger.exception("Quiz parse error")
            await message.answer(f"❌ Failed to parse quiz: {e}")
            return

    await message.answer(f"✅ Quiz saved (ID: {quiz_file_id}) with subject <b>{subject}</b> and title <b>{title}</b>.")


# ----- ADMIN: TIMER VIDEOS -----

@dp.message(Command("add_timer"))
async def cmd_add_timer(message: types.Message):
    if not is_admin(message.from_user):
        return
    await message.answer(
        "⏱ Send a GIF/Video with caption:\n\n"
        "<code>timer: scope duration label</code>\n\n"
        "Where:\n"
        "• scope = single | multi | tournament\n"
        "• duration = seconds (e.g. 30)\n"
        "• label = short name (no spaces or use _)\n\n"
        "Example:\n"
        "<code>timer: single 30 basic_single</code>"
    )


@dp.message(lambda m: m.video or m.animation)
async def handle_timer_video(message: types.Message):
    if not is_admin(message.from_user):
        return
    if not message.caption or not message.caption.startswith("timer:"):
        return

    try:
        _, rest = message.caption.split("timer:", 1)
        parts = rest.strip().split()
        scope = parts[0]
        duration = int(parts[1])
        label = parts[2] if len(parts) > 2 else f"{scope}_{duration}s"
        if scope not in ("single", "multi", "tournament"):
            raise ValueError("invalid scope")
    except Exception:
        await message.answer(
            "❌ Invalid caption.\nUse: <code>timer: scope duration label</code>\n"
            "Example: <code>timer: single 30 basic_single</code>"
        )
        return

    file_id = (
        message.video.file_id if message.video else message.animation.file_id
    )

    async with await get_db() as db:
        await db.execute(
            """
            INSERT INTO timer_videos(file_id,duration_seconds,scope,label)
            VALUES(?,?,?,?)
            """,
            (file_id, duration, scope, label),
        )
        await db.commit()
    await message.answer(
        f"✅ Timer video saved.\nScope: {scope}\nDuration: {duration}s\nLabel: {label}"
    )


# ----- ADMIN: REFERENCE BOOKS -----

@dp.message(Command("add_book"))
async def cmd_add_book(message: types.Message):
    if not is_admin(message.from_user):
        return
    await message.answer(
        "📚 Send a PDF (or any doc) with caption:\n"
        "<code>book: Title of Book</code>"
    )


@dp.message(lambda m: m.document and m.caption and m.caption.startswith("book:"))
async def handle_book(message: types.Message):
    if not is_admin(message.from_user):
        return
    title = message.caption[len("book:") :].strip()
    file_id = message.document.file_id

    async with await get_db() as db:
        await db.execute(
            """
            INSERT INTO reference_books(file_id,title,added_by)
            VALUES(?,?,?)
            """,
            (file_id, title, message.from_user.id),
        )
        await db.commit()

    await message.answer(f"✅ Reference book added: <b>{title}</b>.")


@dp.message(lambda m: m.text == "📚 Reference Books")
async def list_books(message: types.Message):
    async with await get_db() as db:
        if not await check_promo_membership(bot, db, message.from_user):
            return
        cur = await db.execute(
            "SELECT id,title FROM reference_books ORDER BY id DESC"
        )
        rows = await cur.fetchall()
        await cur.close()
    if not rows:
        await message.answer("📚 No reference books yet.")
        return

    kb = InlineKeyboardBuilder()
    for row in rows:
        kb.button(text=row[1][:30], callback_data=f"book_{row[0]}")
    kb.adjust(1)
    await message.answer("Select a reference book:", reply_markup=kb.as_markup())


@dp.callback_query(lambda c: c.data and c.data.startswith("book_"))
async def send_book(call: types.CallbackQuery):
    book_id = int(call.data.split("_", 1)[1])
    async with await get_db() as db:
        cur = await db.execute(
            "SELECT file_id,title FROM reference_books WHERE id=?", (book_id,)
        )
        row = await cur.fetchone()
        await cur.close()
    if not row:
        await call.answer("Not found.", show_alert=True)
        return
    file_id, title = row
    await bot.send_document(call.from_user.id, file_id, caption=f"📚 {title}")
    await call.answer()


# ----- SINGLE PLAYER QUIZ (BASIC FLOW) -----
# For brevity, we implement a very simple single-player flow:
# - user chooses latest quiz
# - each question shown one by one
# - explanation shown after answer
# - summary at end
# You can extend later to choose subject/quiz, timer video options, etc.


async def get_latest_quiz(db: aiosqlite.Connection) -> Optional[Dict[str, Any]]:
    cur = await db.execute(
        "SELECT id,subject,title FROM quiz_files ORDER BY id DESC LIMIT 1"
    )
    row = await cur.fetchone()
    await cur.close()
    if not row:
        return None
    return {"id": row[0], "subject": row[1], "title": row[2]}


async def get_questions_for_quiz(
    db: aiosqlite.Connection, quiz_file_id: int
) -> List[Dict[str, Any]]:
    cur = await db.execute(
        """
        SELECT id,question,option_a,option_b,option_c,option_d,correct_option,explanation,hint
        FROM questions WHERE quiz_file_id=?
        ORDER BY id
        """,
        (quiz_file_id,),
    )
    rows = await cur.fetchall()
    await cur.close()
    return [
        {
            "id": r[0],
            "question": r[1],
            "a": r[2],
            "b": r[3],
            "c": r[4],
            "d": r[5],
            "correct": r[6],
            "exp": r[7],
            "hint": r[8],
        }
        for r in rows
    ]


@dp.message(lambda m: m.text == "🎮 Single Quiz")
async def single_quiz_entry(message: types.Message):
    async with await get_db() as db:
        if not await check_promo_membership(bot, db, message.from_user):
            return
        await ensure_user(db, message.from_user)
        quiz = await get_latest_quiz(db)
        if not quiz:
            await message.answer("❌ No quizzes yet. Ask admin to add one.")
            return

        # choose first matching timer for scope=single (optional)
        cur = await db.execute(
            """
            SELECT id,file_id,duration_seconds FROM timer_videos
            WHERE scope='single' ORDER BY id DESC LIMIT 1
            """
        )
        trow = await cur.fetchone()
        await cur.close()
        timer_id = trow[0] if trow else None

        cur = await db.execute(
            """
            INSERT INTO single_sessions(user_id,quiz_file_id,timer_video_id)
            VALUES(?,?,?)
            """,
            (message.from_user.id, quiz["id"], timer_id),
        )
        session_id = cur.lastrowid
        await db.commit()

    await message.answer(
        f"🎮 Starting single-player quiz:\n<b>{quiz['title']}</b>\nSubject: {quiz['subject']}"
    )
    await send_next_single_question(message.chat.id, message.from_user.id, session_id)


async def send_next_single_question(chat_id: int, user_id: int, session_id: int):
    async with await get_db() as db:
        cur = await db.execute(
            """
            SELECT quiz_file_id,current_question_index,timer_video_id
            FROM single_sessions WHERE id=? AND active=1
            """,
            (session_id,),
        )
        srow = await cur.fetchone()
        await cur.close()
        if not srow:
            return
        quiz_file_id, idx, timer_video_id = srow
        questions = await get_questions_for_quiz(db, quiz_file_id)
        if idx >= len(questions):
            # finished
            await finish_single_session(chat_id, user_id, session_id, db, questions)
            return
        q = questions[idx]

        # send timer video if any
        if timer_video_id:
            cur = await db.execute(
                """
                SELECT file_id,duration_seconds FROM timer_videos WHERE id=?
                """,
                (timer_video_id,),
            )
            trow = await cur.fetchone()
            await cur.close()
        else:
            trow = None

    if trow:
        file_id, duration = trow
        await bot.send_animation(chat_id, file_id, caption=f"⏱ {duration} seconds")

    kb = InlineKeyboardBuilder()
    kb.button(text=f"A) {q['a']}", callback_data=f"sans_{session_id}_{q['id']}_A")
    kb.button(text=f"B) {q['b']}", callback_data=f"sans_{session_id}_{q['id']}_B")
    kb.button(text=f"C) {q['c']}", callback_data=f"sans_{session_id}_{q['id']}_C")
    kb.button(text=f"D) {q['d']}", callback_data=f"sans_{session_id}_{q['id']}_D")
    kb.adjust(1)

    text = f"❓ <b>Question {idx+1}</b>\n\n{q['question']}"
    await bot.send_message(chat_id, text, reply_markup=kb.as_markup())


@dp.callback_query(lambda c: c.data and c.data.startswith("sans_"))
async def handle_single_answer(call: types.CallbackQuery):
    # data: sans_sessionId_questionId_option
    try:
        _, sid, qid, opt = call.data.split("_", 3)
        session_id = int(sid)
        question_id = int(qid)
        chosen = opt
    except Exception:
        await call.answer("Error.", show_alert=True)
        return

    async with await get_db() as db:
        # get session + question
        cur = await db.execute(
            """
            SELECT quiz_file_id,current_question_index,correct_count,total_time_seconds
            FROM single_sessions WHERE id=? AND active=1
            """,
            (session_id,),
        )
        srow = await cur.fetchone()
        await cur.close()
        if not srow:
            await call.answer("Session ended.", show_alert=True)
            return
        quiz_file_id, idx, correct_count, total_time = srow

        cur = await db.execute(
            """
            SELECT id,question,option_a,option_b,option_c,option_d,correct_option,explanation,hint
            FROM questions WHERE id=? AND quiz_file_id=?
            """,
            (question_id, quiz_file_id),
        )
        qrow = await cur.fetchone()
        await cur.close()
        if not qrow:
            await call.answer("Question not found.", show_alert=True)
            return

        correct = qrow[6]
        exp = qrow[7]
        hint = qrow[8]

        is_correct = 1 if chosen == correct else 0
        # time measurement could be refined; here we just add fixed
        time_spent = 5

        await db.execute(
            """
            INSERT INTO single_answers(session_id,question_id,chosen_option,is_correct,time_spent_seconds)
            VALUES(?,?,?,?,?)
            """,
            (session_id, question_id, chosen, is_correct, time_spent),
        )

        if is_correct:
            correct_count += 1
        total_time += time_spent

        # move to next
        idx += 1
        await db.execute(
            """
            UPDATE single_sessions
            SET current_question_index=?,correct_count=?,total_time_seconds=?
            WHERE id=?
            """,
            (idx, correct_count, total_time, session_id),
        )
        await db.commit()

    answer_text = "✅ Correct!" if is_correct else f"❌ Wrong. Correct answer: {correct}"
    answer_text += f"\n\n📘 Explanation:\n{exp}"
    if hint:
        answer_text += f"\n\n💡 Hint was:\n{hint}"
    await call.message.answer(answer_text)

    await call.answer()
    await send_next_single_question(call.message.chat.id, call.from_user.id, session_id)


async def finish_single_session(
    chat_id: int,
    user_id: int,
    session_id: int,
    db: aiosqlite.Connection,
    questions: List[Dict[str, Any]],
):
    cur = await db.execute(
        """
        SELECT correct_count,total_time_seconds
        FROM single_sessions WHERE id=?
        """,
        (session_id,),
    )
    srow = await cur.fetchone()
    await cur.close()
    if not srow:
        return
    correct_count, total_time = srow
    await db.execute(
        """
        UPDATE single_sessions
        SET active=0,ended_at=CURRENT_TIMESTAMP
        WHERE id=?
        """,
        (session_id,),
    )
    await db.commit()

    total_q = len(questions)
    avg_time = total_time / max(total_q, 1)
    text = (
        f"🎉 Single-player quiz finished!\n\n"
        f"Score: <b>{correct_count}</b> / {total_q}\n"
        f"⏱ Avg time per question: {avg_time:.1f} sec\n\n"
        "Thanks for playing!"
    )
    await bot.send_message(chat_id, text)


# ----- AI PROFILE MANAGEMENT (ADMIN) -----

@dp.message(Command("add_ai"))
async def cmd_add_ai(message: types.Message):
    if not is_admin(message.from_user):
        return
    await message.answer(
        "🤖 Let's add a new AI profile.\n"
        "Send me data in this format (all in one message):\n\n"
        "<code>Name\n"
        "API_BASE_URL\n"
        "API_KEY\n"
        "MODEL\n"
        "SYSTEM_PROMPT\n"
        "DESCRIPTION(optional)</code>\n\n"
        "Example:\n"
        "<code>Friendly Tutor\n"
        "https://api.openai.com/v1\n"
        "sk-XXX\n"
        "gpt-4o-mini\n"
        "You are a friendly tutor for high school.\n"
        "Helps with math and science.</code>"
    )


@dp.message(Command("list_ai"))
async def cmd_list_ai(message: types.Message):
    if not is_admin(message.from_user):
        return
    async with await get_db() as db:
        profiles = await list_ai_profiles(db)
    if not profiles:
        await message.answer("No AI profiles yet.")
        return
    lines = []
    for p in profiles:
        status = "✅" if p["active"] else "⛔"
        lines.append(f"{status} <b>{p['id']}</b> – {p['name']} – {p['description']}")
    await message.answer("\n".join(lines))


@dp.message(Command("edit_ai"))
async def cmd_edit_ai(message: types.Message):
    if not is_admin(message.from_user):
        return
    parts = message.text.split(maxsplit=2)
    if len(parts) < 3:
        await message.answer(
            "Usage:\n<code>/edit_ai &lt;id&gt; &lt;on|off|rename|model&gt; new_value</code>"
        )
        return
    ai_id = int(parts[1])
    field_action = parts[2].split()[0]
    new_value = " ".join(parts[2].split()[1:])

    async with await get_db() as db:
        if field_action == "on":
            await db.execute(
                "UPDATE ai_profiles SET active=1 WHERE id=?", (ai_id,)
            )
        elif field_action == "off":
            await db.execute(
                "UPDATE ai_profiles SET active=0 WHERE id=?", (ai_id,)
            )
        elif field_action == "rename":
            await db.execute(
                "UPDATE ai_profiles SET name=? WHERE id=?", (new_value, ai_id)
            )
        elif field_action == "model":
            await db.execute(
                "UPDATE ai_profiles SET model=? WHERE id=?", (new_value, ai_id)
            )
        else:
            await message.answer("Unknown action. Use on/off/rename/model.")
            return
        await db.commit()
    await message.answer("✅ AI profile updated.")


@dp.message(Command("del_ai"))
async def cmd_del_ai(message: types.Message):
    if not is_admin(message.from_user):
        return
    parts = message.text.split()
    if len(parts) < 2:
        await message.answer("Usage: <code>/del_ai &lt;id&gt;</code>")
        return
    ai_id = int(parts[1])
    async with await get_db() as db:
        await db.execute("DELETE FROM ai_conversations WHERE profile_id=?", (ai_id,))
        await db.execute("DELETE FROM ai_profiles WHERE id=?", (ai_id,))
        await db.commit()
    await message.answer("🗑 AI profile deleted.")


@dp.message(lambda m: m.text == "🤖 Ask AI")
async def ai_chat_entry(message: types.Message):
    async with await get_db() as db:
        if not await check_promo_membership(bot, db, message.from_user):
            return
        profiles = await list_ai_profiles(db)
    profiles = [p for p in profiles if p["active"]]
    if not profiles:
        await message.answer("No AI profiles configured yet. Ask admin.")
        return
    kb = InlineKeyboardBuilder()
    for p in profiles:
        label = f"{p['name']}"
        kb.button(text=label[:30], callback_data=f"aiprof_{p['id']}")
    kb.adjust(1)
    await message.answer("Choose an AI:", reply_markup=kb.as_markup())


@dp.callback_query(lambda c: c.data and c.data.startswith("aiprof_"))
async def select_ai_profile(call: types.CallbackQuery):
    profile_id = int(call.data.split("_", 1)[1])
    # store chosen profile in simple in-memory dict or ask user to repeat; for simplicity,
    # we just ask them to use /ai <profile_id> message
    await call.message.answer(
        f"Selected AI profile ID <b>{profile_id}</b>.\n"
        f"Now send:\n<code>/ai {profile_id} your question...</code>"
    )
    await call.answer()


@dp.message(Command("ai"))
async def cmd_ai(message: types.Message):
    parts = message.text.split(maxsplit=2)
    if len(parts) < 3:
        await message.answer("Usage: <code>/ai &lt;profile_id&gt; your question...</code>")
        return
    profile_id = int(parts[1])
    user_msg = parts[2]

    async with await get_db() as db:
        if not await check_promo_membership(bot, db, message.from_user):
            return
        await ensure_user(db, message.from_user)
        profile = await get_ai_profile(db, profile_id)
        if not profile or not profile["active"]:
            await message.answer("AI profile not found or inactive.")
            return
        history = await get_conversation_history(db, message.from_user.id, profile_id)

    await message.answer("⏳ Asking AI...")

    try:
        ai_reply = await call_ai(
            profile,
            history + [{"role": "user", "content": user_msg}],
        )
    except Exception as e:
        logger.exception("AI call failed")
        await message.answer("❌ AI error.")
        return

    async with await get_db() as db:
        await append_message(
            db, message.from_user.id, profile_id, "user", user_msg
        )
        await append_message(
            db, message.from_user.id, profile_id, "assistant", ai_reply
        )

    await message.answer(ai_reply)


# ----- PROMO RECHECK CALLBACK -----

@dp.callback_query(lambda c: c.data == "promo_recheck")
async def promo_recheck(call: types.CallbackQuery):
    async with await get_db() as db:
        ok = await check_promo_membership(bot, db, call.from_user)
    if ok:
        await call.message.answer("✅ Thanks for joining! You can now use the bot.", reply_markup=main_menu_kb())
    await call.answer()


# ----- BASIC TEXT MENU ROUTER -----

@dp.message()
async def text_router(message: types.Message):
    # we handled menu labels above; we can add simple hints
    if message.text in {
        "🎮 Single Quiz",
        "👥 Multiplayer",
        "🏆 Tournament",
        "📚 Reference Books",
        "🤖 Ask AI",
    }:
        # individual handlers already exist
        return
    # Default: just show menu
    await message.answer("Use the menu below:", reply_markup=main_menu_kb())


# ============ TOURNAMENT SCHEDULING (SKELETON) ============
# Due to length, we implement the core requirement:
# - admin can schedule a tournament (code, group_chat_id, quiz, timer, start time)
# - at scheduled time, bot announces in group with deep link + start time
# - detailed tournament gameplay can be added next iteration.


@dp.message(Command("schedule_tour"))
async def cmd_schedule_tour(message: types.Message):
    if not is_admin(message.from_user):
        return
    parts = message.text.split(maxsplit=5)
    if len(parts) < 6:
        await message.answer(
            "Usage:\n"
            "<code>/schedule_tour &lt;code&gt; &lt;group_chat_id&gt; &lt;quiz_id&gt; &lt;timer_id|0&gt; &lt;YYYY-MM-DD_HH:MM&gt;</code>\n"
            "Time is in UTC.\n"
            "Example:\n"
            "<code>/schedule_tour battle1 -1001234567890 1 2 2025-01-01_18:00</code>"
        )
        return
    code = parts[1]
    group_chat_id = int(parts[2])
    quiz_id = int(parts[3])
    timer_id = int(parts[4]) if parts[4] != "0" else None
    dt_str = parts[5]
    try:
        scheduled = datetime.strptime(dt_str, "%Y-%m-%d_%H:%M").replace(tzinfo=timezone.utc)
    except ValueError:
        await message.answer("❌ Invalid datetime. Use YYYY-MM-DD_HH:MM (UTC).")
        return

    async with await get_db() as db:
        cur = await db.execute(
            """
            INSERT INTO tournaments(code,admin_user_id,group_chat_id,quiz_file_id,timer_video_id,scheduled_start)
            VALUES(?,?,?,?,?,?)
            """,
            (code, message.from_user.id, group_chat_id, quiz_id, timer_id, scheduled.isoformat()),
        )
        tour_id = cur.lastrowid
        await db.commit()

    # schedule job
    scheduler.add_job(
        func=announce_tournament_start,
        trigger=DateTrigger(run_date=scheduled),
        args=(tour_id,),
        id=f"tour_{tour_id}",
        replace_existing=True,
    )

    await message.answer(
        f"✅ Tournament scheduled.\n"
        f"Code: <code>{code}</code>\n"
        f"Group: <code>{group_chat_id}</code>\n"
        f"Quiz ID: {quiz_id}\n"
        f"Timer ID: {timer_id or 'none'}\n"
        f"Start (UTC): {scheduled:%Y-%m-%d %H:%M}"
    )


async def announce_tournament_start(tour_id: int):
    async with await get_db() as db:
        cur = await db.execute(
            """
            SELECT code,group_chat_id,quiz_file_id,timer_video_id,scheduled_start
            FROM tournaments WHERE id=?
            """,
            (tour_id,),
        )
        row = await cur.fetchone()
        await cur.close()
        if not row:
            return
        code, group_chat_id, quiz_id, timer_id, scheduled_str = row
        # mark as running
        await db.execute(
            "UPDATE tournaments SET status='running',started_at=CURRENT_TIMESTAMP WHERE id=?",
            (tour_id,),
        )
        await db.commit()

    scheduled = datetime.fromisoformat(scheduled_str)
    start_text = scheduled.strftime("%Y-%m-%d %H:%M UTC")
    deep_link = f"https://t.me/{(await bot.me()).username}?start=tour_{code}"

    text = (
        f"🏆 <b>Tournament Starting Now!</b>\n\n"
        f"Code: <code>{code}</code>\n"
        f"Start time: <b>{start_text}</b>\n\n"
        f"➡️ Join via this link: {deep_link}\n\n"
        "Get ready!"
    )

    try:
        await bot.send_message(group_chat_id, text)
    except Exception as e:
        logger.error("Failed to announce tournament: %s", e)


# ============ STARTUP ============

async def main():
    await init_db()
    scheduler.start()
    logger.info("Bot started.")
    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())