"""
main.py - bot for installin modules by buttons in Telegram channels via Limoka
"""

import os
import json
import logging
import time
import asyncio
import hashlib
import re
from datetime import datetime
from typing import Optional, Dict, List

import aiohttp
from aiogram import Bot, Dispatcher, Router
from aiogram.filters import Command, BaseFilter
from aiogram.types import (
    Message,
    CallbackQuery,
    InlineKeyboardButton,
    InlineKeyboardMarkup,
)
from aiogram.exceptions import TelegramForbiddenError, TelegramAPIError
from aiogram.utils.formatting import (
    Text,
    Bold,
    Code,
    Italic,
    as_section,
    as_list,
    HashTag,
)
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ed25519

from dotenv import load_dotenv

# === CONFIGURATION ===
load_dotenv()
BOT_TOKEN = os.getenv("BOT_TOKEN", "123456789:AA11CC22DD33EE44FF55GG66HH77II88JJ99")
ADMIN_IDS = set(map(int, os.getenv("ADMIN_IDS", "123").split(",")))
WHITELIST_FILE = "whitelist.json"
PRIVATE_KEY_FILE = os.getenv("PRIVATE_KEY_FILE", "key.pem")
MODULES_JSON_URL = "https://raw.githubusercontent.com/MuRuLOSE/limoka/main/modules.json"
MODULES_BASE_URL = MODULES_JSON_URL.replace("modules.json", "")
UPDATE_INTERVAL_MINUTES = 30

# === STRINGS (only plain text — formatting done via aiogram.utils.formatting) ===
STRINGS = {
    "en": {
        # Startup
        "logging_initialized": "✅ Logging initialized with UTF-8 support",
        "starting_bot": "🚀 Starting Limoka Install Bot...",
        "security_manager_initialized": "✅ Security manager initialized",
        "security_manager_failed": "❌ Failed to initialize security manager: {}",
        "security_critical_error": "Bot will not be able to sign modules - shutting down",
        "modules_loaded": "✅ Loaded {} modules from repository",
        "modules_auto_updater": "🔄 Starting modules.json auto-updater (every {} minutes)",
        "auto_update_failed": "❌ Auto-update failed: {}",
        "startup_notification_title": "Limoka Install Bot started successfully!",
        "startup_notification_body": [
            "• Enhanced whitelist: ✅ Active (channel→repo mapping)",
            "• Time validation: ❌ Removed",
            "• Module signing: ✅ Ed25519",
            "",
            "🔧 Admin commands:",
            "/addrepo <channel_id> <repo> — Add repo to channel",
            "/rmrepo <channel_id> <repo> — Remove repo from channel",
            "/whitelist — Show all whitelisted channels",
        ],
        "bot_running": "✅ Bot is now running and listening for updates",
        "shutting_down": "🛑 Shutting down Limoka Install Bot...",
        # Whitelist
        "whitelist_file_created": "Created new whitelist file: {}",
        "whitelist_loaded": "Loaded whitelist with {} channels",
        "whitelist_load_failed": "❌ Error loading whitelist: {}",
        "whitelist_saved": "✅ Saved whitelist with {} channels",
        "whitelist_save_failed": "❌ Error saving whitelist: {}",
        "channel_added": "✅ Channel {} added to whitelist.",
        "channel_already_exists": "ℹ️ Channel {} already in whitelist.",
        "channel_removed": "✅ Channel {} removed from whitelist.",
        "channel_not_found": "❌ Channel {} not found in whitelist.",
        "channel_normalized": "Normalized channel ID: {} → {}",
        "whitelist_empty": "📋 Whitelist is empty.",
        "whitelist_title": "📋 Whitelisted channels:",
        "repo_added": "✅ Repository {} added to channel {} whitelist.",
        "repo_already_exists": "ℹ️ Repository {} already in whitelist for channel {}.",
        "repo_removed": "✅ Repository {} removed from channel {} whitelist.",
        "repo_not_found": "❌ Repository {} not found in whitelist for channel {}.",
        "channel_not_in_whitelist": "❌ Channel {} not found in whitelist.",
        # Commands
        "unauthorized_access": "❌ You are not authorized to use this bot.",
        "start_command_title": "Limoka Install Bot",
        "start_command_body": [
            "Commands:",
            "/whitelist — Show whitelisted channels",
            "/addchannel <id> — Add channel to whitelist",
            "/rmchannel <id> — Remove channel from whitelist",
            "/reload — Reload modules.json",
        ],
        "addchannel_usage": "❌ Usage: /addchannel <channel_id>",
        "rmchannel_usage": "❌ Usage: /rmchannel <channel_id>",
        "addrepo_usage": "❌ Usage: /addrepo <channel_id> <repo>\nExample: /addrepo -1003377102183 MuRuLOSE/limoka-modules",
        "rmrepo_usage": "❌ Usage: /rmrepo <channel_id> <repo>\nExample: /rmrepo -1003377102183 MuRuLOSE/limoka-modules",
        "reload_command": "🔄 Reloading modules.json...",
        "modules_reloaded": "✅ Loaded {} modules.",
        "envforceupdate_success": "✅ Environment variables reloaded.",
        "current_admin_ids": "Current ADMIN_IDS:",
        # Callbacks
        "callback_format_invalid": "❌ Invalid callback data format",
        "service_unavailable": "❌ Service unavailable — modules database not loaded",
        "module_not_in_database": "❌ Module not found in database",
        "hash_collision": "⚠️ Hash collision detected for paths: {}",
        "ambiguous_module": "❌ Ambiguous module match — please try again",
        "signature_verification_failed": "❌ Signature verification failed! Installation aborted.",
        "signature_spoof_attempt": "❌ Signature spoof attempt detected for module: {}",
        "message_sent": "✅ Message sent! Check your private messages.",
        "cannot_send_messages": "❌ I can't send you messages. Please start a chat with me first!",
        "install_success": "✅ Module installed successfully!",
        "install_failed": "❌ Installation failed:\n<code>{}</code>",
        # Buttons
        "install_button_text": "🍋 Install via Limoka",
        "install_reply_text": "🍋 Install via Limoka:",
        # Filters
        "channel_whitelisted": "✅ Channel {} is whitelisted (allowed repos: {})",
        "channel_not_whitelisted": "❌ Channel {} is NOT whitelisted",
        "limoka_tag_found": "✅ Found limoka tag: {}",
        "limoka_tag_processing": "🎯 Processing limoka tag: {}",
    }
}

