app.py

import replicate
import requests
import os
import json
from io import BytesIO
from PIL import Image
from typing import List, Tuple, Dict
from datetime import datetime
import time
import traceback
import base64
from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.dml.color import RGBColor
from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
from pptx.enum.shapes import MSO_SHAPE
import PyPDF2
import pandas as pd
import chardet
import gradio as gr

# 예제 템플릿 정의
EXAMPLE_TOPICS = {
    "비즈니스 제안서": "AI 기반 고객 서비스 자동화 플랫폼 투자 제안",
    "제품 소개": "스마트 홈 IoT 보안 시스템 신제품 런칭",
    "프로젝트 보고": "디지털 전환 프로젝트 3분기 성과 보고",
    "전략 기획": "2025년 글로벌 시장 진출 전략 수립"
}

# 환경 변수에서 토큰 가져오기
REPLICATE_API_TOKEN = os.getenv("RAPI_TOKEN")
FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN")
BRAVE_API_TOKEN = os.getenv("BAPI_TOKEN")

# 전역 변수로 현재 슬라이드 데이터 저장
current_slides_data = []
current_topic = ""
current_template = ""
current_theme = ""

# 디자인 테마 정의
DESIGN_THEMES = {
    "미니멀 라이트": {
        "name": "Minimal Light",
        "description": "밝고 깨끗한 미니멀 디자인",
        "background": RGBColor(250, 250, 252),
        "title_color": RGBColor(33, 37, 41),
        "subtitle_color": RGBColor(52, 58, 64),
        "text_color": RGBColor(73, 80, 87),
        "accent_color": RGBColor(0, 123, 255),
        "box_fill": RGBColor(255, 255, 255),
        "box_opacity": 0.95,
        "shadow": True,
        "gradient": False
    },
    "모던 그라디언트": {
        "name": "Modern Gradient",
        "description": "부드러운 그라디언트와 현대적 느낌",
        "background": RGBColor(245, 247, 250),
        "title_color": RGBColor(25, 42, 86),
        "subtitle_color": RGBColor(68, 85, 102),
        "text_color": RGBColor(85, 102, 119),
        "accent_color": RGBColor(103, 58, 183),
        "box_fill": RGBColor(249, 250, 251),
        "box_opacity": 0.9,
        "shadow": True,
        "gradient": True
    },
    "다크 엘레강스": {
        "name": "Dark Elegance",
        "description": "세련된 다크 모드 디자인",
        "background": RGBColor(25, 25, 35),
        "title_color": RGBColor(240, 240, 245),
        "subtitle_color": RGBColor(200, 200, 210),
        "text_color": RGBColor(170, 170, 180),
        "accent_color": RGBColor(0, 188, 212),
        "box_fill": RGBColor(35, 35, 45),
        "box_opacity": 0.85,
        "shadow": False,
        "gradient": False
    },
    "네이처 그린": {
        "name": "Nature Green",
        "description": "자연 친화적인 그린 테마",
        "background": RGBColor(242, 248, 244),
        "title_color": RGBColor(27, 67, 50),
        "subtitle_color": RGBColor(45, 106, 79),
        "text_color": RGBColor(64, 125, 98),
        "accent_color": RGBColor(76, 175, 80),
        "box_fill": RGBColor(255, 255, 255),
        "box_opacity": 0.92,
        "shadow": True,
        "gradient": False
    },
    "코퍼레이트 블루": {
        "name": "Corporate Blue",
        "description": "전문적인 비즈니스 스타일",
        "background": RGBColor(244, 247, 252),
        "title_color": RGBColor(13, 71, 161),
        "subtitle_color": RGBColor(25, 118, 210),
        "text_color": RGBColor(42, 63, 84),
        "accent_color": RGBColor(33, 150, 243),
        "box_fill": RGBColor(255, 255, 255),
        "box_opacity": 0.95,
        "shadow": True,
        "gradient": False
    }
}

# 스타일 정의 (표지와 종료 슬라이드 스타일 추가)
STYLE_TEMPLATES = {
    "Title Slide (Hero)": {
        "name": "Title Slide",
        "description": "Impactful hero image for title slide",
        "use_case": "표지, 타이틀",
        "example": "A dramatic wide-angle view of a modern glass skyscraper reaching into clouds with golden sunset lighting, symbolizing growth and ambition. Ultra-realistic photography style, cinematic composition, lens flare, professional corporate aesthetic"
    },
    "Thank You Slide": {
        "name": "Closing Slide",
        "description": "Elegant closing slide design with conclusion",
        "use_case": "프레젠테이션 마무리",
        "example": "Abstract elegant background with soft gradient from deep blue to purple, golden particles floating like celebration confetti, subtle light rays, with space for conclusion text. Minimalist, professional, warm feeling"
    },
    "3D Style (Pixar-like)": {
        "name": "3D Style",
        "description": "Pixar-esque 3D render with volumetric lighting",
        "use_case": "표지, 비전, 미래 컨셉",
        "example": "A fluffy ginger cat wearing a tiny spacesuit, floating amidst a vibrant nebula in a 3D render. The cat is gazing curiously at a swirling planet with rings made of candy. Background is filled with sparkling stars and colorful gas clouds, lit with soft, volumetric lighting. Style: Pixar-esque, highly detailed, playful. Colors: Deep blues, purples, oranges, and pinks. Rendered in Octane, 8k resolution."
    },
    "Elegant SWOT Quadrant": {
        "name": "SWOT Analysis",
        "description": "Flat-design 4-grid layout with minimal shadows",
        "use_case": "현황 분석, 전략 평가",
        "example": "Elegant SWOT quadrant: flat-design 4-grid on matte-white backdrop, thin pastel separators, top-left 'Strengths' panel shows glowing shield icon and subtle motif, top-right 'Weaknesses' panel with cracked chain icon in soft crimson, bottom-left 'Opportunities' panel with sunrise-over-horizon icon in optimistic teal, bottom-right 'Threats' panel with storm-cloud & lightning icon in deep indigo, minimal shadows, no text, no watermark, 16:9, 4K"
    },
    "Colorful Mind Map": {
        "name": "Mind Map",
        "description": "Hand-drawn educational style with vibrant colors",
        "use_case": "브레인스토밍, 아이디어 정리",
        "example": "A handrawn colorful mind map diagram: educational style, vibrant colors, clear hierarchy, golden ratio layout. Central concept with branching sub-topics, each branch with unique color coding, organic flowing connections, doodle-style icons for each node"
    },
    "Business Workflow": {
        "name": "Business Process",
        "description": "End-to-end business workflow with clear phases",
        "use_case": "프로세스 설명, 단계별 진행",
        "example": "A detailed hand-drawn diagram illustrating an end-to-end business workflow with Market Analysis, Strategy Development, Product Design, Implementation, and Post-Launch Review phases. Clear directional arrows, iconography for each component, vibrant educational yet professional style"
    },
    "Industrial Design": {
        "name": "Product Design",
        "description": "Sleek industrial design concept sketch",
        "use_case": "제품 소개, 컨셉 디자인",
        "example": "A sleek industrial design concept: Curved metallic body with minimal bezel, Touchscreen panel for settings, Modern matte black finish, Hand-drawn concept sketch style with annotations and dimension lines"
    },
    "3D Bubble Chart": {
        "name": "Bubble Chart",
        "description": "Clean 3D bubble visualization",
        "use_case": "비교 분석, 포지셔닝",
        "example": "3-D bubble chart on clean white 2×2 grid, quadrant titles hidden, four translucent spheres in lime, azure, amber, magenta, gentle depth-of-field, modern consulting aesthetic, no text, 4K"
    },
    "Timeline Ribbon": {
        "name": "Timeline",
        "description": "Horizontal ribbon timeline with cyber-futuristic vibe",
        "use_case": "일정, 로드맵, 마일스톤",
        "example": "Horizontal ribbon timeline, milestone pins glowing hot pink on charcoal, year markers as circles, faint motion streaks, cyber-futuristic vibe, no text, 1920×1080"
    },
    "Risk Heat Map": {
        "name": "Heat Map",
        "description": "Risk assessment heat map with gradient colors",
        "use_case": "리스크 분석, 우선순위",
        "example": "Risk Heat Map: square grid, smooth gradient from mint to fire-red, cells beveled, simple legend strip hidden, long subtle shadow, sterile white frame, no text"
    },
    "Pyramid/Funnel": {
        "name": "Funnel Chart",
        "description": "Multi-layer gradient funnel visualization",
        "use_case": "단계별 축소, 핵심 도출",
        "example": "Pyramid / Funnel: 5-layer gradient funnel narrowing downwards, top vivid sky-blue, mid mint-green, bottom sunset-orange, glass reflection, minimal background, no text"
    },
    "KPI Dashboard": {
        "name": "Dashboard",
        "description": "Dark-mode analytics dashboard with sci-fi interface",
        "use_case": "성과 지표, 실적 대시보드",
        "example": "KPI Dashboard: Dark-mode analytic dashboard, three glass speedometers glowing neon lime, two sparkline charts under, black glass background, sci-fi interface, no text, 4K"
    },
    "Value Chain": {
        "name": "Value Chain",
        "description": "Horizontal value chain with industrial look",
        "use_case": "가치 사슬, 비즈니스 모델",
        "example": "Value Chain Diagram: Horizontal value chain blocks, steel-blue gradient bars with subtle bevel, small gear icons above each segment, sleek industrial look, shadow cast, no text"
    },
    "Gantt Chart": {
        "name": "Gantt Chart",
        "description": "Hand-drawn style Gantt chart with playful colors",
        "use_case": "프로젝트 일정, 작업 관리",
        "example": "Gantt Chart: Hand-drawn style Gantt bars sketched with vibrant markers on dotted grid notebook page, sticky-note color palette, playful yet organized, perspective tilt, no text"
    },
    "Mobile App Mockup": {
        "name": "App Mockup",
        "description": "Clean wireframe for mobile app design",
        "use_case": "앱/웹 UI, 화면 설계",
        "example": "MOCKUP DESIGN: A clean hand-drawn style wireframe for a mobile app with Title screen, Login screen, Dashboard with sections, Bottom navigation bar, minimalist design with annotations"
    },
    "Flowchart": {
        "name": "Flowchart",
        "description": "Vibrant flowchart with minimalistic icons",
        "use_case": "의사결정, 프로세스 흐름",
        "example": "FLOWCHART DESIGN: A hand-drawn style flowchart, vibrant colors, minimalistic icons showing process flow from START to END with decision points, branches, and clear directional arrows"
    }
}

