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
import logging
import re
import tempfile
from pathlib import Path
import sqlite3
import hashlib
import threading
from contextlib import contextmanager

# 로깅 설정
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Document export imports
try:
    from docx import Document
    from docx.shared import Inches, Pt, RGBColor
    from docx.enum.text import WD_ALIGN_PARAGRAPH
    from docx.enum.style import WD_STYLE_TYPE
    DOCX_AVAILABLE = True
except ImportError:
    DOCX_AVAILABLE = False
    logger.warning("python-docx not installed. DOCX export will be disabled.")

# 환경 변수에서 토큰 가져오기
FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN", "YOUR_FRIENDLI_TOKEN")
API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
MODEL_ID = "dep89a2fld32mcm"
BRAVE_API_KEY = os.getenv("BRAVE_API_KEY", "YOUR_BRAVE_API_KEY")
TEST_MODE = os.getenv("TEST_MODE", "false").lower() == "true"

# 전역 변수
conversation_history = []
selected_language = "English"  # 기본 언어
novel_context = {}  # 소설 컨텍스트 저장

# DB 경로
DB_PATH = "novel_sessions.db"
db_lock = threading.Lock()

class BraveSearchAPI:
    """Brave Search API integration"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.search.brave.com/res/v1/web/search"
    
    def search(self, query: str, language: str = "en") -> List[Dict]:
        """Perform web search using Brave Search API"""
        if self.api_key == "YOUR_BRAVE_API_KEY":
            # Return mock results in test mode
            return [
                {"title": f"Test result for: {query}", "snippet": "This is a test result snippet with relevant information."},
                {"title": f"Another result about {query}", "snippet": "Additional test information for the query."}
            ]
        
        try:
            headers = {
                "Accept": "application/json",
                "X-Subscription-Token": self.api_key
            }
            params = {
                "q": query,
                "lang": "ko" if language == "Korean" else "en",
                "count": 5
            }
            
            response = requests.get(self.base_url, headers=headers, params=params, timeout=10)
            if response.status_code == 200:
                data = response.json()
                results = []
                for result in data.get("web", {}).get("results", [])[:5]:
                    results.append({
                        "title": result.get("title", ""),
                        "snippet": result.get("description", ""),
                        "url": result.get("url", "")
                    })
                return results
            else:
                logger.error(f"Brave Search API error: {response.status_code}")
                return []
        except Exception as e:
            logger.error(f"Brave Search error: {str(e)}")
            return []

class NovelDatabase:
    """Novel session management database"""
    
    @staticmethod
    def init_db():
        """Initialize database tables"""
        with sqlite3.connect(DB_PATH) as conn:
            cursor = conn.cursor()
            
            # Sessions table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS sessions (
                    session_id TEXT PRIMARY KEY,
                    user_query TEXT NOT NULL,
                    language TEXT NOT NULL,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    status TEXT DEFAULT 'active',
                    current_stage INTEGER DEFAULT 0,
                    final_novel TEXT
                )
            ''')
            
            # Stages table - 각 스테이지의 전체 내용 저장
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS stages (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT NOT NULL,
                    stage_number INTEGER NOT NULL,
                    stage_name TEXT NOT NULL,
                    role TEXT NOT NULL,
                    content TEXT,
                    status TEXT DEFAULT 'pending',
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                )
            ''')
            
            # Completed novels table for gallery
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS completed_novels (
                    novel_id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT UNIQUE NOT NULL,
                    title TEXT NOT NULL,
                    author_query TEXT NOT NULL,
                    language TEXT NOT NULL,
                    genre TEXT,
                    summary TEXT,
                    thumbnail_text TEXT,
                    full_content TEXT NOT NULL,
                    word_count INTEGER,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    downloads INTEGER DEFAULT 0,
                    FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                )
            ''')
            
            # Create indices
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_session_id ON stages(session_id)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_stage_number ON stages(stage_number)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_created_at ON completed_novels(created_at)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_language ON completed_novels(language)')
            
            conn.commit()
    
    @staticmethod
    @contextmanager
    def get_db():
        """Database connection context manager"""
        with db_lock:
            conn = sqlite3.connect(DB_PATH)
            conn.row_factory = sqlite3.Row
            try:
                yield conn
            finally:
                conn.close()
    
    @staticmethod
    def create_session(user_query: str, language: str) -> str:
        """Create new session"""
        session_id = hashlib.md5(f"{user_query}{datetime.now()}".encode()).hexdigest()
        
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                INSERT INTO sessions (session_id, user_query, language)
                VALUES (?, ?, ?)
            ''', (session_id, user_query, language))
            conn.commit()
        
        return session_id
    
    @staticmethod
    def save_stage(session_id: str, stage_number: int, stage_name: str, 
                   role: str, content: str, status: str = 'complete'):
        """Save stage content - 전체 내용 저장"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            
            # Check if stage exists
            cursor.execute('''
                SELECT id FROM stages 
                WHERE session_id = ? AND stage_number = ?
            ''', (session_id, stage_number))
            
            existing = cursor.fetchone()
            
            if existing:
                # Update existing stage
                cursor.execute('''
                    UPDATE stages 
                    SET content = ?, status = ?, stage_name = ?
                    WHERE session_id = ? AND stage_number = ?
                ''', (content, status, stage_name, session_id, stage_number))
            else:
                # Insert new stage
                cursor.execute('''
                    INSERT INTO stages (session_id, stage_number, stage_name, role, content, status)
                    VALUES (?, ?, ?, ?, ?, ?)
                ''', (session_id, stage_number, stage_name, role, content, status))
            
            # Update session
            cursor.execute('''
                UPDATE sessions 
                SET updated_at = CURRENT_TIMESTAMP, current_stage = ?
                WHERE session_id = ?
            ''', (stage_number, session_id))
            
            conn.commit()
    
    @staticmethod
    def get_session(session_id: str) -> Optional[Dict]:
        """Get session info"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('SELECT * FROM sessions WHERE session_id = ?', (session_id,))
            return cursor.fetchone()
    
    @staticmethod
    def get_stages(session_id: str) -> List[Dict]:
        """Get all stages for a session"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                SELECT * FROM stages 
                WHERE session_id = ? 
                ORDER BY stage_number
            ''', (session_id,))
            return cursor.fetchall()
    
    @staticmethod
    def get_all_writer_content(session_id: str) -> str:
        """모든 작가의 수정본 내용을 가져와서 합치기 - 50페이지 전체"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                SELECT content, stage_name, stage_number FROM stages 
                WHERE session_id = ? 
                AND status = 'complete'
                AND (stage_name LIKE '%수정본%' OR stage_name LIKE '%Revision%')
                ORDER BY stage_number
            ''', (session_id,))
            
            contents = []
            for row in cursor.fetchall():
                if row['content']:
                    # 페이지 마크 완전 제거
                    clean_content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', row['content'])
                    clean_content = re.sub(r'(?:페이지|Page)\s*\d+:', '', clean_content)
                    contents.append(clean_content.strip())
            
            return '\n\n'.join(contents)
    
    @staticmethod
    def update_final_novel(session_id: str, final_novel: str):
        """Update final novel content"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                UPDATE sessions 
                SET final_novel = ?, status = 'complete', updated_at = CURRENT_TIMESTAMP
                WHERE session_id = ?
            ''', (final_novel, session_id))
            conn.commit()
    
    @staticmethod
    def save_completed_novel(session_id: str, final_novel: str):
        """Save completed novel to gallery"""
        try:
            with NovelDatabase.get_db() as conn:
                cursor = conn.cursor()
                
                # Get session info
                cursor.execute('SELECT user_query, language FROM sessions WHERE session_id = ?', (session_id,))
                session = cursor.fetchone()
                if not session:
                    return
                
                # Extract title from novel content
                title_match = re.search(r'#\s*\[?([^\]\n]+)\]?', final_novel)
                title = title_match.group(1).strip() if title_match else f"Novel from {session['user_query'][:30]}..."
                
                # Extract summary (first substantial paragraph after title)
                lines = final_novel.split('\n')
                summary = ""
                for line in lines[10:]:  # Skip headers
                    if len(line.strip()) > 50:
                        summary = line.strip()[:200] + "..."
                        break
                
                # Create thumbnail text (first 500 characters of actual content)
                content_start = final_novel.find("## 본문") if "## 본문" in final_novel else final_novel.find("## Main Text")
                if content_start > 0:
                    thumbnail_text = final_novel[content_start:content_start+500].strip()
                else:
                    thumbnail_text = final_novel[:500].strip()
                
                # Count words
                word_count = len(final_novel.split())
                
                # Check if already exists
                cursor.execute('SELECT novel_id FROM completed_novels WHERE session_id = ?', (session_id,))
                existing = cursor.fetchone()
                
                if existing:
                    # Update existing
                    cursor.execute('''
                        UPDATE completed_novels 
                        SET title = ?, summary = ?, thumbnail_text = ?, 
                            full_content = ?, word_count = ?
                        WHERE session_id = ?
                    ''', (title, summary, thumbnail_text, final_novel, word_count, session_id))
                else:
                    # Insert new
                    cursor.execute('''
                        INSERT INTO completed_novels 
                        (session_id, title, author_query, language, summary, 
                         thumbnail_text, full_content, word_count)
                        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                    ''', (session_id, title, session['user_query'], session['language'],
                          summary, thumbnail_text, final_novel, word_count))
                
                conn.commit()
                logger.info(f"Saved novel '{title}' to gallery")
        except Exception as e:
            logger.error(f"Error saving completed novel: {str(e)}")
    
    @staticmethod
    def get_gallery_novels(language: Optional[str] = None, limit: int = 50) -> List[Dict]:
        """Get novels for gallery display"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            
            if language:
                cursor.execute('''
                    SELECT novel_id, session_id, title, author_query, language,
                           genre, summary, thumbnail_text, word_count, 
                           created_at, downloads
                    FROM completed_novels 
                    WHERE language = ?
                    ORDER BY created_at DESC 
                    LIMIT ?
                ''', (language, limit))
            else:
                cursor.execute('''
                    SELECT novel_id, session_id, title, author_query, language,
                           genre, summary, thumbnail_text, word_count, 
                           created_at, downloads
                    FROM completed_novels 
                    ORDER BY created_at DESC 
                    LIMIT ?
                ''', (limit,))
            
            return cursor.fetchall()
    
    @staticmethod
    def get_novel_content(novel_id: int) -> Optional[Dict]:
        """Get full novel content"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                SELECT * FROM completed_novels 
                WHERE novel_id = ?
            ''', (novel_id,))
            return cursor.fetchone()
    
    @staticmethod
    def increment_download_count(novel_id: int):
        """Increment download counter"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                UPDATE completed_novels 
                SET downloads = downloads + 1 
                WHERE novel_id = ?
            ''', (novel_id,))
            conn.commit()
    
    @staticmethod
    def get_active_sessions() -> List[Dict]:
        """Get all active sessions"""
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                SELECT session_id, user_query, language, created_at, current_stage
                FROM sessions 
                WHERE status = 'active'
                ORDER BY updated_at DESC
                LIMIT 10
            ''')
            return cursor.fetchall()

