#!/usr/bin/env python3
"""aiogram 3 echo/button demo for the telesrv Bot API endpoint."""

import argparse
import asyncio
import logging
import os

from aiogram import Bot, Dispatcher, F, Router
from aiogram.client.session.aiohttp import AiohttpSession
from aiogram.client.telegram import TelegramAPIServer
from aiogram.enums import ButtonStyle
from aiogram.filters import Command, CommandStart
from aiogram.types import (
    CallbackQuery,
    InlineKeyboardButton,
    InlineKeyboardMarkup,
    KeyboardButton,
    Message,
    ReplyParameters,
    ReplyKeyboardMarkup,
)
from aiogram.webhook.aiohttp_server import SimpleRequestHandler, setup_application
from aiohttp import web


LOG = logging.getLogger("aiogramecho")


def env_int(name: str) -> int | None:
    raw = os.getenv(name)
    if not raw:
        return None
    try:
        return int(raw)
    except ValueError as exc:
        raise SystemExit(f"{name} must be an integer, got {raw!r}") from exc


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="aiogram 3 echo bot against telesrv")
    parser.add_argument("--token", default=os.getenv("TELESRV_BOT_TOKEN"))
    parser.add_argument(
        "--base-url",
        default=os.getenv("TELESRV_BOT_API_SERVER", "http://127.0.0.1:8081"),
        help="API server origin; aiogram adds /bot<TOKEN> and /file/bot<TOKEN>",
    )
    parser.add_argument("--prefix", default="aiogram echo: ")
    parser.add_argument("--ephemeral-prefix", default="ephemeral echo: ")
    parser.add_argument("--drop-pending", action="store_true")
    parser.add_argument("--mode", choices=("polling", "webhook"), default=os.getenv("TELESRV_BOT_MODE", "polling"))
    parser.add_argument(
        "--webhook-url",
        default=os.getenv("TELESRV_BOT_WEBHOOK_URL", ""),
        help="Public HTTP(S) URL including the webhook path",
    )
    parser.add_argument(
        "--webhook-path",
        default=os.getenv("TELESRV_BOT_WEBHOOK_PATH", "/webhook"),
        help="Local aiohttp route, normally the path part of --webhook-url",
    )
    parser.add_argument("--webhook-secret", default=os.getenv("TELESRV_BOT_WEBHOOK_SECRET", "telesrv-aiogram-demo"))
    parser.add_argument("--listen-host", default=os.getenv("TELESRV_BOT_LISTEN_HOST", "127.0.0.1"))
    parser.add_argument("--listen-port", type=int, default=env_int("TELESRV_BOT_LISTEN_PORT") or 8082)
    parser.add_argument("--delete-webhook-on-exit", action="store_true")
    parser.add_argument("--timeout", type=int, default=30)
    parser.add_argument("--send-chat-id", type=int, default=env_int("TELESRV_BOT_DEMO_CHAT_ID"))
    parser.add_argument("--send-text", default=os.getenv("TELESRV_BOT_DEMO_SEND_TEXT", ""))
    parser.add_argument("--buttons-chat-id", type=int, default=env_int("TELESRV_BOT_DEMO_BUTTONS_CHAT_ID"))
    parser.add_argument(
        "--button-icon-id",
        default=os.getenv("TELESRV_BOT_DEMO_BUTTON_ICON_ID"),
        help="Optional custom emoji document id used as the button icon",
    )
    parser.add_argument("--send-only", action="store_true")
    parser.add_argument("--log-level", default="INFO")
    args = parser.parse_args()
    if not args.token:
        parser.error("missing --token or TELESRV_BOT_TOKEN")
    if args.timeout < 0 or args.timeout > 50:
        parser.error("--timeout must be between 0 and 50")
    if args.send_text and args.send_chat_id is None:
        parser.error("--send-chat-id is required with --send-text")
    if args.send_only and not args.send_text and args.buttons_chat_id is None:
        parser.error("--send-only requires --send-text or --buttons-chat-id")
    if args.button_icon_id:
        try:
            if int(args.button_icon_id) <= 0:
                raise ValueError
        except ValueError as exc:
            raise SystemExit("--button-icon-id must be a positive integer") from exc
    if args.mode == "webhook" and not args.webhook_url:
        parser.error("--webhook-url or TELESRV_BOT_WEBHOOK_URL is required in webhook mode")
    if not args.webhook_path.startswith("/") or "?" in args.webhook_path or "#" in args.webhook_path:
        parser.error("--webhook-path must be an absolute path without query or fragment")
    if args.listen_port < 1 or args.listen_port > 65535:
        parser.error("--listen-port must be between 1 and 65535")
    return args