# === LOGGING ===
# Configure logging: write DEBUG+ to file, but keep console output concise (INFO+).
logger = logging.getLogger("LimokaBot")
logger.setLevel(logging.DEBUG)

# File handler: store all logs including DEBUG for diagnostics
file_handler = logging.FileHandler("limoka_bot.log", encoding="utf-8")
file_handler.setLevel(logging.DEBUG)
file_formatter = logging.Formatter(
    "%(asctime)s | %(name)s | %(levelname)s | %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
file_handler.setFormatter(file_formatter)

# Console/stream handler: only INFO+ to avoid noisy debug output in production
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
stream_formatter = logging.Formatter(
    "%(asctime)s | %(levelname)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
)
stream_handler.setFormatter(stream_formatter)

# Attach handlers (avoid duplicate handlers if reloading)
if not logger.handlers:
    logger.addHandler(file_handler)
    logger.addHandler(stream_handler)

logger.info(STRINGS["en"]["logging_initialized"])

# === INIT ===
bot = Bot(token=BOT_TOKEN)
dp = Dispatcher()
router = Router()

_cached_modules: Optional[Dict] = None
_modules_last_update: float = 0.0
_security_manager = None


# === SECURITY MANAGER ===
class SecurityManager:
    def __init__(self, private_key_path: str):
        if not os.path.exists(private_key_path):
            raise FileNotFoundError(f"Private key not found: {private_key_path}")
        try:
            with open(private_key_path, "rb") as f:
                self.private_key = serialization.load_pem_private_key(
                    f.read(), password=None
                )
            if not isinstance(self.private_key, ed25519.Ed25519PrivateKey):
                raise ValueError("Only Ed25519 keys are supported")
            logger.info("✅ Ed25519 private key loaded successfully")
        except Exception as e:
            logger.error(f"❌ Failed to load private key: {e}")
            raise

    def sign(self, data: str) -> str:
        try:
            signature = self.private_key.sign(data.encode())
            return signature.hex()
        except Exception as e:
            logger.error(f"❌ Signing failed: {e}")
            raise


# === WHITELIST ===
def load_whitelist() -> dict:
    try:
        if not os.path.exists(WHITELIST_FILE):
            default = {"channels": {}, "last_updated": datetime.now().isoformat()}
            with open(WHITELIST_FILE, "w", encoding="utf-8") as f:
                json.dump(default, f, indent=2, ensure_ascii=False)
            logger.info(f"Created new whitelist file: {WHITELIST_FILE}")
            return default
        with open(WHITELIST_FILE, "r", encoding="utf-8") as f:
            return json.load(f)
    except Exception as e:
        logger.error(f"❌ Error loading whitelist: {e}")
        return {"channels": {}}


def save_whitelist(data: dict):
    data["last_updated"] = datetime.now().isoformat()
    try:
        with open(WHITELIST_FILE, "w", encoding="utf-8") as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
        logger.info(f"✅ Saved whitelist with {len(data['channels'])} channels")
    except Exception as e:
        logger.error(f"❌ Error saving whitelist: {e}")


# === MODULES ===
async def fetch_modules_json() -> Optional[Dict]:
    global _cached_modules, _modules_last_update
    try:
        async with aiohttp.ClientSession() as session:
            async with session.get(MODULES_JSON_URL, timeout=15) as resp:
                if resp.status != 200:
                    logger.error(f"❌ Failed to fetch modules.json: HTTP {resp.status}")
                    return None
                text = await resp.text()
                data = json.loads(text)
                _cached_modules = data
                _modules_last_update = time.time()
                logger.info(STRINGS["en"]["modules_loaded"].format(len(data)))
                return data
    except json.JSONDecodeError as e:
        logger.error(f"❌ Invalid JSON in modules.json: {e}")
        return None
    except Exception as e:
        logger.error(f"❌ Fetch failed: {e}")
        return None


async def get_modules() -> Dict:
    global _cached_modules
    if _cached_modules is None:
        await fetch_modules_json()
    return _cached_modules or {}


async def modules_updater():
    logger.info(STRINGS["en"]["modules_auto_updater"].format(UPDATE_INTERVAL_MINUTES))
    while True:
        try:
            await fetch_modules_json()
        except Exception as e:
            logger.error(STRINGS["en"]["auto_update_failed"].format(e))
        await asyncio.sleep(UPDATE_INTERVAL_MINUTES * 60)


# === FILTERS ===
class WhitelistChannelFilter(BaseFilter):
    async def __call__(self, message: Message) -> bool:
        if not message.chat:
            return False
        whitelist = load_whitelist()
        chat_id = str(message.chat.id)
        return chat_id in whitelist["channels"]


class LimokaTagFilter(BaseFilter):
    async def __call__(self, message: Message) -> Optional[Dict[str, str]]:
        text = (message.text or message.caption or "").strip()
        if not text:
            return False
        pattern = r"#limoka:([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)/([a-zA-Z0-9_/.%-]+\.(?:py|pyc|pyo|pyd))"
        match = re.search(pattern, text)
        if not match:
            return False
        username, repo, module_path = match.groups()
        full_path = f"{username}/{repo}/{module_path}"
        return {
            "username": username,
            "repo": repo,
            "module_path": module_path,
            "full_path": full_path,
        }


# === UTILS ===
def normalize_channel_id(cid: str) -> str:
    if cid.startswith("-100"):
        return cid
    if cid.startswith("-"):
        return "-100" + cid[1:]
    if cid.isdigit():
        return "-100" + cid
    return cid


# === COMMAND HANDLERS ===
@router.message(Command("start"))
async def cmd_start(message: Message):
    if message.from_user.id not in ADMIN_IDS:
        await message.answer(STRINGS["en"]["unauthorized_access"])
        return
    content = as_section(
        Bold(STRINGS["en"]["start_command_title"]),
        "",
        *STRINGS["en"]["start_command_body"],
        "",
        Bold("Current chat ID:"),
        Code(str(message.chat.id)),
    )
    await message.answer(**content.as_kwargs())


# === COMMAND HANDLERS ===
@router.message(Command("envforceupdate"))
async def cmd_envforceupdate(message: Message):
    if message.from_user.id not in ADMIN_IDS:
        await message.answer(STRINGS["en"]["unauthorized_access"])
        return
    load_dotenv()
    content = as_section(
        Bold(STRINGS["en"]["envforceupdate_success"]),
        "",
        Bold(STRINGS["en"]["current_admin_ids"]),
        Code(str(ADMIN_IDS)),
    )
    await message.answer(**content.as_kwargs())


@router.message(Command("whitelist"))
async def cmd_whitelist(message: Message):
    if message.from_user.id not in ADMIN_IDS:
        return
    whitelist = load_whitelist()
    channels = whitelist["channels"]
    if not channels:
        await message.answer(STRINGS["en"]["whitelist_empty"])
        return
    items = [Code(cid) for cid in sorted(channels.keys())]
    content = as_section(Bold(STRINGS["en"]["whitelist_title"]), *items)
    await message.answer(**content.as_kwargs())


@router.message(Command("addchannel"))
async def cmd_addchannel(message: Message):
    if message.from_user.id not in ADMIN_IDS:
        return
    args = message.text.split(maxsplit=1)
    if len(args) < 2:
        await message.answer(STRINGS["en"]["addchannel_usage"])
        return
    raw_id = args[1].strip()
    norm_id = normalize_channel_id(raw_id)
    logger.info(f"Normalized: {raw_id} → {norm_id}")
    whitelist = load_whitelist()
    if norm_id not in whitelist["channels"]:
        whitelist["channels"][norm_id] = {
            "allowed_repos": [],
            "added_date": datetime.now().isoformat(),
        }
        save_whitelist(whitelist)
        await message.answer(STRINGS["en"]["channel_added"].format(norm_id))
    else:
        await message.answer(STRINGS["en"]["channel_already_exists"].format(norm_id))


@router.message(Command("rmchannel"))
async def cmd_rmchannel(message: Message):
    if message.from_user.id not in ADMIN_IDS:
        return
    args = message.text.split(maxsplit=1)
    if len(args) < 2:
        await message.answer(STRINGS["en"]["rmchannel_usage"])
        return
    raw_id = args[1].strip()
    norm_id = normalize_channel_id(raw_id)
    whitelist = load_whitelist()
    if norm_id in whitelist["channels"]:
        del whitelist["channels"][norm_id]
        save_whitelist(whitelist)
        await message.answer(STRINGS["en"]["channel_removed"].format(norm_id))
    else:
        await message.answer(STRINGS["en"]["channel_not_found"].format(norm_id))


@router.message(Command("addrepo"))
async def cmd_addrepo(message: Message):
    if message.from_user.id not in ADMIN_IDS:
        return
    args = message.text.split(maxsplit=2)
    if len(args) < 3:
        content = as_section(Bold("❌ Usage:"), Code("/addrepo <channel_id> <repo>"))
        await message.answer(**content.as_kwargs())
        return
    raw_cid, repo = args[1], args[2]
    cid = normalize_channel_id(raw_cid)
    whitelist = load_whitelist()
    if cid not in whitelist["channels"]:
        await message.answer(STRINGS["en"]["channel_not_in_whitelist"].format(cid))
        return
    if repo not in whitelist["channels"][cid]["allowed_repos"]:
        whitelist["channels"][cid]["allowed_repos"].append(repo)
        save_whitelist(whitelist)
        await message.answer(STRINGS["en"]["repo_added"].format(repo, cid))
    else:
        await message.answer(STRINGS["en"]["repo_already_exists"].format(repo, cid))


@router.message(Command("rmrepo"))
async def cmd_rmrepo(message: Message):
    if message.from_user.id not in ADMIN_IDS:
        return
    args = message.text.split(maxsplit=2)
    if len(args) < 3:
        content = as_section(Bold("❌ Usage:"), Code("/rmrepo <channel_id> <repo>"))
        await message.answer(**content.as_kwargs())
        return
    raw_cid, repo = args[1], args[2]
    cid = normalize_channel_id(raw_cid)
    whitelist = load_whitelist()
    if cid not in whitelist["channels"]:
        await message.answer(STRINGS["en"]["channel_not_in_whitelist"].format(cid))
        return
    if repo in whitelist["channels"][cid]["allowed_repos"]:
        whitelist["channels"][cid]["allowed_repos"].remove(repo)
        if not whitelist["channels"][cid]["allowed_repos"]:
            del whitelist["channels"][cid]
        save_whitelist(whitelist)
        await message.answer(STRINGS["en"]["repo_removed"].format(repo, cid))
    else:
        await message.answer(STRINGS["en"]["repo_not_found"].format(repo, cid))


@router.message(Command("reload"))
async def cmd_reload(message: Message):
    if message.from_user.id not in ADMIN_IDS:
        return
    await message.answer(STRINGS["en"]["reload_command"])
    data = await fetch_modules_json()
    await message.answer(
        STRINGS["en"]["modules_reloaded"].format(len(data) if data else 0)
    )


# === CHANNEL POST HANDLERS ===
@router.channel_post(WhitelistChannelFilter(), LimokaTagFilter())
@router.edited_channel_post(WhitelistChannelFilter(), LimokaTagFilter())
async def handle_limoka_tag(
    message: Message, username: str, repo: str, module_path: str, full_path: str
):
    logger.info(STRINGS["en"]["limoka_tag_found"].format(full_path))
    await process_limoka_tag_directly(message, username, repo, module_path, full_path)


async def process_limoka_tag_directly(
    message: Message, username: str, repo: str, module_path: str, full_path: str
):
    whitelist = load_whitelist()
    chat_id = str(message.chat.id)
    allowed_repos = whitelist["channels"][chat_id].get("allowed_repos", [])
    repo_full = f"{username}/{repo}"
    if allowed_repos and repo_full not in allowed_repos:
        logger.warning(f"Repo {repo_full} blocked for channel {chat_id}")
        return

    modules = await get_modules()
    if not modules or full_path not in modules:
        logger.warning(f"Module not in DB: {full_path}")
        return

    try:
        # Compute sha256 of remote module content and sign "full_path|sha256"
        module_url = MODULES_BASE_URL + full_path
        async with aiohttp.ClientSession() as session:
            async with session.get(module_url, timeout=10) as resp:
                if resp.status != 200:
                    logger.error(f"Failed to fetch module for signing: {module_url} (HTTP {resp.status})")
                    return
                module_bytes = await resp.read()
        sha256 = hashlib.sha256(module_bytes).hexdigest()
        payload = f"{full_path}|{sha256}"
        signature = _security_manager.sign(payload)
        path_hash = hashlib.sha256(full_path.encode()).hexdigest()[:8]
        cb_data = f"install:{path_hash}:{signature[:32]}"[:64]

        keyboard = InlineKeyboardMarkup(
            inline_keyboard=[
                [
                    InlineKeyboardButton(
                        text=STRINGS["en"]["install_button_text"], callback_data=cb_data
                    )
                ]
            ]
        )

        text = (message.text or message.caption or "").strip()
        new_text = (
            re.sub(r"#limoka:[^\s]+", "", text).strip()
            or "Module installation available"
        )

        await bot.edit_message_text(
            chat_id=message.chat.id,
            message_id=message.message_id,
            text=new_text,
            reply_markup=keyboard,
        )
        logger.info(f"✅ Button added to message {message.message_id}")
    except TelegramAPIError as e:
        logger.error(f"Failed to add button: {e}")


# === CALLBACKS ===
@router.callback_query(lambda c: c.data.startswith("install:"))
async def process_install(callback: CallbackQuery):
    try:
        parts = callback.data.split(":", 3)
        if len(parts) < 3:
            await callback.answer(
                STRINGS["en"]["callback_format_invalid"], show_alert=True
            )
            return

        _, path_hash, sig_short = parts[:3]
        modules = await get_modules()
        if not modules:
            await callback.answer(STRINGS["en"]["service_unavailable"], show_alert=True)
            return

        matches = [
            p
            for p in modules
            if hashlib.sha256(p.encode()).hexdigest()[:8] == path_hash
        ]
        if not matches:
            await callback.answer(
                STRINGS["en"]["module_not_in_database"], show_alert=True
            )
            return
        if len(matches) > 1:
            await callback.answer(STRINGS["en"]["ambiguous_module"], show_alert=True)
            logger.warning(STRINGS["en"]["hash_collision"].format(matches))
            return

        module_path = matches[0]
        # Recompute sha256 for module and verify signature prefix
        module_url = MODULES_BASE_URL + module_path
        try:
            async with aiohttp.ClientSession() as session:
                async with session.get(module_url, timeout=10) as resp:
                    if resp.status != 200:
                        await callback.answer(STRINGS["en"]["service_unavailable"], show_alert=True)
                        return
                    module_bytes = await resp.read()
        except Exception:
            await callback.answer(STRINGS["en"]["service_unavailable"], show_alert=True)
            return

        sha256 = hashlib.sha256(module_bytes).hexdigest()
        expected_sig = _security_manager.sign(f"{module_path}|{sha256}")
        if not expected_sig.startswith(sig_short):
            await callback.answer(
                STRINGS["en"]["signature_verification_failed"], show_alert=True
            )
            logger.warning(STRINGS["en"]["signature_spoof_attempt"].format(module_path))
            return

        install_code = f"#limoka:{module_path}:{expected_sig}"
        content = as_section(Code(install_code))
        await bot.send_message(callback.from_user.id, **content.as_kwargs())
        await callback.answer(STRINGS["en"]["message_sent"], show_alert=True)

    except TelegramForbiddenError:
        await callback.answer(STRINGS["en"]["cannot_send_messages"], show_alert=True)
    except Exception as e:
        logger.exception(f"Callback error: {e}")
        await callback.answer(f"❌ {type(e).__name__}", show_alert=True)


# === INSTALL RESULT CONFIRMATION ===
@router.message()
async def handle_install_result(message: Message):
    """Handle #limoka:sucsess: and #limoka:failed: from userbot"""
    if not message.text:
        return

    text = message.text.strip()

    # ✅ Success
    if text.startswith("#limoka:sucsess:"):
        parts = text.split(":", 3)
        if len(parts) >= 3:
            try:
                orig_msg_id = int(parts[2])
                await bot.delete_message(message.chat.id, orig_msg_id)
                logger.info(f"✅ Deleted original message {orig_msg_id} (success)")
            except Exception as e:
                logger.warning(f"Failed to delete success source msg {parts[2]}: {e}")
            await message.answer(STRINGS["en"]["install_success"])
            await message.delete()
        return

    # ✅ Failed
    if text.startswith("#limoka:failed:"):
        parts = text.split(":", 3)
        if len(parts) >= 3:
            try:
                orig_msg_id = int(parts[2])
                await bot.delete_message(message.chat.id, orig_msg_id)
                logger.info(f"✅ Deleted original message {orig_msg_id} (failure)")
            except Exception as e:
                logger.warning(f"Failed to delete failed source msg {parts[2]}: {e}")
            error_msg = parts[3] if len(parts) > 3 else "Unknown error"
            await message.answer(
                STRINGS["en"]["install_failed"].format(error_msg), parse_mode="HTML"
            )
            await message.delete()
        return

    # Ignore private non-service messages from non-admin users.
    # Keep silent (no logs or replies) for non-admin private messages.
    if message.chat.type == "private" and message.from_user.id not in ADMIN_IDS:
        return


# === STARTUP/SHUTDOWN ===
async def on_startup():
    global _security_manager
    logger.info(STRINGS["en"]["starting_bot"])
    try:
        _security_manager = SecurityManager(PRIVATE_KEY_FILE)
        logger.info(STRINGS["en"]["security_manager_initialized"])
    except Exception as e:
        logger.critical(STRINGS["en"]["security_manager_failed"].format(e))
        logger.critical(STRINGS["en"]["security_critical_error"])
        exit(1)

    await fetch_modules_json()
    asyncio.create_task(modules_updater())

    for admin in ADMIN_IDS:
        try:
            content = as_section(
                Bold(STRINGS["en"]["startup_notification_title"]),
                "",
                *STRINGS["en"]["startup_notification_body"],
            )
            await bot.send_message(admin, **content.as_kwargs())
        except Exception as e:
            logger.error(f"Failed to notify admin {admin}: {e}")


async def on_shutdown():
    logger.info(STRINGS["en"]["shutting_down"])
    await bot.session.close()


# === MAIN ===
async def main():
    await on_startup()
    dp.include_router(router)
    logger.info(STRINGS["en"]["bot_running"])
    try:
        await dp.start_polling(bot)
    finally:
        await on_shutdown()


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