bot.py

# Copyright NGGT.LightKeeper. All Rights Reserved.

import os
import django
from functools import wraps
import datetime
import re
import io
from openpyxl import Workbook
from openpyxl.styles import Font, Alignment

# --- Django Setup ---
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'telegram_bot_django.settings')
django.setup()

import telebot
from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton
from settings.settings import BOT_TOKEN, NAME_BTN_BACK
from telegram_bot_db.models import (
    TelegramUser, MessageHistory, Group, Student,
    Lesson, AttendanceType, AttendanceJournal
)
from django.db.models import ProtectedError

# Check if BOT_TOKEN is provided. If not, the bot cannot start.
if not BOT_TOKEN:
    raise ValueError("Bot token is not provided! Please set BOT_TOKEN in settings/settings.py")

# Initialize the bot using the token from settings.
bot = telebot.TeleBot(BOT_TOKEN)

# A dictionary to track the current state of each user's conversation.
# This is crucial for handling multi-step operations like adding a new student.
# Example: {'user_id': {'state': 'awaiting_group_name', 'data': {}}}
user_states = {}


# --- Decorators ---

def escape_markdown(text: str) -> str:
    """
    Escapes characters that have a special meaning in Telegram's Markdown.

    Args:
        text: The text to escape.

    Returns:
        The escaped text, safe for sending in a Markdown-formatted message.
    """
    if not text:
        return ""
    # A list of characters to escape for the legacy Markdown mode.
    escape_chars = r'[_*`[]'
    # Use re.sub to add a backslash before every special character.
    return re.sub(f'({escape_chars})', r'\\\1', str(text))

def admin_required(func):
    """
    Decorator to restrict access to a handler to bot administrators only.

    It checks if the user sending the command is marked as an admin in the
    database. If not, it sends an access denied message.
    """
    @wraps(func)
    def wrapper(m_or_c):
        user_id = m_or_c.from_user.id
        try:
            user = TelegramUser.objects.get(user_id=user_id)
            if not user.is_bot_admin:
                error_text = "❌ You do not have sufficient rights to execute this command."
                if isinstance(m_or_c, telebot.types.CallbackQuery):
                    bot.answer_callback_query(m_or_c.id, error_text, show_alert=True)
                else:
                    bot.reply_to(m_or_c, error_text)
                return
        except TelegramUser.DoesNotExist:
            error_text = "❌ Your user is not registered. Please use /start first."
            if isinstance(m_or_c, telebot.types.CallbackQuery):
                bot.answer_callback_query(m_or_c.id, error_text, show_alert=True)
            else:
                bot.reply_to(m_or_c, error_text)
            return
        return func(m_or_c)
    return wrapper


def export_permission_required(func):
    """
    Decorator that checks if a user has rights to export data.
    Access is granted to bot administrators (`is_bot_admin`) or users with
    the specific export permission (`is_export`).
    """
    @wraps(func)
    def wrapper(m_or_c):
        user_id = m_or_c.from_user.id
        try:
            user = TelegramUser.objects.get(user_id=user_id)
            # Grant access if the user is an admin OR has the export flag.
            if not user.is_bot_admin and not user.is_export:
                error_text = "❌ You do not have permission to export data."
                if isinstance(m_or_c, telebot.types.CallbackQuery):
                    bot.answer_callback_query(m_or_c.id, error_text, show_alert=True)
                else:
                    bot.reply_to(m_or_c, error_text)
                return
        except TelegramUser.DoesNotExist:
            error_text = "❌ Your user is not registered. Please use /start first."
            if isinstance(m_or_c, telebot.types.CallbackQuery):
                bot.answer_callback_query(m_or_c.id, error_text, show_alert=True)
            else:
                bot.reply_to(m_or_c, error_text)
            return
        return func(m_or_c)
    return wrapper


# --- Command Handlers ---

@bot.message_handler(commands=['start'])
def handle_start(message):
    """
    Handles the /start command.

    Registers a new user in the database or updates their information if they
    already exist. Sends a welcome message.
    """
    user_data = message.from_user
    # get_or_create is an efficient way to handle user registration.
    user, created = TelegramUser.objects.get_or_create(
        user_id=user_data.id,
        defaults={
            'first_name': user_data.first_name,
            'last_name': user_data.last_name,
            'username': user_data.username,
        }
    )

    if created:
        welcome_text = (f"Hello, {user.first_name}! 👋\n\n"
                        "Welcome to the attendance tracking bot. I have registered you in the system.\n"
                        "You can view your profile information using the /profile command.")
    else:
        # If the user already exists, update their data in case it changed in Telegram.
        user.first_name = user_data.first_name
        user.last_name = user_data.last_name
        user.username = user_data.username
        user.save()
        welcome_text = (f"Welcome back, {user.first_name}! 👋\n\n"
                        "You are already registered. Use /profile to view your data or /menu to access admin commands.")

    bot.reply_to(message, welcome_text)

@bot.message_handler(commands=['profile'])
def handle_profile(message):
    """
    Handles the /profile command.

    Displays the user's registered information, such as name, username, and
    admin status.
    """
    try:
        user = TelegramUser.objects.get(user_id=message.from_user.id)
        is_admin_str = "Yes" if user.is_bot_admin else "No"
        if user.is_export:
            is_export_str = "Yes"
        elif user.is_bot_admin:
            is_export_str = "Yes"
        else:
            is_export_str = "No"
    
        # Escape user-provided data to prevent Markdown parsing errors.
        first_name = escape_markdown(user.first_name)
        last_name = escape_markdown(user.last_name or 'Not specified')
        username = escape_markdown(user.username or 'Not specified')

        profile_text = (
            f"👤 **Your Profile**\n\n"
            f"**Telegram ID:** `{user.user_id}`\n"
            f"**First Name:** {first_name}\n"
            f"**Last Name:** {last_name}\n"
            f"**Username:** @{username}\n"
            f"**Bot Administrator:** {is_admin_str}\n"
            f"**Can Export Data:** {is_export_str}\n"
            f"**Registered on:** {user.created_at.strftime('%Y-%m-%d %H:%M:%S')}"
        )
        bot.reply_to(message, profile_text, parse_mode='Markdown')
    except TelegramUser.DoesNotExist:
        bot.reply_to(message, "You are not registered yet. Please use the /start command first.")

def send_admin_menu(chat_id: int, message_id: int = None):
    """
    Sends or edits the main administrative menu.

    This menu provides buttons to access different management sections.

    Args:
        chat_id: The ID of the chat to send the menu to.
        message_id: The ID of the message to edit. If None, a new message is sent.
    """
    markup = InlineKeyboardMarkup(row_width=2)
    buttons = [
        InlineKeyboardButton("Groups", callback_data="manage_groups"),
        InlineKeyboardButton("Students", callback_data="manage_students"),
        InlineKeyboardButton("Lessons", callback_data="manage_lessons"),
        InlineKeyboardButton("Attendance Types", callback_data="manage_attendance_types"),
        InlineKeyboardButton("Attendance Journal", callback_data="manage_journal"),
    ]
    markup.add(*buttons)
    text = "Welcome to the Admin Menu. Please choose a section to manage:"

    if message_id:
        try:
            # Edit the existing message to avoid cluttering the chat.
            bot.edit_message_text(text, chat_id, message_id, reply_markup=markup)
        except telebot.apihelper.ApiTelegramException:
            # If editing fails (e.g., message is too old), send a new one.
            bot.send_message(chat_id, text, reply_markup=markup)
    else:
        bot.send_message(chat_id, text, reply_markup=markup)

@bot.message_handler(commands=['menu'])
@admin_required
def handle_menu_command(message):
    """
    Handles the /menu command, which displays the admin menu.
    """
    send_admin_menu(message.chat.id)

@bot.callback_query_handler(func=lambda call: call.data == 'main_menu')
@admin_required
def main_menu_callback(call):
    """
    Handles the 'main_menu' callback, which is used by "Back" buttons
    to return to the main admin menu.
    """
    # Clear any saved page numbers when returning to the main menu.
    state = user_states.get(call.from_user.id, {})
    for key in list(state.keys()):
        if key.endswith('_page'):
            state.pop(key, None)

    send_admin_menu(call.message.chat.id, call.message.message_id)


# --- Export to XLSX ---

def get_groups_for_export_markup(page: int = 1) -> InlineKeyboardMarkup:
    """
    Creates an inline keyboard for selecting a group to export, with pagination.

    Args:
        page: The current page number for pagination.

    Returns:
        An InlineKeyboardMarkup object with group buttons.
    """
    markup = InlineKeyboardMarkup()
    groups = Group.objects.order_by('name')

    # Paginate the results to keep the keyboard from becoming too long.
    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_groups = groups[start_index:end_index]

    for group in paginated_groups:
        markup.add(InlineKeyboardButton(group.name, callback_data=f"export_select_group_{group.id}"))

    # Add pagination buttons if necessary.
    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"export_groups_page_{page-1}"))
    if end_index < groups.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"export_groups_page_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="main_menu"))
    return markup

@bot.message_handler(commands=['export'])
@export_permission_required
def handle_export(message):
    """
    Starts the process of exporting attendance data to an XLSX file.
    It begins by asking the admin to select a group.
    """
    markup = get_groups_for_export_markup()
    bot.send_message(message.chat.id, "Select a group to export attendance data:", reply_markup=markup)

