app.py

from __future__ import annotations

import base64
import asyncio
import json
import os
import re
import threading
import time
import traceback
import uuid
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timezone
from io import BytesIO
from pathlib import Path
from typing import Optional

import uvicorn
from fastapi import FastAPI, File, Form, UploadFile
from fastapi.responses import FileResponse, JSONResponse, Response
from fastapi.staticfiles import StaticFiles
from google import genai
from google.genai import types
from huggingface_hub import HfApi
from openai import OpenAI
from PIL import Image, ImageChops, ImageDraw, ImageFilter, ImageOps


APP_TITLE = "AI ModelCut Studio"
BASE_DIR = Path(__file__).parent
ASSETS_DIR = BASE_DIR / "assets"
PRESET_FACE_CANDIDATES = [
    ASSETS_DIR / "model_face_preset.png",
    BASE_DIR / "model_face_preset.png",
]
OPENAI_DEFAULT_IMAGE_MODEL = os.environ.get("OPENAI_IMAGE_MODEL", "gpt-image-2")
GEMINI_DEFAULT_IMAGE_MODEL = os.environ.get("GEMINI_IMAGE_MODEL", "gemini-3.1-flash-image-preview")
TARGET_SIZES = {
    "1K": (1024, 1536),
    "2K": (2048, 3072),
}
DEMO_FALLBACK = os.environ.get("DEMO_FALLBACK", "").lower() == "true"
API_INPUT_MAX_SIDE = int(os.environ.get("API_INPUT_MAX_SIDE", "2048"))
# Max concurrent image-generation calls (batch shots / Gemini candidates run in parallel).
GEN_MAX_WORKERS = max(1, int(os.environ.get("GEN_MAX_WORKERS", "4")))
# Proportion policy. When a body reference exists, its proportions are always matched.
# With NO body reference: IDEALIZE_PROPORTIONS=true → force 8.2-8.5 heads editorial look;
# otherwise leave proportions neutral (no forced head-shrink / leg elongation).
IDEALIZE_PROPORTIONS = os.environ.get("IDEALIZE_PROPORTIONS", "").lower() == "true"
# Post-process: re-crop full-body output so the subject occupies the same vertical band
# (head-top / feet-bottom margins) as the body reference image. Set to "false" to disable.
MATCH_REFERENCE_FRAMING = os.environ.get("MATCH_REFERENCE_FRAMING", "true").lower() != "false"
# Color distance (0-255) above which a pixel counts as subject vs background.
SUBJECT_BG_TOLERANCE = max(1, int(os.environ.get("SUBJECT_BG_TOLERANCE", "32")))
# Optional manual framing override (fractions of height, e.g. "0.10"). If BOTH are set they
# replace the reference-derived margins — head sits at TOP, feet at (1 - BOTTOM).
FRAMING_TOP_MARGIN = os.environ.get("FRAMING_TOP_MARGIN", "").strip()
FRAMING_BOTTOM_MARGIN = os.environ.get("FRAMING_BOTTOM_MARGIN", "").strip()
HF_DATASET_REPO_DEFAULT = "sunyoung00/ROEM_TEST"
STUDIO_BACKGROUND_PROMPT = (
    "Use a clean seamless studio background in solid warm light gray color #E8E7E2. "
    "Ignore the background from all reference images. "
    "Keep only a natural soft floor shadow. "
    "Do not add props, walls, patterns, gradients, or colored lighting."
)
FULL_BODY_PROPORTION_PROMPT = (
    "Use elegant fashion model proportions with a naturally smaller head-to-body ratio, "
    "approximately 8.2 to 8.5 heads tall. Keep the face identity exactly the same, but scale "
    "the head naturally smaller relative to the full body. Use long legs, balanced shoulders, "
    "and realistic runway/editorial model proportions. Do not distort the face, neck, hands, "
    "feet, or garment shape."
)
PROPORTION_MATCH_PROMPT = (
    "Match the model's head SIZE, face size, neck length, torso-to-leg ratio, and overall "
    "head-to-body proportions to the body-type reference image. Reproduce the natural proportions "
    "shown in that reference. Do NOT elongate the legs, do NOT shrink the head, and do NOT apply "
    "exaggerated runway/editorial proportions. Do not distort the face, neck, hands, feet, or garment shape."
)
FACE_ARTIFACT_PREVENTION_PROMPT = (
    "Keep facial features clean, smooth, and natural. Do not over-sharpen the face, add skin "
    "texture noise, mottling, patchy artifacts, speckles, blotches, or uneven discoloration. "
    "Preserve clear eyes, nose, lips, brows, and natural skin tone without repainting the identity."
)
FULL_BODY_FRAMING_LOCK_PROMPT = (
    "Preserve the subject scale, crop, and camera distance from the selected base image. "
    "The selected base image controls the final framing, not the pose reference image. "
    "Match the selected base image subject bounding box: keep the head top, shoe bottom, body center, "
    "and full-body height in nearly the same pixel positions. Do not zoom out, do not make the model "
    "smaller in the frame, and do not copy the margins from the pose reference image. If pose and "
    "framing conflict, prioritize the selected base image framing."
)
SKIN_TONE_LOCK_PROMPT = (
    "Preserve the original skin tone and facial exposure from the selected base image. "
    "Do not whiten, pale, brighten, over-smooth, or overexpose the face."
)
DETAIL_SHOT_PROMPT = (
    "Create an EXTREME close-up macro detail shot of the garment only. "
    "NO MODEL, NO FACE, NO BODY PARTS, NO HAIR, NO SKIN. "
    "Zoom in tightly to showcase the fabric texture, stitching, and construction quality of the target area. "
    "Keep the exact same garment color, material, and design as the source image."
)
FULL_BODY_FRAMING_BLOCK = (
    "FRAMING (FULL BODY, NON-NEGOTIABLE): wide full-length shot. "
    "The standing figure must occupy approximately 75-80% of the frame height, with clear empty space on all four sides. "
    "Leave at least 8% empty space above the top of the hair/head, at least 8% below the soles of the shoes, and "
    "about 5% on the left and right. Every body part must be visible: head, face, shoulders, torso, waist, knees, "
    "ankles, and feet with complete shoes. If ANY body part is cropped, the result is wrong. "
    "No bags, no phones, no extra accessories held in the hands."
)
# Precise English transform instruction per Korean shot label.
# Used to image-to-image transform the selected base cut while keeping identity/outfit locked.
SHOT_TRANSFORM_INSTRUCTIONS = {
    "전신(정면)": "Front-facing FULL-BODY standing shot of the exact same model and outfit.",
    "전신(앞면)": "Front-facing FULL-BODY standing shot of the exact same model and outfit.",
    "전신(자유포즈)": (
        "FULL-BODY shot of the exact same model and outfit in a natural, relaxed editorial pose. "
        "Keep both feet and the complete standing figure visible."
    ),
    "전신(측면)": (
        "Rotate the model to a SIDE PROFILE (about 90 degrees) to show the silhouette of the exact same outfit "
        "as a full-body shot."
    ),
    "전신(후면)": (
        "Rotate the model 180 degrees to show the BACK of the exact same outfit as a full-body shot. "
        "Show the back construction details of the garment clearly."
    ),
    "상반신": (
        "MEDIUM CLOSE-UP UPPER-BODY portrait, framed from approximately the waist up to above the top of the head. "
        "The entire head including the complete crown of hair MUST be fully visible — leave at least 8% empty space "
        "above the hair, never crop the top of the head. Sharp focus on the upper garment."
    ),
    "상반신(앞면)": (
        "Front-facing MEDIUM CLOSE-UP UPPER-BODY portrait, framed from approximately the waist up to above the top "
        "of the head. The entire head and hair crown MUST be fully visible — leave at least 8% empty space above "
        "the hair, never crop the top of the head. Sharp focus on the upper garment."
    ),
    "상반신(측면)": (
        "SIDE-PROFILE (about 90 degrees) UPPER-BODY portrait, framed from approximately the waist up to above the "
        "top of the head. Keep the whole head and hair crown visible. Show the side silhouette of the upper garment."
    ),
    "상반신(후면)": (
        "Rotate the model 180 degrees and frame an UPPER-BODY BACK portrait from the waist up. "
        "Keep the whole head and hair crown visible. Show the back neckline and upper-back construction of the same garment."
    ),
    "상반신(클로즈업)": (
        "TIGHT CLOSE-UP of the upper chest, neckline, and collar/tie area of the same garment, including the lower "
        "face and shoulders. Show the fabric texture and neckline construction in sharp detail. Keep the same model identity."
    ),
    "하반신": (
        "LOWER-BODY shot framed from the waist down to the soles of the shoes. "
        "Keep both feet and the complete shoes fully visible. Sharp focus on the lower garment, hem, and shoes."
    ),
    "하반신(자유포즈)": (
        "LOWER-BODY shot from the waist down in a natural, relaxed stance. "
        "Both feet and complete shoes must be fully visible. Sharp focus on the lower garment and footwear."
    ),
    "하반신(클로즈업)": (
        "EXTREME CLOSE-UP macro of the lower-garment detail (waistband, tie, hem, or fabric texture). "
        "Garment only — no face. Show the construction and texture in sharp detail."
    ),
    "디테일(상의)": "Focus the detail shot on the TOP garment area (collar, placket, sleeve, or main fabric texture).",
    "디테일(포켓)": "Focus the detail shot on the POCKET area, showing stitching and construction.",
    "디테일(신발)": "Focus the detail shot on the SHOES / footwear.",
    "디테일(후면)": (
        "Focus the detail shot on the BACK construction of the garment (back neckline, zipper, seams, or fabric "
        "texture from behind)."
    ),
}
# Garment-only macro shots (no model/face/skin).
_DETAIL_SHOTS = {"디테일(상의)", "디테일(포켓)", "디테일(신발)", "디테일(후면)", "하반신(클로즈업)"}
# Shots where the deterministic crop-to-reference is skipped (extreme crops / no clear full subject).
_NO_REFRAME_SHOTS = _DETAIL_SHOTS | {"상반신(클로즈업)"}

