Untitled

f=services/bot/core/handlers/__init__.py
f=services/bot/core/handlers/moderation.py
f=services/bot/core/markups/gosb.py
f=services/bot/core/markups/terbank.py
--- services/bot/core/handlers/__init__.py ---
from .admin import admin_menu_handler
from .ai import ai_assistant_handler, ai_rt, event_source_callback_handler
from .event import (
    event_participants_open_handler,
    event_user_enter_code_start_handler,
    event_user_sign_out_handler,
    event_user_sign_up_handler,
    events_menu_handler,
    part_events_menu_handler,
    part_events_page_handler,
    user_events_open_handler,
    user_events_page_handler,
    user_events_rt,
)
from .events_filters import (
    events_filters_apply_handler,
    events_filters_back_handler,
    events_filters_mode_open_handler,
    events_filters_mode_select_handler,
    events_filters_not_implemented_handler,
    events_filters_open_handler,
    events_filters_reset_handler,
    events_filters_tags_open_handler,
    events_filters_tags_toggle_handler,
)
from .main import main_menu_handler, start_handler
from .moderation import (
    all_events_handler,
    all_events_open_handler,
    all_events_page_handler,
    create_event_start_handler,
    event_create_back_to_time_handler,
    event_menu_delete_handler,
    event_menu_edit_field_handler,
    event_menu_edit_handler,
    event_menu_enter_code_start_handler,
    event_menu_sign_out_handler,
    event_menu_sign_up_handler,
    event_tags_toggle_handler,
    event_view_by_id_start,
    events_rt,
    gosb_approved,
    gosb_update_selected,
    moderation_menu_handler,
    my_events_handler,
    my_events_open_handler,
    my_events_page_handler,
    tb_approved,
    tb_reselect_handler,
    tb_update_selected,
)
from .noop import noop_handler
from .points import points_event_open_handler, points_menu_handler, points_page_handler, points_rt
from .profile import (
    my_profile_handler,
    profile_tags_toggle_handler,
    update_user_interests_start,
    update_user_menu_handler,
    update_user_name_start,
)
from .profile import rt as update_user_rt
from .report import (
    report_create_start_handler,
    report_rt,
    report_view_handler,
    reports_export_handler,
)
from .request import (
    all_requests_handler,
    request_approve_handler,
    request_open_handler,
    request_reject_handler,
    requests_next_page_handler,
    requests_page_handler,
    requests_prev_page_handler,
    requests_rt,
)
from .view_by_uuid import rt as view_by_uuid_rt
from .view_by_uuid import view_by_uuid_start_handler
from .volunteer_home import points_leaderboard_handler, volunteer_home_handler

__all__ = [
    "admin_menu_handler",
    "ai_assistant_handler",
    "ai_assistant_handler",
    "ai_rt",
    "all_events_handler",
    "all_events_open_handler",
    "all_events_page_handler",
    "all_requests_handler",
    "create_event_start_handler",
    "event_create_back_to_time_handler",
    "event_menu_delete_handler",
    "event_menu_edit_field_handler",
    "event_menu_edit_handler",
    "event_menu_enter_code_start_handler",
    "event_menu_sign_out_handler",
    "event_menu_sign_up_handler",
    "event_participants_open_handler",
    "event_source_callback_handler",
    "event_tags_toggle_handler",
    "event_user_enter_code_start_handler",
    "event_user_sign_out_handler",
    "event_user_sign_up_handler",
    "event_view_by_id_start",
    "events_filters_apply_handler",
    "events_filters_back_handler",
    "events_filters_mode_open_handler",
    "events_filters_mode_select_handler",
    "events_filters_not_implemented_handler",
    "events_filters_open_handler",
    "events_filters_reset_handler",
    "events_filters_tags_open_handler",
    "events_filters_tags_toggle_handler",
    "events_menu_handler",
    "events_rt",
    "gosb_approved",
    "gosb_update_selected",
    "main_menu_handler",
    "moderation_menu_handler",
    "my_events_handler",
    "my_events_open_handler",
    "my_events_page_handler",
    "my_profile_handler",
    "noop_handler",
    "part_events_menu_handler",
    "part_events_page_handler",
    "points_event_open_handler",
    "points_leaderboard_handler",
    "points_menu_handler",
    "points_page_handler",
    "points_rt",
    "profile_tags_toggle_handler",
    "report_create_start_handler",
    "report_rt",
    "report_view_handler",
    "reports_export_handler",
    "request_approve_handler",
    "request_open_handler",
    "request_reject_handler",
    "requests_next_page_handler",
    "requests_page_handler",
    "requests_prev_page_handler",
    "requests_rt",
    "start_handler",
    "tb_approved",
    "tb_reselect_handler",
    "tb_update_selected",
    "update_user_interests_start",
    "update_user_menu_handler",
    "update_user_name_start",
    "update_user_rt",
    "user_events_open_handler",
    "user_events_page_handler",
    # Routers
    "user_events_rt",
    "view_by_uuid_rt",
    "view_by_uuid_start_handler",
    "volunteer_home_handler",
]

--- services/bot/core/handlers/moderation.py ---
import re
from datetime import datetime

from dialog_bot_sdk.entities.messaging import UpdateInteractiveMediaEvent, UpdateMessage
from dialog_bot_sdk.interactive_media import Button

from core.bot_kit.fsm import FSMContext, State, StatesGroup
from core.bot_kit.router import Router
from core.config import bot
from core.handlers.events_ui import (
    build_back_to_event_editing_keyboard,
    build_back_to_event_keyboard,
    get_ui,
    send_event_card,
    send_event_cards_page,
    send_my_events_page,
    split_event_value,
)
from core.markups import (
    back_to_moderation_keyboard,
    choices_from_backend_tags,
    event_edit_fields_keyboard,
    format_event_details,
    format_request_details,
    gosb_select_keyboard,
    moderation_menu_keyboard,
    tags_toggle_keyboard,
    tb_select_keyboard,
)
from core.schemas import EventCardSchema, TagSchema, UserSchema
from core.services import EventService, ReportService, RequestService, TagService, TerbankService
from core.utils import (
    clear_context_keep_events_filters,
    delete_prev_message,
    delete_prev_message_by_peer,
    logger,
)

TAGS_MEDIA_ID = "event_tags_toggle"
TAGS_TOGGLE_PREFIX = "toggle:"
TAGS_DONE_VALUE = "done"
# TODO убрать хардкод


events_rt = Router()


class EventEditState(StatesGroup):  # legacy
    wait_value = State()
    gosb = State()
    tags = State()


class EventEnterCodeState(StatesGroup):  # legacy
    wait_code = State()


class EventViewState(StatesGroup):  # legacy
    wait_event_id = State()


class EventCreateState(StatesGroup):  # legacy
    name = State()
    date = State()
    time = State()
    # location удалён
    gosb = State()
    project = State()
    description = State()
    hours = State()
    tags = State()
    code = State()


@bot.di
def moderation_menu_handler(event: UpdateInteractiveMediaEvent, context: FSMContext):  # legacy
    clear_context_keep_events_filters(context)
    delete_prev_message_by_peer(bot, event.peer)

    bot.messaging.send_message(
        peer=event.peer,
        text=("Ты в доме модерации!\n\nПожалуйста, выбери, что хочешь сделать 👇"),
        interactive_media_groups=moderation_menu_keyboard(),
    )


@bot.di
def all_events_handler(  # legacy
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
):
    delete_prev_message_by_peer(bot, event.peer)
    clear_context_keep_events_filters(context)
    send_event_cards_page(
        event.peer,
        offset=0,
        event_service=event_service,
        ctx_name="moderation",
        context=context,
    )