@bot.callback_query_handler(func=lambda call: call.data.startswith('export_groups_page_'))
@export_permission_required
def export_groups_page_callback(call):
    """Handles pagination for the group selection list during export."""
    page = int(call.data.split('_')[-1])
    markup = get_groups_for_export_markup(page)
    bot.edit_message_reply_markup(
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('export_select_group_'))
@export_permission_required
def export_select_group_callback(call):
    """
    Handles the selection of a group for export and prompts the user for
    the start date of the reporting period.
    """
    group_id = int(call.data.split('_')[-1])
    user_id = call.from_user.id
    # Set the user's state to await date input.
    user_states[user_id] = {'state': 'awaiting_export_start_date', 'group_id': group_id}

    markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data="main_menu"))
    bot.edit_message_text(
        "Please enter the start date for the report (e.g., YYYY-MM-DD):",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )


# --- State-related helpers ---

def clear_user_state(user_id: int):
    """
    Clears the state for a given user, ending any multi-step conversation.

    Args:
        user_id: The ID of the user whose state should be cleared.
    """
    user_states.pop(user_id, None)

def generate_attendance_report(group_id: int, start_date: datetime.date, end_date: datetime.date):
    """
    Generates an XLSX report of student attendance for a specific group and
    date range.

    Args:
        group_id: The ID of the group to generate the report for.
        start_date: The start date of the reporting period.
        end_date: The end date of the reporting period.

    Returns:
        A tuple containing the file stream (BytesIO) and the suggested filename.
    """
    group = Group.objects.get(id=group_id)
    students = Student.objects.filter(group=group).order_by('last_name', 'first_name')
    lessons = Lesson.objects.filter(
        group=group,
        lesson_date__range=[start_date, end_date]
    ).order_by('lesson_date', 'lesson_time')

    # Create a workbook and select the active worksheet
    wb = Workbook()
    ws = wb.active
    ws.title = f"Attendance_{group.name}"

    # --- Header Formatting ---
    header_font = Font(bold=True)
    center_alignment = Alignment(horizontal='center', vertical='center')

    # --- Populate Headers ---
    # Set width for the first column (student names)
    ws.column_dimensions['A'].width = 30

    # Populate lesson headers (date and topic)
    for col_idx, lesson in enumerate(lessons, start=2):
        # Row 1: Date
        date_cell = ws.cell(row=1, column=col_idx, value=lesson.lesson_date.strftime('%d.%m.%Y'))
        date_cell.font = header_font
        date_cell.alignment = center_alignment

        # Row 2: Lesson Topic
        topic_cell = ws.cell(row=2, column=col_idx, value=lesson.topic)
        topic_cell.font = header_font
        topic_cell.alignment = center_alignment

        ws.column_dimensions[chr(65 + col_idx - 1)].width = 20  # Adjust column width for readability

    # --- Populate Student Data ---
    # Create a map of student IDs to row numbers for efficient cell access.
    student_row_map = {student.id: i for i, student in enumerate(students, start=3)}
    for student_id, row_idx in student_row_map.items():
        student = Student.objects.get(id=student_id)
        ws.cell(row=row_idx, column=1, value=f"{student.last_name} {student.first_name} {student.patronymic or ''}".strip())

    # --- Populate Attendance Data ---
    # Create a map of lesson IDs to column numbers.
    lesson_col_map = {lesson.id: i for i, lesson in enumerate(lessons, start=2)}
    attendance_records = AttendanceJournal.objects.filter(
        lesson__in=lessons,
        student__in=students
    ).select_related('status')

    # Create a dictionary for quick lookups of attendance status.
    attendance_map = {}
    for record in attendance_records:
        attendance_map[(record.student_id, record.lesson_id)] = record.status.name

    # Fill the grid with attendance statuses.
    for student in students:
        for lesson in lessons:
            row_idx = student_row_map[student.id]
            col_idx = lesson_col_map[lesson.id]
            status = attendance_map.get((student.id, lesson.id), "+")  # Default to "+" if not found
            cell = ws.cell(row=row_idx, column=col_idx, value=status)
            cell.alignment = center_alignment

    # Save the workbook to a BytesIO stream to be sent as a file.
    file_stream = io.BytesIO()
    wb.save(file_stream)
    file_stream.seek(0)
    return file_stream, f"attendance_{group.name}_{start_date}_to_{end_date}.xlsx"


# --- Group Management ---

def get_groups_markup(page: int = 1) -> InlineKeyboardMarkup:
    """
    Creates an inline keyboard for the group list, with pagination.
    """
    markup = InlineKeyboardMarkup()
    groups = Group.objects.order_by('name')

    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_groups = groups[start_index:end_index]

    for group in paginated_groups:
        # Pass the current page number in the callback to remember it.
        markup.add(InlineKeyboardButton(group.name, callback_data=f"view_group_{group.id}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"groups_page_{page-1}"))
    if end_index < groups.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"groups_page_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton("➕ Add New Group", callback_data="add_group"))
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="main_menu"))
    return markup

@bot.callback_query_handler(func=lambda call: call.data == 'manage_groups' or call.data == 'back_to_groups')
@admin_required
def manage_groups_callback(call):
    """Displays the list of groups for management."""
    user_id = call.from_user.id
    state = user_states.get(user_id, {})
    page = 1

    # If returning from a group view, use the saved page number.
    if call.data == 'back_to_groups':
        page = state.get('last_groups_page', 1)
    # Otherwise, starting from the main menu, clear any saved page.
    elif user_id in user_states:
        user_states[user_id].pop('last_groups_page', None)

    markup = get_groups_markup(page=page)
    try:
        bot.edit_message_text(
            "📚 Manage Groups",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup
        )
    except telebot.apihelper.ApiTelegramException:
        bot.send_message(call.message.chat.id, "📚 Manage Groups", reply_markup=markup)


@bot.callback_query_handler(func=lambda call: call.data.startswith('groups_page_'))
@admin_required
def groups_page_callback(call):
    """Handles pagination for the group list."""
    page = int(call.data.split('_')[-1])
    markup = get_groups_markup(page)
    bot.edit_message_reply_markup(
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data == 'add_group')
@admin_required
def add_group_callback(call):
    """Prompts the user to enter a name for a new group."""
    user_id = call.from_user.id
    user_states[user_id] = {'state': 'awaiting_group_name'}

    markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data="back_to_groups"))
    bot.edit_message_text(
        "Please enter the name for the new group:",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('view_group_'))
@admin_required
def view_group_callback(call):
    """Displays details for a specific group and options to edit or delete."""
    parts = call.data.split('_')
    group_id = int(parts[2])
    page = int(parts[3])
    user_id = call.from_user.id

    # Store the page number so we can return to it.
    if user_id not in user_states:
        user_states[user_id] = {}
    user_states[user_id]['last_groups_page'] = page

    try:
        group = Group.objects.select_related('default_attendance_status').get(id=group_id)
        default_status_name = group.default_attendance_status.name if group.default_attendance_status else "Not specified"

        text = (f"**Group:** {group.name}\n"
                f"**Default Status:** {default_status_name}\n\n"
                f"Select an action:")

        markup = InlineKeyboardMarkup(row_width=2)
        markup.add(InlineKeyboardButton("✏️ Edit Name", callback_data=f"edit_group_{group_id}"))
        markup.add(InlineKeyboardButton("🏷️ Set Default Status", callback_data=f"set_default_status_{group_id}"))
        markup.add(InlineKeyboardButton("🗑 Delete Group", callback_data=f"delete_group_{group_id}"))
        markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="back_to_groups"))
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')
    except Group.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Group not found.", show_alert=True)
        manage_groups_callback(call)


@bot.callback_query_handler(func=lambda call: call.data.startswith('set_default_status_'))
@admin_required
def set_default_status_callback(call):
    """Displays a list of attendance types to set as the default for a group."""
    group_id = int(call.data.split('_')[-1])
    try:
        group = Group.objects.get(id=group_id)
        attendance_types = AttendanceType.objects.all()

        markup = InlineKeyboardMarkup(row_width=1)
        for att_type in attendance_types:
            markup.add(InlineKeyboardButton(att_type.name, callback_data=f"confirm_set_default_status_{group_id}_{att_type.id}"))

        markup.add(InlineKeyboardButton("🗑️ Remove Default Status", callback_data=f"confirm_set_default_status_{group_id}_none"))
        markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data=f"view_group_{group_id}"))

        bot.edit_message_text(
            f"Select the default attendance status for group **{group.name}**:",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup,
            parse_mode='Markdown'
        )
    except Group.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Group not found.", show_alert=True)
        manage_groups_callback(call)


@bot.callback_query_handler(func=lambda call: call.data.startswith('confirm_set_default_status_'))
@admin_required
def confirm_set_default_status_callback(call):
    """Sets or removes the default attendance status for a group."""
    parts = call.data.split('_')
    group_id = int(parts[4])
    status_id_str = parts[5]

    try:
        group = Group.objects.get(id=group_id)
        if status_id_str == 'none':
            group.default_attendance_status = None
            bot.answer_callback_query(call.id, "✅ Default status removed.")
        else:
            status_id = int(status_id_str)
            attendance_type = AttendanceType.objects.get(id=status_id)
            group.default_attendance_status = attendance_type
            bot.answer_callback_query(call.id, f"✅ Default status set to '{attendance_type.name}'.")

        group.save()

        # Go back to the group view to show the change.
        call.data = f"view_group_{group_id}"
        view_group_callback(call)

    except (Group.DoesNotExist, AttendanceType.DoesNotExist):
        bot.answer_callback_query(call.id, "Error: Group or Status not found.", show_alert=True)
        manage_groups_callback(call)