# ---- Per-shot reference library + body-type reference --------------------------
# Each shot button maps 1:1 to a reference image in assets/poses/ whose filename is the
# shot label with parentheses turned into underscores, e.g.:
#   "전신(앞면)"      -> assets/poses/전신_앞면_.(png|jpg|jpeg|webp)
#   "상반신(클로즈업)" -> assets/poses/상반신_클로즈업_.(...)
#   "하반신"          -> assets/poses/하반신.(...)
# The reference defines pose, camera angle, and crop/framing for that shot.
POSES_DIR = ASSETS_DIR / "poses"
POSE_IMAGE_EXTENSIONS = (".png", ".jpg", ".jpeg", ".webp")
# Model body-type reference (physique only; face stays from the face preset).
BODY_PRESET_CANDIDATES = [
    ASSETS_DIR / "model_body_preset.png",
    BASE_DIR / "model_body_preset.png",
]


def _shot_reference_stems(shot_type: str) -> list[str]:
    """Candidate filename stems for a shot label, in priority order.

    Supports both naming styles so references resolve regardless of how they were saved:
      1) label as-is, with parentheses kept   -> "전신(앞면)"  -> 전신(앞면).jpeg
      2) parentheses replaced with underscores -> "전신_앞면_" -> 전신_앞면_.jpeg
    """
    label = (shot_type or "").strip()
    if not label:
        return []
    underscore = label.replace("(", "_").replace(")", "_")
    stems = [label]
    if underscore != label:
        stems.append(underscore)
    return stems


def _shot_reference_stem(shot_type: str) -> str:
    """Primary (parens-kept) filename stem for a shot label."""
    stems = _shot_reference_stems(shot_type)
    return stems[0] if stems else ""


BODY_REFERENCE_PROMPT = (
    "A BODY-TYPE reference image is provided. Match the model's physique to it: overall height "
    "impression, body build, shoulder width, limb proportions, AND the head-to-body ratio — i.e. how "
    "large the head and face appear relative to the full body. Use ONLY the body type and proportions "
    "from that image. Do NOT copy its face, hairstyle, skin tone, clothing, pose, or background — those "
    "come from the other reference images."
)


def _reference_legend(has_face: bool, has_body: bool, product_count: int, has_pose: bool) -> str:
    """Describe each reference image by its position so the model never confuses roles."""
    roles: list[str] = []
    if has_face:
        roles.append("FACE identity (copy this exact face, hairline, and features)")
    if has_body:
        roles.append("BODY-TYPE physique (match build/proportions only; ignore its face, hair, clothing, pose)")
    if has_pose:
        roles.append("POSE/FRAMING guide (follow its body pose, camera angle, viewing direction and crop only; ignore its face, clothing, body type, background)")
    for index in range(product_count):
        roles.append(f"PRODUCT garment {index + 1} (preserve its design, color, logo, and texture exactly)")
    if not roles:
        return ""
    legend = "; ".join(f"image {index + 1} = {role}" for index, role in enumerate(roles))
    return "REFERENCE IMAGE ROLES (in this exact order): " + legend + "."


app = FastAPI(title=APP_TITLE)
ASSETS_DIR.mkdir(exist_ok=True)
app.mount("/assets", StaticFiles(directory=ASSETS_DIR), name="assets")
_OPENAI_CLIENT: Optional[OpenAI] = None
_GEMINI_CLIENT: Optional[genai.Client] = None
_CLIENT_LOCK = threading.Lock()


def _log(message: str, request_id: str = "-") -> None:
    print(f"[MODEL-CUT][{request_id}] {message}", flush=True)


def _create_fallback_face() -> Image.Image:
    canvas = Image.new("RGB", (768, 1024), (248, 248, 248))
    draw = ImageDraw.Draw(canvas)
    draw.ellipse((210, 120, 558, 468), fill=(36, 28, 26))
    draw.rounded_rectangle((258, 210, 510, 560), radius=118, fill=(238, 211, 195))
    draw.ellipse((276, 315, 332, 344), fill=(74, 64, 58))
    draw.ellipse((436, 315, 492, 344), fill=(74, 64, 58))
    draw.arc((340, 378, 428, 438), 15, 165, fill=(170, 116, 110), width=5)
    draw.line((300, 283, 348, 272), fill=(72, 52, 45), width=7)
    draw.line((420, 272, 468, 283), fill=(72, 52, 45), width=7)
    draw.rounded_rectangle((120, 558, 648, 980), radius=140, fill=(238, 211, 195))
    draw.rectangle((188, 782, 580, 1024), fill=(255, 255, 255))
    draw.line((384, 104, 384, 258), fill=(82, 70, 66), width=5)
    return canvas