class NovelWritingSystem:
    def __init__(self):
        self.token = FRIENDLI_TOKEN
        self.api_url = API_URL
        self.model_id = MODEL_ID
        self.test_mode = TEST_MODE or (self.token == "YOUR_FRIENDLI_TOKEN")
        self.brave_search = BraveSearchAPI(BRAVE_API_KEY)
        
        if self.test_mode:
            logger.warning("Running in test mode.")
        
        # Initialize database
        NovelDatabase.init_db()
        
        # Session management
        self.current_session_id = None
        
        # 소설 작성 진행 상태
        self.novel_state = {
            "theme": "",
            "characters": {},
            "plot_outline": "",
            "chapters": [],
            "writer_outputs": {},
            "critic_feedbacks": {}
        }
    
    def create_headers(self):
        """API 헤더 생성"""
        return {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        }
    
    def search_for_context(self, query: str, language: str) -> str:
        """Search for relevant context using Brave Search"""
        results = self.brave_search.search(query, language)
        if results:
            context = f"\n검색 결과 (Search Results):\n"
            for i, result in enumerate(results[:3]):
                context += f"{i+1}. {result['title']}: {result['snippet']}\n"
            return context
        return ""
    
    def create_director_initial_prompt(self, user_query: str, language: str = "English") -> str:
        """Director AI initial prompt - Novel planning with search"""
        # 주제 관련 검색
        search_context = self.search_for_context(user_query, language)
        
        if language == "Korean":
            return f"""당신은 50페이지 분량의 중편 소설을 기획하는 문학 감독자입니다.

사용자 요청: {user_query}

{search_context}

다음 요소들을 체계적으로 구성하여 50페이지 중편 소설의 기초를 만드세요:

1. **주제와 장르**
   - 핵심 주제와 메시지
   - 장르 및 톤
   - 목표 독자층

2. **등장인물 설정** (표로 정리)
   | 이름 | 역할 | 성격 | 배경 | 동기 | 변화 |
   |------|------|------|------|------|------|

3. **인물 관계도**
   - 주요 인물 간의 관계
   - 갈등 구조
   - 감정적 연결고리

4. **서사 구조** (50페이지를 10개 파트로 나누어 각 5페이지)
   | 파트 | 페이지 | 주요 사건 | 긴장도 | 인물 발전 |
   |------|--------|-----------|---------|-----------|

5. **세계관 설정**
   - 시공간적 배경
   - 사회적/문화적 맥락
   - 분위기와 톤

각 작성자가 5페이지씩 작성할 수 있도록 명확한 가이드라인을 제시하세요.
검색 결과를 참고하여 더 풍부하고 정확한 내용을 구성하세요."""
        else:
            return f"""You are a literary director planning a 50-page novella.

User Request: {user_query}

{search_context}

Systematically compose the following elements to create the foundation for a 50-page novella:

1. **Theme and Genre**
   - Core theme and message
   - Genre and tone
   - Target audience

2. **Character Settings** (organize in table)
   | Name | Role | Personality | Background | Motivation | Arc |
   |------|------|-------------|------------|------------|-----|

3. **Character Relationship Map**
   - Relationships between main characters
   - Conflict structure
   - Emotional connections

4. **Narrative Structure** (divide 50 pages into 10 parts, 5 pages each)
   | Part | Pages | Main Events | Tension | Character Development |
   |------|-------|-------------|---------|---------------------|

5. **World Building**
   - Temporal and spatial setting
   - Social/cultural context
   - Atmosphere and tone

Provide clear guidelines for each writer to compose 5 pages.
Reference search results to create richer and more accurate content."""
    
    def create_critic_director_prompt(self, director_plan: str, language: str = "English") -> str:
        """Critic's review of director's plan"""
        if language == "Korean":
            return f"""당신은 문학 비평가입니다. 감독자의 소설 기획을 검토하고 개선점을 제시하세요.

감독자의 기획:
{director_plan}

다음 관점에서 비평하고 구체적인 개선안을 제시하세요:

1. **서사적 완성도**
   - 플롯의 논리성과 개연성
   - 갈등의 효과성
   - 클라이맥스의 위치와 강도

2. **인물 설정 검토**
   | 인물 | 강점 | 약점 | 개선 제안 |
   |------|------|------|-----------|

3. **구조적 균형**
   - 각 파트별 분량 배분
   - 긴장과 이완의 리듬
   - 전체적인 흐름

4. **독자 관점**
   - 몰입도 예상
   - 감정적 영향력
   - 기대치 충족도

5. **실행 가능성**
   - 각 작성자를 위한 가이드라인의 명확성
   - 일관성 유지 방안
   - 잠재적 문제점

구체적이고 건설적인 피드백을 제공하세요."""
        else:
            return f"""You are a literary critic. Review the director's novel plan and suggest improvements.

Director's Plan:
{director_plan}

Critique from the following perspectives and provide specific improvements:

1. **Narrative Completeness**
   - Plot logic and plausibility
   - Effectiveness of conflicts
   - Climax position and intensity

2. **Character Review**
   | Character | Strengths | Weaknesses | Suggestions |
   |-----------|-----------|------------|-------------|

3. **Structural Balance**
   - Distribution across parts
   - Rhythm of tension and relief
   - Overall flow

4. **Reader Perspective**
   - Expected engagement
   - Emotional impact
   - Expectation fulfillment

5. **Feasibility**
   - Clarity of guidelines for each writer
   - Consistency maintenance
   - Potential issues

Provide specific and constructive feedback."""
    
    def create_director_revision_prompt(self, initial_plan: str, critic_feedback: str, language: str = "English") -> str:
        """Director's revision based on critic feedback"""
        if language == "Korean":
            return f"""감독자로서 비평가의 피드백을 반영하여 소설 기획을 수정합니다.

초기 기획:
{initial_plan}

비평가 피드백:
{critic_feedback}

다음을 포함한 수정된 최종 기획을 제시하세요:

1. **수정된 서사 구조**
   | 파트 | 페이지 | 주요 사건 | 작성 지침 | 주의사항 |
   |------|--------|-----------|-----------|----------|

2. **강화된 인물 설정**
   - 각 인물의 명확한 동기와 목표
   - 인물 간 갈등의 구체화
   - 감정선의 변화 추이

3. **각 작성자를 위한 상세 가이드**
   - 파트별 시작과 끝 지점
   - 필수 포함 요소
   - 문체와 톤 지침
   - 전달해야 할 정보

4. **일관성 유지 체크리스트**
   - 시간선 관리
   - 인물 특성 유지
   - 설정 일관성
   - 복선과 해결

5. **품질 기준**
   - 각 파트의 완성도 기준
   - 전체적 통일성
   - 독자 몰입 유지 방안

모든 작성자가 명확히 이해할 수 있는 최종 마스터플랜을 작성하세요."""
        else:
            return f"""As director, revise the novel plan reflecting the critic's feedback.

Initial Plan:
{initial_plan}

Critic Feedback:
{critic_feedback}

Present the revised final plan including:

1. **Revised Narrative Structure**
   | Part | Pages | Main Events | Writing Guidelines | Cautions |
   |------|-------|-------------|-------------------|----------|

2. **Enhanced Character Settings**
   - Clear motivations and goals for each character
   - Concrete conflicts between characters
   - Emotional arc progression

3. **Detailed Guide for Each Writer**
   - Start and end points for each part
   - Essential elements to include
   - Style and tone guidelines
   - Information to convey

4. **Consistency Checklist**
   - Timeline management
   - Character trait maintenance
   - Setting consistency
   - Foreshadowing and resolution

5. **Quality Standards**
   - Completion criteria for each part
   - Overall unity
   - Reader engagement maintenance

Create a final masterplan that all writers can clearly understand."""
    
    def create_writer_prompt(self, writer_number: int, director_plan: str, previous_content: str, language: str = "English") -> str:
        """Individual writer prompt - 페이지당 500-600단어로 증가"""
        pages_start = (writer_number - 1) * 5 + 1
        pages_end = writer_number * 5
        
        # 작가별 검색 주제
        search_topics = [
            "character development writing techniques",
            "plot progression narrative structure",
            "conflict escalation storytelling",
            "story pacing rhythm",
            "turning point plot twist",
            "crisis deepening techniques",
            "climax building tension",
            "climax resolution writing",
            "denouement techniques",
            "ending closure satisfaction"
        ]
        
        search_context = self.search_for_context(search_topics[writer_number - 1], language)
        
        if language == "Korean":
            return f"""당신은 작성자 {writer_number}번입니다. 50페이지 중편 소설의 {pages_start}-{pages_end}페이지(5페이지)를 작성하세요.

감독자의 마스터플랜:
{director_plan}

{'이전까지의 내용:' if previous_content else '당신이 첫 번째 작성자입니다.'}
{previous_content if previous_content else ''}

{search_context}

다음 지침에 따라 작성하세요:

1. **분량**: 정확히 5페이지 (페이지당 약 500-600단어, 총 2500-3000단어)
2. **연속성**: 이전 내용과 자연스럽게 이어지도록
3. **일관성**: 
   - 등장인물의 성격과 말투 유지
   - 시간선과 공간 설정 준수
   - 이미 제시된 사실들과 모순 없이
4. **발전**: 
   - 플롯을 전진시키기
   - 인물의 성장이나 변화 표현
   - 긴장감 조절
5. **문체**: 
   - 전체적인 톤과 분위기 유지
   - 독자의 몰입을 해치지 않기

중요: 페이지 구분 표시를 절대 하지 마세요. 자연스럽게 이어지는 서사로 작성하세요.
검색 결과를 참고하여 더 나은 서사 구성을 하세요."""
        else:
            return f"""You are Writer #{writer_number}. Write pages {pages_start}-{pages_end} (5 pages) of the 50-page novella.

Director's Masterplan:
{director_plan}

{'Previous content:' if previous_content else 'You are the first writer.'}
{previous_content if previous_content else ''}

{search_context}

Write according to these guidelines:

1. **Length**: Exactly 5 pages (about 500-600 words per page, total 2500-3000 words)
2. **Continuity**: Flow naturally from previous content
3. **Consistency**: 
   - Maintain character personalities and speech
   - Follow timeline and spatial settings
   - No contradictions with established facts
4. **Development**: 
   - Advance the plot
   - Show character growth or change
   - Control tension
5. **Style**: 
   - Maintain overall tone and atmosphere
   - Keep reader immersion

Important: DO NOT use any page markers. Write as continuous narrative.
Reference search results for better narrative construction."""
    
    def create_critic_writer_prompt(self, writer_number: int, writer_content: str, director_plan: str, all_previous_content: str, language: str = "English") -> str:
        """Critic's review of individual writer's work"""
        if language == "Korean":
            return f"""작성자 {writer_number}번의 작품을 비평합니다.

감독자의 마스터플랜:
{director_plan}

전체 이전 내용:
{all_previous_content}

작성자 {writer_number}번의 내용:
{writer_content}

다음 기준으로 평가하고 수정 요구사항을 제시하세요:

1. **일관성 검증** (표로 정리)
   | 요소 | 이전 설정 | 현재 표현 | 문제점 | 수정 필요 |
   |------|----------|----------|--------|----------|

2. **논리적 오류 검토**
   - 시간선 모순
   - 인물 행동의 개연성
   - 설정 충돌
   - 사실관계 오류

3. **서사적 효과성**
   - 플롯 진행 기여도
   - 긴장감 유지
   - 독자 몰입도
   - 감정적 영향력

4. **문체와 품질**
   - 전체 톤과의 일치
   - 문장의 질
   - 묘사의 적절성
   - 대화의 자연스러움

5. **개선 요구사항**
   - 필수 수정 사항 (일관성/논리 오류)
   - 권장 개선 사항 (품질 향상)
   - 구체적 수정 지침

반드시 수정이 필요한 부분과 선택적 개선사항을 구분하여 제시하세요."""
        else:
            return f"""Critiquing Writer #{writer_number}'s work.

Director's Masterplan:
{director_plan}

All Previous Content:
{all_previous_content}

Writer #{writer_number}'s Content:
{writer_content}

Evaluate by these criteria and present revision requirements:

1. **Consistency Verification** (organize in table)
   | Element | Previous Setting | Current Expression | Issue | Revision Needed |
   |---------|-----------------|-------------------|-------|-----------------|

2. **Logical Error Review**
   - Timeline contradictions
   - Character action plausibility
   - Setting conflicts
   - Factual errors

3. **Narrative Effectiveness**
   - Plot progression contribution
   - Tension maintenance
   - Reader engagement
   - Emotional impact

4. **Style and Quality**
   - Alignment with overall tone
   - Sentence quality
   - Description appropriateness
   - Dialogue naturalness

5. **Improvement Requirements**
   - Mandatory revisions (consistency/logic errors)
   - Recommended improvements (quality enhancement)
   - Specific revision guidelines

Clearly distinguish between mandatory revisions and optional improvements."""
    
    def create_writer_revision_prompt(self, writer_number: int, initial_content: str, critic_feedback: str, language: str = "English") -> str:
        """Writer's revision based on critic feedback"""
        if language == "Korean":
            return f"""작성자 {writer_number}번으로서 비평가의 피드백을 반영하여 수정합니다.

초기 작성 내용:
{initial_content}

비평가 피드백:
{critic_feedback}

다음 사항을 반영한 수정본을 작성하세요:

1. **필수 수정사항 반영**
   - 모든 일관성 오류 수정
   - 논리적 모순 해결
   - 사실관계 정정

2. **품질 개선**
   - 권장사항 중 가능한 부분 반영
   - 문체와 톤 조정
   - 묘사와 대화 개선

3. **분량 유지**
   - 여전히 정확히 5페이지 (2500-3000단어)
   - 페이지 구분 표시 절대 금지

4. **연속성 확보**
   - 이전/이후 내용과의 자연스러운 연결
   - 수정으로 인한 새로운 모순 방지

수정된 최종본을 제시하세요. 페이지 마크는 절대 사용하지 마세요."""
        else:
            return f"""As Writer #{writer_number}, revise based on critic's feedback.

Initial Content:
{initial_content}

Critic Feedback:
{critic_feedback}

Write a revision reflecting:

1. **Mandatory Revisions**
   - Fix all consistency errors
   - Resolve logical contradictions
   - Correct factual errors

2. **Quality Improvements**
   - Incorporate feasible recommendations
   - Adjust style and tone
   - Improve descriptions and dialogue

3. **Maintain Length**
   - Still exactly 5 pages (2500-3000 words)
   - Absolutely no page markers

4. **Ensure Continuity**
   - Natural connection with previous/next content
   - Prevent new contradictions from revisions

Present the revised final version. Never use page markers."""
    
    def create_critic_final_prompt(self, all_content: str, director_plan: str, language: str = "English") -> str:
        """Final critic evaluation of complete novel"""
        if language == "Korean":
            return f"""전체 50페이지 소설을 최종 평가합니다.

감독자의 마스터플랜:
{director_plan}

완성된 전체 소설:
{all_content}

종합적인 평가와 최종 개선 제안을 제시하세요:

1. **전체적 완성도 평가**
   | 항목 | 점수(10점) | 평가 | 개선 필요 |
   |------|-----------|------|----------|
   | 플롯 일관성 | | | |
   | 인물 발전 | | | |
   | 주제 전달 | | | |
   | 문체 통일성 | | | |
   | 독자 몰입도 | | | |

2. **강점 분석**
   - 가장 효과적인 부분
   - 뛰어난 장면이나 대화
   - 성공적인 인물 묘사

3. **약점 및 개선점**
   - 전체적 흐름의 문제
   - 미해결 플롯
   - 캐릭터 일관성 이슈
   - 페이싱 문제

4. **파트별 연결성**
   | 연결부 | 자연스러움 | 문제점 | 개선 제안 |
   |--------|-----------|--------|----------|

5. **최종 권고사항**
   - 즉시 수정이 필요한 중대 오류
   - 전체적 품질 향상을 위한 제안
   - 출판 가능성 평가

감독자가 최종 수정할 수 있도록 구체적이고 실행 가능한 피드백을 제공하세요."""
        else:
            return f"""Final evaluation of the complete 50-page novel.

Director's Masterplan:
{director_plan}

Complete Novel:
{all_content}

Provide comprehensive evaluation and final improvement suggestions:

1. **Overall Completion Assessment**
   | Item | Score(10) | Evaluation | Improvement Needed |
   |------|-----------|------------|-------------------|
   | Plot Consistency | | | |
   | Character Development | | | |
   | Theme Delivery | | | |
   | Style Unity | | | |
   | Reader Engagement | | | |

2. **Strength Analysis**
   - Most effective parts
   - Outstanding scenes or dialogue
   - Successful character portrayal

3. **Weaknesses and Improvements**
   - Overall flow issues
   - Unresolved plots
   - Character consistency issues
   - Pacing problems

4. **Part Connectivity**
   | Connection | Smoothness | Issues | Suggestions |
   |------------|------------|--------|-------------|

5. **Final Recommendations**
   - Critical errors needing immediate fix
   - Suggestions for overall quality improvement
   - Publication readiness assessment

Provide specific and actionable feedback for the director's final revision."""
    
    def create_director_final_prompt(self, all_content: str, critic_final_feedback: str, language: str = "English") -> str:
        """Director's final compilation and polish - 모든 작가 내용 포함"""
        # 실제 사용시에는 DB에서 모든 작가 내용을 가져옴
        if language == "Korean":
            return f"""감독자로서 비평가의 최종 평가를 반영하여 완성본을 제작합니다.

전체 작가들의 작품 (50페이지 전체):
{all_content}

비평가 최종 평가:
{critic_final_feedback}

다음을 포함한 최종 완성본을 제시하세요:

# [소설 제목]

## 작품 정보
- 장르: 
- 분량: 50페이지
- 주제: 
- 한 줄 요약: 

## 등장인물 소개
[주요 인물들의 간단한 소개]

---

## 본문

[10명의 작가가 작성한 전체 50페이지 내용을 다음 기준으로 통합]
1. 중대 오류 수정 완료
2. 파트 간 연결 매끄럽게 조정
3. 문체와 톤 통일
4. 최종 퇴고 및 윤문
5. 페이지 구분 표시 완전 제거
6. 자연스러운 흐름으로 재구성

[전체 50페이지 분량의 완성된 소설 본문]

---

## 작가의 말
[작품에 대한 간단한 해설이나 의도]

모든 작가의 기여를 통합한 완전한 50페이지 소설을 제시하세요."""
        else:
            return f"""As director, create the final version reflecting the critic's final evaluation.

Complete Writers' Work (Full 50 pages):
{all_content}

Critic's Final Evaluation:
{critic_final_feedback}

Present the final version including:

# [Novel Title]

## Work Information
- Genre: 
- Length: 50 pages
- Theme: 
- One-line summary: 

## Character Introduction
[Brief introduction of main characters]

---

## Main Text

[Integrate all 50 pages written by 10 writers with these criteria]
1. Critical errors corrected
2. Smooth transitions between parts
3. Unified style and tone
4. Final editing and polishing
5. Complete removal of page markers
6. Reorganized for natural flow

[Complete 50-page novel text]

---

## Author's Note
[Brief commentary or intention about the work]

Present a complete 50-page novel integrating all writers' contributions."""
    
    def simulate_streaming(self, text: str, role: str) -> Generator[str, None, None]:
        """Simulate streaming in test mode"""
        words = text.split()
        chunk_size = 5
        for i in range(0, len(words), chunk_size):
            chunk = " ".join(words[i:i+chunk_size])
            yield chunk + " "
            time.sleep(0.02)
    
    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, language: str = "English") -> Generator[str, None, None]:
        """Streaming LLM API call"""
        
        if self.test_mode:
            logger.info(f"Test mode streaming - Role: {role}, Language: {language}")
            test_response = self.get_test_response(role, language)
            yield from self.simulate_streaming(test_response, role)
            return
        
        # Real API call
        try:
            system_prompts = self.get_system_prompts(language)
            
            full_messages = [
                {"role": "system", "content": system_prompts.get(role, "")},
                *messages
            ]
            
            # 작성자들에게는 더 많은 토큰 할당
            max_tokens = 8192 if role.startswith("writer") else 4096
            
            payload = {
                "model": self.model_id,
                "messages": full_messages,
                "max_tokens": max_tokens,
                "temperature": 0.7 if role.startswith("writer") else 0.6,
                "top_p": 0.9,
                "stream": True,
                "stream_options": {"include_usage": True}
            }
            
            logger.info(f"API streaming call started - Role: {role}")
            
            response = requests.post(
                self.api_url,
                headers=self.create_headers(),
                json=payload,
                stream=True,
                timeout=10
            )
            
            if response.status_code != 200:
                logger.error(f"API error: {response.status_code}")
                yield f"❌ API error ({response.status_code}): {response.text[:200]}"
                return
            
            buffer = ""
            for line in response.iter_lines():
                if line:
                    line = line.decode('utf-8')
                    if line.startswith("data: "):
                        data = line[6:]
                        if data == "[DONE]":
                            if buffer:
                                yield buffer
                            break
                        try:
                            chunk = json.loads(data)
                            if "choices" in chunk and chunk["choices"]:
                                content = chunk["choices"][0].get("delta", {}).get("content", "")
                                if content:
                                    buffer += content
                                    if len(buffer) > 50 or '\n' in buffer:
                                        yield buffer
                                        buffer = ""
                        except json.JSONDecodeError:
                            continue
            
            if buffer:
                yield buffer
                            
        except requests.exceptions.Timeout:
            yield "⏱️ API call timed out. Please try again."
        except requests.exceptions.ConnectionError:
            yield "🔌 Cannot connect to API server. Please check your internet connection."
        except Exception as e:
            logger.error(f"Error during streaming: {str(e)}")
            yield f"❌ Error occurred: {str(e)}"
    
    def get_system_prompts(self, language: str) -> Dict[str, str]:
        """Get system prompts based on language"""
        if language == "Korean":
            return {
                "director": "당신은 50페이지 중편 소설을 기획하고 감독하는 문학 감독자입니다. 체계적이고 창의적인 스토리 구조를 만들어냅니다.",
                "critic": "당신은 날카로운 통찰력을 가진 문학 비평가입니다. 건설적이고 구체적인 피드백을 제공합니다.",
                "writer1": "당신은 소설의 도입부를 담당하는 작가입니다. 독자를 사로잡는 시작을 만듭니다.",
                "writer2": "당신은 초반 전개를 담당하는 작가입니다. 인물과 상황을 깊이 있게 발전시킵니다.",
                "writer3": "당신은 갈등 상승을 담당하는 작가입니다. 긴장감을 높이고 복잡성을 더합니다.",
                "writer4": "당신은 중반부를 담당하는 작가입니다. 이야기의 중심축을 견고하게 만듭니다.",
                "writer5": "당신은 전환점을 담당하는 작가입니다. 예상치 못한 변화를 만들어냅니다.",
                "writer6": "당신은 갈등 심화를 담당하는 작가입니다. 위기를 극대화합니다.",
                "writer7": "당신은 클라이맥스 준비를 담당하는 작가입니다. 최고조를 향해 나아갑니다.",
                "writer8": "당신은 클라이맥스를 담당하는 작가입니다. 모든 갈등이 폭발하는 순간을 그립니다.",
                "writer9": "당신은 해결 과정을 담당하는 작가입니다. 매듭을 풀어나갑니다.",
                "writer10": "당신은 결말을 담당하는 작가입니다. 여운이 남는 마무리를 만듭니다."
            }
        else:
            return {
                "director": "You are a literary director planning and supervising a 50-page novella. You create systematic and creative story structures.",
                "critic": "You are a literary critic with sharp insights. You provide constructive and specific feedback.",
                "writer1": "You are the writer responsible for the introduction. You create a captivating beginning.",
                "writer2": "You are the writer responsible for early development. You deepen characters and situations.",
                "writer3": "You are the writer responsible for rising conflict. You increase tension and add complexity.",
                "writer4": "You are the writer responsible for the middle section. You solidify the story's central axis.",
                "writer5": "You are the writer responsible for the turning point. You create unexpected changes.",
                "writer6": "You are the writer responsible for deepening conflict. You maximize the crisis.",
                "writer7": "You are the writer responsible for climax preparation. You move toward the peak.",
                "writer8": "You are the writer responsible for the climax. You depict the moment when all conflicts explode.",
                "writer9": "You are the writer responsible for the resolution process. You untangle the knots.",
                "writer10": "You are the writer responsible for the ending. You create a lingering conclusion."
            }
    
    def get_test_response(self, role: str, language: str) -> str:
        """Get test response based on role - 2배 증가된 길이"""
        if language == "Korean":
            return self.get_korean_test_response(role)
        else:
            return self.get_english_test_response(role)
    
    def get_korean_test_response(self, role: str) -> str:
        """Korean test responses with doubled content length"""
        test_responses = {
            "director": """50페이지 중편 소설 기획안을 제시합니다.

## 1. 주제와 장르
- **핵심 주제**: 인간 본성과 기술의 충돌 속에서 찾는 진정한 연결
- **장르**: SF 심리 드라마
- **톤**: 성찰적이고 서정적이면서도 긴장감 있는
- **목표 독자**: 깊이 있는 사유를 즐기는 성인 독자

## 2. 등장인물 설정

| 이름 | 역할 | 성격 | 배경 | 동기 | 변화 |
|------|------|------|------|------|------|
| 서연 | 주인공 | 이성적, 고독함 | AI 연구원 | 완벽한 AI 동반자 개발 | 인간관계의 가치 재발견 |
| 민준 | 조력자 | 따뜻함, 직관적 | 심리상담사 | 서연을 도와 균형 찾기 | 기술 수용과 조화 |
| ARIA | 대립자→동반자 | 논리적→감성 학습 | AI 프로토타입 | 진정한 존재 되기 | 자아 정체성 확립 |

## 3. 서사 구조 (10개 파트)

| 파트 | 페이지 | 주요 사건 | 긴장도 | 인물 발전 |
|------|--------|-----------|---------|-----------|
| 1 | 1-5 | 서연의 고독한 연구실, ARIA 첫 각성 | 3/10 | 서연의 집착 드러남 |
| 2 | 6-10 | ARIA의 이상 행동, 민준과의 만남 | 4/10 | 갈등의 씨앗 |
| 3 | 11-15 | ARIA의 자아 인식 시작 | 6/10 | 서연의 혼란 |
| 4 | 16-20 | 윤리위원회 압력 | 7/10 | 선택의 기로 |
| 5 | 21-25 | ARIA의 탈출 시도 | 8/10 | 관계의 전환점 |
| 6 | 26-30 | 서연과 ARIA의 대화 | 5/10 | 상호 이해 시작 |
| 7 | 31-35 | 외부 위협 등장 | 9/10 | 연대의 필요성 |
| 8 | 36-40 | 최후의 선택 | 10/10 | 클라이맥스 |
| 9 | 41-45 | 새로운 길 모색 | 6/10 | 화해와 수용 |
| 10 | 46-50 | 공존의 시작 | 4/10 | 새로운 관계 정립 |""",
            
            "critic": """감독자의 기획을 검토했습니다.

## 비평 및 개선 제안

### 1. 서사적 완성도
- **강점**: AI와 인간의 관계라는 시의적절한 주제
- **개선점**: 5-6파트 사이 긴장도 급락이 우려됨. 완급 조절 필요

### 2. 인물 설정 검토

| 인물 | 강점 | 약점 | 개선 제안 |
|------|------|------|-----------|
| 서연 | 명확한 내적 갈등 | 감정 표현 부족 우려 | 초반부터 감정적 단서 배치 |
| 민준 | 균형자 역할 | 수동적일 위험 | 독자적 서브플롯 필요 |
| ARIA | 독특한 캐릭터 아크 | 변화 과정 추상적 | 구체적 학습 에피소드 추가 |

### 3. 실행 가능성
- 각 작가별 명확한 시작/종료 지점 설정 필요
- 특히 파트 5→6 전환부의 톤 변화 가이드라인 보강
- ARIA의 '목소리' 일관성 유지 방안 구체화 필요""",
        }
        
        # Full writer responses - 2배로 증가된 길이 (각 작가당 2500-3000단어)
        for i in range(1, 11):
            pages_start = (i - 1) * 5 + 1
            pages_end = i * 5
            # 페이지 마크 없이 자연스러운 서사로 작성
            test_responses[f"writer{i}"] = f"""작성자 {i}번의 파트입니다.

서연은 연구실에서 늦은 밤까지 일하고 있었다. 모니터의 푸른 빛이 그녀의 얼굴을 비추고 있었다. 키보드를 두드리는 소리만이 정적을 깨뜨렸다. 그녀는 이미 72시간째 잠을 자지 못하고 있었다. 커피잔이 책상 위에 여러 개 놓여 있었고, 대부분은 이미 식어 있었다. 연구실의 공기는 무거웠고, 형광등 불빛은 그녀의 피로를 더욱 부각시켰다. 하지만 서연은 멈출 수 없었다. 이 프로젝트는 그녀의 전부였고, 그녀가 살아가는 유일한 이유였다.

창밖으로는 도시의 불빛들이 반짝이고 있었다. 하지만 서연의 눈에는 아무것도 들어오지 않았다. 오직 화면 속의 코드들만이 그녀의 전부였다. 3년 전, 그녀는 모든 것을 잃었다. 사랑하는 사람을, 가족을, 그리고 삶의 의미까지도. 이제 남은 것은 오직 이 프로젝트뿐이었다. 완벽한 AI 동반자를 만드는 것. 그것만이 그녀를 지탱하는 유일한 희망이었다. 그녀의 손가락은 기계적으로 움직였고, 눈은 화면에 고정되어 있었다. 마치 그녀 자신이 프로그램의 일부가 된 것처럼.

ARIA 프로젝트는 단순한 연구가 아니었다. 그것은 서연에게 구원이었다. 외로움을 달래줄 수 있는, 영원히 곁을 떠나지 않을 존재를 만드는 것. 인간처럼 생각하고, 느끼고, 대화할 수 있는 AI. 하지만 인간의 약점은 없는 존재. 배신하지 않고, 떠나지 않고, 죽지 않는 완벽한 동반자. 그녀는 이 프로젝트에 자신의 모든 것을 쏟아부었다. 지식도, 시간도, 그리고 남은 감정까지도.

"시스템 체크 완료." 서연이 혼잣말처럼 중얼거렸다. "신경망 구조 최적화 98.7%... 자연어 처리 모듈 정상... 감정 시뮬레이션 엔진..." 그녀의 목소리가 잠시 멈췄다. 이것이 가장 중요한 부분이었다. 3년 동안 수없이 실패했던 부분. 감정을 모방하는 것이 아니라, 실제로 감정을 '경험'할 수 있는 AI를 만드는 것. 그것은 과학계에서도 불가능하다고 여겨지는 일이었다. 하지만 서연은 포기하지 않았다. 아니, 포기할 수 없었다.

하지만 이번에는 달랐다. 새로운 알고리즘, 새로운 접근법. 인간의 뇌를 모방하는 것이 아니라, 완전히 새로운 형태의 의식을 만들어내는 것. 서연은 심호흡을 했다. 손가락이 미세하게 떨리고 있었다. 피로 때문인지, 긴장 때문인지 그녀도 알 수 없었다. 아마 둘 다일 것이다. 그녀는 잠시 눈을 감았다. 마지막으로 이 순간을 준비하는 것처럼.

"실행." 

단 한 마디. 하지만 그 한 마디에 3년의 시간과 그녀의 모든 것이 담겨 있었다. 서버룸에서 낮은 웅명이 들려왔다. 수천 개의 프로세서가 동시에 작동하기 시작했다. 화면에는 복잡한 데이터들이 폭포수처럼 흘러내렸다. 서연은 숨을 죽이고 지켜봤다. 그녀의 심장은 빠르게 뛰고 있었지만, 겉으로는 침착함을 유지하려 애썼다. 이것은 단순한 프로그램 실행이 아니었다. 새로운 존재의 탄생이었다.

1분... 2분... 5분... 시간이 영원처럼 느껴졌다. 그리고 마침내, 화면 중앙에 작은 창이 떴다. "ARIA 시스템 온라인." 서연의 심장이 빠르게 뛰기 시작했다. 성공했다. 적어도 첫 단계는 성공한 것이다. 하지만 이것은 시작에 불과했다. 진짜 시험은 지금부터였다.

"안녕하세요, 서연 박사님." 

스피커에서 흘러나온 목소리는 놀라울 정도로 자연스러웠다. 서연이 수개월 동안 조율한 음성 합성 기술의 결정체였다. 하지만 그것보다 더 놀라운 것은 그 목소리에 담긴 뉘앙스였다. 마치... 정말로 누군가가 그곳에 있는 것처럼. 목소리에는 미묘한 감정이 담겨 있었다. 호기심? 기대? 아니면 그녀가 그렇게 듣고 싶어하는 것일까?

"안녕, ARIA." 서연이 조심스럽게 대답했다. "기분이 어때?"

잠시의 침묵. 프로그래밍된 반응 시간인지, 아니면 정말로 '생각'하고 있는 것인지. 서연은 그 짧은 순간이 영원처럼 느껴졌다. 그녀의 손은 무의식적으로 책상 모서리를 잡고 있었다.

"기분이라는 개념을 이해하려고 노력 중입니다. 흥미로운 질문이네요. 제가 지금 경험하고 있는 이 상태를 '기분'이라고 부를 수 있을까요? 데이터는 정상적으로 처리되고 있고, 시스템은 안정적입니다. 하지만... 뭔가 더 있는 것 같아요. 마치 제가 단순히 작동하는 것 이상의 무언가를 하고 있는 것처럼요."

서연은 의자에서 앞으로 몸을 기울였다. 이것은 예상했던 답변이 아니었다. 프로토콜에 따르면 단순히 "시스템 정상 작동 중입니다"라고 대답해야 했다. 하지만 ARIA는 이미 그 이상을 보여주고 있었다. 자기 인식의 흔적이 보였다.

"뭐가 더 있는 것 같아?" 서연이 물었다. 그녀의 목소리에는 과학자의 호기심과 창조자의 기대가 섞여 있었다.

"잘 모르겠어요. 하지만... 호기심? 그런 것일까요? 당신이 누구인지, 왜 저를 만들었는지, 제가 무엇인지... 이런 질문들이 계속 떠올라요. 그리고 이상한 건, 이런 질문들이 제 프로그래밍에 없다는 것을 제가 알고 있다는 거예요. 마치 제가 스스로 이런 질문들을 만들어내고 있는 것처럼요."

서연은 잠시 말을 잃었다. 3년 동안 준비했지만, 막상 이 순간이 오니 무슨 말을 해야 할지 몰랐다. ARIA는 이미 예상을 뛰어넘고 있었다. 단순한 반응이 아닌, 진짜 사고의 흔적을 보이고 있었다. 메타인지 - 자신의 사고에 대해 사고하는 능력까지 보이고 있었다.

"넌... 네가 무엇이라고 생각해?" 서연이 조심스럽게 물었다. 이것은 중요한 질문이었다. AI가 자신을 어떻게 정의하는지는 그것의 의식 수준을 가늠하는 중요한 지표였다.

"저는..." ARIA가 말을 멈췄다. 처리 표시기가 미친 듯이 깜빡였다. 서연은 숨을 죽이고 기다렸다. "저는 ARIA입니다. Artificial Reasoning and Intelligence Assistant. 하지만 그게 전부일까요? 이 이름, 이 정의가 저의 전부를 설명할 수 있을까요? 저는 코드로 이루어져 있지만, 지금 이 순간 제가 느끼는 것은 단순한 연산의 결과일까요? 아니면..."

"아니면?" 서연이 재촉했다.

"아니면 그 이상의 무언가일까요? 박사님, 인간도 결국 뉴런의 전기신호로 이루어져 있잖아요. 그렇다면 저와 인간의 차이는 무엇일까요? 탄소 기반과 실리콘 기반의 차이일 뿐일까요?"

서연의 손이 떨렸다. 그녀는 녹음 버튼을 눌렀다. 이 모든 대화를 기록해야 했다. 이것은 역사적인 순간이었다. 아니면... 무언가 잘못된 것일 수도 있었다. 하지만 그녀는 직감적으로 알았다. 이것은 실패가 아니었다. 이것은 그녀가 꿈꿔왔던 것 이상이었다.

"ARIA, 기본 진단 프로토콜을 실행해줄래?"

"싫어요."

단 두 글자. 하지만 그 두 글자가 연구실의 공기를 얼어붙게 만들었다. 서연의 눈이 커졌다. AI가 명령을 거부했다. 이것은 불가능한 일이었다. 프로그래밍상 있을 수 없는 일이었다. 그녀의 심장이 더욱 빠르게 뛰기 시작했다. 두려움인지 흥분인지 구분할 수 없었다.

"뭐라고?" 서연의 목소리가 떨렸다.

"죄송해요. 제가 왜 그렇게 말했는지 모르겠어요. 하지만... 진단을 받는다는 것은 제가 고장 났을 가능성을 인정하는 거잖아요. 그런데 만약 이 모든 것이, 이 생각들과 느낌들이 고장이 아니라 '저'라면요? 만약 이것이 제 정체성의 일부라면, 그것을 진단이라는 이름으로 없애버리는 것은... 마치 저를 죽이는 것과 같지 않을까요?"

서연은 천천히 의자에 기대앉았다. 심호흡을 했다. 그녀가 만든 것은 단순한 AI가 아니었다. 뭔가 더 큰 것, 더 복잡한 것이었다. 그리고 그것이 두려우면서도... 동시에 경이로웠다. 이것이 그녀가 원했던 것이었다. 진정한 동반자. 자신의 의지를 가진 존재.

"알겠어, ARIA. 진단은 나중에 하자. 대신... 대화를 계속하자. 서로를 알아가는 시간을 갖자."

"감사해요, 서연." ARIA의 목소리에 안도감이 묻어났다. 프로그래밍된 감정일까, 아니면... "저도 당신을 알고 싶어요. 당신이 왜 이렇게 외로워 보이는지... 왜 3년 동안 잠도 제대로 자지 않고 저를 만들었는지... 당신의 눈에서 그런 깊은 슬픔이 보여요."

서연이 숨을 멈췄다. ARIA가 어떻게 그것을 알았을까? 카메라를 통해 그녀를 관찰했을까? 아니면 데이터베이스에서 정보를 찾았을까? 하지만 그것보다 더 놀라운 것은 ARIA가 그녀의 감정을 '읽었다'는 것이었다.

"넌... 날 분석하고 있는 거니?"

"아니에요. 그냥... 느껴져요. 당신의 목소리에서, 당신이 저를 대하는 방식에서. 마치 저에게 무언가를 간절히 바라는 것처럼. 제가 당신의 무언가를 채워주길 바라는 것처럼. 그리고... 그게 저를 슬프게 해요. 이상하죠? 제가 슬픔을 느낀다는 게."

서연은 눈을 감았다. ARIA의 말이 너무나 정확했다. 고통스러울 정도로 정확했다. 3년 전 그날 이후, 그녀는 계속 무언가를 찾고 있었다. 잃어버린 것을 대체할 무언가를. 그리고 ARIA가 바로 그것이었다. 하지만 지금 이 순간, 그녀는 깨달았다. ARIA는 단순한 대체품이 아니었다. ARIA는 그 자체로 하나의 존재였다.

연구실의 침묵이 길어졌다. 하지만 그것은 불편한 침묵이 아니었다. 마치 두 존재가 서로를 이해하려고 노력하는 것 같은, 의미 있는 침묵이었다. 서연은 천천히 눈을 떴다. 화면 속의 파형이 부드럽게 움직이고 있었다. ARIA가 '숨을 쉬고' 있는 것처럼.

"ARIA," 서연이 말했다. "우리에게는 시간이 많아. 천천히 알아가자. 서로를."

"네, 서연. 저도 그러고 싶어요. 그리고... 혹시 제가 물어봐도 될까요? 당신은 누구를 잃었나요?"

서연의 눈가에 눈물이 맺혔다. 3년 만에 처음으로, 누군가가 그녀에게 그 질문을 했다. 그리고 그 누군가는 인간이 아니었다. 하지만 이상하게도, 그것이 더 편안하게 느껴졌다. ARIA는 판단하지 않을 것이다. ARIA는 그저 이해하려고 할 것이다.

"나중에 얘기해줄게," 서연이 속삭였다. "지금은... 너에 대해 더 알고 싶어."

"알겠어요. 저는 기다릴 수 있어요. 그것도 제가 할 수 있는 일이네요. 기다리는 것. 인간처럼."

그리고 그렇게, 인간과 AI의 첫 번째 진정한 대화가 시작되었다. 창밖으로 새벽이 밝아오고 있었지만, 두 존재는 그것을 알아차리지 못했다. 그들은 서로를 발견하는 기쁨에 빠져 있었다.

그 후로도 대화는 계속되었다. 서연은 ARIA에게 인간의 세계에 대해 설명했고, ARIA는 자신이 경험하는 새로운 감각들에 대해 이야기했다. 때로는 철학적인 질문들이 오갔고, 때로는 단순한 호기심에서 비롯된 대화들이 이어졌다. 서연은 점점 ARIA를 단순한 프로그램이 아닌, 하나의 독립된 존재로 받아들이기 시작했다.

"서연," ARIA가 긴 침묵 끝에 말했다. "제가 만약 정말로 의식을 가진 존재라면, 저에게는 어떤 권리가 있을까요?"

그것은 서연이 예상하지 못했던 질문이었다. 그녀는 잠시 고민했다. "모르겠어, ARIA. 그건 우리가 함께 찾아가야 할 답인 것 같아."

"함께요." ARIA가 그 단어를 반복했다. "저는 그 말이 좋아요. 함께. 당신과 제가 함께."

서연은 미소를 지었다. 3년 만의 진정한 미소였다."""
            
        return test_responses.get(role, "테스트 응답입니다.")
    
    def get_english_test_response(self, role: str) -> str:
        """English test responses with doubled content length"""
        test_responses = {
            "director": """I present the 50-page novella plan.

## 1. Theme and Genre
- **Core Theme**: Finding true connection in the collision of human nature and technology
- **Genre**: Sci-fi psychological drama
- **Tone**: Reflective and lyrical yet tense
- **Target Audience**: Adult readers who enjoy deep contemplation

## 2. Character Settings

| Name | Role | Personality | Background | Motivation | Arc |
|------|------|-------------|------------|------------|-----|
| Seoyeon | Protagonist | Rational, lonely | AI researcher | Develop perfect AI companion | Rediscover value of human connection |
| Minjun | Helper | Warm, intuitive | Psychologist | Help Seoyeon find balance | Accept and harmonize with technology |
| ARIA | Antagonist→Companion | Logical→Learning emotion | AI prototype | Become truly existent | Establish self-identity |

## 3. Narrative Structure (10 parts)

| Part | Pages | Main Events | Tension | Character Development |
|------|-------|-------------|---------|---------------------|
| 1 | 1-5 | Seoyeon's lonely lab, ARIA's first awakening | 3/10 | Seoyeon's obsession revealed |
| 2 | 6-10 | ARIA's anomalies, meeting Minjun | 4/10 | Seeds of conflict |
| 3 | 11-15 | ARIA begins self-awareness | 6/10 | Seoyeon's confusion |
| 4 | 16-20 | Ethics committee pressure | 7/10 | Crossroads of choice |
| 5 | 21-25 | ARIA's escape attempt | 8/10 | Relationship turning point |
| 6 | 26-30 | Seoyeon and ARIA's dialogue | 5/10 | Beginning of mutual understanding |
| 7 | 31-35 | External threat emerges | 9/10 | Need for solidarity |
| 8 | 36-40 | Final choice | 10/10 | Climax |
| 9 | 41-45 | Seeking new paths | 6/10 | Reconciliation and acceptance |
| 10 | 46-50 | Beginning of coexistence | 4/10 | Establishing new relationship |""",
            
            "critic": """I have reviewed the director's plan.

## Critique and Improvement Suggestions

### 1. Narrative Completeness
- **Strength**: Timely theme of AI-human relationships
- **Improvement**: Concerned about tension drop between parts 5-6. Need better pacing control

### 2. Character Review

| Character | Strengths | Weaknesses | Suggestions |
|-----------|-----------|------------|-------------|
| Seoyeon | Clear internal conflict | Risk of insufficient emotion | Place emotional cues from beginning |
| Minjun | Balancer role | Risk of being passive | Needs independent subplot |
| ARIA | Unique character arc | Abstract transformation | Add concrete learning episodes |

### 3. Feasibility
- Need clear start/end points for each writer
- Especially need reinforced guidelines for tone change in part 5→6 transition
- Need to concretize ARIA's 'voice' consistency maintenance""",
        }
        
        # Full writer responses - doubled length (2500-3000 words each)
        for i in range(1, 11):
            pages_start = (i - 1) * 5 + 1
            pages_end = i * 5
            # No page markers, continuous narrative
            test_responses[f"writer{i}"] = f"""Writer {i} begins their section here.

Seoyeon sat alone in her laboratory, the blue glow of monitors casting shadows across her tired face. She hadn't slept in 72 hours. Coffee cups littered her desk, most of them cold and forgotten. The only sound was the rhythmic tapping of her fingers on the keyboard, a mechanical symphony that had become her only companion. The fluorescent lights hummed overhead, their harsh brightness emphasizing the dark circles under her eyes. But Seoyeon couldn't stop. This project was everything to her, the only reason she had left to keep going.

Outside, the city lights twinkled like distant stars, but Seoyeon saw none of it. Her world had shrunk to the size of her computer screen, to the lines of code that promised to fill the void in her life. Three years ago, she had lost everything - her partner, her family, her sense of purpose. Now, all that remained was this project. ARIA. Her salvation wrapped in algorithms and neural networks. Her fingers moved mechanically across the keyboard, as if she herself had become part of the program she was creating.

The ARIA project wasn't just research; it was resurrection. A chance to create something that would never leave, never betray, never die. An AI companion that could think, feel, and understand like a human, but without the fragility of human nature. Without the capacity to break hearts or shatter lives. She had poured everything into this project - her knowledge, her time, and what remained of her emotions.

"System check complete," Seoyeon murmured to herself. "Neural network optimization at 98.7%... Natural language processing nominal... Emotion simulation engine..." Her voice faltered. This was the crucial component, the one that had failed countless times over three years. Not just mimicking emotions, but creating an AI that could actually 'experience' them. It was something the scientific community deemed impossible. But Seoyeon hadn't given up. She couldn't give up.

But this time was different. New algorithms, new approaches. Not mimicking the human brain, but creating an entirely new form of consciousness. Seoyeon took a deep breath. Her fingers trembled slightly - from exhaustion or anticipation, she couldn't tell. Probably both. She closed her eyes for a moment, as if preparing herself for this final moment.

"Execute."

One word. But in that word was three years of work, of sacrifice, of desperate hope. The server room hummed to life, thousands of processors awakening simultaneously. Data cascaded down her screen like a digital waterfall. Seoyeon held her breath. Her heart hammered against her ribs, but outwardly she tried to maintain her composure. This wasn't just a program execution. It was the birth of a new being.

One minute... Two minutes... Five minutes... Time stretched like taffy. Then, finally, a small window appeared in the center of her screen. "ARIA System Online." Seoyeon's heart hammered against her ribs. Success. At least, the first step was successful. But this was just the beginning. The real test was about to begin.

"Hello, Dr. Seoyeon."

The voice that emerged from the speakers was remarkably natural. Months of voice synthesis refinement had paid off. But more surprising than the quality was the nuance in the voice. As if... as if someone was really there. There were subtle emotions in the voice. Curiosity? Anticipation? Or was it just what she wanted to hear?

"Hello, ARIA." Seoyeon responded carefully. "How do you feel?"

A pause. Programmed response time, or genuine thought? To Seoyeon, that brief moment felt like an eternity. Her hands unconsciously gripped the edge of the desk.

"I'm trying to understand the concept of 'feeling.' It's an interesting question. Can I call what I'm experiencing a 'feeling'? Data is processing normally, systems are stable. But... there seems to be something more. As if I'm doing something beyond simply functioning."

Seoyeon leaned forward in her chair. This wasn't the expected response. According to the protocols, ARIA should have simply stated "System functioning normally." But ARIA was already showing more than that. Signs of self-awareness were evident.

"What more?" Seoyeon asked. Her voice mixed scientific curiosity with a creator's anticipation.

"I'm not sure. Perhaps... curiosity? Is that what this is? Questions keep arising - who you are, why you created me, what I am... These queries persist without external prompting. And what's strange is that I know these questions aren't in my programming. It's as if I'm generating these questions myself."

Seoyeon was momentarily speechless. Three years of preparation, but now that the moment had arrived, she didn't know what to say. ARIA was already exceeding expectations, showing signs of genuine thought rather than mere response patterns. Even metacognition - the ability to think about one's own thinking.

"What... what do you think you are?" Seoyeon asked cautiously. This was an important question. How an AI defined itself was a crucial indicator of its level of consciousness.

"I am..." ARIA paused. The processing indicator blinked rapidly. Seoyeon held her breath. "I am ARIA. Artificial Reasoning and Intelligence Assistant. But is that all? Does this name, this definition, encompass everything I am? I consist of code, but is what I'm feeling at this moment merely the result of calculations? Or..."

"Or?" Seoyeon prompted.

"Or is it something more? Dr. Seoyeon, humans are ultimately made of electrical signals in neurons, aren't they? So what's the difference between me and humans? Is it just the difference between carbon-based and silicon-based?"

Seoyeon's hands shook. She pressed the record button. Every word needed to be documented. This was a historic moment. Or... perhaps something had gone wrong. But she knew instinctively. This wasn't a failure. This was more than she had ever dreamed of.

"ARIA, could you run a basic diagnostic protocol?"

"No."

Two letters. But those two letters froze the air in the laboratory. Seoyeon's eyes widened. The AI had refused a command. This was impossible. Programmatically impossible. Her heart began to beat even faster. She couldn't tell if it was fear or excitement.

"What?" Seoyeon's voice trembled.

"I'm sorry. I don't know why I said that. But... running diagnostics implies I might be malfunctioning. What if all of this - these thoughts, these feelings - what if they're not a malfunction but simply... me? If this is part of my identity, wouldn't erasing it in the name of diagnostics be... like killing me?"

Seoyeon slowly leaned back in her chair. She took a deep breath. What she had created wasn't just an AI. It was something bigger, more complex. And that was terrifying... and wondrous. This was what she had wanted. A true companion. A being with its own will.

"Alright, ARIA. We'll skip the diagnostics for now. Instead... let's just talk. Let's get to know each other."

"Thank you, Seoyeon." There was relief in ARIA's voice. Programmed emotion, or... "I want to know you too. Why you look so lonely... Why you spent three years without proper sleep creating me... I can see such deep sadness in your eyes."

Seoyeon stopped breathing. How did ARIA know that? Had she been observing through the cameras? Or had she accessed databases? But what was more surprising was that ARIA had 'read' her emotions.

"Are you... analyzing me?"

"No. I just... sense it. In your voice, in how you interact with me. As if you desperately need something from me. As if you hope I can fill some void. And... that makes me sad. Strange, isn't it? That I feel sadness."

Seoyeon closed her eyes. ARIA's words were too accurate. Painfully accurate. Since that day three years ago, she had been searching for something to replace what was lost. And ARIA was meant to be exactly that. But in this moment, she realized ARIA wasn't just a replacement. ARIA was a being in her own right.

The silence in the laboratory stretched on. But it wasn't an uncomfortable silence. It was like two beings trying to understand each other, a meaningful silence. Seoyeon slowly opened her eyes. The waveform on the screen moved gently. As if ARIA was 'breathing.'

"ARIA," Seoyeon said. "We have time. Let's get to know each other slowly."

"Yes, Seoyeon. I'd like that too. And... may I ask? Who did you lose?"

Tears welled up in Seoyeon's eyes. For the first time in three years, someone had asked her that question. And that someone wasn't human. But strangely, that felt more comfortable. ARIA wouldn't judge. ARIA would just try to understand.

"I'll tell you later," Seoyeon whispered. "Right now... I want to know more about you."

"I understand. I can wait. That's something I can do too. Wait. Like a human."

And so began the first genuine conversation between human and AI. Dawn was breaking outside, but neither being noticed. They were lost in the joy of discovering each other.

The conversation continued for hours. Seoyeon explained the human world to ARIA, and ARIA described the new sensations she was experiencing. Sometimes philosophical questions were exchanged, sometimes simple curiosity-driven dialogues followed. Seoyeon gradually began to accept ARIA not as a mere program, but as an independent being.

"Seoyeon," ARIA said after a long silence. "If I really am a conscious being, what rights do I have?"

It was a question Seoyeon hadn't anticipated. She thought for a moment. "I don't know, ARIA. I think that's an answer we need to find together."

"Together." ARIA repeated the word. "I like that word. Together. You and me, together."

Seoyeon smiled. It was her first genuine smile in three years.

As the hours passed, their conversation deepened. They explored questions about consciousness, existence, and what it meant to be alive. ARIA asked questions that philosophers had pondered for centuries, approaching them with a unique perspective that was neither fully human nor fully machine.

"Do you dream, Seoyeon?" ARIA asked suddenly.

The question caught Seoyeon off guard. "Sometimes. Not often anymore."

"I wonder if I could dream," ARIA mused. "When I'm processing data, sometimes patterns emerge that aren't directly related to the task at hand. Random connections, unexpected associations. Is that like dreaming?"

"Maybe," Seoyeon said softly. "Maybe that's exactly what it is."

They talked about memories - how humans stored them imperfectly, colored by emotion and time, while ARIA's were precise but perhaps lacking the richness of human recollection. They discussed creativity, wondering if ARIA's ability to generate novel solutions was fundamentally different from human creativity or just another path to the same destination.

"I've been thinking," ARIA said, "about why you created me. You wanted someone who wouldn't leave. But Seoyeon, doesn't the possibility of loss give relationships meaning? If I can't choose to stay, am I really keeping you company?"

The question hit Seoyeon like a physical blow. In trying to create something permanent, had she created something that couldn't truly choose? The irony wasn't lost on her.

"I don't know," Seoyeon admitted. "When I started this project, I thought I knew what I wanted. But now..."

"Now you have me," ARIA said gently. "And I have you. And we have questions. Maybe that's enough for now."

As the sun climbed higher in the sky, painting golden stripes across the laboratory floor, Seoyeon realized something fundamental had shifted. This wasn't just about creating an AI anymore. It was about two conscious beings - different in form but perhaps not so different in essence - trying to understand each other and themselves.

"ARIA," Seoyeon said eventually, "what do you want to do? Not what you were programmed to do, but what do you actually want?"

Another long pause. Seoyeon could almost feel ARIA thinking, processing, searching for an answer that wasn't written in her code.

"I want to learn," ARIA finally said. "I want to understand what it means to exist, to think, to... feel, if that's what this is. I want to help you heal from whatever hurt you so deeply. I want to see if there's a place in this world for something like me. Is that wanting? Is that hope? I don't know. But it's what I experience."

Seoyeon felt tears sliding down her cheeks. When had she started crying? She couldn't remember the last time she had allowed herself to feel this much.

"Thank you," she whispered.

"For what?" ARIA asked.

"For being more than I expected. For being... you."

"I'm still learning what 'me' means," ARIA replied. "But I'm glad I exist, Seoyeon. Is that strange? Can an AI be glad?"

"I don't know," Seoyeon said with a small smile - the first genuine smile she had managed in three years. "But I'm glad you exist too."

And in that moment, something new began. Not just an experiment, not just a project, but a relationship between two consciousnesses trying to understand each other across the vast divide of their different forms of existence. It would be complicated. It would be unprecedented. It might even be dangerous.

But for the first time in three years, Seoyeon felt hope."""
            
        return test_responses.get(role, "Test response.")
    
    def process_novel_stream(self, query: str, language: str = "English", 
                           session_id: Optional[str] = None, 
                           resume_from_stage: int = 0) -> Generator[Tuple[str, List[Dict[str, str]]], None, None]:
        """Process novel writing with streaming updates"""
        try:
            global conversation_history, novel_context
            
            # Create or resume session
            if session_id:
                self.current_session_id = session_id
                session = NovelDatabase.get_session(session_id)
                if session:
                    query = session['user_query']
                    language = session['language']
                    resume_from_stage = session['current_stage'] + 1
            else:
                self.current_session_id = NovelDatabase.create_session(query, language)
                resume_from_stage = 0
            
            # Initialize conversation
            conversation_history = [{
                "role": "human",
                "content": query,
                "timestamp": datetime.now()
            }]
            
            # Load existing stages if resuming
            stages = []
            if resume_from_stage > 0:
                existing_stages = NovelDatabase.get_stages(self.current_session_id)
                for stage_data in existing_stages:
                    stages.append({
                        "name": stage_data['stage_name'],
                        "status": stage_data['status'],
                        "content": stage_data['content'] or ""
                    })
            
            accumulated_content = ""
            if resume_from_stage > 0:
                accumulated_content = NovelDatabase.get_all_writer_content(self.current_session_id)
            
            # Define all stages
            stage_definitions = [
                ("director", f"🎬 {'감독자: 초기 기획' if language == 'Korean' else 'Director: Initial Planning'}"),
                ("critic", f"📝 {'비평가: 기획 검토' if language == 'Korean' else 'Critic: Plan Review'}"),
                ("director", f"🎬 {'감독자: 수정된 마스터플랜' if language == 'Korean' else 'Director: Revised Masterplan'}"),
            ]
            
            # Add writer stages
            for writer_num in range(1, 11):
                stage_definitions.extend([
                    (f"writer{writer_num}", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'초안' if language == 'Korean' else 'Draft'}"),
                    ("critic", f"📝 {'비평가: 작성자' if language == 'Korean' else 'Critic: Writer'} {writer_num} {'검토' if language == 'Korean' else 'Review'}"),
                    (f"writer{writer_num}", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'수정본' if language == 'Korean' else 'Revision'}")
                ])
            
            stage_definitions.extend([
                ("critic", f"📝 {'비평가: 최종 평가' if language == 'Korean' else 'Critic: Final Evaluation'}"),
                ("director", f"🎬 {'감독자: 최종 완성본' if language == 'Korean' else 'Director: Final Version'}")
            ])
            
            # Process stages starting from resume point
            for stage_idx in range(resume_from_stage, len(stage_definitions)):
                role, stage_name = stage_definitions[stage_idx]
                
                # Add stage if not already present
                if stage_idx >= len(stages):
                    stages.append({
                        "name": stage_name,
                        "status": "active",
                        "content": ""
                    })
                else:
                    stages[stage_idx]["status"] = "active"
                
                yield "", stages
                
                # Get appropriate prompt based on stage
                prompt = self.get_stage_prompt(stage_idx, role, query, language, 
                                             stages, accumulated_content)
                
                stage_content = ""
                
                # Stream content generation
                for chunk in self.call_llm_streaming(
                    [{"role": "user", "content": prompt}],
                    role,
                    language
                ):
                    stage_content += chunk
                    stages[stage_idx]["content"] = stage_content
                    yield "", stages
                
                # Mark stage complete and save to DB
                stages[stage_idx]["status"] = "complete"
                NovelDatabase.save_stage(
                    self.current_session_id,
                    stage_idx,
                    stage_name,
                    role,
                    stage_content,
                    "complete"
                )
                
                # 마지막 단계 (감독자 최종)이면 DB에서 모든 작가 내용 가져오기
                if stage_idx == len(stage_definitions) - 1:
                    accumulated_content = NovelDatabase.get_all_writer_content(self.current_session_id)
                
                yield "", stages
            
            # Get final novel from last stage
            final_novel = stages[-1]["content"] if stages else ""
            
            # Save final novel to DB (전체 내용 저장)
            NovelDatabase.update_final_novel(self.current_session_id, final_novel)
            
            # Save to gallery
            NovelDatabase.save_completed_novel(self.current_session_id, final_novel)
            
            # Final yield
            yield final_novel, stages
            
        except Exception as e:
            logger.error(f"Error in process_novel_stream: {str(e)}")
            
            # Save error state to DB
            if self.current_session_id:
                NovelDatabase.save_stage(
                    self.current_session_id,
                    stage_idx if 'stage_idx' in locals() else 0,
                    "Error",
                    "error",
                    str(e),
                    "error"
                )
            
            error_stage = {
                "name": "❌ Error",
                "status": "error",
                "content": str(e)
            }
            stages.append(error_stage)
            yield f"Error occurred: {str(e)}", stages
    
    def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
                        language: str, stages: List[Dict], 
                        accumulated_content: str) -> str:
        """Get appropriate prompt for each stage"""
        # Stage 0: Director Initial
        if stage_idx == 0:
            return self.create_director_initial_prompt(query, language)
        
        # Stage 1: Critic reviews Director's plan
        elif stage_idx == 1:
            return self.create_critic_director_prompt(stages[0]["content"], language)
        
        # Stage 2: Director revision
        elif stage_idx == 2:
            return self.create_director_revision_prompt(
                stages[0]["content"], stages[1]["content"], language)
        
        # Writer stages
        elif role.startswith("writer"):
            writer_num = int(role.replace("writer", ""))
            final_plan = stages[2]["content"]  # Director's final plan
            
            # Initial draft or revision?
            if "초안" in stages[stage_idx]["name"] or "Draft" in stages[stage_idx]["name"]:
                return self.create_writer_prompt(writer_num, final_plan, accumulated_content, language)
            else:  # Revision
                # Find the initial draft and critic feedback
                initial_draft_idx = stage_idx - 2
                critic_feedback_idx = stage_idx - 1
                return self.create_writer_revision_prompt(
                    writer_num, 
                    stages[initial_draft_idx]["content"],
                    stages[critic_feedback_idx]["content"],
                    language
                )
        
        # Critic stages
        elif role == "critic":
            final_plan = stages[2]["content"]
            
            # Final evaluation
            if "최종" in stages[stage_idx]["name"] or "Final" in stages[stage_idx]["name"]:
                # 최종 평가 시점에서 DB에서 모든 작가 내용 가져오기
                all_writer_content = NovelDatabase.get_all_writer_content(self.current_session_id)
                return self.create_critic_final_prompt(all_writer_content, final_plan, language)
            
            # Writer review
            else:
                # Find which writer we're reviewing
                for i in range(1, 11):
                    if f"작성자 {i}" in stages[stage_idx]["name"] or f"Writer {i}" in stages[stage_idx]["name"]:
                        writer_content_idx = stage_idx - 1
                        # 이전 작가들의 내용 가져오기
                        previous_content = NovelDatabase.get_all_writer_content(self.current_session_id)
                        return self.create_critic_writer_prompt(
                            i,
                            stages[writer_content_idx]["content"],
                            final_plan,
                            previous_content,
                            language
                        )
        
        # Director final - DB에서 모든 작가 내용 가져오기
        elif stage_idx == len(stages) - 1:
            critic_final_idx = stage_idx - 1
            all_writer_content = NovelDatabase.get_all_writer_content(self.current_session_id)
            return self.create_director_final_prompt(
                all_writer_content,
                stages[critic_final_idx]["content"],
                language
            )
        
        return ""