@bot.callback_query_handler(func=lambda call: call.data.startswith('edit_group_'))
@admin_required
def edit_group_callback(call):
    """Prompts the user to enter a new name for the group."""
    group_id = int(call.data.split('_')[-1])
    user_id = call.from_user.id
    user_states[user_id] = {'state': 'awaiting_group_name_edit', 'group_id': group_id}

    markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data=f"view_group_{group_id}"))
    bot.edit_message_text(
        "Please enter the new name for the group:",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('delete_group_'))
@admin_required
def delete_group_callback(call):
    """Asks for confirmation before deleting a group."""
    group_id = int(call.data.split('_')[-1])
    try:
        group = Group.objects.get(id=group_id)
        text = f"⚠️ Are you sure you want to delete the group **{group.name}**? This action cannot be undone."
        markup = InlineKeyboardMarkup()
        markup.add(InlineKeyboardButton("✅ Yes, Delete", callback_data=f"confirm_delete_group_{group_id}"))
        markup.add(InlineKeyboardButton("❌ No, Cancel", callback_data=f"view_group_{group_id}"))
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')
    except Group.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Group not found.", show_alert=True)
        manage_groups_callback(call)

@bot.callback_query_handler(func=lambda call: call.data.startswith('confirm_delete_group_'))
@admin_required
def confirm_delete_group_callback(call):
    """Deletes the group from the database after confirmation."""
    group_id = int(call.data.split('_')[-1])
    try:
        group = Group.objects.get(id=group_id)
        group_name = group.name
        group.delete()
        bot.answer_callback_query(call.id, f"Group '{group_name}' has been deleted.")
        manage_groups_callback(call)
    except Group.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Group not found.", show_alert=True)
        manage_groups_callback(call)
    except ProtectedError:
        # This occurs if the group has foreign key relations (e.g., students).
        bot.answer_callback_query(
            call.id,
            "This group cannot be deleted because it has students or lessons associated with it.",
            show_alert=True
        )
        # Return to the group view.
        call.data = f"view_group_{group_id}"
        view_group_callback(call)


# --- Student Management ---

def get_student_groups_markup(page: int = 1) -> InlineKeyboardMarkup:
    """
    Creates an inline keyboard for selecting a group to manage its students.
    """
    markup = InlineKeyboardMarkup()
    groups = Group.objects.order_by('name')
    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_groups = groups[start_index:end_index]

    for group in paginated_groups:
        markup.add(InlineKeyboardButton(group.name, callback_data=f"student_manage_group_{group.id}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"student_group_list_page_{page-1}"))
    if end_index < groups.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"student_group_list_page_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="main_menu"))
    return markup


@bot.callback_query_handler(func=lambda call: call.data.startswith('student_group_list_page_'))
@admin_required
def student_group_list_page_callback(call):
    """Paginates through the group list for student management."""
    page = int(call.data.split('_')[-1])
    markup = get_student_groups_markup(page)
    bot.edit_message_reply_markup(
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )


def get_students_for_group_markup(group_id: int, page: int = 1) -> InlineKeyboardMarkup:
    """
    Creates an inline keyboard for the student list of a specific group, with pagination.
    """
    markup = InlineKeyboardMarkup()
    students = Student.objects.filter(group_id=group_id).select_related('group').order_by('last_name', 'first_name')

    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_students = students[start_index:end_index]

    for student in paginated_students:
        markup.add(InlineKeyboardButton(f"{student.last_name} {student.first_name} {student.patronymic or ''}", callback_data=f"view_student_{student.id}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"students_for_group_page_{group_id}_{page-1}"))
    if end_index < students.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"students_for_group_page_{group_id}_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton("➕ Add New Student", callback_data=f"add_student_{group_id}"))
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="manage_students"))  # Back to group list
    return markup


@bot.callback_query_handler(func=lambda call: call.data == 'manage_students')
@admin_required
def manage_students_callback(call):
    """
    Displays a list of groups to choose from for student management.
    This is the main entry point for the "Manage Students" section.
    """
    user_id = call.from_user.id
    state = user_states.get(user_id, {})
    # When coming from a student list, restore the group page.
    page = state.get('last_student_groups_page', 1)

    # Clear the inner list's page to ensure it starts from 1.
    if user_id in user_states:
        user_states[user_id].pop('last_students_for_group_page', None)

    markup = get_student_groups_markup(page=page)
    bot.edit_message_text(
        "Please select a group to manage its students:",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )


@bot.callback_query_handler(func=lambda call: call.data.startswith('student_manage_group_'))
@admin_required
def select_group_for_student_management_callback(call):
    """
    Displays the list of students for the selected group.
    This handler is entered in two ways:
    1. From the group list: callback is `student_manage_group_{group_id}_{page}`.
       - The group list page is saved.
       - The student list is shown from page 1.
    2. From a student view ('Back' button): callback is `student_manage_group_{group_id}`.
       - The student list page is restored from the user's state.
    """
    parts = call.data.split('_')
    group_id = int(parts[3])
    user_id = call.from_user.id
    state = user_states.get(user_id, {})

    page_to_show = 1

    # Case 1: Coming from the group list.
    if len(parts) > 4:
        group_list_page = int(parts[4])
        if user_id not in user_states:
            user_states[user_id] = {}
        user_states[user_id]['last_student_groups_page'] = group_list_page
    # Case 2: Coming back from a student view.
    else:
        page_to_show = state.get('last_students_for_group_page', 1)

    markup = get_students_for_group_markup(group_id=group_id, page=page_to_show)
    try:
        bot.edit_message_text(
            "🧑‍🎓 Manage Students",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup
        )
    except telebot.apihelper.ApiTelegramException:
        bot.send_message(call.message.chat.id, "🧑‍🎓 Manage Students", reply_markup=markup)


@bot.callback_query_handler(func=lambda call: call.data.startswith('students_for_group_page_'))
@admin_required
def students_for_group_page_callback(call):
    """Handles pagination for the student list within a group."""
    parts = call.data.split('_')
    group_id = int(parts[4])
    page = int(parts[5])
    markup = get_students_for_group_markup(group_id, page)
    bot.edit_message_reply_markup(
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )


@bot.callback_query_handler(func=lambda call: call.data.startswith('add_student_'))
@admin_required
def add_student_callback(call):
    """Starts the multi-step process of adding a new student to a specific group."""
    group_id = int(call.data.split('_')[-1])
    user_id = call.from_user.id
    user_states[user_id] = {'state': 'awaiting_student_lastname', 'data': {'group_id': group_id}}

    markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data=f"student_manage_group_{group_id}"))
    bot.edit_message_text(
        "Please enter the student's **last name**:",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup,
        parse_mode='Markdown'
    )


def get_group_selection_markup(page: int = 1, action_type: str = "add", student_id: int = None, user_id: int = None) -> InlineKeyboardMarkup:
    """
    Creates a keyboard for selecting a group, used when adding or editing a student.
    """
    markup = InlineKeyboardMarkup()
    groups = Group.objects.order_by('name')
    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_groups = groups[start_index:end_index]

    for group in paginated_groups:
        if action_type == "add":
            # This part of the logic is now handled by the new student creation flow.
            # We keep it for the edit flow.
            callback_data = f"select_student_group_{group.id}"
        else:  # edit
            callback_data = f"select_student_group_edit_{group.id}_{student_id}"
        markup.add(InlineKeyboardButton(group.name, callback_data=callback_data))

    row = []
    if action_type == "add":
        page_cb = "student_group_page_"
        # The cancel callback should go back to the group's student list.
        group_id = user_states.get(user_id, {}).get('data', {}).get('group_id')
        cancel_cb = f"student_manage_group_{group_id}"
    else:
        page_cb = f"student_group_page_edit_{student_id}_"
        cancel_cb = f"edit_student_{student_id}"

    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"{page_cb}{page-1}"))
    if end_index < groups.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"{page_cb}{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton("❌ Cancel", callback_data=cancel_cb))
    return markup


@bot.callback_query_handler(func=lambda call: call.data.startswith('student_group_page_'))
@admin_required
def student_group_page_callback(call):
    """Paginates through the group selection list when editing a student."""
    user_id = call.from_user.id
    parts = call.data.split('_')
    action_type = "edit"  # This handler is now only for editing
    student_id = int(parts[4])
    page = int(parts[5])
    markup = get_group_selection_markup(page, "edit", student_id, user_id)
    bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=markup)


@bot.callback_query_handler(func=lambda call: call.data.startswith('select_student_group_edit_'))
@admin_required
def select_student_group_edit_callback(call):
    """Handles changing a student's group."""
    parts = call.data.split('_')
    group_id = int(parts[4])
    student_id = int(parts[5])

    try:
        student = Student.objects.get(id=student_id)
        group = Group.objects.get(id=group_id)
        student.group = group
        student.save()
        bot.answer_callback_query(call.id, "✅ Student's group updated.")
        # Go back to the student view.
        call.data = f"view_student_{student_id}"
        view_student_callback(call)
    except (Student.DoesNotExist, Group.DoesNotExist):
        bot.answer_callback_query(call.id, "Error updating student.", show_alert=True)
        call.data = 'manage_students'
        manage_students_callback(call)