@bot.di
def my_events_handler(  # legacy
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
):
    delete_prev_message_by_peer(bot, event.peer)
    clear_context_keep_events_filters(context)

    send_my_events_page(
        event.peer,
        offset=0,
        event_service=event_service,
        requester_messenger_id=event.peer.id,
        ctx_name="my_events",
        context=context,
    )


@bot.di
def my_events_page_handler(  # legacy
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
):
    delete_prev_message_by_peer(bot, event.peer)
    clear_context_keep_events_filters(context)

    try:
        offset = int(event.data.value)
        if offset < 0:
            offset = 0
    except Exception:
        offset = 0

    send_my_events_page(
        event.peer,
        offset=offset,
        event_service=event_service,
        requester_messenger_id=event.peer.id,
        ctx_name="my_events",
        context=context,
    )


@bot.di
def my_events_open_handler(  # legacy
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
    report_service: ReportService,
    user: UserSchema | None,
):
    delete_prev_message_by_peer(bot, event.peer)
    context.set_state(None)

    event_id, ctx_name = split_event_value(event.data.value)
    send_event_card(
        event.peer,
        event_id=event_id,
        event_service=event_service,
        user=user,
        ctx_name=ctx_name or "my_events",
        report_service=report_service,
    )


@bot.di
def all_events_page_handler(  # legacy
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
):
    delete_prev_message_by_peer(bot, event.peer)
    clear_context_keep_events_filters(context)

    try:
        offset = int(event.data.value)
        if offset < 0:
            offset = 0
    except Exception:
        offset = 0

    send_event_cards_page(
        event.peer,
        offset=offset,
        event_service=event_service,
        ctx_name="moderation",
        context=context,
    )


@bot.di
def all_events_open_handler(  # legacy
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
    report_service: ReportService,
    user: UserSchema | None,
):
    delete_prev_message_by_peer(bot, event.peer)
    context.set_state(None)

    event_id, ctx = split_event_value(event.data.value)
    ctx_name = ctx or "moderation"
    send_event_card(
        event.peer,
        event_id=event_id,
        event_service=event_service,
        user=user,
        ctx_name=ctx_name,
        report_service=report_service,
    )


@bot.di
def create_event_start_handler(
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
):
    """старт мастера создания мероприятия"""
    delete_prev_message_by_peer(bot, event.peer)

    context.clear()
    bot.messaging.send_message(
        peer=event.peer,
        text="Создание мероприятия.\n\nШаг 1/10: введи, пожалуйста, название мероприятия:",
        interactive_media_groups=back_to_moderation_keyboard(),
    )
    context.set_state(EventCreateState.name)


@events_rt.message(state=EventCreateState.name)
@bot.di
def event_create_name_step(message: UpdateMessage, context: FSMContext):
    delete_prev_message(bot, message)

    name = message.message.text_message.text.strip()
    context.update_data({"event_name": name})

    bot.messaging.send_message(
        peer=message.peer,
        text="Шаг 2/10: введи, пожалуйста, дату мероприятия например, в формате `20.02.2002`:",
        interactive_media_groups=back_to_moderation_keyboard(),
    )
    context.set_state(EventCreateState.date)


def _validate_date(text):  # throws ValueError
    formats = []
    for first_gap in ". -_":
        for second_gap in ". -_":
            formats.append(f"%d{first_gap}%m{second_gap}%Y")

    date_obj = None
    for format in formats:
        try:
            date_obj = datetime.strptime(text, format).date()
        except ValueError:
            continue

    if date_obj is None:
        raise ValueError

    return date_obj


@events_rt.message(state=EventCreateState.date)
@bot.di
def event_create_date_step(message: UpdateMessage, context: FSMContext):
    delete_prev_message(bot, message)

    date = message.message.text_message.text.strip()

    try:
        date_obj = _validate_date(date)
    except ValueError:
        bot.messaging.send_message(
            peer=message.peer,
            text=(
                "⚠️ Я не смог распознать дату.\n"
                "Пожалуйста, введи дату, например, в формате `20.02.2002`:"
            ),
            interactive_media_groups=back_to_moderation_keyboard(),
        )
        return

    if date_obj <= datetime.now().date():
        bot.messaging.send_message(
            peer=message.peer,
            text=(
                "⚠️ Ты не можешь создать мероприятие раньше завтрашнего дня.\n"
                "Пожалуйста, введи дату, например, в формате `20.02.2002`:"
            ),
            interactive_media_groups=back_to_moderation_keyboard(),
        )
        return

    context.update_data({"event_date": date_obj})

    bot.messaging.send_message(
        peer=message.peer,
        text="Шаг 3/10: введи, пожалуйста, время мероприятия например, в формате `10:30`:",
        interactive_media_groups=back_to_moderation_keyboard(),
    )
    context.set_state(EventCreateState.time)


def _validate_time(text):  # throws ValueError
    time_obj = None
    for format in ["%H:%M", "%H %M", "%H-%M", "%H_%M"]:
        try:
            time_obj = datetime.strptime(text, format).time()
        except ValueError:
            continue

    if time_obj is None:
        raise ValueError

    return time_obj


@events_rt.message(state=EventCreateState.time)
@bot.di
def event_create_time_step(
    message: UpdateMessage, context: FSMContext, terbank_service: TerbankService
):
    delete_prev_message(bot, message)

    time = message.message.text_message.text.strip()

    try:
        time_obj = _validate_time(time)
    except ValueError:
        bot.messaging.send_message(
            peer=message.peer,
            text=(
                "⚠️ Я не смог распознать время.\n"
                "Пожалуйста, введи в формате `HH:MM`, например: `10:30`:"
            ),
            interactive_media_groups=back_to_moderation_keyboard(),
        )
        return

    context.update_data({"event_time": time_obj})

    send_tb_select_menu(
        peer=message.peer,
        terbank_service=terbank_service,
        context=context,
        is_edit=False,
    )


def _tb_select_footer_button(
    *,
    is_edit: bool,
    event_id: str | None,
    ctx_name: str,
) -> list[Button]:
    if is_edit:
        return [
            Button(
                media_id="event_menu_edit",
                value=f"{event_id}|{ctx_name}",
                label="⬅️ К редактированию мероприятия",
            )
        ]
    return [
        Button(
            media_id="event_create_back_to_time",
            value="1",
            label="⬅️ Назад",
        )
    ]


@bot.di
def event_create_back_to_time_handler(
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
):
    delete_prev_message_by_peer(bot, event.peer)

    bot.messaging.send_message(
        peer=event.peer,
        text="Шаг 3/10: введи, пожалуйста, время мероприятия например, в формате `10:30`:",
        interactive_media_groups=back_to_moderation_keyboard(),
    )
    context.set_state(EventCreateState.time)


def send_tb_select_menu(
    *,
    peer,
    terbank_service: TerbankService,
    context: FSMContext,
    is_edit: bool,
    event_id: str | None = None,
    ctx_name: str = "moderation",
):
    saved_event_id = event_id or context.get_data().get("edit_event_id")

    context.update_data(
        {
            "tb_id": "",
            "gosb_id": "",
            "edit_event_id": saved_event_id,
            "edit_event_ctx": ctx_name,
        }
    )

    if is_edit:
        context.set_state(EventEditState.gosb)
        title = "Редактирование ГОСБ: сначала выбери тербанк:"
    else:
        context.set_state(EventCreateState.gosb)
        title = "Шаг 4/10: выбери тебранк:"

    tbs = terbank_service.get_all_tbs(peer.id)

    bot.messaging.send_message(
        peer=peer,
        text=title,
        interactive_media_groups=tb_select_keyboard(
            terbanks=tbs,
            footer_buttons=_tb_select_footer_button(
                is_edit=is_edit,
                event_id=saved_event_id,
                ctx_name=ctx_name,
            ),
        ),
    )