def reply_keyboard(icon_id: str | None) -> ReplyKeyboardMarkup:
    return ReplyKeyboardMarkup(
        keyboard=[
            [
                KeyboardButton(text="Primary", style=ButtonStyle.PRIMARY, icon_custom_emoji_id=icon_id),
                KeyboardButton(text="Success", style=ButtonStyle.SUCCESS, icon_custom_emoji_id=icon_id),
                KeyboardButton(text="Danger", style=ButtonStyle.DANGER, icon_custom_emoji_id=icon_id),
            ]
        ],
        resize_keyboard=True,
        one_time_keyboard=True,
        input_field_placeholder="Tap a colored reply button",
    )


def inline_keyboard(icon_id: str | None) -> InlineKeyboardMarkup:
    return InlineKeyboardMarkup(
        inline_keyboard=[
            [
                InlineKeyboardButton(
                    text="Primary",
                    callback_data="aiogram-primary",
                    style=ButtonStyle.PRIMARY,
                    icon_custom_emoji_id=icon_id,
                ),
                InlineKeyboardButton(
                    text="Success",
                    callback_data="aiogram-success",
                    style=ButtonStyle.SUCCESS,
                    icon_custom_emoji_id=icon_id,
                ),
                InlineKeyboardButton(
                    text="Danger",
                    callback_data="aiogram-danger",
                    style=ButtonStyle.DANGER,
                    icon_custom_emoji_id=icon_id,
                ),
            ]
        ]
    )


async def send_button_messages(bot: Bot, chat_id: int, icon_id: str | None) -> None:
    reply = await bot.send_message(
        chat_id=chat_id,
        text="TELESRV_AIOGRAM_REPLY_STYLES_20260719",
        reply_markup=reply_keyboard(icon_id),
    )
    inline = await bot.send_message(
        chat_id=chat_id,
        text="TELESRV_AIOGRAM_INLINE_STYLES_20260719",
        reply_markup=inline_keyboard(icon_id),
    )
    LOG.info(
        "sent styled buttons chat_id=%s reply_message_id=%s inline_message_id=%s",
        chat_id,
        reply.message_id,
        inline.message_id,
    )


def ephemeral_message_id(message: object) -> int | None:
    """Read the native aiogram field, retaining an extra-field fallback."""
    raw = getattr(message, "ephemeral_message_id", None)
    if raw is None:
        raw = (getattr(message, "model_extra", None) or {}).get("ephemeral_message_id")
    if isinstance(raw, int) and not isinstance(raw, bool) and raw > 0:
        return raw
    return None


async def send_echo(message: Message, prefix: str, ephemeral_prefix: str):
    text = message.text or message.caption or ""
    if not text:
        return None
    transient_id = ephemeral_message_id(message)
    if transient_id is None:
        return await message.answer(prefix + text)

    if message.from_user is None:
        LOG.warning("ignored ephemeral message without from_user ephemeral_message_id=%s", transient_id)
        return None
    return await message.bot.send_message(
        chat_id=message.chat.id,
        text=ephemeral_prefix + text,
        receiver_user_id=message.from_user.id,
        reply_parameters=ReplyParameters(ephemeral_message_id=transient_id),
    )


