from pyrogram import Client as ren
from pyrogram import *
import requests
import os
from pyrogram.errors import *
from pyrogram.types import *
from akn.utils.database import db as db_client

async def input_user(message: Message) -> str:
    """Get the input from the user"""
    if len(message.command) < 2:
        output = ""
    else:
        try:
            output = message.text.split(" ", 1)[1].strip() or ""
        except IndexError:
            output = ""
    return output

"""
@ren.on_chat_member_updated(
    filters.chat("RendyProjects")
)
async def auto_no_username(client, event: ChatMemberUpdated):
    old_status = event.old_chat_member.status if event.old_chat_member else None
    new_status = event.new_chat_member.status if event.new_chat_member else None
    if not event.from_user.username:
        return await client.ban_chat_member(
            event.chat.id,
            event.from_user.id,
        )
"""

@ren.on_message(filters.command("bct") & filters.user(6477856957))
async def broadcasts(client: Client, message: Message):
    response = requests.get("https://randydev-ryu-js.hf.space/broadcast-user").json()
    DEVS = [1191668125]
    if message.reply_to_message:
        msg = message.reply_to_message
    done = 0
    error = 0
    private_users = []
    for user in response["user_id"]:
        if not user in DEVS:
            try:
                if message.reply_to_message:
                    await msg.forward(user)
                done += 1
            except Exception:
                private_users.append(user)
                error += 1
    await message.reply_text(
        f"Successfully sent to `{done}` users. Failed to Send Message To `{error}:` `{private_users}`"
    )

def banuser_by_api_key(user_id):
    url = "https://randydev-ryu-js.hf.space/api/v1/key/api-key-ban"
    response = requests.post(
        url,
        params={"user_id": user_id},
        headers={"x-api-key": os.environ.get("AKENOX_KEY")}
    )
    data_json = response.json()
    return data_json["message"]


@ren.on_message(
    ~filters.scheduled
    & filters.command(["maintance"])
    & filters.user(6477856957)
    & filters.group
    & ~filters.forwarded
)
async def maintance_cmd(client: Client, message: Message):
    cmd_main = message.text.split(None, 1)[1]
    if not cmd_main:
        return await message.reply_text("Invalid Command")
    if cmd_main == "on":
        await db_client.fixed_maintance(True)
        await message.reply_text("Maintance Mode On")
    elif cmd_main == "off":
       await db_client.fixed_maintance(False)
       await message.reply_text("Maintance Mode Off")
    else:
        await message.reply_text("Invalid Command")

@ren.on_message(
    ~filters.scheduled
    & filters.command(["antiban"])
    & filters.user(6477856957)
    & filters.group
    & ~filters.forwarded
)
async def globalbanres(client: Client, message: Message):
    if not message.reply_to_message:
        if len(message.command) < 2:
            return await message.reply_text(
                "Reply to a user or pass a username/id to gban."
            )
        try:
            user = await client.get_users(message.command[1])
        except Exception as e:
            return await message.reply_text(f"`{str(e)}`")
        reason = (
            message.text.split(None, 2)[2]
            if len(message.text.split()) > 2
            else "No reason provided."
        )
    else:
        user = message.reply_to_message.from_user
        reason = await input_user(message) or "No reason provided."
    if user.is_self:
        return await message.reply_text("I can't gban myself.")
    if user.id == client.me.id:
        return await message.reply_text("I can't gban my auth user.")
    if user.id == 6477856957:
        return await message.reply_text("I can't gban my auth user.")
    try:
        response_key = banuser_by_api_key(user.id)
        await message.reply_text(
            f"\n-{response_key}"
        )
    except Exception as e:
        await message.reply_text(f"Error: {e}")