@bot.di
def tb_reselect_handler(
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    terbank_service: TerbankService,
):
    delete_prev_message_by_peer(bot, event.peer)

    data = context.get_data()

    send_tb_select_menu(
        peer=event.peer,
        terbank_service=terbank_service,
        context=context,
        is_edit=_is_equal_state(context, EventEditState.gosb),
        event_id=data.get("edit_event_id"),
        ctx_name=data.get("edit_event_ctx", "moderation"),
    )


@bot.di
def tb_update_selected(event: UpdateInteractiveMediaEvent, context: FSMContext):
    # keeping what user have selected in "tb_id"
    context.update_data({"tb_id": event.data.value})


@bot.di
def tb_approved(
    event: UpdateInteractiveMediaEvent,
    terbank_service: TerbankService,
    context: FSMContext,
):
    # tb was selected and approved. now selecting gosb:
    delete_prev_message_by_peer(bot, event.peer)

    selected_tb_id = context.get_data().get("tb_id")
    if not isinstance(selected_tb_id, str) or not selected_tb_id:
        logger.error(
            "error while creating event: error while selecting tb: selected tb must be a string, got {selected_tb_id!r}"
        )
        bot.messaging.send_message(
            peer=event.peer,
            text="⚠️ Произошла ошибка. Попробуй позже.",
        )
        context.clear()
        return

    gosbs = terbank_service.get_gosbs_for_tb(tb_id=selected_tb_id, messenger_id=event.peer.id)

    is_edit = _is_equal_state(context, EventEditState.gosb)

    # data = context.get_data()
    # event_id = str(data.get("edit_event_id", ""))
    # ctx_name = str(data.get("edit_event_ctx", "moderation"))
    # TODO сделать кнопки "назад" при редактировании. поля выше понадобяться для этого
    # для этого можно сдлеать чтобы gosb_select_keyboard принимал extra_footer, как tags_toggle_keyboard

    bot.messaging.send_message(
        peer=event.peer,
        text="Редактирование ГОСБ: выбери новый ГОСБ" if is_edit else "Шаг 5/10: Выбери ГОСБ",
        interactive_media_groups=gosb_select_keyboard(gosbs),
    )


@bot.di
def gosb_update_selected(event: UpdateInteractiveMediaEvent, context: FSMContext):
    # keeping what user have selected in "gosb_id"
    context.update_data({"gosb_id": event.data.value})


@bot.di
def gosb_approved(
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
):
    # gosb was selected and approved.
    delete_prev_message_by_peer(bot, event.peer)

    selected_gosb_id = context.get_data().get("gosb_id")
    if not isinstance(selected_gosb_id, str) or not selected_gosb_id:
        logger.error(
            "error while creating event: error while selecting gosb: selected gosb must be a string, got {selected_gosb_id!r}"
        )
        bot.messaging.send_message(
            peer=event.peer,
            text="⚠️ Произошла ошибка. Попробуй позже.",
        )
        context.clear()
        return

    data = context.get_data()
    is_edit = _is_equal_state(context, EventEditState.gosb)

    if is_edit:
        event_id = str(data.get("edit_event_id") or "")
        ctx_name = str(data.get("edit_event_ctx") or "moderation")

        if not event_id:
            logger.error("error while editing gosb: edit_event_id is empty")
            bot.messaging.send_message(
                peer=event.peer,
                text="⚠️ Сессия редактирования сброшена. Открой мероприятие заново.",
                interactive_media_groups=back_to_moderation_keyboard(),
            )
            context.clear()
            return

        updated = event_service.update_event(
            event_id=event_id,
            messenger_id=event.peer.id,
            payload={"gosb_id": selected_gosb_id},
        )

        context.set_state(None)

        _send_event_edit_menu(
            event.peer,
            event_id=event_id,
            event_service=event_service,
            note="✅ ГОСБ успешно изменён." if updated else "⚠️ Не удалось изменить ГОСБ.",
            event_obj=event_service.get_event_by_id(event_id, event.peer.id, mine=True),
            show_organizer=True,
            ctx_name=ctx_name,
        )
    else:
        bot.messaging.send_message(
            peer=event.peer,
            text=(
                "Шаг 6/10: Введи id проекта, если хочешь создать мероприятие в проекте\n"
                "Введи `-`, если хочешь создать событийное мероприятие - мероприятие вне проекта."
            ),
            interactive_media_groups=back_to_moderation_keyboard(),
        )
        context.set_state(EventCreateState.project)


@events_rt.message(state=EventCreateState.project)
@bot.di
def event_create_project_step(message: UpdateMessage, context: FSMContext):
    delete_prev_message(bot, message)

    raw = message.message.text_message.text.strip()
    project_id = "" if raw == "-" else raw
    context.update_data({"project_id": project_id})

    bot.messaging.send_message(
        peer=message.peer,
        text="Шаг 7/10: Введи описание:",
        interactive_media_groups=back_to_moderation_keyboard(),
    )
    context.set_state(EventCreateState.description)


@events_rt.message(state=EventCreateState.description)
@bot.di
def event_create_description_step(message: UpdateMessage, context: FSMContext):
    delete_prev_message(bot, message)

    description = message.message.text_message.text.strip()
    context.update_data({"event_description": description})
    bot.messaging.send_message(
        peer=message.peer,
        text="Шаг 8/10: Введи количество волонтёрских часов, начисляемых за мероприятие:",
        interactive_media_groups=back_to_moderation_keyboard(),
    )
    context.set_state(EventCreateState.hours)


def _validate_hours_amount(text) -> int:  # throws ValueError
    if not isinstance(text, str) and not isinstance(text, str):
        logger.error("expected type str or int for hours amount, got '%s'", type(text))
        raise ValueError
    if not re.fullmatch(r"^[0-9]{1,2}$", text):
        logger.error("expected <= 2 long digit sequence for hours amount, got '%s'", text)
        raise ValueError
    hours = int(text)
    if hours <= 0 or hours >= 19:
        raise ValueError
    return hours


@events_rt.message(state=EventCreateState.hours)
@bot.di
def event_create_hours_step(
    message: UpdateMessage,
    context: FSMContext,
    tag_service: TagService,
):
    delete_prev_message(bot, message)

    text = message.message.text_message.text.strip()
    try:
        hours = _validate_hours_amount(text)
    except ValueError:
        bot.messaging.send_message(
            peer=message.peer,
            text="⚠️ Количество часов должно быть натуральным числом, меньшим 19. Попробуй ещё раз.",
            interactive_media_groups=back_to_moderation_keyboard(),
        )
        return

    context.update_data({"hours": hours})

    all_tags = tag_service.get_all_tags()
    choices = choices_from_backend_tags(all_tags)

    context.update_data(
        {
            "event_tag_keys": [],
            "all_tags": [{"id": t.id, "title": t.title} for t in all_tags],
        },
    )

    _send_tags_toggle_ui(
        peer=message.peer,
        title="Шаг 9/10: выбери направления, которым соответствует мероприятие, затем нажми «Готово»:",
        choices=choices,
        selected_keys=set(),
        footer_buttons=[Button(media_id="leave", value="moderation", label="⬅️ В меню модерации")],
    )

    context.set_state(EventCreateState.tags)


