from ptbcontrib.roles import setup_roles, RolesHandler
from telegram import Update, Bot, InlineKeyboardButton, InlineKeyboardMarkup
# check out the telegram docs:
# https://docs.python-telegram-bot.org/en/stable/telegram.bot.html
from telegram.constants import (
    ChatMemberStatus,
    ParseMode,
    ChatType,
)
from telegram.ext import (
    Application,
    ChatJoinRequestHandler,
    ChatMemberHandler,
    CommandHandler,
    ContextTypes,
    Defaults,
    filters,
    MessageHandler,
    PersistenceInput,
    PicklePersistence
)
from telegram.ext.filters import UpdateFilter


#Setup variables#########################

ottbot_persistence = PicklePersistence(
    filepath="ottbot",
    store_data=(
        PersistenceInput(
            bot_data=True,
            chat_data=False,
            user_data=False,
            callback_data=False,
        )
    ),
    update_interval=60
)


# Setup ########################################################################


def main() -> None:
    check_config()
    app = Application \
        .builder() \
        .token(_configVariables.get("BOT_TOKEN")) \
        .defaults(defaults) \
        .persistence(persistence=ottbot_persistence) \
        .post_init(initialize) \
        .post_stop(finalize) \
        .build()

    job_queue = app.job_queue
    app.run_polling(allowed_updates=Update.ALL_TYPES)  # Update.ALL_TYPES required to get ChatMemberHandler events


# Commands #######################################################################
async def cmd_join(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """/join:"""
    print("Join")
    user = update.effective_user
    member_type = await context.bot.get_chat_member(_configVariables.get("MAIN_GROUP_ID"), user.id)
    if member_type.status == ChatMemberStatus.MEMBER or member_type.status == ChatMemberStatus.ADMINISTRATOR:
        await update.message.reply_text("You're already a member!")
        return
    if member_type.status == ChatMemberStatus.BANNED or user.id in ban_list:
        await update.message.reply_text("You cannot apply to rejoin Cambridge Furs as you have previously been banned.")
    if member_type.status == ChatMemberStatus.LEFT:
        print("Hit LEFT")
        name = set_topic_from_user(user)
        print(name)
        topic = await context.bot.create_forum_topic(chat_id=_configVariables.get("WAITING_ROOM_TOPICS_ID"), name=name)
        print(f" Created {topic.name} as topic ID: {topic.message_thread_id}")
        await context.bot.forwardMessage(
            chat_id=_configVariables.get("WAITING_ROOM_TOPICS_ID"),
            from_chat_id=user.id,
            message_thread_id=topic.message_thread_id,
            message_id=update.message.id
        )
        print(f"Forwareded message from {user.id} to Topic id {topic.message_thread_id}")
        context.bot_data[topic.message_thread_id] = user.id
        print(f"Stored user id {context.bot_data.get(topic.message_thread_id)} for key topic ID {topic.message_thread_id}")
        context.bot_data[user.id] = topic.message_thread_id
        print(f"Stored for topic {context.bot_data.get(user.id)} for key user id {user.id}")
        await ottbot_persistence.flush()
        print("flushed")

# Init and Finalize Methods #########################################################
async def initialize(app: Application) -> None:
    # Exceptions escaping from the initialize function result in a silent crash.
    # It's therefore important to wrap everything in a try block
    try:
        print("Started Initialisation")
        roles = await role_setup(app)
        # General Commands
        app.add_handler(CommandHandler("join", cmd_join, filters.Regex(WEBSITE)))
        app.add_handler(ChatJoinRequestHandler(join_request), group=0)
        app.add_handler(CommandHandler("meet_dates", cmd_meet_dates))
        app.add_handler(ChatMemberHandler(chat_member_updated, ChatMemberHandler.CHAT_MEMBER))
        app.add_handler(CommandHandler("registerasadmin", cmd_register_admin))
        app.add_handler(CommandHandler("join", cmd_join))
        app.add_handler(RolesHandler(MessageHandler(
                                        filter_waiting_room & (~filters.COMMAND),
                                        message_reply_from_admin),
                                    roles=roles.admins))
        app.add_handler(RolesHandler(MessageHandler(
                                        filter_direct_message & (~filters.COMMAND),
                                        message_reply_from_joiner),
                                    roles=~roles["sfw_member"]))
        # Admin Commands
        app.add_handler(RolesHandler(CommandHandler("start", cmd_start), roles=roles.admins))
        app.add_handler(RolesHandler(CommandHandler("say", cmd_say), roles=roles.admins))
        app.add_handler(RolesHandler(CommandHandler("notify", cmd_notify), roles=roles.admins))
        app.add_handler(RolesHandler(CommandHandler("canceljob", cmd_cancel_deletion), roles=roles.admins))
        app.add_handler(RolesHandler(CommandHandler("approve", cmd_approve), roles=roles.admins))
        app.add_handler(RolesHandler(CommandHandler("reject", cmd_topic_approve), roles=roles.admins))
        app.add_handler(RolesHandler(CommandHandler("reject", cmd_topic_ban), roles=roles.admins))
        job_hourly_callback = app.job_queue.run_repeating(
            hourly_callback,
            interval=3600,
            first=arrow.utcnow().ceil("hour").datetime)
        app.job_queue.run_repeating(callback=print_persistence, interval=30)

    except Exception as e:
        await alert(app.bot, f"🆘 0ttbot failed to start {e}")
        raise
    else:
        await alert(app.bot, "🟢 0ttbot started")


async def finalize(app) -> None:
    await alert(app.bot, "🆘 CatBot stopped")