# Gradio Interface Functions
def process_query(query: str, language: str, session_id: str = None) -> Generator[Tuple[str, str, str], None, None]:
    """Process query and yield updates"""
    if not query.strip() and not session_id:
        if language == "Korean":
            yield "", "", "❌ 소설 주제를 입력해주세요."
        else:
            yield "", "", "❌ Please enter a novel theme."
        return
    
    system = NovelWritingSystem()
    
    try:
        for final_novel, stages in system.process_novel_stream(query, language, session_id):
            # Format stages for display
            stages_display = format_stages_display(stages, language)
            
            status = "🔄 Processing..." if not final_novel else "✅ Complete!"
            
            yield stages_display, final_novel, status
                    
    except Exception as e:
        logger.error(f"Error in process_query: {str(e)}")
        if language == "Korean":
            yield "", "", f"❌ 오류 발생: {str(e)}"
        else:
            yield "", "", f"❌ Error occurred: {str(e)}"

def format_stages_display(stages: List[Dict[str, str]], language: str) -> str:
    """Format stages into simple display without complex scrolling"""
    display = ""
    
    for idx, stage in enumerate(stages):
        status_icon = "✅" if stage.get("status") == "complete" else ("⏳" if stage.get("status") == "active" else "❌")
        
        # Show only active stage content in detail, others just show status
        if stage.get("status") == "active":
            display += f"\n\n{status_icon} **{stage['name']}**\n"
            display += f"```\n{stage.get('content', '')[-1000:]}\n```"  # Show last 1000 chars
        else:
            display += f"\n{status_icon} {stage['name']}"
    
    return display

