app.py

#!/usr/bin/env python

import os
import re
import json
import requests
from collections.abc import Iterator
from threading import Thread
import tempfile
import random
from typing import Dict, List, Tuple, Optional
import shutil

import gradio as gr
from loguru import logger
import pandas as pd
import PyPDF2
from PIL import Image
from gradio_client import Client
import time

# python-pptx 라이브러리 확인
try:
    from pptx import Presentation
    from pptx.util import Inches, Pt
    from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
    from pptx.dml.color import RGBColor
    from pptx.enum.shapes import MSO_SHAPE
    from pptx.chart.data import CategoryChartData
    from pptx.enum.chart import XL_CHART_TYPE, XL_LEGEND_POSITION
    PPTX_AVAILABLE = True
except ImportError:
    PPTX_AVAILABLE = False
    logger.warning("python-pptx 라이브러리가 설치되지 않았습니다. pip install python-pptx")

##############################################################################
# API Configuration
##############################################################################
FRIENDLI_TOKEN = os.environ.get("FRIENDLI_TOKEN")
if not FRIENDLI_TOKEN:
    raise ValueError("Please set FRIENDLI_TOKEN environment variable")

FRIENDLI_MODEL_ID = "dep89a2fld32mcm"
FRIENDLI_API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"

# SERPHouse API key
SERPHOUSE_API_KEY = os.getenv("SERPHOUSE_API_KEY", "")
if not SERPHOUSE_API_KEY:
    logger.warning("SERPHOUSE_API_KEY not set. Web search functionality will be limited.")

##############################################################################
# AI Image Generation API Configuration
##############################################################################
AI_IMAGE_API_URL = "http://211.233.58.201:7971/"
AI_IMAGE_ENABLED = False
ai_image_client = None

def initialize_ai_image_api():
    """AI 이미지 생성 API 초기화"""
    global AI_IMAGE_ENABLED, ai_image_client
    
    try:
        logger.info("Connecting to AI image generation API...")
        ai_image_client = Client(AI_IMAGE_API_URL)
        AI_IMAGE_ENABLED = True
        logger.info("AI image generation API connected successfully")
        return True
    except Exception as e:
        logger.error(f"Failed to connect to AI image API: {e}")
        AI_IMAGE_ENABLED = False
        return False

##############################################################################
# Design Themes and Color Schemes
##############################################################################
DESIGN_THEMES = {
    "professional": {
        "name": "프로페셔널",
        "colors": {
            "primary": RGBColor(46, 134, 171),      # #2E86AB
            "secondary": RGBColor(162, 59, 114),     # #A23B72
            "accent": RGBColor(241, 143, 1),        # #F18F01
            "background": RGBColor(250, 250, 250),   # #FAFAFA - Lighter background
            "text": RGBColor(44, 44, 44),          # #2C2C2C - Darker text for better contrast
        },
        "fonts": {
            "title": "Arial",
            "subtitle": "Arial",
            "body": "Calibri"
        }
    },
    "modern": {
        "name": "모던",
        "colors": {
            "primary": RGBColor(114, 9, 183),       # #7209B7
            "secondary": RGBColor(247, 37, 133),     # #F72585
            "accent": RGBColor(76, 201, 240),       # #4CC9F0
            "background": RGBColor(252, 252, 252),   # #FCFCFC - Very light background
            "text": RGBColor(40, 40, 40),          # #282828 - Dark text
        },
        "fonts": {
            "title": "Arial",
            "subtitle": "Arial",
            "body": "Helvetica"
        }
    },
    "nature": {
        "name": "자연",
        "colors": {
            "primary": RGBColor(45, 106, 79),       # #2D6A4F
            "secondary": RGBColor(82, 183, 136),     # #52B788
            "accent": RGBColor(181, 233, 185),      # #B5E9B9 - Softer accent
            "background": RGBColor(248, 252, 248),   # #F8FCF8 - Light green tint
            "text": RGBColor(27, 38, 44),          # #1B262C
        },
        "fonts": {
            "title": "Georgia",
            "subtitle": "Verdana",
            "body": "Calibri"
        }
    },
    "creative": {
        "name": "크리에이티브",
        "colors": {
            "primary": RGBColor(255, 0, 110),       # #FF006E
            "secondary": RGBColor(251, 86, 7),       # #FB5607
            "accent": RGBColor(255, 190, 11),       # #FFBE0B
            "background": RGBColor(255, 248, 240),   # #FFF8F0 - Light warm background
            "text": RGBColor(33, 33, 33),          # #212121 - Dark text on light bg
        },
        "fonts": {
            "title": "Impact",
            "subtitle": "Arial",
            "body": "Segoe UI"
        }
    },
    "minimal": {
        "name": "미니멀",
        "colors": {
            "primary": RGBColor(55, 55, 55),       # #373737 - Softer than pure black
            "secondary": RGBColor(120, 120, 120),    # #787878
            "accent": RGBColor(0, 122, 255),        # #007AFF - Blue accent
            "background": RGBColor(252, 252, 252),   # #FCFCFC
            "text": RGBColor(33, 33, 33),          # #212121
        },
        "fonts": {
            "title": "Helvetica",
            "subtitle": "Helvetica",
            "body": "Arial"
        }
    }
}

##############################################################################
# Slide Layout Types
##############################################################################
SLIDE_LAYOUTS = {
    "title": 0,          # 제목 슬라이드
    "title_content": 1,  # 제목과 내용
    "section_header": 2, # 섹션 헤더
    "two_content": 3,    # 2단 레이아웃
    "comparison": 4,     # 비교 레이아웃
    "title_only": 5,     # 제목만
    "blank": 6           # 빈 슬라이드
}

##############################################################################
# Emoji Bullet Points Mapping
##############################################################################
def has_emoji(text: str) -> bool:
    """Check if text already contains emoji"""
    # Check for common emoji unicode ranges
    for char in text[:3]:  # Check first 3 characters
        code = ord(char)
        # Common emoji ranges
        if (0x1F300 <= code <= 0x1F9FF) or \
           (0x2600 <= code <= 0x26FF) or \
           (0x2700 <= code <= 0x27BF) or \
           (0x1F000 <= code <= 0x1F02F) or \
           (0x1F0A0 <= code <= 0x1F0FF) or \
           (0x1F100 <= code <= 0x1F1FF):
            return True
    return False

def get_emoji_for_content(text: str) -> str:
    """Get relevant emoji based on content"""
    text_lower = text.lower()
    
    # Technology
    if any(word in text_lower for word in ['ai', '인공지능', 'ml', '머신러닝', '딥러닝', 'deep learning']):
        return '🤖'
    elif any(word in text_lower for word in ['데이터', 'data', '분석', 'analysis', '통계']):
        return '📊'
    elif any(word in text_lower for word in ['코드', 'code', '프로그래밍', 'programming', '개발']):
        return '💻'
    elif any(word in text_lower for word in ['클라우드', 'cloud', '서버', 'server']):
        return '☁️'
    elif any(word in text_lower for word in ['보안', 'security', '안전', 'safety']):
        return '🔒'
    elif any(word in text_lower for word in ['네트워크', 'network', '연결', 'connection', '인터넷']):
        return '🌐'
    elif any(word in text_lower for word in ['모바일', 'mobile', '스마트폰', 'smartphone', '앱']):
        return '📱'
    
    # Business
    elif any(word in text_lower for word in ['성장', 'growth', '증가', 'increase', '상승']):
        return '📈'
    elif any(word in text_lower for word in ['목표', 'goal', 'target', '타겟', '목적']):
        return '🎯'
    elif any(word in text_lower for word in ['돈', 'money', '비용', 'cost', '예산', 'budget', '수익']):
        return '💰'
    elif any(word in text_lower for word in ['팀', 'team', '협업', 'collaboration', '협력']):
        return '👥'
    elif any(word in text_lower for word in ['시간', 'time', '일정', 'schedule', '기한']):
        return '⏰'
    elif any(word in text_lower for word in ['아이디어', 'idea', '창의', 'creative', '혁신']):
        return '💡'
    elif any(word in text_lower for word in ['전략', 'strategy', '계획', 'plan']):
        return '📋'
    elif any(word in text_lower for word in ['성공', 'success', '달성', 'achieve']):
        return '🏆'
    
    # Education
    elif any(word in text_lower for word in ['학습', 'learning', '교육', 'education', '공부']):
        return '📚'
    elif any(word in text_lower for word in ['연구', 'research', '조사', 'study', '실험']):
        return '🔬'
    elif any(word in text_lower for word in ['문서', 'document', '보고서', 'report']):
        return '📄'
    elif any(word in text_lower for word in ['정보', 'information', '지식', 'knowledge']):
        return '📖'
    
    # Communication
    elif any(word in text_lower for word in ['소통', 'communication', '대화', 'conversation']):
        return '💬'
    elif any(word in text_lower for word in ['이메일', 'email', '메일', 'mail']):
        return '📧'
    elif any(word in text_lower for word in ['전화', 'phone', 'call', '통화']):
        return '📞'
    elif any(word in text_lower for word in ['회의', 'meeting', '미팅', '컨퍼런스']):
        return '👔'
    
    # Nature/Environment
    elif any(word in text_lower for word in ['환경', 'environment', '자연', 'nature']):
        return '🌱'
    elif any(word in text_lower for word in ['지속가능', 'sustainable', '친환경', 'eco']):
        return '♻️'
    elif any(word in text_lower for word in ['에너지', 'energy', '전력', 'power']):
        return '⚡'
    elif any(word in text_lower for word in ['지구', 'earth', '세계', 'world']):
        return '🌍'
    
    # Process/Steps
    elif any(word in text_lower for word in ['프로세스', 'process', '절차', 'procedure', '단계']):
        return '🔄'
    elif any(word in text_lower for word in ['체크', 'check', '확인', 'verify', '검증']):
        return '✅'
    elif any(word in text_lower for word in ['주의', 'warning', '경고', 'caution']):
        return '⚠️'
    elif any(word in text_lower for word in ['중요', 'important', '핵심', 'key', '필수']):
        return '⭐'
    elif any(word in text_lower for word in ['질문', 'question', '문의', 'ask']):
        return '❓'
    elif any(word in text_lower for word in ['해결', 'solution', '답', 'answer']):
        return '💯'
    
    # Actions
    elif any(word in text_lower for word in ['시작', 'start', '출발', 'begin']):
        return '🚀'
    elif any(word in text_lower for word in ['완료', 'complete', '종료', 'finish']):
        return '🏁'
    elif any(word in text_lower for word in ['개선', 'improve', '향상', 'enhance']):
        return '🔧'
    elif any(word in text_lower for word in ['변화', 'change', '변경', 'modify']):
        return '🔄'
    
    # Industries
    elif any(word in text_lower for word in ['의료', 'medical', '병원', 'hospital', '건강']):
        return '🏥'
    elif any(word in text_lower for word in ['금융', 'finance', '은행', 'bank']):
        return '🏦'
    elif any(word in text_lower for word in ['제조', 'manufacturing', '공장', 'factory']):
        return '🏭'
    elif any(word in text_lower for word in ['농업', 'agriculture', '농장', 'farm']):
        return '🌾'
    
    # Emotion/Status
    elif any(word in text_lower for word in ['행복', 'happy', '기쁨', 'joy']):
        return '😊'
    elif any(word in text_lower for word in ['위험', 'danger', 'risk', '리스크']):
        return '⚡'
    elif any(word in text_lower for word in ['새로운', 'new', '신규', 'novel']):
        return '✨'
    
    # Numbers
    elif text_lower.startswith(('첫째', 'first', '1.', '첫번째', '첫 번째')):
        return '1️⃣'
    elif text_lower.startswith(('둘째', 'second', '2.', '두번째', '두 번째')):
        return '2️⃣'
    elif text_lower.startswith(('셋째', 'third', '3.', '세번째', '세 번째')):
        return '3️⃣'
    elif text_lower.startswith(('넷째', 'fourth', '4.', '네번째', '네 번째')):
        return '4️⃣'
    elif text_lower.startswith(('다섯째', 'fifth', '5.', '다섯번째', '다섯 번째')):
        return '5️⃣'
    
    # Default
    else:
        return '▶️'