def load_preset_face() -> Image.Image:
    for preset_path in PRESET_FACE_CANDIDATES:
        if preset_path.exists():
            return ImageOps.exif_transpose(Image.open(preset_path)).convert("RGB")

    return _create_fallback_face()


def load_body_reference() -> Optional[Image.Image]:
    """Optional model body-type reference. Returns None if no preset is present."""
    for preset_path in BODY_PRESET_CANDIDATES:
        if preset_path.exists():
            return ImageOps.exif_transpose(Image.open(preset_path)).convert("RGB")
    return None


def load_shot_reference(shot_type: str) -> Optional[Image.Image]:
    """Load the reference image that defines pose/angle/crop for the given shot label.

    Looks in assets/poses/ (then assets/) for a file whose name matches the shot label,
    accepting both parens-kept ("전신(앞면).jpeg") and underscore ("전신_앞면_.jpeg")
    naming. Returns None if no matching reference file is present.
    """
    stems = _shot_reference_stems(shot_type)
    if not stems:
        return None
    for directory in (POSES_DIR, ASSETS_DIR):
        if not directory.exists():
            continue
        for stem in stems:
            for ext in POSE_IMAGE_EXTENSIONS:
                candidate = directory / f"{stem}{ext}"
                if candidate.exists():
                    return ImageOps.exif_transpose(Image.open(candidate)).convert("RGB")
    return None


async def _read_upload(upload: Optional[UploadFile]) -> Optional[Image.Image]:
    if upload is None or not upload.filename:
        return None

    content = await upload.read()
    if not content:
        return None

    return ImageOps.exif_transpose(Image.open(BytesIO(content))).convert("RGB")


def _read_data_url_image(data_url: str) -> Optional[Image.Image]:
    if not data_url or not data_url.startswith("data:image/") or ";base64," not in data_url:
        return None

    encoded = data_url.split(";base64,", 1)[1]
    raw = base64.b64decode(encoded)
    return ImageOps.exif_transpose(Image.open(BytesIO(raw))).convert("RGB")


def _get_openai_client() -> OpenAI:
    global _OPENAI_CLIENT
    if _OPENAI_CLIENT is None:
        with _CLIENT_LOCK:
            if _OPENAI_CLIENT is None:
                _OPENAI_CLIENT = OpenAI()
    return _OPENAI_CLIENT


def _get_gemini_client(api_key: str) -> genai.Client:
    global _GEMINI_CLIENT
    if _GEMINI_CLIENT is None:
        with _CLIENT_LOCK:
            if _GEMINI_CLIENT is None:
                _GEMINI_CLIENT = genai.Client(api_key=api_key)
    return _GEMINI_CLIENT


def _prepare_api_reference(image: Image.Image) -> Image.Image:
    prepared = ImageOps.exif_transpose(image).convert("RGB")
    prepared.thumbnail((API_INPUT_MAX_SIDE, API_INPUT_MAX_SIDE), Image.Resampling.LANCZOS)
    return prepared


def _image_summary(image: Optional[Image.Image]) -> str:
    if image is None:
        return "none"
    return f"{image.width}x{image.height}"


def _fit_image(image: Image.Image, size: tuple[int, int]) -> Image.Image:
    image = ImageOps.exif_transpose(image).convert("RGBA")
    image.thumbnail(size, Image.Resampling.LANCZOS)
    canvas = Image.new("RGBA", size, (246, 243, 239, 255))
    x = (size[0] - image.width) // 2
    y = (size[1] - image.height) // 2
    canvas.alpha_composite(image, (x, y))
    return canvas


