app.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()

# 장르 템플릿
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 = [
    ("컨셉 개발", "🎬 프로듀서: 핵심 컨셉 및 시장성 분석"),
    ("스토리 구성", "📖 스토리 개발: 시놉시스 및 3막 구조"),
    ("캐릭터 설계", "👥 캐릭터 디자이너: 인물 프로필 및 관계도"),
    ("세계관 구축", "🌍 세계관: 배경, 분위기, 비주얼 설정"),
    ("씬 구성", "🎯 씬 플래너: 상세 씬 브레이크다운"),
]

WRITING_STAGES = [
    ("1막 초고", "✍️ 1막 - 설정 (25%) - 초고 작성"),
    ("1막 수정", "📝 1막 - 확장 및 다듬기"),
    ("1막 검토", "🔧 1막 - 전문가 검토"),
    ("1막 완성", "✅ 1막 - 최종 완성본"),
    
    ("2막A 초고", "✍️ 2막A - 상승 (25%) - 초고 작성"),
    ("2막A 수정", "📝 2막A - 확장 및 다듬기"),
    ("2막A 검토", "🔧 2막A - 전문가 검토"),
    ("2막A 완성", "✅ 2막A - 최종 완성본"),
    
    ("2막B 초고", "✍️ 2막B - 복잡화 (25%) - 초고 작성"),
    ("2막B 수정", "📝 2막B - 확장 및 다듬기"),
    ("2막B 검토", "🔧 2막B - 전문가 검토"),
    ("2막B 완성", "✅ 2막B - 최종 완성본"),
    
    ("3막 초고", "✍️ 3막 - 해결 (25%) - 초고 작성"),
    ("3막 수정", "📝 3막 - 확장 및 다듬기"),
    ("3막 검토", "🔧 3막 - 전문가 검토"),
    ("3막 완성", "✅ 3막 - 최종 완성본"),
    
    ("대사 강화", "💬 대사 전문가: 대사 개선 및 서브텍스트"),
    ("최종 검토", "🎭 최종 리뷰: 전체 시나리오 분석 및 완성"),
]

# 데이터 클래스
@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)

@dataclass
class ScreenplayBible:
    """시나리오 바이블"""
    title: str = ""
    logline: str = ""
    genre: str = ""
    subgenre: str = ""
    tone: str = ""
    themes: List[str] = field(default_factory=list)
    protagonist: Dict[str, Any] = field(default_factory=dict)
    antagonist: Dict[str, Any] = field(default_factory=dict)
    supporting_cast: Dict[str, Dict[str, Any]] = field(default_factory=dict)
    three_act_structure: Dict[str, str] = field(default_factory=dict)
    time_period: str = ""
    primary_locations: List[Dict[str, str]] = field(default_factory=list)
    visual_style: str = ""

