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

# 프로세스 플로우 생성기 임포트 추가
try:
    from process_flow_generator import generate_process_flow_for_ppt
    PROCESS_FLOW_AVAILABLE = True
except ImportError:
    PROCESS_FLOW_AVAILABLE = False
    print("[경고] process_flow_generator를 임포트할 수 없습니다. 프로세스 플로우 다이어그램 기능이 비활성화됩니다.")

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

# 오디언스 타입 정의
AUDIENCE_TYPES = {
    "경영진/임원": {
        "description": "C-level, 의사결정권자",
        "tone": "전략적, 결과 중심, ROI 강조",
        "focus": "비즈니스 가치, 투자 수익률, 전략적 영향"
    },
    "투자자": {
        "description": "VC, 엔젤투자자, 기관투자자",
        "tone": "수치 기반, 성장 가능성, 시장 기회",
        "focus": "시장 규모, 성장률, 경쟁우위, Exit 전략"
    },
    "기술팀": {
        "description": "개발자, 엔지니어, IT 전문가",
        "tone": "기술적, 구체적, 실용적",
        "focus": "기술 스택, 아키텍처, 구현 방법, 성능"
    },
    "일반 직원": {
        "description": "실무자, 팀원",
        "tone": "친근한, 실무적, 협업 중심",
        "focus": "실행 계획, 역할, 프로세스, 협업 방안"
    },
    "고객/파트너": {
        "description": "B2B 고객, 비즈니스 파트너",
        "tone": "신뢰감, 전문적, 혜택 중심",
        "focus": "고객 가치, 혜택, 사례, 지원 체계"
    },
    "일반 대중": {
        "description": "B2C 고객, 일반 사용자",
        "tone": "쉽고 친근한, 이해하기 쉬운",
        "focus": "사용 편의성, 혜택, 가격, 차별점"
    }
}

# 환경 변수에서 토큰 가져오기
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 = ""
uploaded_content = ""  # 전역 변수로 추가

# 디자인 테마 정의
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",
        "is_process_flow": True  # 프로세스 플로우 다이어그램 사용 표시
    },
    "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",
        "is_process_flow": True  # 프로세스 플로우 다이어그램 사용 표시
    }
}