# PPT 템플릿 정의 (동적으로 슬라이드 수 조정 가능)
PPT_TEMPLATES = {
    "비즈니스 제안서": {
        "description": "투자 유치, 사업 제안용",
        "core_slides": [
            {"title": "목차", "style": "Flowchart", "prompt_hint": "프레젠테이션 구조"},
            {"title": "문제 정의", "style": "Colorful Mind Map", "prompt_hint": "현재 시장의 문제점"},
            {"title": "현황 분석", "style": "Elegant SWOT Quadrant", "prompt_hint": "강점, 약점, 기회, 위협"},
            {"title": "솔루션", "style": "Industrial Design", "prompt_hint": "제품/서비스 컨셉"},
            {"title": "프로세스", "style": "Business Workflow", "prompt_hint": "실행 단계"},
            {"title": "일정", "style": "Timeline Ribbon", "prompt_hint": "주요 마일스톤"}
        ],
        "optional_slides": [
            {"title": "시장 규모", "style": "3D Bubble Chart", "prompt_hint": "시장 기회와 성장성"},
            {"title": "경쟁 분석", "style": "Risk Heat Map", "prompt_hint": "경쟁사 포지셔닝"},
            {"title": "비즈니스 모델", "style": "Value Chain", "prompt_hint": "수익 구조"},
            {"title": "팀 소개", "style": "Colorful Mind Map", "prompt_hint": "핵심 팀원과 역량"},
            {"title": "재무 계획", "style": "KPI Dashboard", "prompt_hint": "예상 매출과 손익"},
            {"title": "위험 관리", "style": "Risk Heat Map", "prompt_hint": "주요 리스크와 대응"},
            {"title": "파트너십", "style": "Business Workflow", "prompt_hint": "전략적 제휴"},
            {"title": "기술 스택", "style": "Flowchart", "prompt_hint": "핵심 기술 구조"},
            {"title": "고객 사례", "style": "Industrial Design", "prompt_hint": "성공 사례"},
            {"title": "성장 전략", "style": "Timeline Ribbon", "prompt_hint": "확장 계획"},
            {"title": "투자 활용", "style": "Pyramid/Funnel", "prompt_hint": "자금 사용 계획"},
            {"title": "Exit 전략", "style": "Timeline Ribbon", "prompt_hint": "출구 전략"}
        ]
    },
    "제품 소개": {
        "description": "신제품 런칭, 서비스 소개용",
        "core_slides": [
            {"title": "제품 컨셉", "style": "Industrial Design", "prompt_hint": "제품 디자인"},
            {"title": "사용자 니즈", "style": "Colorful Mind Map", "prompt_hint": "고객 페인포인트"},
            {"title": "기능 소개", "style": "Mobile App Mockup", "prompt_hint": "UI/UX 화면"},
            {"title": "작동 원리", "style": "Flowchart", "prompt_hint": "기능 플로우"},
            {"title": "시장 포지션", "style": "3D Bubble Chart", "prompt_hint": "경쟁사 비교"},
            {"title": "출시 일정", "style": "Timeline Ribbon", "prompt_hint": "런칭 로드맵"}
        ],
        "optional_slides": [
            {"title": "타겟 고객", "style": "Colorful Mind Map", "prompt_hint": "주요 고객층"},
            {"title": "가격 정책", "style": "Pyramid/Funnel", "prompt_hint": "가격 전략"},
            {"title": "기술 우위", "style": "Industrial Design", "prompt_hint": "핵심 기술"},
            {"title": "사용 시나리오", "style": "Business Workflow", "prompt_hint": "활용 사례"},
            {"title": "고객 후기", "style": "KPI Dashboard", "prompt_hint": "사용자 평가"},
            {"title": "판매 채널", "style": "Value Chain", "prompt_hint": "유통 전략"},
            {"title": "마케팅 전략", "style": "Timeline Ribbon", "prompt_hint": "홍보 계획"},
            {"title": "성능 비교", "style": "3D Bubble Chart", "prompt_hint": "벤치마크"}
        ]
    },
    "프로젝트 보고": {
        "description": "진행 상황, 성과 보고용",
        "core_slides": [
            {"title": "프로젝트 개요", "style": "Business Workflow", "prompt_hint": "전체 프로세스"},
            {"title": "진행 현황", "style": "Gantt Chart", "prompt_hint": "작업 일정"},
            {"title": "리스크 관리", "style": "Risk Heat Map", "prompt_hint": "위험 요소"},
            {"title": "성과 지표", "style": "KPI Dashboard", "prompt_hint": "달성 실적"},
            {"title": "향후 계획", "style": "Timeline Ribbon", "prompt_hint": "다음 단계"}
        ],
        "optional_slides": [
            {"title": "예산 현황", "style": "Pyramid/Funnel", "prompt_hint": "예산 집행"},
            {"title": "팀 성과", "style": "3D Bubble Chart", "prompt_hint": "팀별 기여도"},
            {"title": "이슈 관리", "style": "Risk Heat Map", "prompt_hint": "주요 이슈"},
            {"title": "개선 사항", "style": "Colorful Mind Map", "prompt_hint": "프로세스 개선"},
            {"title": "교훈", "style": "Business Workflow", "prompt_hint": "배운 점"}
        ]
    },
    "전략 기획": {
        "description": "중장기 전략, 비전 수립용",
        "core_slides": [
            {"title": "비전", "style": "3D Style (Pixar-like)", "prompt_hint": "미래 비전"},
            {"title": "환경 분석", "style": "Elegant SWOT Quadrant", "prompt_hint": "내외부 환경"},
            {"title": "전략 체계", "style": "Colorful Mind Map", "prompt_hint": "전략 구조"},
            {"title": "가치 사슬", "style": "Value Chain", "prompt_hint": "비즈니스 모델"},
            {"title": "실행 로드맵", "style": "Timeline Ribbon", "prompt_hint": "단계별 계획"},
            {"title": "목표 지표", "style": "KPI Dashboard", "prompt_hint": "KPI 목표"}
        ],
        "optional_slides": [
            {"title": "시장 전망", "style": "3D Bubble Chart", "prompt_hint": "미래 시장"},
            {"title": "혁신 방향", "style": "Industrial Design", "prompt_hint": "혁신 전략"},
            {"title": "조직 변화", "style": "Business Workflow", "prompt_hint": "조직 개편"},
            {"title": "디지털 전환", "style": "Flowchart", "prompt_hint": "DX 전략"},
            {"title": "지속가능성", "style": "Timeline Ribbon", "prompt_hint": "ESG 전략"}
        ]
    },
    "사용자 정의": {
        "description": "직접 구성하기",
        "core_slides": [],
        "optional_slides": []
    }
}

def brave_search(query: str) -> List[Dict]:
    """Brave Search API를 사용한 웹 검색"""
    if not BRAVE_API_TOKEN:
        print("[Brave Search] API 토큰이 없어 검색을 건너뜁니다.")
        return []
    
    print(f"[Brave Search] 검색어: {query}")
    
    headers = {
        "Accept": "application/json",
        "X-Subscription-Token": BRAVE_API_TOKEN
    }
    
    params = {
        "q": query,
        "count": 5
    }
    
    try:
        response = requests.get(
            "https://api.search.brave.com/res/v1/web/search",
            headers=headers,
            params=params,
            timeout=10
        )
        
        if response.status_code == 200:
            data = response.json()
            results = []
            for item in data.get("web", {}).get("results", [])[:3]:
                results.append({
                    "title": item.get("title", ""),
                    "description": item.get("description", ""),
                    "url": item.get("url", "")
                })
            print(f"[Brave Search] {len(results)}개 결과 획득")
            return results
        else:
            print(f"[Brave Search] 오류: {response.status_code}")
            return []
    except Exception as e:
        print(f"[Brave Search] 예외: {str(e)}")
        return []

def read_uploaded_file(file_path: str) -> str:
    """업로드된 파일 읽기 (PDF, CSV, TXT)"""
    print(f"[파일 읽기] {file_path}")
    
    try:
        # 파일 확장자 확인
        ext = os.path.splitext(file_path)[1].lower()
        
        if ext == '.pdf':
            # PDF 읽기
            with open(file_path, 'rb') as file:
                pdf_reader = PyPDF2.PdfReader(file)
                text = ""
                for page in pdf_reader.pages:
                    text += page.extract_text() + "\n"
                return text[:5000]  # 최대 5000자
                
        elif ext == '.csv':
            # CSV 읽기
            # 인코딩 감지
            with open(file_path, 'rb') as file:
                raw_data = file.read()
                result = chardet.detect(raw_data)
                encoding = result['encoding'] or 'utf-8'
            
            df = pd.read_csv(file_path, encoding=encoding)
            return f"CSV 데이터:\n{df.head(20).to_string()}\n\n요약: {len(df)} 행, {len(df.columns)} 열"
            
        elif ext in ['.txt', '.text']:
            # 텍스트 파일 읽기
            with open(file_path, 'rb') as file:
                raw_data = file.read()
                result = chardet.detect(raw_data)
                encoding = result['encoding'] or 'utf-8'
            
            with open(file_path, 'r', encoding=encoding) as file:
                return file.read()[:5000]  # 최대 5000자
        else:
            return "지원하지 않는 파일 형식입니다."
            
    except Exception as e:
        return f"파일 읽기 오류: {str(e)}"

def generate_presentation_notes(topic: str, slide_title: str, content: Dict) -> str:
    """각 슬라이드의 발표자 노트 생성 (구어체)"""
    print(f"[발표자 노트] {slide_title} 생성 중...")
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = """You are a professional presentation coach who creates natural, conversational speaker notes.

The slide content uses concise noun-ending style, but your speaker notes should be natural and conversational.

Create speaker notes that:
1. Sound natural and conversational, as if speaking to an audience
2. Expand on the concise bullet points with additional context
3. Include transitions and engagement phrases
4. Use a warm, professional tone
5. Be 100-150 words long
6. Include pauses and emphasis markers where appropriate

Note: The bullet points may include emojis - incorporate their meaning into your speech.

Format:
- Use conversational language
- Include transition phrases
- Add engagement questions or comments
- Keep it professional but friendly"""
    
    bullet_text = "\n".join(content.get("bullet_points", []))
    user_message = f"""Topic: {topic}
Slide Title: {slide_title}
Subtitle: {content.get('subtitle', '')}
Key Points (concise style with emojis):
{bullet_text}

Create natural speaker notes that expand on these concise points for presenting this slide."""
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": system_prompt
            },
            {
                "role": "user",
                "content": user_message
            }
        ],
        "max_tokens": 300,
        "temperature": 0.8,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            notes = result['choices'][0]['message']['content'].strip()
            
            # 한글 주제인 경우 번역
            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
                notes = translate_content_to_korean_natural(notes)
            
            return notes
        else:
            return "이 슬라이드에서는 핵심 내용을 설명해 주세요."
    except Exception as e:
        print(f"[발표자 노트] 오류: {str(e)}")
        return "이 슬라이드에서는 핵심 내용을 설명해 주세요."