@bot.callback_query_handler(func=lambda call: call.data.startswith('view_student_'))
@admin_required
def view_student_callback(call):
    """Displays details for a specific student."""
    parts = call.data.split('_')
    student_id = int(parts[2])
    page = int(parts[3])
    user_id = call.from_user.id

    # Store the student list page number.
    if user_id not in user_states:
        user_states[user_id] = {}
    user_states[user_id]['last_students_for_group_page'] = page

    try:
        student = Student.objects.select_related('group').get(id=student_id)
        text = (
            f"🧑‍🎓 **Student Profile**\n\n"
            f"**Last Name:** {student.last_name}\n"
            f"**First Name:** {student.first_name}\n"
            f"**Patronymic:** {student.patronymic or 'Not specified'}\n"
            f"**Group:** {student.group.name}"
        )
        markup = InlineKeyboardMarkup(row_width=1)
        markup.add(InlineKeyboardButton("✏️ Edit Student", callback_data=f"edit_student_{student_id}"))
        markup.add(InlineKeyboardButton("🗑 Delete Student", callback_data=f"delete_student_{student_id}"))
        markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data=f"student_manage_group_{student.group.id}"))
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')
    except Student.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Student not found.", show_alert=True)
        manage_students_callback(call)


@bot.callback_query_handler(func=lambda call: call.data.startswith('edit_student_'))
@admin_required
def edit_student_callback(call):
    """Shows options for editing a student's details."""
    student_id = int(call.data.split('_')[-1])
    markup = InlineKeyboardMarkup(row_width=2)
    markup.add(
        InlineKeyboardButton("Last Name", callback_data=f"edit_student_field_lastname_{student_id}"),
        InlineKeyboardButton("First Name", callback_data=f"edit_student_field_firstname_{student_id}")
    )
    markup.add(
        InlineKeyboardButton("Patronymic", callback_data=f"edit_student_field_patronymic_{student_id}"),
        InlineKeyboardButton("Group", callback_data=f"edit_student_field_group_{student_id}")
    )
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data=f"view_student_{student_id}"))
    bot.edit_message_text(
        "Which field do you want to edit?",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )


@bot.callback_query_handler(func=lambda call: call.data.startswith('edit_student_field_'))
@admin_required
def edit_student_field_callback(call):
    """Handles editing a specific field of a student's profile."""
    parts = call.data.split('_')
    field = parts[3]
    student_id = int(parts[4])
    user_id = call.from_user.id

    user_states[user_id] = {'state': f'awaiting_student_{field}_edit', 'student_id': student_id}

    if field == 'group':
        markup = get_group_selection_markup(1, "edit", student_id, user_id)
        bot.edit_message_text(
            "Select the new group for the student:",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup
        )
    else:
        field_name_map = {
            'lastname': 'last name',
            'firstname': 'first name',
            'patronymic': 'patronymic'
        }
        prompt = f"Please enter the new **{field_name_map[field]}**:"
        markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data=f"edit_student_{student_id}"))
        bot.edit_message_text(
            prompt,
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup,
            parse_mode='Markdown'
        )


@bot.callback_query_handler(func=lambda call: call.data.startswith('delete_student_'))
@admin_required
def delete_student_callback(call):
    """Asks for confirmation before deleting a student."""
    student_id = int(call.data.split('_')[-1])
    try:
        student = Student.objects.get(id=student_id)
        text = f"⚠️ Are you sure you want to delete the student **{student.last_name} {student.first_name}**? This action cannot be undone."
        markup = InlineKeyboardMarkup()
        markup.add(InlineKeyboardButton("✅ Yes, Delete", callback_data=f"confirm_delete_student_{student_id}"))
        markup.add(InlineKeyboardButton("❌ No, Cancel", callback_data=f"view_student_{student_id}"))
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')
    except Student.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Student not found.", show_alert=True)
        manage_students_callback(call)


@bot.callback_query_handler(func=lambda call: call.data.startswith('confirm_delete_student_'))
@admin_required
def confirm_delete_student_callback(call):
    """Deletes a student from the database after confirmation."""
    student_id = int(call.data.split('_')[-1])
    try:
        student = Student.objects.get(id=student_id)
        student_name = f"{student.last_name} {student.first_name}"
        group_id = student.group.id
        student.delete()
        bot.answer_callback_query(call.id, f"Student '{student_name}' has been deleted.")
        # Go back to the student list for the group
        call.data = f"student_manage_group_{group_id}"
        select_group_for_student_management_callback(call)
    except Student.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Student not found.", show_alert=True)
        manage_students_callback(call)
    except ProtectedError:
        bot.answer_callback_query(
            call.id,
            "This student cannot be deleted because they have attendance records.",
            show_alert=True
        )
        call.data = f"view_student_{student_id}"
        view_student_callback(call)


# --- AttendanceType Management ---

def get_attendance_types_markup(page: int = 1) -> InlineKeyboardMarkup:
    """
    Creates an inline keyboard for the attendance type list, with pagination.
    """
    markup = InlineKeyboardMarkup()
    types = AttendanceType.objects.order_by('name')

    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_types = types[start_index:end_index]

    for att_type in paginated_types:
        markup.add(InlineKeyboardButton(att_type.name, callback_data=f"view_att_type_{att_type.id}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"att_types_page_{page-1}"))
    if end_index < types.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"att_types_page_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton("➕ Add New Type", callback_data="add_att_type"))
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="main_menu"))
    return markup

@bot.callback_query_handler(func=lambda call: call.data == 'manage_attendance_types' or call.data == 'back_to_att_types')
@admin_required
def manage_attendance_types_callback(call):
    """Displays the list of attendance types for management."""
    user_id = call.from_user.id
    state = user_states.get(user_id, {})
    page = 1

    if call.data == 'back_to_att_types':
        page = state.get('last_att_types_page', 1)
    elif user_id in user_states:
        user_states[user_id].pop('last_att_types_page', None)

    markup = get_attendance_types_markup(page=page)
    try:
        bot.edit_message_text(
            "🏷️ Manage Attendance Types",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup
        )
    except telebot.apihelper.ApiTelegramException:
        bot.send_message(call.message.chat.id, "🏷️ Manage Attendance Types", reply_markup=markup)

@bot.callback_query_handler(func=lambda call: call.data.startswith('att_types_page_'))
@admin_required
def att_types_page_callback(call):
    """Handles pagination for the attendance type list."""
    page = int(call.data.split('_')[-1])
    markup = get_attendance_types_markup(page)
    bot.edit_message_reply_markup(
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data == 'add_att_type')
@admin_required
def add_att_type_callback(call):
    """Starts the process of adding a new attendance type."""
    user_id = call.from_user.id
    user_states[user_id] = {'state': 'awaiting_att_type_name', 'data': {}}

    markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data="back_to_att_types"))
    bot.edit_message_text(
        "Please enter the **name** for the new attendance type (e.g., 'Present', 'Absent'):",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('view_att_type_'))
@admin_required
def view_att_type_callback(call):
    """Displays details for a specific attendance type."""
    parts = call.data.split('_')
    type_id = int(parts[3])
    page = int(parts[4])
    user_id = call.from_user.id

    if user_id not in user_states:
        user_states[user_id] = {}
    user_states[user_id]['last_att_types_page'] = page

    try:
        att_type = AttendanceType.objects.get(id=type_id)
        text = (
            f"🏷️ **Attendance Type Details**\n\n"
            f"**Name:** {att_type.name}\n"
            f"**Description:** {att_type.description or 'Not specified'}"
        )
        markup = InlineKeyboardMarkup(row_width=1)
        markup.add(InlineKeyboardButton("✏️ Edit Type", callback_data=f"edit_att_type_{type_id}"))
        markup.add(InlineKeyboardButton("🗑️ Delete Type", callback_data=f"delete_att_type_{type_id}"))
        markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="back_to_att_types"))
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')
    except AttendanceType.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Attendance Type not found.", show_alert=True)
        manage_attendance_types_callback(call)

@bot.callback_query_handler(func=lambda call: call.data.startswith('edit_att_type_'))
@admin_required
def edit_att_type_callback(call):
    """Shows options for editing an attendance type."""
    type_id = int(call.data.split('_')[-1])
    markup = InlineKeyboardMarkup(row_width=2)
    markup.add(
        InlineKeyboardButton("Name", callback_data=f"edit_att_type_field_name_{type_id}"),
        InlineKeyboardButton("Description", callback_data=f"edit_att_type_field_description_{type_id}")
    )
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data=f"view_att_type_{type_id}"))
    bot.edit_message_text(
        "Which field do you want to edit?",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('edit_att_type_field_'))
@admin_required
def edit_att_type_field_callback(call):
    """Handles editing a specific field of an attendance type."""
    parts = call.data.split('_')
    field = parts[4]
    type_id = int(parts[5])
    user_id = call.from_user.id

    user_states[user_id] = {'state': f'awaiting_att_type_{field}_edit', 'type_id': type_id}

    prompt = f"Please enter the new **{field}**:"
    markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data=f"edit_att_type_{type_id}"))
    bot.edit_message_text(
        prompt,
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('delete_att_type_'))
@admin_required
def delete_att_type_callback(call):
    """Asks for confirmation before deleting an attendance type."""
    type_id = int(call.data.split('_')[-1])
    try:
        att_type = AttendanceType.objects.get(id=type_id)
        text = f"⚠️ Are you sure you want to delete the type **{att_type.name}**?"
        markup = InlineKeyboardMarkup()
        markup.add(InlineKeyboardButton("✅ Yes, Delete", callback_data=f"confirm_delete_att_type_{type_id}"))
        markup.add(InlineKeyboardButton("❌ No, Cancel", callback_data=f"view_att_type_{type_id}"))
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')
    except AttendanceType.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Type not found.", show_alert=True)
        manage_attendance_types_callback(call)