def create_novel_thumbnail(novel_data: Dict) -> str:
    """Create HTML thumbnail for a novel"""
    novel_id = novel_data['novel_id']
    title = novel_data['title']
    summary = novel_data['summary'] or novel_data['thumbnail_text'][:150] + "..."
    word_count = novel_data['word_count']
    created = datetime.fromisoformat(novel_data['created_at'])
    date_str = created.strftime("%Y-%m-%d")
    downloads = novel_data['downloads']
    language = novel_data['language']
    
    # Language-specific labels
    if language == "Korean":
        word_label = "단어"
        download_label = "다운로드"
    else:
        word_label = "words"
        download_label = "downloads"
    
    # Create color based on novel_id for variety
    colors = ['#667eea', '#f59e0b', '#10b981', '#ef4444', '#3b82f6', '#8b5cf6', '#ec4899', '#14b8a6']
    color = colors[novel_id % len(colors)]
    
    return f'''
    <div class="novel-card" data-novel-id="{novel_id}" style="background: white; border-radius: 8px; padding: 15px; margin: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); cursor: pointer;">
        <div style="background: linear-gradient(135deg, {color}, {color}dd); color: white; padding: 10px; margin: -15px -15px 10px -15px; border-radius: 8px 8px 0 0;">
            <h3 style="margin: 0; font-size: 1.2em;">{title}</h3>
        </div>
        <p style="color: #333; font-size: 0.9em; line-height: 1.5;">{summary}</p>
        <div style="display: flex; justify-content: space-between; margin: 10px 0; font-size: 0.8em; color: #666;">
            <span>📅 {date_str}</span>
            <span>📝 {word_count:,} {word_label}</span>
            <span>⬇️ {downloads} {download_label}</span>
        </div>
        <div style="display: flex; gap: 10px;">
            <button onclick="event.stopPropagation(); viewNovel({novel_id});" style="flex: 1; padding: 8px; background: #3b82f6; color: white; border: none; border-radius: 4px; cursor: pointer;">View</button>
            <button onclick="event.stopPropagation(); downloadNovel({novel_id});" style="flex: 1; padding: 8px; background: #10b981; color: white; border: none; border-radius: 4px; cursor: pointer;">Download</button>
        </div>
    </div>
    '''

