import gradio as gr
from gradio_client import Client, handle_file
import random
import os
import time
from PIL import Image

# ==========================================
# PRIVATE SODA-GEN (SINGLE TARGET WAN 2.2)
# Version: V6.3 (70 Stealth Tokens Capacity)
# ==========================================

TARGET_URL = "https://r3gm-wan2-2-fp8da-aoti-preview-2.hf.space"

# 🕵️‍♂️ STEALTH MODE: Menyembunyikan token dari Secret Scanner Hugging Face
# Total 70 Token terenkripsi, dipisah dengan tanda hubung (-) tanpa teks "hf_"
RAW_PAYLOAD = (
    "PiRCDDtPcPFMLWkTkVaZmzoleHOunXnLIA-BHvZXGICstaktSwycmwNmzHGrTNmKxnlRZ-"
    "ZdgawyTPzXIpwhnRYIteUKSMsWnEDtGKtM-nMiFYAFsINxAJWPwiCQlaunmdgmrcxKoaT-"
    "PccpUIbTckCiafwErDLkRlsvqhgtfZaBHL-faGyXBPfBkaHXDMUSJtxEggonhhZbomFIz-"
    "SndsPaRWsevDXCgZcSjTUlBYUJqOkSfFmn-CqobFdUpeVCeuhUaiuXwvdczBUmoUHXRGa-"
    "JKCQYUhhHPPkpucegqkNSyureLdXpmeXRF-tBYfslUwHNiNMufzwAYIlrDVovEWmOQulC-"
    "LKLdrdUxyUyKODSUthmqHXqDMfHrQueera-ivSBboJYQVcifWkCNcOTOnxUQrZOtOglnU-"
    "jiSbBMUmAniRpJOmVIlczuqpRjwSeuizLk-VcXaKQLEawBWZbNrBOSLTjrVtTuSvobhLL-"
    "ZrlTPvhDmYqZGGFuIqDDCrQRcWRhYcuyOI-FCambosUqUQJrThbIveHglnvjoNpOGWBsW-"
    "kUyoiWTbZlNfSrdTNaVINuwlNTQseFCfZB-WGarKlgPBzpJeKxpqirFgnKKAtOFBFomSe-"
    "IZwzmRBCALYfvYtmtvTWsIQYvHuRGUiGyr-NtijfwwAPQRknELkhIWjMQQUUqzgwhIjeu-"
    "obVKYRMqECBoLsBWOKyfVWtHlugAhhuaIH-EsDAvVqRZCbigQrpDFNinlVeijagnAjETW-"
    "yuMifxRJoXWKPRGgYFrXHXTGdoKBuCZCUU-YthKrdEtrmyDbBteZcGzNeoDqGAxzeEinv-"
    "JgNjfcunLsOBcZIaOYcFqgcZIZWjbnocJn-cINBgwvihyKiTpxwDTXjnHTnlQivLCluGJ-"
    "jnciPeeWUwQbHNITBRtOgPjnqWkgAqZDhq-uwTpdbUKmiKUZkpWgsOJyaywRBSPeSHcLY-"
    "ddTsgQvyVXUSRsYrcAioNbGnTsOVugcSpK-BoDGLtNQdSSiIvuveGBiCFJKzEEqQmZTbz-"
    "aKBQewTCodMpeijniAvkcsqoSEhMrbhiKE-hOrZAwkLlabOCjjZVStFoufImunhcjlEhz-"
    "NkfolaYSzHbBLkqkalzvbLJWHxDQfUEwsr-OoFVTidQQHCpKkDBnTsTvPeOogJkVfEWAZ-"
    "plFpieuUJmDJBhyPIdjBmDKKTVNcNpulXJ-AyHpfXRVxcrmiOFUYMLiNAaVtyLwwkdvWJ-"
    "pHNLBEtYhQwfUQJFAxtLcklIaIXyQQkIAt-CpXxqjXPCvnLEyfdlsbgdqXdotkMkzvmBU-"
    "PerSDYxXPlPviQNmACCXyzyIfNBnJgpXst-PKxgUunqjxFjeMUrhgPuHAfUYhrGsFPlBh-"
    "QaVcpabAfUrqncLNBwgXCkpksoGWWxgQxK-PdxIUKbxDsVyMeDtHozMnbQrQXwFxZjKdy-"
    "aMejPqEuMzjwYCKuUVQWOrcvfoWKtKbbgv-CVBXSUlqCHUOPgjbLtmkxXQieFECclgZkT-"
    "pMRYEHGgfGjuxgmKVFobnNhPpxmEoWgsZb-HGSvrRpieiWTbSqRVtdKVgeMHhxVQmakAE-"
    "yrUmRlsTkRjREynarJfHTAOGjcbCQAJDQd-PtPUYmOAhSihYOJpQClGZUsWXBBVzQLOrU-"
    "PLNxMJmXrCgzMNZtIJahbKQfmGFeNceLTE-zLAfTPijfcCqWHOLBuTjEeNXIcWVxsPbbq-"
    "yjgUeEDychEqlzSMSsRZnUFVvOtpAdWtAx-fKcKRTqWTLhgIqiCquYvYyqksBBwvXTlSm-"
    "uUdhNJtMIsIWxZZQmjOAoRwkbuhVbDRkUn-MunRYwrfqwMdLZEbZOGHpPPYnDmuDimopu-"
    "UWAwKSXCNzWvGmsdOhnmqeUIyTJfiNXIZt-iheoERRZTkhdAdnDHJatYgOiLapIgVTFJw-"
    "LLnfrrHopubyFJllMntnFliVrXFFXaAwoj-PGjVbqVHxzglCMkvteIIbdVtPJlCPxefLA-"
    "hkrmPSIlSUTnqsmQLsGECXCwxSmQLnJmEJ-gqxPdLdhmngjpzBznOrzIQqtOrsUGNYbBJ-"
    # --- BARU (BATCH 4 - 10 TOKENS) ---
    "QwsXWJiLNOCRMYuZGNsYxYTLpXygHmQjvW-yQBGhxEAztptTIQXgOYOoVqcAEfiCLdsFd-"
    "pFGVSiujNvgifJoBOHLLPogiOgOZyiQlqu-HwAhtTKtaGUOEjDcjfXVNOMFHKHyZlsQpI-"
    "wbnWdXOgZrkfktwYDlbiqCuhQRZLCsBvak-LDuJYfWVljMjsFFcbKahhsglPTjsvTJfqy-"
    "DAmhXglyPbLZAlbiekBRHnjWZrzdtJSbAL-SByeDprwukcociMPOhJKEtAodUOWSiETeq-"
    "oqfZPYkBcrgJiuWOPLINQImroLKjQDmbRZ-aJLwnooVCfTUssMXtAWIYfgsKhZPthlkYK"
)