@bot.callback_query_handler(func=lambda call: call.data.startswith('confirm_delete_att_type_'))
@admin_required
def confirm_delete_att_type_callback(call):
    """Deletes an attendance type after confirmation."""
    type_id = int(call.data.split('_')[-1])
    try:
        att_type = AttendanceType.objects.get(id=type_id)
        type_name = att_type.name
        att_type.delete()
        bot.answer_callback_query(call.id, f"Type '{type_name}' has been deleted.")
        manage_attendance_types_callback(call)
    except AttendanceType.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Type not found.", show_alert=True)
        manage_attendance_types_callback(call)
    except ProtectedError:
        bot.answer_callback_query(
            call.id,
            "This type cannot be deleted because it is used in attendance records.",
            show_alert=True
        )
        call.data = f"view_att_type_{type_id}"
        view_att_type_callback(call)


# --- Lesson Management ---

def get_lessons_markup(page: int = 1) -> InlineKeyboardMarkup:
    """
    Creates an inline keyboard for the lesson list, with pagination.
    """
    markup = InlineKeyboardMarkup()
    lessons = Lesson.objects.select_related('group').order_by('-lesson_date', '-lesson_time')

    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_lessons = lessons[start_index:end_index]

    for lesson in paginated_lessons:
        lesson_label = f"{lesson.topic} ({lesson.group.name}) - {lesson.lesson_date.strftime('%Y-%m-%d')}"
        markup.add(InlineKeyboardButton(lesson_label, callback_data=f"view_lesson_{lesson.id}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"lessons_page_{page-1}"))
    if end_index < lessons.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"lessons_page_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton("➕ Add New Lesson", callback_data="add_lesson"))
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="main_menu"))
    return markup

@bot.callback_query_handler(func=lambda call: call.data == 'manage_lessons' or call.data == 'back_to_lessons')
@admin_required
def manage_lessons_callback(call):
    """Displays the list of lessons for management."""
    user_id = call.from_user.id
    state = user_states.get(user_id, {})
    page = 1

    if call.data == 'back_to_lessons':
        page = state.get('last_lessons_page', 1)
    elif user_id in user_states:
        user_states[user_id].pop('last_lessons_page', None)

    markup = get_lessons_markup(page=page)
    try:
        bot.edit_message_text(
            "📅 Manage Lessons",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup
        )
    except telebot.apihelper.ApiTelegramException:
        bot.send_message(call.message.chat.id, "📅 Manage Lessons", reply_markup=markup)

@bot.callback_query_handler(func=lambda call: call.data.startswith('lessons_page_'))
@admin_required
def lessons_page_callback(call):
    """Handles pagination for the lesson list."""
    page = int(call.data.split('_')[-1])
    markup = get_lessons_markup(page)
    bot.edit_message_reply_markup(
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data == 'add_lesson')
@admin_required
def add_lesson_callback(call):
    """Starts the multi-step process of adding a new lesson."""
    user_id = call.from_user.id
    user_states[user_id] = {'state': 'awaiting_lesson_topic', 'data': {}}

    markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data="back_to_lessons"))
    bot.edit_message_text(
        "Please enter the **topic** for the new lesson:",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup,
        parse_mode='Markdown'
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('select_lesson_group_'))
@admin_required
def select_lesson_group_callback(call):
    """
    Continues the process of adding or editing a lesson after group selection.
    """
    user_id = call.from_user.id
    state_info = user_states.get(user_id)
    if not state_info:
        # Handle expired state by simply returning.
        return

    group_id = int(call.data.split('_')[-1])
    state_info['data']['group_id'] = group_id

    if state_info['state'] == 'awaiting_lesson_group_edit':
        # This is part of an edit flow.
        lesson_id = state_info.get('lesson_id')
        try:
            lesson = Lesson.objects.get(id=lesson_id)
            lesson.group_id = group_id
            lesson.save()
            bot.answer_callback_query(call.id, "✅ Lesson's group updated.")
            clear_user_state(user_id)
            call.data = f"view_lesson_{lesson_id}"
            view_lesson_callback(call)
        except Lesson.DoesNotExist:
            bot.answer_callback_query(call.id, "Error: Lesson not found.", show_alert=True)
            clear_user_state(user_id)
            manage_lessons_callback(call)
    else:
        # This is part of an add flow.
        user_states[user_id]['state'] = 'awaiting_lesson_date'
        markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data="back_to_lessons"))
        bot.edit_message_text(
            "Great. Now enter the lesson **date** (e.g., YYYY-MM-DD):",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup,
            parse_mode='Markdown'
        )

@bot.callback_query_handler(func=lambda call: call.data.startswith('view_lesson_'))
@admin_required
def view_lesson_callback(call):
    """Displays details for a specific lesson."""
    parts = call.data.split('_')
    lesson_id = int(parts[2])
    page = int(parts[3])
    user_id = call.from_user.id

    if user_id not in user_states:
        user_states[user_id] = {}
    user_states[user_id]['last_lessons_page'] = page

    try:
        lesson = Lesson.objects.select_related('group').get(id=lesson_id)
        text = (
            f"📅 **Lesson Details**\n\n"
            f"**Topic:** {lesson.topic}\n"
            f"**Group:** {lesson.group.name}\n"
            f"**Date:** {lesson.lesson_date.strftime('%Y-%m-%d')}\n"
            f"**Time:** {lesson.lesson_time.strftime('%H:%M')}"
        )
        markup = InlineKeyboardMarkup(row_width=1)
        markup.add(InlineKeyboardButton("✏️ Edit Lesson", callback_data=f"edit_lesson_{lesson_id}"))
        markup.add(InlineKeyboardButton("🗑️ Delete Lesson", callback_data=f"delete_lesson_{lesson_id}"))
        markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="back_to_lessons"))
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')
    except Lesson.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Lesson not found.", show_alert=True)
        manage_lessons_callback(call)

@bot.callback_query_handler(func=lambda call: call.data.startswith('edit_lesson_'))
@admin_required
def edit_lesson_callback(call):
    """Shows options for editing a lesson."""
    lesson_id = int(call.data.split('_')[-1])
    markup = InlineKeyboardMarkup(row_width=2)
    markup.add(
        InlineKeyboardButton("Topic", callback_data=f"edit_lesson_field_topic_{lesson_id}"),
        InlineKeyboardButton("Group", callback_data=f"edit_lesson_field_group_{lesson_id}")
    )
    markup.add(
        InlineKeyboardButton("Date", callback_data=f"edit_lesson_field_date_{lesson_id}"),
        InlineKeyboardButton("Time", callback_data=f"edit_lesson_field_time_{lesson_id}")
    )
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data=f"view_lesson_{lesson_id}"))
    bot.edit_message_text(
        "Which field do you want to edit?",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('edit_lesson_field_'))
@admin_required
def edit_lesson_field_callback(call):
    """Handles editing a specific field of a lesson."""
    parts = call.data.split('_')
    field = parts[3]
    lesson_id = int(parts[4])
    user_id = call.from_user.id

    user_states[user_id] = {'state': f'awaiting_lesson_{field}_edit', 'lesson_id': lesson_id}

    if field == 'group':
        # This is a simplified group selection for editing a lesson.
        # A paginated version could be implemented for scalability.
        markup = InlineKeyboardMarkup()
        groups = Group.objects.order_by('name')
        for group in groups:
            markup.add(InlineKeyboardButton(group.name, callback_data=f"select_lesson_group_{group.id}"))
        markup.add(InlineKeyboardButton("❌ Cancel", callback_data=f"edit_lesson_{lesson_id}"))
        bot.edit_message_text("Select the new group:", call.message.chat.id, call.message.message_id, reply_markup=markup)
    else:
        field_prompts = {
            'topic': "topic",
            'date': "date (YYYY-MM-DD)",
            'time': "time (HH:MM)"
        }
        prompt = f"Please enter the new **{field_prompts[field]}**:"
        markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data=f"edit_lesson_{lesson_id}"))
        bot.edit_message_text(prompt, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')

@bot.callback_query_handler(func=lambda call: call.data.startswith('delete_lesson_'))
@admin_required
def delete_lesson_callback(call):
    """Asks for confirmation before deleting a lesson."""
    lesson_id = int(call.data.split('_')[-1])
    try:
        lesson = Lesson.objects.get(id=lesson_id)
        text = f"⚠️ Are you sure you want to delete the lesson **{lesson.topic}** on {lesson.lesson_date}?"
        markup = InlineKeyboardMarkup()
        markup.add(InlineKeyboardButton("✅ Yes, Delete", callback_data=f"confirm_delete_lesson_{lesson_id}"))
        markup.add(InlineKeyboardButton("❌ No, Cancel", callback_data=f"view_lesson_{lesson_id}"))
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup, parse_mode='Markdown')
    except Lesson.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Lesson not found.", show_alert=True)
        manage_lessons_callback(call)