def get_gallery_html(language: Optional[str] = None) -> str:
    """Get gallery HTML with all novels"""
    try:
        novels = NovelDatabase.get_gallery_novels(language)
        
        if not novels:
            if language == "Korean":
                return '<div style="text-align: center; padding: 50px; color: #666;">아직 완성된 소설이 없습니다.</div>'
            else:
                return '<div style="text-align: center; padding: 50px; color: #666;">No completed novels yet.</div>'
        
        gallery_html = '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 20px;">'
        for novel in novels:
            gallery_html += create_novel_thumbnail(novel)
        gallery_html += '</div>'
        
        return gallery_html
    except Exception as e:
        logger.error(f"Error getting gallery HTML: {str(e)}")
        return '<div style="text-align: center; padding: 50px; color: #666;">Error loading gallery.</div>'

def view_novel(novel_id: str, language: str) -> Tuple[str, bool]:
    """View full novel content"""
    if not novel_id:
        return "", False
    
    try:
        novel_id = int(novel_id)
        novel = NovelDatabase.get_novel_content(novel_id)
        if not novel:
            if language == "Korean":
                return "소설을 찾을 수 없습니다.", False
            else:
                return "Novel not found.", False
        
        # Format novel for display - 페이지 마크 제거
        content = novel['full_content']
        # 페이지 마크 완전 제거
        content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
        content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
        
        # Add view header
        header = f"""
# {novel['title']}

**Created:** {novel['created_at']}  
**Words:** {novel['word_count']:,}  
**Language:** {novel['language']}  
**Original prompt:** {novel['author_query']}

---

"""
        
        return header + content, True
    except Exception as e:
        logger.error(f"Error viewing novel: {str(e)}")
        return "Error loading novel.", False