# Merakit prefix "hf_" menggunakan kode ASCII saat program berjalan
GHOST_PREFIX = chr(104) + chr(102) + chr(95)
GENERATION_TOKENS = [GHOST_PREFIX + t for t in RAW_PAYLOAD.split('-')]

CLIENT_CACHE = {}

# DATABASE ROTASI PINTAR
TOKEN_STATE = {}

def get_cached_client(token):
    if token not in CLIENT_CACHE:
        CLIENT_CACHE[token] = Client(TARGET_URL, headers={"Authorization": f"Bearer {token}"})
    return CLIENT_CACHE[token]

def calculate_cost(duration, steps, frame_mult):
    return float(duration) * float(steps) * int(frame_mult)

def get_smart_active_tokens(current_cost):
    now = time.time()
    active = []
    
    for token in GENERATION_TOKENS:
        state = TOKEN_STATE.get(token, {"max_cost": float('inf'), "cooldown_until": 0.0})
        
        if now > state["cooldown_until"]:
            state["max_cost"] = float('inf') 
            TOKEN_STATE[token] = state
            
        if current_cost < state["max_cost"]:
            active.append(token)
            
    return active

def resize_image_for_video(image_path, width=768, height=512):
    try:
        if not image_path or not os.path.exists(image_path): return None
        img = Image.open(image_path)
        img = img.resize((int(width), int(height)), Image.LANCZOS)
        img.save(image_path) 
        return image_path
    except Exception as e:
        return image_path 