# PPT 템플릿 정의 (동적으로 슬라이드 수 조정 가능)
# PPT_TEMPLATES 수정 - 프로세스 플로우는 특정 슬라이드에만 적용
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": "Value Chain", "prompt_hint": "전략적 제휴"},  # Business Workflow 대신 Value Chain
            {"title": "기술 스택", "style": "Industrial Design", "prompt_hint": "핵심 기술 구조"},  # Flowchart 대신
            {"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": "Mobile App Mockup", "prompt_hint": "활용 사례"},  # Business Workflow 대신
            {"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": "Colorful Mind Map", "prompt_hint": "배운 점"}  # Business Workflow 대신
        ]
    },
    "전략 기획": {
        "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": "Value Chain", "prompt_hint": "조직 개편"},  # Business Workflow 대신
            {"title": "디지털 전환", "style": "Industrial Design", "prompt_hint": "DX 전략"},  # Flowchart 대신
            {"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, audience_type: str) -> str:
    """각 슬라이드의 발표자 노트 생성 (구어체)"""
    print(f"[발표자 노트] {slide_title} 생성 중...")
    
    # 오디언스 정보 가져오기
    audience_info = AUDIENCE_TYPES.get(audience_type, AUDIENCE_TYPES["일반 직원"])
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = f"""You are a professional presentation coach who creates natural, conversational speaker notes.

The audience for this presentation is: {audience_type} - {audience_info['description']}
Tone: {audience_info['tone']}
Focus areas: {audience_info['focus']}

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 {audience_type}
2. Expand on the concise bullet points with additional context relevant to this audience
3. Include transitions and engagement phrases appropriate for {audience_type}
4. Use a warm, professional tone suitable for {audience_type}
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 appropriate for {audience_type}
- Include transition phrases
- Add engagement questions or comments that resonate with this audience
- 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 to {audience_type}."""
    
    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 generate_closing_notes(topic: str, conclusion_phrase: str, audience_type: str) -> str:
    """마지막 슬라이드의 발표자 노트 생성"""
    print(f"[마무리 노트] 생성 중...")
    
    # 오디언스 정보 가져오기
    audience_info = AUDIENCE_TYPES.get(audience_type, AUDIENCE_TYPES["일반 직원"])
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = f"""You are a professional presentation coach creating closing speaker notes.

The audience for this presentation is: {audience_type} - {audience_info['description']}
Tone: {audience_info['tone']}

Create natural closing remarks that:
1. Thank the {audience_type} audience warmly and appropriately
2. Briefly summarize the key message relevant to {audience_type}
3. Reference the conclusion phrase naturally
4. End with an invitation for questions or next steps appropriate for {audience_type}
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}
Audience: {audience_type}
Conclusion phrase on screen: {conclusion_phrase}

Create natural closing speaker notes that wrap up the presentation effectively for {audience_type}."""
    
    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, audience_type: str) -> str:
    """프레젠테이션의 핵심을 담은 결론 문구 생성"""
    print(f"[결론 문구] 생성 중...")
    
    # 오디언스 정보 가져오기
    audience_info = AUDIENCE_TYPES.get(audience_type, AUDIENCE_TYPES["일반 직원"])
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = f"""You are a professional copywriter creating powerful closing statements for presentations.

The audience is: {audience_type} - {audience_info['description']}
Focus on: {audience_info['focus']}

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

Examples for different audiences:
- For executives: "Excellence Through Strategic Innovation"
- For investors: "Maximum Returns, Minimal Risk"
- For technical teams: "Code Today, Transform Tomorrow"
- For customers: "Your Success, Our Mission"

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

Create a powerful closing phrase that encapsulates the main message for {audience_type}."""
    
    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, audience_type: str, 
                          uploaded_content: str = None, web_search_results: List[Dict] = None) -> Dict[str, str]:
    """각 슬라이드의 텍스트 내용 생성"""
    print(f"[슬라이드 내용] {slide_title} 텍스트 생성 중... (대상: {audience_type})")
    
    # 오디언스 정보 가져오기
    audience_info = AUDIENCE_TYPES.get(audience_type, AUDIENCE_TYPES["일반 직원"])
    
    url = "https://api.friendli.ai/dedicated/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    system_prompt = f"""You are a professional presentation content writer specializing in creating concise, impactful slide content.

Target Audience: {audience_type} - {audience_info['description']}
Tone: {audience_info['tone']}
Focus: {audience_info['focus']}

Your task is to create content specifically tailored for {audience_type}:
1. A compelling subtitle (max 10 words) that resonates with {audience_type}
2. Exactly 5 bullet points with emojis relevant to {audience_type}'s interests
3. Each bullet point should be 8-12 words
4. Use noun-ending style (명사형 종결) for Korean or concise fragments for English
5. Content should address {audience_type}'s specific concerns and interests

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 {audience_type} would appreciate
- Be extremely concise and impactful

Audience-specific emoji guidelines:
- For executives: 📊 🎯 💰 🏆 🚀 📈 🔝 💡
- For investors: 💰 📈 💎 🏦 💸 📊 🚀 🔒
- For technical teams: 🔧 💻 🛠️ ⚙️ 🔐 🌐 📱 🤖
- For general staff: 🤝 💡 📋 ✅ 🎯 🌟 📅 💪
- For customers: ⭐ 🎁 💝 🛡️ 🌟 ✨ 🏅 👍
- For general public: 😊 🏠 🌍 ❤️ 🎉 🌈 ✨ 🎯

Output format (EXACTLY FOLLOW THIS FORMAT):
Subtitle: [subtitle here]
- 🎯 [Point 1 - tailored for {audience_type}]
- 📊 [Point 2 - tailored for {audience_type}]
- 💡 [Point 3 - tailored for {audience_type}]
- 🚀 [Point 4 - tailored for {audience_type}]
- ⚡ [Point 5 - tailored for {audience_type}]"""
    
    user_message = f"""Topic: {topic}
