from __future__ import annotations

import logging

from aiogram import F, Router
from aiogram.enums import ChatType
from aiogram.filters import Command
from aiogram.types import Message, MessageReactionUpdated

from bot.services.relay import GENERAL_TOPIC_ID, RelayService, is_relayable_content

logger = logging.getLogger(__name__)


def build_manager_router(manager_group_id: int) -> Router:
    router = Router(name="manager")

    @router.message(
        Command("del"),
        F.chat.id == manager_group_id,
        F.chat.type == ChatType.SUPERGROUP,
    )
    async def manager_del(message: Message, relay: RelayService) -> None:
        """Reply to a relayed message with /del to remove it on both sides."""
        if relay.is_self(message.from_user.id if message.from_user else None):
            return
        topic_id = message.message_thread_id
        if topic_id is None or topic_id == GENERAL_TOPIC_ID:
            return
        if message.reply_to_message is None:
            return
        try:
            deleted = await relay.delete_paired_from_manager(message.bot, message)
        except Exception:
            logger.exception("Failed to delete paired message in topic %s", topic_id)
            return
        if deleted:
            try:
                await message.delete()
            except Exception:
                pass

    @router.message(
        F.chat.id == manager_group_id,
        F.chat.type == ChatType.SUPERGROUP,
    )
    async def manager_message(message: Message, relay: RelayService) -> None:
        if relay.is_self(message.from_user.id if message.from_user else None):
            return

        topic_id = message.message_thread_id
        if topic_id is None or topic_id == GENERAL_TOPIC_ID:
            return
        if not is_relayable_content(message):
            return

        try:
            await relay.relay_manager_to_client(message.bot, message)
        except Exception:
            logger.exception("Failed to relay manager message in topic %s", topic_id)

    @router.edited_message(
        F.chat.id == manager_group_id,
        F.chat.type == ChatType.SUPERGROUP,
    )
    async def manager_edited(message: Message, relay: RelayService) -> None:
        if relay.is_self(message.from_user.id if message.from_user else None):
            return

        topic_id = message.message_thread_id
        if topic_id is None or topic_id == GENERAL_TOPIC_ID:
            return
        if not is_relayable_content(message):
            return

        try:
            await relay.relay_manager_edit(message.bot, message)
        except Exception:
            logger.exception("Failed to relay manager edit in topic %s", topic_id)

    @router.message_reaction(F.chat.id == manager_group_id)
    async def manager_reaction(event: MessageReactionUpdated, relay: RelayService) -> None:
        try:
            await relay.relay_reaction(event.bot, event)
        except Exception:
            logger.exception(
                "Failed to relay manager reaction on message %s",
                event.message_id,
            )

    return router