@bot.di
def event_tags_toggle_handler(
    event: UpdateInteractiveMediaEvent,
    event_service: EventService,
    context: FSMContext,
):
    is_create = _is_equal_state(context, EventCreateState.tags)
    is_edit = _is_equal_state(context, EventEditState.tags)
    if not (is_create or is_edit):
        return

    raw = str(event.data.value or "")
    data = context.get_data()
    ctx_name = str(data.get("edit_event_ctx", "moderation"))

    key_field = "event_tag_keys" if is_create else "edit_tag_keys"
    selected = set(data.get(key_field) or [])

    all_tags = data.get("all_tags", [])
    if not all_tags:
        logger.info("No tags were taken while editing event tags. Please check seeding file.")

    if raw == TAGS_DONE_VALUE:
        title_to_id = {t["title"]: t["id"] for t in all_tags if t.get("title") and t.get("id")}
        app_tag_ids = [title_to_id[n] for n in selected if n in title_to_id]

        delete_prev_message_by_peer(bot, event.peer)

        if is_create:
            context.update_data({"event_app_tag_ids": app_tag_ids})
            bot.messaging.send_message(
                peer=event.peer,
                text="Шаг 10/10: введи код мероприятия:\nБез пробелов, не больше 16 символов. Например: WELCOME2025",
                interactive_media_groups=back_to_moderation_keyboard(),
            )
            context.set_state(EventCreateState.code)
            return

        if is_edit:
            current = set(data.get("edit_current_tag_keys") or [])
            event_id = str(data.get("edit_event_id"))

            if not event_id or event_id == "None":
                logger.error(
                    "Error while editing event tags: "
                    f"no event was found by saved id {event_id!r}, "
                    f"saved in data by the key 'edit_event_id'. "
                    "exiting editing session"
                )

                context.set_state(None)
                bot.messaging.send_message(
                    peer=event.peer,
                    text="⚠️ Сессия редактирования сброшена. Открой мероприятие заново.",
                    interactive_media_groups=back_to_moderation_keyboard(),
                )
                return

            to_add = selected - current
            to_remove = current - selected

            failed = False

            # add
            for title in to_add:
                tag_id = title_to_id.get(title)
                if not tag_id:
                    logger.error(
                        "Error while editing event tags: "
                        f"selected tag with title={title!r} "
                        f"have no entrance in all_tags={all_tags}. "
                        "skipping this tag."
                    )
                elif not event_service.add_tag(
                    event_id=event_id, tag_id=tag_id, messenger_id=event.peer.id
                ):
                    failed = True

            # remove
            for title in to_remove:
                tag_id = title_to_id.get(title)
                if not tag_id:
                    logger.error(
                        "Error while editing event tags: "
                        f"selected tag with title={title!r} "
                        f"have no entrance in all_tags={all_tags}. "
                        "skipping this tag."
                    )
                elif not event_service.remove_tag(
                    event_id=event_id, tag_id=tag_id, messenger_id=event.peer.id
                ):
                    failed = True

            context.set_state(None)

            _send_event_edit_menu(
                event.peer,
                event_id=event_id,
                event_service=event_service,
                note="⚠️ Ошибка изменения тегов! Некоторые теги могли не измениться."
                if failed
                else "✅ Теги успешно изменены.",
                event_obj=event_service.get_event_by_id(event_id, event.peer.id, mine=True),
                show_organizer=True,
                ctx_name=ctx_name,
            )

            return

    if raw.startswith(TAGS_TOGGLE_PREFIX):
        key = raw[len(TAGS_TOGGLE_PREFIX) :].strip()
        if key in selected:
            selected.remove(key)
        else:
            selected.add(key)

        context.update_data({key_field: list(selected)})
        delete_prev_message_by_peer(bot, event.peer)

        if is_create:
            footer = [Button(media_id="leave", value="moderation", label="⬅️ В меню модерации")]
            title = "Шаг 9/10: выбери направления, которым соответствует мероприятие, затем нажми «Готово»:"
        else:
            event_id = data.get("edit_event_id") or ""
            footer = [
                Button(
                    media_id="event_menu_edit",
                    value=f"{event_id}|{ctx_name}",
                    label="⬅️ К редактированию мероприятия",
                )
            ]
            title = "Редактирование направления: выбери направления, которым соответствует мероприятие, затем нажми «Готово»:"

        normalized_tags: list[TagSchema] = []

        for tag in all_tags:
            if isinstance(tag, TagSchema):
                normalized_tags.append(tag)
            elif isinstance(tag, dict):
                normalized_tags.append(TagSchema.from_dict(tag))

        choices = choices_from_backend_tags(normalized_tags)

        _send_tags_toggle_ui(
            peer=event.peer,
            title=title,
            choices=choices,
            selected_keys=set(selected),
            footer_buttons=footer,
        )
        return


def _validate_verification_code(text) -> str:  # throws ValueError
    if not isinstance(text, str):
        logger.error("expected type str for verification code, got '%s'", type(text))
        raise ValueError
    if not re.fullmatch(r"^[A-Za-zА-Яа-я0-9]{1,16}$", text):
        logger.error("invalid verification code: '%s'", text)
        raise ValueError
    return text


@events_rt.message(state=EventCreateState.code)
@bot.di
def event_create_code_step(
    message: UpdateMessage,
    context: FSMContext,
    event_service: EventService,
    request_service: RequestService,
    report_service: ReportService,
    user: UserSchema,
):
    delete_prev_message(bot, message)

    try:
        code = _validate_verification_code(message.message.text_message.text.strip())
    except ValueError:
        bot.messaging.send_message(
            peer=message.peer,
            text=(
                "⚠️ Код должен быть комбинацией русских и латинских букв и цифр, "
                "длиной не больше 16 символов. Попробуй еще раз:"
            ),
            interactive_media_groups=back_to_moderation_keyboard(),
        )
        return

    context.update_data({"event_verification_code": code})
    data = context.get_data()
    try:
        created = event_service.create_from_wizard(data, message.peer)
    except Exception as e:
        logger.error("Error while creating an event via wizard: %s", e)
        bot.messaging.send_message(
            peer=message.peer,
            text="⚠️ Произошла ошибка.",
            interactive_media_groups=back_to_moderation_keyboard(),
        )
        context.clear()
        return

    context.clear()

    note = {
        "REQUEST": "✅ Заявка на мероприятие успешно создана.",
        "COMPLETELY": "✅ Мероприятие успешно создано.",
        "FAILED": "⚠️ Произошла ошибка: не удалось создать заявку/мероприятие.",
    }.get(
        created.get("TYPE", ""),
        "⚠️ Произошла ошибка: не получить статус заявки/мероприятия. Проверь результат в 'Своих заявках' или в 'Своих мероприятиях'.",
    )

    result_type = created.get("TYPE")
    event_id = str(created.get("event_id", ""))
    request_id = str(created.get("request_id", ""))

    if result_type == "COMPLETELY":
        if not event_id:
            logger.error("expected event_id, got none whlie creating event")
            bot.messaging.send_message(
                peer=message.peer,
                text="Мероприятие было создано успешно, но у нас не получилось показать его карточку. Попробуй открыть её из меню мероприятий.",
                interactive_media_groups=back_to_moderation_keyboard(),
            )
        else:
            send_event_card(
                message.peer,
                event_id=event_id,
                event_service=event_service,
                report_service=report_service,
                user=user,
                ctx_name="my_events",  # TODO fix context
                note=note,
            )

    if result_type == "REQUEST":
        if not request_id:
            logger.error("expected reequest_id, got none whlie creating request")
            bot.messaging.send_message(
                peer=message.peer,
                text="Заявка на мероприятие была создано успешно, но у нас не получилось показать её карточку. Попробуй открыть её из меню заявок.",
                interactive_media_groups=back_to_moderation_keyboard(),
            )
        else:
            request_card = request_service.get_request_by_id(request_id, message.peer.id)
            if request_card is not None:
                bot.messaging.send_message(
                    peer=message.peer,
                    text=f"{note}\n\n{format_request_details(request_card)}",
                    interactive_media_groups=back_to_moderation_keyboard(),
                )