def regenerate_slide_text(topic: str, slide_title: str, slide_context: str, 
                         user_instruction: str, uploaded_content: str = None) -> Dict[str, str]:
    """사용자 지시사항에 따라 슬라이드 텍스트 재생성"""
    print(f"[AI 재작성] {slide_title} - 지시사항: {user_instruction}")
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = """You are a professional presentation content writer. 
Follow the user's specific instructions to rewrite slide content.

Your task is to create:
1. A compelling subtitle (max 10 words)
2. Exactly 5 bullet points with emojis
3. Each bullet point should be 8-12 words
4. Use noun-ending style (명사형 종결) for Korean or concise fragments for English

IMPORTANT Style Guidelines:
- End sentences with nouns or concise phrases
- Avoid long verb endings like "입니다", "습니다"
- Use short endings like "임", "함" or noun forms
- Start each bullet with a relevant emoji
- Follow the user's instructions while maintaining this style

Emoji Guidelines:
- Professional emojis: 📊 🎯 💡 🚀 ⚡ 🔍 📈 💰 🏆 🔧 🌐 🔐 ⭐ 🎨 📱 🤝 📍 🎪 🏗️ 🌱
- Match emoji to content meaning
- Use different emojis for variety"""
    
    user_message = f"""Topic: {topic}
Slide Title: {slide_title}
Context: {slide_context}

User's specific instruction: {user_instruction}

Rewrite the content following the instruction above while maintaining concise, noun-ending style with emojis."""
    
    if uploaded_content:
        user_message += f"\n\nReference Material:\n{uploaded_content[:1000]}"
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": system_prompt
            },
            {
                "role": "user",
                "content": user_message
            }
        ],
        "max_tokens": 300,
        "temperature": 0.8,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            content = result['choices'][0]['message']['content'].strip()
            
            # Parse content
            lines = content.split('\n')
            subtitle = ""
            bullet_points = []
            
            for line in lines:
                if line.startswith("Subtitle:"):
                    subtitle = line.replace("Subtitle:", "").strip()
                elif line.strip().startswith("•"):
                    bullet_points.append(line.strip())
            
            # 한글로 번역이 필요한 경우
            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
                subtitle = translate_content_to_korean(subtitle)
                # 불릿 포인트는 이모지를 유지하면서 번역
                translated_bullets = []
                for point in bullet_points:
                    # 이모지와 텍스트 분리
                    parts = point.split(' ', 2)
                    if len(parts) >= 3 and len(parts[1]) <= 2:  # 이모지가 있는 경우
                        emoji = parts[1]
                        text = ' '.join(parts[2:])
                        translated_text = translate_content_to_korean_concise(text)
                        translated_bullets.append(f"• {emoji} {translated_text}")
                    else:
                        translated_bullets.append(translate_content_to_korean_concise(point))
                bullet_points = translated_bullets
            
            return {
                "subtitle": subtitle,
                "bullet_points": bullet_points[:5]
            }
        else:
            return {
                "subtitle": slide_title,
                "bullet_points": ["• ❌ 재생성 실패"] * 5
            }
    except Exception as e:
        print(f"[AI 재작성] 오류: {str(e)}")
        return {
            "subtitle": slide_title,
            "bullet_points": ["• ❌ 재생성 오류"] * 5
        }

def generate_closing_notes(topic: str, conclusion_phrase: str) -> str:
    """마지막 슬라이드의 발표자 노트 생성"""
    print(f"[마무리 노트] 생성 중...")
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = """You are a professional presentation coach creating closing speaker notes.

Create natural closing remarks that:
1. Thank the audience warmly
2. Briefly summarize the key message of the presentation
3. Reference the conclusion phrase naturally
4. End with an invitation for questions or next steps
5. Be 80-100 words long
6. Sound conversational and warm
7. NO stage directions or parentheses - only spoken words

Write only what the speaker would say out loud."""
    
    user_message = f"""Presentation topic: {topic}
Conclusion phrase on screen: {conclusion_phrase}

Create natural closing speaker notes that wrap up the presentation effectively."""
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": system_prompt
            },
            {
                "role": "user",
                "content": user_message
            }
        ],
        "max_tokens": 200,
        "temperature": 0.8,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            notes = result['choices'][0]['message']['content'].strip()
            
            # 한글 주제인 경우 번역
            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
                notes = translate_content_to_korean_natural(notes)
            
            return notes
        else:
            return "오늘 발표를 마무리하며 감사의 말씀을 드립니다. 질문이 있으시면 편하게 말씀해 주세요."
    except Exception as e:
        print(f"[마무리 노트] 오류: {str(e)}")
        return "오늘 발표를 마무리하며 감사의 말씀을 드립니다. 질문이 있으시면 편하게 말씀해 주세요."

def generate_conclusion_phrase(topic: str) -> str:
    """프레젠테이션의 핵심을 담은 결론 문구 생성"""
    print(f"[결론 문구] 생성 중...")
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = """You are a professional copywriter creating powerful closing statements for presentations.

Create a concise, impactful closing phrase that:
1. Captures the essence of the presentation topic
2. Is memorable and inspirational
3. Maximum 5-7 words
4. Uses powerful, action-oriented language
5. Leaves a lasting impression

Examples:
- "Innovation Starts Today"
- "Together We Transform"
- "Future Begins Now"
- "Excellence Through Innovation"

Output only the phrase, no explanation."""
    
    user_message = f"""Presentation topic: {topic}

Create a powerful closing phrase that encapsulates the main message."""
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": system_prompt
            },
            {
                "role": "user",
                "content": user_message
            }
        ],
        "max_tokens": 50,
        "temperature": 0.9,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            phrase = result['choices'][0]['message']['content'].strip()
            
            # 한글 주제인 경우 번역
            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
                phrase = translate_content_to_korean_concise(phrase)
            
            return phrase
        else:
            return "함께 만드는 미래"
    except Exception as e:
        print(f"[결론 문구] 오류: {str(e)}")
        return "함께 만드는 미래"

def generate_slide_content(topic: str, slide_title: str, slide_context: str, uploaded_content: str = None, web_search_results: List[Dict] = None) -> Dict[str, str]:
    """각 슬라이드의 텍스트 내용 생성"""
    print(f"[슬라이드 내용] {slide_title} 텍스트 생성 중...")
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = """You are a professional presentation content writer specializing in creating concise, impactful slide content.

Your task is to create:
1. A compelling subtitle (max 10 words)
2. Exactly 5 bullet points with emojis
3. Each bullet point should be 8-12 words
4. Use noun-ending style (명사형 종결) for Korean or concise fragments for English

IMPORTANT Style Guidelines:
- End sentences with nouns or concise phrases (예: "전략적 확대", "핵심 과제", "주요 목표")
- Avoid long verb endings like "입니다", "습니다"
- Use short endings like "임", "함" or noun forms
- Start each bullet with a relevant emoji that represents the content
- Be extremely concise and impactful

Emoji Guidelines:
- Use professional emojis that match the content
- Common emojis: 
  📊 (data/analysis), 🎯 (goals/targets), 💡 (innovation/ideas), 
  🚀 (growth/launch), ⚡ (speed/efficiency), 🔍 (research/analysis),
  📈 (increase/growth), 💰 (finance/revenue), 🏆 (achievement/success),
  🔧 (tools/solutions), 🌐 (global/network), 🔐 (security/safety),
  ⭐ (excellence/quality), 🎨 (creative/design), 📱 (mobile/tech),
  🤝 (partnership/collaboration), 📍 (location/focus), 🎖️ (strategy),
  🏗️ (building/development), 🌱 (sustainability/growth)
- Each bullet should have a different, relevant emoji

Output format:
Subtitle: [subtitle here]
• 🎯 [Point 1 - noun ending or fragment]
• 📊 [Point 2 - noun ending or fragment]
• 💡 [Point 3 - noun ending or fragment]
• 🚀 [Point 4 - noun ending or fragment]
• ⚡ [Point 5 - noun ending or fragment]"""
    
    user_message = f"""Topic: {topic}
Slide Title: {slide_title}
Context: {slide_context}"""
    
    # 업로드된 콘텐츠가 있으면 추가
    if uploaded_content:
        user_message += f"\n\nReference Material:\n{uploaded_content[:1000]}"
    
    # 웹 검색 결과가 있으면 추가
    if web_search_results:
        search_context = "\n\nWeb Search Results:\n"
        for result in web_search_results[:3]:
            search_context += f"- {result['title']}: {result['description']}\n"
        user_message += search_context
    
    user_message += "\n\nCreate compelling content for this presentation slide. Remember to use emojis and concise noun-ending style."
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": system_prompt
            },
            {
                "role": "user",
                "content": user_message
            }
        ],
        "max_tokens": 300,
        "top_p": 0.8,
        "temperature": 0.7,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            content = result['choices'][0]['message']['content'].strip()
            
            # Parse content
            lines = content.split('\n')
            subtitle = ""
            bullet_points = []
            
            for line in lines:
                if line.startswith("Subtitle:"):
                    subtitle = line.replace("Subtitle:", "").strip()
                elif line.strip().startswith("•"):
                    bullet_points.append(line.strip())
            
            # 한글로 번역이 필요한 경우
            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
                subtitle = translate_content_to_korean(subtitle)
                # 불릿 포인트는 이모지를 유지하면서 번역
                translated_bullets = []
                for point in bullet_points:
                    # 이모지와 텍스트 분리
                    parts = point.split(' ', 2)
                    if len(parts) >= 3 and len(parts[1]) <= 2:  # 이모지가 있는 경우
                        emoji = parts[1]
                        text = ' '.join(parts[2:])
                        translated_text = translate_content_to_korean_concise(text)
                        translated_bullets.append(f"• {emoji} {translated_text}")
                    else:
                        translated_bullets.append(translate_content_to_korean_concise(point))
                bullet_points = translated_bullets
            
            return {
                "subtitle": subtitle,
                "bullet_points": bullet_points[:5]  # 최대 5개
            }
        else:
            return {
                "subtitle": slide_title,
                "bullet_points": ["• 📌 내용 생성 불가"] * 5
            }
    except Exception as e:
        print(f"[슬라이드 내용] 오류: {str(e)}")
        return {
            "subtitle": slide_title,
            "bullet_points": ["• ❌ 내용 생성 오류"] * 5
        }

def translate_content_to_korean(text: str) -> str:
    """영어 텍스트를 한글로 번역 (일반용)"""
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": "You are a translator. Translate the given English text to Korean. Maintain professional business tone. Only return the translation without any explanation."
            },
            {
                "role": "user",
                "content": text
            }
        ],
        "max_tokens": 200,
        "top_p": 0.8,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            return result['choices'][0]['message']['content'].strip()
        else:
            return text
    except Exception as e:
        return text

def translate_content_to_korean_concise(text: str) -> str:
    """영어 텍스트를 간결한 한글로 번역 (명사형 종결)"""
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": """You are a translator specializing in concise Korean business presentations. 
Translate to Korean using noun-ending style (명사형 종결어미).
End with "임", "함", or noun forms instead of "입니다", "습니다".
Keep it extremely concise and professional.
Examples: "전략적 확대", "핵심 과제 도출", "시장 선도 전략 수립"
Only return the translation without any explanation."""
            },
            {
                "role": "user",
                "content": text
            }
        ],
        "max_tokens": 200,
        "top_p": 0.8,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            return result['choices'][0]['message']['content'].strip()
        else:
            return text
    except Exception as e:
        return text

def translate_content_to_korean_natural(text: str) -> str:
    """영어 텍스트를 자연스러운 한글로 번역 (발표 노트용)"""
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": """You are a translator. Translate the given English text to natural, conversational Korean. 
Use polite spoken language suitable for presentations.
Only return the translation without any explanation."""
            },
            {
                "role": "user",
                "content": text
            }
        ],
        "max_tokens": 300,
        "top_p": 0.8,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            return result['choices'][0]['message']['content'].strip()
        else:
            return text
    except Exception as e:
        return text

def generate_prompt_with_llm(topic: str, style_example: str = None, slide_context: str = None, uploaded_content: str = None) -> str:
    """주제와 스타일 예제를 받아서 LLM을 사용해 이미지 프롬프트를 생성"""
    print(f"[LLM] 프롬프트 생성 시작: {slide_context}")
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = """You are an expert image prompt engineer specializing in creating prompts for professional presentation slides. 

