from datetime import datetime
from app import app
from pyrogram.types import (
    InlineKeyboardMarkup,
    InlineKeyboardButton,
    ReplyKeyboardRemove,
    CallbackQuery,
)
from pyrogram.client import Client
from pyrogram import filters
from classes.holo_user import HoloUser
from modules.utils import configGet, locale, logWrite
from modules.handlers.confirmation import confirm_yes
from modules.handlers.welcome import welcome_pass
from modules.database import col_tmp, col_applications


@app.on_callback_query(filters.regex("reapply_yes_[\s\S]*"))
async def callback_reapply_query_accept(app: Client, clb: CallbackQuery):
    fullclb = clb.data.split("_")
    holo_user = HoloUser(int(fullclb[2]))

    await app.send_message(
        configGet("admin", "groups"),
        locale("approved_by", "message").format(clb.from_user.first_name, holo_user.id),
        disable_notification=True,
    )
    logWrite(
        f"User {holo_user.id} got their reapplication approved by {clb.from_user.id}"
    )

    await app.send_message(
        holo_user.id, locale("approved_joined", "message", locale=holo_user)
    )

    applications = col_applications.find({"user": holo_user.id})

    if len(list(applications)) > 1:
        col_applications.delete_many({"user": holo_user.id})
        col_applications.insert_one(
            {
                "user": holo_user.id,
                "date": datetime.now(),
                "admin": clb.from_user.id,
                "application": col_tmp.find_one(
                    {"user": {"$eq": holo_user.id}, "type": {"$eq": "application"}}
                )["application"],
            }
        )
    elif applications == 1:
        col_applications.find_one_and_replace(
            {"user": holo_user.id},
            {
                "user": holo_user.id,
                "date": datetime.now(),
                "admin": clb.from_user.id,
                "application": col_tmp.find_one(
                    {"user": {"$eq": holo_user.id}, "type": {"$eq": "application"}}
                )["application"],
            },
        )
    else:
        col_applications.insert_one(
            {
                "user": holo_user.id,
                "date": datetime.now(),
                "admin": clb.from_user.id,
                "application": col_tmp.find_one(
                    {"user": {"$eq": holo_user.id}, "type": {"$eq": "application"}}
                )["application"],
            }
        )
    col_tmp.update_one(
        {"user": holo_user.id, "type": "application"},
        {"$set": {"state": "approved", "sent": False}},
    )

    edited_markup = [
        [
            InlineKeyboardButton(
                text=str(locale("accepted", "button")), callback_data="nothing"
            )
        ]
    ]

    await clb.message.edit(
        text=clb.message.text, reply_markup=InlineKeyboardMarkup(edited_markup)
    )
    await clb.answer(
        text=locale("sub_accepted", "callback", locale=clb.from_user).format(
            holo_user.id
        ),
        show_alert=True,
    )

    need_link = True

    async for member in app.get_chat_members(configGet("users", "groups")):
        if member.user.id == holo_user.id:
            need_link = False

    if need_link:
        link = await app.create_chat_invite_link(
            configGet("users", "groups"),
            name=f"Invite for {holo_user.id}",
            member_limit=1,
        )  # , expire_date=datetime.now()+timedelta(days=1))

        await app.send_message(
            holo_user.id, locale("read_rules", "message", locale=holo_user)
        )

        for rule_msg in locale("rules", locale=holo_user):
            await app.send_message(holo_user.id, rule_msg)

        await app.send_message(
            holo_user.id,
            locale("approved", "message"),
            reply_markup=InlineKeyboardMarkup(
                [
                    [
                        InlineKeyboardButton(
                            str(locale("join", "button", locale=holo_user)),
                            url=link.invite_link,
                        )
                    ]
                ]
            ),
        )

        holo_user.set("link", link.invite_link)
        logWrite(f"User {holo_user.id} got an invite link {link.invite_link}")

    else:
        await app.send_message(
            holo_user.id, locale("approved_joined", "message", locale=holo_user)
        )


