app.py

# app.py
"""Main PPT Generator with 3-AI collaboration system"""

import os
import re
import json
import time
import logging
import gradio as gr
import requests
from typing import List, Dict, Generator
from datetime import datetime

# Import separated modules
from constants import (
    EXAMPLE_TOPICS, AUDIENCE_TYPES, DESIGN_THEMES, 
    STYLE_TEMPLATES, PPT_TEMPLATES, SLIDE_TITLE_TRANSLATIONS
)
from content_utils import (
    parse_executor_response, extract_relevant_content_from_executor,
    extract_slide_section_from_executor, parse_slide_section,
    extract_speaker_notes_from_section, read_uploaded_file,
    generate_dynamic_slides, brave_search, generate_slide_content,
    generate_presentation_notes, generate_closing_notes,
    generate_conclusion_phrase, generate_prompt_with_llm,
    generate_image, create_slide_preview_html, create_pptx_file,
    PROCESS_FLOW_AVAILABLE
)
from ui_components import (
    create_custom_slides_ui, load_example, update_audience_info,
    update_theme_preview, update_template_info, update_custom_slides_visibility,
    clear_all, get_css, get_usage_instructions
)

# Logging setup
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Environment variables
REPLICATE_API_TOKEN = os.getenv("RAPI_TOKEN")
FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN")
BRAVE_API_TOKEN = os.getenv("BAPI_TOKEN")
API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search"
MODEL_ID = "dep89a2fld32mcm"
TEST_MODE = os.getenv("TEST_MODE", "false").lower() == "true"

# Global variables
current_slides_data = []
current_topic = ""
current_template = ""
current_theme = ""
uploaded_content = ""
current_language = "English"
conversation_history = []

