app-BACKUP2.py

import gradio as gr
import os
import json
import requests
from datetime import datetime
import time
from typing import List, Dict, Any, Generator, Tuple, Optional, Set
import logging
import re
import tempfile
from pathlib import Path
import sqlite3
import hashlib
import threading
from contextlib import contextmanager
from dataclasses import dataclass, field, asdict
from collections import defaultdict
import random

# --- 로깅 설정 ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- 환경 변수 및 상수 ---
FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY", "")
BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
API_URL = "https://api.fireworks.ai/inference/v1/chat/completions"
MODEL_ID = "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507"
DB_PATH = "screenplay_sessions_korean.db"

# 시나리오 길이 설정
SCREENPLAY_LENGTHS = {
   "영화": {"pages": 120, "description": "장편 영화 (110-130페이지)", "min_pages": 110},
   "드라마": {"pages": 60, "description": "TV 드라마 (55-65페이지)", "min_pages": 55},
   "웹드라마": {"pages": 50, "description": "웹/OTT 시리즈 (45-55페이지)", "min_pages": 45},
   "단편": {"pages": 20, "description": "단편 영화 (15-25페이지)", "min_pages": 15}
}

# 환경 검증
if not FIREWORKS_API_KEY:
   logger.error("FIREWORKS_API_KEY가 설정되지 않았습니다.")
   FIREWORKS_API_KEY = "dummy_token_for_testing"

# 글로벌 변수
db_lock = threading.Lock()

# 전문가 역할 정의
EXPERT_ROLES = {
    "프로듀서": {
        "emoji": "🎬",
        "description": "상업성과 시장성 분석",
        "focus": ["타겟 관객", "제작 가능성", "예산 규모", "마케팅 포인트"],
        "personality": "실용적이고 시장 지향적"
    },
    "스토리작가": {
        "emoji": "📖",
        "description": "내러티브 구조와 플롯 개발",
        "focus": ["3막 구조", "플롯 포인트", "서사 아크", "테마"],
        "personality": "창의적이고 구조적"
    },
    "캐릭터디자이너": {
        "emoji": "👥",
        "description": "인물 창조와 관계 설계",
        "focus": ["캐릭터 아크", "동기부여", "관계 역학", "대화 스타일"],
        "personality": "심리학적이고 공감적"
    },
    "감독": {
        "emoji": "🎭",
        "description": "비주얼 스토리텔링과 연출",
        "focus": ["시각적 구성", "카메라 워크", "미장센", "리듬과 페이싱"],
        "personality": "비주얼 중심적이고 예술적"
    },
    "비평가": {
        "emoji": "🔍",
        "description": "객관적 분석과 개선점 제시",
        "focus": ["논리적 일관성", "감정적 임팩트", "원작 충실도", "완성도"],
        "personality": "분석적이고 비판적"
    },
    "편집자": {
        "emoji": "✂️",
        "description": "페이싱과 구조 최적화",
        "focus": ["씬 전환", "리듬", "긴장감 조절", "불필요한 부분 제거"],
        "personality": "정밀하고 효율적"
    },
    "대화전문가": {
        "emoji": "💬",
        "description": "대사와 서브텍스트 강화",
        "focus": ["자연스러운 대화", "캐릭터 보이스", "서브텍스트", "감정 전달"],
        "personality": "언어적이고 뉘앙스 중심"
    },
    "장르전문가": {
        "emoji": "🎯",
        "description": "장르 관습과 기대치 충족",
        "focus": ["장르 관습", "관객 기대", "장르 특유 요소", "트로프 활용"],
        "personality": "장르에 정통한"
    }
}

# 장르 템플릿
GENRE_TEMPLATES = {
   "액션": {
       "pacing": "빠름",
       "scene_length": "짧음",
       "dialogue_ratio": 0.3,
       "key_elements": ["액션 시퀀스", "물리적 갈등", "긴박감", "위기 고조", "영웅적 순간"],
       "structure_beats": ["폭발적 오프닝", "추격", "대결", "클라이맥스 전투", "영웅의 승리"],
       "scene_density": 1.2,
       "action_description_ratio": 0.6
   },
   "스릴러": {
       "pacing": "빠름",
       "scene_length": "짧음",
       "dialogue_ratio": 0.35,
       "key_elements": ["서스펜스", "반전", "편집증", "시간 압박", "진실 폭로"],
       "structure_beats": ["훅", "미스터리 심화", "거짓 승리", "진실 폭로", "최종 대결"],
       "scene_density": 1.1,
       "action_description_ratio": 0.5
   },
   "드라마": {
       "pacing": "보통",
       "scene_length": "중간",
       "dialogue_ratio": 0.55,
       "key_elements": ["캐릭터 깊이", "감정적 진실", "관계", "내적 갈등", "변화"],
       "structure_beats": ["일상", "촉매", "고민", "결심", "복잡화", "위기", "해결"],
       "scene_density": 0.9,
       "action_description_ratio": 0.3
   },
   "코미디": {
       "pacing": "빠름",
       "scene_length": "짧음",
       "dialogue_ratio": 0.65,
       "key_elements": ["셋업과 페이오프", "타이밍", "캐릭터 코미디", "상황 고조", "러닝 개그"],
       "structure_beats": ["웃긴 오프닝", "복잡화", "오해 증폭", "혼돈의 정점", "해결과 콜백"],
       "scene_density": 1.0,
       "action_description_ratio": 0.35
   },
   "공포": {
       "pacing": "가변적",
       "scene_length": "혼합",
       "dialogue_ratio": 0.3,
       "key_elements": ["분위기", "공포감", "점프 스케어", "심리적 공포", "고립"],
       "structure_beats": ["평범한 일상", "첫 징조", "조사", "첫 공격", "생존", "최종 대결"],
       "scene_density": 1.0,
       "action_description_ratio": 0.55
   },
   "SF": {
       "pacing": "보통",
       "scene_length": "중간",
       "dialogue_ratio": 0.45,
       "key_elements": ["세계관 구축", "기술", "개념", "시각적 스펙터클", "철학적 질문"],
       "structure_beats": ["일상 세계", "발견", "새로운 세계", "복잡화", "이해", "선택", "새로운 일상"],
       "scene_density": 0.95,
       "action_description_ratio": 0.45
   },
   "로맨스": {
       "pacing": "보통",
       "scene_length": "중간",
       "dialogue_ratio": 0.6,
       "key_elements": ["케미스트리", "장애물", "감정적 순간", "친밀감", "취약성"],
       "structure_beats": ["만남", "끌림", "첫 갈등", "깊어짐", "위기/이별", "화해", "결합"],
       "scene_density": 0.85,
       "action_description_ratio": 0.25
   },
   "판타지": {
       "pacing": "보통",
       "scene_length": "중간",
       "dialogue_ratio": 0.4,
       "key_elements": ["마법 체계", "영웅의 여정", "신화적 요소", "세계관", "성장"],
       "structure_beats": ["평범한 세계", "소명", "거부", "멘토", "첫 시험", "시련", "보상", "귀환"],
       "scene_density": 1.0,
       "action_description_ratio": 0.5
   }
}

