# ===== 必须首先导入spaces =====
try:
    import spaces
    SPACES_AVAILABLE = True
    print("✅ Spaces available - ZeroGPU mode")
except ImportError:
    SPACES_AVAILABLE = False
    print("⚠️ Spaces not available - running in regular mode")

# ===== 其他导入 =====
import os
import uuid
from datetime import datetime
import random
import torch
import gradio as gr
from diffusers import StableDiffusionXLPipeline, EulerDiscreteScheduler
from PIL import Image
import traceback
import numpy as np

# ===== 长提示词处理 =====
try:
    from compel import Compel, ReturnedEmbeddingsType
    COMPEL_AVAILABLE = True
    print("✅ Compel available for long prompt processing")
except ImportError:
    COMPEL_AVAILABLE = False
    print("⚠️ Compel not available - using standard prompt processing")

# ===== 优化后的配置 =====
# 风格核心关键词 - 更强的风格特征
STYLE_KEYWORDS = {
    "None": {
        "prefix": "",
        "suffix": ""
    },
    "Realistic": {
        "prefix": "(RAW photo:1.3), (photorealistic:1.4), (hyperrealistic:1.3), 8k uhd, (ultra realistic skin texture:1.2), cinematic lighting, vibrant colors,masterpiece, realistic skin texture, detailed anatomy, professional photography",
        "suffix": "sharp focus, (everything in focus:1.3), (no bokeh:1.2), realistic skin texture, subsurface scattering, detailed anatomy, (perfect anatomy:1.2),detailed face, detailed background, lifelike, professional photography, realistic proportions,  (detailed face:1.1), natural pose,expressive eyes, 8k resolution"
    },
    "Anime": {
        "prefix": " (western animation style:1.4), (American cartoon:1.3),  bold colors, clean digital art, highly detailed character design,dynamic pose",
        "suffix": "cel shading, clean linework, vibrant anime colors,expressive features, detailed anime eyes, smooth anime skin, perfect anime proportions, professional animation, manga illustration,masterpiece, best quality, high resolution, highly detailed"
    },
    "Comic": {
        "prefix": "(comic book art:1.4),  (Japanese comic art:1.3),(graphic novel:1.2), clean ink lines,screentone shading, dynamic pose",
        "suffix": "sharp linework, smooth shading, clean faces, professional manga illustration, no halftone dots, no texture noise, flat color fills,  dynamic panel,Japanese comic style"
    },
    "Watercolor": {
        "prefix": "(soft watercolor style:1.4), (smooth watercolor painting:1.3), gentle color blending, dreamy aesthetic, digital watercolor",
        "suffix": "soft color transitions, smooth gradients, clean skin, no brush strokes visible, no paper texture, ethereal atmosphere, seamless blending, no color splotches on face, uniform wash"
    }
}

# 通用质量增强词
QUALITY_TAGS = "masterpiece, best quality, high resolution, highly detailed, professional"

# 固定模型配置
FIXED_MODEL = "votepurchase/pornmasterPro_noobV3VAE"

SAVE_DIR = "generated_images"
os.makedirs(SAVE_DIR, exist_ok=True)

# ===== 模型相关变量 =====
pipeline = None
compel_processor = None
device = None
model_loaded = False

def initialize_model():
    """优化的模型初始化 - 移除torch.compile以兼容ZeroGPU"""
    global pipeline, compel_processor, device, model_loaded
    
    if model_loaded and pipeline is not None:
        print("✅ Model already loaded, skipping initialization")
        return True
    
    try:
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        print(f"🖥️ Using device: {device}")
        
        print(f"📦 Loading model: {FIXED_MODEL}")
        
        # 基础模型加载
        pipeline = StableDiffusionXLPipeline.from_pretrained(
            FIXED_MODEL,
            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
            variant="fp16" if torch.cuda.is_available() else None,
            use_safetensors=True,
            safety_checker=None,
            requires_safety_checker=False
        )
        
        # 优化调度器
        pipeline.scheduler = EulerDiscreteScheduler.from_config(
            pipeline.scheduler.config,
            timestep_spacing="trailing"
        )
        
        pipeline = pipeline.to(device)
        
        # GPU优化 - 适配ZeroGPU环境
        if torch.cuda.is_available():
            try:
                # VAE优化
                pipeline.enable_vae_slicing()
                pipeline.enable_vae_tiling()
                
                # 尝试启用xformers
                try:
                    pipeline.enable_xformers_memory_efficient_attention()
                    print("✅ xFormers enabled")
                except:
                    print("⚠️ xFormers not available, using default attention")
                
                # 不使用torch.compile，因为它在ZeroGPU环境中不稳定
                print("ℹ️ Skipping torch.compile for ZeroGPU compatibility")
                
            except Exception as opt_error:
                print(f"⚠️ Optimization warning: {opt_error}")
        
        # 初始化Compel用于长提示词
        if COMPEL_AVAILABLE:
            try:
                compel_processor = Compel(
                    tokenizer=[pipeline.tokenizer, pipeline.tokenizer_2],
                    text_encoder=[pipeline.text_encoder, pipeline.text_encoder_2],
                    returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,
                    requires_pooled=[False, True],
                    truncate_long_prompts=False
                )
                print("✅ Compel processor initialized")
            except Exception as compel_error:
                print(f"⚠️ Compel initialization failed: {compel_error}")
                compel_processor = None
        
        model_loaded = True
        print("✅ Model initialization complete")
        return True
        
    except Exception as e:
        print(f"❌ Model loading error: {e}")
        print(traceback.format_exc())
        model_loaded = False
        return False

