main.py

# main.py
import os
import time
import uuid
import httpx
import psutil
import ffmpeg
import asyncio
import platform
from datetime import datetime
from typing import List, Optional
from contextlib import asynccontextmanager
from cachetools import TTLCache
from pydantic import BaseModel
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse, Response, StreamingResponse
from fastapi import FastAPI, Query, HTTPException, Body, BackgroundTasks, Header

from app.xs_dl import XoSoApp
from app.cl_lq import ClLqApp
from app.ht_rd import HentaiRandomApp
from app.ht_noti import HentaiApp
from app.ios_app import IOSAppFetcher
from app.tik_dl import TiktokDl
from app.tik_cdn import TiktokCdn
from app.yt_dl import YouTubeDl
from app.yt_cdn import YouTubeCdn
from app.byps_uv import BypassUV
from app.gs_code import GSCodeApp
from app.gm_crate import GmailLogic
from app.gs_daily import GSDailyApp
from app.invite_logic import DiscordInviteLogic
from app.noi_tu import NoiTuApp
from app.panel_svc import PanelManager, PanelActionRequest
from app.panel_login import PanelLogin

xs_app = XoSoApp()
lq_app = ClLqApp()
gm_app = GmailLogic()
gs_app = GSDailyApp()
bypass_app = BypassUV()
tik_app = TiktokDl()
tik_direct = TiktokCdn()
hentai_app = HentaiApp()
yt_app = YouTubeDl()
yt_cdn = YouTubeCdn()
ios_app = IOSAppFetcher()
gs_code_app = GSCodeApp()
invite_app = DiscordInviteLogic()
ht_random_app = HentaiRandomApp()
noitu_app = NoiTuApp()

API_KEY = os.getenv("API_KEY")
START_TIME = time.time()
order_cache = TTLCache(maxsize=100, ttl=86400)

class NoiTuRequest(BaseModel):
    before: str
    answer: str
    list: List[str]

class ProductItem(BaseModel):
    name: str
    price: str

class DailyRequest(BaseModel):
    cookie: str
    discord_id: str
    server: str

class RedeemRequest(BaseModel):
    cookie: str
    server: str
    code: str

class CompleteRequest(BaseModel):
    order_id: str
    tk: str
    mk: str

class GmailRequest(BaseModel):
    to_email: str
    subject: str
    customer_name: str
    status: str
    total_price: str
    products: List[ProductItem]
    order_id: Optional[str] = None
    from_name: Optional[str] = "Celeste Store"

@asynccontextmanager
async def lifespan(app: FastAPI):
    await asyncio.gather(
        invite_app.start(), lq_app.start(), gs_app.start(),
        gs_code_app.start(), hentai_app.start(), ht_random_app.start(),
        bypass_app.start(), ios_app.start(), xs_app.start(), tik_direct.start(), yt_cdn.start(), noitu_app.start()
    )
    yield
    await asyncio.gather(
        invite_app.stop(), lq_app.stop(), gs_app.stop(),
        gs_code_app.stop(), hentai_app.stop(), ht_random_app.stop(),
        bypass_app.stop(), ios_app.stop(), xs_app.stop(), tik_direct.stop(), yt_cdn.stop(), noitu_app.stop()
    )

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

app = FastAPI(
    lifespan=lifespan,
    docs_url="/api-docs",
    redoc_url=None
)

app.mount("/static", StaticFiles(directory="docs"), name="static")

@app.get("/", include_in_schema=False)
async def home():
    index_path = os.path.join(BASE_DIR, "docs", "api", "index.html")
    
    if os.path.exists(index_path):
        return FileResponse(index_path)
    
    return {"error": f"File not found at: {index_path}"}

@app.get("/docs/api", include_in_schema=False)
async def home_alias():
    return await home()

@app.get("/api/v1/system/status")
def system_status():
    memory = psutil.virtual_memory()
    cpu_percent = psutil.cpu_percent(interval=0.5)
    uptime_seconds = int(time.time() - START_TIME)
    uptime_string = str(datetime.utcfromtimestamp(uptime_seconds).strftime("%H:%M:%S"))
    
    return {
        "status": "online",
        "process_id": os.getpid(),
        "hostname": platform.node(),
        "uptime_hms": uptime_string,
        "platform": platform.system(),
        "uptime_seconds": uptime_seconds,
        "ram_usage_percent": memory.percent,
        "cpu_usage_percent": cpu_percent,
        "platform_release": platform.release(),
        "python_version": platform.python_version(),
        "used_ram_mb": round(memory.used / 1024 / 1024, 2),
        "total_ram_mb": round(memory.total / 1024 / 1024, 2)
    }

