from contextlib import asynccontextmanager
from datetime import datetime

import alembic
import structlog
from aiogram import Bot, Dispatcher
from aiogram.client.session.aiohttp import AiohttpSession
from aiogram.enums import ParseMode
from aiogram.fsm.storage.redis import RedisStorage, DefaultKeyBuilder
from aiogram.webhook.aiohttp_server import setup_application, SimpleRequestHandler
from aiohttp import web
from aiohttp.web_request import Request
from aiohttp.web_response import Response
from alembic.config import Config
from dynaconf import LazySettings
from faststream import FastStream
from faststream.rabbit import RabbitBroker

from WebApp import handlers
from WebApp.middlewares.database import SessionMiddleware
from WebApp.middlewares.user import UserDetectMiddleware
from config.configuration import Configuration
from database.build import PostgresBuild


logger: structlog.BoundLogger = structlog.getLogger(__name__)
broker = RabbitBroker("amqp://morington:qwer@localhost:5672/")


class WebhookConstructor:
    def __init__(self, domain: str):
        self.URL = domain
        self.WEBHOOK_PATH = "/bot{bot_token}"

    def webhook_url(self, token: str) -> str:
        return f"{self.URL}{self.WEBHOOK_PATH.format(bot_token=token)}"


async def ping(request: Request) -> Response:
    """
    Checking the application's functionality `/ping`.

    :param request: Request object
    :return: { status": "OK", "datetime": "22.11.2023 17:46:00" }
    """
    now = datetime.now()
    data = {"status": "OK", "datetime": now.strftime("%d.%m.%Y %H:%M:%S")}
    logger.debug("Application ping", data=data)
    return web.json_response(data)


@broker.subscriber("routing_key")
async def handle(msg):
    print(msg, type(msg))


class Initializing:
    def __init__(self, configuration: LazySettings):
        self.configuration = configuration

        self.postgres = PostgresBuild(url=self.configuration.postgres_url)

        self.webhook = WebhookConstructor(domain=self.configuration.web.domain)

        redis_storage = RedisStorage.from_url(
            url=self.configuration.redis_url,
            key_builder=DefaultKeyBuilder(with_destiny=True, with_bot_id=True),
        )

        self.session = AiohttpSession()
        self.app = web.Application()

        self.bot_settings = {
            "session": self.session,
            "parse_mode": ParseMode.HTML,
            "disable_web_page_preview": True,
        }
        bot = Bot(token=self.configuration.telegrambot.key, **self.bot_settings)

        main_dp = Dispatcher(storage=redis_storage)
        main_dp.startup.register(self.on_startup)

        SimpleRequestHandler(dispatcher=main_dp, bot=bot).register(self.app, path=self.webhook.WEBHOOK_PATH)

        setup_application(self.app, main_dp, bot=bot)

        self.app.router.add_get("/ping", ping)
        self.app.on_cleanup.append(self.shutdown_server)

    async def on_startup(self, dispatcher: Dispatcher, bot: Bot):
        _url: str = self.webhook.webhook_url(token=self.configuration.telegrambot.key)

        await bot.delete_webhook(drop_pending_updates=True)
        await bot.set_webhook(_url)
        logger.debug(f"Installed WebHook at: {_url[:-10] + '*' * 10}")

        await self.dispatcher_installer(dispatcher)

        dispatcher.include_router(handlers.router)

        await broker.start()

    async def dispatcher_installer(self, dispatcher: Dispatcher):
        dispatcher.update.middleware(SessionMiddleware(session=self.postgres.session()))
        dispatcher.update.middleware(UserDetectMiddleware())

    async def shutdown_server(self, app):
        await self.postgres.completion()
        logger.debug("Application stopped")


if __name__ == "__main__":
    logger.debug("Launching the application")

    # configuration
    cfg = Configuration()
    config = cfg.all_configuration()

    #  Alembic upgrade
    alembic_config = Config(file_="alembic.ini", attributes={"configure_logger": False})
    alembic.command.upgrade(alembic_config, "head")
    logger.debug("Alembic updates the database")

    #  TelegramBot
    logger.debug("Telegram bot initialization")
    telegrambot = Initializing(configuration=config)

    web.run_app(telegrambot.app, host=config.web.host, port=config.web.port)