# ===== 핵심: 3자 협의 시스템 클래스 =====
class PPTCreationSystem:
    def __init__(self):
        self.token = FRIENDLI_TOKEN
        self.bapi_token = BRAVE_API_TOKEN
        self.api_url = API_URL
        self.brave_url = BRAVE_SEARCH_URL
        self.model_id = MODEL_ID
        self.test_mode = TEST_MODE or (self.token == "YOUR_FRIENDLI_TOKEN")
        
        if self.test_mode:
            logger.warning("테스트 모드로 실행됩니다.")
        if self.bapi_token == "YOUR_BRAVE_API_TOKEN":
            logger.warning("Brave API 토큰이 설정되지 않았습니다.")
        
    def create_headers(self):
        """API 헤더 생성"""
        return {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        }
    
    def create_brave_headers(self):
        """Brave API 헤더 생성"""
        return {
            "Accept": "application/json",
            "Accept-Encoding": "gzip",
            "X-Subscription-Token": self.bapi_token
        }
    
    def create_supervisor_initial_prompt(self, ppt_topic: str) -> str:
        """감독자 AI 초기 프롬프트 생성 - PPT 구조 설계"""
        return f"""당신은 전문적인 PPT 구조를 설계하는 감독자 AI입니다.

PPT 주제: {ppt_topic}

이 주제에 대한 전문적인 PPT를 만들기 위해:

1. **PPT 전체 구조 설계**
   - 목적과 핵심 메시지 정의
   - 타겟 청중 분석 및 톤 설정
   - 전체 슬라이드 개수 및 흐름 설계 (10-15장 권장)

2. **섹션별 구성 제안**
   - 도입부 (표지, 목차, 배경)
   - 본론 (핵심 내용 3-4개 섹션)
   - 결론부 (요약, 시사점, Q&A)

3. **조사가 필요한 핵심 키워드**
   이 주제의 PPT를 위해 조사가 필요한 5-7개의 구체적인 키워드나 검색어를 제시하세요.

키워드는 다음 형식으로 제시하세요:
[검색 키워드]: 키워드1, 키워드2, 키워드3, 키워드4, 키워드5"""
    
    def create_researcher_prompt(self, ppt_topic: str, supervisor_guidance: str, search_results: Dict[str, List[Dict]]) -> str:
        """조사자 AI 프롬프트 생성 - PPT 콘텐츠 조사"""
        search_summary = ""
        all_results = []
        
        for keyword, results in search_results.items():
            search_summary += f"\n\n**{keyword}에 대한 검색 결과:**\n"
            for i, result in enumerate(results[:10], 1):  # 상위 10개만 표시
                search_summary += f"{i}. {result.get('title', 'N/A')} (신뢰도: {result.get('credibility_score', 0):.2f})\n"
                search_summary += f"   - {result.get('description', 'N/A')}\n"
                search_summary += f"   - 출처: {result.get('url', 'N/A')}\n"
                if result.get('published'):
                    search_summary += f"   - 게시일: {result.get('published')}\n"
                
                all_results.extend(results)
        
        # 모순 감지
        contradictions = self.detect_contradictions(all_results)
        contradiction_text = ""
        if contradictions:
            contradiction_text = "\n\n**발견된 정보 모순:**\n"
            for cont in contradictions[:3]:  # 최대 3개만 표시
                contradiction_text += f"- {cont['type']}: {cont['source1']} vs {cont['source2']}\n"
        
        return f"""당신은 PPT 콘텐츠를 위한 정보를 조사하고 정리하는 조사자 AI입니다.

PPT 주제: {ppt_topic}

감독자 AI의 구조 설계:
{supervisor_guidance}

브레이브 검색 결과 (신뢰도 점수 포함):
{search_summary}
{contradiction_text}

위 검색 결과를 바탕으로 PPT에 포함할 핵심 콘텐츠를 정리하세요:

1. **시각적 자료 가능한 통계/수치**
   - 그래프나 차트로 표현 가능한 데이터
   - 인포그래픽으로 변환 가능한 정보

2. **핵심 인사이트와 트렌드**
   - 청중의 관심을 끌 수 있는 최신 정보
   - 업계 동향과 미래 전망

3. **사례 연구 및 성공 스토리**
   - 실제 적용 사례
   - 벤치마크할 수 있는 모범 사례

4. **전문가 의견 및 인용구**
   - 권위 있는 출처의 의견
   - PPT에 인용할 수 있는 명언

5. **시각 자료 추천**
   - 각 슬라이드에 적합한 이미지/아이콘 제안
   - 도표나 다이어그램 아이디어"""
    
    def create_supervisor_execution_prompt(self, ppt_topic: str, research_summary: str) -> str:
        """감독자 AI의 실행 지시 프롬프트 - PPT 제작 지시"""
        return f"""당신은 PPT 제작을 총괄하는 감독자 AI입니다.

PPT 주제: {ppt_topic}

조사자 AI가 정리한 콘텐츠:
{research_summary}

위 조사 내용을 기반으로 실행자 AI에게 구체적인 PPT 제작 지시를 내려주세요:

1. **슬라이드별 상세 구성**
   - 각 슬라이드의 제목과 핵심 메시지
   - 포함할 구체적인 콘텐츠 지정
   - 시각 자료 배치 방안

2. **디자인 가이드라인**
   - 전체적인 톤과 스타일 (전문적/창의적/미니멀 등)
   - 색상 팔레트 제안
   - 폰트 및 레이아웃 원칙

3. **스토리텔링 전략**
   - 도입부에서 청중의 관심을 끄는 방법
   - 핵심 메시지 전달 순서
   - 결론부의 임팩트 있는 마무리

4. **시각화 지침**
   - 각 데이터의 최적 시각화 방법
   - 복잡한 개념의 단순화 방안
   - 애니메이션 효과 제안"""

    def create_executor_prompt(self, ppt_topic: str, supervisor_guidance: str, research_summary: str) -> str:
        """실행자 AI 프롬프트 생성 - PPT 슬라이드 작성"""
        return f"""당신은 실제 PPT 슬라이드 내용을 작성하는 실행자 AI입니다.
    
    PPT 주제: {ppt_topic}
    
    조사자 AI가 정리한 콘텐츠:
    {research_summary}
    
    감독자 AI의 제작 지시:
    {supervisor_guidance}
    
    위 정보를 바탕으로 실제 PPT 슬라이드를 작성하세요:
    
    1. **각 슬라이드를 다음 형식으로 작성**:
       [슬라이드 X]
       제목: 
       부제목: (선택사항)
       • 🎯 첫 번째 핵심 포인트
       • 💡 두 번째 핵심 포인트
       • 🚀 세 번째 핵심 포인트
       • ✅ 네 번째 핵심 포인트
       • 📊 다섯 번째 핵심 포인트
       발표자 노트: (실제 발표할 때 사용할 구어체 스크립트 - 최소 3-4문장)
    
    2. **작성 원칙**
       - 한 슬라이드에 하나의 핵심 메시지
       - 텍스트는 최소화, 시각적 요소 극대화
       - 6x6 규칙 준수 (6줄 이하, 줄당 6단어 이하)
       - 전문적이면서도 이해하기 쉬운 언어 사용
       - 각 불릿 포인트는 반드시 이모지로 시작
    
    3. **발표자 노트 작성 지침**
       - 슬라이드 내용을 자연스럽게 설명하는 구어체 사용
       - 각 포인트를 풀어서 설명하고 연결
       - 청중과 소통하는 느낌의 대화체 ("여러분", "우리가", "함께")
       - 최소 3-4문장으로 풍부하게 작성
       - 예시: "자, 이제 우리가 주목해야 할 핵심 포인트들을 살펴보겠습니다. 첫 번째로 시장 규모를 보시면..."
    
    4. **필수 포함 슬라이드**
       - 표지 (제목, 부제목, 발표자/날짜)
       - 목차
       - 핵심 내용 슬라이드들
       - 요약/결론
       - Q&A/감사 슬라이드"""
    
    def create_supervisor_review_prompt(self, ppt_topic: str, executor_response: str, research_summary: str) -> str:
        """감독자 AI의 검토 프롬프트 - PPT 검토 및 피드백"""
        return f"""당신은 PPT 품질을 검토하고 개선점을 제시하는 감독자 AI입니다.

PPT 주제: {ppt_topic}

조사자 AI가 제공한 콘텐츠:
{research_summary}

실행자 AI의 PPT 초안:
{executor_response}

위 PPT 초안을 검토하고 다음 관점에서 구체적인 피드백을 제공하세요:

1. **콘텐츠 품질**
   - 조사 내용이 충분히 반영되었는지
   - 각 슬라이드의 메시지가 명확한지
   - 논리적 흐름이 자연스러운지

2. **시각적 효과**
   - 텍스트와 시각 요소의 균형
   - 슬라이드별 일관성
   - 청중의 이해를 돕는 구성인지

3. **발표 준비도**
   - 발표자 노트의 충실성
   - 예상 질문에 대한 대비
   - 시간 배분의 적절성

4. **개선 필요사항**
   - 구체적인 수정 지시사항
   - 추가해야 할 내용
   - 삭제하거나 간소화할 부분

5. **최종 점검사항**
   - 오타나 문법 오류
   - 데이터의 정확성
   - 전문성과 신뢰성"""

    def create_executor_final_prompt(self, ppt_topic: str, initial_response: str, supervisor_feedback: str, research_summary: str) -> str:
        """실행자 AI 최종 PPT 프롬프트"""
        return f"""당신은 최종 PPT를 완성하는 실행자 AI입니다.

PPT 주제: {ppt_topic}

조사자 AI의 콘텐츠:
{research_summary}

당신의 초기 PPT 초안:
{initial_response}

감독자 AI의 피드백:
{supervisor_feedback}

위 피드백을 완전히 반영하여 최종 PPT를 작성하세요:

1. **개선사항 반영**
   - 감독자의 모든 피드백 적용
   - 스토리라인 강화
   - 시각적 일관성 확보

2. **발표자 노트 강화**
   - 각 슬라이드마다 풍부한 구어체 발표 스크립트 작성
   - 최소 4-5문장으로 자세하게
   - 실제 발표 상황을 가정한 자연스러운 대화체
   - 예시: "자, 이제 시장 현황을 살펴보겠습니다. 여러분도 아시다시피 최근 디지털 전환이 가속화되면서..."

3. **최종 품질 체크**
   - 전문성과 완성도 향상
   - 오타 및 문법 검토
   - 논리적 흐름 재확인

4. **프레젠테이션 준비**
   - 각 슬라이드별 발표 스크립트 추가
   - 예상 질문과 답변 준비
   - 시간 배분 제안 (20분 발표 기준)

5. **추가 자료**
   - 백업 슬라이드 제안
   - 참고 자료 목록
   - 인쇄용 핸드아웃 버전 제안"""
    
    def extract_keywords(self, supervisor_response: str) -> List[str]:
        """감독자 응답에서 키워드 추출"""
        keywords = []
        
        # [검색 키워드]: 형식으로 키워드 찾기
        keyword_match = re.search(r'\[검색 키워드\]:\s*(.+)', supervisor_response, re.IGNORECASE)
        if keyword_match:
            keyword_str = keyword_match.group(1)
            keywords = [k.strip() for k in keyword_str.split(',') if k.strip()]
        
        # 키워드가 없으면 기본 키워드 생성
        if not keywords:
            keywords = ["industry trends", "market analysis", "case studies", "best practices", "future outlook"]
        
        return keywords[:7]  # 최대 7개로 제한
    
    def generate_synonyms(self, keyword: str) -> List[str]:
        """키워드의 동의어/유사어 생성"""
        synonyms = {
            "trend": ["tendency", "direction", "movement", "pattern"],
            "analysis": ["evaluation", "assessment", "study", "research"],
            "strategy": ["approach", "plan", "tactics", "methodology"],
            "market": ["industry", "sector", "business", "commerce"],
            "innovation": ["breakthrough", "advancement", "revolution", "disruption"],
            "growth": ["expansion", "development", "progress", "advancement"],
            "presentation": ["pitch", "proposal", "demonstration", "showcase"],
            "data": ["statistics", "metrics", "analytics", "insights"],
            "technology": ["tech", "digital", "IT", "innovation"],
            "business": ["enterprise", "corporate", "commercial", "company"]
        }
        
        # 키워드 정규화
        keyword_lower = keyword.lower()
        
        # 직접 매칭되는 동의어가 있으면 반환
        if keyword_lower in synonyms:
            return synonyms[keyword_lower][:2]  # 최대 2개
        
        # 부분 매칭 확인
        for key, values in synonyms.items():
            if key in keyword_lower or keyword_lower in key:
                return values[:2]
        
        # 동의어가 없으면 빈 리스트
        return []
    
    def calculate_credibility_score(self, result: Dict) -> float:
        """검색 결과의 신뢰도 점수 계산 (0-1)"""
        score = 0.5  # 기본 점수
        
        url = result.get('url', '')
        title = result.get('title', '')
        description = result.get('description', '')
        
        # URL 기반 점수
        trusted_domains = [
            '.edu', '.gov', '.org', 'wikipedia.org', 'harvard.edu', 
            'mckinsey.com', 'deloitte.com', 'pwc.com', 'gartner.com',
            'forrester.com', 'statista.com', 'bloomberg.com', 'reuters.com'
        ]
        
        for domain in trusted_domains:
            if domain in url:
                score += 0.2
                break
        
        # HTTPS 사용 여부
        if url.startswith('https://'):
            score += 0.1
        
        # 제목과 설명의 길이 (너무 짧으면 신뢰도 감소)
        if len(title) > 20:
            score += 0.05
        if len(description) > 50:
            score += 0.05
        
        # 광고/스팸 키워드 체크
        spam_keywords = ['buy now', 'sale', 'discount', 'click here', '100% free']
        if any(spam in (title + description).lower() for spam in spam_keywords):
            score -= 0.3
        
        # 날짜 정보가 있으면 가산점
        if any(year in description for year in ['2024', '2023', '2022']):
            score += 0.1
        
        return max(0, min(1, score))  # 0-1 범위로 제한
    
    def detect_contradictions(self, results: List[Dict]) -> List[Dict]:
        """검색 결과 간 모순 감지"""
        contradictions = []
        
        # 간단한 모순 감지 패턴
        opposite_pairs = [
            ("increase", "decrease"),
            ("improve", "worsen"),
            ("effective", "ineffective"),
            ("success", "failure"),
            ("benefit", "harm"),
            ("positive", "negative"),
            ("growth", "decline")
        ]
        
        # 결과들을 비교
        for i in range(len(results)):
            for j in range(i + 1, len(results)):
                desc1 = results[i].get('description', '').lower()
                desc2 = results[j].get('description', '').lower()
                
                # 반대 개념이 포함되어 있는지 확인
                for word1, word2 in opposite_pairs:
                    if (word1 in desc1 and word2 in desc2) or (word2 in desc1 and word1 in desc2):
                        # 같은 주제에 대해 반대 의견인지 확인
                        common_words = set(desc1.split()) & set(desc2.split())
                        if len(common_words) > 5:  # 공통 단어가 5개 이상이면 같은 주제로 간주
                            contradictions.append({
                                'source1': results[i]['url'],
                                'source2': results[j]['url'],
                                'type': f"{word1} vs {word2}",
                                'desc1': results[i]['description'][:100],
                                'desc2': results[j]['description'][:100]
                            })
        
        return contradictions
    
    def brave_search(self, query: str) -> List[Dict]:
        """Brave Search API 호출"""
        if self.test_mode or self.bapi_token == "YOUR_BRAVE_API_TOKEN":
            # 테스트 모드에서는 시뮬레이션된 결과 반환
            test_results = []
            for i in range(5):
                test_results.append({
                    "title": f"{query} - Industry Report {i+1}",
                    "description": f"Comprehensive analysis of {query} including market trends, key statistics, and future projections for strategic planning.",
                    "url": f"https://report{i+1}.com/{query.replace(' ', '-')}",
                    "credibility_score": 0.7 + (i * 0.05)
                })
            return test_results
        
        try:
            params = {
                "q": query,
                "count": 20,  # 20개로 증가
                "safesearch": "moderate",
                "freshness": "pw"  # Past week for recent results
            }
            
            response = requests.get(
                self.brave_url,
                headers=self.create_brave_headers(),
                params=params,
                timeout=10
            )
            
            if response.status_code == 200:
                data = response.json()
                results = []
                for item in data.get("web", {}).get("results", [])[:20]:
                    result = {
                        "title": item.get("title", ""),
                        "description": item.get("description", ""),
                        "url": item.get("url", ""),
                        "published": item.get("published", "")
                    }
                    # 신뢰도 점수 계산
                    result["credibility_score"] = self.calculate_credibility_score(result)
                    results.append(result)
                
                # 신뢰도 점수 기준으로 정렬
                results.sort(key=lambda x: x['credibility_score'], reverse=True)
                return results
            else:
                logger.error(f"Brave API 오류: {response.status_code}")
                return []
                
        except Exception as e:
            logger.error(f"Brave 검색 중 오류: {str(e)}")
            return []
    
    def simulate_streaming(self, text: str, role: str) -> Generator[str, None, None]:
        """테스트 모드에서 스트리밍 시뮬레이션"""
        words = text.split()
        for i in range(0, len(words), 3):
            chunk = " ".join(words[i:i+3])
            yield chunk + " "
            time.sleep(0.05)
    
    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str) -> Generator[str, None, None]:
        """스트리밍 LLM API 호출"""
        
        # 테스트 모드
        if self.test_mode:
            logger.info(f"테스트 모드 스트리밍 - Role: {role}")
            test_responses = {
                "supervisor_initial": """전문적인 PPT 구조를 설계하겠습니다.

## 1. PPT 전체 구조 설계

**목적**: 디지털 트랜스포메이션의 핵심 요소와 성공 전략을 명확하게 전달
**타겟 청중**: 경영진 및 의사결정자
**톤**: 전문적이고 설득력 있는 비즈니스 스타일
**전체 슬라이드**: 12장

## 2. 섹션별 구성

### 도입부 (3장)
- 슬라이드 1: 표지 - 임팩트 있는 제목과 비주얼
- 슬라이드 2: 목차 - 전체 흐름 제시
- 슬라이드 3: 디지털 트랜스포메이션의 필요성

### 본론 (7장)
**섹션 1: 현황 분석 (2장)**
- 슬라이드 4: 산업별 디지털화 현황
- 슬라이드 5: 주요 도전과제

**섹션 2: 핵심 전략 (3장)**
- 슬라이드 6: 디지털 트랜스포메이션 프레임워크
- 슬라이드 7: 기술 스택 및 인프라
- 슬라이드 8: 변화 관리 전략

**섹션 3: 성공 사례 (2장)**
- 슬라이드 9: 글로벌 성공 사례
- 슬라이드 10: ROI 및 성과 지표

### 결론부 (2장)
- 슬라이드 11: 핵심 시사점 및 권고사항
- 슬라이드 12: Q&A

## 3. 비주얼 전략
- 색상: 기업 블루(#003366) + 악센트 오렌지(#FF6B35)
- 아이콘: 모던하고 플랫한 디자인
- 차트: 데이터 시각화 중심

[검색 키워드]: digital transformation trends 2024, DX success cases, digital transformation ROI, change management digital, industry 4.0 statistics""",
                
                "researcher": """PPT 콘텐츠를 위한 핵심 정보를 정리했습니다.

## 1. 시각적 자료 가능한 통계/수치 (신뢰도 높음)

**디지털 트랜스포메이션 투자 현황**
- 2024년 글로벌 DX 투자 규모: $3.4조 (신뢰도: 0.92)
- 연평균 성장률(CAGR): 16.5% (2023-2027)
- 출처: IDC Digital Transformation Spending Guide

**산업별 디지털화 수준**
- 금융: 78% 디지털화 완료 (신뢰도: 0.88)
- 제조: 52% 진행 중 (신뢰도: 0.85)
- 헬스케어: 61% 가속화 단계
- 출처: McKinsey Global Institute

## 2. 핵심 인사이트와 트렌드 (신뢰도 높음)

**2024년 주요 트렌드**
1. AI/ML 통합: 87%의 기업이 AI를 DX 핵심 요소로 채택 (신뢰도: 0.90)
2. 클라우드 우선: 94%가 하이브리드 클라우드 전략 추진
3. 데이터 중심: 실시간 분석이 경쟁력의 핵심
- 출처: Gartner Technology Trends 2024

## 3. 사례 연구 및 성공 스토리 (신뢰도 높음)

**Amazon 사례**
- 물류 자동화로 배송 시간 40% 단축 (신뢰도: 0.87)
- AI 기반 추천으로 매출 35% 증가
- 출처: Amazon Annual Report 2023

**Starbucks 디지털 혁신**
- 모바일 주문 비중: 전체 매출의 26% (신뢰도: 0.85)
- 개인화 마케팅으로 고객 충성도 23% 향상
- 출처: Starbucks Investor Relations

## 4. 전문가 의견 및 인용구

> "디지털 트랜스포메이션은 기술이 아닌 사람과 문화의 변화다"
- Satya Nadella, Microsoft CEO

> "2025년까지 디지털 리더와 후발주자의 격차는 2배 이상 벌어질 것"
- Michael Porter, Harvard Business School

## 5. 시각 자료 추천

**슬라이드별 비주얼 제안**
- 표지: 네트워크 연결 이미지 + 동적인 데이터 흐름
- 통계: 인터랙티브한 대시보드 스타일 차트
- 프레임워크: 계층적 다이어그램 + 아이콘
- 사례: 기업 로고 + 핵심 지표 인포그래픽
- 타임라인: 로드맵 형태의 단계별 진행도

**아이콘 세트**
- 기술: 클라우드, AI, 데이터, 보안
- 비즈니스: 성장, 혁신, 협업, 효율성
- 사람: 리더십, 팀워크, 스킬, 문화""",
                
                "supervisor_execution": """조사 내용을 바탕으로 PPT 제작을 위한 구체적인 지시사항입니다.

## 1. 슬라이드별 상세 구성

**슬라이드 1: 표지**
- 제목: "디지털 트랜스포메이션: 미래를 향한 도약"
- 부제목: "성공적인 DX 전략과 실행 방안"
- 비주얼: 연결된 디지털 네트워크 배경
- 조사 자료 활용: $3.4조 시장 규모 강조

**슬라이드 4: 산업별 현황**
- 조사된 통계 활용: 금융(78%), 제조(52%), 헬스케어(61%)
- 원형 차트 + 진행 바 조합
- 각 산업별 대표 아이콘 배치

**슬라이드 7: 기술 스택**
- AI/ML(87% 채택률) 중심으로 구성
- 클라우드(94%) 하이브리드 전략 시각화
- 계층적 다이어그램 사용

**슬라이드 9: 성공 사례**
- Amazon과 Starbucks 사례 대비
- 핵심 성과 지표 인포그래픽
- Before/After 비교 형식

## 2. 디자인 가이드라인

**색상 팔레트**
- 주색상: 네이비 블루 (#1E3A8A)
- 보조색상: 스카이 블루 (#3B82F6)
- 강조색상: 오렌지 (#F59E0B)
- 배경: 화이트/라이트 그레이

**타이포그래피**
- 제목: Montserrat Bold (32-40pt)
- 본문: Open Sans Regular (18-24pt)
- 강조: Open Sans Semi-Bold

**레이아웃 원칙**
- 여백 충분히 활용 (40% 이상)
- 좌우 대칭 또는 황금비율
- 한 슬라이드 한 메시지 원칙

## 3. 스토리텔링 전략

**도입부 전략**
- 충격적인 통계로 시작 ($3.4조 시장)
- "왜 지금인가?" 질문 제기
- 청중의 pain point 공감

**전개 방식**
- 문제 → 해결책 → 증거 → 행동
- 각 섹션 간 자연스러운 전환
- 사례를 통한 구체화

**클라이맥스**
- ROI 데이터로 설득력 극대화
- 성공 기업과의 격차 시각화
- 행동 촉구 메시지

## 4. 시각화 지침

**데이터 시각화**
- 산업별 현황: 방사형 차트
- 성장률: 상승 곡선 그래프
- ROI: 계산기 스타일 인포그래픽
- 프로세스: 순환형 다이어그램

**애니메이션 효과**
- 슬라이드 전환: Morph 효과
- 차트 등장: 순차적 빌드업
- 강조 포인트: 줌인/하이라이트
- 과도한 효과 지양""",
                
                "executor": """PPT 슬라이드를 작성합니다.

[슬라이드 1] 표지
제목: 디지털 트랜스포메이션: 미래를 향한 도약
부제목: 성공적인 DX 전략과 실행 방안
핵심 내용: 
- 발표자: [이름]
- 날짜: 2024년 3월
- 기업명/로고
발표자 노트: 청중의 주목을 끌 수 있도록 자신감 있게 시작. $3.4조 규모의 거대한 변화의 물결임을 강조
시각 자료: 디지털 네트워크가 연결된 지구본 이미지, 동적인 데이터 흐름 효과

[슬라이드 2] 목차
제목: Agenda
핵심 내용:
- 디지털 트랜스포메이션의 현재
- 산업별 디지털화 현황과 과제
- 성공을 위한 핵심 전략
- 글로벌 성공 사례와 교훈
- 결론 및 다음 단계
발표자 노트: 전체 20분 발표 중 각 섹션별 시간 배분 설명
시각 자료: 번호가 매겨진 아이콘과 진행 표시 바

[슬라이드 3] 도입
제목: 왜 지금 디지털 트랜스포메이션인가?
핵심 내용:
- 2024년 글로벌 DX 투자: $3.4조
- 디지털 리더 기업의 수익성: 평균 대비 2.5배
- 팬데믹 이후 디지털 채택 가속화: 10년→2년
- "변화하거나 도태되거나" - 생존의 문제
발표자 노트: 시장 규모와 긴급성을 강조하여 청중의 관심 유도
시각 자료: 급상승하는 그래프와 시계 아이콘으로 시급함 표현

[슬라이드 4] 산업별 현황
제목: 산업별 디지털 트랜스포메이션 현황
핵심 내용:
- 금융: 78% (선도 그룹)
- 헬스케어: 61% (빠른 추격)
- 제조: 52% (꾸준한 진행)
- 소매: 45% (가속화 필요)
발표자 노트: 각 산업의 특성과 도전과제 간단히 언급
시각 자료: 도넛 차트와 산업별 아이콘, 진행률 바

[슬라이드 5] 주요 도전과제
제목: 디지털 트랜스포메이션의 5대 장벽
핵심 내용:
- 레거시 시스템의 복잡성 (67%)
- 변화 저항과 문화적 관성 (54%)
- 디지털 인재 부족 (48%)
- 불명확한 ROI (41%)
- 사이버 보안 우려 (38%)
발표자 노트: 각 장벽에 대한 극복 방안 미리 준비
시각 자료: 장벽을 나타내는 벽돌 아이콘과 백분율 표시

[슬라이드 6] DX 프레임워크
제목: 디지털 트랜스포메이션 성공 프레임워크
핵심 내용:
- 전략: 비즈니스 목표 정렬
- 기술: AI/클라우드/데이터
- 프로세스: 애자일 방법론
- 문화: 혁신과 실험 장려
- 거버넌스: 지속적 개선
발표자 노트: 각 요소가 상호 연결되어 있음을 강조
시각 자료: 5각형 다이어그램, 각 꼭지점에 아이콘 배치

[슬라이드 7] 기술 스택
제목: 2024 핵심 기술 스택
핵심 내용:
- AI/ML 채택률: 87%
- 클라우드 전략: 94% 하이브리드
- 데이터 분석: 실시간 처리
- 보안: Zero Trust 아키텍처
- 통합: API 우선 접근
발표자 노트: 각 기술의 비즈니스 가치 연결
시각 자료: 계층적 기술 스택 다이어그램

[슬라이드 8] 변화 관리
제목: 사람 중심의 변화 관리
핵심 내용:
- 리더십의 명확한 비전 공유
- 단계별 교육 프로그램
- 빠른 성과로 모멘텀 구축  
- 지속적 커뮤니케이션
- 보상 체계 연계
발표자 노트: Satya Nadella 인용구 활용
시각 자료: 변화 곡선과 사람 아이콘

[슬라이드 9] 성공 사례
제목: 글로벌 DX 성공 스토리
핵심 내용:
- Amazon: 물류 자동화 → 배송 40% 단축
- Starbucks: 모바일 주문 → 매출 26%
- Netflix: AI 추천 → 시청 시간 80% 증가
- Tesla: OTA 업데이트 → 서비스 비용 70% 절감
발표자 노트: 각 사례의 핵심 성공 요인 강조
시각 자료: 기업 로고와 핵심 지표 인포그래픽

[슬라이드 10] ROI 분석
제목: 디지털 트랜스포메이션의 명확한 ROI
핵심 내용:
- 운영 효율성: 30-40% 개선
- 고객 만족도: NPS 25% 상승
- 신규 수익원: 전체 매출의 15%
- 투자 회수 기간: 평균 2.5년
발표자 노트: 구체적인 수치로 투자 정당성 입증
시각 자료: ROI 계산기 스타일의 인포그래픽

[슬라이드 11] 핵심 시사점
제목: 성공적인 DX를 위한 5가지 제언
핵심 내용:
- 작게 시작하되 크게 생각하라
- 기술보다 문화 변화에 투자하라
- 데이터 기반 의사결정을 일상화하라
- 실패를 두려워하지 말고 빠르게 배워라
- 고객 중심으로 모든 것을 재설계하라
발표자 노트: 각 제언에 대한 실천 방안 준비
시각 자료: 체크리스트 스타일의 아이콘

[슬라이드 12] Q&A
제목: Questions & Discussion
핵심 내용:
- 감사합니다
- 질문과 토론 환영
- 연락처: [이메일/전화]
- 추가 자료: [웹사이트/QR코드]
발표자 노트: 예상 질문 3-5개 미리 준비
시각 자료: 물음표 아이콘과 연락처 정보""",
                
                "supervisor_review": """실행자 AI의 PPT 초안을 검토했습니다. 전반적으로 잘 구성되었으나 다음 개선사항을 제안합니다.

## 강점
- 조사된 통계와 수치가 효과적으로 활용됨
- 스토리라인이 논리적이고 설득력 있음
- 각 슬라이드의 핵심 메시지가 명확함
- 시각 자료 제안이 구체적임

## 개선 필요사항

### 1. 임팩트 강화
**슬라이드 3 개선**
- 현재: 통계 나열
- 개선: "귀사는 디지털 리더입니까, 후발주자입니까?"라는 도발적 질문 추가
- 청중 참여를 위한 인터랙티브 요소 고려

**슬라이드 5 개선**  
- 현재: 장벽만 제시
- 개선: 각 장벽별 "Quick Win" 솔루션 한 줄 추가
- 희망적 메시지로 균형 맞추기

### 2. 스토리텔링 강화
**전환 문구 추가**
- 슬라이드 간 연결 문구 필요
- 예: "이제 이러한 현황을 어떻게 개선할 수 있을까요?"

**감정적 연결**
- 숫자와 통계 외에 인간적 스토리 추가
- 변화를 겪은 직원/고객의 실제 경험담

### 3. 비주얼 일관성
**색상 사용 정제**
- 강조색(오렌지) 과도 사용 자제
- 각 섹션별 색상 톤 구분
- 데이터 시각화 색상 팔레트 통일

**아이콘 스타일**
- 모든 아이콘 동일 스타일로 통일
- 라인 두께, 모서리 처리 일관성

### 4. 발표 준비 강화
**시간 배분 명시**
- 각 슬라이드별 예상 소요 시간 추가
- 전체 20분 기준 상세 배분

**전환 스크립트**
- 슬라이드 간 자연스러운 전환 멘트 준비
- 청중 반응 체크 포인트 설정

### 5. 추가 권장사항
**백업 슬라이드 준비**
- 상세 기술 스펙
- 추가 사례 연구
- 업종별 맞춤 전략
- 상세 ROI 계산 방법

**인쇄 자료**
- 3슬라이드/페이지 형식
- 메모 공간 포함
- 핵심 수치 요약 페이지

이러한 개선사항을 반영하면 더욱 완성도 높고 설득력 있는 PPT가 될 것입니다.""",
                
                "executor_final": """감독자 AI의 피드백을 완전히 반영한 최종 PPT를 작성합니다.

# 🎯 디지털 트랜스포메이션: 미래를 향한 도약
## 최종 완성 PPT (발표 시간: 20분)

---

[슬라이드 1] 표지 (30초)
**제목**: 디지털 트랜스포메이션: 미래를 향한 도약
**부제목**: 성공적인 DX 전략과 실행 방안
**비주얼**: 
- 배경: 연결된 디지털 네트워크와 데이터 흐름
- 중앙: 회사 로고
- 하단: 발표자 정보 및 날짜
**발표자 노트**: 
"안녕하십니까. 오늘 여러분과 함께 $3.4조 규모의 디지털 혁명, 그 중심에서 우리가 어떻게 성공할 수 있을지 논의하고자 합니다."

---

[슬라이드 2] 목차 (30초)
**제목**: 오늘의 여정
**핵심 내용**:
1. 📊 디지털 트랜스포메이션의 현재 (3분)
2. 🏭 산업별 현황과 도전과제 (3분)
3. 🎯 성공 전략과 프레임워크 (5분)
4. 🌟 글로벌 성공 사례 (4분)
5. 💡 핵심 시사점과 실행 방안 (4분)
6. 🤝 Q&A (1분)
**발표자 노트**: 
"20분간의 여정을 통해 디지털 트랜스포메이션의 현재와 미래, 그리고 실행 방안을 함께 탐색하겠습니다."
**시각 자료**: 진행 단계를 보여주는 로드맵 스타일 디자인

---

[슬라이드 3] 도전적 질문 (1분 30초)
**제목**: 귀사는 디지털 리더입니까, 후발주자입니까?
**핵심 내용**:
- 🌍 2024년 글로벌 DX 시장: **$3.4조**
- 📈 디지털 리더의 수익성: 평균 대비 **2.5배**
- ⏰ 변화의 속도: 10년 → **2년** (팬데믹 가속화)
- ⚡ 핵심 질문: "우리는 변화를 주도하고 있는가?"
**발표자 노트**: 
"잠시 생각해보십시오. 귀사는 이 거대한 변화의 물결을 타고 있습니까, 아니면 뒤처져 있습니까?"
**시각 자료**: 
- 상단: 도발적 질문 크게 표시
- 중앙: 리더 vs 후발주자 대비 인포그래픽
- 전환: 청중 참여를 위한 3초 pause

---

[슬라이드 4] 산업별 디지털화 현황 (1분 30초)
**제목**: 당신의 산업은 어디에 위치합니까?
**핵심 내용**:
- 🏦 금융: 78% - "디지털이 새로운 표준"
- 🏥 헬스케어: 61% - "원격의료가 일상으로"
- 🏭 제조: 52% - "스마트 팩토리로 진화"
- 🛍️ 소매: 45% - "옴니채널이 생존 조건"
**발표자 노트**: 
"금융업은 이미 78%가 디지털화되었습니다. 귀사의 산업은 어떻습니까? 이제 각 산업의 성공 비결을 살펴보겠습니다."
**시각 자료**: 
- 레이스 트랙 형태의 진행도 표시
- 각 산업별 대표 아이콘과 진행률
- 업종별 대표 기업 로고 작게 표시

---

[슬라이드 5] 5대 장벽과 해결책 (2분)
**제목**: 장벽을 기회로: 5대 도전과제와 Quick Win
**핵심 내용**:
- 🔧 레거시 시스템 (67%) → "단계적 현대화 전략"
- 🚫 변화 저항 (54%) → "작은 성공 스토리 확산"
- 👥 인재 부족 (48%) → "업스킬링 + 외부 파트너십"
- 💰 불명확한 ROI (41%) → "파일럿 프로젝트로 증명"
- 🔒 보안 우려 (38%) → "Security by Design 원칙"
**발표자 노트**: 
"모든 장벽에는 해결책이 있습니다. 중요한 것은 어디서부터 시작할 것인가입니다."
**전환 멘트**: "그렇다면 이러한 장벽을 넘어 성공하기 위한 검증된 프레임워크를 소개하겠습니다."
**시각 자료**: 
- 장벽→해결책 화살표 애니메이션
- 각 항목별 순차적 등장 효과

---

[슬라이드 6] DX 성공 프레임워크 (2분)
**제목**: 검증된 디지털 트랜스포메이션 프레임워크
**핵심 내용**:
🎯 **전략**: 비즈니스 목표와 100% 정렬
🔧 **기술**: AI(87%) + 클라우드(94%) + 데이터
👥 **문화**: 혁신 DNA 주입
⚙️ **프로세스**: 애자일 + DevOps
📊 **거버넌스**: 측정 가능한 KPI
**발표자 노트**: 
"이 5가지 요소는 톱니바퀴처럼 맞물려 있습니다. 하나라도 빠지면 전체가 작동하지 않습니다."
**시각 자료**: 
- 중앙: 5각형 다이어그램
- 각 요소 간 연결선으로 상호의존성 표현
- 호버 효과로 각 요소 상세 설명

---

[슬라이드 7] 2024 기술 스택 (1분 30초)
**제목**: 미래를 만드는 기술 스택
**핵심 내용**:
**Layer 1 - 인프라**
- ☁️ 하이브리드 클라우드 (94% 채택)
**Layer 2 - 데이터**
- 📊 실시간 분석 플랫폼
**Layer 3 - 인텔리전스**
- 🤖 AI/ML (87% 통합)
**Layer 4 - 경험**
- 📱 옴니채널 인터페이스
**Layer 5 - 보안**
- 🔐 Zero Trust 아키텍처
**발표자 노트**: 
"각 레이어는 그 위의 레이어를 지원합니다. 탄탄한 기초 없이는 혁신도 없습니다."
**시각 자료**: 
- 피라미드 형태의 기술 스택
- 각 레이어별 대표 기술 로고

---

[슬라이드 8] 인간 중심 변화 관리 (1분 30초)
**제목**: 기술이 아닌 사람이 만드는 변화
**핵심 내용**:
> "디지털 트랜스포메이션은 기술이 아닌 사람과 문화의 변화다"
> - Satya Nadella, Microsoft CEO

- 🎯 **비전**: 명확하고 고무적인 미래상
- 📚 **교육**: 지속적 학습 문화
- 🏆 **성과**: 작은 승리의 축적
- 💬 **소통**: 양방향 피드백 루프
- 🎁 **보상**: 혁신에 대한 인센티브
**발표자 노트**: 
"가장 앞선 기술도 사람이 받아들이지 않으면 무용지물입니다."
**전환 멘트**: "이제 이러한 원칙들이 실제로 어떤 성과를 만들어냈는지 보시겠습니다."
**시각 자료**: 사람 중심의 원형 다이어그램

---

[슬라이드 9] 글로벌 성공 스토리 (2분)
**제목**: 숫자로 증명된 DX 성공 사례
**핵심 내용**:
📦 **Amazon**: 물류 자동화 → 배송 시간 **40% 단축**
☕ **Starbucks**: 모바일 주문 → 매출의 **26% 차지**
🎬 **Netflix**: AI 추천 → 시청 시간 **80% 증가**
🚗 **Tesla**: OTA 업데이트 → 서비스 비용 **70% 절감**

**공통 성공 요인**:
- 고객 경험 최우선
- 데이터 기반 의사결정
- 지속적 혁신 문화
**발표자 노트**: 
"이들의 공통점은 무엇일까요? 기술을 목적이 아닌 수단으로 활용했다는 점입니다."
**시각 자료**: 
- 각 기업별 Before/After 대비
- 핵심 지표 크게 강조

---

[슬라이드 10] ROI의 진실 (2분)
**제목**: 투자 대비 수익, 숨겨진 가치까지
**정량적 효과**:
- 💰 운영 효율성: **30-40% 개선**
- 😊 고객 만족도: NPS **25포인트 상승**
- 🚀 신규 수익: 전체 매출의 **15% 창출**
- ⏱️ 투자 회수: 평균 **2.5년**

**정성적 효과**:
- 직원 만족도 향상
- 브랜드 이미지 제고
- 미래 대응력 확보
**발표자 노트**: 
"ROI는 단순히 숫자로만 측정되지 않습니다. 조직의 미래 경쟁력이 진정한 가치입니다."
**시각 자료**: 
- ROI 계산기 인터페이스
- 정량/정성 효과 균형 표시

---

[슬라이드 11] 실행을 위한 5가지 제언 (2분)
**제목**: 내일부터 시작할 수 있는 5가지 행동
**핵심 제언**:
1. 🌱 **Start Small, Think Big**
   - "파일럿 프로젝트로 시작하되 전사 확산 계획 수립"
2. 👥 **Culture First, Technology Second**
   - "최고의 기술도 문화가 뒷받침되지 않으면 실패"
3. 📊 **Data-Driven Everything**
   - "추측이 아닌 데이터로 의사결정"
4. 🔄 **Fail Fast, Learn Faster**
   - "실패를 두려워하지 말고 빠르게 피벗"
5. 🎯 **Customer at the Center**
   - "모든 변화의 중심에 고객 가치"
**발표자 노트**: 
"이 중 단 하나만이라도 내일부터 실천한다면, 1년 후 조직은 완전히 달라져 있을 것입니다."
**시각 자료**: 체크박스 스타일, 하나씩 체크되는 애니메이션

---

[슬라이드 12] 마무리 및 Q&A (1분)
**제목**: 함께 만드는 디지털 미래
**핵심 내용**:
🙏 **감사합니다**

💭 **생각해볼 질문들**:
- 우리 조직의 디지털 성숙도는?
- 가장 먼저 해결해야 할 과제는?
- 첫 번째 파일럿 프로젝트는?

📧 연락처: [이메일]
📱 LinkedIn: [프로필]
🔗 추가 자료: [QR 코드]
**발표자 노트**: 
"디지털 트랜스포메이션은 목적지가 아닌 여정입니다. 그 여정을 함께하게 되어 영광입니다."
**시각 자료**: QR 코드와 연락처 정보

---

## 📎 백업 슬라이드 (필요시 활용)

[백업 1] 산업별 상세 전략
[백업 2] 기술 스택 상세 스펙
[백업 3] 추가 성공 사례 (국내 기업)
[백업 4] ROI 계산 방법론
[백업 5] 단계별 실행 로드맵

## 🎤 예상 Q&A 및 답변 준비

**Q1: 우리 같은 중견기업도 가능한가요?**
A: 오히려 중견기업이 더 빠르게 변화할 수 있습니다. 작은 파일럿부터 시작하세요.

**Q2: 예산이 제한적인데 어떻게 시작하나요?**
A: 클라우드 기반 SaaS를 활용하면 초기 투자를 최소화할 수 있습니다.

**Q3: 직원들의 저항이 심한데 어떻게 극복하나요?**
A: 변화의 수혜자를 먼저 만들고, 그들이 전도사가 되게 하세요.

---
*이 PPT는 20분 발표를 기준으로 작성되었으며, 청중과의 상호작용을 극대화하도록 설계되었습니다.*"""
            }
            
            # 프롬프트 내용에 따라 적절한 응답 선택
            if role == "supervisor" and "조사자 AI가 정리한" in messages[0]["content"]:
                response = test_responses["supervisor_execution"]
            elif role == "supervisor" and messages[0]["content"].find("실행자 AI의 PPT 초안") > -1:
                response = test_responses["supervisor_review"]  
            elif role == "supervisor":
                response = test_responses["supervisor_initial"]
            elif role == "researcher":
                response = test_responses["researcher"]
            elif role == "executor" and "최종 PPT" in messages[0]["content"]:
                response = test_responses["executor_final"]
            else:
                response = test_responses["executor"]
            
            yield from self.simulate_streaming(response, role)
            return
        
        # 실제 API 호출
        try:
            system_prompts = {
                "supervisor": "당신은 전문적인 PPT 구조를 설계하고 지도하는 감독자 AI입니다.",
                "researcher": "당신은 PPT 콘텐츠를 위한 정보를 조사하고 정리하는 조사자 AI입니다.",
                "executor": "당신은 실제 PPT 슬라이드 내용을 작성하는 실행자 AI입니다."
            }
            
            full_messages = [
                {"role": "system", "content": system_prompts.get(role, "")},
                *messages
            ]
            
            payload = {
                "model": self.model_id,
                "messages": full_messages,
                "max_tokens": 4096,
                "temperature": 0.7,
                "top_p": 0.8,
                "stream": True,
                "stream_options": {"include_usage": True}
            }
            
            logger.info(f"API 스트리밍 호출 시작 - Role: {role}")
            
            response = requests.post(
                self.api_url,
                headers=self.create_headers(),
                json=payload,
                stream=True,
                timeout=10
            )
            
            if response.status_code != 200:
                logger.error(f"API 오류: {response.status_code}")
                yield f"❌ API 오류 ({response.status_code}): {response.text[:200]}"
                return
            
            for line in response.iter_lines():
                if line:
                    line = line.decode('utf-8')
                    if line.startswith("data: "):
                        data = line[6:]
                        if data == "[DONE]":
                            break
                        try:
                            chunk = json.loads(data)
                            if "choices" in chunk and chunk["choices"]:
                                content = chunk["choices"][0].get("delta", {}).get("content", "")
                                if content:
                                    yield content
                        except json.JSONDecodeError:
                            continue
                            
        except requests.exceptions.Timeout:
            yield "⏱️ API 호출 시간이 초과되었습니다. 다시 시도해주세요."
        except requests.exceptions.ConnectionError:
            yield "🔌 API 서버에 연결할 수 없습니다. 인터넷 연결을 확인해주세요."
        except Exception as e:
            logger.error(f"스트리밍 중 오류: {str(e)}")
            yield f"❌ 오류 발생: {str(e)}"