##############################################################################
# Icon and Shape Mappings
##############################################################################
SHAPE_ICONS = {
    "목표": MSO_SHAPE.STAR_5_POINT,
    "프로세스": MSO_SHAPE.BLOCK_ARC,
    "성장": MSO_SHAPE.UP_ARROW,
    "아이디어": MSO_SHAPE.LIGHTNING_BOLT,
    "체크": MSO_SHAPE.RECTANGLE,
    "주의": MSO_SHAPE.DIAMOND,
    "질문": MSO_SHAPE.OVAL,
    "분석": MSO_SHAPE.PENTAGON,
    "시간": MSO_SHAPE.DONUT,
    "팀": MSO_SHAPE.HEXAGON,
}

##############################################################################
# File Processing Constants
##############################################################################
MAX_FILE_SIZE = 30 * 1024 * 1024  # 30MB
MAX_CONTENT_CHARS = 6000

##############################################################################
# Improved Keyword Extraction
##############################################################################
def extract_keywords(text: str, top_k: int = 5) -> str:
    """
    Extract keywords: supports English and Korean
    """
    stop_words = {'은', '는', '이', '가', '을', '를', '의', '에', '에서', 
                  'the', 'is', 'at', 'on', 'in', 'a', 'an', 'and', 'or', 'but'}
    
    text = re.sub(r"[^a-zA-Z0-9가-힣\s]", "", text)
    tokens = text.split()
    
    key_tokens = [
        token for token in tokens 
        if token.lower() not in stop_words and len(token) > 1
    ][:top_k]
    
    return " ".join(key_tokens)

##############################################################################
# File Size Validation
##############################################################################
def validate_file_size(file_path: str) -> bool:
    """Check if file size is within limits"""
    try:
        file_size = os.path.getsize(file_path)
        return file_size <= MAX_FILE_SIZE
    except:
        return False

##############################################################################
# Web Search Function
##############################################################################
def do_web_search(query: str, use_korean: bool = False) -> str:
    """
    Search web and return top 20 organic results
    """
    if not SERPHOUSE_API_KEY:
        return "Web search unavailable. API key not configured."
        
    try:
        url = "https://api.serphouse.com/serp/live"
        
        params = {
            "q": query,
            "domain": "google.com",
            "serp_type": "web",
            "device": "desktop",
            "lang": "ko" if use_korean else "en",
            "num": "20"
        }
        
        headers = {
            "Authorization": f"Bearer {SERPHOUSE_API_KEY}"
        }
        
        logger.info(f"Calling SerpHouse API... Query: {query}")
        
        response = requests.get(url, headers=headers, params=params, timeout=30)
        response.raise_for_status()
        
        data = response.json()
        
        # Parse results
        results = data.get("results", {})
        organic = None
        
        if isinstance(results, dict) and "organic" in results:
            organic = results["organic"]
        elif isinstance(results, dict) and "results" in results:
            if isinstance(results["results"], dict) and "organic" in results["results"]:
                organic = results["results"]["organic"]
        elif "organic" in data:
            organic = data["organic"]
            
        if not organic:
            return "No search results found or unexpected API response structure."

        max_results = min(20, len(organic))
        limited_organic = organic[:max_results]
        
        summary_lines = []
        for idx, item in enumerate(limited_organic, start=1):
            title = item.get("title", "No title")
            link = item.get("link", "#")
            snippet = item.get("snippet", "No description")
            displayed_link = item.get("displayed_link", link)
            
            summary_lines.append(
                f"### Result {idx}: {title}\n\n"
                f"{snippet}\n\n"
                f"**Source**: [{displayed_link}]({link})\n\n"
                f"---\n"
            )
        
        instructions = """
# Web Search Results
Below are the search results. Use this information when answering questions:
1. Reference the title, content, and source links
2. Explicitly cite sources in your answer (e.g., "According to source X...")
3. Include actual source links in your response
4. Synthesize information from multiple sources
"""
        
        search_results = instructions + "\n".join(summary_lines)
        return search_results
    
    except requests.exceptions.Timeout:
        logger.error("Web search timeout")
        return "Web search timed out. Please try again."
    except requests.exceptions.RequestException as e:
        logger.error(f"Web search network error: {e}")
        return "Network error during web search."
    except Exception as e:
        logger.error(f"Web search failed: {e}")
        return f"Web search failed: {str(e)}"

##############################################################################
# File Analysis Functions
##############################################################################
def analyze_csv_file(path: str) -> str:
    """Analyze CSV file with size validation and encoding handling"""
    if not validate_file_size(path):
        return f"⚠️ Error: File size exceeds {MAX_FILE_SIZE/1024/1024:.1f}MB limit."
        
    try:
        encodings = ['utf-8', 'cp949', 'euc-kr', 'latin-1']
        df = None
        
        for encoding in encodings:
            try:
                df = pd.read_csv(path, encoding=encoding, nrows=50)
                break
            except UnicodeDecodeError:
                continue
                
        if df is None:
            return f"Failed to read CSV: Unsupported encoding"
            
        total_rows = len(pd.read_csv(path, encoding=encoding, usecols=[0]))
        
        if df.shape[1] > 10:
            df = df.iloc[:, :10]
            
        summary = f"**Data size**: {total_rows} rows x {df.shape[1]} columns\n"
        summary += f"**Showing**: Top {min(50, total_rows)} rows\n"
        summary += f"**Columns**: {', '.join(df.columns)}\n\n"
        
        # Extract data for charts
        chart_data = {
            "columns": list(df.columns),
            "sample_data": df.head(10).to_dict('records')
        }
        
        df_str = df.to_string()
        if len(df_str) > MAX_CONTENT_CHARS:
            df_str = df_str[:MAX_CONTENT_CHARS] + "\n...(truncated)..."
            
        return f"**[CSV File: {os.path.basename(path)}]**\n\n{summary}{df_str}\n\nCHART_DATA:{json.dumps(chart_data)}"
    except Exception as e:
        logger.error(f"CSV read error: {e}")
        return f"Failed to read CSV file ({os.path.basename(path)}): {str(e)}"

def analyze_txt_file(path: str) -> str:
    """Analyze text file with automatic encoding detection"""
    if not validate_file_size(path):
        return f"⚠️ Error: File size exceeds {MAX_FILE_SIZE/1024/1024:.1f}MB limit."
        
    encodings = ['utf-8', 'cp949', 'euc-kr', 'latin-1', 'utf-16']
    
    for encoding in encodings:
        try:
            with open(path, "r", encoding=encoding) as f:
                text = f.read()
            
            file_size = os.path.getsize(path)
            size_info = f"**File size**: {file_size/1024:.1f}KB\n\n"
            
            if len(text) > MAX_CONTENT_CHARS:
                text = text[:MAX_CONTENT_CHARS] + "\n...(truncated)..."
                
            return f"**[TXT File: {os.path.basename(path)}]**\n\n{size_info}{text}"
        except UnicodeDecodeError:
            continue
    
    return f"Failed to read text file ({os.path.basename(path)}): Unsupported encoding"

