import tempfile
import time
from collections.abc import Sequence
from typing import Any, cast
import os
from huggingface_hub import login, hf_hub_download

import gradio as gr
import numpy as np
import pillow_heif
import spaces
import torch
from gradio_image_annotation import image_annotator
from gradio_imageslider import ImageSlider
from PIL import Image
from pymatting.foreground.estimate_foreground_ml import estimate_foreground_ml
from refiners.fluxion.utils import no_grad
from refiners.solutions import BoxSegmenter
from transformers import GroundingDinoForObjectDetection, GroundingDinoProcessor
from diffusers import FluxPipeline
from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
import gc
import base64


# GPU 설정
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  # 명시적으로 cuda:0 지정

###--------------ZERO GPU 필수/ 메모리 관리 공통 --------------------###
def clear_memory():
    """메모리 정리 함수"""
    gc.collect()
    if torch.cuda.is_available():
        try:
            with torch.cuda.device('cuda:0'):
                torch.cuda.empty_cache()
                torch.cuda.synchronize()
        except Exception as e:
            print(f"Warning: Could not clear CUDA memory: {e}")

###---------------------------------------------------------------

# GPU 설정을 try-except로 감싸기
if torch.cuda.is_available():
    try:
        with torch.cuda.device(0):
            torch.cuda.empty_cache()
            torch.backends.cudnn.benchmark = True
            torch.backends.cuda.matmul.allow_tf32 = True
    except:
        print("Warning: Could not configure CUDA settings")

# 번역 모델 초기화
model_name = "Helsinki-NLP/opus-mt-ko-en"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to('cpu')
translator = pipeline("translation", model=model, tokenizer=tokenizer, device=-1)

def translate_to_english(text: str) -> str:
    """한글 텍스트를 영어로 번역"""
    try:
        if any(ord('가') <= ord(char) <= ord('힣') for char in text):
            translated = translator(text, max_length=128)[0]['translation_text']
            print(f"Translated '{text}' to '{translated}'")
            return translated
        return text
    except Exception as e:
        print(f"Translation error: {str(e)}")
        return text

BoundingBox = tuple[int, int, int, int]

pillow_heif.register_heif_opener()
pillow_heif.register_avif_opener()

# HF 토큰 설정
HF_TOKEN = os.getenv("HF_TOKEN")
if HF_TOKEN is None:
    raise ValueError("Please set the HF_TOKEN environment variable")

try:
    login(token=HF_TOKEN)
except Exception as e:
    raise ValueError(f"Failed to login to Hugging Face: {str(e)}")

# 모델 초기화
segmenter = BoxSegmenter(device="cpu")
segmenter.device = device
segmenter.model = segmenter.model.to(device=segmenter.device)

gd_model_path = "IDEA-Research/grounding-dino-base"
gd_processor = GroundingDinoProcessor.from_pretrained(gd_model_path)
gd_model = GroundingDinoForObjectDetection.from_pretrained(gd_model_path, torch_dtype=torch.float32)
gd_model = gd_model.to(device=device)
assert isinstance(gd_model, GroundingDinoForObjectDetection)

# 파이프라인 초기화 및 최적화 설정
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16,
    use_auth_token=HF_TOKEN
)

# 메모리 최적화 설정 - FluxPipeline에서 지원하는 메서드만 사용
pipe.enable_attention_slicing(slice_size="auto")

# xformers 최적화 (설치되어 있는 경우에만)
try:
    import xformers
    pipe.enable_xformers_memory_efficient_attention()
except ImportError:
    print("xformers is not installed. Skipping memory efficient attention.")

# GPU 설정
if torch.cuda.is_available():
    try:
        pipe = pipe.to("cuda:0")
        # CPU 오프로딩이 지원되는 경우에만 활성화
        if hasattr(pipe, 'enable_model_cpu_offload'):
            pipe.enable_model_cpu_offload()
    except Exception as e:
        print(f"Warning: Could not move pipeline to CUDA: {str(e)}")

    

# LoRA 가중치 로드
pipe.load_lora_weights(
    hf_hub_download(
        "ByteDance/Hyper-SD",
        "Hyper-FLUX.1-dev-8steps-lora.safetensors",
        use_auth_token=HF_TOKEN
    )
)
pipe.fuse_lora(lora_scale=0.125)