Slide Title: {slide_title}
Context: {slide_context}
Target Audience: {audience_type}"""
    
    # 업로드된 콘텐츠가 있으면 추가
    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 += f"\n\nCreate compelling content for this presentation slide specifically tailored for {audience_type}. 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()
            
            print(f"[슬라이드 내용] LLM 응답:\n{content}")
            
            # Parse content - 더 강건한 파싱
            lines = content.split('\n')
            subtitle = ""
            bullet_points = []
            
            for line in lines:
                line = line.strip()
                if not line:
                    continue
                    
                # Subtitle 파싱
                if line.lower().startswith("subtitle:") or line.startswith("Subtitle:"):
                    subtitle = line.split(':', 1)[1].strip()
                # Bullet point 파싱 - • 또는 - 로 시작하는 경우 모두 처리
                elif line.startswith("•") or line.startswith("-") or (len(line) > 2 and line[1] == ' ' and ord(line[0]) >= 128):
                    # 이미 • 가 있으면 그대로, 없으면 추가
                    if not line.startswith("•"):
                        line = "• " + line.lstrip("- ")
                    bullet_points.append(line)
            
            # 만약 subtitle이 없으면 기본값 사용
            if not subtitle:
                subtitle = f"{slide_title} 개요"
            
            # 만약 bullet_points가 5개 미만이면 기본값 추가
            while len(bullet_points) < 5:
                bullet_points.append(f"• 📌 포인트 {len(bullet_points) + 1}")
            
            # 5개만 선택
            bullet_points = bullet_points[:5]
            
            print(f"[슬라이드 내용] 파싱된 subtitle: {subtitle}")
            print(f"[슬라이드 내용] 파싱된 bullets: {bullet_points}")
            
            # 한글로 번역이 필요한 경우
            if any(ord('가') <= ord(char) <= ord('힣') for char in topic):
                subtitle = translate_content_to_korean(subtitle)
                # 불릿 포인트는 이모지를 유지하면서 번역
                translated_bullets = []
                for point in bullet_points:
                    # • 제거하고 내용만 추출
                    clean_point = point.replace('•', '').strip()
                    
                    # 이모지와 텍스트 분리 (첫 번째 공백을 기준으로)
                    if len(clean_point) > 0 and clean_point[0] in '🎯📊💡🚀⚡🔍📈💰🏆🔧🌐🔐⭐🎨📱🤝📍🎖️🏗️🌱💻🛠️⚙️🤖📋✅🌟📅💪🎁💝🛡️✨🏅👍😊🏠🌍❤️🎉🌈':
                        # 이모지가 있는 경우
                        emoji = clean_point[0]
                        text = clean_point[1:].strip()
                        translated_text = translate_content_to_korean_concise(text)
                        translated_bullets.append(f"• {emoji} {translated_text}")
                    else:
                        # 이모지가 없는 경우
                        translated_bullets.append(f"• {translate_content_to_korean_concise(clean_point)}")
                
                bullet_points = translated_bullets
            
            return {
                "subtitle": subtitle,
                "bullet_points": bullet_points
            }
        else:
            print(f"[슬라이드 내용] API 오류: {response.status_code}")
            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]}...")
    
    global current_topic, uploaded_content
    
    # 프로세스 플로우 다이어그램 생성 조건 확인
    should_generate_process_flow = False
    
    # 슬라이드 정보에서 제목 추출
    slide_title = ""
    if ":" in slide_info:
        # "슬라이드 5: 프로세스" 형태에서 "프로세스" 추출
        parts = slide_info.split(":")
        if len(parts) >= 2:
            slide_title = parts[1].strip()
    
    print(f"[이미지 생성] 추출된 슬라이드 제목: '{slide_title}'")
    
    # 1. 프로세스 관련 키워드가 슬라이드 제목에 포함되어 있는지 확인
    process_keywords = [
        "프로세스", "작동", "플로우", "흐름", "워크플로우", 
        "절차", "단계", "처리", "진행", "개요"
    ]
    
    # 2. 스타일 확인
    is_workflow_style = False
    if any(style in prompt for style in ["Business Workflow", "Flowchart", "Business Process"]):
        is_workflow_style = True
        print(f"[이미지 생성] Business Workflow 또는 Flowchart 스타일 감지")
    
    # 3. 슬라이드 제목에 프로세스 키워드가 있거나, 스타일이 워크플로우인 경우
    title_has_process = any(keyword in slide_title for keyword in process_keywords)
    prompt_has_process = any(keyword in prompt.lower() for keyword in ["process", "flow", "workflow"])
    
    print(f"[이미지 생성] 제목에 프로세스 키워드: {title_has_process}")
    print(f"[이미지 생성] 워크플로우 스타일: {is_workflow_style}")
    print(f"[이미지 생성] 프롬프트에 프로세스 키워드: {prompt_has_process}")
    
    # 조건 완화: 제목에 프로세스 키워드가 있고, 스타일이 맞거나 프롬프트에 관련 키워드가 있으면 생성
    if title_has_process and (is_workflow_style or prompt_has_process):
        should_generate_process_flow = True
        print(f"[이미지 생성] ✅ 프로세스 플로우 다이어그램 생성 조건 충족!")
    
    # 특별 케이스: "목차"는 프로세스 플로우가 아닌 일반 이미지로
    if "목차" in slide_title:
        should_generate_process_flow = False
        print(f"[이미지 생성] 목차는 프로세스 플로우 제외")
    
    # 프로세스 플로우 다이어그램 생성
    if PROCESS_FLOW_AVAILABLE and should_generate_process_flow:
        try:
            print("[이미지 생성] 🔧 프로세스 플로우 다이어그램 생성 시작...")
            
            # 슬라이드 컨텍스트를 기반으로 적절한 프로세스 플로우 생성
            img = generate_process_flow_for_ppt(
                topic=current_topic,
                context=slide_info,
                style="Business Workflow"
            )
            
            if isinstance(img, Image.Image):
                print("[이미지 생성] ✅ 프로세스 플로우 다이어그램 생성 성공!")
                return img, "Process flow diagram generated with Korean support"
            else:
                print("[이미지 생성] ❌ 프로세스 플로우 생성 실패, 일반 이미지로 대체")
        except Exception as e:
            print(f"[이미지 생성] ❌ 프로세스 플로우 생성 오류: {str(e)}")
            import traceback
            traceback.print_exc()
            # 실패시 일반 이미지 생성으로 폴백
    else:
        if not PROCESS_FLOW_AVAILABLE:
            print("[이미지 생성] ⚠️ 프로세스 플로우 생성기를 사용할 수 없음")
        else:
            print("[이미지 생성] ℹ️ 프로세스 플로우 생성 조건 미충족, 일반 이미지 생성")
    
    # 기존 이미지 생성 로직
    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;
                    display: flex;
                    align-items: center;
                    justify-content: center;
                    padding: 20px;
                ">
        """
        
        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_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.8  # 50% 투명도 (더 투명하게)
            title_bg.line.fill.background()
            
            # 그림자 효과 추가 (더 약하게)
            shadow = title_bg.shadow
            shadow.visible = True
            shadow.distance = Pt(6)
            shadow.size = 100
            shadow.blur_radius = Pt(12)
            shadow.transparency = 0.8
            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.8  # 50% 투명도 (더 투명하게)
            thanks_bg.line.fill.background()
            
            # 그림자 효과 추가 (더 약하게)
            shadow = thanks_bg.shadow
            shadow.visible = True
            shadow.distance = Pt(6)
            shadow.size = 100
            shadow.blur_radius = Pt(12)
            shadow.transparency = 0.8
            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"]
            
            # 우측 이미지 추가 (배경 박스 제거)
            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_custom_slides_ui(initial_count=5):
    """사용자 정의 슬라이드 구성 UI (3-20장)"""
    slides = []
    for i in range(20):  # 최대 20장
        row = gr.Row(visible=(i < initial_count))  # Row를 변수에 할당
        with row:
            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": row})
    return slides