# 기획 단계 - 다중 역할 협업
PLANNING_STAGES = [
    ("프로듀서", "producer", "🎬 프로듀서: 핵심 컨셉 및 시장성 분석"),
    ("스토리작가", "story_writer", "📖 스토리 작가: 시놉시스 및 3막 구조"),
    ("캐릭터디자이너", "character_designer", "👥 캐릭터 디자이너: 인물 프로필 및 관계도"),
    ("감독", "director", "🎭 감독: 비주얼 컨셉 및 연출 방향"),
    ("비평가", "critic", "🔍 비평가: 기획안 종합 검토 및 개선점"),
]

# 작성 단계 - 다중 역할 협업
WRITING_STAGES = [
    ("스토리작가", "1막 초고", "✍️ 1막 초고 작성"),
    ("편집자", "1막 편집", "✂️ 1막 편집 및 페이싱 조정"),
    ("감독", "1막 연출", "🎭 1막 비주얼 강화"),
    ("대화전문가", "1막 대사", "💬 1막 대사 개선"),
    ("비평가", "1막 검토", "🔍 1막 종합 검토"),
    ("스토리작가", "1막 완성", "✅ 1막 최종 완성본"),
    
    ("스토리작가", "2막A 초고", "✍️ 2막A 초고 작성"),
    ("편집자", "2막A 편집", "✂️ 2막A 편집 및 페이싱 조정"),
    ("감독", "2막A 연출", "🎭 2막A 비주얼 강화"),
    ("대화전문가", "2막A 대사", "💬 2막A 대사 개선"),
    ("비평가", "2막A 검토", "🔍 2막A 종합 검토"),
    ("스토리작가", "2막A 완성", "✅ 2막A 최종 완성본"),
    
    ("스토리작가", "2막B 초고", "✍️ 2막B 초고 작성"),
    ("편집자", "2막B 편집", "✂️ 2막B 편집 및 페이싱 조정"),
    ("감독", "2막B 연출", "🎭 2막B 비주얼 강화"),
    ("대화전문가", "2막B 대사", "💬 2막B 대사 개선"),
    ("비평가", "2막B 검토", "🔍 2막B 종합 검토"),
    ("스토리작가", "2막B 완성", "✅ 2막B 최종 완성본"),
    
    ("스토리작가", "3막 초고", "✍️ 3막 초고 작성"),
    ("편집자", "3막 편집", "✂️ 3막 편집 및 페이싱 조정"),
    ("감독", "3막 연출", "🎭 3막 비주얼 강화"),
    ("대화전문가", "3막 대사", "💬 3막 대사 개선"),
    ("비평가", "3막 검토", "🔍 3막 종합 검토"),
    ("스토리작가", "3막 완성", "✅ 3막 최종 완성본"),
    
    ("장르전문가", "장르 최적화", "🎯 장르 특성 최적화"),
    ("비평가", "최종 검토", "🔍 최종 검토 및 완성도 평가"),
]

# 데이터 클래스
@dataclass
class ExpertFeedback:
    """전문가 피드백"""
    role: str
    stage: str
    feedback: str
    suggestions: List[str]
    score: float
    timestamp: datetime = field(default_factory=datetime.now)

@dataclass
class ScreenplayPlan:
    """시나리오 기획안"""
    title: str = ""
    logline: str = ""
    genre: str = ""
    subgenre: str = ""
    themes: List[str] = field(default_factory=list)
    
    # 시놉시스
    synopsis: str = ""
    extended_synopsis: str = ""
    
    # 3막 구조
    act1_summary: str = ""
    act2a_summary: str = ""
    act2b_summary: str = ""
    act3_summary: str = ""
    
    # 주요 캐릭터
    protagonist: Dict[str, str] = field(default_factory=dict)
    antagonist: Dict[str, str] = field(default_factory=dict)
    supporting_characters: List[Dict[str, str]] = field(default_factory=list)
    
    # 세계관
    time_period: str = ""
    locations: List[str] = field(default_factory=list)
    atmosphere: str = ""
    visual_style: str = ""
    
    # 씬 구성
    total_scenes: int = 0
    scene_breakdown: List[Dict] = field(default_factory=list)
    
    # 전문가 피드백
    expert_feedbacks: List[ExpertFeedback] = field(default_factory=list)