@bot.callback_query_handler(func=lambda call: call.data.startswith('confirm_delete_lesson_'))
@admin_required
def confirm_delete_lesson_callback(call):
    """Deletes a lesson after confirmation."""
    lesson_id = int(call.data.split('_')[-1])
    try:
        lesson = Lesson.objects.get(id=lesson_id)
        lesson_topic = lesson.topic
        lesson.delete()
        bot.answer_callback_query(call.id, f"Lesson '{lesson_topic}' has been deleted.")
        manage_lessons_callback(call)
    except Lesson.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Lesson not found.", show_alert=True)
        manage_lessons_callback(call)
    except ProtectedError:
        bot.answer_callback_query(
            call.id,
            "This lesson cannot be deleted because it has attendance records.",
            show_alert=True
        )
        call.data = f"view_lesson_{lesson_id}"
        view_lesson_callback(call)


# --- Attendance Journal Management ---

# The attendance journal workflow is a multi-step process:
# 1. Select Group -> 2. Select Date -> 3. Select Lesson -> 4. Mark Students

def get_journal_groups_markup(page: int = 1) -> InlineKeyboardMarkup:
    """Step 1: Creates a keyboard to select a group for the journal."""
    markup = InlineKeyboardMarkup()
    groups = Group.objects.order_by('name')

    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_groups = groups[start_index:end_index]

    for group in paginated_groups:
        markup.add(InlineKeyboardButton(group.name, callback_data=f"journal_select_group_{group.id}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"journal_groups_page_{page-1}"))
    if end_index < groups.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"journal_groups_page_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="main_menu"))
    return markup

@bot.callback_query_handler(func=lambda call: call.data == 'manage_journal')
@admin_required
def manage_journal_callback(call):
    """Displays the initial group selection screen for managing attendance."""
    user_id = call.from_user.id
    state = user_states.get(user_id, {})
    page = state.get('last_journal_groups_page', 1)

    # Clear deeper-level page states.
    if user_id in user_states:
        user_states[user_id].pop('last_journal_dates_page', None)
        user_states[user_id].pop('last_journal_lessons_page', None)
        user_states[user_id].pop('last_journal_students_page', None)

    markup = get_journal_groups_markup(page=page)
    bot.edit_message_text(
        "Step 1: Select a group",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('journal_groups_page_'))
@admin_required
def journal_groups_page_callback(call):
    """Paginates through the group list for the attendance journal."""
    page = int(call.data.split('_')[-1])
    markup = get_journal_groups_markup(page)
    bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=markup)

def get_journal_dates_markup(group_id: int, page: int = 1):
    """
    Step 2: Creates a keyboard with dates that have lessons for a group.
    """
    markup = InlineKeyboardMarkup()
    lesson_dates = Lesson.objects.filter(group_id=group_id)\
                                 .values_list('lesson_date', flat=True)\
                                 .distinct()\
                                 .order_by('-lesson_date')

    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_dates = lesson_dates[start_index:end_index]

    if not lesson_dates.exists():
        markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="manage_journal"))
        return markup, False

    for lesson_date in paginated_dates:
        date_str = lesson_date.strftime('%Y-%m-%d')
        markup.add(InlineKeyboardButton(date_str, callback_data=f"journal_select_date_{group_id}_{date_str}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"journal_dates_page_{group_id}_{page-1}"))
    if end_index < lesson_dates.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"journal_dates_page_{group_id}_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data="manage_journal"))
    return markup, True

@bot.callback_query_handler(func=lambda call: call.data.startswith('journal_select_group_'))
@admin_required
def journal_select_group_callback(call):
    """Displays a list of dates with lessons for the selected group."""
    parts = call.data.split('_')
    group_id = int(parts[3])
    user_id = call.from_user.id
    state = user_states.get(user_id, {})
    page_to_show = 1

    # Coming from group list, save the page number
    if len(parts) > 4:
        page = int(parts[4])
        if user_id not in user_states:
            user_states[user_id] = {}
        user_states[user_id]['last_journal_groups_page'] = page
    # Coming back from lesson list
    else:
        page_to_show = state.get('last_journal_dates_page', 1)

    # Clear deeper-level page states.
    if user_id in user_states:
        user_states[user_id].pop('last_journal_lessons_page', None)
        user_states[user_id].pop('last_journal_students_page', None)

    markup, has_dates = get_journal_dates_markup(group_id, page=page_to_show)
    text = "Step 2: Select a date" if has_dates else "This group has no scheduled lessons."

    bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup)

@bot.callback_query_handler(func=lambda call: call.data.startswith('journal_dates_page_'))
@admin_required
def journal_dates_page_callback(call):
    """Paginates through the date list for the attendance journal."""
    parts = call.data.split('_')
    group_id = int(parts[3])
    page = int(parts[4])
    markup, _ = get_journal_dates_markup(group_id, page)
    bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=markup)

def get_journal_lessons_for_date_markup(group_id: int, date_str: str, page: int = 1) -> InlineKeyboardMarkup:
    """
    Step 3: Creates a keyboard with lessons for a specific group and date.
    """
    markup = InlineKeyboardMarkup()
    lesson_date = datetime.datetime.strptime(date_str, '%Y-%m-%d').date()
    lessons = Lesson.objects.filter(group_id=group_id, lesson_date=lesson_date).order_by('lesson_time')

    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_lessons = lessons[start_index:end_index]

    for lesson in paginated_lessons:
        label = f"{lesson.lesson_time.strftime('%H:%M')} - {lesson.topic}"
        markup.add(InlineKeyboardButton(label, callback_data=f"journal_lesson_{lesson.id}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"journal_lessons_for_date_page_{group_id}_{date_str}_{page-1}"))
    if end_index < lessons.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"journal_lessons_for_date_page_{group_id}_{date_str}_{page+1}"))
    if row:
        markup.row(*row)

    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data=f"journal_select_group_{group_id}")) # Back to date selection
    return markup

@bot.callback_query_handler(func=lambda call: call.data.startswith('journal_select_date_'))
@admin_required
def journal_select_date_callback(call):
    """Displays a list of lessons for the selected group and date."""
    parts = call.data.split('_')
    group_id = int(parts[3])
    date_str = parts[4]
    user_id = call.from_user.id
    state = user_states.get(user_id, {})
    page_to_show = 1

    # Coming from the date list, save the page number
    if len(parts) > 5:
        page = int(parts[5])
        if user_id not in user_states:
            user_states[user_id] = {}
        user_states[user_id]['last_journal_dates_page'] = page
    # Coming back from student list
    else:
        page_to_show = state.get('last_journal_lessons_page', 1)

    if user_id in user_states:
        user_states[user_id].pop('last_journal_students_page', None)

    markup = get_journal_lessons_for_date_markup(group_id, date_str, page=page_to_show)
    bot.edit_message_text(
        f"Step 3: Select a lesson for {date_str}",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('journal_lessons_for_date_page_'))
@admin_required
def journal_lessons_for_date_page_callback(call):
    """Paginates through the lesson list for a specific date."""
    parts = call.data.split('_')
    group_id = int(parts[5])
    date_str = parts[6]
    page = int(parts[7])
    markup = get_journal_lessons_for_date_markup(group_id, date_str, page)
    bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=markup)

def get_journal_students_markup(lesson_id: int, page: int = 1) -> InlineKeyboardMarkup:
    """
    Step 4: Creates a keyboard with students for a lesson to mark attendance.
    Each student button shows their current attendance status.
    """
    markup = InlineKeyboardMarkup()
    try:
        lesson = Lesson.objects.select_related('group').get(id=lesson_id)
    except Lesson.DoesNotExist:
        return None  # Should be handled by the caller.

    students = Student.objects.filter(group=lesson.group).order_by('last_name')
    # Fetch all journal entries for this lesson in one query for efficiency.
    journal_entries = {entry.student_id: entry.status.name for entry in AttendanceJournal.objects.filter(lesson=lesson)}

    page_size = 5
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    paginated_students = students[start_index:end_index]

    for student in paginated_students:
        status = journal_entries.get(student.id, "Not Marked")
        label = f"{student.last_name} {student.first_name}: {status}"
        markup.add(InlineKeyboardButton(label, callback_data=f"change_att_status_{lesson.id}_{student.id}_{page}"))

    row = []
    if start_index > 0:
        row.append(InlineKeyboardButton("⬅️ Prev", callback_data=f"journal_students_page_{lesson_id}_{page-1}"))
    if end_index < students.count():
        row.append(InlineKeyboardButton("Next ➡️", callback_data=f"journal_students_page_{lesson_id}_{page+1}"))
    if row:
        markup.row(*row)

    # Back button goes to the list of lessons for that date.
    date_str = lesson.lesson_date.strftime('%Y-%m-%d')
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data=f"journal_select_date_{lesson.group.id}_{date_str}"))
    return markup