def pdf_to_markdown(pdf_path: str) -> str:
    """Convert PDF to markdown with improved error handling"""
    if not validate_file_size(pdf_path):
        return f"⚠️ Error: File size exceeds {MAX_FILE_SIZE/1024/1024:.1f}MB limit."
        
    text_chunks = []
    try:
        with open(pdf_path, "rb") as f:
            reader = PyPDF2.PdfReader(f)
            total_pages = len(reader.pages)
            max_pages = min(5, total_pages)
            
            text_chunks.append(f"**Total pages**: {total_pages}")
            text_chunks.append(f"**Showing**: First {max_pages} pages\n")
            
            for page_num in range(max_pages):
                try:
                    page = reader.pages[page_num]
                    page_text = page.extract_text() or ""
                    page_text = page_text.strip()
                    
                    if page_text:
                        if len(page_text) > MAX_CONTENT_CHARS // max_pages:
                            page_text = page_text[:MAX_CONTENT_CHARS // max_pages] + "...(truncated)"
                        text_chunks.append(f"## Page {page_num+1}\n\n{page_text}\n")
                except Exception as e:
                    text_chunks.append(f"## Page {page_num+1}\n\nFailed to read page: {str(e)}\n")
                    
            if total_pages > max_pages:
                text_chunks.append(f"\n...({max_pages}/{total_pages} pages shown)...")
    except Exception as e:
        logger.error(f"PDF read error: {e}")
        return f"Failed to read PDF file ({os.path.basename(pdf_path)}): {str(e)}"

    full_text = "\n".join(text_chunks)
    if len(full_text) > MAX_CONTENT_CHARS:
        full_text = full_text[:MAX_CONTENT_CHARS] + "\n...(truncated)..."

    return f"**[PDF File: {os.path.basename(pdf_path)}]**\n\n{full_text}"

##############################################################################
# AI Image Generation Functions using API
##############################################################################
def generate_cover_image_prompt(topic: str, slides_data: list) -> str:
    """PPT 주제와 내용을 기반으로 표지 이미지 프롬프트 생성 - 한글 지원"""
    
    # 주요 키워드 추출
    keywords = []
    topic_keywords = extract_keywords(topic, top_k=3)
    keywords.extend(topic_keywords.split())
    
    # 각 슬라이드 제목에서 키워드 추출
    for slide in slides_data[:5]:
        title = slide.get('title', '')
        if title:
            slide_keywords = extract_keywords(title, top_k=2)
            keywords.extend(slide_keywords.split())
    
    unique_keywords = list(dict.fromkeys(keywords))[:5]
    
    # 주제 분석을 통한 스타일 결정
    style = "현대적이고 전문적인"
    topic_lower = topic.lower()
    
    if any(word in topic_lower for word in ['기술', 'tech', 'ai', '인공지능', 'digital', '디지털']):
        style = "미래지향적이고 하이테크한 디지털 아트"
    elif any(word in topic_lower for word in ['비즈니스', 'business', '경영', 'management']):
        style = "전문적이고 기업적인 현대적"
    elif any(word in topic_lower for word in ['교육', 'education', '학습', 'learning']):
        style = "교육적이고 영감을 주는 밝은"
    elif any(word in topic_lower for word in ['환경', 'environment', '자연', 'nature']):
        style = "자연적이고 친환경적인 녹색"
    elif any(word in topic_lower for word in ['의료', 'medical', '건강', 'health']):
        style = "의료적이고 건강한 깨끗한"
    elif any(word in topic_lower for word in ['금융', 'finance', '투자', 'investment']):
        style = "금융적이고 전문적인 신뢰감 있는"
    
    # wbgmsst 스타일을 위한 한글 프롬프트 구성
    prompt = f"wbgmsst, 3D, {' '.join(unique_keywords)}를 상징하는 아이소메트릭 스타일의 {style} 일러스트레이션, 흰색 배경, 깔끔한 미니멀리스틱 구성, 전문적인 프레젠테이션 표지, 고품질, 스튜디오 조명"
    
    return prompt



def generate_ai_cover_image_via_api(topic: str, slides_data: list) -> Optional[str]:
    """API를 통해 AI 표지 이미지 생성(PNG 변환 포함)"""
    if not AI_IMAGE_ENABLED or not ai_image_client:
        logger.warning("AI image generation API is not available")
        return None

    try:
        # ── 1. 프롬프트 및 파라미터 ─────────────────────────────
        prompt = generate_cover_image_prompt(topic, slides_data)
        logger.info(f"Generated image prompt: {prompt}")

        height, width = 1024.0, 1024.0
        steps, scales = 8.0, 3.5
        seed = float(random.randint(0, 1_000_000))
        logger.info(f"Calling AI image API… (h={height}, w={width}, steps={steps}, scales={scales}, seed={seed})")

        result = ai_image_client.predict(
            height=height,
            width=width,
            steps=steps,
            scales=scales,
            prompt=prompt,
            seed=seed,
            api_name="/process_and_save_image"
        )
        logger.info(f"API call successful. Result type: {type(result)}")

        # ── 2. 내부 헬퍼: WEBP → PNG 변환 ────────────────────────
        def _to_png(src_path: str) -> Optional[str]:
            try:
                with Image.open(src_path) as im:
                    png_tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
                    im.save(png_tmp.name, format="PNG")
                    logger.info(f"Converted {src_path} → {png_tmp.name}")
                    return png_tmp.name
            except Exception as e:
                logger.error(f"PNG 변환 실패: {e}")
                return None

        # ── 3. 결과 처리 ────────────────────────────────────────
        image_path = None
        if isinstance(result, dict):
            image_path = result.get("path")
        elif isinstance(result, str):
            image_path = result

        if image_path and os.path.exists(image_path):
            ext = os.path.splitext(image_path)[1].lower()
            if ext == ".png":
                # 이미 PNG라면 그대로 복사
                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
                    shutil.copy2(image_path, tmp.name)
                    logger.info(f"PNG copied from {image_path} → {tmp.name}")
                    return tmp.name
            else:
                # WEBP·JPEG 등은 PNG로 변환
                return _to_png(image_path)

        logger.error(f"Image path not found or invalid: {result}")
        return None

    except Exception as e:
        logger.error(f"Failed to generate AI image via API: {e}", exc_info=True)
        return None


##############################################################################
# PPT Generation Functions - FIXED VERSION
##############################################################################
def parse_llm_ppt_response(response: str, layout_style: str = "consistent") -> list:
    """Parse LLM response to extract slide content - COMPLETELY FIXED VERSION"""
    slides = []
    
    # Debug: 전체 응답 확인
    logger.info(f"Parsing LLM response, total length: {len(response)}")
    logger.debug(f"First 500 chars: {response[:500]}")
    
    # Try JSON parsing first
    try:
        json_match = re.search(r'\[[\s\S]*\]', response)
        if json_match:
            slides_data = json.loads(json_match.group())
            return slides_data
    except:
        pass
    
    # Split by slide markers and process each section
    # 슬라이드를 구분하는 더 강력한 정규식
    slide_pattern = r'(?:^|\n)(?:슬라이드|Slide)\s*\d+|(?:^|\n)\d+[\.)](?:\s|$)'
    
    # 슬라이드 섹션으로 분할
    sections = re.split(slide_pattern, response, flags=re.MULTILINE | re.IGNORECASE)
    
    # 첫 번째 빈 섹션 제거
    if sections and not sections[0].strip():
        sections = sections[1:]
    
    logger.info(f"Found {len(sections)} potential slide sections")
    
    for idx, section in enumerate(sections):
        if not section.strip():
            continue
            
        logger.debug(f"Processing section {idx}: {section[:100]}...")
        
        slide = {
            'title': '',
            'content': '',
            'notes': '',
            'layout': 'title_content',
            'chart_data': None
        }
        
        # 섹션 내에서 제목, 내용, 노트 추출
        lines = section.strip().split('\n')
        current_part = None
        title_lines = []
        content_lines = []
        notes_lines = []
        
        for line in lines:
            line = line.strip()
            if not line:
                continue
            
            # 제목 섹션 감지
            if line.startswith('제목:') or line.startswith('Title:'):
                current_part = 'title'
                title_text = line.split(':', 1)[1].strip() if ':' in line else ''
                if title_text:
                    title_lines.append(title_text)
            # 내용 섹션 감지
            elif line.startswith('내용:') or line.startswith('Content:'):
                current_part = 'content'
                content_text = line.split(':', 1)[1].strip() if ':' in line else ''
                if content_text:
                    content_lines.append(content_text)
            # 노트 섹션 감지
            elif line.startswith('노트:') or line.startswith('Notes:') or line.startswith('발표자 노트:'):
                current_part = 'notes'
                notes_text = line.split(':', 1)[1].strip() if ':' in line else ''
                if notes_text:
                    notes_lines.append(notes_text)
            # 현재 섹션에 따라 내용 추가
            else:
                if current_part == 'title' and not title_lines:
                    title_lines.append(line)
                elif current_part == 'content':
                    content_lines.append(line)
                elif current_part == 'notes':
                    notes_lines.append(line)
                elif not current_part and not title_lines:
                    # 첫 번째 줄을 제목으로
                    title_lines.append(line)
                    current_part = 'content'  # 이후 줄들은 content로
                elif not current_part:
                    content_lines.append(line)
        
        # 슬라이드 데이터 설정
        slide['title'] = ' '.join(title_lines).strip()
        slide['content'] = '\n'.join(content_lines).strip()
        slide['notes'] = ' '.join(notes_lines).strip()
        
        # 제목 정리
        slide['title'] = re.sub(r'^(슬라이드|Slide)\s*\d+\s*[:：\-]?\s*', '', slide['title'], flags=re.IGNORECASE)
        slide['title'] = re.sub(r'^(제목|Title)\s*[:：]\s*', '', slide['title'], flags=re.IGNORECASE)
        
        # 내용이 있는 경우에만 추가
        if slide['title'] or slide['content']:
            logger.info(f"Slide {len(slides)+1}: Title='{slide['title'][:30]}...', Content length={len(slide['content'])}")
            slides.append(slide)
    
    # 만약 위 방법으로 파싱이 안 되었다면, 더 간단한 방법 시도
    if not slides:
        logger.warning("Primary parsing failed, trying fallback method...")
        
        # 더블 뉴라인으로 구분
        sections = response.split('\n\n')
        for section in sections:
            lines = section.strip().split('\n')
            if len(lines) >= 2:  # 최소 제목과 내용이 있어야 함
                slide = {
                    'title': lines[0].strip(),
                    'content': '\n'.join(lines[1:]).strip(),
                    'notes': '',
                    'layout': 'title_content',
                    'chart_data': None
                }
                
                # 제목 정리
                slide['title'] = re.sub(r'^(슬라이드|Slide)\s*\d+\s*[:：\-]?\s*', '', slide['title'], flags=re.IGNORECASE)
                
                if slide['title'] and slide['content']:
                    slides.append(slide)
    
    logger.info(f"Total slides parsed: {len(slides)}")
    return slides

def force_font_size(text_frame, font_size_pt: int, theme: Dict):
    """Force font size for all paragraphs and runs in a text frame"""
    if not text_frame:
        return
    
    try:
        # Ensure paragraphs exist
        if not hasattr(text_frame, 'paragraphs'):
            return
            
        for paragraph in text_frame.paragraphs:
            try:
                # Set paragraph level font
                if hasattr(paragraph, 'font'):
                    paragraph.font.size = Pt(font_size_pt)
                    paragraph.font.name = theme['fonts']['body']
                    paragraph.font.color.rgb = theme['colors']['text']
                
                # Set run level font (most important for actual rendering)
                if hasattr(paragraph, 'runs'):
                    for run in paragraph.runs:
                        run.font.size = Pt(font_size_pt)
                        run.font.name = theme['fonts']['body']
                        run.font.color.rgb = theme['colors']['text']
                
                # If paragraph has no runs but has text, create a run
                if paragraph.text and (not hasattr(paragraph, 'runs') or len(paragraph.runs) == 0):
                    # Force creation of runs by modifying text
                    temp_text = paragraph.text
                    paragraph.text = temp_text  # This creates runs
                    if hasattr(paragraph, 'runs'):
                        for run in paragraph.runs:
                            run.font.size = Pt(font_size_pt)
                            run.font.name = theme['fonts']['body']
                            run.font.color.rgb = theme['colors']['text']
            except Exception as e:
                logger.warning(f"Error setting font for paragraph: {e}")
                continue
    except Exception as e:
        logger.warning(f"Error in force_font_size: {e}")

def apply_theme_to_slide(slide, theme: Dict, layout_type: str = 'title_content'):
    """Apply design theme to a slide with consistent styling"""
    # Add colored background shape for all slides
    bg_shape = slide.shapes.add_shape(
        MSO_SHAPE.RECTANGLE, 0, 0, Inches(10), Inches(5.625)
    )
    bg_shape.fill.solid()
    
    # Use lighter background for content slides
    if layout_type in ['title_content', 'two_content', 'comparison']:
        # Light background with subtle gradient effect
        bg_shape.fill.fore_color.rgb = theme['colors']['background']
        
        # Add accent strip at top
        accent_strip = slide.shapes.add_shape(
            MSO_SHAPE.RECTANGLE, 0, 0, Inches(10), Inches(0.5)
        )
        accent_strip.fill.solid()
        accent_strip.fill.fore_color.rgb = theme['colors']['primary']
        accent_strip.line.fill.background()
        
        # Add bottom accent
        bottom_strip = slide.shapes.add_shape(
            MSO_SHAPE.RECTANGLE, 0, Inches(5.125), Inches(10), Inches(0.5)
        )
        bottom_strip.fill.solid()
        bottom_strip.fill.fore_color.rgb = theme['colors']['secondary']
        bottom_strip.fill.transparency = 0.7
        bottom_strip.line.fill.background()
        
    else:
        # Section headers get primary color background
        bg_shape.fill.fore_color.rgb = theme['colors']['primary']
    
    bg_shape.line.fill.background()
    
    # Move background shapes to back
    slide.shapes._spTree.remove(bg_shape._element)
    slide.shapes._spTree.insert(2, bg_shape._element)
    
    # Apply title formatting if exists
    if slide.shapes.title:
        try:
            title = slide.shapes.title
            if title.text_frame and title.text_frame.paragraphs:
                for paragraph in title.text_frame.paragraphs:
                    paragraph.font.name = theme['fonts']['title']
                    paragraph.font.bold = True
                    
                    # UPDATED: Increased font sizes for better readability
                    if layout_type == 'section_header':
                        paragraph.font.size = Pt(28)  # Increased from 20
                        paragraph.font.color.rgb = RGBColor(255, 255, 255)
                        paragraph.alignment = PP_ALIGN.CENTER
                    else:
                        paragraph.font.size = Pt(24)  # Increased from 18
                        paragraph.font.color.rgb = theme['colors']['primary']
                        paragraph.alignment = PP_ALIGN.LEFT
        except Exception as e:
            logger.warning(f"Title formatting failed: {e}")
    
    # Apply content formatting with improved readability
    # NOTE: Do NOT add emojis here - they will be added in create_advanced_ppt_from_content
    for shape in slide.shapes:
        if shape.has_text_frame and shape != slide.shapes.title:
            try:
                text_frame = shape.text_frame
                
                # Set text frame margins for better spacing
                text_frame.margin_left = Inches(0.25)
                text_frame.margin_right = Inches(0.25)
                text_frame.margin_top = Inches(0.1)
                text_frame.margin_bottom = Inches(0.1)
                
                # Only apply font formatting, no content modification
                if text_frame.text.strip():
                    # Use force_font_size helper to ensure font is applied
                    force_font_size(text_frame, 16, theme)  # Increased from 12
                    
                    for paragraph in text_frame.paragraphs:
                        # Add line spacing for better readability
                        paragraph.space_after = Pt(4)  # Increased from 3
                        paragraph.line_spacing = 1.2  # Increased from 1.1
                        
            except Exception as e:
                logger.warning(f"Content formatting failed: {e}")

def add_gradient_background(slide, color1: RGBColor, color2: RGBColor):
    """Add gradient-like background to slide using shapes"""
    # Note: python-pptx doesn't directly support gradients in backgrounds,
    # so we'll create a gradient effect using overlapping shapes
    left = top = 0
    width = Inches(10)
    height = Inches(5.625)
    
    # Add base color rectangle
    shape1 = slide.shapes.add_shape(
        MSO_SHAPE.RECTANGLE, left, top, width, height
    )
    shape1.fill.solid()
    shape1.fill.fore_color.rgb = color1
    shape1.line.fill.background()
    
    # Add semi-transparent overlay for gradient effect
    shape2 = slide.shapes.add_shape(
        MSO_SHAPE.RECTANGLE, left, top, width, Inches(2.8)
    )
    shape2.fill.solid()
    shape2.fill.fore_color.rgb = color2
    shape2.fill.transparency = 0.5
    shape2.line.fill.background()
    
    # Move shapes to back
    slide.shapes._spTree.remove(shape1._element)
    slide.shapes._spTree.remove(shape2._element)
    slide.shapes._spTree.insert(2, shape1._element)
    slide.shapes._spTree.insert(3, shape2._element)

def add_decorative_shapes(slide, theme: Dict):
    """Add decorative shapes to enhance visual appeal"""
    try:
        # Add corner accent circle
        shape1 = slide.shapes.add_shape(
            MSO_SHAPE.OVAL,
            Inches(9.3), Inches(4.8),
            Inches(0.7), Inches(0.7)
        )
        shape1.fill.solid()
        shape1.fill.fore_color.rgb = theme['colors']['accent']
        shape1.fill.transparency = 0.3
        shape1.line.fill.background()
        
        # Add smaller accent
        shape2 = slide.shapes.add_shape(
            MSO_SHAPE.OVAL,
            Inches(0.1), Inches(0.1),
            Inches(0.4), Inches(0.4)
        )
        shape2.fill.solid()
        shape2.fill.fore_color.rgb = theme['colors']['secondary']
        shape2.fill.transparency = 0.5
        shape2.line.fill.background()
        
    except Exception as e:
        logger.warning(f"Failed to add decorative shapes: {e}")

def create_chart_slide(slide, chart_data: Dict, theme: Dict):
    """Create a chart on the slide based on data"""
    try:
        # Add chart
        x, y, cx, cy = Inches(1), Inches(2), Inches(8), Inches(4.5)
        
        # Prepare chart data
        chart_data_obj = CategoryChartData()
        
        # Simple bar chart example
        if 'columns' in chart_data and 'sample_data' in chart_data:
            # Use first numeric column for chart
            numeric_cols = []
            for col in chart_data['columns']:
                try:
                    # Check if column has numeric data
                    float(chart_data['sample_data'][0].get(col, 0))
                    numeric_cols.append(col)
                except:
                    pass
            
            if numeric_cols:
                categories = [str(row.get(chart_data['columns'][0], '')) 
                             for row in chart_data['sample_data'][:5]]
                chart_data_obj.categories = categories
                
                for col in numeric_cols[:3]:  # Max 3 series
                    values = [float(row.get(col, 0)) 
                             for row in chart_data['sample_data'][:5]]
                    chart_data_obj.add_series(col, values)
                
                chart = slide.shapes.add_chart(
                    XL_CHART_TYPE.COLUMN_CLUSTERED, x, y, cx, cy, chart_data_obj
                ).chart
                
                # Style the chart
                chart.has_legend = True
                chart.legend.position = XL_LEGEND_POSITION.BOTTOM
    except Exception as e:
        logger.warning(f"Chart creation failed: {e}")
        # If chart fails, add a text placeholder instead
        textbox = slide.shapes.add_textbox(x, y, cx, cy)
        text_frame = textbox.text_frame
        text_frame.text = "데이터 차트 (차트 생성 실패)"
        text_frame.paragraphs[0].font.size = Pt(16)  # Increased font size
        text_frame.paragraphs[0].font.color.rgb = theme['colors']['secondary']

def create_advanced_ppt_from_content(
    slides_data: list,
    topic: str,
    theme_name: str,
    include_charts: bool = False,
    include_ai_image: bool = False
) -> str:
    """Create advanced PPT file with consistent visual design and AI image option"""
    if not PPTX_AVAILABLE:
        raise ImportError("python-pptx library is required")

    prs = Presentation()
    theme = DESIGN_THEMES.get(theme_name, DESIGN_THEMES['professional'])

    # Set slide size (16:9)
    prs.slide_width = Inches(10)
    prs.slide_height = Inches(5.625)

    # ─────────────────────────────────────────────────────────
    # 1) 제목 슬라이드(표지) 생성
    # ─────────────────────────────────────────────────────────
    title_slide_layout = prs.slide_layouts[0]
    slide = prs.slides.add_slide(title_slide_layout)

    # 배경 그라디언트
    add_gradient_background(slide, theme['colors']['primary'], theme['colors']['secondary'])

    # AI 이미지(표지 그림)
    title_top_position = Inches(2.0)
    if include_ai_image and AI_IMAGE_ENABLED:
        logger.info("Generating AI cover image via API...")
        ai_image_path = generate_ai_cover_image_via_api(topic, slides_data)
        if ai_image_path and os.path.exists(ai_image_path):
            img = Image.open(ai_image_path)
            img_width, img_height = img.size

            # 이미지 더 크게 (60% 폭, 최대 높이 4")
            max_width = Inches(6)
            ratio = img_height / img_width
            img_w = max_width
            img_h = max_width * ratio
            max_height = Inches(4)
            if img_h > max_height:
                img_h = max_height
                img_w = max_height / ratio

            left = (prs.slide_width - img_w) / 2
            top = Inches(0.6)

            pic = slide.shapes.add_picture(ai_image_path, left, top, width=img_w, height=img_h)
            pic.shadow.inherit = False
            pic.shadow.visible = True
            pic.shadow.blur_radius = Pt(15)
            pic.shadow.distance = Pt(8)
            pic.shadow.angle = 45

            title_top_position = top + img_h + Inches(0.35)

            try:
                os.unlink(ai_image_path)
            except Exception as e:
                logger.warning(f"Temp image delete failed: {e}")

    # 제목 / 부제목 텍스트
    title_shape = slide.shapes.title
    subtitle_shape = slide.placeholders[1] if len(slide.placeholders) > 1 else None

    if title_shape:
        title_shape.left = Inches(0.5)
        title_shape.width = prs.slide_width - Inches(1)
        title_shape.top = int(title_top_position)
        title_shape.height = Inches(1.2)

        tf = title_shape.text_frame
        tf.clear()
        tf.text = topic
        p = tf.paragraphs[0]
        p.font.name = theme['fonts']['title']
        p.font.size = Pt(32)
        p.font.bold = True
        p.font.color.rgb = RGBColor(255, 255, 255)
        p.alignment = PP_ALIGN.CENTER

        # 가로 방향 고정
        bodyPr = tf._txBody.bodyPr
        bodyPr.set('vert', 'horz')

        # 최상위 레이어로 이동
        slide.shapes._spTree.remove(title_shape._element)
        slide.shapes._spTree.append(title_shape._element)

    if subtitle_shape:
        subtitle_shape.left = Inches(0.5)
        subtitle_shape.width = prs.slide_width - Inches(1)
        subtitle_shape.top = int(title_top_position + Inches(1.0))
        subtitle_shape.height = Inches(0.9)

        tf2 = subtitle_shape.text_frame
        tf2.clear()
        tf2.text = f"자동 생성된 프레젠테이션  •  총 {len(slides_data)}장"
        p2 = tf2.paragraphs[0]
        p2.font.name = theme['fonts']['subtitle']
        p2.font.size = Pt(18)
        p2.font.color.rgb = RGBColor(255, 255, 255)
        p2.alignment = PP_ALIGN.CENTER

        bodyPr2 = tf2._txBody.bodyPr
        bodyPr2.set('vert', 'horz')

        slide.shapes._spTree.remove(subtitle_shape._element)
        slide.shapes._spTree.append(subtitle_shape._element)

    # 장식 요소
    add_decorative_shapes(slide, theme)

    # Add content slides with consistent design
    for i, slide_data in enumerate(slides_data):
        layout_type = slide_data.get('layout', 'title_content')
        
        # Log slide creation
        logger.info(f"Creating slide {i+1}: {slide_data.get('title', 'No title')}")
        logger.debug(f"Content length: {len(slide_data.get('content', ''))}")
        
        # Choose appropriate layout
        if layout_type == 'section_header' and len(prs.slide_layouts) > 2:
            slide_layout = prs.slide_layouts[2]
        elif layout_type == 'two_content' and len(prs.slide_layouts) > 3:
            slide_layout = prs.slide_layouts[3]
        elif layout_type == 'comparison' and len(prs.slide_layouts) > 4:
            slide_layout = prs.slide_layouts[4]
        else:
            slide_layout = prs.slide_layouts[1] if len(prs.slide_layouts) > 1 else prs.slide_layouts[0]
        
        slide = prs.slides.add_slide(slide_layout)
        
        # Apply theme to EVERY slide for consistency
        apply_theme_to_slide(slide, theme, layout_type)
        
        # Set title
        if slide.shapes.title:
            slide.shapes.title.text = slide_data.get('title', '제목 없음')
            # IMMEDIATELY set title font size after setting text
            try:
                title_text_frame = slide.shapes.title.text_frame
                if title_text_frame and title_text_frame.paragraphs:
                    for paragraph in title_text_frame.paragraphs:
                        if layout_type == 'section_header':
                            paragraph.font.size = Pt(28)  # Increased from 20
                            paragraph.font.color.rgb = RGBColor(255, 255, 255)
                            paragraph.alignment = PP_ALIGN.CENTER
                        else:
                            paragraph.font.size = Pt(24)  # Increased from 18
                            paragraph.font.color.rgb = theme['colors']['primary']
                        paragraph.font.bold = True
                        paragraph.font.name = theme['fonts']['title']
            except Exception as e:
                logger.warning(f"Title font sizing failed: {e}")
        
        # Add content based on layout - COMPLETELY FIXED VERSION
        if layout_type == 'section_header':
            # Section header content handling
            content = slide_data.get('content', '')
            if content:
                logger.info(f"Adding content to section header slide {i+1}: {content[:50]}...")
                textbox = slide.shapes.add_textbox(
                    Inches(1), Inches(3.5), Inches(8), Inches(1.5)
                )
                tf = textbox.text_frame
                tf.clear()
                tf.text = content
                tf.word_wrap = True
                
                for paragraph in tf.paragraphs:
                    paragraph.font.name = theme['fonts']['body']
                    paragraph.font.size = Pt(16)
                    paragraph.font.color.rgb = RGBColor(255, 255, 255)
                    paragraph.alignment = PP_ALIGN.CENTER
            
            # Add decorative line
            line = slide.shapes.add_shape(
                MSO_SHAPE.RECTANGLE, Inches(3), Inches(3.2), Inches(4), Pt(4)
            )
            line.fill.solid()
            line.fill.fore_color.rgb = RGBColor(255, 255, 255)
            line.line.fill.background()
        
        elif layout_type == 'two_content':
            content = slide_data.get('content', '')
            if content:
                logger.info(f"Creating two-column layout for slide {i+1}")
                content_lines = content.split('\n')
                mid_point = len(content_lines) // 2
                
                # Left column
                left_box = slide.shapes.add_textbox(
                    Inches(0.5), Inches(1.5), Inches(4.5), Inches(3.5)
                )
                left_tf = left_box.text_frame
                left_tf.clear()
                left_content = '\n'.join(content_lines[:mid_point])
                if left_content:
                    left_tf.text = left_content
                    left_tf.word_wrap = True
                    force_font_size(left_tf, 14, theme)
                    
                    # Apply emoji bullets
                    for paragraph in left_tf.paragraphs:
                        text = paragraph.text.strip()
                        if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
                            clean_text = text.lstrip('-•● ')
                            emoji = get_emoji_for_content(clean_text)
                            paragraph.text = f"{emoji} {clean_text}"
                            force_font_size(left_tf, 14, theme)
                
                # Right column
                right_box = slide.shapes.add_textbox(
                    Inches(5), Inches(1.5), Inches(4.5), Inches(3.5)
                )
                right_tf = right_box.text_frame
                right_tf.clear()
                right_content = '\n'.join(content_lines[mid_point:])
                if right_content:
                    right_tf.text = right_content
                    right_tf.word_wrap = True
                    force_font_size(right_tf, 14, theme)
                    
                    # Apply emoji bullets
                    for paragraph in right_tf.paragraphs:
                        text = paragraph.text.strip()
                        if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
                            clean_text = text.lstrip('-•● ')
                            emoji = get_emoji_for_content(clean_text)
                            paragraph.text = f"{emoji} {clean_text}"
                            force_font_size(right_tf, 14, theme)
        
        else:
            # Regular content - MOST IMPORTANT PART - COMPLETELY FIXED
            content = slide_data.get('content', '')
            
            # 디버깅 로그
            logger.info(f"Slide {i+1} - Content to add: '{content[:100]}...' (length: {len(content)})")
            
            if include_charts and slide_data.get('chart_data'):
                create_chart_slide(slide, slide_data['chart_data'], theme)
            
            # content가 있으면 무조건 텍스트박스 추가
            if content and content.strip():
                # 명확한 위치와 크기로 텍스트박스 생성
                textbox = slide.shapes.add_textbox(
                    Inches(0.5),   # left
                    Inches(1.5),   # top  
                    Inches(9),     # width
                    Inches(3.5)    # height
                )
                
                tf = textbox.text_frame
                tf.clear()
                
                # 텍스트 설정
                tf.text = content.strip()
                tf.word_wrap = True
                
                # 텍스트 프레임 여백 설정
                tf.margin_left = Inches(0.1)
                tf.margin_right = Inches(0.1)
                tf.margin_top = Inches(0.05)
                tf.margin_bottom = Inches(0.05)
                
                # 폰트 강제 적용
                force_font_size(tf, 16, theme)
                
                # 각 단락에 대해 처리
                for p_idx, paragraph in enumerate(tf.paragraphs):
                    if paragraph.text.strip():
                        # 이모지 추가
                        text = paragraph.text.strip()
                        if text.startswith(('-', '•', '●')) and not has_emoji(text):
                            clean_text = text.lstrip('-•● ')
                            emoji = get_emoji_for_content(clean_text)
                            paragraph.text = f"{emoji} {clean_text}"
                        
                        # 폰트 재적용 - 각 run에 대해 명시적으로 설정
                        if paragraph.runs:
                            for run in paragraph.runs:
                                run.font.size = Pt(16)
                                run.font.name = theme['fonts']['body']
                                run.font.color.rgb = theme['colors']['text']
                        else:
                            # runs가 없으면 생성
                            paragraph.font.size = Pt(16)
                            paragraph.font.name = theme['fonts']['body']
                            paragraph.font.color.rgb = theme['colors']['text']
                        
                        # 단락 간격
                        paragraph.space_before = Pt(6)
                        paragraph.space_after = Pt(6)
                        paragraph.line_spacing = 1.3
                
                logger.info(f"Successfully added content to slide {i+1}")
            else:
                logger.warning(f"Slide {i+1} has no content or empty content")
        
        # Add slide notes if available
        if slide_data.get('notes'):
            try:
                notes_slide = slide.notes_slide
                notes_text_frame = notes_slide.notes_text_frame
                notes_text_frame.text = slide_data.get('notes', '')
            except Exception as e:
                logger.warning(f"Failed to add slide notes: {e}")
        
        # Add slide number with better design
        slide_number_bg = slide.shapes.add_shape(
            MSO_SHAPE.ROUNDED_RECTANGLE,
            Inches(8.3), Inches(5.0), Inches(1.5), Inches(0.5)
        )
        slide_number_bg.fill.solid()
        slide_number_bg.fill.fore_color.rgb = theme['colors']['primary']
        slide_number_bg.fill.transparency = 0.8
        slide_number_bg.line.fill.background()
        
        slide_number_box = slide.shapes.add_textbox(
            Inches(8.3), Inches(5.05), Inches(1.5), Inches(0.4)
        )
        slide_number_frame = slide_number_box.text_frame
        slide_number_frame.text = f"{i + 1} / {len(slides_data)}"
        slide_number_frame.paragraphs[0].font.size = Pt(10)  # Increased from 8
        slide_number_frame.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
        slide_number_frame.paragraphs[0].font.bold = False
        slide_number_frame.paragraphs[0].alignment = PP_ALIGN.CENTER
        
        # Add subtle design element on alternating slides
        if i % 2 == 0:
            accent_shape = slide.shapes.add_shape(
                MSO_SHAPE.OVAL,
                Inches(9.6), Inches(0.1),
                Inches(0.2), Inches(0.2)
            )
            accent_shape.fill.solid()
            accent_shape.fill.fore_color.rgb = theme['colors']['accent']
            accent_shape.line.fill.background()
    
    # Add thank you slide with consistent design
    thank_you_layout = prs.slide_layouts[5] if len(prs.slide_layouts) > 5 else prs.slide_layouts[0]
    thank_you_slide = prs.slides.add_slide(thank_you_layout)
    
    # Apply gradient background
    add_gradient_background(thank_you_slide, theme['colors']['secondary'], theme['colors']['primary'])
    
    if thank_you_slide.shapes.title:
        thank_you_slide.shapes.title.text = "감사합니다"
        try:
            if thank_you_slide.shapes.title.text_frame and thank_you_slide.shapes.title.text_frame.paragraphs:
                thank_you_slide.shapes.title.text_frame.paragraphs[0].font.size = Pt(36)  # Increased from 28
                thank_you_slide.shapes.title.text_frame.paragraphs[0].font.bold = True
                thank_you_slide.shapes.title.text_frame.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
                thank_you_slide.shapes.title.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER
        except Exception as e:
            logger.warning(f"Thank you slide styling failed: {e}")
    
    # Add contact or additional info placeholder
    info_box = thank_you_slide.shapes.add_textbox(
        Inches(2), Inches(3.5), Inches(6), Inches(1)
    )
    info_tf = info_box.text_frame
    info_tf.text = "AI로 생성된 프레젠테이션"
    info_tf.paragraphs[0].font.size = Pt(18)  # Increased from 14
    info_tf.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
    info_tf.paragraphs[0].alignment = PP_ALIGN.CENTER
    
    # Save to temporary file
    with tempfile.NamedTemporaryFile(delete=False, suffix=".pptx") as tmp_file:
        prs.save(tmp_file.name)
        return tmp_file.name

##############################################################################
# Streaming Response Handler for PPT Generation - IMPROVED VERSION
##############################################################################
def generate_ppt_content(topic: str, num_slides: int, additional_context: str, use_korean: bool = False, layout_style: str = "consistent") -> Iterator[str]:
    """Generate PPT content using LLM with clearer format"""
    
    # Layout instructions based on style
    layout_instructions = ""
    if layout_style == "varied":
        layout_instructions = """
슬라이드 레이아웃을 다양하게 구성해주세요:
- 매 5번째 슬라이드는 '섹션 구분' 슬라이드로 만들어주세요
- 비교나 대조 내용이 있으면 '비교' 레이아웃을 사용하세요
- 내용이 많으면 2단 구성을 고려하세요
"""
    elif layout_style == "consistent":
        layout_instructions = """
일관된 레이아웃을 유지해주세요:
- 모든 슬라이드는 동일한 구조로 작성
- 제목과 글머리 기호 형식 통일
- 간결하고 명확한 구성
"""
    
    # 더 명확한 시스템 프롬프트
    if use_korean:
        system_prompt = f"""당신은 전문적인 PPT 프레젠테이션 작성 전문가입니다. 
주어진 주제에 대해 정확히 {num_slides}장의 슬라이드 내용을 작성해주세요.

**반드시 아래 형식을 정확히 따라주세요:**

슬라이드 1
제목: [슬라이드 제목 - "슬라이드 1" 같은 번호는 포함하지 마세요]
내용:
- 첫 번째 핵심 포인트
- 두 번째 핵심 포인트
- 세 번째 핵심 포인트
- 네 번째 핵심 포인트
- 다섯 번째 핵심 포인트
노트: [발표자가 이 슬라이드를 설명할 때 사용할 구어체 스크립트]

슬라이드 2
제목: [슬라이드 제목]
내용:
- 첫 번째 핵심 포인트
- 두 번째 핵심 포인트
- 세 번째 핵심 포인트
- 네 번째 핵심 포인트
- 다섯 번째 핵심 포인트
노트: [발표 스크립트]

(이런 식으로 슬라이드 {num_slides}까지 계속)

{layout_instructions}

**중요 지침:**
1. 각 슬라이드는 "슬라이드 숫자"로 시작
2. 제목: 뒤에 실제 제목 작성 (번호 제외)
3. 내용: 뒤에 정확히 5개의 글머리 기호 포인트
4. 노트: 뒤에 발표 스크립트
5. 각 섹션 사이에 빈 줄 없음
6. 총 {num_slides}장 작성
7. 각 포인트는 '-' 기호로 시작하세요 (이모지는 자동으로 추가됩니다)
8. 노트는 해당 슬라이드의 내용을 발표자가 청중에게 설명하는 구어체 대본으로 작성하세요"""
    else:
        system_prompt = f"""You are a professional PPT presentation expert.
Create content for exactly {num_slides} slides on the given topic.

**You MUST follow this exact format:**

Slide 1
Title: [Slide title - do NOT include "Slide 1" in the title]
Content:
- First key point
- Second key point
- Third key point
- Fourth key point
- Fifth key point
Notes: [Speaker script in conversational style for explaining this slide]

Slide 2
Title: [Slide title]
Content:
- First key point
- Second key point
- Third key point
- Fourth key point
- Fifth key point
Notes: [Speaker script]

(Continue this way until Slide {num_slides})

**Important instructions:**
1. Each slide starts with "Slide number"
2. Title: followed by the actual title (no numbers)
3. Content: followed by exactly 5 bullet points
4. Notes: followed by speaker script
5. No empty lines between sections
6. Create exactly {num_slides} slides
7. Start each point with '-' (emojis will be added automatically)
8. Notes should be a speaker script explaining the slide content in conversational style"""

    # Add search results if web search is performed
    if additional_context:
        system_prompt += f"\n\n참고 정보:\n{additional_context}"
    
    # Prepare messages
    user_prompt = f"주제: {topic}\n\n위에서 설명한 형식에 맞춰 정확히 {num_slides}장의 PPT 슬라이드 내용을 작성해주세요. 각 슬라이드마다 5개의 핵심 포인트와 함께, 발표자가 청중에게 해당 내용을 설명하는 구어체 발표 대본을 노트로 작성해주세요."
    if not use_korean:
        user_prompt = f"Topic: {topic}\n\nPlease create exactly {num_slides} PPT slides following the format described above. Include exactly 5 key points per slide, and write speaker notes as a conversational script explaining the content to the audience."
    
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_prompt}
    ]
    
    # Call LLM API
    headers = {
        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": FRIENDLI_MODEL_ID,
        "messages": messages,
        "max_tokens": min(4000, num_slides * 300),  # More tokens for 5 points + notes
        "top_p": 0.9,
        "temperature": 0.8,
        "stream": True,
        "stream_options": {
            "include_usage": True
        }
    }
    
    try:
        response = requests.post(
            FRIENDLI_API_URL,
            headers=headers,
            json=payload,
            stream=True,
            timeout=60
        )
        response.raise_for_status()
        
        full_response = ""
        for line in response.iter_lines():
            if line:
                line_text = line.decode('utf-8')
                if line_text.startswith("data: "):
                    data_str = line_text[6:]
                    if data_str == "[DONE]":
                        break
                    
                    try:
                        data = json.loads(data_str)
                        if "choices" in data and len(data["choices"]) > 0:
                            delta = data["choices"][0].get("delta", {})
                            content = delta.get("content", "")
                            if content:
                                full_response += content
                                yield full_response
                    except json.JSONDecodeError:
                        logger.warning(f"JSON parsing failed: {data_str}")
                        continue
                        
    except Exception as e:
        logger.error(f"LLM API error: {str(e)}")
        yield f"⚠️ Error generating content: {str(e)}"