@app.on_callback_query(filters.regex("reapply_no_[\s\S]*"))
async def callback_query_reapply_reject(app: Client, clb: CallbackQuery):
    fullclb = clb.data.split("_")
    holo_user = HoloUser(int(fullclb[2]))

    await app.send_message(
        configGet("admin", "groups"),
        locale("rejected_by", "message").format(clb.from_user.first_name, fullclb[2]),
        disable_notification=True,
    )
    await app.send_message(
        holo_user.id, locale("rejected", "message", locale=holo_user)
    )
    logWrite(
        f"User {fullclb[2]} got their reapplication rejected by {clb.from_user.id}"
    )

    col_tmp.update_one(
        {"user": {"$eq": holo_user.id}, "type": {"$eq": "application"}},
        {"$set": {"state": "rejected", "sent": False}},
    )

    edited_markup = [
        [
            InlineKeyboardButton(
                text=str(locale("declined", "button")), callback_data="nothing"
            )
        ],
        [
            InlineKeyboardButton(
                text=str(locale("ban", "button")), callback_data=f"ban_{fullclb[2]}"
            )
        ],
    ]

    await clb.message.edit(
        text=clb.message.text, reply_markup=InlineKeyboardMarkup(edited_markup)
    )
    await clb.answer(
        text=locale("sub_rejected", "callback", locale=clb.from_user).format(
            fullclb[2]
        ),
        show_alert=True,
    )


# Use old application when user reapplies after leaving the chat
@app.on_callback_query(filters.regex("reapply_old_[\s\S]*"))
async def callback_query_reapply_old(app: Client, clb: CallbackQuery):
    fullclb = clb.data.split("_")
    holo_user = HoloUser(clb.from_user)

    if holo_user.sponsorship_state()[0] == "fill":
        await clb.message.reply_text(
            locale("finish_sponsorship", "message"), quote=False
        )
        return

    message = await app.get_messages(clb.from_user.id, int(fullclb[2]))

    if (
        col_tmp.find_one({"user": holo_user.id, "type": "application"}) is None
        and col_applications.find_one({"user": holo_user.id}) is not None
    ):
        col_tmp.insert_one(
            {
                "user": holo_user.id,
                "type": "application",
                "complete": True,
                "sent": False,
                "state": "fill",
                "reapply": True,
                "stage": 10,
                "application": col_applications.find_one({"user": holo_user.id})[
                    "application"
                ],
            }
        )

    await confirm_yes(app, message, kind="application")
    await clb.message.edit(
        clb.message.text,
        reply_markup=InlineKeyboardMarkup(
            [
                [
                    InlineKeyboardButton(
                        locale("done", "button", locale=clb.from_user), "nothing"
                    )
                ]
            ]
        ),
    )


# Start a new application when user reapplies after leaving the chat
@app.on_callback_query(filters.regex("reapply_new_[\s\S]*"))
async def callback_query_reapply_new(app: Client, clb: CallbackQuery):
    fullclb = clb.data.split("_")

    holo_user = HoloUser(clb.from_user)

    if holo_user.sponsorship_state()[0] == "fill":
        await clb.message.reply_text(
            locale("finish_sponsorship", "message"), quote=False
        )
        return

    await clb.answer(locale("reapply_stopped", "callback", locale=clb.from_user))
    message = await app.get_messages(clb.from_user.id, int(fullclb[2]))
    col_tmp.update_one(
        {"user": clb.from_user.id, "type": "application"},
        {"$set": {"state": "fill", "completed": False, "stage": 1}},
    )
    holo_user.application_restart(reapply=True)
    await welcome_pass(app, message, once_again=True)
    logWrite(
        f"User {clb.from_user.id} restarted the application after leaving the chat earlier"
    )
    await clb.message.edit(
        clb.message.text,
        reply_markup=InlineKeyboardMarkup(
            [
                [
                    InlineKeyboardButton(
                        locale("done", "button", locale=clb.from_user), "nothing"
                    )
                ]
            ]
        ),
    )


# Abort application fill in progress and restart it
@app.on_callback_query(filters.regex("reapply_stop_[\s\S]*"))
async def callback_query_reapply_stop(app: Client, clb: CallbackQuery):
    fullclb = clb.data.split("_")
    holo_user = HoloUser(clb.from_user)

    holo_user.application_restart()
    await clb.answer(locale("reapply_stopped", "callback", locale=holo_user))
    message = await app.get_messages(clb.from_user.id, int(fullclb[2]))
    await welcome_pass(app, message, once_again=True)
    logWrite(f"User {clb.from_user.id} restarted the application due to typo in it")
    await clb.message.edit(
        locale("reapply_restarted", "message", locale=holo_user),
        reply_markup=ReplyKeyboardRemove(),
    )