def enhance_prompt(prompt: str, style: str) -> str:
    """优化的提示词增强 - 清晰的单一流程"""
    if not prompt or prompt.strip() == "":
        return ""
    
    # 获取风格关键词
    style_config = STYLE_KEYWORDS.get(style, STYLE_KEYWORDS["None"])
    
    # 组合顺序：风格前缀 → 用户提示词 → 风格后缀 → 质量标签
    parts = []
    
    if style_config["prefix"]:
        parts.append(style_config["prefix"])
    
    parts.append(prompt.strip())
    
    if style_config["suffix"]:
        parts.append(style_config["suffix"])
    
    parts.append(QUALITY_TAGS)
    
    enhanced = ", ".join(parts)
    
    print(f"\n🎨 Style: {style}")
    print(f"📝 User prompt: {prompt[:100]}...")
    print(f"✨ Enhanced: {enhanced[:200]}...\n")
    
    return enhanced

def build_negative_prompt(style: str, custom_negative: str = "") -> str:
    """根据风格构建负面提示词"""
    base_negative = "(low quality:1.4), (worst quality:1.4), (bad anatomy:1.3), (bad hands:1.2), blurry, watermark, text, error, cropped, jpeg artifacts, ugly, duplicate, deformed"
    
    # 风格特定的负面词
    style_negatives = {
        "Realistic": ", (cartoon:1.3), (anime:1.3), (3d render:1.2), (illustration:1.2), (painting:1.2), (drawing:1.2), (art:1.2), (sketch:1.2), artificial, unrealistic, (depth of field:1.2), (bokeh:1.2)",
        "Anime": ", (realistic:1.3), (photorealistic:1.3), (photo:1.2), (3d:1.2), (hyperrealistic:1.2), (manga style:1.2), (Japanese anime:1.2)",
        "Comic": ", (realistic:1.3), (photorealistic:1.3), (blurry lines:1.2), (soft edges:1.2), (halftone dots:1.5), (screen tone noise:1.4), (grainy texture:1.3), (dots on face:1.4), (spotted skin:1.3)",
        "Watercolor": ", (sharp edges:1.3), (vector art:1.2), (3d:1.2), (hard lines:1.2), (paper texture:1.4), (visible brush strokes:1.3), (canvas texture:1.3), (paint splotches:1.3), (uneven patches:1.2)"
    }
    
    negative = base_negative
    if style in style_negatives:
        negative += style_negatives[style]
    
    # 添加用户自定义负面词
    if custom_negative.strip():
        negative += f", {custom_negative.strip()}"
    
    return negative

def process_with_compel(prompt, negative_prompt):
    """使用Compel处理长提示词"""
    if not compel_processor:
        return None, None
    
    try:
        # Compel会自动处理超过77 tokens的提示词
        conditioning, pooled = compel_processor([prompt, negative_prompt])
        print("✅ Long prompt processed with Compel")
        return conditioning, pooled
    except Exception as e:
        print(f"⚠️ Compel processing failed: {e}")
        return None, None

def apply_spaces_decorator(func):
    """应用spaces装饰器"""
    if SPACES_AVAILABLE:
        return spaces.GPU(duration=50)(func)
    return func

def create_metadata_content(prompt, enhanced_prompt, seed, steps, cfg_scale, width, height, style):
    """创建元数据"""
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return f"""Generated Image Metadata
======================
Timestamp: {timestamp}
Original Prompt: {prompt}
Enhanced Prompt: {enhanced_prompt}
Seed: {seed}
Steps: {steps}
CFG Scale: {cfg_scale}
Dimensions: {width}x{height}
Style: {style}
Model: PornMasterPro NoobV3VAE
"""