# 데이터베이스 클래스
class ScreenplayDatabase:
    @staticmethod
    def init_db():
        with sqlite3.connect(DB_PATH) as conn:
            conn.execute("PRAGMA journal_mode=WAL")
            cursor = conn.cursor()
            
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS screenplay_sessions (
                    session_id TEXT PRIMARY KEY,
                    user_query TEXT NOT NULL,
                    screenplay_type TEXT NOT NULL,
                    genre TEXT NOT NULL,
                    target_pages INTEGER,
                    title TEXT,
                    logline TEXT,
                    planning_data TEXT,
                    expert_feedbacks TEXT,
                    screenplay_content TEXT,
                    created_at TEXT DEFAULT (datetime('now')),
                    updated_at TEXT DEFAULT (datetime('now')),
                    status TEXT DEFAULT 'planning',
                    current_stage INTEGER DEFAULT 0,
                    total_pages REAL DEFAULT 0
                )
            ''')
            
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS expert_reviews (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT NOT NULL,
                    role TEXT NOT NULL,
                    stage TEXT NOT NULL,
                    feedback TEXT,
                    suggestions TEXT,
                    score REAL,
                    created_at TEXT DEFAULT (datetime('now')),
                    FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id)
                )
            ''')
            
            conn.commit()

    @staticmethod
    @contextmanager
    def get_db():
        with db_lock:
            conn = sqlite3.connect(DB_PATH, timeout=30.0)
            conn.row_factory = sqlite3.Row
            try:
                yield conn
            finally:
                conn.close()

    @staticmethod
    def create_session(user_query: str, screenplay_type: str, genre: str) -> str:
        session_id = hashlib.md5(f"{user_query}{screenplay_type}{datetime.now()}".encode()).hexdigest()
        target_pages = SCREENPLAY_LENGTHS[screenplay_type]["pages"]
        
        with ScreenplayDatabase.get_db() as conn:
            conn.cursor().execute(
                '''INSERT INTO screenplay_sessions 
                   (session_id, user_query, screenplay_type, genre, target_pages) 
                   VALUES (?, ?, ?, ?, ?)''',
                (session_id, user_query, screenplay_type, genre, target_pages)
            )
            conn.commit()
        return session_id

    @staticmethod
    def save_expert_feedback(session_id: str, role: str, stage: str, 
                           feedback: str, suggestions: List[str], score: float):
        with ScreenplayDatabase.get_db() as conn:
            conn.cursor().execute(
                '''INSERT INTO expert_reviews 
                   (session_id, role, stage, feedback, suggestions, score)
                   VALUES (?, ?, ?, ?, ?, ?)''',
                (session_id, role, stage, feedback, json.dumps(suggestions, ensure_ascii=False), score)
            )
            conn.commit()

    @staticmethod
    def save_planning_data(session_id: str, planning_data: Dict):
        with ScreenplayDatabase.get_db() as conn:
            conn.cursor().execute(
                '''UPDATE screenplay_sessions 
                   SET planning_data = ?, status = 'planned', updated_at = datetime('now')
                   WHERE session_id = ?''',
                (json.dumps(planning_data, ensure_ascii=False), session_id)
            )
            conn.commit()

    @staticmethod
    def save_screenplay_content(session_id: str, content: str, title: str, logline: str):
        with ScreenplayDatabase.get_db() as conn:
            total_pages = len(content.split('\n')) / 58
            conn.cursor().execute(
                '''UPDATE screenplay_sessions 
                   SET screenplay_content = ?, title = ?, logline = ?, 
                       total_pages = ?, status = 'complete', updated_at = datetime('now')
                   WHERE session_id = ?''',
                (content, title, logline, total_pages, session_id)
            )
            conn.commit()

