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()
        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.8,
                "top_p": 1,
                "top_k": 40,
                "presence_penalty": 0.2,
                "frequency_penalty": 0.2,
                "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.current_session_id = ScreenplayDatabase.create_session(query, screenplay_type, genre)
            
            planning_content = {}
            total_stages = len(PLANNING_STAGES)
            
            for idx, (stage_name, stage_desc) in enumerate(PLANNING_STAGES):
                progress = (idx / total_stages) * 100
                
                yield f"🔄 {stage_desc} 진행 중...", progress, planning_content
                
                # 각 단계별 프롬프트 생성
                if stage_name == "컨셉 개발":
                    prompt = f"""당신은 할리우드 프로듀서입니다. 다음 요청으로 {screenplay_type} 시나리오 컨셉을 개발하세요.

요청: {query}
장르: {genre}

다음을 포함하여 작성하세요:
1. 제목
2. 로그라인 (한 문장으로 핵심 갈등과 주인공 설명)
3. 핵심 테마
4. 타겟 관객
5. 유사 작품 3개와 차별점
6. 상업적 매력 포인트"""

                elif stage_name == "스토리 구성":
                    prompt = f"""이전 컨셉을 바탕으로 상세한 스토리 구조를 만드세요.

1. 시놉시스 (500자)
2. 확장 시놉시스 (1000자)
3. 3막 구조:
   - 1막 (설정): 주인공 소개, 일상, 사건 발생
   - 2막A (상승): 새로운 세계, 시련 시작
   - 2막B (복잡화): 갈등 심화, 위기 고조
   - 3막 (해결): 클라이맥스, 결말"""

                elif stage_name == "캐릭터 설계":
                    prompt = f"""주요 캐릭터들을 상세히 설계하세요.

주인공:
- 이름과 나이
- 외모와 성격
- 목표 (WANT)
- 필요 (NEED)
- 성장 아크

적대자:
- 이름과 역할
- 동기와 목표
- 주인공과의 관계

조연 3명:
- 각자의 역할과 특징"""

                elif stage_name == "세계관 구축":
                    prompt = f"""시나리오의 세계관과 분위기를 구축하세요.

1. 시대 배경
2. 주요 장소 5곳
3. 전체적 분위기와 톤
4. 시각적 스타일
5. 음향/음악 스타일"""

                elif stage_name == "씬 구성":
                    prompt = f"""전체 씬 구성을 계획하세요.

{SCREENPLAY_LENGTHS[screenplay_type]['pages']}페이지 분량으로:
- 1막: 약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지 (10-12개 씬)
- 2막A: 약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지 (12-15개 씬)
- 2막B: 약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지 (12-15개 씬)
- 3막: 약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지 (8-10개 씬)

각 씬마다:
- 장소와 시간
- 등장인물
- 핵심 사건
- 페이지 수"""

                # LLM 호출
                messages = [
                    {"role": "system", "content": "당신은 전문 시나리오 작가입니다. 상세하고 창의적인 내용을 작성하세요."},
                    {"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
                
                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막": ""}
            
            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, "초고")
                elif "수정" in stage_name:
                    prompt = self._create_writing_prompt(current_act, planning_data, act_contents, "수정")
                elif "검토" in stage_name:
                    prompt = self._create_review_prompt(current_act, act_contents[current_act])
                elif "완성" in stage_name:
                    prompt = self._create_writing_prompt(current_act, planning_data, act_contents, "완성")
                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": "당신은 전문 시나리오 작가입니다. 표준 시나리오 포맷으로 작성하세요."},
                    {"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) -> str:
        """작성 프롬프트 생성"""
        
        story_structure = planning_data.get("스토리 구성", "")
        characters = planning_data.get("캐릭터 설계", "")
        scenes = planning_data.get("씬 구성", "")
        
        if phase == "초고":
            min_lines = 800
            instruction = "초고를 작성하세요"
        elif phase == "수정":
            min_lines = 1000
            instruction = "내용을 확장하고 다듬으세요"
        else:  # 완성
            min_lines = 1200
            instruction = "최종 완성본을 작성하세요"
        
        prompt = f"""{act} {instruction}.

목표 분량: 최소 {min_lines}줄

스토리 구조:
{story_structure}

캐릭터:
{characters}

씬 구성:
{scenes}

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

요구사항:
1. 표준 시나리오 포맷 사용
2. INT./EXT. 장소 - 시간
3. 캐릭터명은 대문자
4. 대사는 자연스럽게
5. 액션은 현재형으로 시각적으로
6. 각 씬마다 충분한 분량 (5-7페이지)

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

    def _create_review_prompt(self, act: str, content: str) -> str:
        """검토 프롬프트"""
        return f"""{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;
    }
    """
    
    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("📝 새 시나리오"):
                with gr.Row():
                    with gr.Column(scale=2):
                        query_input = gr.Textbox(
                            label="💡 시나리오 아이디어",
                            placeholder="""원하는 시나리오의 핵심 아이디어를 입력하세요. 예시:
- 기억을 잃은 형사가 자신이 쫓던 연쇄살인범임을 알게 된다
- 시간을 되돌릴 수 있는 능력을 얻은 의사가 환자를 구하려 한다
- 가상현실 게임에 갇힌 프로게이머가 현실로 돌아가려 한다
- 조선시대로 타임슬립한 현대 검사가 부정부패와 싸운다""",
                            lines=5
                        )
                    
                    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=[
                        ["기억을 잃은 형사가 자신이 쫓던 연쇄살인범임을 알게 된다"],
                        ["시간을 되돌릴 수 있는 능력을 얻은 의사가 환자를 구하려 한다"],
                        ["가상현실 게임에 갇힌 프로게이머가 현실로 돌아가려 한다"],
                        ["조선시대로 타임슬립한 현대 검사가 부정부패와 싸운다"]
                    ],
                    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("Fireworks AI 모델 사용")
    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
    )