##############################################################################
# Main PPT Generation Function - IMPROVED VERSION with API Image
##############################################################################
def generate_ppt(
    topic: str,
    num_slides: int = 10,
    use_web_search: bool = False,
    use_korean: bool = True,
    reference_files: list = None,
    design_theme: str = "professional",
    font_style: str = "modern",
    layout_style: str = "consistent",
    include_charts: bool = False,
    include_ai_image: bool = False
) -> tuple:
    """Main function to generate PPT with advanced design and API-based AI image"""
    
    if not PPTX_AVAILABLE:
        return None, "❌ python-pptx 라이브러리가 설치되지 않았습니다.\n\n설치 명령: pip install python-pptx", ""
    
    if not topic.strip():
        return None, "❌ PPT 주제를 입력해주세요.", ""
    
    if num_slides < 3 or num_slides > 20:
        return None, "❌ 슬라이드 수는 3장 이상 20장 이하로 설정해주세요.", ""
    
    try:
        # AI 이미지 생성이 요청되었지만 초기화되지 않은 경우
        if include_ai_image and not AI_IMAGE_ENABLED:
            yield None, "🔄 AI 이미지 생성 API에 연결하는 중...", ""
            if initialize_ai_image_api():
                yield None, "✅ AI 이미지 API 연결 성공!", ""
            else:
                include_ai_image = False
                yield None, "⚠️ AI 이미지 API 연결 실패. AI 이미지 없이 진행합니다.", ""
        
        # Process reference files if provided
        additional_context = ""
        chart_data = None
        if reference_files:
            file_contents = []
            for file_path in reference_files:
                if file_path.lower().endswith(".csv"):
                    csv_content = analyze_csv_file(file_path)
                    file_contents.append(csv_content)
                    # Extract chart data if available
                    if "CHART_DATA:" in csv_content:
                        chart_json = csv_content.split("CHART_DATA:")[1]
                        try:
                            chart_data = json.loads(chart_json)
                        except:
                            pass
                elif file_path.lower().endswith(".txt"):
                    file_contents.append(analyze_txt_file(file_path))
                elif file_path.lower().endswith(".pdf"):
                    file_contents.append(pdf_to_markdown(file_path))
            
            if file_contents:
                additional_context = "\n\n".join(file_contents)
        
        # Web search if enabled
        if use_web_search:
            search_query = extract_keywords(topic, top_k=5)
            search_results = do_web_search(search_query, use_korean=use_korean)
            if not search_results.startswith("Web search"):
                additional_context += f"\n\n{search_results}"
        
        # Generate PPT content
        llm_response = ""
        for response in generate_ppt_content(topic, num_slides, additional_context, use_korean, layout_style):
            llm_response = response
            yield None, f"📝 생성 중...\n\n{response}", response
        
        # Parse LLM response
        slides_data = parse_llm_ppt_response(llm_response, layout_style)
        
        # Debug: 파싱된 각 슬라이드 내용 출력
        logger.info(f"=== Parsed Slides Debug Info ===")
        for i, slide in enumerate(slides_data):
            logger.info(f"Slide {i+1}:")
            logger.info(f"  Title: {slide.get('title', 'NO TITLE')}")
            logger.info(f"  Content: {slide.get('content', 'NO CONTENT')[:100]}...")
            logger.info(f"  Content Length: {len(slide.get('content', ''))}")
            logger.info("---")
        
        # Add chart data to relevant slides if available
        if chart_data and include_charts:
            for slide in slides_data:
                if '데이터' in slide.get('title', '') or 'data' in slide.get('title', '').lower():
                    slide['chart_data'] = chart_data
                    break
        
        # Debug logging
        logger.info(f"Parsed {len(slides_data)} slides from LLM response")
        logger.info(f"Design theme: {design_theme}, Layout style: {layout_style}")
        
        if not slides_data:
            # Show the raw response for debugging
            error_msg = "❌ PPT 내용 파싱에 실패했습니다.\n\n"
            error_msg += "LLM 응답을 확인해주세요:\n"
            error_msg += "=" * 50 + "\n"
            error_msg += llm_response[:500] + "..." if len(llm_response) > 500 else llm_response
            yield None, error_msg, llm_response
            return
        
        # AI 이미지 생성 알림
        if include_ai_image and AI_IMAGE_ENABLED:
            yield None, f"📝 슬라이드 생성 완료!\n\n🎨 AI 3D 표지 이미지 생성 중... (30초 정도 소요)", llm_response
        
        # Create PPT file with advanced design
        ppt_path = create_advanced_ppt_from_content(slides_data, topic, design_theme, include_charts, include_ai_image)
        
        success_msg = f"✅ PPT 파일이 성공적으로 생성되었습니다!\n\n"
        success_msg += f"📊 주제: {topic}\n"
        success_msg += f"📄 슬라이드 수: {len(slides_data)}장\n"
        success_msg += f"🎨 디자인 테마: {DESIGN_THEMES[design_theme]['name']}\n"
        success_msg += f"📐 레이아웃 스타일: {layout_style}\n"
        if include_ai_image and AI_IMAGE_ENABLED:
            success_msg += f"🖼️ AI 생성 3D 스타일 표지 이미지 포함\n"
        success_msg += f"📝 생성된 슬라이드:\n"
        
        for i, slide in enumerate(slides_data[:5]):  # Show first 5 slides
            success_msg += f"  {i+1}. {slide.get('title', '제목 없음')} [{slide.get('layout', 'standard')}]\n"
            if slide.get('notes'):
                success_msg += f"     💡 노트: {slide.get('notes', '')[:50]}...\n"
        
        if len(slides_data) > 5:
            success_msg += f"  ... 외 {len(slides_data) - 5}장"
        
        yield ppt_path, success_msg, llm_response
        
    except Exception as e:
        logger.error(f"PPT generation error: {str(e)}")
        import traceback
        error_details = traceback.format_exc()
        logger.error(f"Error details: {error_details}")
        yield None, f"❌ PPT 생성 중 오류 발생: {str(e)}\n\n상세 오류:\n{error_details}", ""