@apply_spaces_decorator
def generate_image(prompt: str, style: str, negative_prompt: str = "", 
                  steps: int = 25, cfg_scale: float = 7.0, 
                  seed: int = -1, width: int = 1024, height: int = 1024, 
                  progress=gr.Progress()):
    """图像生成主函数"""
    
    # 验证输入
    if not prompt or prompt.strip() == "":
        return None, "", "❌ Please enter a prompt"
    
    progress(0.05, desc="Initializing...")
    
    # 初始化模型
    if not initialize_model():
        return None, "", "❌ Failed to load model"
    
    progress(0.1, desc="Processing prompt...")
    
    try:
        # 处理seed
        if seed == -1:
            seed = random.randint(0, np.iinfo(np.int32).max)
        
        # 增强提示词
        enhanced_prompt = enhance_prompt(prompt, style)
        
        # 构建负面提示词
        final_negative = build_negative_prompt(style, negative_prompt)
        
        print(f"🔧 Generation params: seed={seed}, steps={steps}, cfg={cfg_scale}, size={width}x{height}")
        
        # 设置生成器
        generator = torch.Generator(device).manual_seed(seed)
        
        progress(0.2, desc="Generating image...")
        
        # 检查提示词长度并决定是否使用Compel
        prompt_length = len(enhanced_prompt.split())
        use_compel = prompt_length > 50 and compel_processor is not None
        
        if use_compel:
            print(f"📏 Long prompt detected ({prompt_length} words), using Compel")
            conditioning, pooled = process_with_compel(enhanced_prompt, final_negative)
            
            if conditioning is not None:
                # 使用embeddings生成
                result = pipeline(
                    prompt_embeds=conditioning[0:1],
                    pooled_prompt_embeds=pooled[0:1],
                    negative_prompt_embeds=conditioning[1:2],
                    negative_pooled_prompt_embeds=pooled[1:2],
                    num_inference_steps=steps,
                    guidance_scale=cfg_scale,
                    width=width,
                    height=height,
                    generator=generator
                ).images[0]
            else:
                # Compel失败，回退到普通模式
                print("⚠️ Falling back to standard generation")
                result = pipeline(
                    prompt=enhanced_prompt,
                    negative_prompt=final_negative,
                    num_inference_steps=steps,
                    guidance_scale=cfg_scale,
                    width=width,
                    height=height,
                    generator=generator
                ).images[0]
        else:
            # 标准生成
            print(f"📝 Standard generation ({prompt_length} words)")
            result = pipeline(
                prompt=enhanced_prompt,
                negative_prompt=final_negative,
                num_inference_steps=steps,
                guidance_scale=cfg_scale,
                width=width,
                height=height,
                generator=generator
            ).images[0]
        
        progress(0.95, desc="Finalizing...")
        
        # 确保结果是PIL Image
        if not isinstance(result, Image.Image):
            if isinstance(result, np.ndarray):
                if result.dtype != np.uint8:
                    result = (result * 255).astype(np.uint8)
                result = Image.fromarray(result)
        
        # 创建元数据
        metadata = create_metadata_content(
            prompt, enhanced_prompt, seed, steps, cfg_scale, 
            width, height, style
        )
        
        generation_info = f"Style: {style} | Seed: {seed} | Size: {width}×{height} | Steps: {steps} | CFG: {cfg_scale}"
        
        progress(1.0, desc="Complete!")
        print("✅ Generation successful\n")
        
        return result, generation_info, metadata
        
    except Exception as e:
        error_msg = str(e)
        print(f"❌ Generation error: {error_msg}")
        print(traceback.format_exc())
        return None, "", f"❌ Generation failed: {error_msg}"

