import logging
import base64
import requests
import uvloop
import aiofiles
import aiohttp
import os
from bs4 import BeautifulSoup

from pydantic import BaseModel
import base64
from rembg import remove
from io import BytesIO
from PIL import Image

from akenoai import OldAkenoXToJs
from akenoai.runner import run_fast
from akenoai.clients import create_pyrogram
from akenoai.clients.enums import ChatMembersFilter
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse

from pyrogram.enums import *
from pyrogram.errors import *
from pyrogram.types import *
from pyrogram import filters

from config import API_ID, API_HASH, BOT_TOKEN, SESSION

from src.catergory import router as catergory_router

logger = logging.getLogger(__name__)
LOGS = logging.getLogger("[akenox]")
logger.setLevel(logging.DEBUG)

js = OldAkenoXToJs()
fast_app = js.get_app()

os.environ["U2NET_HOME"] = "/usr/src/app/.u2net"
os.environ["XDG_CACHE_HOME"] = "/usr/src/app/.cache"

origins = [
    "https://randydev-meta-ai.hf.space"
]
fast_app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

import uvloop

uvloop.install()

from src.combo import router as combo_router
# from src.recent_torrents import router as recent_torrents_router
# from src.search_torrent_url import router as search_torrent_url_router
# from src.search_torrents import router as search_torrents_router
from src.sites_list_torrens import router as sites_list_torrens_router
# from src.trending_torrents import router as trending_torrents_router

# torrent router
fast_app.include_router(combo_router)
fast_app.include_router(catergory_router)
# fast_app.include_router(recent_torrents_router)
# fast_app.include_router(search_torrent_url_router)
# fast_app.include_router(search_torrents_router)
fast_app.include_router(sites_list_torrens_router)
# fast_app.include_router(sites_list_torrens_router)
# fast_app.include_router(trending_torrents_router)


bot = create_pyrogram(
    name="fastapi-bot",
    api_id=API_ID,
    api_hash=API_HASH,
    bot_token=BOT_TOKEN
)

user_client = create_pyrogram(
    name="fastapi-user",
    api_id=API_ID,
    api_hash=API_HASH,
    session_string=SESSION
)

def get_random_from_channel(link):
    clean_link = link.split("?")[0]
    target_link = clean_link.split("/c/") if "/c/" in clean_link else clean_link.split("/")
    random_id = int(target_link[-1].split("/")[-1]) if len(target_link) > 1 else None
    desired_username = target_link[3] if len(target_link) > 3 else None
    username = (
        "@" + desired_username if desired_username else "-100" + target_link[1].split("/")[0]
        if len(target_link) > 1 else None
    )
    return username, random_id

async def upload_to_catbox(dl_path: str) -> str:
    base_url = "https://catbox.moe/user/api.php"
    proxy_url = f"http://186.26.92.180:58339"
    async with aiohttp.ClientSession() as session:
        form_data = aiohttp.FormData()
        form_data.add_field("reqtype", "fileupload")

        async with aiofiles.open(dl_path, mode="rb") as file:
            file_data = await file.read()
            form_data.add_field(
                "fileToUpload",
                file_data,
                filename=dl_path.split("/")[-1],
                content_type="application/octet-stream"
            )

        async with session.post(base_url, data=form_data, proxy=proxy_url) as response:
            response.raise_for_status()
            return (await response.text()).strip()

class ImageInput(BaseModel):
    image_base64: str

@fast_app.post("/remove-bg-base64")
async def remove_bg_base64(data: ImageInput):
    try:
        image_data = base64.b64decode(data.image_base64)
        input_image = Image.open(BytesIO(image_data))
        output_image = remove(input_image)

        buffer = BytesIO()
        output_image.save(buffer, format="PNG")
        output_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
        return {"output_image_base64": output_base64}
    except Exception as e:
        return {"error": str(e)}

@fast_app.get("/image/share/{filename}")
async def get_image(filename: str):
    file_path = f"image/{filename}"
    
    if not os.path.exists(file_path):
        return {"error": "File not found"}
    
    return FileResponse(file_path)

@fast_app.get("/original/license")
async def license_private():
    file_path = f"AknUserbotLicense_RAW_AKNUSERBOT-20250411-D81B4FBB.pdf"
    
    if not os.path.exists(file_path):
        return {"error": "File not found"}
    
    return FileResponse(file_path)

