import asyncio
import logging
import sys

from telegram.ext import ApplicationBuilder, ContextTypes, TypeHandler, Application

# Enable logging
logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
)
logging.getLogger("telegram.ext.Application").setLevel(logging.DEBUG)
logging.getLogger("telegram.ext.Updater").setLevel(logging.DEBUG)
logging.getLogger("httpx").setLevel(logging.WARNING)
logging.getLogger("httpcore").setLevel(logging.WARNING)


async def queue(application: Application):
    for ___ in range(5):
        await application.update_queue.put("Hello, world!")


async def queue_and_raise(context: ContextTypes.DEFAULT_TYPE):
    await queue(context.application)
    print("raising system exit")
    raise sys.exit(1)


async def raise_system_exit(_, context: ContextTypes.DEFAULT_TYPE):
    # await queue_and_raise(context)
    raise RuntimeError("This is a test error")


async def error_handler(_, context: ContextTypes.DEFAULT_TYPE):
    print("error handler got called")
    await queue_and_raise(context)


async def general_handler(update: object, context: ContextTypes.DEFAULT_TYPE):
    # await asyncio.sleep(1)
    # context.application.stop_running()
    print("general handler got called for update", update)


async def job_callback(context: ContextTypes.DEFAULT_TYPE):
    await queue_and_raise(context)


async def post_init(application):
    async def put(app):
        await asyncio.sleep(2)
        print("enqueueing update")
        await app.update_queue.put(-1)

    # application.create_task(put(application))
    application.job_queue.run_once(job_callback, 5)


application = (
    ApplicationBuilder().token("TOKEN")
    .post_init(post_init)
    .build()
)
application.add_handler(TypeHandler(int, raise_system_exit, block=True))
application.add_handler(TypeHandler(object, general_handler))
application.add_error_handler(error_handler, block=False)


def main():
    application.run_polling()


async def main_async():
    await application.initialize()
    await application.start()
    await application.updater.start_polling()
    await application.post_init(application)
    await queue(application)
    try:
        await asyncio.Event().wait()
    except Exception as ex:
        print(f"exception while running server: {ex!r}")
    except BaseException as ex:
        print(f"base exception while running server: {ex!r}")
        raise ex
    finally:
        print("stopping application")
        await application.stop()
        await application.updater.stop()
        await application.shutdown()


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