def _draw_model_cut(
    product_image: Optional[Image.Image],
    model_face: Image.Image,
    label: str,
    resolution: str,
    pose_shift: int,
    shot_type: str = "?꾩떊(?뺣㈃)",
) -> Image.Image:
    size = (1024, 1280) if resolution == "1K" else (1536, 1920)
    canvas = Image.new("RGB", size, (246, 243, 239))
    draw = ImageDraw.Draw(canvas)

    grid = max(size[0] // 24, 36)
    for x in range(0, size[0], grid):
        draw.line((x, 0, x, size[1]), fill=(235, 232, 226), width=1)
    for y in range(0, size[1], grid):
        draw.line((0, y, size[0], y), fill=(235, 232, 226), width=1)

    cx = size[0] // 2 + pose_shift
    head_r = size[0] // 15
    is_upper = "상반신" in shot_type or "?곷컲" in shot_type
    is_lower = "하반신" in shot_type or "?섎컲" in shot_type
    is_detail = "디테일" in shot_type or "?뷀뀒" in shot_type
    is_back = "후면" in shot_type or "?꾨㈃" in shot_type

    if is_upper:
        head_r = size[0] // 11
    if is_detail:
        head_r = size[0] // 18

    draw.ellipse((cx - head_r, size[1] // 8, cx + head_r, size[1] // 8 + head_r * 2), fill=(232, 204, 184))
    draw.arc(
        (cx - head_r - 8, size[1] // 8 - 6, cx + head_r + 8, size[1] // 8 + head_r * 2),
        190,
        350,
        fill=(24, 24, 26),
        width=max(8, size[0] // 70),
    )

    face = ImageOps.fit(model_face, (head_r * 2, head_r * 2), method=Image.Resampling.LANCZOS, centering=(0.5, 0.34))
    face_mask = Image.new("L", face.size, 0)
    mask_draw = ImageDraw.Draw(face_mask)
    mask_draw.ellipse((0, 0, face.width, face.height), fill=230)
    canvas.paste(face, (cx - head_r, size[1] // 8), face_mask.filter(ImageFilter.GaussianBlur(0.6)))

    shoulder_y = size[1] // 4
    hem_y = int(size[1] * 0.72)
    if is_upper:
        shoulder_y = size[1] // 3
        hem_y = int(size[1] * 0.92)
    if is_lower:
        shoulder_y = size[1] // 7
        hem_y = int(size[1] * 0.82)
    if is_back:
        draw.rectangle((cx - head_r, size[1] // 8, cx + head_r, size[1] // 8 + head_r * 2), fill=(31, 28, 27))

    body = [
        (cx - size[0] // 6, shoulder_y),
        (cx + size[0] // 6, shoulder_y),
        (cx + size[0] // 8, hem_y),
        (cx - size[0] // 8, hem_y),
    ]
    draw.polygon(body, fill=(29, 32, 36))

    if product_image:
        product_box = (size[0] // 3, int(size[1] * 0.44))
        if is_upper:
            product_box = (size[0] // 2, int(size[1] * 0.5))
        if is_lower:
            product_box = (size[0] // 2, int(size[1] * 0.58))
        if is_detail:
            product_box = (int(size[0] * 0.72), int(size[1] * 0.55))

        product = _fit_image(product_image, product_box)
        product_mask = Image.new("L", product.size, 0)
        product_mask_draw = ImageDraw.Draw(product_mask)
        product_mask_draw.rounded_rectangle((0, 0, product.width, product.height), radius=18, fill=210)
        px = cx - product.width // 2
        py = shoulder_y + size[1] // 18
        if is_lower:
            py = int(size[1] * 0.36)
        if is_detail:
            py = int(size[1] * 0.26)
        canvas.paste(product.convert("RGB"), (px, py), product_mask.filter(ImageFilter.GaussianBlur(1.2)))

    leg_y = hem_y
    if not is_upper and not is_detail:
        draw.line((cx - size[0] // 14, leg_y, cx - size[0] // 9, int(size[1] * 0.9)), fill=(24, 26, 29), width=size[0] // 34)
        draw.line((cx + size[0] // 14, leg_y, cx + size[0] // 9, int(size[1] * 0.9)), fill=(24, 26, 29), width=size[0] // 34)
    draw.ellipse((24, 24, 82, 82), fill=(20, 22, 24))
    draw.text((41, 42), "AI", fill=(255, 255, 255))
    draw.text((24, size[1] - 64), label, fill=(30, 34, 38))

    return canvas


def _image_to_data_url(image: Image.Image, resolution: str = "1K") -> str:
    output = BytesIO()
    if resolution == "2K":
        image.convert("RGB").save(output, format="JPEG", quality=92, optimize=True, progressive=True, subsampling=0)
        encoded = base64.b64encode(output.getvalue()).decode("ascii")
        return f"data:image/jpeg;base64,{encoded}"

    image.save(output, format="PNG", optimize=True)
    encoded = base64.b64encode(output.getvalue()).decode("ascii")
    return f"data:image/png;base64,{encoded}"


def _image_to_png_bytes(image: Image.Image) -> bytes:
    output = BytesIO()
    image.save(output, format="PNG")
    output.seek(0)
    return output.getvalue()


def _image_to_jpeg_bytes(image: Image.Image) -> bytes:
    output = BytesIO()
    image.convert("RGB").save(output, format="JPEG", quality=95, optimize=True, subsampling=0)
    output.seek(0)
    return output.getvalue()


def _safe_dataset_name(value: str) -> str:
    cleaned = re.sub(r"[^0-9A-Za-z가-힣_.()-]+", "_", value.strip())
    return cleaned.strip("_")[:80] or "modelcut"


def _upload_generation_to_dataset(
    images: list[Image.Image],
    labels: list[str],
    metadata: dict,
    request_id: str,
) -> None:
    dataset_repo = os.environ.get("HF_DATASET_REPO", HF_DATASET_REPO_DEFAULT).strip()
    token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
    if not dataset_repo:
        _log("dataset upload skipped: HF_DATASET_REPO is empty", request_id)
        return
    if not token:
        _log("dataset upload skipped: HF_TOKEN is not set", request_id)
        return

    try:
        api = HfApi(token=token)
        api.create_repo(repo_id=dataset_repo, repo_type="dataset", exist_ok=True)

        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
        folder = f"generated/{timestamp}_{request_id}"
        uploaded_files = []

        for index, image in enumerate(images, start=1):
            label = labels[index - 1] if index - 1 < len(labels) else f"image-{index}"
            filename = f"{index:02d}_{_safe_dataset_name(label)}.png"
            path_in_repo = f"{folder}/{filename}"
            api.upload_file(
                path_or_fileobj=_image_to_png_bytes(image),
                path_in_repo=path_in_repo,
                repo_id=dataset_repo,
                repo_type="dataset",
                commit_message=f"Add generated model cut {request_id}",
            )
            uploaded_files.append(path_in_repo)

        metadata_payload = {
            **metadata,
            "request_id": request_id,
            "created_at": timestamp,
            "files": uploaded_files,
        }
        api.upload_file(
            path_or_fileobj=json.dumps(metadata_payload, ensure_ascii=False, indent=2).encode("utf-8"),
            path_in_repo=f"{folder}/metadata.json",
            repo_id=dataset_repo,
            repo_type="dataset",
            commit_message=f"Add model cut metadata {request_id}",
        )
        _log(f"dataset upload done repo={dataset_repo} files={len(uploaded_files)} folder={folder}", request_id)
    except Exception as error:
        _log(f"dataset upload failed repo={dataset_repo} error={error}", request_id)


def _normalize_output_size(image: Image.Image, resolution: str) -> Image.Image:
    target = TARGET_SIZES.get(resolution, TARGET_SIZES["1K"])
    image = ImageOps.exif_transpose(image).convert("RGB")
    if image.size == target:
        return image

    fitted = ImageOps.contain(image, target, method=Image.Resampling.LANCZOS)
    canvas = Image.new("RGB", target, (246, 243, 239))
    x = (target[0] - fitted.width) // 2
    y = (target[1] - fitted.height) // 2
    canvas.paste(fitted, (x, y))
    return canvas


def _estimate_bg_color(image: Image.Image) -> tuple[int, int, int]:
    """Estimate the (solid studio) background color from the image corners."""
    rgb = image.convert("RGB")
    w, h = rgb.size
    patch = max(4, min(w, h) // 50)
    samples: list[tuple[int, int, int]] = []
    for cx, cy in [(0, 0), (w - patch, 0), (0, h - patch), (w - patch, h - patch)]:
        region = rgb.crop((cx, cy, cx + patch, cy + patch))
        samples.append(tuple(int(v) for v in region.resize((1, 1), Image.Resampling.LANCZOS).getpixel((0, 0))))
    samples.sort(key=lambda c: c[0] + c[1] + c[2])
    return samples[len(samples) // 2]  # median-ish corner


def _subject_bbox(image: Image.Image, tolerance: int) -> Optional[tuple[int, int, int, int]]:
    """Bounding box (left, top, right, bottom) of the subject vs a near-solid background."""
    rgb = image.convert("RGB")
    bg = Image.new("RGB", rgb.size, _estimate_bg_color(rgb))
    diff = ImageChops.difference(rgb, bg)
    r, g, b = diff.split()
    per_pixel_max = ImageChops.lighter(ImageChops.lighter(r, g), b)  # strongest channel diff
    mask = per_pixel_max.point(lambda p: 255 if p >= tolerance else 0)
    return mask.getbbox()


def _reframe_to_reference(
    image: Image.Image,
    reference: Optional[Image.Image],
    target_size: tuple[int, int],
) -> Image.Image:
    """Re-crop/scale a full-body output so the subject occupies the same vertical band
    (head-top and feet-bottom margins) as the reference image — or as explicit env margins.
    Falls back to the unchanged image (at target size) if detection looks unreliable."""
    width, height = target_size
    base = image.convert("RGB")

    # 1) Determine the target vertical band (fractions of final height).
    top_frac: Optional[float] = None
    bottom_frac: Optional[float] = None
    if FRAMING_TOP_MARGIN and FRAMING_BOTTOM_MARGIN:
        try:
            top_frac = float(FRAMING_TOP_MARGIN)
            bottom_frac = 1.0 - float(FRAMING_BOTTOM_MARGIN)
        except ValueError:
            top_frac = bottom_frac = None
    if top_frac is None and reference is not None:
        ref_box = _subject_bbox(reference, SUBJECT_BG_TOLERANCE)
        if ref_box:
            top_frac = ref_box[1] / reference.height
            bottom_frac = ref_box[3] / reference.height
    if top_frac is None or bottom_frac is None:
        return _normalize_output_size(base, "1K" if target_size == TARGET_SIZES["1K"] else "2K")

    subject_frac = bottom_frac - top_frac
    if not (0.2 < subject_frac < 0.98):  # sanity: reference detection failed
        return _normalize_output_size(base, "1K" if target_size == TARGET_SIZES["1K"] else "2K")

    # 2) Find the subject in the generated image.
    gen_box = _subject_bbox(base, SUBJECT_BG_TOLERANCE)
    if not gen_box:
        return _normalize_output_size(base, "1K" if target_size == TARGET_SIZES["1K"] else "2K")
    gen_subject_h = gen_box[3] - gen_box[1]
    if gen_subject_h <= 0:
        return _normalize_output_size(base, "1K" if target_size == TARGET_SIZES["1K"] else "2K")

    # 3) Scale so the subject height matches the target band, then place it.
    scale = (subject_frac * height) / gen_subject_h
    new_w = max(1, round(base.width * scale))
    new_h = max(1, round(base.height * scale))
    scaled = base.resize((new_w, new_h), Image.Resampling.LANCZOS)

    subject_cx = ((gen_box[0] + gen_box[2]) / 2) * scale
    subject_top = gen_box[1] * scale
    paste_x = round(width / 2 - subject_cx)
    paste_y = round(top_frac * height - subject_top)

    canvas = Image.new("RGB", (width, height), _estimate_bg_color(base))
    canvas.paste(scaled, (paste_x, paste_y))
    return canvas


def _openai_size_for_model(model: str, resolution: str) -> str:
    if model == "gpt-image-2":
        return "2048x3072" if resolution == "2K" else "1024x1536"

    return "1024x1536"


def _gemini_image_config(model: str, resolution: str) -> types.ImageConfig:
    image_config = {"aspect_ratio": "2:3"}
    if model in {"gemini-3.1-flash-image-preview", "gemini-3-pro-image-preview"}:
        image_config["image_size"] = resolution
    return types.ImageConfig(**image_config)


def _compose_generation_prompt(
    category: str,
    fit: str,
    length: str,
    style: str,
    prompt: str,
    pose: str,
    total_length_cm: str,
    generation_mode: str,
    shot_type: str,
    selected_base_index: int,
    has_body_reference: bool = False,
    has_pose_reference: bool = False,
    product_count: int = 0,
) -> str:
    shot_instruction = "?꾩떊(?뺣㈃) 而ㅻ㉧??紐⑤뜽而??꾨낫瑜??앹꽦?섏꽭??"
    is_full_body = generation_mode != "shot_variant" or "전신" in shot_type or "?꾩떊" in shot_type
    if generation_mode == "shot_variant":
        shot_instruction = (
            f"?좏깮??湲곗? 而?{selected_base_index + 1}??紐⑤뜽 ?쇨뎬, ?ㅼ뼱, 泥댄삎, ?섏긽, ?됱긽, ?뚯옱, 濡쒓퀬, "
            f"?ㅻ（?ｌ? ?좎??섍퀬 ??援щ룄留?'{shot_type}'濡?蹂€寃쏀븯?몄슂. "
            "Use the selected base image reference as the source photo to transform; do not create a new unrelated model."
        )

    length_text = f"{length}, ?덉긽 珥앹옣 {total_length_cm}cm" if total_length_cm else length
    legend = _reference_legend(
        has_face=True,
        has_body=has_body_reference,
        product_count=product_count,
        has_pose=has_pose_reference,
    )
    # Proportion policy: a body reference always wins (match it). Without one, only
    # apply the idealized 8.2-8.5 head look when explicitly enabled.
    if not is_full_body:
        proportion_prompt = ""
    elif has_body_reference:
        proportion_prompt = PROPORTION_MATCH_PROMPT
    elif IDEALIZE_PROPORTIONS:
        proportion_prompt = FULL_BODY_PROPORTION_PROMPT
    else:
        proportion_prompt = ""
    return "\n".join(
        [
            "Create a high-resolution fashion ecommerce AI model photo.",
            legend,
            "CRITICAL IDENTITY LOCK: Use the face reference (image 1) as the exact persona model.",
            "All generated candidates must show the same person, not a similar-looking new model.",
            "Preserve the same face shape, jawline, eye shape, eye spacing, nose, lips, eyebrows, skin tone, and hairline from the face reference.",
            "Do not beautify, age-shift, ethnicity-shift, change makeup style, or invent a different face.",
            "If generating multiple candidates, keep the face identity identical across every candidate.",
            BODY_REFERENCE_PROMPT if has_body_reference else "",
            proportion_prompt,
            FACE_ARTIFACT_PREVENTION_PROMPT if is_full_body else "",
            FULL_BODY_FRAMING_BLOCK if is_full_body else "",
            "Preserve the original skin tone and facial exposure from the face reference. Do not whiten, pale, brighten, over-smooth, or overexpose the face.",
            shot_instruction,
            f"Garment category: {category}. Fit: {fit}. Length: {length_text}.",
            f"Style: {style}. Pose reference: {pose}.",
            STUDIO_BACKGROUND_PROMPT,
            "Use sharp fabric texture and accurate garment edges.",
            "Preserve the uploaded product image details as faithfully as possible.",
            "Do not alter logos, buttons, patterns, colors, or silhouette.",
            "Output should be suitable for a shopping mall product detail page.",
            prompt.strip(),
        ]
    ).strip()


def _compose_transform_prompt(
    shot_type: str,
    prompt: str,
    total_length_cm: str,
    selected_base_index: int,
    has_pose_reference: bool = False,
) -> str:
    is_detail = shot_type in _DETAIL_SHOTS
    is_full_body = "전신" in shot_type
    shot_instruction = SHOT_TRANSFORM_INSTRUCTIONS.get(
        shot_type, f"Create this shot composition: {shot_type}."
    )
    extra = f"Additional instruction: {prompt.strip()}" if prompt.strip() else ""
    pose_reference = (
        "A POSE/FRAMING reference image is also provided. Match its body pose, camera angle, viewing "
        "direction (front / side / back), and crop/framing as closely as possible. Take ONLY pose, angle "
        "and framing from it — identity, face, outfit, garment color and texture must come from the source "
        "(first) image, never from the pose reference."
        if has_pose_reference
        else ""
    )

    lines = [
        "Edit the FIRST image. Use it as the source photo to transform; do NOT create a new, unrelated model.",
    ]
    if is_detail:
        lines.append(
            "Keep the exact same garment color, fabric texture, material, silhouette, logos, and design as the first image."
        )
    else:
        lines.append(
            "Keep the exact same person, face, skin tone, hair style, outfit, garment color, fabric texture, "
            "silhouette, shoes, and background from the first image."
        )
        lines.append("Do not repaint the face, do not beautify, and do not change the clothing design.")
    lines.append(f"TARGET SHOT: {shot_type}.")
    lines.append(shot_instruction)
    if is_detail:
        lines.append(DETAIL_SHOT_PROMPT)
    else:
        # Person is in frame → preserve skin tone; lock scale/crop only for full-body shots.
        lines.append(SKIN_TONE_LOCK_PROMPT)
        if is_full_body:
            lines.append(FULL_BODY_FRAMING_LOCK_PROMPT)
            lines.append(FULL_BODY_FRAMING_BLOCK)
    lines.append(pose_reference)
    lines.append("Keep the edit natural and close to the source image.")
    lines.append(extra)
    return "\n".join(line for line in lines if line).strip()


def _split_provider_model(image_model: str) -> tuple[str, str]:
    if ":" not in image_model:
        return "openai", image_model

    provider, model = image_model.split(":", 1)
    return provider, model


def _resolve_model(provider: str, model: str) -> str:
    if provider == "openai":
        return os.environ.get("OPENAI_IMAGE_MODEL", model or OPENAI_DEFAULT_IMAGE_MODEL)
    if provider == "gemini":
        return os.environ.get("GEMINI_IMAGE_MODEL", model or GEMINI_DEFAULT_IMAGE_MODEL)
    return model


def _generate_with_openai(
    references: list[Optional[Image.Image]],
    model: str,
    prompt: str,
    resolution: str,
    count: int,
    request_id: str = "-",
) -> list[Image.Image]:
    if not os.environ.get("OPENAI_API_KEY"):
        raise RuntimeError("OPENAI_API_KEY is not set.")

    client = _get_openai_client()
    references = [_prepare_api_reference(image) for image in references if image is not None]
    size = _openai_size_for_model(model, resolution)
    image_files = []
    try:
        started = time.perf_counter()
        _log(
            f"openai start model={model} size={size} count={count} refs={len(references)} "
            f"ref_sizes={[f'{image.width}x{image.height}' for image in references]} prompt_chars={len(prompt)}",
            request_id,
        )
        for index, image in enumerate(references):
            payload = BytesIO(_image_to_jpeg_bytes(image))
            payload.name = f"reference_{index}.jpg"
            image_files.append(payload)

        if image_files:
            response = client.images.edit(
                model=model,
                image=image_files,
                prompt=prompt,
                size=size,
                quality="high",
                n=count,
            )
        else:
            response = client.images.generate(
                model=model,
                prompt=prompt,
                size=size,
                quality="high",
                n=count,
            )

        images = []
        for item in response.data:
            if getattr(item, "b64_json", None):
                raw = base64.b64decode(item.b64_json)
                images.append(_normalize_output_size(Image.open(BytesIO(raw)), resolution))
            elif getattr(item, "url", None):
                raise RuntimeError("OpenAI returned an image URL, but URL fetching is disabled in this container.")

        if not images:
            raise RuntimeError("OpenAI did not return image data.")
        _log(f"openai done images={len(images)} elapsed={time.perf_counter() - started:.1f}s", request_id)
        return images
    finally:
        for file in image_files:
            file.close()


def _generate_with_gemini(
    references: list[Optional[Image.Image]],
    model: str,
    prompt: str,
    resolution: str,
    count: int,
    request_id: str = "-",
) -> list[Image.Image]:
    api_key = os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY")
    if not api_key:
        raise RuntimeError("GEMINI_API_KEY or GOOGLE_API_KEY is not set.")

    client = _get_gemini_client(api_key)
    references = [_prepare_api_reference(image) for image in references if image is not None]
    contents = [*references, prompt]
    started = time.perf_counter()
    _log(
        f"gemini start model={model} count={count} refs={len(references)} "
        f"ref_sizes={[f'{image.width}x{image.height}' for image in references]} prompt_chars={len(prompt)}",
        request_id,
    )

    def _one_candidate(_index: int) -> Optional[Image.Image]:
        response = client.models.generate_content(
            model=model,
            contents=contents,
            config=types.GenerateContentConfig(
                response_modalities=["TEXT", "IMAGE"],
                image_config=_gemini_image_config(model, resolution),
            ),
        )
        parts = getattr(response, "parts", None)
        if parts is None and getattr(response, "candidates", None):
            parts = response.candidates[0].content.parts
        for part in parts or []:
            inline_data = getattr(part, "inline_data", None)
            if inline_data and inline_data.data:
                raw = inline_data.data
                if isinstance(raw, str):
                    raw = base64.b64decode(raw)
                return _normalize_output_size(Image.open(BytesIO(raw)), resolution)
        return None

    if count <= 1:
        images = [image for image in [_one_candidate(0)] if image is not None]
    else:
        # Fan out the candidate calls; executor.map preserves input order.
        with ThreadPoolExecutor(max_workers=min(count, GEN_MAX_WORKERS)) as executor:
            images = [image for image in executor.map(_one_candidate, range(count)) if image is not None]

    if not images:
        raise RuntimeError("Gemini did not return image data.")
    _log(f"gemini done images={len(images)} elapsed={time.perf_counter() - started:.1f}s", request_id)
    return images


def generate_model_cuts(
    product_images: list[Optional[Image.Image]],
    model_face: Image.Image,
    selected_reference_image: Optional[Image.Image],
    pose_reference_image: Optional[Image.Image],
    image_model: str,
    selected_product: str,
    category: str,
    fit: str,
    length: str,
    style: str,
    prompt: str,
    pose: str,
    resolution: str,
    total_length_cm: str,
    generation_mode: str,
    shot_type: str,
    shot_types: list[str],
    selected_base_index: int,
    only_selected_cut: bool,
    model_body: Optional[Image.Image] = None,
    request_id: str = "-",
) -> tuple[list[Image.Image], list[str]]:
    product_match = re.search(r"\d+", selected_product or "")
    product_index = max(0, min(3, int(product_match.group(0)) - 1 if product_match else 0))
    selected_pair = product_images[product_index * 2 : product_index * 2 + 2]
    primary_product = next((image for image in selected_pair + product_images if image is not None), None)
    length_label = f"{length} / {total_length_cm}cm" if total_length_cm else length
    provider, requested_model = _split_provider_model(image_model)
    model = _resolve_model(provider, requested_model)
    # Body-type reference: explicit upload wins, otherwise fall back to assets preset (may be None).
    body_reference = model_body or load_body_reference()
    front_products = [image for image in product_images if image is not None]
    _log(
        f"compose mode={generation_mode} provider={provider} model={model} resolution={resolution} "
        f"selected_product={selected_product} selected_pair={[_image_summary(image) for image in selected_pair]} "
        f"selected_reference={_image_summary(selected_reference_image)} pose_reference={_image_summary(pose_reference_image)} "
        f"face={_image_summary(model_face)} body_reference={_image_summary(body_reference)} "
        f"shot_type={shot_type or '-'} shot_types={shot_types or []}",
        request_id,
    )
    composed_prompt = _compose_generation_prompt(
        category=category,
        fit=fit,
        length=length,
        style=style,
        prompt=prompt,
        pose=pose,
        total_length_cm=total_length_cm,
        generation_mode=generation_mode,
        shot_type=shot_type,
        selected_base_index=selected_base_index,
        has_body_reference=body_reference is not None,
        has_pose_reference=False,
        product_count=len(front_products),
    )

    if generation_mode in {"shot_variant", "shot_batch"}:
        selected_shots = shot_types if generation_mode == "shot_batch" and shot_types else [shot_type or "?꾩떊(?먯쑀?ъ쫰)"]
        reference_face = None if selected_reference_image is not None else model_face

        def _render_shot(selected_shot: str) -> list[Image.Image]:
            # User-uploaded pose wins; otherwise load the named reference for this exact shot.
            shot_pose = pose_reference_image or load_shot_reference(selected_shot)
            # Order matters: base image first, then the pose/framing reference.
            references = [
                image
                for image in [reference_face, selected_reference_image, shot_pose]
                if image is not None
            ]
            _log(
                f"transform shot={selected_shot} refs={len(references)} "
                f"ref_sizes={[_image_summary(image) for image in references]} "
                f"pose={'upload' if pose_reference_image is not None else ('named' if shot_pose is not None else 'none')}",
                request_id,
            )
            shot_prompt = _compose_transform_prompt(
                shot_type=selected_shot,
                prompt=prompt,
                total_length_cm=total_length_cm,
                selected_base_index=selected_base_index,
                has_pose_reference=shot_pose is not None,
            )
            if provider == "openai":
                shot_images = _generate_with_openai(references, model, shot_prompt, resolution, 1, request_id)
            else:
                shot_images = _generate_with_gemini(references, model, shot_prompt, resolution, 1, request_id)
            # Crop/scale the output to match the reference's framing — except for extreme
            # garment crops (detail / close-up) where subject detection is unreliable.
            if MATCH_REFERENCE_FRAMING and shot_pose is not None and selected_shot not in _NO_REFRAME_SHOTS:
                target_size = TARGET_SIZES.get(resolution, TARGET_SIZES["1K"])
                shot_images = [_reframe_to_reference(image, shot_pose, target_size) for image in shot_images]
            return shot_images

        try:
            if provider in {"openai", "gemini"}:
                if len(selected_shots) <= 1:
                    results = [_render_shot(selected_shots[0])]
                else:
                    # Shots are independent → fan out. executor.map keeps the input order,
                    # so images stay aligned with their labels.
                    with ThreadPoolExecutor(max_workers=min(len(selected_shots), GEN_MAX_WORKERS)) as executor:
                        results = list(executor.map(_render_shot, selected_shots))
                images = [image for shot_images in results for image in shot_images]
                labels = list(selected_shots)
                return images, labels
        except Exception as error:
            if not DEMO_FALLBACK:
                raise
            print(f"Real image generation failed, using demo renderer: {error}")

    elif generation_mode in {"front_candidates", "front_candidate"}:
        front_count = 1 if generation_mode == "front_candidate" else 3
        # Reference order: face (identity) → body-type (physique) → product garments.
        front_references = [model_face]
        if body_reference is not None:
            front_references.append(body_reference)
        front_references.extend(front_products)
        try:
            if provider == "openai":
                images = _generate_with_openai(front_references, model, composed_prompt, resolution, front_count, request_id)
            elif provider == "gemini":
                images = _generate_with_gemini(front_references, model, composed_prompt, resolution, front_count, request_id)
            else:
                images = None
            if images is not None:
                # Re-crop so the subject sits in the same vertical band as the framing reference.
                # Prefer the dedicated 전신(앞면) reference, else fall back to the body reference.
                framing_ref = load_shot_reference("전신(앞면)") or body_reference
                if MATCH_REFERENCE_FRAMING and (framing_ref is not None or (FRAMING_TOP_MARGIN and FRAMING_BOTTOM_MARGIN)):
                    target_size = TARGET_SIZES.get(resolution, TARGET_SIZES["1K"])
                    reframed = [_reframe_to_reference(image, framing_ref, target_size) for image in images]
                    _log(f"reframe applied to {len(reframed)} front candidate(s) target={target_size}", request_id)
                    images = reframed
                return images, [f"전신(정면) 후보 {index + 1}" for index in range(front_count)]
        except Exception as error:
            if not DEMO_FALLBACK:
                raise
            print(f"Real image generation failed, using demo renderer: {error}")

    if generation_mode in {"shot_variant", "shot_batch"}:
        selected_shots = shot_types if generation_mode == "shot_batch" and shot_types else [shot_type or "?꾩떊(?먯쑀?ъ쫰)"]
        images = []
        labels = []
        base_label = f"?좏깮 而?{selected_base_index + 1}"
        shift_map = {
            "전신(자유포즈)": -36,
            "전신(측면)": 42,
            "전신(후면)": 0,
            "상반신": 0,
            "상반신(후면)": 18,
            "하반신": -18,
            "하반신(자유포즈)": 34,
            "디테일(상의)": 0,
            "디테일(포켓)": -22,
            "디테일(신발)": 22,
        }
        for shot_label in selected_shots:
            label = f"{shot_label} / {base_label}"
            image = _draw_model_cut(primary_product, model_face, label, resolution, shift_map.get(shot_label, 0), shot_label)
            images.append(image)
            labels.append(shot_label)
        return images, labels

    fallback_count = 1 if generation_mode == "front_candidate" else 3
    labels = [
        f"전신(정면) 후보 1 / {category} / {fit} / {length_label}",
        f"전신(정면) 후보 2 / {style}",
        f"전신(정면) 후보 3 / {pose}",
    ][:fallback_count]
    shifts = [0, -18, 18][:fallback_count]
    images = [
        _draw_model_cut(primary_product, model_face, label, resolution, shift, "전신(정면)")
        for label, shift in zip(labels, shifts)
    ]
    return images, [f"전신(정면) 후보 {index + 1}" for index in range(fallback_count)]


@app.get("/")
def index() -> FileResponse:
    return FileResponse(BASE_DIR / "index.html")


@app.get("/styles.css")
def styles() -> FileResponse:
    return FileResponse(BASE_DIR / "styles.css")


@app.get("/script.js")
def script() -> FileResponse:
    return FileResponse(BASE_DIR / "script.js")


@app.get("/model_face_preset.png")
def model_face_preset() -> Response:
    for preset_path in PRESET_FACE_CANDIDATES:
        if preset_path.exists():
            return FileResponse(preset_path)

    return Response(content=_image_to_png_bytes(_create_fallback_face()), media_type="image/png")


@app.get("/health")
def health() -> dict[str, str]:
    return {"status": "ok"}


@app.post("/api/generate")
async def generate(
    product_1_front: Optional[UploadFile] = File(None),
    product_1_back: Optional[UploadFile] = File(None),
    product_2_front: Optional[UploadFile] = File(None),
    product_2_back: Optional[UploadFile] = File(None),
    product_3_front: Optional[UploadFile] = File(None),
    product_3_back: Optional[UploadFile] = File(None),
    product_4_front: Optional[UploadFile] = File(None),
    product_4_back: Optional[UploadFile] = File(None),
    model_face: Optional[UploadFile] = File(None),
    model_body: Optional[UploadFile] = File(None),
    face_source: str = Form("첨부 얼굴 프리셋"),
    image_model: str = Form("openai:gpt-image-2"),
    selected_product: str = Form("제품 1"),
    category: str = Form("아우터"),
    fit: str = Form("표준"),
    length: str = Form("무릎"),
    style: str = Form("커머스 룩북"),
    prompt: str = Form(""),
    pose: str = Form("정면"),
    resolution: str = Form("1K"),
    total_length_cm: str = Form(""),
    generation_mode: str = Form("front_candidates"),
    shot_type: str = Form(""),
    shot_types: str = Form(""),
    selected_base_index: int = Form(0),
    selected_reference_image: Optional[UploadFile] = File(None),
    pose_reference_image: Optional[UploadFile] = File(None),
    only_selected_cut: bool = Form(False),
) -> JSONResponse:
    request_id = uuid.uuid4().hex[:8]
    request_started = time.perf_counter()
    _log(
        f"request start mode={generation_mode} shot_type={shot_type or '-'} shot_types={shot_types or '-'} "
        f"model={image_model} resolution={resolution} selected_product={selected_product}",
        request_id,
    )
    uploads = [
        product_1_front,
        product_1_back,
        product_2_front,
        product_2_back,
        product_3_front,
        product_3_back,
        product_4_front,
        product_4_back,
    ]
    product_images = [await _read_upload(upload) for upload in uploads]
    selected_reference = await _read_upload(selected_reference_image)
    pose_reference = await _read_upload(pose_reference_image)
    uploaded_face = await _read_upload(model_face)
    uploaded_body = await _read_upload(model_body)
    _log(
        f"uploads products={sum(image is not None for image in product_images)}/8 "
        f"product_sizes={[_image_summary(image) for image in product_images if image is not None]} "
        f"selected_reference={_image_summary(selected_reference)} pose_reference={_image_summary(pose_reference)} "
        f"uploaded_face={_image_summary(uploaded_face)}",
        request_id,
    )
    if face_source == "?낅줈???쇨뎬" and uploaded_face:
        selected_face = uploaded_face
    elif any(preset_path.exists() for preset_path in PRESET_FACE_CANDIDATES):
        selected_face = load_preset_face()
    elif DEMO_FALLBACK:
        selected_face = load_preset_face()
    else:
        return JSONResponse(
            {
                "error": "?섎Ⅴ?뚮굹 ?쇨뎬 ?꾨━?뗭씠 ?놁뒿?덈떎. assets/model_face_preset.png ?먮뒗 猷⑦듃 model_face_preset.png瑜??щ━嫄곕굹 ?붾㈃?먯꽌 紐⑤뜽 ?쇨뎬???낅줈?쒗븯?몄슂.",
                "provider": _split_provider_model(image_model)[0],
                "model": _resolve_model(*_split_provider_model(image_model)),
                "generation_mode": generation_mode,
                "resolution": resolution,
            },
            status_code=400,
        )
    try:
        images, labels = await asyncio.to_thread(
            generate_model_cuts,
            product_images=product_images,
            model_face=selected_face,
            selected_reference_image=selected_reference,
            pose_reference_image=pose_reference,
            image_model=image_model,
            selected_product=selected_product,
            category=category,
            fit=fit,
            length=length,
            style=style,
            prompt=prompt,
            pose=pose,
        resolution=resolution,
        total_length_cm=total_length_cm,
        generation_mode=generation_mode,
        shot_type=shot_type,
            shot_types=[item for item in shot_types.split("|") if item],
            selected_base_index=selected_base_index,
            only_selected_cut=only_selected_cut,
            model_body=uploaded_body,
            request_id=request_id,
        )
        _log(f"request done images={len(images)} labels={labels} elapsed={time.perf_counter() - request_started:.1f}s", request_id)
        asyncio.create_task(
            asyncio.to_thread(
                _upload_generation_to_dataset,
                images,
                labels,
                {
                    "kind": "generate",
                    "image_model": image_model,
                    "selected_product": selected_product,
                    "category": category,
                    "fit": fit,
                    "length": length,
                    "style": style,
                    "pose": pose,
                    "resolution": resolution,
                    "total_length_cm": total_length_cm,
                    "generation_mode": generation_mode,
                    "shot_type": shot_type,
                    "shot_types": [item for item in shot_types.split("|") if item],
                    "selected_base_index": selected_base_index,
                    "labels": labels,
                },
                request_id,
            )
        )
    except Exception as error:
        provider, requested_model = _split_provider_model(image_model)
        resolved_model = _resolve_model(provider, requested_model)
        traceback.print_exc()
        _log(f"request failed error={error} elapsed={time.perf_counter() - request_started:.1f}s", request_id)
        return JSONResponse(
            {
                "error": str(error),
                "provider": provider,
                "model": resolved_model,
                "generation_mode": generation_mode,
                "resolution": resolution,
            },
            status_code=500,
        )

    return JSONResponse({"images": [_image_to_data_url(image, resolution) for image in images], "labels": labels})


@app.post("/api/edit")
async def edit_image(
    base_image: UploadFile = File(...),
    reference_images: Optional[list[UploadFile]] = File(None),
    image_model: str = Form("openai:gpt-image-2"),
    instruction: str = Form(""),
    background: str = Form(""),
    resolution: str = Form("1K"),
) -> JSONResponse:
    try:
      base = await _read_upload(base_image)
      if base is None:
          return JSONResponse({"error": "?섏젙??湲곗? ?대?吏€媛€ ?놁뒿?덈떎."}, status_code=400)

      refs = []
      for upload in reference_images or []:
          image = await _read_upload(upload)
          if image is not None:
              refs.append(image)

      provider, requested_model = _split_provider_model(image_model)
      model = _resolve_model(provider, requested_model)
      edit_prompt = "\n".join(
          [
              "Edit this fashion model image while preserving the same model identity, outfit, garment color, fabric texture, silhouette, and product details.",
              "Only apply the requested changes. Do not change the face or clothing unless explicitly requested.",
              f"Background preset: {background or 'keep current background'}",
              f"User edit instruction: {instruction or 'Regenerate naturally with the same settings.'}",
          ]
      )

      if provider == "openai":
          images = _generate_with_openai([base, *refs], model, edit_prompt, resolution, 1)
      elif provider == "gemini":
          images = _generate_with_gemini([base, *refs], model, edit_prompt, resolution, 1)
      else:
          return JSONResponse({"error": f"吏€?먰븯吏€ ?딅뒗 provider?낅땲?? {provider}"}, status_code=400)

      edit_request_id = uuid.uuid4().hex[:8]
      asyncio.create_task(
          asyncio.to_thread(
              _upload_generation_to_dataset,
              images,
              ["수정 이미지"],
              {
                  "kind": "edit",
                  "image_model": image_model,
                  "resolution": resolution,
                  "background": background,
                  "instruction": instruction,
                  "labels": ["수정 이미지"],
              },
              edit_request_id,
          )
      )
      return JSONResponse({"images": [_image_to_data_url(image, resolution) for image in images], "labels": ["?섏젙 ?대?吏€"]})
    except Exception as error:
      provider, requested_model = _split_provider_model(image_model)
      traceback.print_exc()
      return JSONResponse(
          {
              "error": str(error),
              "provider": provider,
              "model": _resolve_model(provider, requested_model),
              "resolution": resolution,
          },
          status_code=500,
      )


if __name__ == "__main__":
    port = int(os.environ.get("PORT", "7860"))
    uvicorn.run("app:app", host="0.0.0.0", port=port)