@bot.di
def event_view_by_id_start(event: UpdateInteractiveMediaEvent, context: FSMContext):  # legacy
    """старт диалога - просим у модератора UUID мероприятия"""
    delete_prev_message_by_peer(bot, event.peer)

    bot.messaging.send_message(
        peer=event.peer,
        text="Введи UUID мероприятия, которое хочешь посмотреть.\n\n",
        interactive_media_groups=back_to_moderation_keyboard(),
    )
    context.set_state(EventViewState.wait_event_id)


@events_rt.message(state=EventViewState.wait_event_id)
@bot.di
def event_view_by_id_step(  # legacy
    message: UpdateMessage,
    context: FSMContext,
    event_service: EventService,
    user: UserSchema,
):
    """читаем UUID, тянем мероприятие из бэкенда и показываем информацию"""
    delete_prev_message(bot, message)
    raw_id = message.message.text_message.text.strip()
    event = event_service.get_event_by_id(raw_id, message.peer.id)

    if event is None:
        bot.messaging.send_message(
            peer=message.peer,
            text="⚠️ Мероприятие с таким UUID не найдено.\nПопробуй ещё раз. Пример UUID: `932cf1cb-1ee7-4a45-bc96-41a232f3f538`",
            interactive_media_groups=back_to_moderation_keyboard(),
        )
        return

    context.update_data({"current_event_id": event.id})
    context.set_state(None)

    send_event_card(
        message.peer,
        event_id=event.id,
        event_service=event_service,
        user=user,
        ctx_name="moderation_menu",
    )


@bot.di
def event_menu_sign_up_handler(
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
    report_service: ReportService,
    user: UserSchema | None,
):
    delete_prev_message_by_peer(bot, event.peer)
    context.set_state(None)

    event_id, ctx = split_event_value(event.data.value)
    ctx_name = ctx or "moderation"
    ok = event_service.sign_up(event_id, event.peer.id)
    if not ok:
        note = "⚠️ Не удалось записаться на мероприятие."
    else:
        note = "✅ Запись на мероприятие прошла успешно!"

    send_event_card(
        event.peer,
        event_id=event_id,
        event_service=event_service,
        report_service=report_service,
        user=user,
        ctx_name=ctx_name,
        note=note,
    )


@bot.di
def event_menu_sign_out_handler(
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
    report_service: ReportService,
    user: UserSchema | None,
):
    delete_prev_message_by_peer(bot, event.peer)
    context.set_state(None)

    event_id, ctx = split_event_value(event.data.value)
    ctx_name = ctx or "moderation"
    # TODO may be a source of bugs. do we really need to deafult context?
    status = event_service.get_participation_status(event_id, event.peer.id)

    if status is None:
        note = "⚠️ Не удалось отписаться: ты не записан на это мероприятие."
    elif status.state == "confirmed":
        note = "⚠️ Нельзя отписаться: часы уже получен за это участие."
    else:
        ok = event_service.sign_out_by_event(event_id, event.peer.id)
        if ok:
            note = "✅ Ты успешно отписался от мероприятия."
        else:
            note = "⚠️ Не удалось отписаться. Попробуй ещё раз."

    send_event_card(
        event.peer,
        event_id=event_id,
        event_service=event_service,
        report_service=report_service,
        user=user,
        ctx_name=ctx_name,
        note=note,
    )


@bot.di
def event_menu_enter_code_start_handler(
    event: UpdateInteractiveMediaEvent, context: FSMContext
):  # legacy
    delete_prev_message_by_peer(bot, event.peer)
    event_id, ctx = split_event_value(event.data.value)
    ctx_name = ctx or "moderation"
    context.update_data({"current_event_id": event_id, "current_event_ctx": ctx_name})
    context.set_state(EventEnterCodeState.wait_code)

    bot.messaging.send_message(
        peer=event.peer,
        text="🎟️ Введи бонус-код мероприятия (без пробелов):",
        interactive_media_groups=build_back_to_event_keyboard(event_id, ctx_name),
    )


@events_rt.message(state=EventEnterCodeState.wait_code)
@bot.di
def event_menu_enter_code_step(
    message: UpdateMessage,
    context: FSMContext,
    event_service: EventService,
    report_service: ReportService,
    user: UserSchema,
):
    delete_prev_message(bot, message)

    event_id = str(context.get_data().get("current_event_id"))
    # если event_id is None, то клиент не найдёт event с id == "None", и всё ок

    code = message.message.text_message.text.strip()
    note: str
    status = event_service.get_participation_status(event_id, message.peer.id)
    if status is None:
        note = "⚠️ Код не принят, сначала нужно записаться на мероприятие"
    elif status.state == "confirmed":
        note = "⚠️ Код не принят, баллы уже получены"
    else:
        ok = event_service.enter_code_by_event(event_id, message.peer.id, code)
        if not ok:
            note = "⚠️ Код не принят, проверь правильность кода"
        else:
            note = "✅ Код принят. Часы начислены."

    data = context.get_data()
    ctx_name = data.get("current_event_ctx") or "moderation"
    context.set_state(None)

    send_event_card(
        message.peer,
        event_id=event_id,
        event_service=event_service,
        report_service=report_service,
        user=user,
        ctx_name=ctx_name,
        note=note,
    )


@bot.di
def event_menu_delete_handler(  # legacy
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
    report_service: ReportService,
    user: UserSchema | None,
):
    delete_prev_message_by_peer(bot, event.peer)
    context.set_state(None)

    event_id, ctx = split_event_value(event.data.value)
    ctx_name = ctx or "moderation"
    if ctx_name not in ("moderation", "moderation_menu"):
        ctx_name = "moderation"

    try:
        ok = event_service.delete_event(
            event_id,
            requester_messenger_id=event.peer.id,
        )
    except Exception:
        ok = False

    if ok:
        context.clear()
        if ctx_name == "moderation":
            send_event_cards_page(
                event.peer,
                offset=0,
                event_service=event_service,
                ctx_name="moderation",
                note="Мероприятие удалено.",
            )
        else:
            bot.messaging.send_message(
                peer=event.peer,
                text="Мероприятие удалено.\n\nТы в доме модерации",
                interactive_media_groups=moderation_menu_keyboard(),
            )
        return

    send_event_card(
        event.peer,
        event_id=event_id,
        event_service=event_service,
        report_service=report_service,
        user=user,
        ctx_name=ctx_name,
        note="⚠️ Не удалось удалить мероприятие",
    )


def _send_event_edit_menu(
    peer,
    *,
    event_id: str,
    event_service: EventService,
    note: str | None = None,
    event_obj=None,  # temporary remove type since it was fixed in another branch
    show_organizer: bool,
    ctx_name: str,
):
    ui = get_ui(ctx_name)
    refreshed = event_obj or event_service.get_event_by_id(event_id, peer.id, mine=True)
    base = (
        format_event_details(refreshed, show_code=True, show_organizer=show_organizer)
        if refreshed
        else "⚠️ Мероприятие не найдено"
    )

    prefix = f"{note}\n\n" if note else ""
    bot.messaging.send_message(
        peer=peer,
        text=(f"{prefix}Редактирование мероприятия\n\n{base}\n\nВыбери поле для Редактирования:"),
        interactive_media_groups=event_edit_fields_keyboard(
            event_id,
            leave_media_id=ui.list_open_media_id,
            leave_value=f"{event_id}|{ui.name}",
            leave_label="⬅️ К мероприятию",
        ),
    )