# 시스템 인스턴스 생성
ppt_system = PPTCreationSystem()

# ===== 메인 처리 함수 =====
def process_ppt_streaming(ppt_topic: str, template_name: str, audience_type: str, language: str,
                         custom_slides: List[Dict], slide_count: int, seed: int, uploaded_file, 
                         use_web_search: bool, theme_name: str = "Minimal Light", 
                         progress=gr.Progress()):
    """통합된 PPT 생성 처리 - 3자 협의 시스템 사용"""
    # Update global variables
    global current_topic, uploaded_content, current_language
    current_topic = ppt_topic
    current_language = language
    
    # Read uploaded file content
    uploaded_content = ""
    if uploaded_file is not None:
        try:
            uploaded_content = read_uploaded_file(uploaded_file.name)
            print(f"[File Upload] Content length: {len(uploaded_content)} characters")
        except Exception as e:
            print(f"[File Upload] Error: {str(e)}")
            uploaded_content = ""
    
    # Template selection and slide configuration
    try:
        if template_name == "Custom" and custom_slides:
            slides = [{"title": "Cover", "style": "Title Slide (Hero)", "prompt_hint": "Presentation cover"}]
            slides.extend(custom_slides)
            slides.append({"title": "Thank You", "style": "Thank You Slide", "prompt_hint": "Presentation closing and key message"})
        else:
            template = PPT_TEMPLATES.get(template_name)
            if not template:
                yield "", "", "", None, f"❌ Template '{template_name}' not found."
                return
            slides = generate_dynamic_slides(ppt_topic, template, slide_count)
    except Exception as e:
        print(f"[Slide Configuration] Error: {str(e)}")
        yield "", "", "", None, f"❌ Error configuring slides: {str(e)}"
        return
    
    if not slides:
        yield "", "", "", None, "No slides defined."
        return
    
    total_slides = len(slides)
    print(f"\n[PPT Generation] Starting - Total {total_slides} slides (Cover + {slide_count} content + Thank You)")
    print(f"[PPT Generation] Topic: {ppt_topic}")
    print(f"[PPT Generation] Template: {template_name}")
    print(f"[PPT Generation] Audience: {audience_type}")
    print(f"[PPT Generation] Language: {language}")
    print(f"[PPT Generation] Design Theme: {theme_name}")
    print(f"[PPT Generation] Web Search: {'Enabled' if use_web_search else 'Disabled'}")
    
    conversation_log = []
    all_responses = {"supervisor": [], "researcher": [], "executor": []}
    
    try:
        # 1단계: 감독자 AI 초기 분석 및 키워드 추출
        progress(0.1, "🧠 감독자 AI가 PPT 구조를 설계 중...")
        supervisor_prompt = ppt_system.create_supervisor_initial_prompt(ppt_topic)
        supervisor_initial_response = ""
        
        supervisor_text = "[PPT 구조 설계] 🔄 생성 중...\n"
        for chunk in ppt_system.call_llm_streaming(
            [{"role": "user", "content": supervisor_prompt}], 
            "supervisor"
        ):
            supervisor_initial_response += chunk
            supervisor_text = f"[PPT 구조 설계] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_initial_response}"
            yield supervisor_text, "", "", None, "🔄 감독자 AI가 PPT 구조를 설계 중..."
        
        all_responses["supervisor"].append(supervisor_initial_response)
        
        # 2단계: 웹 검색 수행 (선택된 경우)
        search_results = {}
        if use_web_search and BRAVE_API_TOKEN:
            progress(0.2, "🔍 PPT 콘텐츠 검색 중...")
            keywords = ppt_system.extract_keywords(supervisor_initial_response)
            logger.info(f"추출된 키워드: {keywords}")
            
            researcher_text = "[콘텐츠 검색] 🔍 검색 중...\n"
            yield supervisor_text, researcher_text, "", None, "🔍 PPT 콘텐츠 검색 중..."
            
            total_search_count = 0
            
            # 원래 키워드로 검색
            for keyword in keywords:
                try:
                    results = ppt_system.brave_search(keyword)
                    if results:
                        search_results[keyword] = results
                        total_search_count += len(results)
                        researcher_text += f"✓ '{keyword}' 검색 완료 ({len(results)}개 결과)\n"
                        yield supervisor_text, researcher_text, "", None, f"🔍 '{keyword}' 검색 중..."
                except Exception as e:
                    print(f"[Search] Error searching for '{keyword}': {str(e)}")
            
            researcher_text += f"\n📊 총 {total_search_count}개의 검색 결과 수집 완료\n"
        
        # 3단계: 조사자 AI가 검색 결과 정리
        progress(0.3, "📝 조사자 AI가 콘텐츠 정리 중...")
        researcher_prompt = ppt_system.create_researcher_prompt(ppt_topic, supervisor_initial_response, search_results)
        researcher_response = ""
        
        researcher_text = "[PPT 콘텐츠 정리] 🔄 생성 중...\n"
        for chunk in ppt_system.call_llm_streaming(
            [{"role": "user", "content": researcher_prompt}], 
            "researcher"
        ):
            researcher_response += chunk
            researcher_text = f"[PPT 콘텐츠 정리] - {datetime.now().strftime('%H:%M:%S')}\n{researcher_response}"
            yield supervisor_text, researcher_text, "", None, "📝 조사자 AI가 콘텐츠 정리 중..."
        
        all_responses["researcher"].append(researcher_response)
        
        # 4단계: 감독자 AI가 조사 내용 기반으로 실행 지시
        progress(0.4, "🎯 감독자 AI가 제작 지시 중...")
        supervisor_execution_prompt = ppt_system.create_supervisor_execution_prompt(ppt_topic, researcher_response)
        supervisor_execution_response = ""
        
        supervisor_text += "\n\n---\n\n[PPT 제작 지시] 🔄 생성 중...\n"
        for chunk in ppt_system.call_llm_streaming(
            [{"role": "user", "content": supervisor_execution_prompt}], 
            "supervisor"
        ):
            supervisor_execution_response += chunk
            temp_text = f"{all_responses['supervisor'][0]}\n\n---\n\n[PPT 제작 지시] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_execution_response}"
            supervisor_text = f"[PPT 구조 설계] - {datetime.now().strftime('%H:%M:%S')}\n{temp_text}"
            yield supervisor_text, researcher_text, "", None, "🎯 감독자 AI가 제작 지시 중..."
        
        all_responses["supervisor"].append(supervisor_execution_response)
        
        # 5단계: 실행자 AI가 조사 내용과 지시를 기반으로 초기 PPT 작성
        progress(0.5, "📊 실행자 AI가 PPT 작성 중...")
        executor_prompt = ppt_system.create_executor_prompt(ppt_topic, supervisor_execution_response, researcher_response)
        executor_response = ""
        
        executor_text = "[초기 PPT 작성] 🔄 생성 중...\n"
        for chunk in ppt_system.call_llm_streaming(
            [{"role": "user", "content": executor_prompt}], 
            "executor"
        ):
            executor_response += chunk
            executor_text = f"[초기 PPT 작성] - {datetime.now().strftime('%H:%M:%S')}\n{executor_response}"
            yield supervisor_text, researcher_text, executor_text, None, "📊 실행자 AI가 PPT 작성 중..."
        
        all_responses["executor"].append(executor_response)
        
        # 5.5단계: 실행자 AI 응답 파싱 (개선된 파서 사용)
        progress(0.55, "📝 실행자 AI 응답을 슬라이드로 변환 중...")
        
        # 개선된 파서 사용
        parsed_slides = parse_executor_response(executor_response, slides, language)
        logger.info(f"파싱된 슬라이드 수: {len(parsed_slides)}")
        
        # 파싱 성공 여부 확인
        parsing_success = len(parsed_slides) > 0
        
        # 파싱 결과 로그
        for slide_idx, slide_data in parsed_slides.items():
            logger.info(f"[파싱 결과] 슬라이드 {slide_idx + 1}:")
            logger.info(f"  - 제목: {slide_data.get('title', 'N/A')}")
            logger.info(f"  - 부제목: {slide_data.get('subtitle', 'N/A')}")
            logger.info(f"  - 불릿 포인트 수: {len(slide_data.get('bullet_points', []))}")
            if slide_data.get('bullet_points'):
                logger.info(f"  - 첫 번째 불릿: {slide_data['bullet_points'][0]}")
        
        # 파싱 실패 시 경고 및 대체 방안
        if not parsing_success:
            logger.warning("[파싱] 실행자 응답 파싱 실패 - 실행자 응답 원문을 직접 사용 시도")
            
            # 실행자 응답을 직접 보여주기 (디버깅용)
            yield supervisor_text, researcher_text, executor_text + "\n\n⚠️ 파싱 실패 - 대체 방법 사용 중...", None, "⚠️ 슬라이드 파싱 중 문제 발견, 대체 방법 사용..."
        
        # 6단계: 실제 슬라이드 생성 (개선된 로직)
        progress(0.6, "🎨 슬라이드 이미지 생성 중...")
        results = []
        preview_html = """
        <style>
            .slides-container {
                width: 100%;
                max-width: 1400px;
                margin: 0 auto;
            }
        </style>
        <div class="slides-container">
        """
        
        # Process each slide with improved logic
        for i, slide in enumerate(slides):
            try:
                progress((0.6 + (0.3 * i / total_slides)), f"슬라이드 {i+1}/{total_slides} 처리 중...")
        
                # Translate slide title if Korean
                display_title = slide.get('title', '')
                if language == "Korean" and slide.get('title', '') in SLIDE_TITLE_TRANSLATIONS:
                    display_title = SLIDE_TITLE_TRANSLATIONS[slide.get('title', '')]
        
                slide_info = f"Slide {i+1}: {display_title}"
                slide_context = f"{slide.get('title', '')} - {slide.get('prompt_hint', '')}"
                
                # 파싱된 데이터 확인 및 사용
                content = None
                speaker_notes = ""
                
                if i in parsed_slides and parsing_success:
                    # 파싱된 데이터 사용
                    parsed_data = parsed_slides[i]
                    logger.info(f"[슬라이드 {i+1}] 실행자 AI의 파싱된 콘텐츠 사용")
                    
                    # 불릿 포인트 검증
                    valid_bullets = []
                    for bp in parsed_data.get("bullet_points", []):
                        # 의미없는 placeholder 제거
                        if bp and not any(skip in bp for skip in ["Point 1", "Point 2", "Point 3", "Point 4", "Point 5", "📌 Point"]):
                            valid_bullets.append(bp)
                    
                    # 유효한 불릿 포인트가 있으면 사용
                    if len(valid_bullets) >= 3:  # 최소 3개 이상일 때만 사용
                        content = {
                            "subtitle": parsed_data.get("subtitle") or display_title,
                            "bullet_points": valid_bullets[:5]  # 최대 5개
                        }
                        speaker_notes = parsed_data.get("speaker_notes", "")
                        logger.info(f"[슬라이드 {i+1}] 파싱된 콘텐츠 사용 완료 - 불릿 {len(valid_bullets)}개")
                    else:
                        logger.warning(f"[슬라이드 {i+1}] 불릿 포인트 부족 ({len(valid_bullets)}개) - 실행자 응답에서 재추출 시도")
                        
                        # 실행자 응답에서 해당 슬라이드 관련 내용 재추출
                        slide_keywords = [display_title, slide.get('title', ''), slide.get('prompt_hint', '')]
                        extracted_content = extract_relevant_content_from_executor(
                            executor_response, slide_keywords, i+1, slide.get('title', '')
                        )
                        
                        if extracted_content and len(extracted_content.get("bullet_points", [])) >= 3:
                            content = extracted_content
                            speaker_notes = extracted_content.get("speaker_notes", "")
                            logger.info(f"[슬라이드 {i+1}] 실행자 응답에서 재추출 성공")
                
                # 파싱 실패하거나 콘텐츠가 없으면 실행자 응답에서 직접 추출
                if not content:
                    logger.warning(f"[슬라이드 {i+1}] 파싱 실패 - 실행자 응답에서 직접 추출 시도")
                    
                    # 슬라이드 번호로 실행자 응답에서 해당 부분 찾기
                    slide_section = extract_slide_section_from_executor(executor_response, i+1)
                    
                    if slide_section:
                        content = parse_slide_section(slide_section, display_title)
                        speaker_notes = extract_speaker_notes_from_section(slide_section)
                        logger.info(f"[슬라이드 {i+1}] 실행자 응답에서 직접 추출 성공")
                
                # 그래도 콘텐츠가 없으면 최종 폴백
                if not content or len(content.get("bullet_points", [])) < 3:
                    logger.warning(f"[슬라이드 {i+1}] 모든 방법 실패 - generate_slide_content 폴백 사용")
                    
                    # Thank You slide 특별 처리
                    if slide.get('title') == 'Thank You':
                        conclusion_phrase = generate_conclusion_phrase(
                            ppt_topic, audience_type, language, 
                            FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
                        )
                        content = {
                            "subtitle": conclusion_phrase,
                            "bullet_points": []
                        }
                        speaker_notes = generate_closing_notes(
                            ppt_topic, conclusion_phrase, audience_type, language,
                            FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
                        )
                    else:
                        # 일반 슬라이드 폴백 생성
                        content = generate_slide_content(
                            ppt_topic, slide.get('title', ''), slide_context, audience_type, language,
                            uploaded_content, list(search_results.values()) if use_web_search else [],
                            FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
                        )
                        speaker_notes = generate_presentation_notes(
                            ppt_topic, slide.get('title', ''), content, audience_type, language,
                            FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
                        )
                
                # 발표자 노트가 없으면 생성
                if not speaker_notes:
                    speaker_notes = generate_presentation_notes(
                        ppt_topic, slide.get('title', ''), content, audience_type, language,
                        FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
                    )
                
                # Generate prompt and image
                style_key = slide.get("style", "Colorful Mind Map")
                if style_key in STYLE_TEMPLATES:
                    style_info = STYLE_TEMPLATES[style_key]
                    prompt = generate_prompt_with_llm(
                        ppt_topic, style_info["example"], 
                        slide_context, uploaded_content,
                        FRIENDLI_TOKEN, API_URL, MODEL_ID
                    )
                    
                    # Generate image
                    slide_seed = seed + i
                    img, used_prompt = generate_image(
                        prompt, slide_seed, slide_info, 
                        REPLICATE_API_TOKEN, current_topic, current_language,
                        FRIENDLI_TOKEN, API_URL, MODEL_ID
                    )
                    
                    # Prepare slide data
                    slide_data = {
                        "slide_number": i + 1,
                        "title": display_title,
                        "subtitle": content["subtitle"],
                        "bullet_points": content["bullet_points"][:5],
                        "image": img,
                        "style": style_info["name"],
                        "speaker_notes": speaker_notes,
                        "topic": ppt_topic
                    }
                    
                    # 디버깅: 실제 사용된 콘텐츠 로그
                    logger.info(f"[슬라이드 {i+1}] 최종 콘텐츠:")
                    logger.info(f"  - 부제목: {slide_data['subtitle']}")
                    logger.info(f"  - 불릿 포인트: {len(slide_data['bullet_points'])}개")
                    if slide_data['bullet_points']:
                        logger.info(f"  - 첫 번째 불릿: {slide_data['bullet_points'][0]}")
                    
                    # Generate preview HTML
                    preview_html += create_slide_preview_html(slide_data)
                    
                    # Update current state
                    yield supervisor_text, researcher_text, executor_text, None, f"### 🔄 {slide_info} 생성 중..."
                    
                    results.append({
                        "slide_data": slide_data,
                        "success": img is not None
                    })
                else:
                    logger.error(f"[슬라이드 {i+1}] 알 수 없는 스타일: {style_key}")
                    
            except Exception as e:
                logger.error(f"[슬라이드 {i+1}] 처리 중 오류: {str(e)}")
                import traceback
                traceback.print_exc()
                
                # 오류 시 기본값
                results.append({
                    "slide_data": {
                        "slide_number": i + 1,
                        "title": display_title,
                        "subtitle": "콘텐츠 생성 중 오류 발생",
                        "bullet_points": ["• 오류로 인해 콘텐츠를 생성할 수 없습니다"],
                        "image": None,
                        "style": "Error",
                        "speaker_notes": "오류로 인해 발표자 노트를 생성할 수 없습니다.",
                        "topic": ppt_topic
                    },
                    "success": False
                })
        
        # Create PPTX file
        progress(0.95, "Creating PPTX file...")
        pptx_path = None
        try:
            pptx_path = create_pptx_file(results, ppt_topic, template_name, theme_name, DESIGN_THEMES)
        except Exception as e:
            print(f"[PPTX] File creation error: {str(e)}")
            import traceback
            traceback.print_exc()
        
        preview_html += "</div>"
        progress(1.0, "Complete!")
        successful = sum(1 for r in results if r["success"])
        final_status = f"### 🎉 Generation complete! {successful} out of {total_slides} slides succeeded"
        
        # Save global variables
        global current_slides_data, current_template, current_theme
        current_slides_data = results
        current_template = template_name
        current_theme = theme_name
        
        if pptx_path:
            final_status += f"\n\n### 📥 PPTX file is ready!"
            final_status += f"\n\n🎤 **Speaker notes for {audience_type} included in each slide!**"
            if PROCESS_FLOW_AVAILABLE:
                final_status += f"\n\n🔧 **Process flow diagrams are automatically generated ({language} support)**"
        
        yield supervisor_text, researcher_text, executor_text, pptx_path, final_status
        
    except Exception as e:
        error_msg = f"❌ 처리 중 오류: {str(e)}"
        print(f"[PPT Generation] Critical error: {str(e)}")
        import traceback
        traceback.print_exc()
        yield "", "", "", None, error_msg