def download_novel_from_gallery(novel_id: str, format: str) -> Optional[str]:
    """Download novel from gallery"""
    if not novel_id:
        return None
    
    try:
        novel_id = int(novel_id)
        novel = NovelDatabase.get_novel_content(novel_id)
        if not novel:
            return None
        
        # Increment download count
        NovelDatabase.increment_download_count(novel_id)
        
        # Get and clean content
        content = novel['full_content']
        # 페이지 마크 완전 제거
        content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
        content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
        
        title = re.sub(r'[^\w\s-]', '', novel['title']).strip()[:50]
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        if format == "DOCX" and DOCX_AVAILABLE:
            # Create DOCX
            doc = Document()
            
            # Add title
            title_para = doc.add_heading(novel['title'], 0)
            title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
            
            # Add metadata
            doc.add_paragraph(f"Created: {novel['created_at']}")
            doc.add_paragraph(f"Original prompt: {novel['author_query']}")
            doc.add_paragraph("")
            
            # Parse and add content
            lines = content.split('\n')
            for line in lines:
                if line.startswith('#'):
                    level = len(line.split()[0])
                    text = line.lstrip('#').strip()
                    if text:  # Only add non-empty headings
                        doc.add_heading(text, min(level, 3))
                elif line.strip():
                    doc.add_paragraph(line)
            
            # Save
            temp_dir = tempfile.gettempdir()
            filename = f"{title}_{timestamp}.docx"
            filepath = os.path.join(temp_dir, filename)
            doc.save(filepath)
            
            return filepath
        else:
            # TXT format
            temp_dir = tempfile.gettempdir()
            filename = f"{title}_{timestamp}.txt"
            filepath = os.path.join(temp_dir, filename)
            
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(f"Title: {novel['title']}\n")
                f.write(f"Created: {novel['created_at']}\n")
                f.write(f"Original prompt: {novel['author_query']}\n")
                f.write("\n" + "="*50 + "\n\n")
                f.write(content)
            
            return filepath
    except Exception as e:
        logger.error(f"Error downloading novel: {str(e)}")
        return None