@bot.di
def event_menu_edit_handler(
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
):
    delete_prev_message_by_peer(bot, event.peer)
    context.set_state(None)
    event_id, ctx_name = split_event_value(event.data.value)
    ctx_name = "moderation" if ctx_name is None else ctx_name
    context.update_data(
        {
            "edit_event_id": event_id,
            "edit_event_ctx": ctx_name,
        }
    )

    _send_event_edit_menu(
        event.peer,
        event_id=event_id,
        event_service=event_service,
        show_organizer=True,
        ctx_name=ctx_name,
    )


def _get_field_label(field: str) -> str:
    return {
        "title": "Название",
        "date": "Дата",
        "time": "Время",
        "tags": "Теги",
        "gosb_id": "ГОСБ",
        "event_organizers": "Организаторы",
        "hours": "Часы",
        "description": "Описание",
        "code": "Код",
    }.get(field, field)


def _get_current_value(event_card: EventCardSchema, field: str) -> str:
    event_fields = {
        # valid fields
        "title",
        "description",
        "gosb_id",
        "hours",
        #
        # TODO rename properly
        "verification_code",  # from code
        "event_organizers",  # from creator_id
    }

    match field:
        case "date":
            val = event_card.event.date_time.strftime("%d.%m.%Y")
        case "time":
            val = event_card.event.date_time.strftime("%H:%M")
        case "code":  # once 'code' is renamed, this will be deleted
            val = event_card.event.verification_code
        case "creator_id":  # once 'creator_id' is renamed, this will be deleted
            val = event_card.event.creator_id
        case "gosb_id":
            val = event_card.gosb.name
        case _:
            val = (
                getattr(event_card.event, field, None)
                if field in event_fields
                else getattr(event_card, field, None)
            )

    return (
        ("\n" if len(str(val)) > 140 else "")
        + "_"
        + ("-" if val is None or val == "" else str(val)).replace("\n", "_\n_")
        + "_"
    )


def _is_equal_state(context: FSMContext, state: State) -> bool:
    current = context.get_state()
    return current == state or str(current) == str(state)


def _send_tags_toggle_ui(
    *,
    peer,
    title: str,
    choices,
    selected_keys: set[str],
    footer_buttons: list[Button],
):
    bot.messaging.send_message(
        peer=peer,
        text=title,
        interactive_media_groups=tags_toggle_keyboard(
            choices=choices,
            selected_keys=selected_keys,
            media_id=TAGS_MEDIA_ID,
            toggle_value_prefix=TAGS_TOGGLE_PREFIX,
            done_value=TAGS_DONE_VALUE,
            done_label="✅ Готово",
            extra_footer=footer_buttons,
        ),
    )


@bot.di
def event_menu_edit_field_handler(
    event: UpdateInteractiveMediaEvent,
    context: FSMContext,
    event_service: EventService,
    tag_service: TagService,
    terbank_service: TerbankService,
):
    delete_prev_message_by_peer(bot, event.peer)
    raw = str(event.data.value or "")

    if "|" not in raw:
        logger.error("Got unexpected event.data.value={raw!r} while trying to edit event")
        bot.messaging.send_message(peer=event.peer, text="⚠️ Некорректная команда редактирования.")
        return

    event_id, field = raw.split("|", 1)
    field = field.strip()
    data = context.get_data()
    ctx_name = str(data.get("edit_event_ctx", "moderation"))

    edited_event_card = event_service.get_event_by_id(event_id, event.peer.id, mine=True)
    if not edited_event_card:
        bot.messaging.send_message(peer=event.peer, text="⚠️ Мероприятие не найдено.")
        return

    if field == "tags":
        # редактируем теги через toggle UI
        all_tags = tag_service.get_all_tags()
        choices = choices_from_backend_tags(all_tags)

        selected_titles: set[str] = set()
        for t in edited_event_card.tags or []:
            if isinstance(t, dict) and t.get("title"):
                selected_titles.add(str(t["title"]))
            else:
                title = getattr(t, "title", None)
                if title:
                    selected_titles.add(str(title))

        context.update_data(
            {
                "edit_event_id": event_id,
                "all_tags": [{"id": t.id, "title": t.title} for t in all_tags],
                "edit_tag_keys": list(selected_titles),
                "edit_current_tag_keys": list(selected_titles),
            }
        )
        context.set_state(EventEditState.tags)

        _send_tags_toggle_ui(
            peer=event.peer,
            title="Редактирование направления: выбери направления, которым соответствует мероприятие, затем нажми «Готово»:",
            choices=choices,
            selected_keys=set(selected_titles),
            footer_buttons=[
                Button(
                    media_id="event_menu_edit",
                    value=f"{event_id}|{ctx_name}",
                    label="⬅️ К редактированию мероприятия",
                )
            ],
        )
        return

    if field == "gosb_id":
        # редактируем госб через UI
        # вызываем клавиатуру выбора тербанка, дальше она сама вызовет
        # выбор ГОСБ и определит, редактируем мы или создаем мероприятие

        context.update_data(
            {
                "edit_event_id": event_id,
                "edit_event_ctx": ctx_name,
                "edit_field": "gosb_id",
            }
        )

        send_tb_select_menu(
            peer=event.peer,
            terbank_service=terbank_service,
            context=context,
            is_edit=True,
            event_id=event_id,
            ctx_name=ctx_name,
        )
        return

    context.update_data({"edit_event_id": event_id, "edit_field": field})
    context.set_state(EventEditState.wait_value)

    field_label = _get_field_label(field)
    field_current_value = _get_current_value(edited_event_card, field)

    if field == "event_organizers":
        bot.messaging.send_message(
            peer=event.peer,
            text="Пока не реализовано",
            interactive_media_groups=build_back_to_event_editing_keyboard(
                event_id=event_id,
                ctx_name=ctx_name,
            ),
        )
        return
    if field == "date":
        hint = "*Введи дату в формате* `dd.mm.yyyy`, например: `20.02.2002`"
    elif field == "time":
        hint = "*Введи время в формате* `HH:MM`, например: `10:30`"
    else:
        hint = '*Введи новое значение.* Чтобы очистить поле - отправь: "-"'

    bot.messaging.send_message(
        peer=event.peer,
        text=f" ✍️ *Редактирование*: _{field_label}_\n\n*Текущее значение*: {field_current_value}\n\n{hint}",
        interactive_media_groups=build_back_to_event_editing_keyboard(
            event_id=event_id,
            ctx_name=ctx_name,
        ),
    )


