import asyncio
import logging
import signal
import sys
from aiohttp import web
from bot.api import send_message
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 storage.profile import Profile
from bot.state import State
from bot.config import FEEDBACK_CHAT_ID

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
state = State()


async def command_start_handler(message):
    caption = "Напишите своё сообщение для нас" if message.from_user.llanguage_code == 'ru' else "Write your message for us"
    await message.answer(caption)


async def process_callback(callback_query):
    cbq = vars(callback_query)
    try:
        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)
    except Exception as e:
        logger.error(f"[main.process_callback] ERROR {e}")
        logger.debug(cbq)
        import traceback
        text = traceback.format_exc()
        await send_message(FEEDBACK_CHAT_ID, text)


async def join_request_handler(update):
    print("chat join request")
    join_request = vars(update)
    try:
        join_request["from"] = vars(update.from_user)
        join_request["chat"] = vars(update.chat)
        await handle_join_request(join_request)
    except Exception as e:
        logger.error(f"[main.join_request_handler] ERROR {e}")
        logger.debug(join_request)
        import traceback
        text = traceback.format_exc()
        await send_message(FEEDBACK_CHAT_ID, text)


async def all_handler(message):
    msg = vars(message)
    try:
        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)
    except Exception as e:
        logger.error(f"[main.all_handler] ERROR {e}")
        logger.debug(msg)
        import traceback
        text = traceback.format_exc()
        await send_message(FEEDBACK_CHAT_ID, text)


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

    except Exception as e:
        logger.error(f"[main.my_chat_member] ERROR {e}")
        logger.debug(member_updated)
        import traceback
        text = traceback.format_exc()
        await send_message(FEEDBACK_CHAT_ID, text)


async def main(request):
    # storage revalidation
    await handle_startup()

    # Получение обновлений
    updates = await request.json()

    for update in updates["result"]:
        if "message" in update:
            await all_handler(update["message"])
        elif "callback_query" in update:
            await process_callback(update["callback_query"])
        elif "join_chat_request" in update:
            await join_request_handler(update["join_chat_request"])
        elif "my_chat_member" in update:
            await chat_members_change(update["my_chat_member"])

    return web.Response()


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

    app = web.Application()
    app.router.add_post('/your_bot_token', main)  # Замените 'your_bot_token' на реальный токен вашего бота
    web.run_app(app, host='0.0.0.0', port=3000)  # Выберите подходящий порт