def generate_ppt_with_content(topic: str, template_name: str, audience_type: 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 = ""
    
    # 전역 변수 업데이트
    global current_topic, uploaded_content
    current_topic = topic
    
    # 업로드된 파일 내용 읽기
    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 생성] 오디언스: {audience_type}")
    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, audience_type)
            content = {
                "subtitle": conclusion_phrase,
                "bullet_points": []
            }
            # Thank You 슬라이드용 특별 노트
            speaker_notes = generate_closing_notes(topic, conclusion_phrase, audience_type)
        else:
            content = generate_slide_content(
                topic, slide['title'], slide_context, audience_type,
                uploaded_content, web_search_results
            )
            # 일반 슬라이드 발표자 노트
            speaker_notes = generate_presentation_notes(topic, slide['title'], content, audience_type)
        
        # 프롬프트 생성 및 이미지 생성
        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 생성 (편집 기능 제거)
            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>"
    progress(1.0, "완료!")
    successful = sum(1 for r in results if r["success"])
    final_status = f"### 🎉 생성 완료! 총 {total_slides}개 슬라이드 중 {successful}개 성공"
    
    # 전역 변수 저장
    global current_slides_data, current_template, current_theme
    current_slides_data = results
    current_template = template_name
    current_theme = theme_name
    
    if pptx_path:
        final_status += f"\n\n### 📥 PPTX 파일이 준비되었습니다!"
        final_status += f"\n\n🎤 **{audience_type}를 위한 발표자 노트가 각 슬라이드에 포함되어 있습니다!**"
        if PROCESS_FLOW_AVAILABLE:
            final_status += f"\n\n🔧 **프로세스 플로우 다이어그램이 자동으로 생성됩니다 (한글 지원)**"
    
    yield preview_html, final_status, pptx_path