# GPU 설정을 try-except로 감싸기
try:
    if torch.cuda.is_available():
        pipe = pipe.to("cuda:0")  # 명시적으로 cuda:0 지정
except Exception as e:
    print(f"Warning: Could not move pipeline to CUDA: {str(e)}")

class timer:
    def __init__(self, method_name="timed process"):
        self.method = method_name
    def __enter__(self):
        self.start = time.time()
        print(f"{self.method} starts")
    def __exit__(self, exc_type, exc_val, exc_tb):
        end = time.time()
        print(f"{self.method} took {str(round(end - self.start, 2))}s")

def bbox_union(bboxes: Sequence[list[int]]) -> BoundingBox | None:
    if not bboxes:
        return None
    for bbox in bboxes:
        assert len(bbox) == 4
        assert all(isinstance(x, int) for x in bbox)
    return (
        min(bbox[0] for bbox in bboxes),
        min(bbox[1] for bbox in bboxes),
        max(bbox[2] for bbox in bboxes),
        max(bbox[3] for bbox in bboxes),
    )

def corners_to_pixels_format(bboxes: torch.Tensor, width: int, height: int) -> torch.Tensor:
    x1, y1, x2, y2 = bboxes.round().to(torch.int32).unbind(-1)
    return torch.stack((x1.clamp_(0, width), y1.clamp_(0, height), x2.clamp_(0, width), y2.clamp_(0, height)), dim=-1)

def gd_detect(img: Image.Image, prompt: str) -> BoundingBox | None:
    inputs = gd_processor(images=img, text=f"{prompt}.", return_tensors="pt").to(device=device)
    with no_grad():
        outputs = gd_model(**inputs)
    width, height = img.size
    results: dict[str, Any] = gd_processor.post_process_grounded_object_detection(
        outputs,
        inputs["input_ids"],
        target_sizes=[(height, width)],
    )[0]
    assert "boxes" in results and isinstance(results["boxes"], torch.Tensor)
    bboxes = corners_to_pixels_format(results["boxes"].cpu(), width, height)
    return bbox_union(bboxes.numpy().tolist())

def apply_mask(img: Image.Image, mask_img: Image.Image, defringe: bool = True) -> Image.Image:
    assert img.size == mask_img.size
    img = img.convert("RGB")
    mask_img = mask_img.convert("L")
    if defringe:
        rgb, alpha = np.asarray(img) / 255.0, np.asarray(mask_img) / 255.0
        foreground = cast(np.ndarray[Any, np.dtype[np.uint8]], estimate_foreground_ml(rgb, alpha))
        img = Image.fromarray((foreground * 255).astype("uint8"))
    result = Image.new("RGBA", img.size)
    result.paste(img, (0, 0), mask_img)
    return result