@app.post("/api/v1/noitu/check")
async def api_noitu_check(
    data: NoiTuRequest, 
    apikey: Optional[str] = Query(None), 
    x_api_key: Optional[str] = Header(None, alias="X-API-Key")
):
    # Kiểm tra API KEY
    key = x_api_key or apikey
    if not API_KEY or key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    
    # Trả về kết quả check từ trọng tài
    return noitu_app.validate_turn(data.before, data.answer, data.list)

@app.get("/api/v1/invites/discord")
async def get_new_invite():
    res = await invite_app.get_invite()
    if "error" in res:
        raise HTTPException(status_code=500, detail="500: Yo mama called, said stop hacking or she'll whoop ur ass. Listen to her for once.")
    return res

@app.get("/api/v1/get/lqAov")
async def get_free_account():
    res = await lq_app.fetch_acc()
    if not res["ok"]:
        raise HTTPException(status_code=500, detail="500: Yo mama called, said stop hacking or she'll whoop ur ass. Listen to her for once.")
    return res

@app.post("/api/v1/genshin/daily")
async def genshin_daily(data: DailyRequest, x_api_key: str = Header(None)):
    if not API_KEY:
        raise HTTPException(status_code=500, detail="500: Yo mama called, said stop hacking or she'll whoop ur ass. Listen to her for once.")
    if x_api_key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    
    res = await gs_app.run_daily_and_capture(data.cookie, data.discord_id, data.server)
    if not res["ok"]:
        raise HTTPException(status_code=400, detail=res["error"])
    return res

@app.post("/api/v1/genshin/redeem")
async def genshin_redeem(data: RedeemRequest, x_api_key: str = Header(None)):
    if x_api_key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    
    res = await gs_code_app.redeem_code(data.cookie, data.server, data.code)
    if not res["ok"]:
        raise HTTPException(status_code=400, detail=res)
    return res

@app.get("/api/v1/hentai/newest")
async def hentai_newest(apikey: Optional[str] = Query(None), x_api_key: Optional[str] = Header(None, alias="X-API-Key")):
    key_to_check = x_api_key or apikey
    return await hentai_app.get_new(key_to_check, API_KEY)

@app.get("/api/v1/hentai/info")
async def hentai_info(slug: str = Query(...), apikey: Optional[str] = Query(None), x_api_key: Optional[str] = Header(None, alias="X-API-Key")):
    key = x_api_key or apikey
    if not API_KEY or key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    return await hentai_app.fetch_info(slug)

@app.get("/api/v1/hentai/random")
async def hentai_random(apikey: Optional[str] = Query(None), limit: str = Query("1"), x_api_key: Optional[str] = Header(None, alias="X-API-Key")):
    key = x_api_key or apikey
    return await ht_random_app.get_random(key, API_KEY, limit)

@app.get("/api/v1/tiktok/dl")
async def tiktok_dl(
    url: str = Query(...), 
    hd: int = Query(1), 
    apikey: Optional[str] = Query(None), 
    x_api_key: Optional[str] = Header(None, alias="X-API-Key")
):
    key = x_api_key or apikey
    if not API_KEY or key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid")
    
    res = await tik_app.fetch_video(url, tik_direct, hd)
    if not res["ok"]:
        raise HTTPException(status_code=400, detail=res["error"])
    return res

