import contextlib
from asyncio import sleep
from random import uniform

from pyrogram.enums import ChatMemberStatus
from pyrogram import filters
from pyrogram.errors import ChatAdminRequired, FloodWait, UserAdminInvalid, PeerIdInvalid, BadRequest

from datetime import datetime, timedelta

from pagermaid.listener import listener
from pagermaid.enums import Message, Client
from pagermaid.services import bot


async def check_self_and_from(message: Message):
    cid = message.chat.id
    data = await bot.get_chat_member(cid, (await bot.get_me()).id)
    if data.status not in [ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]:
        return False
    if not message.from_user:
        return False
    if message.outgoing:
        return True
    data = await bot.get_chat_member(cid, message.from_user.id)
    return data.status in [ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]


async def kick_chat_member(cid, uid, only_search: bool = False):
    if only_search:
        return
    try:
        with contextlib.suppress(UserAdminInvalid, PeerIdInvalid, BadRequest):
            await bot.ban_chat_member(
                cid,
                uid,
                datetime.now() + timedelta(minutes=5))
    except FloodWait as e:
        await sleep(e.value + uniform(0.5, 1.0))
        await kick_chat_member(cid, uid, only_search)


async def process_clean_member(message: Message, mode: str, day: int, only_search: bool = False):
    member_count = 0
    try:
        async for member in bot.get_chat_members(message.chat.id):
            if mode == "1" and member.user.last_online_date and \
                    member.user.last_online_date < datetime.now() - timedelta(days=day):
                member_count += 1
                await kick_chat_member(message.chat.id, member.user.id, only_search)
            if mode == "2":
                now = datetime.now() - timedelta(days=day)
                async for message in bot.search_messages(message.chat.id, limit=1, from_user=member.user.id):
                    if message.date < now:
                        member_count += 1
                        await kick_chat_member(message.chat.id, member.user.id, only_search)
            elif mode == "3":
                try:
                    count = await bot.search_messages_count(message.chat.id, from_user=member.user.id)
                except PeerIdInvalid:
                    continue
                if count < day:
                    member_count += 1
                    await kick_chat_member(message.chat.id, member.user.id, only_search)
            if mode == "4" and member.user.is_deleted:
                member_count += 1
                await kick_chat_member(message.chat.id, member.user.id, only_search)
            if mode == "5":
                member_count += 1
                await kick_chat_member(message.chat.id, member.user.id, only_search)
        if not only_search:
            await message.edit(f'成功清理了 `{member_count}` 人。')
        else:
            await message.edit(f'查找到了 `{member_count}` 人。')
    except ChatAdminRequired:
        await message.edit("你好像并不拥有封禁用户权限。")
    except FloodWait:
        return await message.edit('处理失败，您已受到 TG 服务器限制。')


@listener(command="clean_member",
          need_admin=True,
          groups_only=True,
          description="多种方式清理群成员")
async def clean_member(client: Client, message: Message):
    if not await check_self_and_from(message):
        return await message.edit("您不是群管理员，无法使用此命令")
    uid = message.from_user.id
    mode, day = "0", 0
    reply = await message.edit("请选择清理模式：\n\n"
                               "1. 按未上线时间清理\n"
                               "2. 按未发言时间清理（大群慎用）\n"
                               "3. 按发言数清理\n"
                               "4. 清理死号\n"
                               "5. 清理所有人（大群慎用）")
    try:
        async with client.conversation(message.chat.id, filters=filters.user(uid)) as conv:
            await sleep(1)
            res: Message = await conv.get_response()
            mode = res.text
            await res.safe_delete()
            if mode in ["1", "2"]:
                await res.safe_delete()
                await reply.edit("请输入清理天数：")
                await sleep(1)
                res = await conv.get_response()
                day = max(int(res.text), 7)
                await res.safe_delete()
            elif mode == "3":
                await res.safe_delete()
                await reply.edit("清理发言少于多少条的群成员：")
                await sleep(1)
                res = await conv.get_response()
                day = int(res.text)
                await res.safe_delete()
            elif mode == "4":
                pass
            elif mode != "5":
                raise ValueError("清理模式错误")
            await reply.edit("查找还是清理？")
            await sleep(1)
            res = await conv.get_response()
            only_search = res.text == "查找"
            await res.safe_delete()
    except ValueError as e:
        return await reply.edit(f"{e}")
    await reply.edit("遍历成员中。。。")
    await process_clean_member(reply, mode, day, only_search)