Your task is to create prompts that:
1. Are highly specific and visual, perfect for PPT backgrounds or main visuals
2. Consider the slide's purpose and maintain consistency across a presentation
3. Include style references matching the given example
4. Focus on clean, professional visuals that won't distract from text overlays
5. Ensure high contrast areas for text readability when needed
6. Maintain brand consistency and professional aesthetics

Important guidelines:
- If given a style example, adapt the topic to match that specific visual style
- Consider the slide context (e.g., "표지", "현황 분석") to create appropriate visuals
- Always output ONLY the prompt without any explanation
- Keep prompts between 50-150 words for optimal results
- Ensure the visual supports rather than overwhelms the slide content"""
    
    user_message = f"Topic: {topic}"
    if style_example:
        user_message += f"\n\nStyle reference to follow:\n{style_example}"
    if slide_context:
        user_message += f"\n\nSlide context: {slide_context}"
    if uploaded_content:
        user_message += f"\n\nAdditional context from document:\n{uploaded_content[:500]}"
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": system_prompt
            },
            {
                "role": "user",
                "content": user_message
            }
        ],
        "max_tokens": 300,
        "top_p": 0.8,
        "temperature": 0.7,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            prompt = result['choices'][0]['message']['content'].strip()
            print(f"[LLM] 프롬프트 생성 완료: {prompt[:50]}...")
            return prompt
        else:
            error_msg = f"프롬프트 생성 실패: {response.status_code}"
            print(f"[LLM] {error_msg}")
            return error_msg
    except Exception as e:
        error_msg = f"프롬프트 생성 중 오류 발생: {str(e)}"
        print(f"[LLM] {error_msg}")
        return error_msg

def translate_to_english(text: str) -> str:
    """한글 텍스트를 영어로 번역 (LLM 사용)"""
    if not any(ord('가') <= ord(char) <= ord('힣') for char in text):
        return text
    
    print(f"[번역] 한글 감지, 영어로 번역 시작")
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "dep89a2fld32mcm",
        "messages": [
            {
                "role": "system",
                "content": "You are a translator. Translate the given Korean text to English. Only return the translation without any explanation."
            },
            {
                "role": "user",
                "content": text
            }
        ],
        "max_tokens": 500,
        "top_p": 0.8,
        "stream": False
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)
        if response.status_code == 200:
            result = response.json()
            translated = result['choices'][0]['message']['content'].strip()
            print(f"[번역] 완료")
            return translated
        else:
            print(f"[번역] 실패, 원본 사용")
            return text
    except Exception as e:
        print(f"[번역] 오류: {str(e)}, 원본 사용")
        return text

def generate_image(prompt: str, seed: int = 10, slide_info: str = "") -> Tuple[Image.Image, str]:
    """Replicate API를 사용해 이미지 생성"""
    print(f"\n[이미지 생성] {slide_info}")
    print(f"[이미지 생성] 프롬프트: {prompt[:50]}...")
    
    try:
        english_prompt = translate_to_english(prompt)
        
        if not REPLICATE_API_TOKEN:
            error_msg = "RAPI_TOKEN 환경변수가 설정되지 않았습니다."
            print(f"[이미지 생성] 오류: {error_msg}")
            return None, error_msg
        
        print(f"[이미지 생성] Replicate API 호출 중...")
        client = replicate.Client(api_token=REPLICATE_API_TOKEN)
        
        input_params = {
            "seed": seed,
            "prompt": english_prompt,
            "speed_mode": "Extra Juiced 🚀 (even more speed)",
            "output_quality": 100
        }
        
        start_time = time.time()
        output = client.run(
            "prunaai/hidream-l1-fast:17c237d753218fed0ed477cb553902b6b75735f48c128537ab829096ef3d3645",
            input=input_params
        )
        
        elapsed = time.time() - start_time
        print(f"[이미지 생성] API 응답 받음 ({elapsed:.1f}초)")
        
        if output:
            if isinstance(output, str) and output.startswith('http'):
                print(f"[이미지 생성] URL에서 이미지 다운로드 중...")
                response = requests.get(output, timeout=30)
                img = Image.open(BytesIO(response.content))
                print(f"[이미지 생성] 완료!")
                return img, english_prompt
            else:
                print(f"[이미지 생성] 바이너리 데이터 처리 중...")
                img = Image.open(BytesIO(output.read()))
                print(f"[이미지 생성] 완료!")
                return img, english_prompt
        else:
            error_msg = "이미지 생성 실패 - 빈 응답"
            print(f"[이미지 생성] {error_msg}")
            return None, error_msg
            
    except Exception as e:
        error_msg = f"오류: {str(e)}"
        print(f"[이미지 생성] {error_msg}")
        print(f"[이미지 생성] 상세 오류:\n{traceback.format_exc()}")
        return None, error_msg

def create_slide_preview_html(slide_data: Dict) -> str:
    """16:9 비율의 슬라이드 프리뷰 HTML 생성 (둥근 모서리와 입체감)"""
    
    # 이미지를 base64로 인코딩
    img_base64 = ""
    if slide_data.get("image"):
        buffered = BytesIO()
        slide_data["image"].save(buffered, format="PNG")
        img_base64 = base64.b64encode(buffered.getvalue()).decode()
    
    # 텍스트 내용 가져오기
    subtitle = slide_data.get("subtitle", "")
    bullet_points = slide_data.get("bullet_points", [])
    
    # HTML 생성
    html = f"""
    <div class="slide-container" style="
        width: 100%;
        max-width: 1200px;
        margin: 20px auto;
        background: white;
        border-radius: 12px;
        box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
        overflow: hidden;
    ">
        <div class="slide-header" style="
            background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
            color: white;
            padding: 15px 30px;
            font-size: 18px;
            font-weight: bold;
        ">
            슬라이드 {slide_data.get('slide_number', '')}: {slide_data.get('title', '')}
        </div>
        
        <div class="slide-content" style="
            display: flex;
            height: 0;
            padding-bottom: 56.25%; /* 16:9 비율 */
            position: relative;
            background: #fafbfc;
        ">
            <div class="slide-inner" style="
                position: absolute;
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
                display: flex;
                padding: 20px;
                gap: 20px;
            ">
    """
    
    # 표지와 마지막 슬라이드는 전체 화면 이미지
    if slide_data.get('title') in ['표지', 'Thank You']:
        html += f"""
                <!-- 전체 화면 이미지 -->
                <div style="
                    width: 100%;
                    height: 100%;
                    position: relative;
                    background: #e9ecef;
                    border-radius: 12px;
                    overflow: hidden;
                ">
        """
        
        if img_base64:
            html += f"""
                    <img src="data:image/png;base64,{img_base64}" style="
                        width: 100%;
                        height: 100%;
                        object-fit: cover;
                    " alt="Slide Image">
                    <div style="
                        position: absolute;
                        top: 50%;
                        left: 50%;
                        transform: translate(-50%, -50%);
                        text-align: center;
                        background: rgba(255, 255, 255, 0.9);
                        padding: 30px 60px;
                        border-radius: 20px;
                        box-shadow: 0 10px 40px rgba(0,0,0,0.3);
                        backdrop-filter: blur(10px);
                    ">
            """
            
            if slide_data.get('title') == '표지':
                html += f"""
                        <h1 style="font-size: 48px; margin-bottom: 10px; color: #000000; font-weight: 700;">{slide_data.get('topic', '')}</h1>
                        <h2 style="font-size: 24px; margin-top: 0; color: #212529; font-weight: 400;">{subtitle}</h2>
                """
            else:  # Thank You
                html += f"""
                        <h1 style="font-size: 42px; color: #000000; font-weight: 700; line-height: 1.2;">{subtitle}</h1>
                """
            
            html += """
                    </div>
            """
        
        html += """
                </div>
        """
    else:
        # 일반 슬라이드 레이아웃
        html += f"""
                <!-- 텍스트 영역 (좌측) -->
                <div class="text-area" style="
                    flex: 1;
                    padding: 30px;
                    display: flex;
                    flex-direction: column;
                    justify-content: center;
                    background: rgba(255, 255, 255, 0.95);
                    border-radius: 12px;
                    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.08);
                ">
                    <h2 style="
                        color: #212529;
                        font-size: 28px;
                        margin-bottom: 30px;
                        font-weight: 600;
                    ">{subtitle}</h2>
                    
                    <ul style="
                        list-style: none;
                        padding: 0;
                        margin: 0;
                    ">
        """
        
        for point in bullet_points:
            clean_point = point.replace('•', '').strip()
            html += f"""
                        <li style="
                            margin-bottom: 16px;
                            padding-left: 28px;
                            position: relative;
                            color: #495057;
                            font-size: 16px;
                            line-height: 1.6;
                        ">
                            <span style="
                                position: absolute;
                                left: 0;
                                color: #007bff;
                                font-size: 18px;
                            ">•</span>
                            {clean_point}
                        </li>
            """
        
        html += f"""
                    </ul>
                </div>
                
                <!-- 이미지 영역 (우측) -->
                <div class="image-area" style="
                    flex: 1;
                    background: rgba(248, 249, 250, 0.9);
                    border-radius: 12px;
                    display: flex;
                    align-items: center;
                    justify-content: center;
                    padding: 20px;
                    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.05);
                ">
        """
        
        if img_base64:
            html += f"""
                    <img src="data:image/png;base64,{img_base64}" style="
                        max-width: 100%;
                        max-height: 100%;
                        object-fit: contain;
                        border-radius: 8px;
                        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
                    " alt="Slide Image">
            """
        else:
            html += """
                    <div style="
                        color: #6c757d;
                        text-align: center;
                    ">
                        <div style="font-size: 48px;">🖼️</div>
                        <p>이미지 생성 중...</p>
                    </div>
            """
        
        html += """
                </div>
        """
    
    html += """
            </div>
        </div>
    </div>
    """
    
    return html

def create_final_pptx_with_edits(results: List[Dict], topic: str, template_name: str, 
                                 theme_name: str, edited_data: Dict = None) -> str:
    """편집된 내용을 반영한 최종 PPTX 파일 생성"""
    print("[PPTX] 편집된 내용으로 최종 파일 생성 중...")
    
    # 편집된 데이터가 있으면 결과에 반영
    if edited_data:
        for slide_index, edits in edited_data.items():
            if slide_index < len(results):
                results[slide_index]["slide_data"].update(edits)
    
    # 기존 create_pptx_file 함수 호출
    return create_pptx_file(results, topic, template_name, theme_name)

def create_pptx_file(results: List[Dict], topic: str, template_name: str, theme_name: str = "미니멀 라이트") -> str:
    """생성된 결과를 PPTX 파일로 변환 (발표자 노트 포함)"""
    print(f"[PPTX] 파일 생성 시작... 테마: {theme_name}")
    
    # 프레젠테이션 생성 (16:9 비율)
    prs = Presentation()
    prs.slide_width = Inches(16)
    prs.slide_height = Inches(9)
    
    # 선택된 테마 가져오기
    theme = DESIGN_THEMES.get(theme_name, DESIGN_THEMES["미니멀 라이트"])
    
    # 각 결과 슬라이드 추가
    for i, result in enumerate(results):
        if not result.get("success", False):
            continue
            
        slide_data = result.get("slide_data", {})
        
        # 빈 레이아웃 사용 (제목 플레이스홀더 없는 완전한 빈 슬라이드)
        blank_layout = prs.slide_layouts[6]  # 완전히 빈 레이아웃
        slide = prs.slides.add_slide(blank_layout)
        
        # 표지 슬라이드
        if slide_data.get('title') == '표지':
            # 배경 이미지 추가
            if slide_data.get('image'):
                try:
                    img_buffer = BytesIO()
                    slide_data['image'].save(img_buffer, format='PNG')
                    img_buffer.seek(0)
                    
                    # 전체 화면 배경 이미지
                    pic = slide.shapes.add_picture(
                        img_buffer, 
                        0, 0,
                        width=prs.slide_width, 
                        height=prs.slide_height
                    )
                    # 맨 뒤로 보내기
                    slide.shapes._spTree.remove(pic._element)
                    slide.shapes._spTree.insert(2, pic._element)
                except Exception as e:
                    print(f"[PPTX] 표지 이미지 추가 실패: {str(e)}")
            
            # 제목 배경 박스 (반투명 - 더 밝고 투명하게)
            title_bg = slide.shapes.add_shape(
                MSO_SHAPE.ROUNDED_RECTANGLE,
                Inches(2), Inches(2.8),
                Inches(12), Inches(3.2)
            )
            title_bg.fill.solid()
            title_bg.fill.fore_color.rgb = RGBColor(255, 255, 255)  # 흰색 배경
            title_bg.fill.transparency = 0.2  # 20% 투명도 (80% 불투명)
            title_bg.line.fill.background()
            
            # 그림자 효과 추가 (더 강하게)
            shadow = title_bg.shadow
            shadow.visible = True
            shadow.distance = Pt(8)
            shadow.size = 120
            shadow.blur_radius = Pt(15)
            shadow.transparency = 0.3
            shadow.angle = 45
            
            # 제목 텍스트 추가
            title_box = slide.shapes.add_textbox(
                Inches(2), Inches(3.2), 
                Inches(12), Inches(1.5)
            )
            title_frame = title_box.text_frame
            title_frame.text = topic
            title_para = title_frame.paragraphs[0]
            title_para.font.size = Pt(48)
            title_para.font.bold = True
            title_para.font.color.rgb = RGBColor(0, 0, 0)  # 완전한 검정색
            title_para.alignment = PP_ALIGN.CENTER
            
            # 부제목 추가 (제목과 가까이)
            subtitle_box = slide.shapes.add_textbox(
                Inches(2), Inches(4.3), 
                Inches(12), Inches(1.0)
            )
            subtitle_frame = subtitle_box.text_frame
            subtitle_frame.text = slide_data.get('subtitle', f'{template_name} - AI 프레젠테이션')
            subtitle_para = subtitle_frame.paragraphs[0]
            subtitle_para.font.size = Pt(28)  # 24에서 28로 증가
            subtitle_para.font.color.rgb = RGBColor(33, 37, 41)  # 진한 회색
            subtitle_para.alignment = PP_ALIGN.CENTER
            
        # Thank You 슬라이드
        elif slide_data.get('title') == 'Thank You':
            # 배경 이미지 추가
            if slide_data.get('image'):
                try:
                    img_buffer = BytesIO()
                    slide_data['image'].save(img_buffer, format='PNG')
                    img_buffer.seek(0)
                    
                    # 전체 화면 배경 이미지
                    pic = slide.shapes.add_picture(
                        img_buffer, 
                        0, 0,
                        width=prs.slide_width, 
                        height=prs.slide_height
                    )
                    # 맨 뒤로 보내기
                    slide.shapes._spTree.remove(pic._element)
                    slide.shapes._spTree.insert(2, pic._element)
                except Exception as e:
                    print(f"[PPTX] Thank You 이미지 추가 실패: {str(e)}")
            
            # Thank You 배경 박스 (반투명 - 더 밝고 투명하게)
            thanks_bg = slide.shapes.add_shape(
                MSO_SHAPE.ROUNDED_RECTANGLE,
                Inches(2), Inches(3.5),
                Inches(12), Inches(2.5)
            )
            thanks_bg.fill.solid()
            thanks_bg.fill.fore_color.rgb = RGBColor(255, 255, 255)  # 흰색 배경
            thanks_bg.fill.transparency = 0.2  # 20% 투명도
            thanks_bg.line.fill.background()
            
            # 그림자 효과 추가 (더 강하게)
            shadow = thanks_bg.shadow
            shadow.visible = True
            shadow.distance = Pt(8)
            shadow.size = 120
            shadow.blur_radius = Pt(15)
            shadow.transparency = 0.3
            shadow.angle = 45
            
            # Thank You 텍스트 (결론 문구)
            thanks_box = slide.shapes.add_textbox(
                Inches(2), Inches(4), 
                Inches(12), Inches(1.5)
            )
            thanks_frame = thanks_box.text_frame
            thanks_frame.text = slide_data.get('subtitle', 'Thank You')  # 결론 문구 사용
            thanks_para = thanks_frame.paragraphs[0]
            thanks_para.font.size = Pt(42)  # 크기를 조금 줄임
            thanks_para.font.bold = True
            thanks_para.font.color.rgb = RGBColor(0, 0, 0)  # 완전한 검정색
            thanks_para.alignment = PP_ALIGN.CENTER
            
        # 일반 슬라이드
        else:
            # 배경색 설정
            background = slide.background
            fill = background.fill
            fill.solid()
            fill.fore_color.rgb = theme["background"]
            
            # 슬라이드 제목 배경 박스 (둥근 모서리 효과)
            title_box_bg = slide.shapes.add_shape(
                MSO_SHAPE.ROUNDED_RECTANGLE,
                Inches(0.3), Inches(0.2),
                Inches(15.4), Inches(1.0)
            )
            title_box_bg.fill.solid()
            title_box_bg.fill.fore_color.rgb = theme["box_fill"]
            title_box_bg.fill.transparency = 1 - theme["box_opacity"]
            
            # 그림자 효과
            if theme["shadow"]:
                shadow = title_box_bg.shadow
                shadow.visible = True
                shadow.distance = Pt(4)
                shadow.size = 100
                shadow.blur_radius = Pt(8)
                shadow.transparency = 0.75
                shadow.angle = 45
            
            title_box_bg.line.fill.background()  # 테두리 없음
            
            # 슬라이드 제목 추가
            title_box = slide.shapes.add_textbox(
                Inches(0.5), Inches(0.3), 
                Inches(15), Inches(0.8)
            )
            title_frame = title_box.text_frame
            title_frame.text = f"{slide_data.get('title', '')}"
            title_para = title_frame.paragraphs[0]
            title_para.font.size = Pt(28)
            title_para.font.bold = True
            title_para.font.color.rgb = theme["title_color"]
            
            # 좌측 텍스트 영역 배경 박스
            text_box_bg = slide.shapes.add_shape(
                MSO_SHAPE.ROUNDED_RECTANGLE,
                Inches(0.3), Inches(1.4),
                Inches(7.8), Inches(6.8)
            )
            text_box_bg.fill.solid()
            text_box_bg.fill.fore_color.rgb = theme["box_fill"]
            text_box_bg.fill.transparency = 1 - theme["box_opacity"]
            
            if theme["shadow"]:
                shadow = text_box_bg.shadow
                shadow.visible = True
                shadow.distance = Pt(5)
                shadow.size = 100
                shadow.blur_radius = Pt(10)
                shadow.transparency = 0.7
                shadow.angle = 45
            
            text_box_bg.line.fill.background()
            
            # 좌측 텍스트 영역
            text_box = slide.shapes.add_textbox(
                Inches(0.8), Inches(1.8),
                Inches(7.0), Inches(6.0)
            )
            text_frame = text_box.text_frame
            text_frame.word_wrap = True
            
            # 소제목 추가
            subtitle_para = text_frame.paragraphs[0]
            subtitle_para.text = slide_data.get('subtitle', '')
            subtitle_para.font.size = Pt(20)
            subtitle_para.font.bold = True
            subtitle_para.font.color.rgb = theme["subtitle_color"]
            subtitle_para.space_after = Pt(20)
            
            # 불릿 포인트 추가
            bullet_points = slide_data.get('bullet_points', [])
            for point in bullet_points:
                p = text_frame.add_paragraph()
                # • 제거하고 텍스트만 추가 (이모지는 유지)
                clean_text = point.replace('•', '').strip()
                p.text = clean_text
                p.font.size = Pt(16)
                p.font.color.rgb = theme["text_color"]
                # 불릿 없이 들여쓰기만
                p.level = 0
                p.space_after = Pt(12)
                p.line_spacing = 1.5
                # 왼쪽 여백 설정
                p.left_indent = Pt(0)
                
                # 불릿 색상
                p.font.color.rgb = theme["text_color"]
            
            # 우측 이미지 영역 배경 박스
            img_box_bg = slide.shapes.add_shape(
                MSO_SHAPE.ROUNDED_RECTANGLE,
                Inches(8.3), Inches(1.4),
                Inches(7.4), Inches(6.8)
            )
            img_box_bg.fill.solid()
            img_box_bg.fill.fore_color.rgb = RGBColor(248, 249, 250)
            img_box_bg.fill.transparency = 0.1
            
            if theme["shadow"]:
                shadow = img_box_bg.shadow
                shadow.visible = True
                shadow.distance = Pt(5)
                shadow.size = 100
                shadow.blur_radius = Pt(10)
                shadow.transparency = 0.7
                shadow.angle = 45
            
            img_box_bg.line.fill.background()
            
            # 우측 이미지 추가
            if slide_data.get('image'):
                try:
                    img_buffer = BytesIO()
                    slide_data['image'].save(img_buffer, format='PNG')
                    img_buffer.seek(0)
                    
                    pic = slide.shapes.add_picture(
                        img_buffer, 
                        Inches(8.5), Inches(1.6),
                        width=Inches(6.8), height=Inches(6.4)
                    )
                    
                    # 이미지 테두리 제거
                    pic.line.fill.background()
                    
                except Exception as e:
                    print(f"[PPTX] 이미지 추가 실패: {str(e)}")
            
            # 페이지 번호 추가
            page_num = slide.shapes.add_textbox(
                Inches(15), Inches(8.5),
                Inches(1), Inches(0.5)
            )
            page_frame = page_num.text_frame
            page_frame.text = str(i + 1)
            page_para = page_frame.paragraphs[0]
            page_para.font.size = Pt(12)
            page_para.font.color.rgb = theme["text_color"]
            page_para.alignment = PP_ALIGN.RIGHT
        
        # 발표자 노트 추가
        notes_slide = slide.notes_slide
        notes_slide.notes_text_frame.text = slide_data.get('speaker_notes', '')
    
    # 파일 저장
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"presentation_{timestamp}.pptx"
    filepath = os.path.join("/tmp", filename)
    prs.save(filepath)
    
    print(f"[PPTX] 파일 생성 완료: {filename}")
    return filepath

def generate_dynamic_slides(topic: str, template: Dict, slide_count: int) -> List[Dict]:
    """선택된 슬라이드 수에 따라 동적으로 슬라이드 구성"""
    core_slides = template.get("core_slides", [])
    optional_slides = template.get("optional_slides", [])
    
    # 표지와 Thank You를 제외한 본문 슬라이드 수
    content_slide_count = slide_count
    
    # 코어 슬라이드가 요청된 수보다 많으면 조정
    if len(core_slides) > content_slide_count:
        selected_slides = core_slides[:content_slide_count]
    else:
        # 코어 슬라이드 + 옵셔널 슬라이드에서 선택
        selected_slides = core_slides.copy()
        remaining = content_slide_count - len(core_slides)
        
        if remaining > 0 and optional_slides:
            # 옵셔널 슬라이드에서 추가 선택
            additional = optional_slides[:remaining]
            selected_slides.extend(additional)
    
    # 표지 추가 (맨 앞)
    slides = [{"title": "표지", "style": "Title Slide (Hero)", "prompt_hint": "프레젠테이션 표지"}]
    
    # 본문 슬라이드 추가
    slides.extend(selected_slides)
    
    # Thank You 슬라이드 추가 (맨 뒤)
    slides.append({"title": "Thank You", "style": "Thank You Slide", "prompt_hint": "프레젠테이션 마무리와 핵심 메시지"})
    
    return slides

def create_editable_slide_interface(slide_data: Dict, slide_index: int, topic: str) -> str:
    """편집 가능한 슬라이드 인터페이스 생성"""
    
    # 이미지를 base64로 인코딩
    img_base64 = ""
    if slide_data.get("image"):
        buffered = BytesIO()
        slide_data["image"].save(buffered, format="PNG")
        img_base64 = base64.b64encode(buffered.getvalue()).decode()
    
    # 텍스트 내용 가져오기
    subtitle = slide_data.get("subtitle", "")
    bullet_points = slide_data.get("bullet_points", [])
    
    # 표지와 Thank You는 편집 불가
    if slide_data.get('title') in ['표지', 'Thank You']:
        return create_slide_preview_html(slide_data)
    
    # HTML 생성
    html = f"""
    <div class="slide-container" id="slide_container_{slide_index}" style="
        width: 100%;
        max-width: 1200px;
        margin: 20px auto;
        background: white;
        border-radius: 12px;
        box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
        overflow: hidden;
    ">
        <div class="slide-header" style="
            background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
            color: white;
            padding: 15px 30px;
            font-size: 18px;
            font-weight: bold;
            display: flex;
            justify-content: space-between;
            align-items: center;
        ">
            <span>슬라이드 {slide_data.get('slide_number', '')}: {slide_data.get('title', '')}</span>
            <button id="edit_btn_{slide_index}" style="
                background: #3498db;
                color: white;
                border: none;
                padding: 5px 15px;
                border-radius: 5px;
                cursor: pointer;
                font-size: 14px;
            ">✏️ 편집</button>
        </div>
        
        <div class="slide-content" style="
            display: flex;
            min-height: 400px;
            background: #fafbfc;
            position: relative;
        ">
            <div class="slide-inner" style="
                width: 100%;
                display: flex;
                padding: 20px;
                gap: 20px;
            ">
                <!-- 텍스트 영역 (좌측) -->
                <div class="text-area" style="
                    flex: 1;
                    padding: 30px;
                    background: rgba(255, 255, 255, 0.95);
                    border-radius: 12px;
                    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.08);
                ">
                    <div id="view_mode_{slide_index}" style="display: block;">
                        <h2 style="
                            color: #212529;
                            font-size: 28px;
                            margin-bottom: 30px;
                            font-weight: 600;
                        ">{subtitle}</h2>
                        
                        <ul style="
                            list-style: none;
                            padding: 0;
                            margin: 0;
                        ">
    """
    
    for point in bullet_points:
        clean_point = point.replace('•', '').strip()
        html += f"""
                            <li style="
                                margin-bottom: 16px;
                                padding-left: 28px;
                                position: relative;
                                color: #495057;
                                font-size: 16px;
                                line-height: 1.6;
                            ">
                                <span style="
                                    position: absolute;
                                    left: 0;
                                    color: #007bff;
                                    font-size: 18px;
                                ">•</span>
                                {clean_point}
                            </li>
        """
    
    html += f"""
                        </ul>
                    </div>
                    
                    <!-- 편집 모드 -->
                    <div id="edit_mode_{slide_index}" style="display: none;">
                        <input type="text" id="subtitle_{slide_index}" value="{subtitle}" style="
                            width: 100%;
                            font-size: 24px;
                            font-weight: 600;
                            margin-bottom: 20px;
                            padding: 10px;
                            border: 2px solid #e9ecef;
                            border-radius: 5px;
                        " placeholder="소제목 입력">
                        
                        <div style="margin-bottom: 20px;">
    """
    
    for i, point in enumerate(bullet_points):
        # 이모지를 포함한 전체 텍스트 (• 제거)
        clean_point = point.replace('•', '').strip()
        html += f"""
                            <input type="text" id="bullet_{slide_index}_{i}" value="{clean_point}" style="
                                width: 100%;
                                margin-bottom: 10px;
                                padding: 8px 8px 8px 25px;
                                border: 1px solid #e9ecef;
                                border-radius: 5px;
                                font-size: 16px;
                            " placeholder="예: 🎯 포인트 {i+1}">
        """
    
    html += f"""
                        </div>
                        
                        <div style="
                            background: #f3e5f5;
                            border-radius: 8px;
                            padding: 15px;
                            margin-top: 20px;
                        ">
                            <h4 style="margin-bottom: 10px; color: #7b1fa2;">🤖 AI로 다시 작성하기</h4>
                            <textarea id="instruction_{slide_index}" style="
                                width: 100%;
                                height: 60px;
                                padding: 10px;
                                border: 2px solid #e1bee7;
                                border-radius: 5px;
                                font-size: 14px;
                                resize: vertical;
                                background: white;
                            " placeholder="예: 더 전문적으로, 숫자와 통계 포함, 더 간단하게, 임팩트 있게"></textarea>
                            <button id="ai_btn_{slide_index}" style="
                                background: #9b59b6;
                                color: white;
                                border: none;
                                padding: 8px 20px;
                                border-radius: 5px;
                                cursor: pointer;
                                margin-top: 10px;
                                font-size: 14px;
                            ">🔄 AI 새로 작성</button>
                        </div>
                        
                        <div style="margin-top: 20px;">
                            <button id="save_btn_{slide_index}" style="
                                background: #27ae60;
                                color: white;
                                border: none;
                                padding: 8px 20px;
                                border-radius: 5px;
                                cursor: pointer;
                                margin-right: 10px;
                            ">저장</button>
                            <button id="cancel_btn_{slide_index}" style="
                                background: #95a5a6;
                                color: white;
                                border: none;
                                padding: 8px 20px;
                                border-radius: 5px;
                                cursor: pointer;
                            ">취소</button>
                        </div>
                    </div>
                </div>
                
                <!-- 이미지 영역 (우측) -->
                <div class="image-area" style="
                    flex: 1;
                    background: rgba(248, 249, 250, 0.9);
                    border-radius: 12px;
                    display: flex;
                    align-items: center;
                    justify-content: center;
                    padding: 20px;
                    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.05);
                ">
    """
    
    if img_base64:
        html += f"""
                    <img src="data:image/png;base64,{img_base64}" style="
                        max-width: 100%;
                        max-height: 100%;
                        object-fit: contain;
                        border-radius: 8px;
                        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
                    " alt="Slide Image">
        """
    
    html += f"""
                </div>
            </div>
        </div>
    </div>
    
    <script>
        // 즉시 실행 함수로 스코프 분리
        (function() {{
            const slideIndex = {slide_index};
            
            // DOM이 준비되면 실행
            setTimeout(function() {{
                const viewMode = document.getElementById('view_mode_' + slideIndex);
                const editMode = document.getElementById('edit_mode_' + slideIndex);
                const editBtn = document.getElementById('edit_btn_' + slideIndex);
                const saveBtn = document.getElementById('save_btn_' + slideIndex);
                const cancelBtn = document.getElementById('cancel_btn_' + slideIndex);
                const aiBtn = document.getElementById('ai_btn_' + slideIndex);
                
                if (editBtn) {{
                    editBtn.onclick = function(e) {{
                        e.preventDefault();
                        e.stopPropagation();
                        viewMode.style.display = 'none';
                        editMode.style.display = 'block';
                        return false;
                    }};
                }}
                
                if (saveBtn) {{
                    saveBtn.onclick = function(e) {{
                        e.preventDefault();
                        e.stopPropagation();
                        const subtitle = document.getElementById('subtitle_' + slideIndex).value;
                        const bullets = [];
                        for (let i = 0; i < 5; i++) {{
                            const bullet = document.getElementById('bullet_' + slideIndex + '_' + i);
                            if (bullet && bullet.value) {{
                                let bulletText = bullet.value.trim();
                                if (!bulletText.startsWith('•')) {{
                                    bulletText = '• ' + bulletText;
                                }}
                                bullets.push(bulletText);
                            }}
                        }}
                        
                        window.savedSlideData = window.savedSlideData || {{}};
                        window.savedSlideData[slideIndex] = {{
                            subtitle: subtitle,
                            bullet_points: bullets
                        }};
                        
                        // 뷰 모드 업데이트
                        const h2 = viewMode.querySelector('h2');
                        if (h2) h2.textContent = subtitle;
                        
                        const ul = viewMode.querySelector('ul');
                        if (ul) {{
                            ul.innerHTML = bullets.map(b => `
                                <li style="margin-bottom: 16px; padding-left: 28px; position: relative; color: #495057; font-size: 16px; line-height: 1.6;">
                                    <span style="position: absolute; left: 0; color: #007bff; font-size: 18px;">•</span>
                                    ${{b.replace('•', '').trim()}}
                                </li>
                            `).join('');
                        }}
                        
                        viewMode.style.display = 'block';
                        editMode.style.display = 'none';
                        return false;
                    }};
                }}
                
                if (cancelBtn) {{
                    cancelBtn.onclick = function(e) {{
                        e.preventDefault();
                        e.stopPropagation();
                        viewMode.style.display = 'block';
                        editMode.style.display = 'none';
                        return false;
                    }};
                }}
                
                if (aiBtn) {{
                    aiBtn.onclick = function(e) {{
                        e.preventDefault();
                        e.stopPropagation();
                        const instruction = document.getElementById('instruction_' + slideIndex).value;
                        if (instruction) {{
                            window.aiRegenerateRequest = {{
                                slideIndex: slideIndex,
                                instruction: instruction,
                                topic: "{topic}"
                            }};
                            alert('AI 재생성이 요청되었습니다. 실제 구현에서는 서버와 통신합니다.');
                        }}
                        return false;
                    }};
                }}
            }}, 100);
        }})();
    </script>
    """
    
    return html

def generate_ppt_with_content(topic: str, template_name: str, custom_slides: List[Dict], 
                             slide_count: int, seed: int, uploaded_file, 
                             use_web_search: bool, theme_name: str = "미니멀 라이트", 
                             progress=gr.Progress()):
    """PPT 이미지와 텍스트 내용을 함께 생성 (발표자 노트 포함)"""
    results = []
    preview_html = ""
    
    # 업로드된 파일 내용 읽기
    uploaded_content = ""
    if uploaded_file is not None:
        try:
            uploaded_content = read_uploaded_file(uploaded_file.name)
            print(f"[파일 업로드] 내용 길이: {len(uploaded_content)}자")
        except Exception as e:
            print(f"[파일 업로드] 오류: {str(e)}")
            uploaded_content = ""
    
    # 템플릿 선택 및 슬라이드 구성
    if template_name == "사용자 정의" and custom_slides:
        slides = [{"title": "표지", "style": "Title Slide (Hero)", "prompt_hint": "프레젠테이션 표지"}]
        slides.extend(custom_slides)
        slides.append({"title": "Thank You", "style": "Thank You Slide", "prompt_hint": "프레젠테이션 마무리와 핵심 메시지"})
    else:
        template = PPT_TEMPLATES[template_name]
        slides = generate_dynamic_slides(topic, template, slide_count)
    
    if not slides:
        yield "", "슬라이드가 정의되지 않았습니다.", None
        return
    
    total_slides = len(slides)
    print(f"\n[PPT 생성] 시작 - 총 {total_slides}개 슬라이드 (표지 + 본문 {slide_count} + Thank You)")
    print(f"[PPT 생성] 주제: {topic}")
    print(f"[PPT 생성] 템플릿: {template_name}")
    print(f"[PPT 생성] 디자인 테마: {theme_name}")
    print(f"[PPT 생성] 웹 검색: {'사용' if use_web_search else '미사용'}")
    
    # 웹 검색 실행 (선택된 경우)
    web_search_results = []
    if use_web_search and BRAVE_API_TOKEN:
        progress(0.05, "웹 검색 중...")
        web_search_results = brave_search(topic)
    
    # CSS 스타일 추가
    preview_html = """
    <style>
        .slides-container {
            width: 100%;
            max-width: 1400px;
            margin: 0 auto;
        }
    </style>
    <div class="slides-container">
    """
    
    # 각 슬라이드 순차 처리
    for i, slide in enumerate(slides):
        progress((i + 1) / (total_slides + 1), f"슬라이드 {i+1}/{total_slides} 처리 중...")
        
        slide_info = f"슬라이드 {i+1}: {slide['title']}"
        
        # 텍스트 내용 생성
        slide_context = f"{slide['title']} - {slide.get('prompt_hint', '')}"
        
        # Thank You 슬라이드는 결론 문구 생성
        if slide['title'] == 'Thank You':
            conclusion_phrase = generate_conclusion_phrase(topic)
            content = {
                "subtitle": conclusion_phrase,
                "bullet_points": []
            }
            # Thank You 슬라이드용 특별 노트
            speaker_notes = generate_closing_notes(topic, conclusion_phrase)
        else:
            content = generate_slide_content(
                topic, slide['title'], slide_context, 
                uploaded_content, web_search_results
            )
            # 일반 슬라이드 발표자 노트
            speaker_notes = generate_presentation_notes(topic, slide['title'], content)
        
        # 프롬프트 생성 및 이미지 생성
        style_key = slide["style"]
        if style_key in STYLE_TEMPLATES:
            style_info = STYLE_TEMPLATES[style_key]
            prompt = generate_prompt_with_llm(
                topic, style_info["example"], 
                slide_context, uploaded_content
            )
            
            # 이미지 생성
            slide_seed = seed + i
            img, used_prompt = generate_image(prompt, slide_seed, slide_info)
            
            # 슬라이드 데이터 구성
            slide_data = {
                "slide_number": i + 1,
                "title": slide["title"],
                "subtitle": content["subtitle"],
                "bullet_points": content["bullet_points"],
                "image": img,
                "style": style_info["name"],
                "speaker_notes": speaker_notes,
                "topic": topic  # 표지용
            }
            
            # 프리뷰 HTML 생성 (편집 가능한 인터페이스)
            if slide_data.get('title') not in ['표지', 'Thank You']:
                preview_html += create_editable_slide_interface(slide_data, i, topic)
            else:
                preview_html += create_slide_preview_html(slide_data)
            
            # 현재까지의 상태 업데이트
            yield preview_html + "</div>", f"### 🔄 {slide_info} 생성 중...", None
            
            results.append({
                "slide_data": slide_data,
                "success": img is not None
            })
    
    # PPTX 파일 생성
    progress(0.95, "PPTX 파일 생성 중...")
    pptx_path = None
    try:
        pptx_path = create_pptx_file(results, topic, template_name, theme_name)
    except Exception as e:
        print(f"[PPTX] 파일 생성 오류: {str(e)}")
    
    # 최종 결과에 편집 가능한 슬라이드 데이터 저장
    preview_html += """
    <div style="margin: 40px auto; max-width: 1200px; text-align: center; padding: 30px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; box-shadow: 0 10px 30px rgba(0,0,0,0.3);">
        <h3 style="color: white; margin-bottom: 20px;">✨ 모든 편집이 완료되었나요?</h3>
        <button id="finalDownloadBtn" onclick="prepareFinalDownload()" style="
            background: white;
            color: #667eea;
            border: none;
            padding: 18px 50px;
            border-radius: 50px;
            cursor: pointer;
            font-size: 20px;
            font-weight: bold;
            box-shadow: 0 5px 15px rgba(0,0,0,0.3);
            transition: all 0.3s ease;
        " onmouseover="this.style.transform='scale(1.05)'" onmouseout="this.style.transform='scale(1)'">
            💾 편집 내용 반영하여 최종 다운로드
        </button>
        <p style="color: white; margin-top: 15px; font-size: 14px;">
            💡 편집한 내용이 최종 PPT에 반영됩니다
        </p>
    </div>
    
    <script>
        function prepareFinalDownload() {
            // 편집된 모든 데이터 수집
            alert('편집된 내용을 반영한 최종 PPT를 다운로드합니다.');
            // 실제 구현에서는 Gradio 이벤트로 처리
        }
    </script>
    """
    
    preview_html += "</div>"
    progress(1.0, "완료!")
    successful = sum(1 for r in results if r["success"])
    final_status = f"### 🎉 생성 완료! 총 {total_slides}개 슬라이드 중 {successful}개 성공"
    
    # 편집 가능한 슬라이드 데이터를 전역 변수로 저장
    global current_slides_data, current_topic, current_template, current_theme
    current_slides_data = results
    current_topic = topic
    current_template = template_name
    current_theme = theme_name
    
    if pptx_path:
        final_status += f"\n\n### 📥 PPTX 파일이 준비되었습니다!"
        final_status += f"\n\n💡 **각 슬라이드를 편집한 후 '편집 완료 후 최종 다운로드' 버튼을 클릭하세요**"
        final_status += f"\n\n🎤 **발표자 노트가 각 슬라이드에 포함되어 있습니다!**"
    
    yield preview_html, final_status, pptx_path

def create_custom_slides_ui():
    """사용자 정의 슬라이드 구성 UI (3-20장)"""
    slides = []
    for i in range(20):  # 최대 20장
        with gr.Row(visible=(i < 3)):  # 기본 3장만 표시
            with gr.Column(scale=2):
                title = gr.Textbox(
                    label=f"슬라이드 {i+1} 제목",
                    placeholder="예: 현황 분석, 솔루션, 로드맵...",
                )
            with gr.Column(scale=3):
                style = gr.Dropdown(
                    choices=list(STYLE_TEMPLATES.keys()),
                    label=f"스타일 선택",
                    value="Colorful Mind Map"
                )
            with gr.Column(scale=3):
                hint = gr.Textbox(
                    label=f"프롬프트 힌트",
                    placeholder="이 슬라이드에서 표현하고 싶은 내용"
                )
        slides.append({"title": title, "style": style, "hint": hint, "row": gr.Row})
    return slides

# Gradio 인터페이스 생성
with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft(), css="""
    .preview-container { max-width: 1400px; margin: 0 auto; }
    .slide-container { transition: all 0.3s ease; }
    .slide-container:hover { transform: translateY(-2px); box-shadow: 0 12px 24px rgba(0, 0, 0, 0.15) !important; }
    input[type="text"], textarea { transition: all 0.3s ease; }
    input[type="text"]:focus, textarea:focus { border-color: #3498db !important; outline: none; box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.2); }
    button { 
        transition: all 0.3s ease; 
        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif; 
        cursor: pointer !important; 
        user-select: none;
        -webkit-user-select: none;
    }
    button:hover { transform: translateY(-1px); box-shadow: 0 4px 8px rgba(0,0,0,0.2); opacity: 0.9; }
    button:active { transform: translateY(0); }
    .edit-mode { background: #f8f9fa; padding: 20px; border-radius: 8px; }
    .ai-instruction { background: #f3e5f5; padding: 15px; border-radius: 8px; margin-top: 15px; }
""") as demo:
    gr.Markdown("""
    # 🎯 AI 기반 PPT 통합 생성기 (간결한 스타일 버전)
    
    ### 텍스트와 이미지가 완벽하게 조화된 프레젠테이션을 자동으로 생성하고 편집 후 다운로드하세요!
    
    #### 🆕 새로운 기능:
    - 📝 **간결한 명사형 텍스트**: "~임", "~함" 스타일의 프로페셔널한 문체
    - 🎨 **이모지 자동 추가**: 각 포인트별 적절한 이모지로 시각적 구분
    - ✏️ **슬라이드 텍스트 편집**: 생성된 각 슬라이드의 텍스트를 직접 수정
    - 🤖 **AI 재작성**: 지시사항을 입력하면 AI가 텍스트를 다시 작성
    - 📋 **예제 템플릿**: 버튼 클릭으로 예제 주제 불러오기
    - 🎨 **디자인 테마**: 5가지 전문적인 디자인 테마 선택 가능
    - 💎 **개선된 표지 디자인**: 반투명 배경과 선명한 텍스트
    - 📊 **표지와 Thank You 슬라이드** 자동 추가
    - 📝 **발표자 노트** 자동 생성 (구어체)
    - 📁 **파일 업로드** 지원 (PDF/CSV/TXT)
    - 🔍 **웹 검색** 기능 (Brave Search)
    - 🎚️ **슬라이드 수 조절** (6-20장)
    """)
    
    # API 토큰 상태 확인
    token_status = []
    if not REPLICATE_API_TOKEN:
        token_status.append("⚠️ RAPI_TOKEN 환경 변수가 설정되지 않았습니다.")
    if not FRIENDLI_TOKEN:
        token_status.append("⚠️ FRIENDLI_TOKEN 환경 변수가 설정되지 않았습니다.")
    if not BRAVE_API_TOKEN:
        token_status.append("ℹ️ BAPI_TOKEN이 없어 웹 검색 기능이 비활성화됩니다.")
    
    if token_status:
        gr.Markdown("\n".join(token_status))
    
    with gr.Row():
        with gr.Column(scale=1):
            # 예제 선택
            with gr.Row():
                example_btn = gr.Button("📋 예제 불러오기", size="sm", variant="secondary")
                
            # 기본 입력
            topic_input = gr.Textbox(
                label="프레젠테이션 주제",
                placeholder="예: AI 스타트업 투자 유치, 신제품 런칭, 디지털 전환 전략",
                lines=2
            )
            
            # PPT 템플릿 선택
            template_select = gr.Dropdown(
                choices=list(PPT_TEMPLATES.keys()),
                label="PPT 템플릿 선택",
                value="비즈니스 제안서",
                info="목적에 맞는 템플릿을 선택하세요"
            )
            
            # 디자인 테마 선택
            theme_select = gr.Dropdown(
                choices=list(DESIGN_THEMES.keys()),
                label="디자인 테마 선택",
                value="미니멀 라이트",
                info="프레젠테이션의 전체적인 디자인 스타일"
            )
            
            # 테마 미리보기
            theme_preview = gr.HTML()
            
            # 슬라이드 수 선택
            slide_count = gr.Slider(
                minimum=6,
                maximum=20,
                value=8,
                step=1,
                label="본문 슬라이드 수 (표지와 Thank You 제외)",
                info="생성할 본문 슬라이드 수를 선택하세요"
            )
            
            # 파일 업로드
            file_upload = gr.File(
                label="참고 자료 업로드 (선택)",
                file_types=[".pdf", ".csv", ".txt"],
                type="filepath",
                value=None
            )
            
            # 웹 검색 옵션
            use_web_search = gr.Checkbox(
                label="웹 검색 사용",
                value=False,
                info="Brave Search를 사용하여 최신 정보 반영"
            )
            
            # 템플릿 설명
            template_info = gr.Markdown()
            
            # 시드 값
            seed_input = gr.Slider(
                minimum=1,
                maximum=100,
                value=10,
                step=1,
                label="시드 값"
            )
            
            generate_btn = gr.Button("🚀 PPT 생성 시작 (AI가 모든 내용을 자동 생성)", variant="primary", size="lg")
            
            # 사용 방법 안내
            with gr.Accordion("📖 사용 방법", open=False):
                gr.Markdown("""
                ### 🔄 작업 순서:
                1. **예제 불러오기** 버튼으로 샘플 주제를 로드하거나 직접 입력
                2. **템플릿과 테마 선택** 후 생성 버튼 클릭
                3. **각 슬라이드 편집**: ✏️ 편집 버튼으로 텍스트 수정
                4. **AI 재작성**: 지시사항 입력 후 AI로 다시 작성
                5. **최종 다운로드**: 편집 완료 후 다운로드
                
                ### 💡 텍스트 스타일 특징:
                - **간결한 명사형 종결**: "~임", "~함" 또는 명사로 끝남
                - **이모지 활용**: 각 포인트 앞에 내용 관련 이모지 자동 추가
                - **8-12단어**: 각 불릿 포인트는 매우 간결하게 구성
                
                **스타일 예시:**
                - ❌ "시장 점유율을 확대하기 위한 전략을 수립합니다"
                - ✅ "🎯 시장 점유율 확대 전략 수립"
                - ❌ "AI 기술을 활용하여 효율성을 향상시킵니다"
                - ✅ "🚀 AI 기술 활용한 효율성 극대화"
                
                ### 🤖 AI 재작성 팁:
                - "더 간단하게": 핵심만 남기고 축약
                - "숫자 포함": 구체적 수치나 통계 추가
                - "전문적으로": 업계 전문 용어 사용
                - "임팩트 있게": 강조점과 핵심 성과 부각
                """)
            
            # PPTX 다운로드 영역
            with gr.Row():
                download_file = gr.File(
                    label="📥 생성된 PPTX 파일 다운로드",
                    visible=True,
                    elem_id="download-file"
                )
            
            # 사용자 정의 섹션
            with gr.Accordion("📝 사용자 정의 슬라이드 구성", open=False) as custom_accordion:
                gr.Markdown("템플릿을 사용하지 않고 직접 슬라이드를 구성하세요. (3-20장)")
                
                # 사용자 정의 슬라이드 수 선택
                custom_slide_count = gr.Slider(
                    minimum=3,
                    maximum=20,
                    value=3,
                    step=1,
                    label="사용자 정의 슬라이드 수"
                )
                
                custom_slides_components = create_custom_slides_ui()
    
    # 상태 표시
    status_output = gr.Markdown(
        value="### 👆 템플릿을 선택하고 생성 버튼을 클릭하세요!"
    )
    
    # 프리뷰 영역
    preview_output = gr.HTML(
        label="PPT 프리뷰 (16:9)",
        elem_classes="preview-container"
    )
    
    # 이벤트 핸들러
    def load_example(template_name):
        """템플릿에 맞는 예제 주제 로드"""
        example_topic = EXAMPLE_TOPICS.get(template_name, "")
        return example_topic
    
    def update_theme_preview(theme_name):
        """테마 미리보기 HTML 생성"""
        theme = DESIGN_THEMES.get(theme_name, DESIGN_THEMES["미니멀 라이트"])
        
        # RGB 값을 hex로 변환
        def rgb_to_hex(rgb_color):
            return f"#{rgb_color[0]:02x}{rgb_color[1]:02x}{rgb_color[2]:02x}"
        
        bg_hex = rgb_to_hex(theme["background"])
        box_hex = rgb_to_hex(theme["box_fill"])
        title_hex = rgb_to_hex(theme["title_color"])
        text_hex = rgb_to_hex(theme["text_color"])
        accent_hex = rgb_to_hex(theme["accent_color"])
        
        preview_html = f"""
        <div style="
            background: {bg_hex};
            padding: 20px;
            border-radius: 8px;
            margin: 10px 0;
        ">
            <div style="
                background: {box_hex};
                opacity: {theme['box_opacity']};
                padding: 15px;
                border-radius: 12px;
                margin-bottom: 10px;
                {'box-shadow: 0 4px 8px rgba(0,0,0,0.1);' if theme['shadow'] else ''}
            ">
                <h4 style="color: {title_hex}; margin: 0 0 10px 0;">{theme['name']}</h4>
                <p style="color: {text_hex}; margin: 0; font-size: 14px;">
                    {theme['description']}
                </p>
                <div style="
                    width: 40px;
                    height: 4px;
                    background: {accent_hex};
                    margin-top: 10px;
                    border-radius: 2px;
                "></div>
            </div>
        </div>
        """
        return preview_html
    
    def update_template_info(template_name, slide_count):
        if template_name in PPT_TEMPLATES:
            template = PPT_TEMPLATES[template_name]
            info = f"**{template['description']}**\n\n"
            
            # 동적으로 생성될 슬라이드 구성 표시
            slides = generate_dynamic_slides("", template, slide_count)
            info += f"생성될 슬라이드 ({len(slides)}장):\n"
            for i, slide in enumerate(slides):
                style_info = STYLE_TEMPLATES.get(slide['style'], {})
                info += f"{i+1}. {slide['title']} - {style_info.get('use_case', '')}\n"
            
            return info
        return ""
    
    def update_custom_slides_visibility(count):
        """사용자 정의 슬라이드 수에 따라 UI 표시/숨김"""
        updates = []
        for i in range(20):
            updates.extend([
                gr.update(visible=(i < count)),  # title
                gr.update(visible=(i < count)),  # style
                gr.update(visible=(i < count))   # hint
            ])
        return updates
    
    def generate_ppt_handler(topic, template_name, theme_name, slide_count, seed, file_upload, 
                           use_web_search, custom_slide_count, progress=gr.Progress(), 
                           *custom_inputs):
        if not topic.strip():
            yield "", "❌ 주제를 입력해주세요.", None
            return
        
        # 사용자 정의 슬라이드 처리
        custom_slides = []
        if template_name == "사용자 정의":
            for i in range(0, custom_slide_count * 3, 3):
                if i < len(custom_inputs):
                    title = custom_inputs[i]
                    style = custom_inputs[i+1] if i+1 < len(custom_inputs) else None
                    hint = custom_inputs[i+2] if i+2 < len(custom_inputs) else ""
                    
                    if title and style:
                        custom_slides.append({
                            "title": title,
                            "style": style,
                            "prompt_hint": hint
                        })
        
        # PPT 생성
        for preview, status, pptx_file in generate_ppt_with_content(
            topic, template_name, custom_slides, slide_count, seed, 
            file_upload, use_web_search, theme_name, progress
        ):
            yield preview, status, pptx_file
    
    # 이벤트 연결
# --- 이벤트 연결 -------------------------------------------------
    example_btn.click(
        fn=load_example,
        inputs=[template_select],
        outputs=[topic_input]
    )

    theme_select.change(
        fn=update_theme_preview,
        inputs=[theme_select],
        outputs=[theme_preview]
    )

    template_select.change(
        fn=update_template_info,
        inputs=[template_select, slide_count],
        outputs=[template_info]
    )

    slide_count.change(
        fn=update_template_info,
        inputs=[template_select, slide_count],
        outputs=[template_info]
    )

    custom_slide_count.change(
        fn=update_custom_slides_visibility,
        inputs=[custom_slide_count],
        outputs=[
            comp
            for slide in custom_slides_components
            for comp in (slide["title"], slide["style"], slide["hint"])
        ]
    )

    # 사용자 정의 슬라이드 입력 컴포넌트 평탄화
    all_custom_inputs = []
    for slide in custom_slides_components:
        all_custom_inputs.extend([slide["title"], slide["style"], slide["hint"]])

    generate_btn.click(
        fn=generate_ppt_handler,
        inputs=[
            topic_input,
            template_select,
            theme_select,
            slide_count,
            seed_input,
            file_upload,
            use_web_search,
            custom_slide_count,
        ]
        + all_custom_inputs,
        outputs=[preview_output, status_output, download_file],
    )

    # 초기 로드시 템플릿/테마 정보 표시
    demo.load(
        fn=lambda: (
            update_template_info(template_select.value, slide_count.value),
            update_theme_preview(theme_select.value),
        ),
        inputs=[],
        outputs=[template_info, theme_preview],
    )

# --- 앱 실행 --------------------------------------------------------
if __name__ == "__main__":
    demo.launch(ssr_mode=False)