# 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; }
    #custom_accordion .form { 
        max-height: 600px; 
        overflow-y: auto; 
        padding-right: 10px;
    }
    #custom_accordion .form::-webkit-scrollbar {
        width: 6px;
    }
    #custom_accordion .form::-webkit-scrollbar-track {
        background: #f1f1f1;
        border-radius: 3px;
    }
    #custom_accordion .form::-webkit-scrollbar-thumb {
        background: #888;
        border-radius: 3px;
    }
    #custom_accordion .form::-webkit-scrollbar-thumb:hover {
        background: #555;
    }
""") as demo:
    gr.Markdown("""
    # 🎯 AI 기반 PPT 통합 생성기 (간결한 스타일 버전)
    
    ### 텍스트와 이미지가 완벽하게 조화된 프레젠테이션을 자동으로 생성하세요!
    
    #### 🆕 새로운 기능:
    - 🎭 **오디언스별 최적화**: 발표 대상에 맞춘 내용과 톤 자동 조정
    - 📝 **간결한 명사형 텍스트**: "~임", "~함" 스타일의 프로페셔널한 문체
    - 🎨 **이모지 자동 추가**: 각 포인트별 적절한 이모지로 시각적 구분
    - 📋 **예제 템플릿**: 버튼 클릭으로 예제 주제 불러오기
    - 🎨 **디자인 테마**: 5가지 전문적인 디자인 테마 선택 가능
    - 💎 **개선된 슬라이드 디자인**: 더 투명한 배경과 깔끔한 레이아웃
    - 📊 **표지와 Thank You 슬라이드** 자동 추가
    - 🎤 **오디언스별 발표자 노트** 자동 생성 (구어체)
    - 📁 **파일 업로드** 지원 (PDF/CSV/TXT)
    - 🔍 **웹 검색** 기능 (Brave Search)
    - 🎚️ **슬라이드 수 조절** (6-20장)
    - 🔧 **프로세스 플로우 다이어그램** 자동 생성 (한글 지원)
    - 🎯 **사용자 정의 슬라이드**: 3-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 not PROCESS_FLOW_AVAILABLE:
        token_status.append("ℹ️ process_flow_generator가 없어 프로세스 플로우 다이어그램이 비활성화됩니다.")
    
    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
            )
            
            # 오디언스 선택 (새로 추가)
            audience_select = gr.Dropdown(
                choices=list(AUDIENCE_TYPES.keys()),
                label="🎭 발표 대상 오디언스",
                value="일반 직원",
                info="발표 대상에 따라 내용과 톤이 자동으로 최적화됩니다"
            )
            
            # 오디언스 설명 표시
            audience_info = gr.Markdown()
            
            # 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. **다운로드**: 생성 완료 후 PPTX 파일 다운로드
                
                ### 🎭 오디언스별 특징:
                - **경영진/임원**: 전략적 가치, ROI, 비즈니스 임팩트 중심
                - **투자자**: 시장 기회, 성장 가능성, 수익성 강조
                - **기술팀**: 기술적 세부사항, 구현 방법, 성능 지표
                - **일반 직원**: 실무적 내용, 협업 방안, 실행 계획
                - **고객/파트너**: 고객 가치, 혜택, 성공 사례
                - **일반 대중**: 쉬운 설명, 사용 편의성, 실질적 이점
                
                ### 💡 텍스트 스타일 특징:
                - **간결한 명사형 종결**: "~임", "~함" 또는 명사로 끝남
                - **이모지 활용**: 각 포인트 앞에 내용 관련 이모지 자동 추가
                - **8-12단어**: 각 불릿 포인트는 매우 간결하게 구성
                
                ### 📝 사용자 정의 슬라이드:
                - **템플릿 대신 직접 구성**: "사용자 정의" 템플릿 선택 시 활성화
                - **3-20장 자유롭게 구성**: 슬라이더로 원하는 슬라이드 수 선택
                - **각 슬라이드별 스타일 지정**: 16가지 스타일 중 선택
                - **힌트 제공**: 각 슬라이드의 내용 방향을 프롬프트 힌트로 지정
                
                ### 🔧 프로세스 플로우 다이어그램:
                - **Business Workflow** 또는 **Flowchart** 스타일 선택 시 자동으로 프로세스 플로우 다이어그램 생성
                - 한글 텍스트를 완벽하게 지원하는 다이어그램
                - 프로세스, 의사결정, 입출력 등 다양한 노드 타입 지원
                """)
            
            # PPTX 다운로드 영역
            with gr.Row():
                download_file = gr.File(
                    label="📥 생성된 PPTX 파일 다운로드",
                    visible=True,
                    elem_id="download-file"
                )
            
            # 사용자 정의 섹션
            with gr.Accordion("📝 사용자 정의 슬라이드 구성", open=False, elem_id="custom_accordion") as custom_accordion:
                gr.Markdown("템플릿을 사용하지 않고 직접 슬라이드를 구성하세요. (3-20장)")
                
                # 사용자 정의 슬라이드 수 선택
                custom_slide_count = gr.Slider(
                    minimum=3,
                    maximum=20,
                    value=5,
                    step=1,
                    label="사용자 정의 슬라이드 수",
                    info="생성할 사용자 정의 슬라이드 수를 선택하세요"
                )
                
                custom_slides_components = create_custom_slides_ui(initial_count=5)
    
    # 상태 표시
    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_audience_info(audience_type):
        """오디언스 정보 표시"""
        info = AUDIENCE_TYPES.get(audience_type, {})
        return f"""**{info.get('description', '')}**