# ===== CSS样式 =====
css = """
.gradio-container {
    max-width: 100% !important;
    margin: 0 !important;
    padding: 0 !important;
    background: linear-gradient(135deg, #e6a4f2 0%, #1197e4 100%) !important;
    min-height: 100vh !important;
    font-family: 'Segoe UI', Arial, sans-serif !important;
}

.main-content {
    background: rgba(255, 255, 255, 0.9) !important;
    border-radius: 20px !important;
    padding: 20px !important;
    margin: 15px !important;
    box-shadow: 0 10px 25px rgba(255, 255, 255, 0.2) !important;
    min-height: calc(100vh - 30px) !important;
    color: #3e3e3e !important;
    backdrop-filter: blur(10px) !important;
}

.title {
    text-align: center !important;
    background: linear-gradient(45deg, #bb6ded, #08676b) !important;
    -webkit-background-clip: text !important;
    -webkit-text-fill-color: transparent !important;
    background-clip: text !important;
    font-size: 2rem !important;
    margin-bottom: 15px !important;
    font-weight: bold !important;
}

.warning-box {
    background: linear-gradient(45deg, #bb6ded, #08676b) !important;
    color: white !important;
    padding: 8px !important;
    border-radius: 8px !important;
    margin-bottom: 15px !important;
    text-align: center !important;
    font-weight: bold !important;
    font-size: 14px !important;
}

.prompt-box textarea, .prompt-box input {
    border-radius: 10px !important;
    border: 2px solid #bb6ded !important;
    padding: 15px !important;
    font-size: 18px !important;
    background: linear-gradient(135deg, rgba(245, 243, 255, 0.9), rgba(237, 233, 254, 0.9)) !important;
    color: #2d2d2d !important;
}

.prompt-box textarea:focus, .prompt-box input:focus {
    border-color: #08676b !important;
    box-shadow: 0 0 15px rgba(77, 8, 161, 0.3) !important;
    background: linear-gradient(135deg, rgba(255, 255, 255, 0.95), rgba(248, 249, 250, 0.95)) !important;
}

.controls-section {
    background: linear-gradient(135deg, rgba(224, 218, 255, 0.8), rgba(196, 181, 253, 0.8)) !important;
    border-radius: 12px !important;
    padding: 15px !important;
    margin-bottom: 8px !important;
    border: 2px solid rgba(187, 109, 237, 0.3) !important;
    backdrop-filter: blur(5px) !important;
}

.controls-section label {
    font-weight: 600 !important;
    color: #2d2d2d !important;
    margin-bottom: 8px !important;
}

.controls-section input[type="radio"] {
    accent-color: #bb6ded !important;
}

.controls-section input[type="number"], 
.controls-section input[type="range"] {
    background: rgba(255, 255, 255, 0.9) !important;
    border: 1px solid #bb6ded !important;
    border-radius: 6px !important;
    padding: 8px !important;
    color: #2d2d2d !important;
}

.generate-btn {
    background: linear-gradient(45deg, #bb6ded, #08676b) !important;
    color: white !important;
    border: none !important;
    padding: 15px 25px !important;
    border-radius: 25px !important;
    font-size: 16px !important;
    font-weight: bold !important;
    width: 100% !important;
    cursor: pointer !important;
    transition: all 0.3s ease !important;
    text-transform: uppercase !important;
    letter-spacing: 1px !important;
}

.generate-btn:hover {
    transform: translateY(-2px) !important;
    box-shadow: 0 8px 25px rgba(187, 109, 237, 0.5) !important;
}

.image-output {
    border-radius: 15px !important;
    overflow: hidden !important;
    max-width: 100% !important;
    max-height: 70vh !important;
    border: 3px solid #08676b !important;
    box-shadow: 0 8px 20px rgba(0,0,0,0.15) !important;
    background: linear-gradient(135deg, rgba(255, 255, 255, 0.9), rgba(248, 249, 250, 0.9)) !important;
}

.image-info {
    background: linear-gradient(135deg, rgba(248, 249, 250, 0.2), rgba(233, 236, 239, 0.9)) !important;
    border-radius: 8px !important;
    padding: 12px !important;
    margin-top: 10px !important;
    font-size: 12px !important;
    color: #495057 !important;
    border: 2px solid rgba(187, 109, 237, 0.2) !important;
    backdrop-filter: blur(5px) !important;
}

.metadata-box {
    background: linear-gradient(135deg, rgba(248, 249, 250, 0.2), rgba(233, 236, 239, 0.9)) !important;
    border-radius: 8px !important;
    padding: 15px !important;
    margin-top: 15px !important;
    font-family: 'Courier New', monospace !important;
    font-size: 12px !important;
    color: #495057 !important;
    border: 2px solid rgba(187, 109, 237, 0.2) !important;
    backdrop-filter: blur(5px) !important;
    white-space: pre-wrap !important;
    overflow-y: auto !important;
    max-height: 300px !important;
}

@media (max-width: 768px) {
    .main-content {
        margin: 10px !important;
        padding: 15px !important;
    }
    .title {
        font-size: 1.5rem !important;
    }
}
"""