@events_rt.message(state=EventEditState.wait_value)
@bot.di
def event_edit_value_step(
    message: UpdateMessage,
    context: FSMContext,
    event_service: EventService,
):
    delete_prev_message(bot, message)

    data = context.get_data()
    event_id: str = str(data.get("edit_event_id", ""))
    field: str = str(data.get("edit_field", ""))
    ctx_name = str(data.get("edit_event_ctx", "moderation"))

    if not event_id or not field:
        logger.error("expected values for event_id and field, got '%s' and '%s'", event_id, field)
        bot.messaging.send_message(
            peer=message.peer,
            text="⚠️ Сессия редактирования сброшена. Открой мероприятие заново.",
        )
        context.set_state(None)
        return

    raw = message.message.text_message.text.strip()
    value: str | int = "" if raw == "-" else raw

    if field == "event_organizers":
        bot.messaging.send_message(
            peer=message.peer,
            text="Пока не реализовано.",
            interactive_media_groups=build_back_to_event_editing_keyboard(
                event_id=event_id,
                ctx_name=ctx_name,
            ),
        )
        context.set_state(None)
        return

    if field == "hours":
        try:
            value = _validate_hours_amount(value)
        except ValueError:
            bot.messaging.send_message(
                peer=message.peer,
                text="⚠️ Количество часов должно быть натуральным числом, меньшим 19. Попробуй ещё раз.",
                interactive_media_groups=build_back_to_event_editing_keyboard(
                    event_id=event_id,
                    ctx_name=ctx_name,
                ),
            )
            return

    if field == "code":
        try:
            value = _validate_verification_code(value)
        except ValueError:
            bot.messaging.send_message(
                peer=message.peer,
                text=(
                    "⚠️ Код должен быть комбинацией русских и латинских букв и цифр, "
                    "длиной не больше 16 символов. Попробуй еще раз:"
                ),
                interactive_media_groups=build_back_to_event_editing_keyboard(
                    event_id=event_id,
                    ctx_name=ctx_name,
                ),
            )
            return

    if field == "date":
        try:
            date_obj = _validate_date(str(value))
        except ValueError:
            bot.messaging.send_message(
                peer=message.peer,
                text=(
                    "⚠️ Я не смог распознать дату.\n"
                    "Пожалуйста, введи дату в формате `dd.mm.yyyy`, например: `20.02.2002`:"
                ),
                interactive_media_groups=build_back_to_event_editing_keyboard(
                    event_id=event_id,
                    ctx_name=ctx_name,
                ),
            )
            return

        current_event_card = event_service.get_event_by_id(event_id, message.peer.id)
        if current_event_card is None:
            logger.error(
                "expected event card while editing date, got None for event_id=%s",
                event_id,
            )
            bot.messaging.send_message(
                peer=message.peer,
                text="⚠️ Мероприятие не найдено. Открой мероприятие заново.",
            )
            context.set_state(None)
            return

        current_dt = current_event_card.event.date_time
        new_dt = current_dt.replace(
            year=date_obj.year,
            month=date_obj.month,
            day=date_obj.day,
        )

        field = "date_time"
        value = new_dt.strftime("%Y-%m-%dT%H:%M:%SZ")

    if field == "time":
        try:
            time_obj = _validate_time(str(value))
        except ValueError:
            bot.messaging.send_message(
                peer=message.peer,
                text=(
                    "⚠️ Я не смог распознать время.\n"
                    "Пожалуйста, введи в формате `HH:MM`, например: `10:30`:"
                ),
                interactive_media_groups=build_back_to_event_editing_keyboard(
                    event_id=event_id,
                    ctx_name=ctx_name,
                ),
            )
            return

        current_event_card = event_service.get_event_by_id(event_id, message.peer.id)
        if current_event_card is None:
            logger.error(
                "expected event card while editing time, got None for event_id=%s",
                event_id,
            )
            bot.messaging.send_message(
                peer=message.peer,
                text="⚠️ Мероприятие не найдено. Открой мероприятие заново.",
            )
            context.set_state(None)
            return

        current_dt = current_event_card.event.date_time
        new_dt = current_dt.replace(
            hour=time_obj.hour,
            minute=time_obj.minute,
            second=0,
            microsecond=0,
        )

        field = "date_time"
        value = new_dt.strftime("%Y-%m-%dT%H:%M:%SZ")

    payload = {field: value}

    updated = event_service.update_event(
        event_id=event_id,
        messenger_id=message.peer.id,
        payload=payload,  # type(value) in (int, str)
    )
    context.set_state(None)

    _send_event_edit_menu(
        message.peer,
        event_id=event_id,
        event_service=event_service,
        note="⚠️ Не удалось обновить поле." if not updated else "✅ Поле обновлено.",
        event_obj=event_service.get_event_by_id(event_id, message.peer.id),
        show_organizer=True,
        ctx_name=ctx_name,
    )

--- services/bot/core/markups/gosb.py ---
from dialog_bot_sdk.interactive_media import (
    Button,
    InteractiveMediaGroup,
    MediaGroupBuilder,
    Select,
)

from core.schemas import GosbSchema


def gosb_select_keyboard(gosbs: list[GosbSchema]) -> list[InteractiveMediaGroup]:
    group1 = MediaGroupBuilder(
        [
            Select(
                media_id="gosb_select",
                label="ГОСБ",
                options={g.id: g.name for g in gosbs},
            ),
        ],
    )

    group2 = MediaGroupBuilder(
        [
            Button(
                media_id="tb_reselect",
                value="from_gosb",
                label="⬅️ Выбрать другой ТБ",
            ),
            Button(
                media_id="gosb_approved",
                value="1",
                label="✅ Подтвердить выбор",
            ),
        ]
    )

    return group1.merge([group2])

--- services/bot/core/markups/terbank.py ---
from dialog_bot_sdk.interactive_media import (
    Button,
    InteractiveMediaGroup,
    MediaGroupBuilder,
    Select,
)

from core.schemas import TerbankSchema


def tb_select_keyboard(
    terbanks: list[TerbankSchema],
    *,
    footer_buttons: list[Button],
) -> list[InteractiveMediaGroup]:
    group1 = MediaGroupBuilder(
        [
            Select(
                media_id="tb_select",
                label="Тер. Банк",
                options={tb.id: tb.name for tb in terbanks},
            ),
        ],
    )

    group2 = MediaGroupBuilder(
        [
            *footer_buttons,
            Button(
                media_id="tb_approved",
                value="1",
                label="✅ Подтвердить выбор",
            ),
        ]
    )

    return group1.merge([group2])

--- services/bot/main.py ---
from core.bot_kit.router import Router
from core.config import bot
from core.handlers import (
    admin_menu_handler,
    ai_assistant_handler,
    ai_rt,
    all_events_handler,
    all_events_open_handler,
    all_events_page_handler,
    all_requests_handler,
    create_event_start_handler,
    event_create_back_to_time_handler,
    event_menu_delete_handler,
    event_menu_edit_field_handler,
    event_menu_edit_handler,
    event_menu_enter_code_start_handler,
    event_menu_sign_out_handler,
    event_menu_sign_up_handler,
    event_participants_open_handler,
    event_source_callback_handler,  # временное название для отображения карточек в нейронке
    event_tags_toggle_handler,
    event_user_enter_code_start_handler,
    event_user_sign_out_handler,
    event_user_sign_up_handler,
    event_view_by_id_start,
    events_filters_apply_handler,
    events_filters_back_handler,
    events_filters_mode_open_handler,
    events_filters_mode_select_handler,
    events_filters_not_implemented_handler,
    events_filters_open_handler,
    events_filters_reset_handler,
    events_filters_tags_open_handler,
    events_filters_tags_toggle_handler,
    events_menu_handler,
    events_rt,
    gosb_approved,
    gosb_update_selected,
    main_menu_handler,
    moderation_menu_handler,
    my_events_handler,
    my_events_open_handler,
    my_events_page_handler,
    my_profile_handler,
    noop_handler,
    part_events_menu_handler,
    part_events_page_handler,
    points_event_open_handler,
    points_leaderboard_handler,
    points_menu_handler,
    points_page_handler,
    points_rt,
    profile_tags_toggle_handler,
    report_create_start_handler,
    report_rt,
    report_view_handler,
    reports_export_handler,
    request_approve_handler,
    request_open_handler,
    request_reject_handler,
    requests_next_page_handler,
    requests_page_handler,
    requests_prev_page_handler,
    requests_rt,
    start_handler,
    tb_approved,
    tb_reselect_handler,
    tb_update_selected,
    update_user_interests_start,
    update_user_menu_handler,
    update_user_name_start,
    update_user_rt,
    user_events_open_handler,
    user_events_page_handler,
    user_events_rt,
    view_by_uuid_rt,
    view_by_uuid_start_handler,
    volunteer_home_handler,
)
from dialog_bot_sdk.entities.messaging import CommandHandler, EventHandler