@app.get("/api/v1/tiktok/cdn")
async def tiktok_cdn(
    token: str = Query(None, description="Token generated from /dl endpoint"),
    url: str = Query(None, description="Direct URL to proxy (Requires API Key)"),
    type: str = Query("mp4", description="File extension type"),
    apikey: Optional[str] = Query(None),
    x_api_key: Optional[str] = Header(None, alias="X-API-Key")
):
    if url:
        key = x_api_key or apikey
        if not API_KEY or key != API_KEY:
            raise HTTPException(status_code=403, detail="Proxying via URL requires a valid API Key")
        data = {"url": url, "type": type}
    
    elif token:
        data = tik_direct.consume_token(token)
        if not data:
            raise HTTPException(status_code=404, detail="Token invalid, expired or limit reached")
    
    else:
        raise HTTPException(status_code=400, detail="Either 'token' or 'url' must be provided")

    target_url = data["url"]
    media_type_req = data["type"]

    if media_type_req in ["mp3_convert", "wav_convert"]:
        is_wav = media_type_req == "wav_convert"
        ext = "wav" if is_wav else "mp3"
        acodec = "pcm_s16le" if is_wav else "libmp3lame"
        fmt = "wav" if is_wav else "mp3"
        media_header = "audio/wav" if is_wav else "audio/mpeg"
        
        try:
            process = (
                ffmpeg
                .input(target_url)
                .output('pipe:', format=fmt, acodec=acodec, ar='44100')
                .run_async(pipe_stdout=True, pipe_stderr=True)
            )

            async def stream_ffmpeg():
                try:
                    while True:
                        chunk = await asyncio.to_thread(process.stdout.read, 8192)
                        if not chunk: break
                        yield chunk
                finally:
                    try: process.kill()
                    except: pass

            return StreamingResponse(
                stream_ffmpeg(),
                media_type=media_header,
                headers={"Content-Disposition": f"attachment; filename=Celeskry_{int(time.time())}.{ext}"}
            )
        except Exception as e:
            raise HTTPException(status_code=500, detail=f"Conversion Error: {str(e)}")

    async def stream_file():
        async with httpx.AsyncClient(follow_redirects=True, timeout=60.0) as client:
            async with client.stream("GET", target_url) as r:
                if r.status_code != 200:
                    yield b"Error: Resource not found"
                    return
                async for chunk in r.aiter_bytes(chunk_size=1024*1024):
                    yield chunk
                    
    content_types = {
        "mp4": "video/mp4",
        "mp3": "audio/mpeg",
        "jpg": "image/jpeg",
        "png": "image/png"
    }
    final_type = content_types.get(media_type_req, "application/octet-stream")
    
    return StreamingResponse(
        stream_file(),
        media_type=final_type,
        headers={"Content-Disposition": f"attachment; filename=Celeste_{int(time.time())}.{media_type_req}"}
    )

    raise HTTPException(status_code=400, detail="Provide either 'url' or 'token'")

@app.get("/api/v1/youtube/dl")
async def youtube_dl(
    url: str = Query(...), 
    format: str = Query("1080"), 
    apikey: Optional[str] = Query(None), 
    x_api_key: Optional[str] = Header(None, alias="X-API-Key")
):
    key = x_api_key or apikey
    if not API_KEY or key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid")
    
    job_id = await yt_app.create_job(url, format, yt_cdn)
    return {
        "ok": True,
        "message": "Job created.",
        "job_id": job_id,
        "status_url": f"/api/v1/youtube/status?job_id={job_id}"
    }

@app.get("/api/v1/youtube/status")
async def youtube_status(job_id: str = Query(...)):
    job = yt_app.jobs.get(job_id)
    if not job:
        raise HTTPException(status_code=404, detail="Job not found or expired")
    
    return {
        "ok": True,
        "meta": yt_app.meta_info,
        "data": job
    }

@app.get("/api/v1/youtube/cdn")
async def youtube_cdn_proxy(
    token: str = Query(...),
):
    data = yt_cdn.consume_token(token)
    if not data:
        raise HTTPException(status_code=404, detail="Token invalid or expired")

    async def stream_file():
        async with httpx.AsyncClient(follow_redirects=True, timeout=120.0) as client:
            async with client.stream("GET", data["url"]) as r:
                async for chunk in r.aiter_bytes(chunk_size=1024*1024):
                    yield chunk

    media_types = {
        "mp4": "video/mp4",
        "mp3": "audio/mpeg",
        "wav": "audio/wav",
        "jpg": "image/jpeg"
    }
    
    return StreamingResponse(
        stream_file(),
        media_type=media_types.get(data["type"], "application/octet-stream"),
        headers={"Content-Disposition": f"attachment; filename=Celeskry_YT_{int(time.time())}.{data['type']}"}
    )

@app.get("/api/v1/bypass")
async def bypass_link(url: str = Query(...), apikey: Optional[str] = Query(None), x_api_key: Optional[str] = Header(None, alias="X-API-Key")):
    key = x_api_key or apikey
    if not API_KEY or key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    
    res = await bypass_app.bypass(url)
    if not res["ok"]:
        raise HTTPException(status_code=400, detail=res["error"])
    return res

@app.get("/api/v1/ios/app")
async def ios_app_fetch(n: str = Query(...), apikey: Optional[str] = Query(None), x_api_key: Optional[str] = Header(None, alias="X-API-Key")):
    key = x_api_key or apikey
    if not API_KEY or key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    
    res = await ios_app.get_app_accounts(n)
    if not res["ok"]:
        raise HTTPException(status_code=404, detail=res["error"])
    return res