##############################################################################
# Gradio UI
##############################################################################
css = """
/* Full width UI */
.gradio-container {
    background: rgba(255, 255, 255, 0.98);
    padding: 40px 50px;
    margin: 30px auto;
    width: 100% !important;
    max-width: 1400px !important;
    border-radius: 20px;
    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.1);
}

/* Background */
body {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    margin: 0;
    padding: 0;
    font-family: 'Segoe UI', 'Helvetica Neue', Arial, sans-serif;
}

/* Title styling */
h1 {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    background-clip: text;
    -webkit-background-clip: text;
    -webkit-text-fill-color: transparent;
    font-weight: 700;
    margin-bottom: 10px;
}

/* Button styles */
button.primary {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
    border: none;
    color: white !important;
    font-weight: 600;
    padding: 15px 30px !important;
    font-size: 18px !important;
    transition: all 0.3s ease;
    text-transform: uppercase;
    letter-spacing: 1px;
}

button.primary:hover {
    transform: translateY(-3px);
    box-shadow: 0 8px 20px rgba(102, 126, 234, 0.4);
}

/* Input styles */
.textbox, textarea, input[type="text"], input[type="number"] {
    border: 2px solid #e5e7eb;
    border-radius: 12px;
    padding: 15px;
    font-size: 16px;
    transition: all 0.3s ease;
    background: white;
}

.textbox:focus, textarea:focus, input[type="text"]:focus {
    border-color: #667eea;
    outline: none;
    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
}

/* Card style */
.card {
    background: white;
    border-radius: 16px;
    padding: 25px;
    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.08);
    margin-bottom: 25px;
    border: 1px solid rgba(102, 126, 234, 0.1);
}

/* Dropdown styles */
.dropdown {
    border: 2px solid #e5e7eb;
    border-radius: 12px;
    padding: 12px;
    background: white;
    transition: all 0.3s ease;
}

.dropdown:hover {
    border-color: #667eea;
}

/* Slider styles */
.gr-slider input[type="range"] {
    background: linear-gradient(to right, #667eea 0%, #764ba2 100%);
    height: 8px;
    border-radius: 4px;
}

/* File upload area */
.file-upload {
    border: 3px dashed #667eea;
    border-radius: 16px;
    padding: 40px;
    text-align: center;
    transition: all 0.3s ease;
    background: rgba(102, 126, 234, 0.02);
}

.file-upload:hover {
    border-color: #764ba2;
    background: rgba(102, 126, 234, 0.05);
    transform: scale(1.01);
}

/* Checkbox styles */
input[type="checkbox"] {
    width: 20px;
    height: 20px;
    margin-right: 10px;
    cursor: pointer;
}

/* Tab styles */
.tabs {
    border-radius: 12px;
    overflow: hidden;
    margin-bottom: 20px;
}

.tab-nav {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    padding: 5px;
}

.tab-nav button {
    background: transparent;
    color: white;
    border: none;
    padding: 10px 20px;
    margin: 0 5px;
    border-radius: 8px;
    transition: all 0.3s ease;
}

.tab-nav button.selected {
    background: white;
    color: #667eea;
}

/* Section headers */
.section-header {
    font-size: 20px;
    font-weight: 600;
    color: #667eea;
    margin: 20px 0 15px 0;
    padding-bottom: 10px;
    border-bottom: 2px solid rgba(102, 126, 234, 0.2);
}

/* Status box styling */
.status-box {
    background: linear-gradient(135deg, rgba(102, 126, 234, 0.1) 0%, rgba(118, 75, 162, 0.1) 100%);
    border-radius: 12px;
    padding: 20px;
}

/* Preview box styling */
.preview-box {
    background: #f8f9fa;
    border-radius: 12px;
    padding: 20px;
    font-family: 'Courier New', monospace;
    font-size: 13px;
    line-height: 1.5;
    max-height: 500px;
    overflow-y: auto;
}
"""