def generate_ppt_handler(topic, template_name, audience_type, language, theme_name, slide_count, 
                       seed, file_upload, use_web_search, custom_slide_count, 
                       progress=gr.Progress(), *custom_inputs):
    if not topic.strip():
        yield "", "", "", None, "❌ Please enter a topic."
        return
    
    # Process custom slides
    custom_slides = []
    if template_name == "Custom" and custom_inputs:
        try:
            # Convert custom_inputs to list to avoid tuple slicing issues
            custom_inputs_list = list(custom_inputs)
            
            for i in range(0, min(custom_slide_count * 3, len(custom_inputs_list)), 3):
                title = custom_inputs_list[i] if i < len(custom_inputs_list) else ""
                style = custom_inputs_list[i+1] if i+1 < len(custom_inputs_list) else "Colorful Mind Map"
                hint = custom_inputs_list[i+2] if i+2 < len(custom_inputs_list) else ""
                
                if title and style:
                    custom_slides.append({
                        "title": title,
                        "style": style,
                        "prompt_hint": hint
                    })
        except Exception as e:
            print(f"[Custom Slides] Error processing custom inputs: {str(e)}")
            yield "", "", "", None, f"❌ Error processing custom slides: {str(e)}"
            return
    
    # Generate PPT
    try:
        for supervisor, researcher, executor, pptx_file, status in process_ppt_streaming(
            topic, template_name, audience_type, language, custom_slides, slide_count, 
            seed, file_upload, use_web_search, theme_name, progress
        ):
            yield supervisor, researcher, executor, pptx_file, status
    except Exception as e:
        print(f"[PPT Generation] Error: {str(e)}")
        import traceback
        traceback.print_exc()
        yield "", "", "", None, f"❌ Error during PPT generation: {str(e)}"