@app.post("/api/v1/gmail/create")
async def create_gmail_notif(data: GmailRequest, x_api_key: str = Header(None)):
    if x_api_key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    
    final_order_id = data.order_id or gm_app.generate_random_order_id()
    order_cache[final_order_id] = {
        "email": data.to_email,
        "name": data.customer_name,
        "product": data.products[0].name if data.products else "Sản phẩm",
        "price": data.total_price
    }
    
    res = await gm_app.send_order_email(
        to_email=data.to_email, subject=data.subject, customer_name=data.customer_name,
        order_id=final_order_id, status=data.status, products=[p.dict() for p in data.products],
        total_price=data.total_price, from_name=data.from_name
    )
    if not res["ok"]:
        raise HTTPException(status_code=500, detail="500: Yo mama called, said stop hacking or she'll whoop ur ass. Listen to her for once.")
    
    res["order_id"] = final_order_id
    return res

@app.post("/api/v1/gmail/done")
async def complete_order(data: CompleteRequest, x_api_key: str = Header(None)):
    if x_api_key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    
    cached_order = order_cache.get(data.order_id)
    if not cached_order:
        raise HTTPException(status_code=404, detail="Order not found or expired")
    
    res = await gm_app.send_complete_email(
        to_email=cached_order["email"], customer_name=cached_order["name"],
        order_id=data.order_id, product_name=cached_order["product"],
        price=cached_order["price"], tk=data.tk, mk=data.mk
    )
    if not res["ok"]:
        raise HTTPException(status_code=500, detail="500: Yo mama called, said stop hacking or she'll whoop ur ass. Listen to her for once.")
    
    del order_cache[data.order_id]
    return {"ok": True, "message": f"Sent the account to {cached_order['email']}"}

@app.get("/api/v1/xoso/xsmn")
async def get_xsmn(type: str = Query("latest"), date: Optional[str] = Query(None), apikey: Optional[str] = Query(None), x_api_key: Optional[str] = Header(None, alias="X-API-Key")):
    key = x_api_key or apikey
    if not API_KEY or key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Go touch grass")
    
    res = await xs_app.fetch_mn(date if type == "date" else None)
    if not res["ok"]:
        raise HTTPException(status_code=400, detail=res["error"])
    return res

panel_app = PanelManager(
    ws_url="wss://stratos.pikamc.vn:8080/api/servers/45feca4d-3f79-4bcc-ae11-114335a1c77e/ws",
    origin="https://cp.pikamc.vn"
)

@app.post("/api/v1/panel/token")
async def update_token(token: str = Body(..., embed=True), x_api_key: str = Header(None)):
    if x_api_key != API_KEY: raise HTTPException(status_code=403)
    panel_app.update_token(token)
    return {"ok": True, "message": "Token updated successfully"}

@app.post("/api/v1/panel/control")
async def control_panel(data: PanelActionRequest, x_api_key: str = Header(None)):
    if x_api_key != API_KEY: raise HTTPException(status_code=403)
    
    res = await panel_app.execute(command=data.command, action=data.action)
    
    if not res["ok"] and ("token" in res["error"].lower() or "auth" in res["error"].lower()):
        print("[!] Token error, automatically refreshing...")
        
        login_svc = PanelLogin(PANEL_USER, PANEL_PASS, "45feca4d-3f79-4bcc-ae11-114335a1c77e")
        refresh_res = await login_svc.fetch_ws_credentials()
        
        if refresh_res["ok"]:
            panel_app.update_token(refresh_res["token"])
            res = await panel_app.execute(command=data.command, action=data.action)
            
    if not res["ok"]:
        raise HTTPException(status_code=500, detail=res["error"])
    return res

PANEL_USER = os.getenv("PANEL_USER")
PANEL_PASS = os.getenv("PANEL_PASS") 

@app.get("/api/v1/panel/refresh")
async def refresh_panel_token(apikey: str = Query(None), x_api_key: str = Header(None, alias="X-API-Key")):
    # Kiểm tra API Key (Sửa lại logic so sánh cho chắc chắn)
    key = x_api_key or apikey
    if not API_KEY or key != API_KEY:
        raise HTTPException(status_code=403, detail="API key invalid. Check your params.")
    
    login_svc = PanelLogin(PANEL_USER, PANEL_PASS, "45feca4d-3f79-4bcc-ae11-114335a1c77e")
    result = await login_svc.fetch_ws_credentials()
    
    if not result["ok"]:
        # Trả về lỗi chi tiết từ Playwright để debug
        return {"ok": False, "error": result["error"], "debug_img": "/api/v1/panel/debug-img"}
    
    panel_app.update_token(result["token"])
    return {"ok": True, "token_preview": result["token"][:20] + "..."}

@app.get("/api/v1/panel/debug-img")
async def get_debug_img():
    if os.path.exists("debug_screenshot.png"):
        return FileResponse("debug_screenshot.png")
    return {"error": "No debug image found"}