# 데이터베이스 클래스
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,
                    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 screenplay_stages (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT NOT NULL,
                    stage_type TEXT NOT NULL,
                    stage_number INTEGER NOT NULL,
                    stage_name TEXT NOT NULL,
                    content TEXT,
                    page_count REAL DEFAULT 0,
                    status TEXT DEFAULT 'pending',
                    created_at TEXT DEFAULT (datetime('now')),
                    FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id),
                    UNIQUE(session_id, stage_type, stage_number)
                )
            ''')
            
            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_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 get_planning_data(session_id: str) -> Optional[Dict]:
        with ScreenplayDatabase.get_db() as conn:
            row = conn.cursor().execute(
                'SELECT planning_data FROM screenplay_sessions WHERE session_id = ?',
                (session_id,)
            ).fetchone()
            if row and row['planning_data']:
                return json.loads(row['planning_data'])
        return None

    @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 = {}  # 누적 내용 저장
        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_p도 조정
                "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 generate_planning(self, query: str, screenplay_type: str, genre: str, 
                         progress_callback=None) -> Generator[Tuple[str, float, Dict], None, None]:
        """기획안 생성 - 원본 요청 유지"""
        try:
            self.original_query = query  # 원본 저장
            self.current_session_id = ScreenplayDatabase.create_session(query, screenplay_type, genre)
            
            planning_content = {}
            self.accumulated_content = {}  # 누적 내용 초기화
            total_stages = len(PLANNING_STAGES)
            
            # 원본 요청을 명확히 정리
            core_request = f"""
【핵심 요청사항】
{query}

【필수 준수사항】
- 위 요청사항을 절대적으로 준수할 것
- 요청된 설정, 인물, 스토리를 그대로 사용할 것
- 임의로 내용을 변경하거나 다른 이야기로 바꾸지 말 것
- 장르: {genre}
- 형식: {screenplay_type}
"""
            
            for idx, (stage_name, stage_desc) in enumerate(PLANNING_STAGES):
                progress = (idx / total_stages) * 100
                
                yield f"🔄 {stage_desc} 진행 중...", progress, planning_content
                
                # 이전 단계 내용 요약
                previous_content = ""
                if self.accumulated_content:
                    previous_content = "\n【이전 단계 내용】\n"
                    for key, value in self.accumulated_content.items():
                        previous_content += f"\n[{key}]\n{value[:500]}...\n"
                
                # 각 단계별 프롬프트 생성
                if stage_name == "컨셉 개발":
                    prompt = f"""{core_request}

당신은 할리우드 프로듀서입니다. 위 요청사항에 정확히 맞는 {screenplay_type} 시나리오 컨셉을 개발하세요.

【작성 항목】
1. 제목: (요청 내용을 반영한 제목)
2. 로그라인: (위 요청의 핵심 스토리를 한 문장으로)
3. 핵심 테마: (요청에서 다루고자 하는 주제)
4. 타겟 관객: (이 스토리가 어필할 관객층)
5. 유사 작품 3개와 차별점
6. 상업적 매력 포인트

⚠️ 중요: 반드시 "{query}"의 내용을 그대로 사용하세요."""

                elif stage_name == "스토리 구성":
                    prompt = f"""{core_request}
{previous_content}

이전 컨셉을 바탕으로 스토리 구조를 만드세요.
⚠️ 반드시 원본 요청 "{query}"의 스토리라인을 유지하세요.

【작성 항목】
1. 시놉시스 (500자): 원본 요청의 스토리를 충실히 반영
2. 확장 시놉시스 (1000자): 세부 사건과 전개 추가
3. 3막 구조:
   - 1막: 요청된 설정과 인물 소개
   - 2막A: 요청된 갈등의 시작
   - 2막B: 요청된 위기의 심화
   - 3막: 요청된 방식의 해결

절대 다른 이야기로 바뀌지 않도록 주의하세요."""

                elif stage_name == "캐릭터 설계":
                    prompt = f"""{core_request}
{previous_content}

원본 요청에 나온 캐릭터들을 설계하세요.
⚠️ 요청에 명시된 인물 설정을 절대 변경하지 마세요.

【작성 항목】
주인공: (요청에 나온 주인공 그대로)
- 이름과 나이
- 외모와 성격 (요청 내용 반영)
- 목표 (요청된 목표)
- 필요 (내적 성장)
- 성장 아크

적대자: (요청에 나온 대립 인물/세력)
- 이름과 역할
- 동기와 목표
- 주인공과의 관계

조연들: (요청에 언급된 인물들)
- 각자의 역할과 특징

새로운 인물을 임의로 추가하지 마세요."""

                elif stage_name == "세계관 구축":
                    prompt = f"""{core_request}
{previous_content}

원본 요청의 배경과 세계관을 구축하세요.
⚠️ 요청에 명시된 시대, 장소, 분위기를 그대로 사용하세요.

【작성 항목】
1. 시대 배경: (요청된 시대)
2. 주요 장소: (요청에 나온 장소들)
3. 전체적 분위기: (요청된 톤)
4. 시각적 스타일
5. 음향/음악 스타일

임의로 배경을 바꾸지 마세요."""

                elif stage_name == "씬 구성":
                    prompt = f"""{core_request}
{previous_content}

원본 요청의 스토리를 씬으로 구성하세요.
⚠️ 반드시 요청된 사건들이 모두 포함되어야 합니다.

{SCREENPLAY_LENGTHS[screenplay_type]['pages']}페이지 분량으로:
- 1막: 요청된 설정과 시작 (약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지)
- 2막A: 요청된 갈등 전개 (약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지)
- 2막B: 요청된 위기 심화 (약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지)
- 3막: 요청된 해결 (약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지)

각 씬마다:
- 장소와 시간
- 등장인물
- 핵심 사건 (요청 내용 반영)
- 예상 페이지

스토리가 다른 방향으로 가지 않도록 주의하세요."""

                # LLM 호출
                messages = [
                    {"role": "system", "content": f"""당신은 전문 시나리오 작가입니다. 
사용자의 원본 요청을 절대적으로 준수하여 작성하세요.
절대 임의로 스토리를 변경하거나 다른 이야기를 만들지 마세요.
원본 요청: {query}"""},
                    {"role": "user", "content": prompt}
                ]
                
                content = ""
                for chunk in self.call_llm_streaming(messages):
                    content += chunk
                    planning_content[stage_name] = content
                    yield f"✅ {stage_desc} 완료", progress, planning_content
                
                # 누적 내용 저장
                self.accumulated_content[stage_name] = content
                time.sleep(0.5)  # API 제한 고려
            
            # 최종 기획안 저장
            ScreenplayDatabase.save_planning_data(self.current_session_id, planning_content)
            yield "✅ 기획안 완성!", 100, planning_content
            
        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], None, None]:
        """시나리오 작성 - 기획안 충실히 반영"""
        try:
            total_stages = len(WRITING_STAGES)
            screenplay_content = ""
            act_contents = {"1막": "", "2막A": "", "2막B": "", "3막": ""}
            
            # 기획안에서 핵심 정보 추출
            concept = planning_data.get("컨셉 개발", "")
            story = planning_data.get("스토리 구성", "")
            characters = planning_data.get("캐릭터 설계", "")
            world = planning_data.get("세계관 구축", "")
            scenes = planning_data.get("씬 구성", "")
            
            for idx, (stage_name, stage_desc) in enumerate(WRITING_STAGES):
                progress = (idx / total_stages) * 100
                
                yield f"🔄 {stage_desc} 진행 중...", progress, screenplay_content
                
                # 막 결정
                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 "초고" in stage_name:
                    prompt = self._create_writing_prompt(
                        current_act, planning_data, act_contents, "초고",
                        self.original_query
                    )
                elif "수정" in stage_name:
                    prompt = self._create_writing_prompt(
                        current_act, planning_data, act_contents, "수정",
                        self.original_query
                    )
                elif "검토" in stage_name:
                    prompt = self._create_review_prompt(
                        current_act, act_contents[current_act],
                        self.original_query
                    )
                elif "완성" in stage_name:
                    prompt = self._create_writing_prompt(
                        current_act, planning_data, act_contents, "완성",
                        self.original_query
                    )
                elif "대사 강화" in stage_name:
                    prompt = self._create_dialogue_prompt(screenplay_content)
                elif "최종 검토" in stage_name:
                    prompt = self._create_final_review_prompt(screenplay_content)
                else:
                    continue
                
                # LLM 호출
                messages = [
                    {"role": "system", "content": f"""당신은 전문 시나리오 작가입니다. 
표준 시나리오 포맷으로 작성하세요.
기획안과 원본 요청을 충실히 반영하세요.
원본 요청: {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
                
                time.sleep(0.5)
            
            # 최종 저장
            title = planning_data.get("컨셉 개발", "").split("제목")[1].split("\n")[0].strip() if "컨셉 개발" in planning_data else "무제"
            logline = planning_data.get("컨셉 개발", "").split("로그라인")[1].split("\n")[0].strip() if "컨셉 개발" in planning_data else ""
            
            ScreenplayDatabase.save_screenplay_content(session_id, screenplay_content, title, logline)
            yield "✅ 시나리오 완성!", 100, screenplay_content
            
        except Exception as e:
            yield f"❌ 오류 발생: {str(e)}", 0, ""

    def _create_writing_prompt(self, act: str, planning_data: Dict, 
                              previous_acts: Dict, phase: str, original_query: str) -> str:
        """작성 프롬프트 생성 - 원본 충실"""
        
        story_structure = planning_data.get("스토리 구성", "")
        characters = planning_data.get("캐릭터 설계", "")
        scenes = planning_data.get("씬 구성", "")
        world = planning_data.get("세계관 구축", "")
        
        if phase == "초고":
            min_lines = 800
            instruction = "초고를 작성하세요"
        elif phase == "수정":
            min_lines = 1000
            instruction = "내용을 확장하고 다듬으세요"
        else:  # 완성
            min_lines = 1200
            instruction = "최종 완성본을 작성하세요"
        
        prompt = f"""【원본 요청】
{original_query}

【{act} {instruction}】

목표 분량: 최소 {min_lines}줄

【기획안 내용】
스토리 구조:
{story_structure[:1000]}

캐릭터:
{characters[:1000]}

세계관:
{world[:500]}

씬 구성:
{scenes[:1000]}

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

【필수 요구사항】
1. 원본 요청과 기획안을 충실히 반영
2. 표준 시나리오 포맷 사용
   - INT./EXT. 장소 - 시간
   - 캐릭터명은 대문자
   - 대사는 캐릭터 아래 들여쓰기
3. 시각적 묘사는 현재형으로
4. 각 씬마다 충분한 분량 (5-7페이지)
5. 절대 다른 이야기로 변경하지 말 것

⚠️ 중요: 반드시 원본 요청 "{original_query}"의 스토리를 그대로 구현하세요.
임의로 스토리를 바꾸지 마세요.

{min_lines}줄 이상 작성하세요."""
        
        return prompt

    def _create_review_prompt(self, act: str, content: str, original_query: str) -> str:
        """검토 프롬프트"""
        return f"""【원본 요청】
{original_query}

【{act} 검토】

작성된 내용:
{content[:2000]}...

【검토 항목】
1. 원본 요청과의 일치성 (가장 중요)
2. 스토리 논리성
3. 캐릭터 일관성
4. 대사 자연스러움
5. 페이싱과 리듬

【필수 확인사항】
- 원본 요청의 스토리가 제대로 구현되었는가?
- 임의로 변경된 부분은 없는가?
- 기획안과 일치하는가?

구체적인 개선 제안을 하세요."""

    def _create_dialogue_prompt(self, screenplay: str) -> str:
        """대사 강화 프롬프트"""
        return f"""전체 시나리오의 대사를 검토하고 개선하세요.

【개선 포인트】
1. 캐릭터별 고유한 말투 확립
2. 서브텍스트 추가
3. 불필요한 설명 대사 제거
4. 감정적 진정성 강화
5. 장르에 맞는 톤 유지

【원본 유지】
- 스토리와 설정은 절대 변경하지 마세요
- 대사만 개선하세요

주요 개선이 필요한 대사들을 찾아 수정안을 제시하세요."""

    def _create_final_review_prompt(self, screenplay: str) -> str:
        """최종 검토 프롬프트"""
        return f"""완성된 시나리오를 최종 검토하세요.

【평가 항목】
1. 원본 요청 충실도 (최우선)
2. 전체 구조와 페이싱
3. 캐릭터 아크 완성도
4. 테마 전달력
5. 상업성과 완성도

【확인사항】
- 처음 요청한 스토리가 제대로 구현되었는가?
- 중간에 다른 이야기로 바뀌지 않았는가?
- 기획안과 일치하는가?

총평과 함께 최종 개선 사항을 제시하세요."""

# 유틸리티 함수
def format_planning_display(planning_data: Dict) -> str:
    """기획안 표시 포맷"""
    if not planning_data:
        return "기획안이 아직 생성되지 않았습니다."
    
    formatted = "# 📋 시나리오 기획안\n\n"
    
    for stage_name, content in planning_data.items():
        formatted += f"## {stage_name}\n\n"
        formatted += content + "\n\n"
        formatted += "---\n\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 = {
        '액션': [
            "은퇴한 특수요원이 납치된 딸을 구하기 위해 다시 현장으로 복귀한다",
            "평범한 택시기사가 우연히 국제 테러 조직의 음모에 휘말린다",
            "부패 경찰과 맞서 싸우는 정의로운 형사의 고독한 싸움"
        ],
        '스릴러': [
            "기억을 잃은 남자가 자신이 연쇄살인범이라는 증거를 발견한다",
            "실종된 아이를 찾는 과정에서 마을의 끔찍한 비밀이 드러난다",
            "완벽한 알리바이를 가진 용의자를 쫓는 검사의 집요한 추적"
        ],
        '드라마': [
            "말기 암 환자가 마지막 소원으로 가족과의 화해를 시도한다",
            "재개발로 사라질 동네를 지키려는 주민들의 마지막 싸움",
            "입양아가 생모를 찾아가는 가슴 아픈 여정"
        ],
        '코미디': [
            "결혼식장을 운영하는 커플이 자신들의 이혼을 숨기며 일한다",
            "복권에 당첨된 가족이 서로 돈을 차지하려 음모를 꾸민다",
            "실수로 대통령 경호원이 된 평범한 회사원의 좌충우돌 이야기"
        ],
        '공포': [
            "폐병원에서 밤새 생존해야 하는 의대생들의 공포 체험",
            "거울 속에서 나타나는 또 다른 자신과 마주한 여자",
            "저주받은 골동품을 판매한 후 벌어지는 기이한 사건들"
        ],
        'SF': [
            "시간 여행으로 과거를 바꾸려다 더 큰 재앙을 만든 과학자",
            "인공지능이 인간의 감정을 학습하며 벌어지는 예상치 못한 사건",
            "외계 신호를 해독한 언어학자가 인류의 운명을 결정해야 한다"
        ],
        '로맨스': [
            "첫사랑과 20년 만에 재회한 두 사람의 두 번째 기회",
            "계약결혼으로 시작했다가 진짜 사랑에 빠진 커플",
            "서로 다른 시대를 살아가는 두 사람의 편지를 통한 사랑"
        ],
        '판타지': [
            "평범한 고등학생이 판타지 세계의 선택받은 용사가 된다",
            "도시에 나타난 용과 소통할 수 있는 유일한 사람",
            "마법이 사라진 세계에서 마지막 마법사가 되어버린 청년"
        ]
    }
    
    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);
    }
    
    .planning-section {
        background: #f8f9fa;
        padding: 1.5rem;
        border-radius: 10px;
        margin: 1rem 0;
        max-height: 600px;
        overflow-y: auto;
    }
    
    .screenplay-output {
        font-family: 'Nanum Gothic Coding', 'Courier New', monospace;
        white-space: pre-wrap;
        background: white;
        padding: 2rem;
        border: 2px solid #e0e0e0;
        border-radius: 10px;
        max-height: 800px;
        overflow-y: auto;
    }
    
    .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;
    }
    
    .warning-box {
        background: #fff3cd;
        border: 1px solid #ffc107;
        border-radius: 5px;
        padding: 1rem;
        margin: 1rem 0;
    }
    """
    
    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;">
                전문가 수준의 한국어 시나리오를 AI가 작성합니다<br>
                입력한 아이디어를 충실히 반영하여 완벽한 시나리오를 생성합니다
            </p>
        </div>
        """)
        
        current_session_id = gr.State(None)
        current_planning_data = gr.State({})
        
        with gr.Tabs():
            with gr.Tab("📝 새 시나리오"):
                # 주의사항
                gr.HTML("""
                <div class="warning-box">
                    <strong>💡 팁:</strong> 구체적이고 명확한 설정을 입력할수록 원하는 스토리가 정확히 구현됩니다.<br>
                    주인공, 배경, 핵심 갈등, 결말 방향을 구체적으로 제시해주세요.
                </div>
                """)
                
                with gr.Row():
                    with gr.Column(scale=2):
                        query_input = gr.Textbox(
                            label="💡 시나리오 아이디어 (구체적으로 작성하세요)",
                            placeholder="""원하는 시나리오를 구체적으로 설명하세요. 예시:

"2045년 서울, AI가 인간의 감정을 완벽히 모방하는 시대. 
주인공 김민준(35세, AI 윤리학자)은 자신의 죽은 아내를 복제한 AI와 살고 있다.
어느 날 진짜 아내가 살아있다는 증거를 발견하고, 
AI 아내와 함께 진실을 찾아 나선다.
결말에서 진짜와 가짜의 경계가 무너지며 
사랑의 본질에 대해 질문을 던진다."

구체적인 설정일수록 원하는 결과를 얻을 수 있습니다.""",
                            lines=8
                        )
                    
                    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("### 📋 시나리오 기획안")
                    planning_display = gr.Markdown(
                        value="*기획안이 여기에 표시됩니다...*",
                        elem_classes=["planning-section"]
                    )
                    
                    with gr.Row():
                        edit_planning_btn = gr.Button("✏️ 기획안 수정", scale=1)
                        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="*시나리오가 여기에 표시됩니다...*",
                        elem_classes=["screenplay-output"]
                    )
                    
                    with gr.Row():
                        download_btn = gr.Button("💾 다운로드 (TXT)", scale=1)
                        pdf_btn = gr.Button("📑 PDF 변환", scale=1)
                
                # 예시
                gr.Examples(
                    examples=[
                        ["2045년 서울, AI가 인간 감정을 완벽히 모방하는 시대. AI 윤리학자가 죽은 아내를 복제한 AI와 살다가 진짜 아내가 살아있다는 증거를 발견하고 진실을 찾아 나선다."],
                        ["조선시대 한양, 신분을 숨긴 왕세자가 저잣거리에서 의녀를 만나 사랑에 빠진다. 역모 사건에 휘말려 함께 진실을 밝혀야 한다."],
                        ["작은 해안 마을, 10년 전 실종된 딸이 갑자기 돌아온다. 하지만 그녀는 10년 전 모습 그대로다. 마을의 숨겨진 비밀이 드러나기 시작한다."],
                        ["대기업 법무팀 변호사가 회사의 불법을 고발하려다 모함을 받는다. 숨어서 증거를 모으며 거대한 음모와 맞선다."]
                    ],
                    inputs=query_input,
                    label="💡 예시 아이디어 (구체적인 설정 참고)"
                )
            
            with gr.Tab("📚 내 작품"):
                gr.Markdown("""
                ### 📁 저장된 시나리오
                
                작업 중이거나 완성된 시나리오를 관리합니다.
                """)
                
                saved_list = gr.Dataframe(
                    headers=["제목", "장르", "유형", "페이지", "상태", "수정일"],
                    value=[],
                    label="저장된 작품 목록"
                )
                
                with gr.Row():
                    refresh_btn = gr.Button("🔄 새로고침")
                    load_btn = gr.Button("📂 불러오기")
                    delete_btn = gr.Button("🗑️ 삭제")
        
        # 이벤트 핸들러
        def handle_planning(query, s_type, genre):
            if not query:
                yield "", "❌ 아이디어를 입력해주세요", "", {}
                return
            
            system = ScreenplayGenerationSystem()
            
            for status, progress, planning_data 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)
                
                yield progress_html, status, planning_display, planning_data
        
        def handle_screenplay_generation(session_id, planning_data):
            if not planning_data:
                yield "", "❌ 먼저 기획안을 생성해주세요", ""
                return
            
            system = ScreenplayGenerationSystem()
            
            for status, progress, screenplay 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)
                
                yield progress_html, status, screenplay_display
        
        def handle_random(s_type, genre):
            return generate_random_concept(s_type, genre)
        
        def handle_clear():
            empty_progress = '<div class="progress-bar"><div class="progress-fill" style="width: 0%"></div></div>'
            return "", empty_progress, "준비됨", "", "", None, {}
        
        def handle_download(screenplay_text):
            if not screenplay_text or screenplay_text == "*시나리오가 여기에 표시됩니다...*":
                return None
            
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"시나리오_{timestamp}.txt"
            
            with open(filename, 'w', encoding='utf-8') as f:
                # 마크다운 제거
                clean_text = re.sub(r'\*\*([^*]+)\*\*', r'\1', screenplay_text)
                clean_text = re.sub(r'^#+ ', '', clean_text, flags=re.MULTILINE)
                f.write(clean_text)
            
            return filename
        
        # 이벤트 연결
        planning_btn.click(
            fn=handle_planning,
            inputs=[query_input, screenplay_type, genre_select],
            outputs=[progress_bar, status_text, 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, screenplay_output]
        )
        
        random_btn.click(
            fn=handle_random,
            inputs=[screenplay_type, genre_select],
            outputs=[query_input]
        )
        
        clear_btn.click(
            fn=handle_clear,
            outputs=[query_input, progress_bar, status_text, planning_display, 
                    screenplay_output, current_session_id, current_planning_data]
        )
        
        download_btn.click(
            fn=handle_download,
            inputs=[screenplay_output],
            outputs=[gr.File(label="다운로드")]
        )
    
    return interface

# 메인 실행
if __name__ == "__main__":
    logger.info("=" * 60)
    logger.info("AI 시나리오 작가 시작...")
    logger.info("원본 요청 충실도 강화 버전")
    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'")
    
    ScreenplayDatabase.init_db()
    
    interface = create_interface()
    interface.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False
    )