""""
@fast_app.on_event("startup")
async def startup_event():
    # user = await bot.start()
    # userbot = await user_client.start()
    LOGS.info(f"Started Bot: {user.me.first_name}")
    LOGS.info(f"Started UserBot: {userbot.me.first_name}")


@fast_app.get("/user/status/ban")
async def user_status_ban(username: str = None):
    username_ch = "RendyProjects"
    try:
        mention_user = await bot.get_users(username)
        user = await bot.get_chat_member(username_ch, username)
        if user.status == ChatMemberStatus.BANNED:
            return {
                "message": f"❌ you {mention_user.first_name} have been blocked from the RendyProjects",
                "is_ban": True,
                "user_id": mention_user.id
            }
        return {
            "message": "User is not banned",
            "is_ban": False,
            "user_id": mention_user.id
        }
    except PeerIdInvalid:
        return False
    except UserNotParticipant:
        return False

async def hello():
    return {"success": "hello world!"}

@fast_app.get("/user/get_story")
async def get_user_story(link: str = None):
    username, random_id = get_random_from_channel(link)
    try:
        stories = await user_client.get_stories(username, story_ids=[random_id])
    except Exception as e:
        return {"error": str(e)}
    if stories:
        for story in stories:
            file_id = (
                story.photo.file_id if story and story.photo else None
                or story.video.file_id if story and story.video else None
            )
            caption = story.caption or f"By {user_client.me.mention}"
            if file_id:
                image_path = await user_client.download_media(file_id)
                
                with open(image_path, "rb") as f:
                    base64_image = base64.b64encode(f.read()).decode("utf-8")
                # url_dl = await upload_to_catbox(image_path)
                return {
                    "download": base64_image,
                    "random_file_id": file_id,
                    "caption": caption
                }
    return {
        "download": None,
        "random_file_id": None,
        "caption": None
    }

@fast_app.get("/user/media-dl/file_id")
async def get_download_media_file(file_id: str = None):
    try:
        image_path = await user_client.download_media(file_id)
    except Exception as e:
        return {"error": str(e)}
    with open(image_path, "rb") as f:
        base64_image = base64.b64encode(f.read()).decode("utf-8")
    return {
        "download": base64_image,
    }
"""

ALERT_WARN = """
🚨 Security Alert: API Key Activity Detected!  

👁️ Full Log:

`{text_log}`

🔗 Need help? Contact support: @xpushz  
"""

NOTIF_KEY = """
🚨 **Notification: API Key Expired (Premium Required)!**  

Your current API key has expired. To continue using premium features, please upgrade to **Premium v2** first.  

🔑 **API Key:** <spoiler>{api_key}</spoiler>  

🔗 Need help? Contact support: @xpushz
"""

"""
@fast_app.get("/user/tg/notifications")
async def user_send_notif(user_id: int = None, api_key: str = None):
    try:
        await bot.send_sticker(
            user_id,
            "CAACAgUAAyEGAASPgam4AAI5T2fTWtyF4FNdBlRL-PWcs_l3Y0emAAI-BwACj774VGLOns79NgeCHgQ"
        )
        await bot.send_message(
            user_id,
            text=NOTIF_KEY.format(api_key=api_key)
        )
        return {"status": True}
    except Exception as e:
        return None

@fast_app.get("/user/tg/send_message")
async def user_send_message(user_id: int = None, api_key: str = None, text_log: str = None):
    try:
        await bot.send_message(
            user_id,
            text=ALERT_WARN.format(
                api_key=api_key,
                text_log=text_log
            )
        )
        return {"status": True}
    except Exception as e:
        return None

@fast_app.get("/user/author/admin")
async def get_author_chat_admin(username: str = None):
    same_user = {}
    async for m in user_client.get_chat_members(username, filter=ChatMembersFilter.ADMINISTRATORS):
        if not m.user.is_bot and not m.user.is_deleted:
            same_user[m.user.id] = {
                "first_name": m.user.first_name,
                "username": m.user.username if m.user else None
            }
    return {  
        "admin_list": same_user  
    }

@fast_app.get("/user/raw/getchat")
async def get_chat_raw(username: str = None):
    try:
        user_id = None
        chat_raw = (await bot.get_chat(username)).raw
        ok = await user_client.get_chat(username)
        if ok.pinned_message.from_user:
            user_id = ok.pinned_message.from_user.id if ok.pinned_message.from_user else None
        if not user_id:
            user_id = None
        if user_id:
            response = await js.get_creation_date(
                user_id=user_id
            )
    except Exception as e:
        return {"error": f"Error try again invalid: {str(e)}"}
    return {
        "id": chat_raw.id,
        "about": chat_raw.about,
        "title": ok.title,
        "username": ok.username if ok else None,
        "photo": {
            "id": chat_raw.chat_photo.id,
            "small_file_id": ok.photo.small_file_id,
            "small_photo_unique_id": ok.photo.small_photo_unique_id,
            "big_file_id": ok.photo.big_file_id,
            "big_photo_unique_id": ok.photo.big_photo_unique_id,
            "date": chat_raw.chat_photo.date,
            "dc_id": chat_raw.chat_photo.dc_id,
            "has_animation": ok.photo.has_animation,
            "is_personal": ok.photo.is_personal
        },
        "from_user": {
            "id": ok.pinned_message.from_user.id if ok.pinned_message.from_user else None,
            "first_name": ok.pinned_message.from_user.first_name if ok.pinned_message.from_user else None,
            "last_name": ok.pinned_message.from_user.last_name if ok.pinned_message.from_user else None,
            "status": ok.pinned_message.from_user.status.name if ok.pinned_message.from_user.status else None,
            "last_online_date": ok.pinned_message.from_user.last_online_date if ok.pinned_message.from_user else None,
            "username": ok.pinned_message.from_user.username if ok.pinned_message.from_user else None,
            "is_premium": ok.pinned_message.from_user.is_premium if ok.pinned_message.from_user else None,
            "is_scam": ok.pinned_message.from_user.is_scam if ok.pinned_message.from_user else None,
            "creation_date": response
        },
        "can_view_participants": chat_raw.can_view_participants,
        "can_set_username": chat_raw.can_set_username,
        "can_set_stickers": chat_raw.can_set_stickers,
        "hidden_prehistory": chat_raw.hidden_prehistory,
        "can_set_location": chat_raw.can_set_location,
        "has_scheduled": chat_raw.has_scheduled,
        "can_view_stats": chat_raw.can_view_stats,
        "blocked": chat_raw.blocked,
        "can_delete_channel": chat_raw.can_delete_channel,
        "antispam": chat_raw.antispam,
        "participants_hidden": chat_raw.participants_hidden,
        "translations_disabled": chat_raw.translations_disabled,
        "stories_pinned_available": chat_raw.stories_pinned_available,
        "view_forum_as_messages": chat_raw.view_forum_as_messages,
        "restricted_sponsored": chat_raw.restricted_sponsored,
        "can_view_revenue": chat_raw.can_view_revenue,
        "paid_media_allowed": chat_raw.paid_media_allowed,
        "can_view_stars_revenue": chat_raw.can_view_stars_revenue,
        "paid_reactions_available": chat_raw.paid_reactions_available,
        "stargifts_available": chat_raw.stargifts_available,
        "participants_count": chat_raw.participants_count,
        "online_count": chat_raw.online_count,
        "pinned_msg_id": chat_raw.pinned_msg_id,
        "linked_chat_id": chat_raw.linked_chat_id,
        "pending_suggestions": chat_raw.pending_suggestions,
        "recent_requesters": chat_raw.recent_requesters,
        "available_reactions": {
            "allow_custom": chat_raw.available_reactions.allow_custom
        },
    }

async def send_to_telegram(user_id="@xpushz", text: str = None):
    return await bot.send_message(user_id, text=text)

@fast_app.post("/log_captcha")
async def log_captcha(data: dict):
    user_ip = data.get("user_ip", "Unknown IP")
    timestamp = data.get("challenge_ts", "No Timestamp")
    log_message = f"✅ CAPTCHA Verified\n🖥 IP: `{user_ip}`\n⏳ Time: `{timestamp}`"
    await send_to_telegram(text=log_message)
    return {"status": "logged"}
"""