@bot.callback_query_handler(func=lambda call: call.data.startswith('journal_lesson_') or call.data.startswith('journal_students_page_'))
@admin_required
def journal_lesson_callback(call):
    """
    Displays the list of students for a lesson to manage their attendance.
    Also handles pagination for this list.
    """
    parts = call.data.split('_')
    user_id = call.from_user.id
    state = user_states.get(user_id, {})
    page_to_show = 1

    if call.data.startswith('journal_students_page_'):
        # Case: Paginating the student list
        lesson_id = int(parts[3])
        page_to_show = int(parts[4])
    else: # journal_lesson_...
        lesson_id = int(parts[2])
        # Case: Coming from lesson list
        if len(parts) > 3:
            lesson_list_page = int(parts[3])
            if user_id not in user_states:
                user_states[user_id] = {}
            user_states[user_id]['last_journal_lessons_page'] = lesson_list_page
        # Case: Returning from status selection
        else:
            page_to_show = state.get('last_journal_students_page', 1)

    markup = get_journal_students_markup(lesson_id, page_to_show)
    if not markup:
        bot.answer_callback_query(call.id, "Error: Lesson not found.", show_alert=True)
        call.data = 'manage_journal'
        manage_journal_callback(call)
        return

    bot.edit_message_text(
        "Step 4: Mark attendance for each student",
        call.message.chat.id,
        call.message.message_id,
        reply_markup=markup
    )

def get_journal_att_types_markup(lesson_id: int, student_id: int) -> InlineKeyboardMarkup:
    """Creates a keyboard to select an attendance type for a student."""
    markup = InlineKeyboardMarkup()
    types = AttendanceType.objects.order_by('name')
    for att_type in types:
        markup.add(InlineKeyboardButton(att_type.name, callback_data=f"set_att_status_{lesson_id}_{student_id}_{att_type.id}"))
    # Back button returns to the student list for the current lesson.
    markup.add(InlineKeyboardButton(NAME_BTN_BACK, callback_data=f"journal_lesson_{lesson_id}"))
    return markup

@bot.callback_query_handler(func=lambda call: call.data.startswith('change_att_status_'))
@admin_required
def change_att_status_callback(call):
    """Shows a list of attendance types to choose from for a student."""
    parts = call.data.split('_')
    lesson_id = int(parts[3])
    student_id = int(parts[4])
    page = int(parts[5])
    user_id = call.from_user.id

    if user_id not in user_states:
        user_states[user_id] = {}
    user_states[user_id]['last_journal_students_page'] = page

    try:
        student = Student.objects.get(id=student_id)
        markup = get_journal_att_types_markup(lesson_id, student_id)
        bot.edit_message_text(
            f"Set status for **{student.last_name} {student.first_name}**:",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup,
            parse_mode='Markdown'
        )
    except Student.DoesNotExist:
        bot.answer_callback_query(call.id, "Error: Student not found.", show_alert=True)

@bot.callback_query_handler(func=lambda call: call.data.startswith('set_att_status_'))
@admin_required
def set_att_status_callback(call):
    """Sets the attendance status for a student in a specific lesson."""
    parts = call.data.split('_')
    lesson_id = int(parts[3])
    student_id = int(parts[4])
    status_id = int(parts[5])

    # update_or_create handles both creating a new entry and updating an existing one.
    AttendanceJournal.objects.update_or_create(
        lesson_id=lesson_id,
        student_id=student_id,
        defaults={'status_id': status_id}
    )

    bot.answer_callback_query(call.id, "Status updated.")

    # Go back to the student list for that lesson to show the change.
    call.data = f"journal_lesson_{lesson_id}"
    journal_lesson_callback(call)


# --- Message History and State Handler ---