# 시나리오 생성 시스템
class ScreenplayGenerationSystem:
    def __init__(self):
        self.api_key = FIREWORKS_API_KEY
        self.api_url = API_URL
        self.model_id = MODEL_ID
        self.current_session_id = None
        self.current_plan = ScreenplayPlan()
        self.original_query = ""
        self.accumulated_content = {}
        self.expert_feedbacks = []
        ScreenplayDatabase.init_db()

    def create_headers(self):
        if not self.api_key or self.api_key == "dummy_token_for_testing":
            raise ValueError("유효한 FIREWORKS_API_KEY가 필요합니다")
        
        return {
            "Accept": "application/json",
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }

    def call_llm_streaming(self, messages: List[Dict[str, str]], max_tokens: int = 8000) -> Generator[str, None, None]:
        try:
            payload = {
                "model": self.model_id,
                "messages": messages,
                "max_tokens": max_tokens,
                "temperature": 0.7,
                "top_p": 0.9,
                "top_k": 40,
                "presence_penalty": 0.3,
                "frequency_penalty": 0.3,
                "stream": True
            }
            
            headers = self.create_headers()
            
            response = requests.post(
                self.api_url, 
                headers=headers, 
                json=payload, 
                stream=True, 
                timeout=300
            )
            
            if response.status_code != 200:
                yield f"❌ API 오류: {response.status_code}"
                return
            
            buffer = ""
            for line in response.iter_lines():
                if not line:
                    continue
                
                try:
                    line_str = line.decode('utf-8').strip()
                    if not line_str.startswith("data: "):
                        continue
                    
                    data_str = line_str[6:]
                    if data_str == "[DONE]":
                        break
                    
                    data = json.loads(data_str)
                    if "choices" in data and len(data["choices"]) > 0:
                        content = data["choices"][0].get("delta", {}).get("content", "")
                        if content:
                            buffer += content
                            if len(buffer) >= 100 or '\n' in buffer:
                                yield buffer
                                buffer = ""
                except:
                    continue
            
            if buffer:
                yield buffer
                
        except Exception as e:
            yield f"❌ 오류: {str(e)}"

    def get_expert_prompt(self, role: str, stage: str, query: str, 
                         previous_content: Dict, genre: str, screenplay_type: str) -> str:
        """각 전문가별 맞춤 프롬프트 생성"""
        
        expert = EXPERT_ROLES[role]
        focus_areas = ", ".join(expert["focus"])
        
        # 이전 전문가들의 피드백 요약
        previous_feedbacks = ""
        if self.expert_feedbacks:
            previous_feedbacks = "\n【이전 전문가 의견】\n"
            for fb in self.expert_feedbacks[-3:]:  # 최근 3개만
                previous_feedbacks += f"[{fb.role}]: {fb.feedback[:200]}...\n"
        
        base_prompt = f"""
【당신의 역할】
당신은 {role}입니다. {expert['description']}
성격: {expert['personality']}
집중 영역: {focus_areas}

【원본 요청】
{query}

【장르】 {genre}
【형식】 {screenplay_type}

{previous_feedbacks}

【이전 작업 내용】
{self._summarize_previous_content(previous_content)}
"""
        
        # 역할별 특화 프롬프트
        if role == "프로듀서":
            return base_prompt + f"""
【프로듀서로서 분석할 내용】
1. 상업적 가치와 시장성
   - 타겟 관객층 명확화
   - 예상 제작비 규모
   - 배급 전략
   
2. 제목과 로그라인
   - 마케팅 가능한 매력적인 제목
   - 한 문장으로 핵심 갈등 표현
   
3. 유사 성공작 분석
   - 최근 3년 내 유사 작품
   - 차별화 포인트
   
4. 제작 리스크 평가
   - 기술적 난이도
   - 캐스팅 요구사항

⚠️ 원본 요청을 상업적으로 최적화하되 핵심은 유지하세요."""

        elif role == "스토리작가":
            return base_prompt + f"""
【스토리 작가로서 구성할 내용】
1. 시놉시스 (500-800자)
   - 원본 요청의 핵심 스토리
   - 명확한 시작-중간-끝
   
2. 3막 구조 상세
   - 1막 (25%): 설정과 촉발 사건
   - 2막A (25%): 새로운 세계와 재미
   - 2막B (25%): 시련과 위기
   - 3막 (25%): 클라이맥스와 해결
   
3. 주요 플롯 포인트
   - 10개의 핵심 전환점
   - 각 전환점의 감정적 임팩트
   
4. 테마와 메시지
   - 중심 테마
   - 서브 테마들

⚠️ 원본 스토리의 논리적 흐름을 완벽하게 구현하세요."""

        elif role == "캐릭터디자이너":
            return base_prompt + f"""
【캐릭터 디자이너로서 창조할 내용】
1. 주인공 상세 프로필
   - 이름, 나이, 직업
   - 성격 (MBTI 포함)
   - 핵심 욕구(Want)와 필요(Need)
   - 치명적 결함
   - 변화 아크
   - 특징적 말투와 행동
   
2. 적대자 프로필
   - 주인공과의 대립 구조
   - 나름의 정당성
   - 약점과 맹점
   
3. 조연 캐릭터들 (3-5명)
   - 각자의 역할과 기능
   - 주인공과의 관계
   - 고유한 특징
   
4. 캐릭터 관계도
   - 인물간 역학 관계
   - 갈등 구조

⚠️ 원본에 명시된 인물 설정을 충실히 발전시키세요."""

        elif role == "감독":
            return base_prompt + f"""
【감독으로서 연출할 내용】
1. 비주얼 컨셉
   - 전체적인 룩앤필
   - 색감과 톤
   - 참조 영화/이미지
   
2. 핵심 비주얼 씬 (5개)
   - 오프닝 이미지
   - 주요 액션/감정 씬
   - 클라이맥스 비주얼
   - 엔딩 이미지
   
3. 카메라 스타일
   - 주요 샷 구성
   - 움직임과 앵글
   - 특수 촬영 기법
   
4. 사운드 디자인
   - 음악 스타일
   - 핵심 사운드 모티프
   - 침묵의 활용

⚠️ 원본의 분위기와 톤을 시각적으로 구현하세요."""

        elif role == "비평가":
            return base_prompt + f"""
【비평가로서 검토할 내용】
1. 원본 충실도 평가 (40점)
   - 핵심 요청사항 반영도
   - 임의 변경 사항 지적
   
2. 스토리 완성도 (20점)
   - 논리적 일관성
   - 감정적 호소력
   - 페이싱과 리듬
   
3. 캐릭터 평가 (20점)
   - 입체성과 매력
   - 성장 아크
   - 관계 역학
   
4. 상업성과 예술성 (20점)
   - 시장 어필
   - 독창성
   - 제작 가능성
   
5. 구체적 개선 제안
   - 우선순위별 개선점
   - 실행 가능한 해결책

총점: /100점
⚠️ 건설적이면서도 정직한 피드백을 제공하세요."""

        elif role == "편집자":
            return base_prompt + f"""
【편집자로서 조정할 내용】
1. 페이싱 분석
   - 각 씬의 길이 적정성
   - 긴장과 이완의 리듬
   - 불필요한 부분 식별
   
2. 구조 최적화
   - 씬 순서 조정 제안
   - 전환의 자연스러움
   - 정보 공개 타이밍
   
3. 트리밍 제안
   - 삭제 가능한 씬/대사
   - 압축 가능한 부분
   - 중복 제거
   
4. 임팩트 강화
   - 클라이맥스 빌드업
   - 감정적 비트 강화

⚠️ 원본 스토리를 더 타이트하고 임팩트있게 만드세요."""

        elif role == "대화전문가":
            return base_prompt + f"""
【대화 전문가로서 개선할 내용】
1. 캐릭터별 고유 화법
   - 어휘 수준과 스타일
   - 말버릇과 패턴
   - 감정 표현 방식
   
2. 서브텍스트 강화
   - 표면 대사 vs 진짜 의미
   - 침묵과 행간
   - 비언어적 소통
   
3. 핵심 대사 창조
   - 명대사 5개
   - 캐릭터 정체성 드러내기
   - 테마 전달 대사
   
4. 대화 리듬
   - 자연스러운 주고받기
   - 긴장 고조 패턴
   - 유머와 위트

⚠️ 각 캐릭터의 목소리를 뚜렷하게 구분하세요."""

        elif role == "장르전문가":
            genre_template = GENRE_TEMPLATES.get(genre, GENRE_TEMPLATES["드라마"])
            return base_prompt + f"""
【{genre} 장르 전문가로서 최적화할 내용】
1. 장르 필수 요소 체크
   - 핵심 요소: {', '.join(genre_template['key_elements'])}
   - 구조 비트: {', '.join(genre_template['structure_beats'])}
   
2. 장르 관습 충족도
   - 관객 기대 충족
   - 클리셰 활용과 전복
   - 장르 특유 장치
   
3. 톤과 분위기
   - 페이싱: {genre_template['pacing']}
   - 씬 길이: {genre_template['scene_length']}
   - 대사 비율: {genre_template['dialogue_ratio']}
   
4. 장르 특화 강화
   - 부족한 요소 추가
   - 과도한 부분 조정
   - 장르 정체성 명확화

⚠️ {genre} 장르의 정수를 완벽하게 구현하세요."""

        return base_prompt

    def _summarize_previous_content(self, content: Dict) -> str:
        """이전 내용 요약"""
        summary = ""
        for key, value in content.items():
            if value:
                summary += f"\n[{key}]\n{value[:300]}...\n"
        return summary if summary else "첫 작업입니다."

    def generate_planning(self, query: str, screenplay_type: str, genre: str, 
                         progress_callback=None) -> Generator[Tuple[str, float, Dict, List], None, None]:
        """다중 전문가 협업 기획안 생성"""
        try:
            self.original_query = query
            self.current_session_id = ScreenplayDatabase.create_session(query, screenplay_type, genre)
            
            planning_content = {}
            self.accumulated_content = {}
            self.expert_feedbacks = []
            total_stages = len(PLANNING_STAGES)
            
            for idx, (role, stage_key, stage_desc) in enumerate(PLANNING_STAGES):
                progress = (idx / total_stages) * 100
                
                yield f"🔄 {stage_desc} 진행 중...", progress, planning_content, self.expert_feedbacks
                
                # 전문가별 프롬프트 생성
                prompt = self.get_expert_prompt(
                    role, stage_key, query, 
                    self.accumulated_content, genre, screenplay_type
                )
                
                # LLM 호출
                messages = [
                    {"role": "system", "content": f"""당신은 {role}입니다.
{EXPERT_ROLES[role]['description']}
전문 분야: {', '.join(EXPERT_ROLES[role]['focus'])}
원본 요청을 절대적으로 준수하면서 전문성을 발휘하세요."""},
                    {"role": "user", "content": prompt}
                ]
                
                content = ""
                for chunk in self.call_llm_streaming(messages):
                    content += chunk
                    planning_content[f"{role}_{stage_key}"] = content
                    yield f"✏️ {stage_desc} 작성 중...", progress, planning_content, self.expert_feedbacks
                
                # 전문가 피드백 저장
                feedback = ExpertFeedback(
                    role=role,
                    stage=stage_key,
                    feedback=content[:500],
                    suggestions=self._extract_suggestions(content),
                    score=self._calculate_score(content, query)
                )
                self.expert_feedbacks.append(feedback)
                
                # DB에 피드백 저장
                ScreenplayDatabase.save_expert_feedback(
                    self.current_session_id, role, stage_key,
                    feedback.feedback, feedback.suggestions, feedback.score
                )
                
                # 누적 내용 저장
                self.accumulated_content[f"{role}_{stage_key}"] = content
                time.sleep(0.5)
            
            # 최종 기획안 저장
            ScreenplayDatabase.save_planning_data(self.current_session_id, planning_content)
            yield "✅ 전문가 협업 기획안 완성!", 100, planning_content, self.expert_feedbacks
            
        except Exception as e:
            yield f"❌ 오류 발생: {str(e)}", 0, {}, []

    def generate_screenplay(self, session_id: str, planning_data: Dict,
                          progress_callback=None) -> Generator[Tuple[str, float, str, List], None, None]:
        """다중 전문가 협업 시나리오 작성"""
        try:
            total_stages = len(WRITING_STAGES)
            screenplay_content = ""
            act_contents = {"1막": "", "2막A": "", "2막B": "", "3막": ""}
            self.expert_feedbacks = []
            
            for idx, (role, stage_name, stage_desc) in enumerate(WRITING_STAGES):
                progress = (idx / total_stages) * 100
                
                yield f"🔄 {stage_desc} 진행 중...", progress, screenplay_content, self.expert_feedbacks
                
                # 현재 막 결정
                current_act = ""
                if "1막" in stage_name:
                    current_act = "1막"
                elif "2막A" in stage_name:
                    current_act = "2막A"
                elif "2막B" in stage_name:
                    current_act = "2막B"
                elif "3막" in stage_name:
                    current_act = "3막"
                
                # 역할별 프롬프트 생성
                if role == "스토리작가":
                    prompt = self._create_writer_prompt(
                        current_act, planning_data, act_contents, stage_name
                    )
                elif role == "편집자":
                    prompt = self._create_editor_prompt(
                        current_act, act_contents[current_act] if current_act else screenplay_content
                    )
                elif role == "감독":
                    prompt = self._create_director_prompt(
                        current_act, act_contents[current_act] if current_act else screenplay_content
                    )
                elif role == "대화전문가":
                    prompt = self._create_dialogue_prompt(
                        current_act, act_contents[current_act] if current_act else screenplay_content
                    )
                elif role == "비평가":
                    prompt = self._create_critic_prompt(
                        current_act, act_contents[current_act] if current_act else screenplay_content,
                        self.original_query
                    )
                elif role == "장르전문가":
                    prompt = self._create_genre_expert_prompt(
                        screenplay_content, planning_data
                    )
                else:
                    continue
                
                # LLM 호출
                expert = EXPERT_ROLES.get(role, EXPERT_ROLES["스토리작가"])
                messages = [
                    {"role": "system", "content": f"""당신은 {role}입니다.
{expert['description']}
원본 요청: {self.original_query}
표준 시나리오 포맷을 준수하세요."""},
                    {"role": "user", "content": prompt}
                ]
                
                content = ""
                for chunk in self.call_llm_streaming(messages, max_tokens=15000):
                    content += chunk
                    
                    # 완성 단계에서만 막 내용 업데이트
                    if current_act and "완성" in stage_name:
                        act_contents[current_act] = content
                        screenplay_content = "\n\n".join([
                            act_contents[act] for act in ["1막", "2막A", "2막B", "3막"] 
                            if act_contents[act]
                        ])
                    
                    yield f"✏️ {stage_desc} 작성 중...", progress, screenplay_content, self.expert_feedbacks
                
                # 전문가 피드백 생성
                feedback = ExpertFeedback(
                    role=role,
                    stage=stage_name,
                    feedback=f"{role}가 {stage_name}을 검토/작업했습니다.",
                    suggestions=[],
                    score=85.0
                )
                self.expert_feedbacks.append(feedback)
                
                time.sleep(0.5)
            
            # 최종 저장
            title = self._extract_title(planning_data)
            logline = self._extract_logline(planning_data)
            
            ScreenplayDatabase.save_screenplay_content(session_id, screenplay_content, title, logline)
            yield "✅ 전문가 협업 시나리오 완성!", 100, screenplay_content, self.expert_feedbacks
            
        except Exception as e:
            yield f"❌ 오류 발생: {str(e)}", 0, "", []

    def _create_writer_prompt(self, act: str, planning_data: Dict, 
                             previous_acts: Dict, stage_name: str) -> str:
        """스토리 작가 프롬프트"""
        
        if "초고" in stage_name:
            min_lines = 800
        elif "완성" in stage_name:
            min_lines = 1200
        else:
            min_lines = 1000
        
        return f"""【{act} 작성】
목표 분량: {min_lines}줄 이상

【기획안 핵심】
{self._extract_planning_core(planning_data)}

【이전 막】
{previous_acts if previous_acts else "첫 막입니다"}

【작성 요구사항】
1. 표준 시나리오 포맷
2. 충분한 씬 분량 (각 5-7페이지)
3. 시각적 액션 묘사
4. 자연스러운 대화
5. 원본 스토리 충실

반드시 {min_lines}줄 이상 작성하세요."""

    def _create_editor_prompt(self, act: str, content: str) -> str:
        """편집자 프롬프트"""
        return f"""【{act} 편집】

현재 내용:
{content[:2000]}...

【편집 포인트】
1. 페이싱 조정
   - 느린 부분 가속
   - 급한 부분 완화
   
2. 불필요한 부분 제거
   - 중복 대사/액션
   - 과도한 설명
   
3. 씬 전환 개선
   - 자연스러운 연결
   - 시간/공간 이동
   
4. 긴장감 조절
   - 클라이맥스 빌드업
   - 완급 조절

구체적인 편집 제안을 하세요."""

    def _create_director_prompt(self, act: str, content: str) -> str:
        """감독 프롬프트"""
        return f"""【{act} 연출 강화】

현재 시나리오:
{content[:2000]}...

【비주얼 강화 포인트】
1. 오프닝 씬 비주얼
2. 핵심 액션 시퀀스
3. 감정적 클로즈업
4. 환경/분위기 묘사
5. 상징적 이미지

각 씬에 시각적 디테일을 추가하세요."""

    def _create_dialogue_prompt(self, act: str, content: str) -> str:
        """대화 전문가 프롬프트"""
        return f"""【{act} 대사 개선】

현재 대사 검토:
{content[:2000]}...

【개선 방향】
1. 캐릭터별 말투 차별화
2. 서브텍스트 추가
3. 불필요한 설명 제거
4. 감정적 뉘앙스 강화
5. 리듬과 템포 조정

개선된 대사 예시를 제시하세요."""

    def _create_critic_prompt(self, act: str, content: str, original_query: str) -> str:
        """비평가 프롬프트"""
        return f"""【{act} 종합 검토】

원본 요청: {original_query}

현재 내용:
{content[:2000]}...

【평가 항목】
1. 원본 충실도 (40점)
2. 스토리 완성도 (20점)
3. 캐릭터 매력 (20점)
4. 대사 품질 (10점)
5. 비주얼 임팩트 (10점)

총점: /100

【개선 필요사항】
구체적이고 실행 가능한 제안을 하세요."""

    def _create_genre_expert_prompt(self, screenplay: str, planning_data: Dict) -> str:
        """장르 전문가 프롬프트"""
        genre = planning_data.get("장르", "드라마")
        genre_template = GENRE_TEMPLATES.get(genre, GENRE_TEMPLATES["드라마"])
        
        return f"""【{genre} 장르 최적화】

【장르 특성】
- 핵심 요소: {', '.join(genre_template['key_elements'])}
- 구조 비트: {', '.join(genre_template['structure_beats'])}

【최적화 포인트】
1. 장르 관습 충족도
2. 페이싱 조정
3. 특유 요소 강화
4. 톤 일관성

장르 특성을 극대화하는 제안을 하세요."""

    def _extract_suggestions(self, content: str) -> List[str]:
        """내용에서 제안사항 추출"""
        suggestions = []
        lines = content.split('\n')
        for line in lines:
            if any(keyword in line for keyword in ['제안', '개선', '추천', '권장']):
                suggestions.append(line.strip())
        return suggestions[:5]

    def _calculate_score(self, content: str, original_query: str) -> float:
        """충실도 점수 계산"""
        score = 70.0  # 기본 점수
        
        # 원본 키워드 포함도 체크
        keywords = original_query.split()
        matched = sum(1 for keyword in keywords if keyword in content)
        score += (matched / len(keywords)) * 20 if keywords else 0
        
        # 길이 체크
        if len(content) > 500:
            score += 10
        
        return min(score, 100.0)

    def _extract_title(self, planning_data: Dict) -> str:
        """기획안에서 제목 추출"""
        for key, value in planning_data.items():
            if "제목" in value:
                match = re.search(r'제목[:\s]*([^\n]+)', value)
                if match:
                    return match.group(1).strip()
        return "무제"

    def _extract_logline(self, planning_data: Dict) -> str:
        """기획안에서 로그라인 추출"""
        for key, value in planning_data.items():
            if "로그라인" in value:
                match = re.search(r'로그라인[:\s]*([^\n]+)', value)
                if match:
                    return match.group(1).strip()
        return ""

    def _extract_planning_core(self, planning_data: Dict) -> str:
        """기획안 핵심 내용 추출"""
        core = ""
        for key, value in planning_data.items():
            if any(k in key for k in ["스토리", "캐릭터", "구조"]):
                core += f"\n[{key}]\n{value[:500]}...\n"
        return core