def generate_wan_video(prompt, input_image, end_image, duration, steps, frame_mult):
    print(f"\n🎬 [WAN 2.2 TARGET] PROMPT: {prompt[:50]}...")
    if not prompt: return None, "❌ Prompt is required."

    safe_img1 = handle_file(resize_image_for_video(input_image)) if input_image else None
    safe_img2 = handle_file(resize_image_for_video(end_image)) if end_image else None

    wan_neg = "色调艳丽, 过曝, 静态, 细节模糊不清, 字幕, 风格, 作品, 画作, 画面, 静止, 整体发灰, 最差质量, 低质量, JPEG压缩残留, 丑陋的, 残缺的, 多余手指, 画不好手部, 畸形, 毁容"

    current_cost = calculate_cost(duration, steps, frame_mult)
    print(f"📊 Calculated Job Cost: {current_cost}")
    
    session_tokens = get_smart_active_tokens(current_cost)
    random.shuffle(session_tokens)
    
    print(f"✅ Found {len(session_tokens)} capable tokens out of {len(GENERATION_TOKENS)} total.")

    if not session_tokens:
        return None, "❌ ALL tokens are currently resting/out of quota for this heavy specification. Try lowering duration/steps or wait a bit."

    final_video = None
    last_error = ""

    for i, token in enumerate(session_tokens):
        try:
            print(f"🚀 Attempt {i+1}/{len(session_tokens)} connecting...")
            client = get_cached_client(token)
            
            result = client.predict(
                input_image=safe_img1,
                last_image=safe_img2,
                prompt=prompt,
                steps=float(steps),
                negative_prompt=wan_neg,
                duration_seconds=float(duration),
                guidance_scale=1.0,
                guidance_scale_2=1.0,
                seed=float(random.randint(0, 999999)),
                randomize_seed=True,
                quality=6.0,
                scheduler="UniPCMultistep",
                flow_shift=3.0,
                frame_multiplier=int(frame_mult),
                safe_mode=False,
                video_component=True,
                api_name="/generate_video"
            )
            
            if isinstance(result, (list, tuple)):
                final_video = result[0]
            else:
                final_video = result
                
            break 

        except Exception as e:
            err_msg = str(e).lower()
            
            if "exceeded" in err_msg or "quota" in err_msg:
                safe_print_token = token[:8] + "..."
                print(f"⚠️ Token {safe_print_token} OUT OF QUOTA for cost {current_cost}. Sleeping for 40 mins for this tier & above.")
                
                TOKEN_STATE[token] = {
                    "max_cost": current_cost,
                    "cooldown_until": time.time() + (40 * 60)
                }
            else:
                safe_print_token = token[:8] + "..."
                print(f"⚠️ Server Glitch with token {safe_print_token}: {err_msg[:50]}... skipping.")
                
            last_error = str(e)
            if token in CLIENT_CACHE:
                del CLIENT_CACHE[token]
            continue 

    if final_video: 
        print("✅ SUCCESS: WAN Video generated!")
        return final_video, "✅ Success! Video ready."
    
    return None, f"❌ Request failed across capable tokens. Last error: {last_error[:50]}"

# --- GRADIO INTERFACE ---
with gr.Blocks(theme=gr.themes.Monochrome()) as app:
    gr.Markdown("# 🎬 Private WAN 2.2 Node V6.3")
    gr.Markdown("*Smart Quota Load Balancing + Stealth Protocol (70 Tokens Active)*")
    
    with gr.Row():
        with gr.Column(scale=1):
            p_in = gr.Textbox(label="Prompt", lines=3)
            with gr.Row():
                img_in = gr.Image(type="filepath", label="Start Image")
                img_end_in = gr.Image(type="filepath", label="End Image")
            with gr.Row():
                d_in = gr.Slider(minimum=1.0, maximum=15.0, step=0.5, value=3.5, label="Duration (s)")
                s_in = gr.Slider(minimum=1.0, maximum=30.0, step=1.0, value=6.0, label="Steps")
                f_mult = gr.Dropdown(choices=['16', '32', '64', '128'], value='16', label="Frame Multiplier")
            btn_gen = gr.Button("🚀 GENERATE RAW", variant="primary")
        with gr.Column(scale=1):
            vid_out = gr.Video(label="Output Video")
            txt_out = gr.Textbox(label="System Log", interactive=False)
            
    btn_gen.click(
        fn=generate_wan_video, 
        inputs=[p_in, img_in, img_end_in, d_in, s_in, f_mult], 
        outputs=[vid_out, txt_out], 
        api_name="generate_private"
    )

# Ubah dari yang lama menjadi ini:
if __name__ == "__main__":
    app.queue(max_size=10).launch(share=False, server_name="0.0.0.0", ssr_mode=False)