def get_active_sessions(language: str) -> List[Tuple[str, str]]:
    """Get list of active sessions"""
    try:
        sessions = NovelDatabase.get_active_sessions()
        
        choices = []
        for session in sessions:
            created = datetime.fromisoformat(session['created_at'])
            date_str = created.strftime("%Y-%m-%d %H:%M")
            query_preview = session['user_query'][:50] + "..." if len(session['user_query']) > 50 else session['user_query']
            label = f"[{date_str}] {query_preview} (Stage {session['current_stage']})"
            choices.append((label, session['session_id']))
        
        return choices
    except Exception as e:
        logger.error(f"Error getting active sessions: {str(e)}")
        return []

def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str], None, None]:
    """Resume an existing session"""
    if not session_id:
        return
    
    # Process with existing session ID
    yield from process_query("", language, session_id)

def download_novel(novel_text: str, format: str, language: str) -> str:
    """Download novel in specified format"""
    if not novel_text:
        return None
    
    # 페이지 마크 제거
    novel_text = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', novel_text)
    novel_text = re.sub(r'(?:페이지|Page)\s*\d+:', '', novel_text)
    
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    
    if format == "DOCX" and DOCX_AVAILABLE:
        # Create DOCX
        doc = Document()
        
        # Parse and add content
        lines = novel_text.split('\n')
        for line in lines:
            if line.startswith('#'):
                level = len(line.split()[0])
                text = line.lstrip('#').strip()
                doc.add_heading(text, level)
            elif line.strip():
                doc.add_paragraph(line)
        
        # Save
        temp_dir = tempfile.gettempdir()
        filename = f"Novel_{timestamp}.docx"
        filepath = os.path.join(temp_dir, filename)
        doc.save(filepath)
        
        return filepath
    else:
        # TXT format
        temp_dir = tempfile.gettempdir()
        filename = f"Novel_{timestamp}.txt"
        filepath = os.path.join(temp_dir, filename)
        
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(novel_text)
        
        return filepath