# 유틸리티 함수
def format_planning_display(planning_data: Dict) -> str:
    """기획안 표시 포맷"""
    if not planning_data:
        return "기획안이 아직 생성되지 않았습니다."
    
    formatted = "# 📋 시나리오 기획안 (전문가 협업)\n\n"
    
    for key, content in planning_data.items():
        role = key.split('_')[0] if '_' in key else key
        emoji = EXPERT_ROLES.get(role, {}).get("emoji", "📝")
        formatted += f"## {emoji} {key}\n\n"
        formatted += content + "\n\n"
        formatted += "---\n\n"
    
    return formatted

def format_expert_feedbacks(feedbacks: List[ExpertFeedback]) -> str:
    """전문가 피드백 표시"""
    if not feedbacks:
        return ""
    
    formatted = "## 🎯 전문가 평가\n\n"
    
    for fb in feedbacks:
        emoji = EXPERT_ROLES.get(fb.role, {}).get("emoji", "📝")
        formatted += f"### {emoji} {fb.role}\n"
        formatted += f"**점수:** {fb.score:.1f}/100\n"
        formatted += f"**피드백:** {fb.feedback[:200]}...\n"
        
        if fb.suggestions:
            formatted += "**제안사항:**\n"
            for suggestion in fb.suggestions[:3]:
                formatted += f"- {suggestion}\n"
        
        formatted += "\n"
    
    return formatted