with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
    gr.Markdown(
        """
        # 🎯 AI 기반 PPT 자동 생성 시스템 Pro
        
        고급 디자인 테마와 레이아웃을 활용한 전문적인 프레젠테이션을 자동으로 생성합니다.
        각 슬라이드마다 5개의 핵심 포인트와 발표자 노트를 포함합니다.
        """
    )
    
    with gr.Row():
        with gr.Column(scale=2):
            topic_input = gr.Textbox(
                label="📌 PPT 주제",
                placeholder="예: 인공지능의 미래와 산업 적용 사례",
                lines=2,
                elem_classes="card"
            )
            
            with gr.Row():
                with gr.Column():
                    num_slides = gr.Slider(
                        label="📄 슬라이드 수",
                        minimum=3,
                        maximum=20,
                        step=1,
                        value=10,
                        info="생성할 슬라이드 개수 (3-20장)"
                    )
                
                with gr.Column():
                    use_korean = gr.Checkbox(
                        label="🇰🇷 한국어",
                        value=True,
                        info="한국어로 생성"
                    )
                    
                    use_web_search = gr.Checkbox(
                        label="🔍 웹 검색",
                        value=False,
                        info="최신 정보 검색"
                    )
            
            # Design Options Section
            gr.Markdown("<div class='section-header'>🎨 디자인 옵션</div>")
            
            with gr.Row():
                design_theme = gr.Dropdown(
                    label="디자인 테마",
                    choices=[
                        ("프로페셔널 (파랑/회색)", "professional"),
                        ("모던 (보라/핑크)", "modern"),
                        ("자연 (초록/갈색)", "nature"),
                        ("크리에이티브 (다채로운)", "creative"),
                        ("미니멀 (흑백)", "minimal")
                    ],
                    value="professional",
                    elem_classes="dropdown"
                )
                
                layout_style = gr.Dropdown(
                    label="레이아웃 스타일",
                    choices=[
                        ("일관된 레이아웃", "consistent"),
                        ("다양한 레이아웃", "varied"),
                        ("미니멀 레이아웃", "minimal")
                    ],
                    value="consistent",
                    elem_classes="dropdown"
                )
            
            with gr.Row():
                font_style = gr.Dropdown(
                    label="폰트 스타일",
                    choices=[
                        ("모던", "modern"),
                        ("클래식", "classic"),
                        ("캐주얼", "casual")
                    ],
                    value="modern",
                    elem_classes="dropdown"
                )
                
                include_charts = gr.Checkbox(
                    label="📊 차트 포함",
                    value=False,
                    info="CSV 데이터가 있을 경우 차트 생성"
                )
            
            include_ai_image = gr.Checkbox(
                label="🖼️ AI 3D 표지 이미지",
                value=False,
                info="AI로 생성한 3D 스타일 이미지를 표지에 추가 (생성 시간 30초 추가)"
            )
            
            reference_files = gr.File(
                label="📎 참고 자료 (선택사항)",
                file_types=[".pdf", ".csv", ".txt"],
                file_count="multiple",
                elem_classes="file-upload"
            )
            
            generate_btn = gr.Button(
                "🚀 PPT 생성하기",
                variant="primary",
                size="lg"
            )
        
        with gr.Column(scale=1):
            download_file = gr.File(
                label="📥 생성된 PPT 다운로드",
                interactive=False,
                elem_classes="card"
            )
            
            status_text = gr.Textbox(
                label="📊 생성 상태",
                lines=10,
                interactive=False,
                elem_classes="status-box"
            )
    
    with gr.Row():
        content_preview = gr.Textbox(
            label="📝 생성된 내용 미리보기",
            lines=20,
            interactive=False,
            visible=True,
            elem_classes="preview-box"
        )
    
    gr.Markdown(
        """
        ### 📋 사용 방법
        1. **PPT 주제 입력**: 구체적인 주제일수록 더 좋은 결과
        2. **슬라이드 수 선택**: 3-20장 범위에서 선택
        3. **디자인 테마 선택**: 5가지 전문적인 테마 중 선택
        4. **추가 옵션 설정**: 웹 검색, 차트 포함 등
        5. **AI 3D 이미지**: 주제를 상징하는 3D 스타일 표지 이미지 생성
        6. **참고 자료 업로드**: PDF, CSV, TXT 파일 지원
        7. **생성 버튼 클릭**: AI가 자동으로 PPT 생성
        
        ### 🎨 디자인 테마 특징
        - **프로페셔널**: 비즈니스 프레젠테이션에 적합한 깔끔한 디자인
        - **모던**: 트렌디하고 세련된 색상 조합
        - **자연**: 편안하고 친근한 느낌의 자연 색상
        - **크리에이티브**: 대담하고 활기찬 색상으로 주목도 높음
        - **미니멀**: 깔끔하고 단순한 흑백 디자인
        
        ### ✨ 새로운 기능
        - **5개 핵심 포인트**: 각 슬라이드마다 5개의 핵심 내용
        - **발표자 노트**: 각 슬라이드마다 발표자를 위한 노트 자동 생성
        - **향상된 폰트 크기**: 더 큰 폰트로 가독성 향상
        - **AI 3D 이미지**: API를 통한 고품질 3D 스타일 표지 이미지 (한글 프롬프트 지원)
        
        ### 💡 고급 팁
        - CSV 파일 업로드 시 '차트 포함' 옵션으로 데이터 시각화 가능
        - 웹 검색 활성화로 최신 정보 반영
        - AI 이미지는 주제의 핵심 키워드를 분석하여 자동 생성
        - 다양한 레이아웃으로 시각적 흥미 유발
        """
    )
    
    # Examples
    gr.Examples(
        examples=[
            ["인공지능의 미래와 산업 적용 사례", 10, False, True, [], "professional", "modern", "consistent", False, False],
            ["2024년 디지털 마케팅 트렌드", 12, True, True, [], "modern", "modern", "consistent", False, True],
            ["기후변화와 지속가능한 발전", 15, True, True, [], "nature", "classic", "consistent", False, True],
            ["스타트업 사업계획서", 8, False, True, [], "creative", "modern", "varied", False, True],
        ],
        inputs=[topic_input, num_slides, use_web_search, use_korean, reference_files, 
                design_theme, font_style, layout_style, include_charts, include_ai_image],
    )
    
    # Event handler
    generate_btn.click(
        fn=generate_ppt,
        inputs=[
            topic_input,
            num_slides,
            use_web_search,
            use_korean,
            reference_files,
            design_theme,
            font_style,
            layout_style,
            include_charts,
            include_ai_image
        ],
        outputs=[download_file, status_text, content_preview]
    )

if __name__ == "__main__":
    demo.launch()