def handlers_setting() -> None:  # legacy
    router = Router()
    router.register(update_user_rt)
    router.register(events_rt)
    router.register(user_events_rt)
    router.register(points_rt)
    router.register(view_by_uuid_rt)
    router.register(report_rt)
    router.register(ai_rt)
    router.register(requests_rt)

    router.subscribe(bot)
    bot.messaging.command_handler(
        [
            CommandHandler(
                function=start_handler,
                command="start",
                description="Расскажу о себе",
            ),
            CommandHandler(
                function=create_event_start_handler,
                command="create_event",
                description="Создать мероприятие",
            ),
            CommandHandler(
                function=all_events_handler,
                command="all_events",
                description="Показать все мероприятия",
            ),
            CommandHandler(
                function=reports_export_handler,
                command="reports_export",
                description="Выгрузка отчётов",
            ),
        ]
    )

    bot.messaging.event_handler(
        [
            EventHandler(function=volunteer_home_handler, value="volunteer_home"),
            EventHandler(function=main_menu_handler, value="main_menu"),
            EventHandler(function=ai_assistant_handler, value="ai_assistant"),
            EventHandler(function=my_profile_handler, value="my_profile"),
            EventHandler(function=update_user_menu_handler, value="update_profile_menu"),
            EventHandler(function=update_user_name_start, _id="update_user_name"),
            EventHandler(function=update_user_interests_start, _id="update_user_interests"),
            EventHandler(function=profile_tags_toggle_handler, _id="profile_tags_toggle"),
            EventHandler(function=points_menu_handler, value="points"),
            EventHandler(function=points_leaderboard_handler, value="points_leaderboard"),
            EventHandler(function=moderation_menu_handler, value="moderation"),
            EventHandler(function=reports_export_handler, value="download_reports_list"),
            EventHandler(function=all_events_handler, value="all_events"),
            EventHandler(function=events_menu_handler, value="events"),
            EventHandler(function=part_events_menu_handler, value="part_events"),
            EventHandler(function=user_events_page_handler, _id="user_events_prev"),
            EventHandler(function=user_events_page_handler, _id="user_events_next"),
            EventHandler(function=part_events_page_handler, _id="part_events_prev"),
            EventHandler(function=part_events_page_handler, _id="part_events_next"),
            EventHandler(function=event_user_sign_up_handler, _id="event_user_sign_up"),
            EventHandler(function=event_user_sign_out_handler, _id="event_user_sign_out"),
            EventHandler(function=event_user_enter_code_start_handler, _id="event_user_enter_code"),
            EventHandler(function=event_tags_toggle_handler, _id="event_tags_toggle"),
            EventHandler(function=event_participants_open_handler, _id="event_participants_open"),
            EventHandler(function=report_create_start_handler, _id="event_report_create"),
            EventHandler(function=report_view_handler, _id="event_report_view"),
            EventHandler(function=all_events_page_handler, _id="all_events_prev"),
            EventHandler(function=all_events_page_handler, _id="all_events_next"),
            EventHandler(function=my_events_handler, value="my_events"),
            EventHandler(function=my_events_page_handler, _id="my_events_prev"),
            EventHandler(function=my_events_page_handler, _id="my_events_next"),
            EventHandler(function=my_events_open_handler, _id="my_events_open"),
            EventHandler(function=create_event_start_handler, value="create_event"),
            EventHandler(function=event_view_by_id_start, value="update_event"),
            EventHandler(function=admin_menu_handler, value="administration"),
            EventHandler(function=event_menu_sign_up_handler, _id="event_menu_sign_up"),
            EventHandler(function=event_menu_sign_out_handler, _id="event_menu_sign_out"),
            EventHandler(function=event_menu_enter_code_start_handler, _id="event_menu_enter_code"),
            EventHandler(function=event_menu_delete_handler, _id="event_menu_delete"),
            EventHandler(function=event_menu_edit_handler, _id="event_menu_edit"),
            EventHandler(function=view_by_uuid_start_handler, _id="view_by_uuid"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_name"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_description"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_date"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_time"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_tags"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_organizers"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_hours"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_code"),
            EventHandler(function=event_menu_edit_field_handler, _id="event_menu_edit_gosb"),
            EventHandler(function=user_events_open_handler, _id="user_events_open"),
            EventHandler(function=all_events_open_handler, _id="all_events_open"),
            EventHandler(function=points_page_handler, _id="points_prev"),
            EventHandler(function=points_page_handler, _id="points_next"),
            EventHandler(function=points_event_open_handler, _id="points_event_open"),
            EventHandler(function=points_event_open_handler, _id="points_events_open"),
            EventHandler(function=events_filters_open_handler, _id="events_filters_open"),
            EventHandler(function=events_filters_apply_handler, _id="events_filters_apply"),
            EventHandler(function=events_filters_reset_handler, _id="events_filters_reset"),
            EventHandler(function=events_filters_back_handler, _id="events_filters_back"),
            EventHandler(function=events_filters_tags_open_handler, _id="events_filters_tags"),
            EventHandler(
                function=events_filters_tags_toggle_handler, _id="events_filters_tags_toggle"
            ),
            EventHandler(
                function=events_filters_not_implemented_handler, _id="events_filters_date"
            ),
            EventHandler(function=events_filters_mode_open_handler, _id="events_filters_mode"),
            EventHandler(
                function=events_filters_mode_select_handler, _id="events_filters_mode_select"
            ),
            EventHandler(function=all_requests_handler, value="requests"),
            EventHandler(function=requests_page_handler, _id="requests_prev"),
            EventHandler(function=requests_page_handler, _id="requests_next"),
            EventHandler(function=request_open_handler, _id="request_open"),
            EventHandler(function=request_approve_handler, _id="request_approve"),
            EventHandler(function=request_reject_handler, _id="request_reject"),
            # TODO почистить
            EventHandler(function=noop_handler, _id="noop_prev"),
            EventHandler(function=noop_handler, _id="noop_mid"),
            EventHandler(function=noop_handler, _id="noop_next"),
            EventHandler(function=noop_handler, _id="noop_uuid"),
            EventHandler(function=requests_prev_page_handler, _id="requests_prev"),
            EventHandler(function=requests_next_page_handler, _id="requests_next"),
            EventHandler(function=tb_approved, _id="tb_approved"),
            EventHandler(function=gosb_approved, _id="gosb_approved"),
            EventHandler(function=tb_update_selected, _id="tb_select"),
            EventHandler(
                function=event_create_back_to_time_handler, _id="event_create_back_to_time"
            ),
            EventHandler(function=tb_reselect_handler, _id="tb_reselect"),
            EventHandler(function=gosb_update_selected, _id="gosb_select"),
            EventHandler(function=event_source_callback_handler, _id="ai_event_card"),
        ]
    )


def main() -> None:  # legacy
    handlers_setting()
    bot.profile.edit_about_sync("Волонтёрский бот, который помогает сотрудникам Сбера нести добро!")
    bot.updates.on_updates(do_read_message=True, do_register_commands=True)


if __name__ == "__main__":
    main()