def format_screenplay_display(screenplay_text: str) -> str:
    """시나리오 표시 포맷"""
    if not screenplay_text:
        return "시나리오가 아직 작성되지 않았습니다."
    
    formatted = "# 🎬 시나리오\n\n"
    
    # 씬 헤딩 강조
    formatted_text = re.sub(
        r'^(INT\.|EXT\.).*$',
        r'**\g<0>**',
        screenplay_text,
        flags=re.MULTILINE
    )
    
    # 캐릭터명 강조
    formatted_text = re.sub(
        r'^([가-힣A-Z][가-힣A-Z\s]+)$',
        r'**\g<0>**',
        formatted_text,
        flags=re.MULTILINE
    )
    
    # 페이지 수 계산
    page_count = len(screenplay_text.splitlines()) / 58
    formatted = f"**총 페이지: {page_count:.1f}**\n\n" + formatted_text
    
    return formatted

def generate_random_concept(screenplay_type: str, genre: str) -> str:
    """랜덤 컨셉 생성"""
    concepts = {
        '액션': [
            "은퇴한 특수요원이 납치된 딸을 구하기 위해 다시 현장으로 복귀한다",
            "평범한 택시기사가 우연히 국제 테러 조직의 음모에 휘말린다",
        ],
        '스릴러': [
            "기억을 잃은 남자가 자신이 연쇄살인범이라는 증거를 발견한다",
            "실종된 아이를 찾는 과정에서 마을의 끔찍한 비밀이 드러난다",
        ],
        '드라마': [
            "말기 암 환자가 마지막 소원으로 가족과의 화해를 시도한다",
            "재개발로 사라질 동네를 지키려는 주민들의 마지막 싸움",
        ],
    }
    
    genre_concepts = concepts.get(genre, concepts['드라마'])
    return random.choice(genre_concepts)