@bot.message_handler(func=lambda message: True, content_types=['text'])
def handle_text_messages(message):
    """
    Handles all incoming text messages that are not commands.

    This function is the core of the state-based conversation management.
    - If the user is in a specific state (e.g., 'awaiting_group_name'), it
      processes the text as input for that state.
    - If the user is not in a state, it logs the message to history (if the
      user is registered).
    """
    user_id = message.from_user.id
    state_info = user_states.get(user_id)

    # --- State Handling ---
    if state_info:
        state = state_info.get('state')

        # Generic cancel command to exit any state.
        if message.text.lower() == '/cancel':
             clear_user_state(user_id)
             bot.reply_to(message, "Action cancelled.")
             # Send a new main menu since the previous message might be from the bot.
             send_admin_menu(user_id)
             return

        # --- Group Creation State ---
        if state == 'awaiting_group_name':
            group_name = message.text.strip()
            if not group_name:
                bot.reply_to(message, "Group name cannot be empty. Please try again or type /cancel.")
                return

            if Group.objects.filter(name=group_name).exists():
                bot.reply_to(message, f"A group with the name '{group_name}' already exists. Please choose a different name.")
                return

            Group.objects.create(name=group_name)
            bot.reply_to(message, f"✅ Group '{group_name}' created successfully.")
            clear_user_state(user_id)
            # Create a mock call object to refresh the group list without user interaction.
            mock_call = type('MockCall', (), {'message': message, 'from_user': message.from_user})
            manage_groups_callback(mock_call)
            return

        # --- Group Edit State ---
        elif state == 'awaiting_group_name_edit':
            new_name = message.text.strip()
            group_id = state_info.get('group_id')
            if not new_name:
                bot.reply_to(message, "Group name cannot be empty. Please try again or type /cancel.")
                return

            # Ensure the new name is not already taken by another group.
            if Group.objects.filter(name=new_name).exclude(id=group_id).exists():
                bot.reply_to(message, f"A group with the name '{new_name}' already exists. Please choose a different name.")
                return

            try:
                group = Group.objects.get(id=group_id)
                group.name = new_name
                group.save()
                bot.reply_to(message, f"✅ Group name updated to '{new_name}'.")
                clear_user_state(user_id)
                # Create a mock call to return to the group view.
                mock_call = type('MockCall', (), {'message': message, 'from_user': message.from_user, 'data': f'view_group_{group_id}'})
                view_group_callback(mock_call)
            except Group.DoesNotExist:
                bot.reply_to(message, "An error occurred: The group was not found.")
                clear_user_state(user_id)
            return

        # --- Student Creation States ---
        elif state == 'awaiting_student_lastname':
            last_name = message.text.strip()
            if not last_name:
                bot.reply_to(message, "Last name cannot be empty. Please try again or type /cancel.")
                return
            user_states[user_id]['data']['last_name'] = last_name
            user_states[user_id]['state'] = 'awaiting_student_firstname'
            group_id = user_states[user_id]['data']['group_id']
            markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data=f"student_manage_group_{group_id}"))
            bot.send_message(user_id, "Great. Now enter the student's **first name**:", reply_markup=markup, parse_mode='Markdown')
            return

        elif state == 'awaiting_student_firstname':
            first_name = message.text.strip()
            if not first_name:
                bot.reply_to(message, "First name cannot be empty. Please try again or type /cancel.")
                return
            user_states[user_id]['data']['first_name'] = first_name
            user_states[user_id]['state'] = 'awaiting_student_patronymic'
            group_id = user_states[user_id]['data']['group_id']
            markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data=f"student_manage_group_{group_id}"))
            bot.send_message(user_id, "Got it. Now enter the student's **patronymic** (or type 'skip' if not applicable):", reply_markup=markup, parse_mode='Markdown')
            return

        elif state == 'awaiting_student_patronymic':
            patronymic = message.text.strip()
            if patronymic.lower() != 'skip':
                user_states[user_id]['data']['patronymic'] = patronymic

            state_info = user_states.get(user_id)
            if not state_info or 'data' not in state_info or 'group_id' not in state_info['data']:
                 bot.reply_to(message, "An error occurred (group not found). Please start over.")
                 clear_user_state(user_id)
                 return

            student_data = state_info['data']
            group_id = student_data['group_id']
            try:
                group = Group.objects.get(id=group_id)
                Student.objects.create(
                    first_name=student_data['first_name'],
                    last_name=student_data['last_name'],
                    patronymic=student_data.get('patronymic', ''),
                    group=group
                )
                bot.reply_to(message, "✅ Student added successfully!")
                clear_user_state(user_id)
                # Return to the student list for that group.
                mock_call = type('MockCall', (), {'message': message, 'from_user': message.from_user, 'data': f"student_manage_group_{group_id}"})
                select_group_for_student_management_callback(mock_call)
            except Group.DoesNotExist:
                bot.reply_to(message, "Error: Selected group not found.")
                clear_user_state(user_id)
            return

        # --- Student Edit States ---
        elif state.startswith('awaiting_student_') and state.endswith('_edit'):
            field_text = message.text.strip()
            student_id = state_info.get('student_id')
            # Extract field name (e.g., 'lastname') from state string.
            field_to_edit = state.replace('awaiting_student_', '').replace('_edit', '')

            if not field_text:
                bot.reply_to(message, "The field cannot be empty. Please try again or type /cancel.")
                return

            try:
                student = Student.objects.get(id=student_id)

                # Map state-derived field name to the actual model field name.
                field_map = {
                    'lastname': 'last_name',
                    'firstname': 'first_name',
                    'patronymic': 'patronymic'
                }
                model_field = field_map.get(field_to_edit)

                if model_field:
                    setattr(student, model_field, field_text if field_text.lower() != 'skip' else '')
                    student.save()
                    bot.reply_to(message, f"✅ Student's {field_to_edit} has been updated.")
                    clear_user_state(user_id)
                    # Create mock call to return to the student view.
                    mock_call = type('MockCall', (), {'message': message, 'from_user': message.from_user, 'data': f'view_student_{student_id}'})
                    view_student_callback(mock_call)
                else:
                    bot.reply_to(message, "An unknown error occurred during editing.")
                    clear_user_state(user_id)

            except Student.DoesNotExist:
                bot.reply_to(message, "Error: Student not found.")
                clear_user_state(user_id)
                manage_students_callback(type('MockCall', (), {'message': message, 'from_user': message.from_user}))
            return

        # --- Attendance Type Creation States ---
        elif state == 'awaiting_att_type_name':
            name = message.text.strip()
            if not name:
                bot.reply_to(message, "Name cannot be empty. Please try again or type /cancel.")
                return
            if AttendanceType.objects.filter(name=name).exists():
                bot.reply_to(message, f"An attendance type with the name '{name}' already exists.")
                return

            user_states[user_id]['data']['name'] = name
            user_states[user_id]['state'] = 'awaiting_att_type_description'
            markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data="back_to_att_types"))
            bot.send_message(user_id, "Great. Now enter a short **description** (or type 'skip'):", reply_markup=markup, parse_mode='Markdown')
            return

        elif state == 'awaiting_att_type_description':
            description = message.text.strip()
            type_data = state_info['data']

            AttendanceType.objects.create(
                name=type_data['name'],
                description=description if description.lower() != 'skip' else ''
            )

            bot.reply_to(message, f"✅ Attendance type '{type_data['name']}' created successfully.")
            clear_user_state(user_id)
            manage_attendance_types_callback(type('MockCall', (), {'message': message, 'from_user': message.from_user}))
            return

        # --- Attendance Type Edit States ---
        elif state == 'awaiting_att_type_name_edit' or state == 'awaiting_att_type_description_edit':
            text = message.text.strip()
            type_id = state_info.get('type_id')
            field = 'name' if 'name' in state else 'description'

            if not text:
                bot.reply_to(message, "Input cannot be empty. Please try again or type /cancel.")
                return

            try:
                att_type = AttendanceType.objects.get(id=type_id)

                if field == 'name' and AttendanceType.objects.filter(name=text).exclude(id=type_id).exists():
                    bot.reply_to(message, f"An attendance type with the name '{text}' already exists.")
                    return

                setattr(att_type, field, text if text.lower() != 'skip' else '')
                att_type.save()

                bot.reply_to(message, f"✅ Attendance type's {field} has been updated.")
                clear_user_state(user_id)
                view_att_type_callback(type('MockCall', (), {'message': message, 'from_user': message.from_user, 'data': f'view_att_type_{type_id}'}))

            except AttendanceType.DoesNotExist:
                bot.reply_to(message, "Error: Attendance type not found.")
                clear_user_state(user_id)
            return

        # --- Export State Handling ---
        elif state == 'awaiting_export_start_date':
            date_str = message.text.strip()
            try:
                start_date = datetime.datetime.strptime(date_str, '%Y-%m-%d').date()
                user_states[user_id]['start_date'] = start_date
                user_states[user_id]['state'] = 'awaiting_export_end_date'
                markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data="main_menu"))
                bot.send_message(user_id, "Great. Now enter the end date for the report (e.g., YYYY-MM-DD):", reply_markup=markup)
            except ValueError:
                bot.reply_to(message, "Invalid date format. Please use YYYY-MM-DD or type /cancel.")
            return

        elif state == 'awaiting_export_end_date':
            date_str = message.text.strip()
            try:
                end_date = datetime.datetime.strptime(date_str, '%Y-%m-%d').date()
                start_date = state_info.get('start_date')
                group_id = state_info.get('group_id')

                if not start_date or not group_id:
                    bot.reply_to(message, "An error occurred (missing data). Please start over with /export.")
                    clear_user_state(user_id)
                    return

                if end_date < start_date:
                    bot.reply_to(message, "End date cannot be earlier than the start date. Please enter a valid end date.")
                    return

                bot.send_message(user_id, "Generating your report, please wait...")

                # Generate and send the file.
                file_stream, filename = generate_attendance_report(group_id, start_date, end_date)
                bot.send_document(user_id, file_stream, visible_file_name=filename)

                clear_user_state(user_id)

            except ValueError:
                bot.reply_to(message, "Invalid date format. Please use YYYY-MM-DD or type /cancel.")
            except Exception as e:
                bot.reply_to(message, f"An unexpected error occurred while generating the report: {e}")
                clear_user_state(user_id)
            return

        # --- Lesson Creation States ---
        elif state == 'awaiting_lesson_topic':
            topic = message.text.strip()
            if not topic:
                bot.reply_to(message, "Topic cannot be empty. Please try again or type /cancel.")
                return

            user_states[user_id]['data']['topic'] = topic
            user_states[user_id]['state'] = 'awaiting_lesson_group'

            markup = InlineKeyboardMarkup()
            groups = Group.objects.order_by('name')
            for group in groups:
                 markup.add(InlineKeyboardButton(group.name, callback_data=f"select_lesson_group_{group.id}"))
            markup.add(InlineKeyboardButton("❌ Cancel", callback_data="back_to_lessons"))

            bot.send_message(user_id, "Topic saved. Now, select the group for this lesson:", reply_markup=markup)
            return

        elif state == 'awaiting_lesson_date':
            date_str = message.text.strip()
            try:
                lesson_date = datetime.datetime.strptime(date_str, '%Y-%m-%d').date()
                user_states[user_id]['data']['lesson_date'] = lesson_date
                user_states[user_id]['state'] = 'awaiting_lesson_time'
                markup = InlineKeyboardMarkup().add(InlineKeyboardButton("❌ Cancel", callback_data="back_to_lessons"))
                bot.send_message(user_id, "Date saved. Now enter the lesson **time** (e.g., HH:MM):", reply_markup=markup, parse_mode='Markdown')
            except ValueError:
                bot.reply_to(message, "Invalid date format. Please use YYYY-MM-DD or type /cancel.")
            return

        elif state == 'awaiting_lesson_time':
            time_str = message.text.strip()
            try:
                lesson_time = datetime.datetime.strptime(time_str, '%H:%M').time()
                lesson_data = state_info['data']

                group = Group.objects.select_related('default_attendance_status').get(id=lesson_data['group_id'])

                new_lesson = Lesson.objects.create(
                    topic=lesson_data['topic'],
                    group=group,
                    lesson_date=lesson_data['lesson_date'],
                    lesson_time=lesson_time
                )

                # If the group has a default attendance status, automatically create
                # journal entries for all students in the group.
                if group.default_attendance_status:
                    students_in_group = Student.objects.filter(group=group)
                    journal_entries = [
                        AttendanceJournal(
                            student=student,
                            lesson=new_lesson,
                            status=group.default_attendance_status
                        )
                        for student in students_in_group
                    ]
                    AttendanceJournal.objects.bulk_create(journal_entries)
                    bot.reply_to(message, f"✅ Lesson created successfully!\nAttendance has been pre-filled with the group's default status: '{group.default_attendance_status.name}'.")
                else:
                    bot.reply_to(message, "✅ Lesson created successfully!")

                clear_user_state(user_id)
                manage_lessons_callback(type('MockCall', (), {'message': message, 'from_user': message.from_user}))

            except ValueError:
                bot.reply_to(message, "Invalid time format. Please use HH:MM or type /cancel.")
            except Group.DoesNotExist:
                 bot.reply_to(message, "An error occurred: The selected group was not found.")
                 clear_user_state(user_id)
            return

        # --- Lesson Edit States ---
        elif state in ['awaiting_lesson_topic_edit', 'awaiting_lesson_date_edit', 'awaiting_lesson_time_edit']:
            text = message.text.strip()
            lesson_id = state_info.get('lesson_id')
            field = state.replace('awaiting_lesson_', '').replace('_edit', '')

            if not text:
                bot.reply_to(message, "Input cannot be empty. Please try again or type /cancel.")
                return

            try:
                lesson = Lesson.objects.get(id=lesson_id)

                # Update the correct field based on the state.
                if field == 'date':
                    new_value = datetime.datetime.strptime(text, '%Y-%m-%d').date()
                    lesson.lesson_date = new_value
                elif field == 'time':
                    new_value = datetime.datetime.strptime(text, '%H:%M').time()
                    lesson.lesson_time = new_value
                else:  # topic
                    lesson.topic = text

                lesson.save()
                bot.reply_to(message, f"✅ Lesson's {field} has been updated.")
                clear_user_state(user_id)
                view_lesson_callback(type('MockCall', (), {'message': message, 'from_user': message.from_user, 'data': f'view_lesson_{lesson_id}'}))

            except Lesson.DoesNotExist:
                bot.reply_to(message, "Error: Lesson not found.")
                clear_user_state(user_id)
            except ValueError:
                bot.reply_to(message, "Invalid format. Please check your input and try again.")
            return

    # --- Message History Saving ---
    # Log non-command messages from registered users to the database.
    if message.text.startswith('/'):
        # Reply for unrecognized commands to guide the user.
        bot.reply_to(message, "Unknown command. Use /menu to see available admin commands.")
        return

    try:
        user = TelegramUser.objects.get(user_id=message.from_user.id)
        MessageHistory.objects.create(user=user, text=message.text)
    except TelegramUser.DoesNotExist:
        pass


# --- Main Loop ---
if __name__ == "__main__":
    print("Bot is starting...")
    try:
        # Start the bot's polling loop. skip_pending=True ignores messages
        # sent while the bot was offline.
        bot.infinity_polling(skip_pending=True)
    except Exception as e:
        print(f"An error occurred: {e}")
        # In a real-world scenario, you might want to add more robust error
        # handling or restart logic here.
    finally:
        print("Bot has stopped.")