def calculate_dimensions(aspect_ratio: str, base_size: int = 512) -> tuple[int, int]:
    """선택된 비율에 따라 이미지 크기 계산"""
    # FLUX 파이프라인이 지원하는 안전한 크기 사용
    if aspect_ratio == "1:1":
        width = height = 512
    elif aspect_ratio == "16:9":
        width, height = 576, 320  # 16:9에 가까운 안전한 크기
    elif aspect_ratio == "9:16":
        width, height = 320, 576  # 9:16에 가까운 안전한 크기
    elif aspect_ratio == "4:3":
        width, height = 512, 384  # 4:3에 가까운 안전한 크기
    else:
        width = height = 512
    
    # 8의 배수로 조정
    width = (width // 8) * 8
    height = (height // 8) * 8
    
    return width, height

def generate_background(prompt: str, aspect_ratio: str) -> Image.Image:
    try:
        # 안전한 크기 계산
        width, height = calculate_dimensions(aspect_ratio)
        
        print(f"Generating background with size: {width}x{height}")
        
        with timer("Background generation"):
            try:
                # 먼저 512x512로 생성
                with torch.inference_mode():
                    image = pipe(
                        prompt=prompt,
                        width=512,
                        height=512,
                        num_inference_steps=8,
                        guidance_scale=4.0,
                    ).images[0]
                
                # 원하는 크기로 리사이즈
                if width != 512 or height != 512:
                    image = image.resize((width, height), Image.LANCZOS)
                return image
                
            except Exception as e:
                print(f"Pipeline error: {str(e)}")
                # 에러 발생 시 흰색 배경 반환
                return Image.new('RGB', (width, height), 'white')
                
    except Exception as e:
        print(f"Background generation error: {str(e)}")
        return Image.new('RGB', (512, 512), 'white')


def adjust_size_to_multiple_of_8(width: int, height: int) -> tuple[int, int]:
    """이미지 크기를 8의 배수로 조정"""
    new_width = max(8, ((width + 7) // 8) * 8)  # 최소 8픽셀 보장
    new_height = max(8, ((height + 7) // 8) * 8)  # 최소 8픽셀 보장
    return new_width, new_height

def create_position_grid():
    return """
    <div class="position-grid" style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; width: 150px; margin: auto;">
        <button class="position-btn" data-pos="top-left">↖</button>
        <button class="position-btn" data-pos="top-center">↑</button>
        <button class="position-btn" data-pos="top-right">↗</button>
        <button class="position-btn" data-pos="middle-left">←</button>
        <button class="position-btn" data-pos="middle-center">•</button>
        <button class="position-btn" data-pos="middle-right">→</button>
        <button class="position-btn" data-pos="bottom-left">↙</button>
        <button class="position-btn" data-pos="bottom-center" data-default="true">↓</button>
        <button class="position-btn" data-pos="bottom-right">↘</button>
    </div>
    """

def calculate_object_position(position: str, bg_size: tuple[int, int], obj_size: tuple[int, int]) -> tuple[int, int]:
    """오브젝트의 위치 계산"""
    bg_width, bg_height = bg_size
    obj_width, obj_height = obj_size
    
    positions = {
        "top-left": (0, 0),
        "top-center": ((bg_width - obj_width) // 2, 0),
        "top-right": (bg_width - obj_width, 0),
        "middle-left": (0, (bg_height - obj_height) // 2),
        "middle-center": ((bg_width - obj_width) // 2, (bg_height - obj_height) // 2),
        "middle-right": (bg_width - obj_width, (bg_height - obj_height) // 2),
        "bottom-left": (0, bg_height - obj_height),
        "bottom-center": ((bg_width - obj_width) // 2, bg_height - obj_height),
        "bottom-right": (bg_width - obj_width, bg_height - obj_height)
    }
    
    return positions.get(position, positions["bottom-center"])

def resize_object(image: Image.Image, scale_percent: float) -> Image.Image:
    """오브젝트 크기 조정"""
    width = int(image.width * scale_percent / 100)
    height = int(image.height * scale_percent / 100)
    return image.resize((width, height), Image.Resampling.LANCZOS)

def combine_with_background(foreground: Image.Image, background: Image.Image, 
                          position: str = "bottom-center", scale_percent: float = 100) -> Image.Image:
    """전경과 배경 합성 함수"""
    # 배경 이미지 준비
    result = background.convert('RGBA')
    
    # 오브젝트 크기 조정
    scaled_foreground = resize_object(foreground, scale_percent)
    
    # 오브젝트 위치 계산
    x, y = calculate_object_position(position, result.size, scaled_foreground.size)
    
    # 합성
    result.paste(scaled_foreground, (x, y), scaled_foreground)
    return result

@spaces.GPU(duration=20)  # 30초에서 20초로 감소
def _gpu_process(img: Image.Image, prompt: str | BoundingBox | None) -> tuple[Image.Image, BoundingBox | None, list[str]]:
    try:
        with torch.inference_mode(), torch.amp.autocast('cuda', enabled=torch.cuda.is_available()):
            if isinstance(prompt, str):
                bbox = gd_detect(img, prompt)
                if not bbox:
                    raise gr.Error("No object detected in image")
            else:
                bbox = prompt
                
            mask = segmenter(img, bbox)
            return mask, bbox, []
    except Exception as e:
        print(f"GPU process error: {str(e)}")
        raise
    finally:
        clear_memory()

def _process(img: Image.Image, prompt: str | BoundingBox | None, bg_prompt: str | None = None, aspect_ratio: str = "1:1") -> tuple[tuple[Image.Image, Image.Image, Image.Image], gr.DownloadButton]:
    try:
        # 입력 이미지 크기 제한
        max_size = 1024
        if img.width > max_size or img.height > max_size:
            ratio = max_size / max(img.width, img.height)
            new_size = (int(img.width * ratio), int(img.height * ratio))
            img = img.resize(new_size, Image.LANCZOS)

        # CUDA 메모리 관리
        if torch.cuda.is_available():
            torch.cuda.empty_cache()

        # 새로운 autocast 구문 사용
        with torch.amp.autocast('cuda', enabled=torch.cuda.is_available()):
            mask, bbox, time_log = _gpu_process(img, prompt)
            masked_alpha = apply_mask(img, mask, defringe=True)

        if bg_prompt:
            background = generate_background(bg_prompt, aspect_ratio)
            combined = background
        else:
            combined = Image.alpha_composite(Image.new("RGBA", masked_alpha.size, "white"), masked_alpha)

        clear_memory()

        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp:
            combined.save(temp.name)
            return (img, combined, masked_alpha), gr.DownloadButton(value=temp.name, interactive=True)
    except Exception as e:
        clear_memory()
        print(f"Processing error: {str(e)}")
        raise gr.Error(f"Processing failed: {str(e)}")

def on_change_bbox(prompts: dict[str, Any] | None):
    return gr.update(interactive=prompts is not None)


def on_change_prompt(img: Image.Image | None, prompt: str | None, bg_prompt: str | None = None):
    return gr.update(interactive=bool(img and prompt))


        
def process_prompt(img: Image.Image, prompt: str, bg_prompt: str | None = None, 
                  aspect_ratio: str = "1:1", position: str = "bottom-center", 
                  scale_percent: float = 100) -> tuple[Image.Image, Image.Image]:
    try:
        if img is None or not prompt or prompt.isspace():
            raise gr.Error("Please provide both image and prompt")
        
        print(f"Processing with position: {position}, scale: {scale_percent}")  # 디버깅용
        
        # 입력 이미지 크기 제한
        max_size = 1024
        if img.width > max_size or img.height > max_size:
            ratio = max_size / max(img.width, img.height)
            img = img.resize((int(img.width * ratio), int(img.height * ratio)), Image.LANCZOS)
        
        # 번역 처리
        translated_prompt = translate_to_english(prompt)
        translated_bg_prompt = translate_to_english(bg_prompt) if bg_prompt else None
        
        # 이미지 처리
        with torch.inference_mode():
            results, _ = _process(img, translated_prompt, translated_bg_prompt, aspect_ratio)
            
            if translated_bg_prompt:
                try:
                    combined = combine_with_background(
                        foreground=results[2],
                        background=results[1],
                        position=position,
                        scale_percent=scale_percent  # scale_slider가 아닌 scale_percent 사용
                    )
                    return combined, results[2]
                except Exception as e:
                    print(f"Background combination error: {e}")
                    return results[1], results[2]
            
            return results[1], results[2]
            
    except Exception as e:
        print(f"Process error: {str(e)}")
        raise gr.Error(str(e))
    finally:
        clear_memory()
        
def process_bbox(img: Image.Image, box_input: str) -> tuple[Image.Image, Image.Image]:
    try:
        if img is None or box_input.strip() == "":
            raise gr.Error("Please provide both image and bounding box coordinates")
        
        try:
            coords = eval(box_input)
            if not isinstance(coords, list) or len(coords) != 4:
                raise ValueError("Invalid box format")
            bbox = tuple(int(x) for x in coords)
        except:
            raise gr.Error("Invalid box format. Please provide [xmin, ymin, xmax, ymax]")
        
        # Process the image
        results, _ = _process(img, bbox)
        
        # 합성된 이미지와 추출된 이미지만 반환
        return results[1], results[2]
    except Exception as e:
        raise gr.Error(str(e))

# Event handler functions 수정
def update_process_button(img, prompt):
    return gr.update(
        interactive=bool(img and prompt),
        variant="primary" if bool(img and prompt) else "secondary"
    )

def update_box_button(img, box_input):
    try:
        if img and box_input:
            coords = eval(box_input)
            if isinstance(coords, list) and len(coords) == 4:
                return gr.update(interactive=True, variant="primary")
        return gr.update(interactive=False, variant="secondary")
    except:
        return gr.update(interactive=False, variant="secondary")


# CSS 정의
css = """
footer {display: none}
.main-title {
    text-align: center;
    margin: 2em 0;
    padding: 1em;
    background: #f7f7f7;
    border-radius: 10px;
}
.main-title h1 {
    color: #2196F3;
    font-size: 2.5em;
    margin-bottom: 0.5em;
}
.main-title p {
    color: #666;
    font-size: 1.2em;
}
.container {
    max-width: 1200px;
    margin: auto;
    padding: 20px;
}
.tabs {
    margin-top: 1em;
}
.input-group {
    background: white;
    padding: 1em;
    border-radius: 8px;
    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
.output-group {
    background: white;
    padding: 1em;
    border-radius: 8px;
    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
button.primary {
    background: #2196F3;
    border: none;
    color: white;
    padding: 0.5em 1em;
    border-radius: 4px;
    cursor: pointer;
    transition: background 0.3s ease;
}
button.primary:hover {
    background: #1976D2;
}
.position-btn {
    transition: all 0.3s ease;
}
.position-btn:hover {
    background-color: #e3f2fd;
}
.position-btn.selected {
    background-color: #2196F3;
    color: white;
}
"""


def get_image_base64(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode()

# 이미지를 Base64로 변환
try:
    example_img1 = get_image_base64("aa1.png")
    example_img2 = get_image_base64("aa2.png")
    example_img3 = get_image_base64("aa3.png")
except Exception as e:
    print(f"Error loading example images: {e}")
    example_img1 = example_img2 = example_img3 = ""

# HTML 템플릿 수정
example_html = f"""
<div style="margin-top: 50px; padding: 20px; background-color: #f8f9fa; border-radius: 10px;">
    <h2 style="text-align: center; color: #2196F3; margin-bottom: 30px;">How It Works: Step by Step Guide</h2>
    
    <div style="display: flex; justify-content: space-around; align-items: center; flex-wrap: wrap; gap: 20px;">
        <div style="text-align: center; flex: 1; min-width: 250px; max-width: 300px;">
            <img src="data:image/png;base64,{example_img1}" 
                 style="width: 100%; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
            <h3 style="color: #333; margin: 15px 0;">Step 1: Original Image</h3>
            <p style="color: #666;">Upload your original image containing the object you want to extract.</p>
        </div>
        
        <div style="text-align: center; flex: 1; min-width: 250px; max-width: 300px;">
            <img src="data:image/png;base64,{example_img2}" 
                 style="width: 100%; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
            <h3 style="color: #333; margin: 15px 0;">Step 2: Object Extraction</h3>
            <p style="color: #666;">AI automatically detects and extracts the specified object.</p>
        </div>
        
        <div style="text-align: center; flex: 1; min-width: 250px; max-width: 300px;">
            <img src="data:image/png;base64,{example_img3}" 
                 style="width: 100%; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
            <h3 style="color: #333; margin: 15px 0;">Step 3: Final Result</h3>
            <p style="color: #666;">The extracted object is placed on an AI-generated background.</p>
        </div>
    </div>

    <div style="margin-top: 30px; text-align: center; padding: 20px; background-color: #e3f2fd; border-radius: 8px;">
        <h4 style="color: #1976D2; margin-bottom: 10px;">Key Features:</h4>
        <ul style="list-style: none; padding: 0;">
            <li style="margin: 5px 0;">✨ Advanced AI-powered object detection and extraction</li>
            <li style="margin: 5px 0;">🎨 Custom background generation with text prompts</li>
            <li style="margin: 5px 0;">🔄 Flexible object positioning and sizing options</li>
            <li style="margin: 5px 0;">📐 Multiple aspect ratio support for various use cases</li>
        </ul>
    </div>
</div>
"""

    
# UI 구성
with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
    gr.HTML("""
        <div class="main-title">
            <h1>🎨GiniGen Canvas</h1>
            <p>AI Integrated Image Creator: Extract objects, generate backgrounds, and adjust ratios and positions to create complete images with AI.</p>
        </div>
    """)

    # 예제 섹션 추가
    gr.HTML(example_html)
    
    with gr.Row():
        with gr.Column(scale=1):
            input_image = gr.Image(
                type="pil",
                label="Upload Image",
                interactive=True
            )
            text_prompt = gr.Textbox(
                label="Object to Extract",
                placeholder="Enter what you want to extract...",
                interactive=True
            )
            with gr.Row():
                bg_prompt = gr.Textbox(
                    label="Background Prompt (optional)",
                    placeholder="Describe the background...",
                    interactive=True,
                    scale=3
                )
                aspect_ratio = gr.Dropdown(
                    choices=["1:1", "16:9", "9:16", "4:3"],
                    value="1:1",
                    label="Aspect Ratio",
                    interactive=True,
                    visible=True,
                    scale=1
                )

            with gr.Row(visible=False) as object_controls:
                with gr.Column(scale=1):
                    with gr.Row():
                        position = gr.State(value="bottom-center")
                        btn_top_left = gr.Button("↖")
                        btn_top_center = gr.Button("↑")
                        btn_top_right = gr.Button("↗")
                    with gr.Row():
                        btn_middle_left = gr.Button("←")
                        btn_middle_center = gr.Button("•")
                        btn_middle_right = gr.Button("→")
                    with gr.Row():
                        btn_bottom_left = gr.Button("↙")
                        btn_bottom_center = gr.Button("↓")
                        btn_bottom_right = gr.Button("↘")
                with gr.Column(scale=1):
                    scale_slider = gr.Slider(
                        minimum=10,
                        maximum=200,
                        value=100,
                        step=5,
                        label="Object Size (%)"
                    )

            process_btn = gr.Button(
                "Process",
                variant="primary",
                interactive=False
            )

            # 각 버튼에 대한 클릭 이벤트 처리
            def update_position(new_position):
                return new_position

            btn_top_left.click(fn=lambda: update_position("top-left"), outputs=position)
            btn_top_center.click(fn=lambda: update_position("top-center"), outputs=position)
            btn_top_right.click(fn=lambda: update_position("top-right"), outputs=position)
            btn_middle_left.click(fn=lambda: update_position("middle-left"), outputs=position)
            btn_middle_center.click(fn=lambda: update_position("middle-center"), outputs=position)
            btn_middle_right.click(fn=lambda: update_position("middle-right"), outputs=position)
            btn_bottom_left.click(fn=lambda: update_position("bottom-left"), outputs=position)
            btn_bottom_center.click(fn=lambda: update_position("bottom-center"), outputs=position)
            btn_bottom_right.click(fn=lambda: update_position("bottom-right"), outputs=position)

        with gr.Column(scale=1):
            with gr.Row():
                combined_image = gr.Image(
                    label="Combined Result",
                    show_download_button=True,
                    type="pil",
                    height=512
                )
            with gr.Row():
                extracted_image = gr.Image(
                    label="Extracted Object",
                    show_download_button=True,
                    type="pil",
                    height=256
                )

    # Event bindings
    input_image.change(
        fn=update_process_button,
        inputs=[input_image, text_prompt],
        outputs=process_btn,
        queue=False
    )
    
    text_prompt.change(
        fn=update_process_button,
        inputs=[input_image, text_prompt],
        outputs=process_btn,
        queue=False
    )

    def update_controls(bg_prompt):
        is_visible = bool(bg_prompt)
        return [
            gr.update(visible=is_visible, interactive=is_visible),  # aspect_ratio
            gr.update(visible=is_visible),  # object_controls
        ]
    


    bg_prompt.change(
        fn=update_controls,
        inputs=bg_prompt,
        outputs=[aspect_ratio, object_controls],
        queue=False
    )

    process_btn.click(
        fn=process_prompt,
        inputs=[
            input_image,
            text_prompt,
            bg_prompt,
            aspect_ratio,
            position,
            scale_slider
        ],
        outputs=[combined_image, extracted_image],
        queue=True
    )


demo.queue(max_size=5)  # 큐 크기 제한
demo.launch(
    server_name="0.0.0.0",
    server_port=7860,
    share=False,
    max_threads=2)  # 스레드 수 제한