import asyncio
import logging
import sys
import signal  # Import the signal module
from aiogram import Bot, Dispatcher, Router
from aiogram.enums import ParseMode
from aiogram.filters import CommandStart, Command
from aiogram.types import Message, ChatJoinRequest, CallbackQuery, ChatMemberUpdated, ChatMemberLeft, ChatMemberBanned
from aiogram.enums import ChatMemberStatus
from config import BOT_TOKEN
from handlers.routing import handle_routing
from handlers.callback_unlink import handle_unlink
from handlers.callback_vouch import handle_button
from handlers.handle_join_request import handle_join_request
from handlers.handle_startup import handle_startup
from handlers.handle_members_change import handle_join, handle_left
from state import State
from storage import Profile

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
router = Router()
bot = Bot(BOT_TOKEN, parse_mode=ParseMode.HTML)
dp = Dispatcher()
state = State()


@router.message(CommandStart())
async def command_start_handler(message: Message) -> None:
    await message.answer("Напишите своё сообщение для администрации чата")


@router.callback_query()
async def process_callback(callback_query: CallbackQuery):
    cbq = vars(callback_query)
    cbq["from"] = vars(callback_query.from_user)
    cbq["message"] = vars(callback_query.message)
    data = cbq["data"]
    if data.startswith("vouch"):
        await handle_button(cbq)
    elif data.startswith("unlink"):
        await handle_unlink(cbq, state)


@router.chat_join_request()
async def join_request_handler(update: ChatJoinRequest) -> None:
    print("chat join request")
    join_request = vars(update)
    join_request["from"] = vars(update.from_user)
    join_request["chat"] = vars(update.chat)
    await handle_join_request(join_request)

@router.message()
async def all_handler(message: Message) -> None:
    msg = vars(message)
    msg["from"] = vars(message.from_user)
    msg["chat"] = vars(message.chat)
    if message.reply_to_message:
        msg["reply_to_message"] = vars(message.reply_to_message)
    await handle_routing(msg, state)
    await asyncio.sleep(1.0)


@router.my_chat_member()
async def chat_members_change(update: ChatMemberUpdated):
    msg = vars(update)
    msg["chat"] = vars(update.chat)
    msg["from"] = vars(update.from_user)
    logger.debug(msg)
    old_member = update.old_chat_member
    new_member = update.new_chat_member
    if old_member:
        if old_member.status == ChatMemberStatus.KICKED:
            Profile.erase(update.from_user.id)
        await handle_left(msg)
    elif new_member:
        await handle_join(msg)
    else:
        logger.info("unhandled members update")


async def main() -> None:
    # connect router
    dp.include_router(router)
    # storage revalidation
    await handle_startup()
    # Start event dispatching
    await dp.start_polling(bot)


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO, stream=sys.stdout)

    # Define a function to handle SIGTERM
    def handle_sigterm(signum, frame):
        logger.info("Received SIGTERM. Shutting down gracefully...")
        asyncio.get_event_loop().stop()

    # Register the SIGTERM signal handler
    signal.signal(signal.SIGTERM, handle_sigterm)

    asyncio.get_event_loop().run_until_complete(main())