# ===== 创建UI =====
def create_interface():
    with gr.Blocks(css=css, title="Adult NSFW AI Image Generator") as interface:
        with gr.Column(elem_classes=["main-content"]):
            gr.HTML('<div class="title">Adult NSFW AI Image Generator</div>')
            gr.HTML('<div class="warning-box">⚠️ 18+ CONTENT WARNING ⚠️</div>')
            
            with gr.Row():
                with gr.Column(scale=2):
                    prompt_input = gr.Textbox(
                        label="Detailed Prompt",
                        placeholder="Enter your detailed prompt here...",
                        lines=15,
                        elem_classes=["prompt-box"]
                    )
                    
                    negative_prompt_input = gr.Textbox(
                        label="Negative Prompt (Optional)",
                        placeholder="Additional things you don't want...",
                        lines=4,
                        elem_classes=["prompt-box"]
                    )
                
                with gr.Column(scale=1):
                    with gr.Group(elem_classes=["controls-section"]):
                        style_input = gr.Radio(
                            label="Style Preset",
                            choices=list(STYLE_KEYWORDS.keys()),
                            value="Realistic"
                        )
                    
                    with gr.Group(elem_classes=["controls-section"]):
                        seed_input = gr.Number(
                            label="Seed (-1 for random)",
                            value=-1,
                            precision=0
                        )
                    
                    with gr.Group(elem_classes=["controls-section"]):
                        width_input = gr.Slider(
                            label="Width",
                            minimum=512,
                            maximum=2048,
                            value=1024,
                            step=64
                        )
                    
                    with gr.Group(elem_classes=["controls-section"]):
                        height_input = gr.Slider(
                            label="Height",
                            minimum=512,
                            maximum=2048,
                            value=1024,
                            step=64
                        )
                    
                    with gr.Group(elem_classes=["controls-section"]):
                        steps_input = gr.Slider(
                            label="Steps",
                            minimum=10,
                            maximum=50,
                            value=25,
                            step=1
                        )
                        
                        cfg_input = gr.Slider(
                            label="CFG Scale",
                            minimum=1.0,
                            maximum=15.0,
                            value=7.0,
                            step=0.1
                        )
                    
                    generate_button = gr.Button(
                        "GENERATE",
                        elem_classes=["generate-btn"],
                        variant="primary"
                    )
            
            image_output = gr.Image(
                label="Generated Image",
                elem_classes=["image-output"],
                show_label=False,
                container=True
            )
            
            with gr.Row():
                generation_info = gr.Textbox(
                    label="Generation Info",
                    interactive=False,
                    elem_classes=["image-info"],
                    show_label=True,
                    visible=False
                )
            
            with gr.Row():
                metadata_display = gr.Textbox(
                    label="Image Metadata",
                    interactive=True,
                    elem_classes=["metadata-box"],
                    show_label=True,
                    lines=15,
                    visible=False
                )
        
        def on_generate(prompt, style, neg_prompt, steps, cfg, seed, width, height):
            image, info, metadata = generate_image(
                prompt, style, neg_prompt, steps, cfg, seed, width, height
            )
            
            if image is not None:
                return (
                    image,
                    info,
                    metadata,
                    gr.update(visible=True, value=info),
                    gr.update(visible=True, value=metadata)
                )
            else:
                return (
                    None,
                    info,
                    "",
                    gr.update(visible=False),
                    gr.update(visible=False)
                )
        
        generate_button.click(
            fn=on_generate,
            inputs=[
                prompt_input, style_input, negative_prompt_input,
                steps_input, cfg_input, seed_input, width_input, height_input
            ],
            outputs=[
                image_output, generation_info, metadata_display,
                generation_info, metadata_display
            ],
            show_progress=True
        )
        
        prompt_input.submit(
            fn=on_generate,
            inputs=[
                prompt_input, style_input, negative_prompt_input,
                steps_input, cfg_input, seed_input, width_input, height_input
            ],
            outputs=[
                image_output, generation_info, metadata_display,
                generation_info, metadata_display
            ],
            show_progress=True
        )
    
    return interface

# ===== 启动应用 =====
if __name__ == "__main__":
    print("\n" + "="*50)
    print("🚀 Starting NSFW Image Generator")
    print("="*50)
    print(f"📦 Model: {FIXED_MODEL}")
    print(f"🖥️  Device: {'CUDA' if torch.cuda.is_available() else 'CPU'}")
    print(f"⚡ ZeroGPU: {'Enabled' if SPACES_AVAILABLE else 'Disabled'}")
    print(f"📝 Compel: {'Available' if COMPEL_AVAILABLE else 'Not Available'}")
    print("="*50 + "\n")
    
    # 不预加载模型，让ZeroGPU按需分配
    # 这样可以避免GPU分配冲突
    
    app = create_interface()
    app.queue(max_size=10, default_concurrency_limit=2)
    
    app.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False
    )