# Gradio 인터페이스
def create_interface():
    css = """
    .main-header {
        text-align: center;
        margin-bottom: 2rem;
        padding: 2.5rem;
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        border-radius: 15px;
        color: white;
        box-shadow: 0 10px 30px rgba(0,0,0,0.3);
    }
    
    .header-title {
        font-size: 3rem;
        margin-bottom: 1rem;
        text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
    }
    
    .expert-panel {
        background: #f0f4f8;
        padding: 1rem;
        border-radius: 10px;
        margin: 1rem 0;
    }
    
    .expert-badge {
        display: inline-block;
        padding: 0.3rem 0.8rem;
        background: white;
        border-radius: 20px;
        margin: 0.2rem;
        font-size: 0.9rem;
    }
    
    .progress-bar {
        background: #e0e0e0;
        border-radius: 10px;
        height: 30px;
        position: relative;
        margin: 1rem 0;
    }
    
    .progress-fill {
        background: linear-gradient(90deg, #667eea, #764ba2);
        height: 100%;
        border-radius: 10px;
        transition: width 0.3s ease;
    }
    """
    
    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="AI 시나리오 작가 - 전문가 협업 시스템") as interface:
        gr.HTML("""
        <div class="main-header">
            <h1 class="header-title">🎬 AI 시나리오 작가</h1>
            <p style="font-size: 1.2rem; opacity: 0.95;">
                8명의 전문가가 협업하여 완벽한 시나리오를 작성합니다<br>
                프로듀서, 감독, 작가, 비평가가 함께 만드는 전문 시나리오
            </p>
        </div>
        """)
        
        # 전문가 소개
        gr.HTML("""
        <div class="expert-panel">
            <h3>👥 참여 전문가</h3>
            <span class="expert-badge">🎬 프로듀서</span>
            <span class="expert-badge">📖 스토리작가</span>
            <span class="expert-badge">👥 캐릭터디자이너</span>
            <span class="expert-badge">🎭 감독</span>
            <span class="expert-badge">🔍 비평가</span>
            <span class="expert-badge">✂️ 편집자</span>
            <span class="expert-badge">💬 대화전문가</span>
            <span class="expert-badge">🎯 장르전문가</span>
        </div>
        """)
        
        current_session_id = gr.State(None)
        current_planning_data = gr.State({})
        current_feedbacks = gr.State([])
        
        with gr.Tabs():
            with gr.Tab("📝 새 시나리오"):
                with gr.Row():
                    with gr.Column(scale=2):
                        query_input = gr.Textbox(
                            label="💡 시나리오 아이디어",
                            placeholder="""구체적인 스토리를 입력하세요. 예시:
"2045년 서울, AI가 인간 감정을 완벽히 모방하는 시대. 
AI 윤리학자가 죽은 아내를 복제한 AI와 살다가 
진짜 아내가 살아있다는 증거를 발견하고 진실을 찾아 나선다."
""",
                            lines=6
                        )
                    
                    with gr.Column(scale=1):
                        screenplay_type = gr.Radio(
                            choices=list(SCREENPLAY_LENGTHS.keys()),
                            value="영화",
                            label="📽️ 시나리오 유형"
                        )
                        
                        genre_select = gr.Dropdown(
                            choices=list(GENRE_TEMPLATES.keys()),
                            value="드라마",
                            label="🎭 장르"
                        )
                
                with gr.Row():
                    random_btn = gr.Button("🎲 랜덤 아이디어", scale=1)
                    clear_btn = gr.Button("🗑️ 초기화", scale=1)
                    planning_btn = gr.Button("📋 전문가 기획 회의", variant="primary", scale=2)
                
                # 진행 상태
                progress_bar = gr.HTML(
                    value='<div class="progress-bar"><div class="progress-fill" style="width: 0%"></div></div>'
                )
                status_text = gr.Textbox(
                    label="📊 진행 상태",
                    interactive=False,
                    value="아이디어를 입력하고 전문가 기획 회의를 시작하세요"
                )
                
                # 전문가 피드백
                with gr.Group():
                    gr.Markdown("### 🎯 전문가 피드백")
                    expert_feedback_display = gr.Markdown(
                        value="*전문가들의 의견이 여기에 표시됩니다...*"
                    )
                
                # 기획안
                with gr.Group():
                    gr.Markdown("### 📋 시나리오 기획안")
                    planning_display = gr.Markdown(
                        value="*기획안이 여기에 표시됩니다...*"
                    )
                    
                    with gr.Row():
                        save_planning_btn = gr.Button("💾 기획안 저장", scale=1)
                        generate_screenplay_btn = gr.Button("🎬 전문가 시나리오 작성", variant="primary", scale=2)
                
                # 시나리오 출력
                with gr.Group():
                    gr.Markdown("### 📄 완성된 시나리오")
                    screenplay_output = gr.Markdown(
                        value="*시나리오가 여기에 표시됩니다...*"
                    )
                    
                    download_btn = gr.Button("💾 다운로드 (TXT)")
        
        # 이벤트 핸들러
        def handle_planning(query, s_type, genre):
            if not query:
                yield "", "❌ 아이디어를 입력해주세요", "", "", {}
                return
            
            system = ScreenplayGenerationSystem()
            
            for status, progress, planning_data, feedbacks in system.generate_planning(query, s_type, genre):
                progress_html = f'<div class="progress-bar"><div class="progress-fill" style="width: {progress}%"></div></div>'
                planning_display = format_planning_display(planning_data)
                feedback_display = format_expert_feedbacks(feedbacks)
                
                yield progress_html, status, feedback_display, planning_display, planning_data
        
        def handle_screenplay_generation(session_id, planning_data):
            if not planning_data:
                yield "", "❌ 먼저 기획안을 생성해주세요", "", ""
                return
            
            system = ScreenplayGenerationSystem()
            
            for status, progress, screenplay, feedbacks in system.generate_screenplay(session_id, planning_data):
                progress_html = f'<div class="progress-bar"><div class="progress-fill" style="width: {progress}%"></div></div>'
                screenplay_display = format_screenplay_display(screenplay)
                feedback_display = format_expert_feedbacks(feedbacks)
                
                yield progress_html, status, feedback_display, screenplay_display
        
        # 이벤트 연결
        planning_btn.click(
            fn=handle_planning,
            inputs=[query_input, screenplay_type, genre_select],
            outputs=[progress_bar, status_text, expert_feedback_display, planning_display, current_planning_data]
        )
        
        generate_screenplay_btn.click(
            fn=handle_screenplay_generation,
            inputs=[current_session_id, current_planning_data],
            outputs=[progress_bar, status_text, expert_feedback_display, screenplay_output]
        )
        
        random_btn.click(
            fn=generate_random_concept,
            inputs=[screenplay_type, genre_select],
            outputs=[query_input]
        )
    
    return interface

# 메인 실행
if __name__ == "__main__":
    logger.info("=" * 60)
    logger.info("AI 시나리오 작가 - 전문가 협업 시스템")
    logger.info("8명의 전문가가 협업하여 시나리오를 작성합니다")
    logger.info("=" * 60)
    
    if not FIREWORKS_API_KEY or FIREWORKS_API_KEY == "dummy_token_for_testing":
        logger.warning("⚠️ FIREWORKS_API_KEY를 설정해주세요!")
        logger.warning("export FIREWORKS_API_KEY='your-api-key'")
    
    # 전문가 역할 소개
    logger.info("\n참여 전문가:")
    for role, info in EXPERT_ROLES.items():
        logger.info(f"  {info['emoji']} {role}: {info['description']}")
    
    ScreenplayDatabase.init_db()
    
    interface = create_interface()
    interface.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False
    )