- 톤: {info.get('tone', '')}
- 포커스: {info.get('focus', '')}"""
    
    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):
        is_custom = template_name == "사용자 정의"
        info = ""
        
        if not is_custom and 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', '')}"
                if style_info.get('is_process_flow'):
                    info += " 🔧"
                info += "\n"
        elif is_custom:
            info = "**사용자 정의 템플릿**\n\n아래 '사용자 정의 슬라이드 구성' 섹션에서 직접 슬라이드를 구성하세요."
        
        # 사용자 정의 템플릿일 때 슬라이드 수 선택 숨기기
        slide_count_visible = not is_custom
        custom_accordion_open = is_custom
        
        return info, gr.update(visible=slide_count_visible), gr.update(open=custom_accordion_open)
    
    def update_custom_slides_visibility(count):
        """사용자 정의 슬라이드 수에 따라 UI 표시/숨김"""
        updates = []
        for i in range(20):
            updates.append(gr.update(visible=(i < count)))  # row
        return updates
    
    def generate_ppt_handler(topic, template_name, audience_type, 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, audience_type, 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]
    )
    
    audience_select.change(
        fn=update_audience_info,
        inputs=[audience_select],
        outputs=[audience_info]
    )
    
    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, custom_accordion]
    )
    
    slide_count.change(
        fn=lambda t, s: update_template_info(t, s)[0],
        inputs=[template_select, slide_count],
        outputs=[template_info]
    )
    
    custom_slide_count.change(
        fn=update_custom_slides_visibility,
        inputs=[custom_slide_count],
        outputs=[slide["row"] for slide in custom_slides_components]
    )
    
    # 사용자 정의 슬라이드 입력 컴포넌트 평탄화
    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, audience_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)[0],
                   update_theme_preview(theme_select.value),
                   update_audience_info(audience_select.value)),
        inputs=[],
        outputs=[template_info, theme_preview, audience_info]
    )

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