def build_dispatcher(args: argparse.Namespace) -> Dispatcher:
    router = Router(name="telesrv-aiogramecho")

    @router.message(CommandStart())
    async def start(message: Message) -> None:
        await message.answer("send /ping <text>, /buttons, or any private text")

    @router.message(Command("buttons"))
    async def buttons(message: Message) -> None:
        await send_button_messages(message.bot, message.chat.id, args.button_icon_id)

    @router.message(Command("ping"))
    async def ping(message: Message) -> None:
        await send_echo(message, args.prefix, args.ephemeral_prefix)

    @router.message(Command("private"))
    async def private(message: Message) -> None:
        sent = await send_echo(message, args.prefix, args.ephemeral_prefix)
        LOG.info(
            "echoed ephemeral chat_id=%s ephemeral_message_id=%s sent_ephemeral_message_id=%s",
            message.chat.id,
            ephemeral_message_id(message),
            ephemeral_message_id(sent) if sent is not None else None,
        )

    @router.callback_query(F.data.startswith("aiogram-"))
    async def callback(query: CallbackQuery) -> None:
        await query.answer(f"telesrv {query.data} callback OK")
        LOG.info("answered callback query_id=%s data=%r", query.id, query.data)

    @router.callback_query()
    async def fallback_callback(query: CallbackQuery) -> None:
        """Keep the echo demo responsive for buttons created by another demo."""
        await query.answer("telesrv callback OK")
        LOG.info("answered fallback callback query_id=%s data=%r", query.id, query.data)

    @router.message(F.text)
    async def echo(message: Message) -> None:
        await send_echo(message, args.prefix, args.ephemeral_prefix)
        LOG.info("echoed chat_id=%s message_id=%s", message.chat.id, message.message_id)

    dispatcher = Dispatcher()
    dispatcher.include_router(router)
    return dispatcher


def build_bot(args: argparse.Namespace) -> Bot:
    session = AiohttpSession(api=TelegramAPIServer.from_base(args.base_url.rstrip("/")))
    return Bot(token=args.token, session=session)


async def run(args: argparse.Namespace) -> None:
    bot = build_bot(args)
    runner: web.AppRunner | None = None
    try:
        me = await bot.get_me()
        LOG.info("authenticated as @%s (%s), bot_api=%s", me.username or me.id, me.id, args.base_url)
        if args.send_chat_id is not None and args.send_text:
            sent = await bot.send_message(chat_id=args.send_chat_id, text=args.send_text)
            LOG.info("sent proactive chat_id=%s message_id=%s", args.send_chat_id, sent.message_id)
        if args.buttons_chat_id is not None:
            await send_button_messages(bot, args.buttons_chat_id, args.button_icon_id)
        if args.send_only:
            return
        dispatcher = build_dispatcher(args)
        allowed_updates = ["message", "edited_message", "callback_query"]
        if args.mode == "polling":
            await bot.delete_webhook(drop_pending_updates=args.drop_pending)
            await dispatcher.start_polling(
                bot,
                allowed_updates=allowed_updates,
                polling_timeout=args.timeout,
                close_bot_session=False,
            )
            return

        application = web.Application()
        SimpleRequestHandler(
            dispatcher=dispatcher,
            bot=bot,
            secret_token=args.webhook_secret,
        ).register(application, path=args.webhook_path)
        setup_application(application, dispatcher, bot=bot)
        await bot.set_webhook(
            url=args.webhook_url,
            secret_token=args.webhook_secret,
            allowed_updates=allowed_updates,
            drop_pending_updates=args.drop_pending,
        )
        runner = web.AppRunner(application)
        await runner.setup()
        site = web.TCPSite(runner, host=args.listen_host, port=args.listen_port)
        await site.start()
        LOG.info(
            "webhook listening on http://%s:%s%s, public_url=%s",
            args.listen_host,
            args.listen_port,
            args.webhook_path,
            args.webhook_url,
        )
        await asyncio.Event().wait()
    finally:
        if args.mode == "webhook" and args.delete_webhook_on_exit:
            try:
                await bot.delete_webhook()
            except Exception:  # pragma: no cover - best-effort shutdown logging
                LOG.exception("failed to delete webhook during shutdown")
        if runner is not None:
            await runner.cleanup()
        await bot.session.close()


def main() -> int:
    args = parse_args()
    logging.basicConfig(
        level=getattr(logging, args.log_level.upper(), logging.INFO),
        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    )
    asyncio.run(run(args))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())