Update app.py

app.py

@@ -6,11 +6,32 @@ 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
@@ -27,6 +48,282 @@ 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
 ##############################################################################
@@ -182,11 +479,17 @@ def analyze_csv_file(path: str) -> str:
         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}"
+        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)}"
@@ -256,127 +559,972 @@ def pdf_to_markdown(pdf_path: str) -> str:
     return f"**[PDF File: {os.path.basename(pdf_path)}]**\n\n{full_text}"
 
 ##############################################################################
-# File Type Check Functions
+# AI Image Generation Functions using API
 ##############################################################################
-def is_image_file(file_path: str) -> bool:
-    """Check if file is an image"""
-    return bool(re.search(r"\.(png|jpg|jpeg|gif|webp)$", file_path, re.IGNORECASE))
+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 is_video_file(file_path: str) -> bool:
-    """Check if file is a video"""
-    return bool(re.search(r"\.(mp4|avi|mov|mkv)$", file_path, re.IGNORECASE))
 
-def is_document_file(file_path: str) -> bool:
-    """Check if file is a document"""
-    return bool(re.search(r"\.(pdf|csv|txt)$", file_path, re.IGNORECASE))
+
+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
+
 
 ##############################################################################
-# Message Processing Functions
+# PPT Generation Functions - FIXED VERSION
 ##############################################################################
-def process_new_user_message(message: dict) -> str:
-    """Process user message and convert to text"""
-    content_parts = [message["text"]]
+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)
     
-    if not message.get("files"):
-        return message["text"]
+    logger.info(f"Total slides parsed: {len(slides)}")
+    return slides
 
-    # Classify files
-    csv_files = []
-    txt_files = []
-    pdf_files = []
-    image_files = []
-    video_files = []
-    unknown_files = []
+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
     