@fast_app.get("/api/twitter")
async def twitter_downloader(link: str):
    # credits @xpushz don't remove credits here
    import akenoai as jsx
    import re
    if not link:
        return {"error": "required link"}
    urls = re.sub(r"(https?:\/\/)(?:www\.)?x\.com", r"\1twitter.com", link)
    if not urls:
        return {"error": None}
    response = await jsx.fetch_and_extract_urls(
        f"https://snapdownloader.com/tools/twitter-video-downloader/download?url={urls}",
        href_url=r"https://video",
        return_unsafe_href=True
    )
    return {"results": response}

"""
@fast_app.get("/user/get_user")
async def get_user(user_id=None):
    try:
        get_users = await bot.get_users(user_id)
        response = await js.get_creation_date(
            user_id=get_users.id
        )
    except Exception:
        return {"error": "Error try again invalid"}
    return {
        "id": get_users.id,
        "is_self": get_users.is_self,
        "is_contact": get_users.is_contact,
        "is_mutual_contact": get_users.is_mutual_contact,
        "is_deleted": get_users.is_deleted,
        "is_bot": get_users.is_bot,
        "is_verified": get_users.is_verified,
        "is_restricted": get_users.is_restricted,
        "is_scam": get_users.is_scam,
        "is_fake": get_users.is_fake,
        "is_support": get_users.is_support,
        "is_premium": get_users.is_premium,
        "is_contact_require_premium": get_users.is_contact_require_premium,
        "is_close_friend": get_users.is_close_friend,
        "is_stories_hidden": get_users.is_stories_hidden,
        "is_stories_unavailable": get_users.is_stories_unavailable,
        "is_business_bot": get_users.is_business_bot,
        "first_name": get_users.first_name,
        "status": get_users.status.name,
        "last_online_date": get_users.last_online_date,
        "dc_id": get_users.dc_id,
        "username": get_users.username if get_users else None,
        "photo": {
            "small_file_id": get_users.photo.small_file_id,
            "small_photo_unique_id": get_users.photo.small_photo_unique_id,
            "big_file_id": get_users.photo.big_file_id,
            "has_animation": get_users.photo.has_animation,
            "is_personal": get_users.photo.is_personal
        },
        "creation_date": response
    }
"""

js.custom_openapi(
    app=fast_app,
    title="AkenoX Beta AI API",
    version="1.0.0",
    summary="Use It Only For Personal Project",
    description="Free API By akenoai-lib",
    routes=fast_app.routes,
)

run_fast(build=fast_app, port=7860)