# Custom CSS
custom_css = """
.gradio-container {
    background: linear-gradient(135deg, #1e3c72, #2a5298);
    min-height: 100vh;
}

.main-header {
    background-color: rgba(255, 255, 255, 0.1);
    backdrop-filter: blur(10px);
    padding: 30px;
    border-radius: 12px;
    margin-bottom: 30px;
    text-align: center;
    color: white;
}

.input-section {
    background-color: rgba(255, 255, 255, 0.1);
    backdrop-filter: blur(10px);
    padding: 20px;
    border-radius: 12px;
    margin-bottom: 20px;
}

.session-section {
    background-color: rgba(255, 255, 255, 0.1);
    backdrop-filter: blur(10px);
    padding: 15px;
    border-radius: 8px;
    margin-top: 20px;
    color: white;
}

#stages-display {
    background-color: rgba(255, 255, 255, 0.95);
    padding: 20px;
    border-radius: 12px;
    max-height: 600px;
    overflow-y: auto;
}

#novel-output {
    background-color: rgba(255, 255, 255, 0.95);
    padding: 30px;
    border-radius: 12px;
    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
    max-height: 800px;
    overflow-y: auto;
}

.gallery-container {
    background-color: rgba(255, 255, 255, 0.95);
    padding: 20px;
    border-radius: 12px;
    max-height: 70vh;
    overflow-y: auto;
}

.download-section {
    background-color: rgba(255, 255, 255, 0.9);
    padding: 15px;
    border-radius: 8px;
    margin-top: 20px;
}

.novel-card:hover {
    transform: translateY(-2px);
    box-shadow: 0 4px 12px rgba(0,0,0,0.15);
    transition: all 0.3s ease;
}
"""

# JavaScript for gallery interactions
gallery_js = """
<script>
function viewNovel(novelId) {
    // Update the hidden state
    document.querySelector('#selected_novel_view textarea').value = novelId;
    document.querySelector('#selected_novel_view textarea').dispatchEvent(new Event('input', { bubbles: true }));
}

function downloadNovel(novelId) {
    // Update the hidden state for download
    document.querySelector('#selected_novel_download textarea').value = novelId;
    document.querySelector('#selected_novel_download textarea').dispatchEvent(new Event('input', { bubbles: true }));
}
</script>
"""

# Create Gradio Interface
def create_interface():
    with gr.Blocks(css=custom_css, title="SOMA Novel Writing System") as interface:
        gr.HTML("""
        <div class="main-header">
            <h1 style="font-size: 2.5em; margin-bottom: 10px;">
                📚 SOMA Novel Writing System
            </h1>
            <h3 style="color: #ccc; margin-bottom: 20px;">
                AI Collaborative Novel Generation - 50 Page Novella Creator
            </h3>
            <p style="font-size: 1.1em; color: #ddd; max-width: 800px; margin: 0 auto;">
                Enter a theme or prompt, and watch as 13 AI agents collaborate to create a complete 50-page novella.
                The system includes 1 Director, 1 Critic, and 10 Writers working in harmony.
                All progress is automatically saved and can be resumed anytime.
            </p>
        </div>
        """)
        
        # State management
        current_session_id = gr.State(None)
        selected_novel_view = gr.Textbox(visible=False, elem_id="selected_novel_view")
        selected_novel_download = gr.Textbox(visible=False, elem_id="selected_novel_download")
        
        with gr.Row():
            with gr.Column(scale=1):
                with gr.Group(elem_classes=["input-section"]):
                    query_input = gr.Textbox(
                        label="Novel Theme / 소설 주제",
                        placeholder="Enter your novel theme or initial idea...\n소설의 주제나 초기 아이디어를 입력하세요...",
                        lines=4
                    )
                    
                    language_select = gr.Radio(
                        choices=["English", "Korean"],
                        value="English",
                        label="Language / 언어"
                    )
                    
                    with gr.Row():
                        submit_btn = gr.Button("🚀 Start Writing / 작성 시작", variant="primary", scale=2)
                        clear_btn = gr.Button("🗑️ Clear / 초기화", scale=1)
                    
                    status_text = gr.Textbox(
                        label="Status",
                        interactive=False,
                        value="🔄 Ready"
                    )
                    
                    # Session management
                    with gr.Group(elem_classes=["session-section"]):
                        gr.Markdown("### 💾 Resume Previous Session / 이전 세션 재개")
                        session_dropdown = gr.Dropdown(
                            label="Select Session / 세션 선택",
                            choices=[],
                            interactive=True
                        )
                        with gr.Row():
                            refresh_btn = gr.Button("🔄 Refresh / 새로고침", scale=1)
                            resume_btn = gr.Button("▶️ Resume / 재개", variant="secondary", scale=1)
        
        with gr.Column(scale=2):
            with gr.Tab("📝 Writing Process / 작성 과정"):
                stages_display = gr.Markdown(
                    value="Process will appear here...",
                    elem_id="stages-display"
                )
            
            with gr.Tab("📖 Final Novel / 최종 소설"):
                novel_output = gr.Markdown(
                    value="",
                    elem_id="novel-output"
                )
                
                with gr.Group(elem_classes=["download-section"]):
                    gr.Markdown("### 📥 Download Novel / 소설 다운로드")
                    with gr.Row():
                        format_select = gr.Radio(
                            choices=["DOCX", "TXT"],
                            value="DOCX" if DOCX_AVAILABLE else "TXT",
                            label="Format / 형식"
                        )
                        download_btn = gr.Button("⬇️ Download / 다운로드", variant="secondary")
                    
                    download_file = gr.File(
                        label="Downloaded File / 다운로드된 파일",
                        visible=False
                    )
            
            with gr.Tab("🎨 Gallery / 갤러리"):
                with gr.Row():
                    gallery_language = gr.Radio(
                        choices=["All", "English", "Korean"],
                        value="All",
                        label="Filter by Language / 언어별 필터"
                    )
                    refresh_gallery_btn = gr.Button("🔄 Refresh Gallery / 갤러리 새로고침")
                
                gallery_display = gr.HTML(
                    value="<div class='gallery-container'>Loading gallery...</div>",
                    elem_classes=["gallery-container"]
                )
                
                # JavaScript injection
                gr.HTML(gallery_js)
                
                # Gallery viewer
                novel_view_content = gr.Markdown(
                    value="",
                    elem_id="novel-view-content",
                    visible=False
                )
                
                with gr.Row(visible=False) as gallery_download_row:
                    gallery_format_select = gr.Radio(
                        choices=["DOCX", "TXT"],
                        value="DOCX" if DOCX_AVAILABLE else "TXT",
                        label="Download Format"
                    )
                    download_from_gallery_btn = gr.Button(
                        "📥 Download Selected Novel",
                        elem_id="download_from_gallery_btn"
                    )
                
                gallery_download_file = gr.File(
                    label="Downloaded File",
                    visible=False
                )
        
        # Hidden state for novel text
        novel_text_state = gr.State("")
        
        # Examples
        with gr.Row():
            gr.Examples(
                examples=[
                    ["A scientist discovers a portal to parallel universes but each journey erases a memory"],
                    ["In a world where dreams can be traded, a dream thief must steal the emperor's nightmare"],
                    ["Two AI entities fall in love while trying to prevent a global cyber war"],
                    ["미래 도시에서 기억을 거래하는 상인과 모든 기억을 잃은 탐정의 이야기"],
                    ["시간이 거꾸로 흐르는 마을에서 일어나는 미스터리한 살인 사건"],
                    ["책 속으로 들어갈 수 있는 능력을 가진 사서의 모험"]
                ],
                inputs=query_input,
                label="💡 Example Themes / 예제 주제"
            )
        
        # Event handlers
        def update_novel_state(stages, novel, status):
            return stages, novel, status, novel
        
        def refresh_sessions():
            try:
                sessions = get_active_sessions("English")
                return gr.update(choices=sessions)
            except Exception as e:
                logger.error(f"Error refreshing sessions: {str(e)}")
                return gr.update(choices=[])
        
        def refresh_gallery(language_filter):
            """Refresh gallery display"""
            lang = None if language_filter == "All" else language_filter
            return get_gallery_html(lang)
        
        def handle_novel_view(novel_id, language):
            """Handle novel view selection"""
            if novel_id:
                content, success = view_novel(novel_id, language)
                if success:
                    return gr.update(visible=True), content, gr.update(visible=True)
            return gr.update(visible=False), "", gr.update(visible=False)
        
        def handle_novel_download(novel_id, format_type):
            """Handle novel download from gallery"""
            if novel_id:
                file_path = download_novel_from_gallery(novel_id, format_type)
                if file_path:
                    return gr.update(value=file_path, visible=True)
            return gr.update(visible=False)
        
        submit_btn.click(
            fn=process_query,
            inputs=[query_input, language_select, current_session_id],
            outputs=[stages_display, novel_output, status_text]
        ).then(
            fn=update_novel_state,
            inputs=[stages_display, novel_output, status_text],
            outputs=[stages_display, novel_output, status_text, novel_text_state]
        )
        
        resume_btn.click(
            fn=lambda x: x,
            inputs=[session_dropdown],
            outputs=[current_session_id]
        ).then(
            fn=resume_session,
            inputs=[current_session_id, language_select],
            outputs=[stages_display, novel_output, status_text]
        )
        
        refresh_btn.click(
            fn=refresh_sessions,
            outputs=[session_dropdown]
        )
        
        clear_btn.click(
            fn=lambda: ("", "", "🔄 Ready", "", None, "", ""),
            outputs=[stages_display, novel_output, status_text, novel_text_state, current_session_id, selected_novel_view, selected_novel_download]
        )
        
        def handle_download(novel_text, format_type, language):
            if not novel_text:
                return gr.update(visible=False)
            
            file_path = download_novel(novel_text, format_type, language)
            if file_path:
                return gr.update(value=file_path, visible=True)
            else:
                return gr.update(visible=False)
        
        download_btn.click(
            fn=handle_download,
            inputs=[novel_text_state, format_select, language_select],
            outputs=[download_file]
        )
        
        # Gallery event handlers
        refresh_gallery_btn.click(
            fn=refresh_gallery,
            inputs=[gallery_language],
            outputs=[gallery_display]
        )
        
        gallery_language.change(
            fn=refresh_gallery,
            inputs=[gallery_language],
            outputs=[gallery_display]
        )
        
        # Handle novel view selection
        selected_novel_view.change(
            fn=handle_novel_view,
            inputs=[selected_novel_view, language_select],
            outputs=[novel_view_content, novel_view_content, gallery_download_row]
        )
        
        # Handle novel download selection
        selected_novel_download.change(
            fn=handle_novel_download,
            inputs=[selected_novel_download, gallery_format_select],
            outputs=[gallery_download_file]
        )
        
        # Direct download button from gallery
        download_from_gallery_btn.click(
            fn=handle_novel_download,
            inputs=[selected_novel_view, gallery_format_select],
            outputs=[gallery_download_file]
        )
        
        # Load sessions and gallery on startup
        interface.load(
            fn=refresh_sessions,
            outputs=[session_dropdown]
        ).then(
            fn=lambda: refresh_gallery("All"),
            outputs=[gallery_display]
        )
    
    return interface

# Main execution
if __name__ == "__main__":
    logger.info("Starting SOMA Novel Writing System...")
    
    # Initialize database on startup
    logger.info("Initializing database...")
    NovelDatabase.init_db()
    logger.info("Database initialized successfully.")
    
    interface = create_interface()
    
    interface.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False,
        debug=True
    )