-    for file_path in message["files"]:
-        if file_path.lower().endswith(".csv"):
-            csv_files.append(file_path)
-        elif file_path.lower().endswith(".txt"):
-            txt_files.append(file_path)
-        elif file_path.lower().endswith(".pdf"):
-            pdf_files.append(file_path)
-        elif is_image_file(file_path):
-            image_files.append(file_path)
-        elif is_video_file(file_path):
-            video_files.append(file_path)
-        else:
-            unknown_files.append(file_path)
-    
-    # Process document files
-    for csv_path in csv_files:
-        csv_analysis = analyze_csv_file(csv_path)
-        content_parts.append(csv_analysis)
-
-    for txt_path in txt_files:
-        txt_analysis = analyze_txt_file(txt_path)
-        content_parts.append(txt_analysis)
-
-    for pdf_path in pdf_files:
-        pdf_markdown = pdf_to_markdown(pdf_path)
-        content_parts.append(pdf_markdown)
-    
-    # Warning messages for unsupported files
-    if image_files:
-        image_names = [os.path.basename(f) for f in image_files]
-        content_parts.append(
-            f"\n⚠️ **Image files detected**: {', '.join(image_names)}\n"
-            "This demo currently does not support image analysis. "
-            "Please describe the image content in text if you need help with it."
+    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']
     
-    if video_files:
-        video_names = [os.path.basename(f) for f in video_files]
-        content_parts.append(
-            f"\n⚠️ **Video files detected**: {', '.join(video_names)}\n"
-            "This demo currently does not support video analysis. "
-            "Please describe the video content in text if you need help with it."
+    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()
         
-    if unknown_files:
-        unknown_names = [os.path.basename(f) for f in unknown_files]
-        content_parts.append(
-            f"\n⚠️ **Unsupported file format**: {', '.join(unknown_names)}\n"
-            "Supported formats: PDF, CSV, TXT"
+        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'])
     
-    return "\n\n".join(content_parts)
-
-def process_history(history: list[dict]) -> list[dict]:
-    """Convert conversation history to Friendli API format"""
-    messages = []
-    
-    for item in history:
-        if item["role"] == "assistant":
-            messages.append({
-                "role": "assistant",
-                "content": item["content"]
-            })
-        else:  # user
-            content = item["content"]
-            if isinstance(content, str):
-                messages.append({
-                    "role": "user",
-                    "content": content
-                })
-            elif isinstance(content, list) and len(content) > 0:
-                # File processing
-                file_info = []
-                for file_path in content:
-                    if isinstance(file_path, str):
-                        file_info.append(f"[File: {os.path.basename(file_path)}]")
-                if file_info:
-                    messages.append({
-                        "role": "user",
-                        "content": " ".join(file_info)
-                    })
-    
-    return messages
-
-##############################################################################
-# Streaming Response Handler
-##############################################################################
-def stream_friendli_response(messages: list[dict], max_tokens: int = 1000) -> Iterator[str]:
-    """Get streaming response from Friendli AI API"""
+    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"
@@ -385,9 +1533,9 @@ def stream_friendli_response(messages: list[dict], max_tokens: int = 1000) -> It
     payload = {
         "model": FRIENDLI_MODEL_ID,
         "messages": messages,
-        "max_tokens": max_tokens,
-        "top_p": 0.8,
-        "temperature": 0.7,
+        "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
@@ -425,341 +1573,517 @@ def stream_friendli_response(messages: list[dict], max_tokens: int = 1000) -> It
                         logger.warning(f"JSON parsing failed: {data_str}")
                         continue
                         
-    except requests.exceptions.Timeout:
-        yield "⚠️ Response timeout. Please try again."
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Friendli API network error: {e}")
-        yield f"⚠️ Network error occurred: {str(e)}"
     except Exception as e:
-        logger.error(f"Friendli API error: {str(e)}")
-        yield f"⚠️ API call error: {str(e)}"
+        logger.error(f"LLM API error: {str(e)}")
+        yield f"⚠️ Error generating content: {str(e)}"
 
 ##############################################################################
-# Main Inference Function
+# Main PPT Generation Function - IMPROVED VERSION with API Image
 ##############################################################################
-
-def run(
-    message: dict,
-    history: list[dict],
-    max_new_tokens: int = 512,
+def generate_ppt(
+    topic: str,
+    num_slides: int = 10,
     use_web_search: bool = False,
-    use_korean: bool = False,
-    system_prompt: str = "",
-) -> Iterator[str]:
+    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:
-        # Prepare system message
-        messages = []
-        
-        if use_korean:
-            combined_system_msg = "너는 AI 어시스턴트 역할이다. 한국어로 친절하고 정확하게 답변해라."
-        else:
-            combined_system_msg = "You are an AI assistant. Please respond helpfully and accurately in English."
+        # 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 이미지 없이 진행합니다.", ""
         
-        if system_prompt.strip():
-            combined_system_msg += f"\n\n{system_prompt.strip()}"
+        # 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 processing
+        # Web search if enabled
         if use_web_search:
-            user_text = message.get("text", "")
-            if user_text:
-                ws_query = extract_keywords(user_text, top_k=5)
-                if ws_query.strip():
-                    logger.info(f"[Auto web search keywords] {ws_query!r}")
-                    ws_result = do_web_search(ws_query, use_korean=use_korean)
-                    if not ws_result.startswith("Web search"):
-                        combined_system_msg += f"\n\n[Search Results]\n{ws_result}"
-                        if use_korean:
-                            combined_system_msg += "\n\n[중요: 답변에 검색 결과의 출처를 반드시 인용하세요]"
-                        else:
-                            combined_system_msg += "\n\n[Important: Always cite sources from search results in your answer]"
+            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}"
         
-        messages.append({
-            "role": "system",
-            "content": combined_system_msg
-        })
+        # 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
         
-        # Add conversation history
-        messages.extend(process_history(history))
+        # Parse LLM response
+        slides_data = parse_llm_ppt_response(llm_response, layout_style)
         
-        # Process current message
-        user_content = process_new_user_message(message)
-        messages.append({
-            "role": "user",
-            "content": user_content
-        })
+        # 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("---")
         
-        # Debug log
-        logger.debug(f"Total messages: {len(messages)}")
+        # 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
         
-        # Call Friendli API and stream
-        for response_text in stream_friendli_response(messages, max_new_tokens):
-            yield response_text
-            
     except Exception as e:
-        logger.error(f"run function error: {str(e)}")
-        yield f"⚠️ Sorry, an error occurred: {str(e)}"
-
-##############################################################################
-# Examples
-##############################################################################
-examples = [
-    # PDF comparison example
-    [
-        {
-            "text": "Compare the contents of the two PDF files.",
-            "files": [
-                "assets/additional-examples/before.pdf",
-                "assets/additional-examples/after.pdf",
-            ],
-        }
-    ],
-    # CSV analysis example
-    [
-        {
-            "text": "Summarize and analyze the contents of the CSV file.",
-            "files": ["assets/additional-examples/sample-csv.csv"],
-        }
-    ],
-    # Web search example
-    [
-        {
-            "text": "Explain discord.gg/openfreeai",
-            "files": [],
-        }
-    ],
-    # Code generation example
-    [
-        {
-            "text": "Write Python code to generate Fibonacci sequence.",
-            "files": [],
-        }
-    ],
-]
+        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 Styles (Removed blue colors)
+# Gradio UI
 ##############################################################################
 css = """
 /* Full width UI */
 .gradio-container {
-    background: rgba(255, 255, 255, 0.95);
-    padding: 30px 40px;
-    margin: 20px auto;
+    background: rgba(255, 255, 255, 0.98);
+    padding: 40px 50px;
+    margin: 30px auto;
     width: 100% !important;
-    max-width: none !important;
-    border-radius: 12px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-}
-
-.fillable {
-    width: 100% !important; 
-    max-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, #f5f7fa 0%, #e0e0e0 100%);
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
     margin: 0;
     padding: 0;
     font-family: 'Segoe UI', 'Helvetica Neue', Arial, sans-serif;
-    color: #333;
 }
 
-/* Button styles - neutral gray */
-button, .btn {
-    background: #6b7280 !important;
+/* 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;
-    padding: 10px 20px;
-    text-transform: uppercase;
     font-weight: 600;
-    letter-spacing: 0.5px;
-    cursor: pointer;
-    border-radius: 6px;
+    padding: 15px 30px !important;
+    font-size: 18px !important;
     transition: all 0.3s ease;
+    text-transform: uppercase;
+    letter-spacing: 1px;
 }
 
-button:hover, .btn:hover {
-    background: #4b5563 !important;
-    transform: translateY(-1px);
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
-}
-
-/* Examples section */
-#examples_container, .examples-container {
-    margin: 20px auto;
-    width: 90%;
-    background: rgba(255, 255, 255, 0.8);
-    padding: 20px;
-    border-radius: 8px;
-}
-
-#examples_row, .examples-row {
-    justify-content: center;
+button.primary:hover {
+    transform: translateY(-3px);
+    box-shadow: 0 8px 20px rgba(102, 126, 234, 0.4);
 }
 
-/* Example buttons */
-.gr-samples-table button,
-.gr-examples button,
-.examples button {
-    background: #f0f2f5 !important;
-    border: 1px solid #d1d5db;
-    color: #374151 !important;
-    margin: 5px;
-    font-size: 14px;
+/* 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;
 }
 
-.gr-samples-table button:hover,
-.gr-examples button:hover,
-.examples button:hover {
-    background: #e5e7eb !important;
-    border-color: #9ca3af;
+.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);
 }
 
-/* Chat interface */
-.chatbox, .chatbot {
-    background: white !important;
-    border-radius: 8px;
-    box-shadow: 0 1px 3px rgba(0, 0, 0, 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);
 }
 
-.message {
-    padding: 15px;
-    margin: 10px 0;
-    border-radius: 8px;
+/* Dropdown styles */
+.dropdown {
+    border: 2px solid #e5e7eb;
+    border-radius: 12px;
+    padding: 12px;
+    background: white;
+    transition: all 0.3s ease;
 }
 
-/* Input styles */
-.multimodal-textbox, textarea, input[type="text"] {
-    background: white !important;
-    border: 1px solid #d1d5db;
-    border-radius: 6px;
-    padding: 10px;
-    font-size: 16px;
+.dropdown:hover {
+    border-color: #667eea;
 }
 
-.multimodal-textbox:focus, textarea:focus, input[type="text"]:focus {
-    border-color: #6b7280;
-    outline: none;
-    box-shadow: 0 0 0 3px rgba(107, 114, 128, 0.1);
+/* Slider styles */
+.gr-slider input[type="range"] {
+    background: linear-gradient(to right, #667eea 0%, #764ba2 100%);
+    height: 8px;
+    border-radius: 4px;
 }
 
-/* Warning messages */
-.warning-box {
-    background: #fef3c7 !important;
-    border: 1px solid #f59e0b;
-    border-radius: 8px;
-    padding: 15px;
-    margin: 10px 0;
-    color: #92400e;
+/* 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);
 }
 
-/* Headings */
-h1, h2, h3 {
-    color: #1f2937;
+.file-upload:hover {
+    border-color: #764ba2;
+    background: rgba(102, 126, 234, 0.05);
+    transform: scale(1.01);
 }
 
-/* Links - neutral gray */
-a {
-    color: #6b7280;
-    text-decoration: none;
+/* Checkbox styles */
+input[type="checkbox"] {
+    width: 20px;
+    height: 20px;
+    margin-right: 10px;
+    cursor: pointer;
 }
 
-a:hover {
-    text-decoration: underline;
-    color: #4b5563;
+/* Tab styles */
+.tabs {
+    border-radius: 12px;
+    overflow: hidden;
+    margin-bottom: 20px;
 }
 
-/* Slider */
-.gr-slider {
-    margin: 15px 0;
+.tab-nav {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    padding: 5px;
 }
 
-/* Checkbox */
-input[type="checkbox"] {
-    width: 18px;
-    height: 18px;
-    margin-right: 8px;
+.tab-nav button {
+    background: transparent;
+    color: white;
+    border: none;
+    padding: 10px 20px;
+    margin: 0 5px;
+    border-radius: 8px;
+    transition: all 0.3s ease;
 }
 
-/* Scrollbar */
-::-webkit-scrollbar {
-    width: 8px;
-    height: 8px;
+.tab-nav button.selected {
+    background: white;
+    color: #667eea;
 }
 
-::-webkit-scrollbar-track {
-    background: #f1f1f1;
+/* 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);
 }
 
-::-webkit-scrollbar-thumb {
-    background: #888;
-    border-radius: 4px;
+/* 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;
 }
 
-::-webkit-scrollbar-thumb:hover {
-    background: #555;
+/* 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;
 }
 """
 
-##############################################################################
-# Gradio UI Main
-##############################################################################
-with gr.Blocks(css=css, title="Gemma-3-R1984-27B Chatbot") as demo:
-    # Title
-    gr.Markdown("# 🤗 Gemma-3-R1984-27B Chatbot")
-    gr.Markdown("Community: [https://discord.gg/openfreeai](https://discord.gg/openfreeai)")
+with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
+    gr.Markdown(
+        """
+        # 🎯 AI 기반 PPT 자동 생성 시스템 Pro
+        
+        고급 디자인 테마와 레이아웃을 활용한 전문적인 프레젠테이션을 자동으로 생성합니다.
+        각 슬라이드마다 5개의 핵심 포인트와 발표자 노트를 포함합니다.
+        """
+    )
     
-    # UI Components
     with gr.Row():
         with gr.Column(scale=2):
-            web_search_checkbox = gr.Checkbox(
-                label="🔍 Enable Deep Research (Web Search)",
-                value=False,
-                info="Check for questions requiring latest information"
+            topic_input = gr.Textbox(
+                label="📌 PPT 주제",
+                placeholder="예: 인공지능의 미래와 산업 적용 사례",
+                lines=2,
+                elem_classes="card"
             )
-        with gr.Column(scale=1):
-            korean_checkbox = gr.Checkbox(
-                label="🇰🇷 한글 (Korean)",
+            
+            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="Check for Korean responses"
+                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):
-            max_tokens_slider = gr.Slider(
-                label="Max Tokens",
-                minimum=100,
-                maximum=8000,
-                step=50,
-                value=1000,
-                info="Adjust response length"
+            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],
+    )
     
-    # Main chat interface
-    chat = gr.ChatInterface(
-        fn=run,
-        type="messages",
-        chatbot=gr.Chatbot(type="messages", scale=1),
-        textbox=gr.MultimodalTextbox(
-            file_types=[
-                ".webp", ".png", ".jpg", ".jpeg", ".gif",
-                ".mp4", ".csv", ".txt", ".pdf"
-            ],
-            file_count="multiple",
-            autofocus=True,
-            placeholder="Enter text or upload PDF, CSV, TXT files. (Images/videos not supported in this demo)"
-        ),
-        multimodal=True,
-        additional_inputs=[
-            max_tokens_slider,
-            web_search_checkbox,
-            korean_checkbox,
+    # 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
         ],
-        stop_btn=False,
-        examples=examples,
-        run_examples_on_click=False,
-        cache_examples=False,
-        delete_cache=(1800, 1800),
+        outputs=[download_file, status_text, content_preview]
     )
 
 if __name__ == "__main__":