# ===== Gradio UI =====
with gr.Blocks(title="PPT Generator", theme=gr.themes.Soft(), css=get_css()) as demo:
    gr.Markdown("""
    # 🎯 Open GAMMA 'GAMJA' - AI Presentation Generator with 3-AI Collaboration
    
    ### Create professional presentations with AI-powered collaboration system!
    
    ** Community: https://discord.gg/openfreeai
    """)
    
    # API token status check
    token_status = []
    if not REPLICATE_API_TOKEN:
        token_status.append("⚠️ RAPI_TOKEN environment variable not set.")
    if not FRIENDLI_TOKEN:
        token_status.append("⚠️ FRIENDLI_TOKEN environment variable not set.")
    if not BRAVE_API_TOKEN:
        token_status.append("ℹ️ BAPI_TOKEN not available. Web search disabled.")
    if not PROCESS_FLOW_AVAILABLE:
        token_status.append("ℹ️ process_flow_generator not available. Process flow diagrams disabled.")
    
    if token_status:
        gr.Markdown("\n".join(token_status))
    
    with gr.Row():
        with gr.Column(scale=1):
            # Language selection (at the top)
            language_select = gr.Radio(
                choices=["English", "Korean"],
                label="🌐 Content Language",
                value="English",
                info="Select the language for your presentation content"
            )
            
            # Example selection
            with gr.Row():
                example_btn = gr.Button("📋 Load Example", size="sm", variant="secondary")
                
            # Basic inputs
            topic_input = gr.Textbox(
                label="Presentation Topic",
                placeholder="e.g., AI Startup Investment Pitch, New Product Launch, Digital Transformation Strategy",
                lines=2
            )
            
            # Audience selection
            audience_select = gr.Dropdown(
                choices=list(AUDIENCE_TYPES.keys()),
                label="🎭 Target Audience",
                value="General Staff",
                info="Content and tone will be automatically optimized for your audience"
            )
            
            # Audience description display
            audience_info = gr.Markdown()
            
            # PPT template selection
            template_select = gr.Dropdown(
                choices=list(PPT_TEMPLATES.keys()),
                label="PPT Template",
                value="Business Proposal",
                info="Select a template that matches your purpose"
            )
            
            # Design theme selection
            theme_select = gr.Dropdown(
                choices=list(DESIGN_THEMES.keys()),
                label="Design Theme",
                value="Minimal Light",
                info="Overall design style for your presentation"
            )
            
            # Theme preview
            theme_preview = gr.HTML()
            
            # Slide count selection
            slide_count = gr.Slider(
                minimum=6,
                maximum=20,
                value=8,
                step=1,
                label="Number of Content Slides (excluding Cover and Thank You)",
                info="Select the number of content slides to generate (not used in Custom template)"
            )
            
            # File upload
            file_upload = gr.File(
                label="Reference Material Upload (Optional)",
                file_types=[".pdf", ".csv", ".txt"],
                type="filepath",
                value=None
            )
            
            # Web search option
            use_web_search = gr.Checkbox(
                label="Use Web Search",
                value=True,
                info="Use Brave Search to include latest information"
            )
            
            # Template description
            template_info = gr.Markdown()
            
            # Seed value
            seed_input = gr.Slider(
                minimum=1,
                maximum=100,
                value=10,
                step=1,
                label="Seed Value"
            )
            
            generate_btn = gr.Button("🚀 Generate PPT (AI creates all content automatically)", variant="primary", size="lg")
            
            # Usage instructions
            with gr.Accordion("📖 How to Use", open=False):
                gr.Markdown(get_usage_instructions())
    
    # Status display
    with gr.Row():
        with gr.Column():
            status_output = gr.Markdown(
                value="### 👆 Select a template and click the generate button!"
            )
            
            # PPTX download area
            download_file = gr.File(
                label="📥 Download Generated PPTX File",
                visible=True,
                elem_id="download-file"
            )
    
    # AI outputs in tabs
    with gr.Tabs():
        with gr.TabItem("🤖 3-AI Collaboration Process"):
            with gr.Row():
                # 감독자 AI 출력
                with gr.Column():
                    gr.Markdown("### 🧠 Supervisor AI (Structure Design)")
                    supervisor_output = gr.Textbox(
                        label="",
                        lines=20,
                        max_lines=25,
                        interactive=False,
                        elem_classes=["supervisor-box"]
                    )
                
                # 조사자 AI 출력
                with gr.Column():
                    gr.Markdown("### 🔍 Researcher AI (Content Collection)")
                    researcher_output = gr.Textbox(
                        label="",
                        lines=20,
                        max_lines=25,
                        interactive=False,
                        elem_classes=["researcher-box"]
                    )
                
                # 실행자 AI 출력
                with gr.Column():
                    gr.Markdown("### 📝 Executor AI (Slide Creation)")
                    executor_output = gr.Textbox(
                        label="",
                        lines=20,
                        max_lines=25,
                        interactive=False,
                        elem_classes=["executor-box"]
                    )
        
        with gr.TabItem("📊 PPT Preview"):
            # Preview area
            preview_output = gr.HTML(
                label="PPT Preview (16:9)",
                elem_classes="preview-container"
            )
    
    # Custom slides section
    with gr.Accordion("📝 Custom Slide Configuration", open=False, elem_id="custom_accordion") as custom_accordion:
        gr.Markdown("Build your presentation without using templates. (3-20 slides)")
        
        # Custom slide count selection
        custom_slide_count = gr.Slider(
            minimum=3,
            maximum=20,
            value=5,
            step=1,
            label="Number of Custom Slides",
            info="Select the number of custom slides to create"
        )
        
        custom_slides_components = create_custom_slides_ui(initial_count=5)
    
    # Connect events
    example_btn.click(
        fn=load_example,
        inputs=[template_select, language_select],
        outputs=[topic_input]
    )
    
    audience_select.change(
        fn=update_audience_info,
        inputs=[audience_select],
        outputs=[audience_info]
    )
    
    theme_select.change(
        fn=update_theme_preview,
        inputs=[theme_select],
        outputs=[theme_preview]
    )
    
    template_select.change(
        fn=update_template_info,
        inputs=[template_select, slide_count],
        outputs=[template_info, slide_count, custom_accordion]
    )
    
    slide_count.change(
        fn=lambda t, s: update_template_info(t, s)[0],
        inputs=[template_select, slide_count],
        outputs=[template_info]
    )
    
    custom_slide_count.change(
        fn=update_custom_slides_visibility,
        inputs=[custom_slide_count],
        outputs=[slide["row"] for slide in custom_slides_components]
    )
    
    # Flatten custom slide input components
    all_custom_inputs = []
    for slide in custom_slides_components:
        all_custom_inputs.extend([slide["title"], slide["style"], slide["hint"]])
    
    generate_btn.click(
        fn=generate_ppt_handler,
        inputs=[
            topic_input, template_select, audience_select, language_select, theme_select, 
            slide_count, seed_input, file_upload, use_web_search, custom_slide_count
        ] + all_custom_inputs,
        outputs=[supervisor_output, researcher_output, executor_output, download_file, status_output]
    )
    
    # Load initial info on startup
    demo.load(
        fn=lambda: (update_template_info(template_select.value, slide_count.value)[0],
                   update_theme_preview(theme_select.value),
                   update_audience_info(audience_select.value)),
        inputs=[],
        outputs=[template_info, theme_preview, audience_info]
    )

# Run app
if __name__ == "__main__":
    demo.queue()  # Enable queue for streaming
    demo.launch(ssr_mode=False)