app.py

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

# --- 로깅 설정 ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
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
    from docx.oxml.ns import qn
    from docx.oxml import OxmlElement
    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", "")
BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
MODEL_ID = "dep89a2fld32mcm"
DB_PATH = "novel_sessions_v7.db"

# 목표 분량 설정 (기존 값으로 복원)
TARGET_WORDS = 8000  # 안전 마진을 위해 8000단어
MIN_WORDS_PER_WRITER = 800  # 각 작가 최소 분량 800단어

# --- 환경 변수 검증 ---
if not FRIENDLI_TOKEN:
    logger.error("FRIENDLI_TOKEN not set. Application will not work properly.")
    FRIENDLI_TOKEN = "dummy_token_for_testing"

if not BRAVE_SEARCH_API_KEY:
    logger.warning("BRAVE_SEARCH_API_KEY not set. Web search features will be disabled.")

# --- 전역 변수 ---
db_lock = threading.Lock()

# 서사 진행 단계 정의
NARRATIVE_PHASES = [
    "도입: 일상과 균열",
    "발전 1: 불안의 고조",
    "발전 2: 외부 충격",
    "발전 3: 내적 갈등 심화",
    "절정 1: 위기의 정점",
    "절정 2: 선택의 순간",
    "하강 1: 결과와 여파",
    "하강 2: 새로운 인식",
    "결말 1: 변화된 일상",
    "결말 2: 열린 질문"
]

# 편집자 단계 사용 여부 (False로 설정하면 편집자 단계 건너뛰기)
USE_EDITOR_STAGE = False  # 편집자가 과도하게 삭제하는 문제로 비활성화

# 단계별 구성 - 편집자 단계 조건부 포함
PROGRESSIVE_STAGES = [
    ("director", "🎬 감독자: 통합된 서사 구조 기획"),
    ("critic", "📝 비평가: 서사 진행성과 깊이 검토"),
    ("director", "🎬 감독자: 수정된 마스터플랜"),
] + [
    (f"writer{i}", f"✍️ 작가 {i}: 초안 - {NARRATIVE_PHASES[i-1]}")
    for i in range(1, 11)
] + [
    ("critic", "📝 비평가: 중간 검토 (서사 누적성과 변화)"),
] + [
    (f"writer{i}", f"✍️ 작가 {i}: 수정본 - {NARRATIVE_PHASES[i-1]}")
    for i in range(1, 11)
]

# 편집자 단계 조건부 추가
if USE_EDITOR_STAGE:
    PROGRESSIVE_STAGES.extend([
        ("editor", "✂️ 편집자: 반복 제거 및 서사 재구성"),
        ("critic", f"📝 비평가: 최종 검토 및 문학적 평가"),
    ])
else:
    PROGRESSIVE_STAGES.append(
        ("critic", f"📝 비평가: 최종 검토 및 문학적 평가"),
    )

# 절대 금지사항 - 언어 오류 방지 (간소화)
STRICT_RULES = """
금지사항:
1. 일본어, 중국어 등 외국어 문자 사용 금지
2. 이전 단계 사건의 단순 반복 금지
3. 캐릭터 이름 변경 금지
"""

# --- 데이터 클래스 ---
@dataclass
class CharacterArc:
    """인물의 변화 궤적 추적"""
    name: str
    initial_state: Dict[str, Any]  # 초기 상태
    phase_states: Dict[int, Dict[str, Any]] = field(default_factory=dict)  # 단계별 상태
    transformations: List[str] = field(default_factory=list)  # 주요 변화들
    relationships_evolution: Dict[str, List[str]] = field(default_factory=dict)  # 관계 변화

@dataclass
class PlotThread:
    """플롯 라인 추적"""
    thread_id: str
    description: str
    introduction_phase: int
    development_phases: List[int]
    resolution_phase: Optional[int]
    status: str = "active"  # active, resolved, suspended

@dataclass
class SymbolicEvolution:
    """상징의 의미 변화 추적"""
    symbol: str
    initial_meaning: str
    phase_meanings: Dict[int, str] = field(default_factory=dict)
    transformation_complete: bool = False

@dataclass
class CharacterConsistency:
    """캐릭터 일관성 관리"""
    primary_names: Dict[str, str] = field(default_factory=dict)  # role -> canonical name
    aliases: Dict[str, List[str]] = field(default_factory=dict)  # canonical -> aliases
    name_history: List[Tuple[int, str, str]] = field(default_factory=list)  # (phase, role, used_name)
    
    def validate_name(self, phase: int, role: str, name: str) -> bool:
        """이름 일관성 검증"""
        if role in self.primary_names:
            canonical = self.primary_names[role]
            if name != canonical and name not in self.aliases.get(canonical, []):
                return False
        return True
    
    def register_name(self, phase: int, role: str, name: str):
        """이름 등록"""
        if role not in self.primary_names:
            self.primary_names[role] = name
        self.name_history.append((phase, role, name))


# --- 핵심 로직 클래스 ---
class LanguageFilter:
    """언어 혼입 및 특수기호 오류 방지"""
    def __init__(self):
        self.forbidden_patterns = [
            r'[ぁ-ん]+',  # 히라가나
            r'[ァ-ヶ]+',  # 가타카나  
            r'[\u4e00-\u9fff]+',  # 한자
            r'\$\s*[.,]',  # 특수기호 오류
            r'[는은이가을를에의와과도로부터까지만든한다]\s*\$'  # 조사 뒤 특수기호
        ]
        
    def clean_text(self, text: str) -> str:
        """생성된 텍스트 정제"""
        import re
        cleaned = text
        
        # 일본어 문자 제거
        for pattern in self.forbidden_patterns:
            cleaned = re.sub(pattern, '', cleaned)
            
        # 연속 공백 정리
        cleaned = re.sub(r'\s+', ' ', cleaned)
        
        # 문장 끝 정리
        cleaned = re.sub(r'([.!?])\s*\$', r'\1', cleaned)
        
        return cleaned.strip()


class ContentDeduplicator:
    """중복 콘텐츠 감지 및 제거"""
    def __init__(self):
        self.seen_paragraphs = set()
        self.seen_key_phrases = set()
        self.similarity_threshold = 0.85
        
    def check_similarity(self, text1: str, text2: str) -> float:
        """두 텍스트의 유사도 측정"""
        # 간단한 Jaccard 유사도 구현
        words1 = set(text1.lower().split())
        words2 = set(text2.lower().split())
        
        intersection = words1.intersection(words2)
        union = words1.union(words2)
        
        return len(intersection) / len(union) if union else 0
    
    def extract_key_phrases(self, text: str) -> List[str]:
        """핵심 문구 추출"""
        # 20자 이상의 문장들을 핵심 문구로 간주
        sentences = [s.strip() for s in re.split(r'[.!?]', text) if len(s.strip()) > 20]
        return sentences[:5]  # 상위 5개만
    
    def is_duplicate(self, paragraph: str) -> bool:
        """중복 문단 감지"""
        # 핵심 문구 체크
        key_phrases = self.extract_key_phrases(paragraph)
        for phrase in key_phrases:
            if phrase in self.seen_key_phrases:
                return True
                
        # 전체 문단 유사도 체크
        for seen in self.seen_paragraphs:
            if self.check_similarity(paragraph, seen) > self.similarity_threshold:
                return True
                
        # 중복이 아니면 저장
        self.seen_paragraphs.add(paragraph)
        self.seen_key_phrases.update(key_phrases)
        return False
    
    def get_used_elements(self) -> List[str]:
        """사용된 핵심 요소 반환"""
        return list(self.seen_key_phrases)[:10]  # 최근 10개
    
    def count_repetitions(self, content: str) -> int:
        """텍스트 내의 반복 횟수 계산"""
        paragraphs = content.split('\n\n')
        repetitions = 0
        
        for i, para1 in enumerate(paragraphs):
            for para2 in paragraphs[i+1:]:
                if self.check_similarity(para1, para2) > 0.7:
                    repetitions += 1
                    
        return repetitions


class RealTimeConsistencyChecker:
    """실시간 서사 일관성 검증"""
    def __init__(self):
        self.plot_graph = {}  # 인과관계 그래프
        self.character_states = {}  # 캐릭터 상태 추적
        self.event_timeline = []  # 시간순 이벤트
        self.resolved_conflicts = set()  # 해결된 갈등
        
    def validate_new_content(self, phase: int, content: str, 
                           previous_contents: List[str]) -> Tuple[bool, List[str]]:
        """새 콘텐츠의 일관성 검증"""
        issues = []
        
        # 1. 시간 역행 검사
        time_markers = self.extract_time_markers(content)
        if self.check_time_contradiction(time_markers):
            issues.append("시간 순서 모순 발견")
            
        # 2. 캐릭터 상태 모순 검사
        character_actions = self.extract_character_actions(content)
        for char, action in character_actions.items():
            if not self.is_action_possible(char, action, phase):
                issues.append(f"{char}의 행동이 이전 상태와 모순됨")
                
        # 3. 이미 해결된 갈등의 재등장 검사
        conflicts = self.extract_conflicts(content)
        for conflict in conflicts:
            if conflict in self.resolved_conflicts:
                issues.append(f"이미 해결된 갈등 '{conflict}'이 다시 등장")
                
        return len(issues) == 0, issues
    
    def extract_time_markers(self, content: str) -> List[str]:
        """시간 표지 추출"""
        markers = re.findall(r'(아침|점심|저녁|밤|새벽|오전|오후|다음날|며칠 후|일주일 후)', content)
        return markers
    
    def extract_character_actions(self, content: str) -> Dict[str, str]:
        """캐릭터 행동 추출"""
        actions = {}
        # 간단한 패턴 매칭 (실제로는 더 정교한 NLP 필요)
        patterns = re.findall(r'(\w+)(?:이|가|은|는)\s+(\w+(?:했다|한다|하다))', content)
        for char, action in patterns:
            actions[char] = action
        return actions
    
    def extract_conflicts(self, content: str) -> List[str]:
        """갈등 요소 추출"""
        conflict_keywords = ['갈등', '대립', '충돌', '문제', '위기']
        conflicts = []
        for keyword in conflict_keywords:
            if keyword in content:
                # 주변 문맥 추출
                idx = content.index(keyword)
                context = content[max(0, idx-20):min(len(content), idx+20)]
                conflicts.append(context)
        return conflicts
    
    def check_time_contradiction(self, markers: List[str]) -> bool:
        """시간 모순 검사"""
        # 간단한 시간 순서 체크
        time_order = ['새벽', '아침', '오전', '점심', '오후', '저녁', '밤']
        prev_idx = -1
        for marker in markers:
            if marker in time_order:
                curr_idx = time_order.index(marker)
                if curr_idx < prev_idx:
                    return True
                prev_idx = curr_idx
        return False
    
    def is_action_possible(self, character: str, action: str, phase: int) -> bool:
        """캐릭터 행동 가능성 검사"""
        # 캐릭터 상태 기반 검증
        if character not in self.character_states:
            self.character_states[character] = {"phase": phase, "status": "active"}
            return True
            
        char_state = self.character_states[character]
        # 예: 죽은 캐릭터가 다시 등장하는 경우 등
        if char_state.get("status") == "dead" and "했다" in action:
            return False
            
        return True


class ProgressionMonitor:
    """실시간 서사 진행 모니터링"""
    def __init__(self):
        self.phase_keywords = {}
        self.locations = set()
        self.characters = set()
        
    def count_new_characters(self, content: str, phase: int) -> int:
        """새로운 인물 등장 횟수"""
        # 간단한 고유명사 추출 (대문자로 시작하는 단어)
        potential_names = re.findall(r'\b[A-Z가-힣][a-z가-힣]+\b', content)
        new_chars = set(potential_names) - self.characters
        self.characters.update(new_chars)
        return len(new_chars)
    
    def count_new_locations(self, content: str, phase: int) -> int:
        """새로운 장소 등장 횟수"""
        # 장소 관련 키워드
        location_markers = ['에서', '으로', '에', '의', 'at', 'in', 'to']
        new_locs = 0
        
        for marker in location_markers:
            matches = re.findall(rf'(\S+)\s*{marker}', content)
            for match in matches:
                if match not in self.locations and len(match) > 2:
                    self.locations.add(match)
                    new_locs += 1
                    
        return new_locs
    
    def calculate_content_difference(self, current_phase: int, content: str, previous_content: str) -> float:
        """이전 단계와의 내용 차이 비율"""
        if not previous_content:
            return 1.0
            
        dedup = ContentDeduplicator()
        return 1.0 - dedup.check_similarity(content, previous_content)
    
    def count_repetitions(self, content: str) -> int:
        """반복 횟수 계산"""
        paragraphs = content.split('\n\n')
        repetitions = 0
        
        for i, para1 in enumerate(paragraphs):
            for para2 in paragraphs[i+1:]:
                similarity = ContentDeduplicator().check_similarity(para1, para2)
                if similarity > 0.7:
                    repetitions += 1
                    
        return repetitions
    
    def calculate_progression_score(self, current_phase: int, content: str, previous_content: str = "") -> Dict[str, float]:
        """진행도 점수 계산"""
        
        scores = {
            "new_elements": 0.0,  # 새로운 요소
            "character_growth": 0.0,  # 인물 성장
            "plot_advancement": 0.0,  # 플롯 진전
            "no_repetition": 0.0  # 반복 없음
        }
        
        # 새로운 요소 체크
        new_characters = self.count_new_characters(content, current_phase)
        new_locations = self.count_new_locations(content, current_phase)
        scores["new_elements"] = min(10, (new_characters * 3 + new_locations * 2))
        
        # 성장 관련 키워드
        growth_keywords = ["깨달았다", "이제는", "달라졌다", "새롭게", "비로소", "변했다", "더 이상"]
        growth_count = sum(1 for k in growth_keywords if k in content)
        scores["character_growth"] = min(10, growth_count * 2)
        
        # 플롯 진전 (이전 단계와의 차이)
        if current_phase > 1 and previous_content:
            diff_ratio = self.calculate_content_difference(current_phase, content, previous_content)
            scores["plot_advancement"] = min(10, diff_ratio * 10)
        else:
            scores["plot_advancement"] = 8.0  # 첫 단계는 기본 점수
        
        # 반복 체크 (역산)
        repetition_count = self.count_repetitions(content)
        scores["no_repetition"] = max(0, 10 - repetition_count * 2)
        
        return scores


class ProgressiveNarrativeTracker:
    """서사 진행과 누적을 추적하는 시스템"""
    def __init__(self):
        self.character_arcs: Dict[str, CharacterArc] = {}
        self.plot_threads: Dict[str, PlotThread] = {}
        self.symbolic_evolutions: Dict[str, SymbolicEvolution] = {}
        self.phase_summaries: Dict[int, str] = {}
        self.accumulated_events: List[Dict[str, Any]] = []
        self.thematic_deepening: List[str] = []
        self.philosophical_insights: List[str] = []  # 철학적 통찰 추적
        self.literary_devices: Dict[int, List[str]] = {}  # 문학적 기법 사용 추적
        self.character_consistency = CharacterConsistency()  # 캐릭터 일관성 추가
        self.content_deduplicator = ContentDeduplicator()  # 중복 감지기 추가
        self.progression_monitor = ProgressionMonitor()  # 진행도 모니터 추가
        self.used_expressions: Set[str] = set()  # 사용된 표현 추적
        self.consistency_checker = RealTimeConsistencyChecker()  # 실시간 일관성 체커 추가
        
    def register_character_arc(self, name: str, initial_state: Dict[str, Any]):
        """캐릭터 아크 등록"""
        self.character_arcs[name] = CharacterArc(name=name, initial_state=initial_state)
        self.character_consistency.register_name(0, "protagonist", name)
        logger.info(f"Character arc registered: {name}")
        
    def update_character_state(self, name: str, phase: int, new_state: Dict[str, Any], transformation: str):
        """캐릭터 상태 업데이트 및 변화 기록"""
        if name in self.character_arcs:
            arc = self.character_arcs[name]
            arc.phase_states[phase] = new_state
            arc.transformations.append(f"Phase {phase}: {transformation}")
            logger.info(f"Character {name} transformed in phase {phase}: {transformation}")
            
    def add_plot_thread(self, thread_id: str, description: str, intro_phase: int):
        """새로운 플롯 라인 추가"""
        self.plot_threads[thread_id] = PlotThread(
            thread_id=thread_id,
            description=description,
            introduction_phase=intro_phase,
            development_phases=[]
        )
        
    def develop_plot_thread(self, thread_id: str, phase: int):
        """플롯 라인 발전"""
        if thread_id in self.plot_threads:
            self.plot_threads[thread_id].development_phases.append(phase)
            
    def check_narrative_progression(self, current_phase: int) -> Tuple[bool, List[str]]:
        """서사가 실제로 진행되고 있는지 확인"""
        issues = []
        
        # 1. 캐릭터 변화 확인
        static_characters = []
        for name, arc in self.character_arcs.items():
            if len(arc.transformations) < current_phase // 3:  # 최소 3단계마다 변화 필요
                static_characters.append(name)
        
        if static_characters:
            issues.append(f"다음 인물들의 변화가 부족합니다: {', '.join(static_characters)}")
            
        # 2. 플롯 진행 확인
        unresolved_threads = []
        for thread_id, thread in self.plot_threads.items():
            if thread.status == "active" and len(thread.development_phases) < 2:
                unresolved_threads.append(thread.description)
                
        if unresolved_threads:
            issues.append(f"진전되지 않은 플롯: {', '.join(unresolved_threads)}")
            
        # 3. 상징 발전 확인
        static_symbols = []
        for symbol, evolution in self.symbolic_evolutions.items():
            if len(evolution.phase_meanings) < current_phase // 4:
                static_symbols.append(symbol)
                
        if static_symbols:
            issues.append(f"의미가 발전하지 않은 상징: {', '.join(static_symbols)}")
            
        # 4. 철학적 깊이 확인
        if len(self.philosophical_insights) < current_phase // 2:
            issues.append("철학적 성찰과 인간에 대한 통찰이 부족합니다")
            
        # 5. 문학적 기법 다양성
        unique_devices = set()
        for devices in self.literary_devices.values():
            unique_devices.update(devices)
        if len(unique_devices) < 5:
            issues.append("문학적 기법이 단조롭습니다. 더 다양한 표현 기법이 필요합니다")
            
        # 6. 캐릭터 이름 일관성
        name_issues = []
        for phase, role, name in self.character_consistency.name_history:
            if not self.character_consistency.validate_name(phase, role, name):
                name_issues.append(f"Phase {phase}: {role} 이름 불일치 ({name})")
        if name_issues:
            issues.extend(name_issues)
            
        # 7. 인과관계 체크 (추가)
        if current_phase > 3:
            # 사건의 연쇄성 확인
            if len(self.accumulated_events) < current_phase - 1:
                issues.append("사건 간 인과관계가 불명확합니다. 각 사건이 다음 사건의 원인이 되어야 합니다")
            
        return len(issues) == 0, issues

    def generate_phase_requirements(self, phase: int) -> str:
        """각 단계별 필수 요구사항 생성 (간소화)"""
        requirements = []
        
        # 이전 단계 요약
        if phase > 1 and (phase-1) in self.phase_summaries:
            requirements.append(f"이전 단계 핵심: {self.phase_summaries[phase-1][:200]}...")
            
        # 사용된 표현 목록 (5개만)
        if self.used_expressions:
            requirements.append("\n❌ 다음 표현은 이미 사용됨:")
            for expr in list(self.used_expressions)[-5:]:  # 최근 5개만
                requirements.append(f"- {expr[:50]}...")
            
        # 단계별 특수 요구사항
        phase_name = NARRATIVE_PHASES[phase-1] if phase <= 10 else "수정"
        
        requirements.append(f"\n✅ {phase_name} 필수 포함:")
        requirements.append(f"- 최소 {MIN_WORDS_PER_WRITER}단어 작성")
        requirements.append("- 구체적인 장면 묘사와 대화")
        requirements.append("- 인물의 내면 탐구")
        requirements.append("- 이전 단계의 결과로 시작")
        
        return "\n".join(requirements)
    
    def extract_used_elements(self, content: str):
        """사용된 핵심 표현 추출 및 저장"""
        # 20자 이상의 특징적인 문장들 추출
        sentences = re.findall(r'[^.!?]+[.!?]', content)
        for sent in sentences:
            if len(sent) > 20 and len(sent) < 100:
                self.used_expressions.add(sent.strip())


class NovelDatabase:
    """데이터베이스 관리"""
    @staticmethod
    def init_db():
        with sqlite3.connect(DB_PATH) as conn:
            conn.execute("PRAGMA journal_mode=WAL")
            cursor = conn.cursor()
            
            # 기존 테이블들
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS sessions (
                    session_id TEXT PRIMARY KEY,
                    user_query TEXT NOT NULL,
                    language TEXT NOT NULL,
                    created_at TEXT DEFAULT (datetime('now')),
                    updated_at TEXT DEFAULT (datetime('now')),
                    status TEXT DEFAULT 'active',
                    current_stage INTEGER DEFAULT 0,
                    final_novel TEXT,
                    literary_report TEXT,
                    total_words INTEGER DEFAULT 0,
                    narrative_tracker TEXT
                )
            ''')
            
            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,
                    word_count INTEGER DEFAULT 0,
                    status TEXT DEFAULT 'pending',
                    progression_score REAL DEFAULT 0.0,
                    repetition_score REAL DEFAULT 0.0,
                    consistency_check TEXT,
                    created_at TEXT DEFAULT (datetime('now')),
                    updated_at TEXT DEFAULT (datetime('now')),
                    FOREIGN KEY (session_id) REFERENCES sessions(session_id),
                    UNIQUE(session_id, stage_number)
                )
            ''')
            
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS plot_threads (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT NOT NULL,
                    thread_id TEXT NOT NULL,
                    description TEXT,
                    introduction_phase INTEGER,
                    status TEXT DEFAULT 'active',
                    created_at TEXT DEFAULT (datetime('now')),
                    FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                )
            ''')
            
            # 새로운 테이블: 중복 감지 기록
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS duplicate_detection (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT NOT NULL,
                    phase INTEGER NOT NULL,
                    duplicate_content TEXT,
                    original_phase INTEGER,
                    similarity_score REAL,
                    created_at TEXT DEFAULT (datetime('now')),
                    FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                )
            ''')
            
            # 새로운 테이블: 품질 평가 기록
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS quality_evaluations (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT NOT NULL,
                    evaluation_type TEXT NOT NULL,
                    score REAL,
                    details TEXT,
                    created_at TEXT DEFAULT (datetime('now')),
                    FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                )
            ''')
            
            conn.commit()

    # 기존 메서드들 유지
    @staticmethod
    @contextmanager
    def get_db():
        with db_lock:
            conn = sqlite3.connect(DB_PATH, timeout=30.0)
            conn.row_factory = sqlite3.Row
            try:
                yield conn
            finally:
                conn.close()

    @staticmethod
    def create_session(user_query: str, language: str) -> str:
        session_id = hashlib.md5(f"{user_query}{datetime.now()}".encode()).hexdigest()
        with NovelDatabase.get_db() as conn:
            conn.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',
                   progression_score: float = 0.0, repetition_score: float = 0.0,
                   consistency_check: str = ""):
        word_count = len(content.split()) if content else 0
        with NovelDatabase.get_db() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                INSERT INTO stages (session_id, stage_number, stage_name, role, content, word_count, status, progression_score, repetition_score, consistency_check)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                ON CONFLICT(session_id, stage_number)
                DO UPDATE SET content=?, word_count=?, status=?, stage_name=?, progression_score=?, repetition_score=?, consistency_check=?, updated_at=datetime('now')
            ''', (session_id, stage_number, stage_name, role, content, word_count, status, progression_score, repetition_score, consistency_check,
                  content, word_count, status, stage_name, progression_score, repetition_score, consistency_check))
            
            # 총 단어 수 업데이트
            cursor.execute('''
                UPDATE sessions 
                SET total_words = (
                    SELECT SUM(word_count) 
                    FROM stages 
                    WHERE session_id = ? AND role LIKE 'writer%' AND content IS NOT NULL
                ),
                updated_at = datetime('now'),
                current_stage = ?
                WHERE session_id = ?
            ''', (session_id, stage_number, session_id))
            
            conn.commit()

    @staticmethod
    def get_writer_content(session_id: str) -> str:
        """작가 콘텐츠 가져오기 (수정본 우선)"""
        with NovelDatabase.get_db() as conn:
            all_content = []
            for writer_num in range(1, 11):
                # 수정본이 있으면 수정본을, 없으면 초안을
                row = conn.cursor().execute('''
                    SELECT content FROM stages 
                    WHERE session_id = ? AND role = ? 
                    AND stage_name LIKE '%수정본%'
                    ORDER BY stage_number DESC LIMIT 1
                ''', (session_id, f'writer{writer_num}')).fetchone()
                
                if not row or not row['content']:
                    # 수정본이 없으면 초안 사용
                    row = conn.cursor().execute('''
                        SELECT content FROM stages 
                        WHERE session_id = ? AND role = ? 
                        AND stage_name LIKE '%초안%'
                        ORDER BY stage_number DESC LIMIT 1
                    ''', (session_id, f'writer{writer_num}')).fetchone()
                
                if row and row['content']:
                    all_content.append(row['content'].strip())
                    
            return '\n\n'.join(all_content)

    @staticmethod
    def get_total_words(session_id: str) -> int:
        """총 단어 수 가져오기"""
        with NovelDatabase.get_db() as conn:
            row = conn.cursor().execute(
                'SELECT total_words FROM sessions WHERE session_id = ?', 
                (session_id,)
            ).fetchone()
            return row['total_words'] if row and row['total_words'] else 0

    @staticmethod
    def save_narrative_tracker(session_id: str, tracker: ProgressiveNarrativeTracker):
        """서사 추적기 저장"""
        with NovelDatabase.get_db() as conn:
            tracker_data = json.dumps({
                'character_arcs': {k: asdict(v) for k, v in tracker.character_arcs.items()},
                'plot_threads': {k: asdict(v) for k, v in tracker.plot_threads.items()},
                'phase_summaries': tracker.phase_summaries,
                'thematic_deepening': tracker.thematic_deepening,
                'philosophical_insights': tracker.philosophical_insights,
                'literary_devices': tracker.literary_devices,
                'character_consistency': asdict(tracker.character_consistency),
                'used_expressions': list(tracker.used_expressions)
            })
            conn.cursor().execute(
                'UPDATE sessions SET narrative_tracker = ? WHERE session_id = ?',
                (tracker_data, session_id)
            )
            conn.commit()

    @staticmethod
    def load_narrative_tracker(session_id: str) -> Optional[ProgressiveNarrativeTracker]:
        """서사 추적기 로드"""
        with NovelDatabase.get_db() as conn:
            row = conn.cursor().execute(
                'SELECT narrative_tracker FROM sessions WHERE session_id = ?',
                (session_id,)
            ).fetchone()
            
            if row and row['narrative_tracker']:
                data = json.loads(row['narrative_tracker'])
                tracker = ProgressiveNarrativeTracker()
                
                # 데이터 복원
                for name, arc_data in data.get('character_arcs', {}).items():
                    tracker.character_arcs[name] = CharacterArc(**arc_data)
                for thread_id, thread_data in data.get('plot_threads', {}).items():
                    tracker.plot_threads[thread_id] = PlotThread(**thread_data)
                tracker.phase_summaries = data.get('phase_summaries', {})
                tracker.thematic_deepening = data.get('thematic_deepening', [])
                tracker.philosophical_insights = data.get('philosophical_insights', [])
                tracker.literary_devices = data.get('literary_devices', {})
                
                # 캐릭터 일관성 복원
                if 'character_consistency' in data:
                    tracker.character_consistency = CharacterConsistency(**data['character_consistency'])
                    
                # 사용된 표현 복원
                if 'used_expressions' in data:
                    tracker.used_expressions = set(data['used_expressions'])
                
                return tracker
        return None

    @staticmethod
    def save_duplicate_detection(session_id: str, phase: int, duplicate_content: str, 
                                original_phase: int, similarity_score: float):
        """중복 감지 기록 저장"""
        with NovelDatabase.get_db() as conn:
            conn.cursor().execute('''
                INSERT INTO duplicate_detection 
                (session_id, phase, duplicate_content, original_phase, similarity_score)
                VALUES (?, ?, ?, ?, ?)
            ''', (session_id, phase, duplicate_content, original_phase, similarity_score))
            conn.commit()

    @staticmethod
    def save_quality_evaluation(session_id: str, evaluation_type: str, score: float, details: str):
        """품질 평가 저장"""
        with NovelDatabase.get_db() as conn:
            conn.cursor().execute('''
                INSERT INTO quality_evaluations
                (session_id, evaluation_type, score, details)
                VALUES (?, ?, ?, ?)
            ''', (session_id, evaluation_type, score, details))
            conn.commit()

    @staticmethod
    def get_session(session_id: str) -> Optional[Dict]:
        with NovelDatabase.get_db() as conn:
            row = conn.cursor().execute('SELECT * FROM sessions WHERE session_id = ?', (session_id,)).fetchone()
            return dict(row) if row else None

    @staticmethod
    def get_stages(session_id: str) -> List[Dict]:
        with NovelDatabase.get_db() as conn:
            rows = conn.cursor().execute('SELECT * FROM stages WHERE session_id = ? ORDER BY stage_number', (session_id,)).fetchall()
            return [dict(row) for row in rows]

    @staticmethod
    def update_final_novel(session_id: str, final_novel: str, literary_report: str = ""):
        with NovelDatabase.get_db() as conn:
            conn.cursor().execute(
                "UPDATE sessions SET final_novel = ?, status = 'complete', updated_at = datetime('now'), literary_report = ? WHERE session_id = ?",
                (final_novel, literary_report, session_id)
            )
            conn.commit()

    @staticmethod
    def get_active_sessions() -> List[Dict]:
        with NovelDatabase.get_db() as conn:
            rows = conn.cursor().execute(
                """SELECT session_id, user_query, language, created_at, current_stage, 
                   COALESCE(total_words, 0) as total_words 
                   FROM sessions 
                   WHERE status = 'active' 
                   ORDER BY updated_at DESC 
                   LIMIT 10"""
            ).fetchall()
            return [dict(row) for row in rows]
    

class WebSearchIntegration:
    """웹 검색 기능"""
    def __init__(self):
        self.brave_api_key = BRAVE_SEARCH_API_KEY
        self.search_url = "https://api.search.brave.com/res/v1/web/search"
        self.enabled = bool(self.brave_api_key)

    def search(self, query: str, count: int = 3, language: str = "en") -> List[Dict]:
        if not self.enabled:
            return []
        headers = {
            "Accept": "application/json",
            "X-Subscription-Token": self.brave_api_key
        }
        params = {
            "q": query,
            "count": count,
            "search_lang": "ko" if language == "Korean" else "en",
            "text_decorations": False,
            "safesearch": "moderate"
        }
        try:
            response = requests.get(self.search_url, headers=headers, params=params, timeout=10)
            response.raise_for_status()
            results = response.json().get("web", {}).get("results", [])
            return results
        except requests.exceptions.RequestException as e:
            logger.error(f"웹 검색 API 오류: {e}")
            return []

    def extract_relevant_info(self, results: List[Dict], max_chars: int = 1500) -> str:
        if not results:
            return ""
        extracted = []
        total_chars = 0
        for i, result in enumerate(results[:3], 1):
            title = result.get("title", "")
            description = result.get("description", "")
            info = f"[{i}] {title}: {description}"
            if total_chars + len(info) < max_chars:
                extracted.append(info)
                total_chars += len(info)
            else:
                break
        return "\n".join(extracted)


class ProgressiveLiterarySystem:
    """진행형 문학 소설 생성 시스템"""
    def __init__(self):
        self.token = FRIENDLI_TOKEN
        self.api_url = API_URL
        self.model_id = MODEL_ID
        self.narrative_tracker = ProgressiveNarrativeTracker()
        self.web_search = WebSearchIntegration()
        self.language_filter = LanguageFilter()  # 언어 필터 추가
        self.current_session_id = None
        NovelDatabase.init_db()

    def augment_prompt_if_needed(self, user_query: str, language: str) -> str:
        """프롬프트 증강 - 특별한 지시가 없을 때 예시 형식으로 증강"""
        # 특별한 지시 키워드 체크
        special_keywords = ['인과관계', '캐릭터 일관성', '설정 일관성', '문체 일관성', 
                          'causality', 'character consistency', 'setting consistency', 'style consistency']
        
        has_special_instruction = any(keyword in user_query.lower() for keyword in special_keywords)
        
        if has_special_instruction:
            return user_query
        
        # 특별한 지시가 없으면 예시 형식으로 증강
        example_augmentation = {
            "Korean": f"""인과관계 치밀함: {user_query}. 모든 사건은 필연적 인과관계로 연결되며, 외부 충격이 내적 갈등을 심화시키고, 각 선택이 다음 국면을 결정한다. 우연은 없고 모든 장면이 결말을 향한 필수 요소가 된다.
캐릭터 일관성: 주인공은 처음부터 끝까지 핵심 가치관을 유지하되, 사건을 통해 그 가치관의 새로운 면을 발견한다. 각 인물은 고유한 말투와 행동 패턴을 가지며, 갈등 상황에서도 캐릭터의 본질에서 벗어나지 않는다.
설정 일관성: 핵심 상징물은 이야기 전체를 관통하며 점진적으로 의미가 확장된다. 공간과 시간 설정은 단순한 배경이 아니라 서사의 필수 요소로 기능한다.
문체 일관성: 선택한 서술 시점과 문체 톤을 끝까지 유지하되, 서사의 흐름에 따라 리듬과 호흡을 조절한다. 장르적 특성을 살린 문체로 독자를 몰입시킨다.""",
            
            "English": f"""Causal Tightness: {user_query}. All events connect through necessary causality, external shocks deepen internal conflicts, each choice determines the next phase. No coincidences - every scene is essential to the conclusion.
Character Consistency: Protagonist maintains core values throughout while discovering new facets through events. Each character has unique speech patterns and behaviors, staying true to essence even in conflict.
Setting Consistency: Core symbols pervade the entire story with gradually expanding meanings. Space and time settings function as narrative necessities, not mere backdrops.
Style Consistency: Maintain chosen POV and tone throughout while adjusting rhythm and pacing to narrative flow. Genre-appropriate style immerses readers."""
        }
        
        return example_augmentation.get(language, example_augmentation["Korean"])

    def create_headers(self):
        return {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}

    # --- 프롬프트 생성 함수들 ---
    def create_director_initial_prompt(self, user_query: str, language: str) -> str:
        """감독자 초기 기획 - 통합된 서사 구조"""
        # 프롬프트 증강 - 특별한 지시가 없을 때 예시 형식으로 증강
        augmented_query = self.augment_prompt_if_needed(user_query, language)
        
        search_results_str = ""
        if self.web_search.enabled:
            # 철학적 키워드 추가 (쿼리 길이 제한)
            short_query = user_query[:50] if len(user_query) > 50 else user_query
            queries = [
                f"{short_query} 철학적 의미",  # 철학적 관점
                f"인간 존재 의미 {short_query}",  # 실존적 주제
                f"{short_query} 문학 작품",
            ]
            for q in queries[:2]:  # 2개까지만 검색
                try:
                    results = self.web_search.search(q, count=2, language=language)
                    if results:
                        search_results_str += self.web_search.extract_relevant_info(results)[:500] + "\n"
                except Exception as e:
                    logger.warning(f"검색 쿼리 실패: {q[:50]}... - {str(e)}")
                    continue
    
        lang_prompts = {
            "Korean": f"""당신은 노벨문학상 수상작가 수준의 한국 문학 거장입니다. 
중편 소설(8,000단어)을 위한 통합된 서사 구조를 기획하세요.

**주제:** {augmented_query}

**참고 자료:**
{search_results_str[:500] if search_results_str else "N/A"}

**필수 요구사항:**

1. **인과관계가 치밀한 통합 서사**
   - 10개 단계가 필연적으로 연결된 단일 서사
   - 각 단계는 이전 단계의 직접적 결과로 이어짐
   - 외부 충격과 내적 갈등의 인과관계 명확히
   - 주인공과 조연들의 이름/설정 처음부터 고정
   
   단계별 진행:
   1) 도입: 일상과 균열
   2) 발전 1: 불안의 고조
   3) 발전 2: 외부 충격
   4) 발전 3: 내적 갈등 심화
   5) 절정 1: 위기의 정점
   6) 절정 2: 선택의 순간
   7) 하강 1: 결과와 여파
   8) 하강 2: 새로운 인식
   9) 결말 1: 변화된 일상
   10) 결말 2: 열린 질문

2. **캐릭터 일관성과 입체성**
   - 각 인물의 핵심 가치관/성격 명시
   - 주인공: 초기 → 중간 → 최종 상태의 변화 궤적
   - 조연들: 고유한 말투와 행동 패턴 설정
   - 갈등이 인물의 본질을 드러내도록 설계

3. **설정과 상징의 일관된 활용**
   - 핵심 상징물(1-2개)의 의미 변화 추적
   - 공간/시간 설정의 서사적 기능 명시
   - 반복되는 모티프의 점진적 의미 확장

4. **문체 일관성 계획**
   - 서술 시점과 문체 톤 결정
   - 장르적 특성을 살린 문체 전략
   - 리듬과 호흡의 변주 계획

5. **분량 계획**
   - 총 8,000단어
   - 각 단계 800단어

치밀하고 유기적인 계획을 제시하세요.""",

            "English": f"""You are a Nobel Prize-winning literary master.
Plan an integrated narrative structure for a novella (8,000 words).

**Theme:** {augmented_query}

**Reference:**
{search_results_str[:500] if search_results_str else "N/A"}

**Requirements:**

1. **Causally Tight Integrated Structure**
   - 10 phases connected by necessity
   - Each phase as direct result of previous
   - Clear external conflicts and internal struggles
   - Fixed protagonist/supporting cast names

2. **Character Consistency & Depth**
   - Core values/personality for each character
   - Protagonist's transformation trajectory
   - Unique speech patterns and behaviors
   - Conflicts reveal character essence

3. **Consistent Settings & Symbols**
   - 1-2 core symbols with evolving meanings
   - Narrative function of space/time settings
   - Progressive expansion of recurring motifs

4. **Stylistic Consistency Plan**
   - Narrative POV and tone decisions
   - Genre-appropriate style strategy
   - Rhythm and pacing variations

5. **Length Plan**
   - Total 8,000 words
   - 800 words per phase

Present precise, organic plan."""
        }
    
        return lang_prompts.get(language, lang_prompts["Korean"])

    def create_writer_prompt_enhanced(self, writer_number: int, director_plan: str, 
                                    previous_content: str, phase_requirements: str,
                                    narrative_summary: str, language: str,
                                    used_elements: List[str]) -> str:
        """강화된 작가 프롬프트 - 분량 문제 해결"""
        
        phase_name = NARRATIVE_PHASES[writer_number-1]
        target_words = MIN_WORDS_PER_WRITER
        
        # 현재까지 총 단어 수
        total_words = NovelDatabase.get_total_words(self.current_session_id) if self.current_session_id else 0
        remaining_words = TARGET_WORDS - total_words
        
        lang_prompts = {
            "Korean": f"""당신은 작가 {writer_number}번입니다. 
**현재 단계: {phase_name}**

**전체 계획 (요약):**
{director_plan[:800]}

**이전 내용:**
{previous_content[-800:] if previous_content else "시작"}

**현재 진행 상황:**
- 현재까지 총 단어: {total_words}
- 목표까지 남은 단어: {remaining_words}
- 이번 단계 최소 단어: {target_words}

**작성 지침:**

1. **필수 분량: {target_words}-1000 단어**
   
2. **서사의 필연성 확보:**
   - 이전 단계의 직접적 결과로 시작
   - 새로운 사건은 기존 갈등의 논리적 귀결
   - 인물의 선택이 다음 국면을 결정
   - 우연이 아닌 필연으로 전개

3. **캐릭터 일관성 유지:**
   - 설정된 인물명과 관계 엄수
   - 각 인물의 고유 말투 유지
   - 성격의 일관성 속에서 변화 표현
   - 행동이 캐릭터의 본질에서 출발

4. **구체적 장면 구성:**
   - 감각적 묘사 (시각, 청각, 촉각 등)
   - 생생한 대화 (인물별 어투 차별화)
   - 내면 심리의 구체적 표현
   - 공간과 시간의 명확한 설정

5. **금지사항:**
   - 이전 상황 단순 반복
   - 캐릭터 이름/설정 변경
   - 갑작스러운 설정 변화
   - 분량 미달

**중요: 반드시 {target_words}단어 이상, 인과관계가 명확한 서사를 작성하세요!**

이제 시작하세요:""",

            "English": f"""You are Writer #{writer_number}.
**Current Phase: {phase_name}**

**Overall Plan (Summary):**
{director_plan[:800]}

**Previous Content:**
{previous_content[-800:] if previous_content else "Beginning"}

**Progress Status:**
- Total words so far: {total_words}
- Words remaining to target: {remaining_words}
- Minimum words this phase: {target_words}

**Writing Guidelines:**

1. **Required Length: {target_words}-1000 words**

2. **Narrative Necessity:**
   - Start from direct results of previous
   - New events as logical consequences
   - Character choices determine next phase
   - Necessity, not coincidence

3. **Character Consistency:**
   - Maintain established names/relationships
   - Keep unique speech patterns
   - Express change within consistent personality
   - Actions stem from character essence

4. **Concrete Scene Construction:**
   - Sensory descriptions (visual, auditory, tactile)
   - Vivid dialogue (differentiated speech)
   - Specific psychological expression
   - Clear spatial/temporal settings

5. **Forbidden:**
   - Simple repetition
   - Character name/setting changes
   - Sudden setting shifts
   - Under word count

**IMPORTANT: Must write {target_words}+ words with clear causality!**

Begin now:"""
        }
        
        return lang_prompts.get(language, lang_prompts["Korean"])

    def create_critic_consistency_prompt_enhanced(self, all_content: str, 
                                                narrative_tracker: ProgressiveNarrativeTracker,
                                                user_query: str, language: str) -> str:
        """강화된 비평가 중간 검토"""
    
        # 서사 진행 체크
        phase_count = len(narrative_tracker.phase_summaries)
        progression_ok, issues = narrative_tracker.check_narrative_progression(phase_count)
    
        # 중복 감지
        duplicates = []
        paragraphs = all_content.split('\n\n')
        for i, para1 in enumerate(paragraphs[:10]):  # 최근 10개만
            for j, para2 in enumerate(paragraphs[i+1:i+11]):
                if narrative_tracker.content_deduplicator.check_similarity(para1, para2) > 0.7:
                    duplicates.append(f"문단 {i+1}과 문단 {i+j+2} 유사")
        
        # 인과관계 체크 (추가)
        causality_issues = []
        if phase_count > 3:
            # 각 단계가 이전 단계의 결과인지 확인
            if "그러나 갑자기" in all_content or "우연히" in all_content or "뜻밖에" in all_content:
                causality_issues.append("우연적 사건 발생 - 필연적 전개 필요")
        
        lang_prompts = {
            "Korean": f"""서사 진행을 검토하세요.

**원 주제:** {user_query}

**현재 진행:** {phase_count}/10 단계

**발견된 문제:**
{chr(10).join(issues[:5]) if issues else "없음"}

**중복 발견:**
{chr(10).join(duplicates[:3]) if duplicates else "없음"}

**인과관계 문제:**
{chr(10).join(causality_issues) if causality_issues else "없음"}

**검토 항목:**
1. 서사가 필연적으로 진행되는가?
2. 인물이 일관되게 변화하는가?
3. 반복이나 자기복제가 있는가?
4. 각 단계가 이전의 결과인가?
5. 분량이 충분한가?

**판정:** 통과/재작성 필요

치밀한 인과관계와 캐릭터 일관성을 중심으로 평가하세요.""",

        "English": f"""Review narrative progression.

**Theme:** {user_query}

**Progress:** {phase_count}/10 phases

**Issues Found:**
{chr(10).join(issues[:5]) if issues else "None"}

**Duplications:**
{chr(10).join(duplicates[:3]) if duplicates else "None"}

**Causality Issues:**
{chr(10).join(causality_issues) if causality_issues else "None"}

**Review Items:**
1. Is narrative progressing necessarily?
2. Are characters changing consistently?
3. Any repetitions or self-copying?
4. Does each phase result from previous?
5. Sufficient length?

**Verdict:** Pass/Rewrite needed

Evaluate focusing on tight causality and character consistency."""
        }
    
        return lang_prompts.get(language, lang_prompts["Korean"])

    
    def create_writer_revision_prompt(self, writer_number: int, initial_content: str, 
                                   critic_feedback: str, language: str) -> str:
        """작가 수정 프롬프트 (간소화)"""
        target_words = MIN_WORDS_PER_WRITER
        
        lang_prompts = {
            "Korean": f"""작가 {writer_number}번, 수정하세요.

**비평 요점:**
{critic_feedback[:500]}

**수정 방향:**
1. 반복 제거, 새로운 전개 추가
2. 최소 {target_words}단어 유지
3. 인물 변화 구체화
4. 대화와 묘사 추가

전면 재작성이 필요하면 과감히 수정하세요.
수정본만 제시하세요.""",

            "English": f"""Writer #{writer_number}, revise.

**Critique Points:**
{critic_feedback[:500]}

**Revision Direction:**
1. Remove repetition, add new development
2. Maintain {target_words} words minimum
3. Specify character changes
4. Add dialogue and description

Boldly rewrite if needed.
Present only revised version."""
        }
        
        return lang_prompts.get(language, lang_prompts["Korean"])

    def create_editor_prompt(self, complete_novel: str, issues: List[str], language: str) -> str:
       """편집자 프롬프트 - 보존 중심 편집"""
       
       current_word_count = len(complete_novel.split())
       min_words = int(current_word_count * 0.95)  # 95% 이상 유지
       
       lang_prompts = {
           "Korean": f"""당신은 보존을 중시하는 편집자입니다.

**원고 분량: {current_word_count}단어**
**편집 후 최소 분량: {min_words}단어 (필수!)**

**편집 규칙:**

1. **원고 보존이 최우선**
   - 원고의 95% 이상을 반드시 유지
   - 삭제보다는 수정을 우선
   - 전체 문단 삭제는 절대 금지

2. **허용되는 편집:**
   - 완전히 동일한 문장이 연속으로 나올 때만 하나 제거
   - 문법 오류나 오타 수정
   - 연결이 어색한 부분에 접속사 추가 (1-2단어)

3. **절대 금지사항:**
   - 문단 통째로 삭제 ❌
   - 내용 요약이나 축약 ❌
   - 작가의 문체 변경 ❌
   - 줄거리 재구성 ❌

4. **편집 방법:**
   - 중복 문장: 두 번째 것만 제거
   - 어색한 연결: 접속사로 연결
   - 오타: 최소한의 수정

**중요: 거의 모든 내용을 그대로 유지하면서 아주 작은 문제만 수정하세요.**

원고 전체를 다시 작성하지 말고, 원본을 복사한 후 최소한의 수정만 가하세요.

편집된 전체 원고를 제시하세요. ({min_words}단어 이상 필수!)""",

           "English": f"""You are a preservation-focused editor.

**Manuscript length: {current_word_count} words**
**Minimum after editing: {min_words} words (REQUIRED!)**

**Editing Rules:**

1. **Preservation is Priority**
   - Must keep 95%+ of manuscript
   - Prefer correction over deletion
   - Never delete whole paragraphs

2. **Allowed Edits:**
   - Remove only when exact same sentence appears consecutively
   - Fix grammar errors or typos
   - Add conjunctions for awkward connections (1-2 words)

3. **Absolutely Forbidden:**
   - Deleting whole paragraphs ❌
   - Summarizing or abbreviating ❌
   - Changing author's style ❌
   - Restructuring plot ❌

4. **Editing Method:**
   - Duplicates: Remove only second occurrence
   - Awkward connections: Connect with conjunctions
   - Typos: Minimal fixes

**IMPORTANT: Keep almost everything while fixing only tiny issues.**

Don't rewrite the manuscript, copy the original and apply minimal edits.

Present the full edited manuscript. ({min_words}+ words required!)"""
       }
       
       return lang_prompts.get(language, lang_prompts["Korean"])

    def create_critic_final_prompt(self, content: str, query: str, language: str) -> str:
        """최종 비평"""
        
        word_count = len(content.split())
        
        # 서사 구조 분석 (추가)
        has_single_plot = self.check_single_narrative(content)
        character_consistency = self.check_character_consistency_in_final(content)
        
        lang_prompts = {
            "Korean": f"""완성된 소설을 평가하세요.

**주제:** {query}
**분량:** {word_count}단어 (목표: 8,000)

**평가 기준:**
1. 통합된 서사 구조 (30점)
   - 단일한 플롯 존재 여부
   - 인과관계의 치밀함
   - 각 단계의 필연성
   
2. 캐릭터 일관성 (25점)
   - 이름과 설정의 통일성
   - 성격과 행동의 일관성
   - 변화의 설득력
   
3. 문학적 완성도 (25점)
   - 문체의 일관성
   - 상징과 모티프 활용
   - 문학적 기법의 다양성
   
4. 주제 의식과 통찰 (20점)
   - 철학적 깊이
   - 인간에 대한 통찰
   - 독창적 해석

**감점 요인:**
- 플롯 자기복제 (-10점)
- 캐릭터 설정 충돌 (-10점)
- 단순 반복 (-5점)
- 분량 미달 (-5점)

**종합 평가:**
작품이 하나의 완결된 장편소설로 기능하는가?

총점: /100점

작품의 문학적 가치와 구조적 완성도를 종합적으로 평가하세요.""",

            "English": f"""Evaluate the completed novel.

**Theme:** {query}
**Length:** {word_count} words (target: 8,000)

**Criteria:**
1. Integrated Narrative Structure (30 pts)
   - Single plot existence
   - Causal tightness
   - Necessity of each phase
   
2. Character Consistency (25 pts)
   - Name/setting unity
   - Personality/behavior consistency
   - Convincing transformation
   
3. Literary Quality (25 pts)
   - Stylistic consistency
   - Symbol/motif usage
   - Literary technique variety
   
4. Thematic Insight (20 pts)
   - Philosophical depth
   - Human insight
   - Original interpretation

**Deductions:**
- Plot self-replication (-10 pts)
- Character setting conflicts (-10 pts)
- Simple repetition (-5 pts)
- Under length (-5 pts)

**Overall Assessment:**
Does the work function as a complete novel?

Total: /100 points

Comprehensively evaluate literary value and structural completeness."""
        }
        
        return lang_prompts.get(language, lang_prompts["Korean"])

   # --- LLM 호출 함수들 ---
    def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
       full_content = ""
       for chunk in self.call_llm_streaming(messages, role, language):
           full_content += chunk
       if full_content.startswith("❌"):
           raise Exception(f"LLM Call Failed: {full_content}")
       
       # 언어 필터 적용
       filtered_content = self.language_filter.clean_text(full_content)
       return filtered_content

    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, language: str) -> Generator[str, None, None]:
       try:
           system_prompts = self.get_system_prompts(language)
           full_messages = [{"role": "system", "content": system_prompts.get(role, "")}, *messages]
           
           # 작가와 편집자 역할일 때는 더 많은 토큰 허용
           if role.startswith("writer"):
               max_tokens = 25000
           elif role == "editor":
               # 편집자는 원본 길이 + 여유분
               max_tokens = 30000  # 편집자에게 더 많은 토큰 할당
           else:
               max_tokens = 10000
           
           payload = {
               "model": self.model_id,
               "messages": full_messages,
               "max_tokens": max_tokens,
               "temperature": 0.8,
               "top_p": 0.95,
               "presence_penalty": 0.5,
               "frequency_penalty": 0.3,
               "stream": True
           }
           
           response = requests.post(
               self.api_url, 
               headers=self.create_headers(), 
               json=payload, 
               stream=True, 
               timeout=180
           )
           
           if response.status_code != 200:
               yield f"❌ API 오류 (상태 코드: {response.status_code})"
               return
           
           buffer = ""
           for line in response.iter_lines():
               if not line:
                   continue
               
               try:
                   line_str = line.decode('utf-8').strip()
                   if not line_str.startswith("data: "):
                       continue
                   
                   data_str = line_str[6:]
                   if data_str == "[DONE]":
                       break
                   
                   data = json.loads(data_str)
                   choices = data.get("choices", [])
                   if choices and choices[0].get("delta", {}).get("content"):
                       content = choices[0]["delta"]["content"]
                       buffer += content
                       
                       if len(buffer) >= 50 or '\n' in buffer:
                           # 언어 필터 적용
                           clean_buffer = self.language_filter.clean_text(buffer)
                           yield clean_buffer
                           buffer = ""
                           time.sleep(0.01)
                   
               except Exception as e:
                   logger.error(f"청크 처리 오류: {str(e)}")
                   continue
           
           if buffer:
               clean_buffer = self.language_filter.clean_text(buffer)
               yield clean_buffer
               
       except Exception as e:
           logger.error(f"스트리밍 오류: {type(e).__name__}: {str(e)}")
           yield f"❌ 오류 발생: {str(e)}"

    def get_system_prompts(self, language: str) -> Dict[str, str]:
       """역할별 시스템 프롬프트 (간소화)"""
       
       base_prompts = {
           "Korean": {
               "director": """당신은 노벨문학상 수상 작가입니다.
치밀한 인과관계의 단일 서사를 설계하세요.
캐릭터 이름과 설정을 처음부터 명확히 고정하세요.
플롯의 자기복제 없이 필연적 전개를 구축하세요.""",
               
               "critic": """당신은 문학 비평가입니다.
서사의 인과관계와 캐릭터 일관성을 엄격히 검토하세요.
플롯 자기복제와 설정 충돌을 찾아내세요.
작품이 하나의 완결된 소설인지 평가하세요.""",
               
               "writer_base": f"""당신은 한국 문학 작가입니다.
반드시 {MIN_WORDS_PER_WRITER}단어 이상 작성하세요.
이전 단계의 필연적 결과로 시작하세요.
캐릭터 이름과 설정을 절대 변경하지 마세요.
구체적 장면과 생생한 대화로 서사를 전개하세요.""",
               
               "editor": """당신은 원고 보존을 최우선으로 하는 편집자입니다.
원고의 95% 이상을 반드시 유지하세요.
전체 문단을 삭제하지 마세요.
원본을 복사한 후 최소한의 수정만 하세요.
편집 후에도 거의 모든 내용이 남아있어야 합니다."""
           },
           "English": {
               "director": """You are a Nobel Prize-winning author.
Design a single narrative with tight causality.
Fix character names and settings clearly from start.
Build necessary development without plot self-replication.""",
               
               "critic": """You are a literary critic.
Strictly review narrative causality and character consistency.
Find plot self-replication and setting conflicts.
Evaluate if work is one complete novel.""",
               
               "writer_base": f"""You are a literary writer.
Must write at least {MIN_WORDS_PER_WRITER} words.
Start as necessary result of previous phase.
Never change character names or settings.
Develop narrative with concrete scenes and vivid dialogue.""",
               
               "editor": """You are a preservation-focused editor.
Must maintain 95%+ of manuscript.
Never delete whole paragraphs.
Copy original and apply minimal edits only.
Almost all content must remain after editing."""
           }
       }
       
       prompts = base_prompts.get(language, base_prompts["Korean"]).copy()
       
       # 특수 작가 프롬프트
       for i in range(1, 11):
           prompts[f"writer{i}"] = prompts["writer_base"]
       
       return prompts

   # --- 메인 프로세스 ---
    def process_novel_stream(self, query: str, language: str, session_id: Optional[str] = None) -> Generator[Tuple[str, List[Dict[str, Any]], str], None, None]:
       """소설 생성 프로세스"""
       try:
           resume_from_stage = 0
           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
                   # 서사 추적기 복원
                   saved_tracker = NovelDatabase.load_narrative_tracker(session_id)
                   if saved_tracker:
                       self.narrative_tracker = saved_tracker
           else:
               self.current_session_id = NovelDatabase.create_session(query, language)
               logger.info(f"Created new session: {self.current_session_id}")

           stages = []
           if resume_from_stage > 0:
               stages = [{
                   "name": s['stage_name'], 
                   "status": s['status'], 
                   "content": s.get('content', ''),
                   "word_count": s.get('word_count', 0),
                   "progression_score": s.get('progression_score', 0.0),
                   "repetition_score": s.get('repetition_score', 0.0),
                   "consistency_check": s.get('consistency_check', '')
               } for s in NovelDatabase.get_stages(self.current_session_id)]

           # 총 단어 수 추적
           total_words = NovelDatabase.get_total_words(self.current_session_id)

           for stage_idx in range(resume_from_stage, len(PROGRESSIVE_STAGES)):
               role, stage_name = PROGRESSIVE_STAGES[stage_idx]
               if stage_idx >= len(stages):
                   stages.append({
                       "name": stage_name, 
                       "status": "active", 
                       "content": "", 
                       "word_count": 0,
                       "progression_score": 0.0,
                       "repetition_score": 0.0,
                       "consistency_check": ""
                   })
               else:
                   stages[stage_idx]["status"] = "active"

               yield f"🔄 진행 중... (현재 {total_words:,}단어)", stages, self.current_session_id
               
               prompt = self.get_stage_prompt(stage_idx, role, query, language, stages)
               stage_content = ""
               
               for chunk in self.call_llm_streaming([{"role": "user", "content": prompt}], role, language):
                   stage_content += chunk
                   stages[stage_idx]["content"] = stage_content
                   stages[stage_idx]["word_count"] = len(stage_content.split())
                   yield f"🔄 {stage_name} 작성 중... ({total_words + stages[stage_idx]['word_count']:,}단어)", stages, self.current_session_id

               # 작가 역할일 때 단어 수 체크 및 재생성
               if role.startswith("writer"):
                   word_count = len(stage_content.split())
                   writer_num = int(re.search(r'\d+', role).group())
                   
                   # 단어 수가 부족하면 추가 생성 요청
                   if word_count < MIN_WORDS_PER_WRITER * 0.9:  # 90% 미만이면
                       retry_prompt = f"""
현재 {word_count}단어만 작성되었습니다.
최소 {MIN_WORDS_PER_WRITER}단어가 필요합니다.

다음을 추가하여 {MIN_WORDS_PER_WRITER - word_count}단어 이상 더 작성하세요:
- 더 자세한 인물 묘사
- 추가 대화 장면
- 배경과 분위기 묘사
- 인물의 과거 회상
- 내적 독백 확대

기존 내용에 자연스럽게 이어서 작성하세요:
"""
                       
                       additional_content = self.call_llm_sync(
                           [{"role": "user", "content": retry_prompt}], 
                           role, 
                           language
                       )
                       stage_content += "\n\n" + additional_content
                       stages[stage_idx]["content"] = stage_content
                       stages[stage_idx]["word_count"] = len(stage_content.split())
                   
                   # 진행도 평가
                   previous_content = self.get_previous_writer_content(stages, writer_num)
                   
                   # 진행도 점수 계산
                   progression_scores = self.narrative_tracker.progression_monitor.calculate_progression_score(
                       writer_num, stage_content, previous_content
                   )
                   progression_score = sum(progression_scores.values()) / len(progression_scores)
                   stages[stage_idx]["progression_score"] = progression_score
                   
                   # 반복도 점수 계산
                   repetition_score = 10.0 - self.narrative_tracker.progression_monitor.count_repetitions(stage_content)
                   stages[stage_idx]["repetition_score"] = max(0, repetition_score)
                   
                   # 일관성 체크
                   consistency_ok, consistency_issues = self.narrative_tracker.consistency_checker.validate_new_content(
                       writer_num, stage_content, [s["content"] for s in stages[:stage_idx] if s["content"]]
                   )
                   stages[stage_idx]["consistency_check"] = "통과" if consistency_ok else "; ".join(consistency_issues)
                   
                   # 서사 추적기 업데이트
                   self.update_narrative_tracker(stage_content, writer_num)
                   self.narrative_tracker.extract_used_elements(stage_content)

               # 편집 단계 특별 처리
               if role == "editor" and stage_content:
                   # 편집 전후 단어 수 비교
                   original_novel = ""
                   for i in range(1, 11):
                       for s in stages:
                           if f"writer{i}" in s.get("name", "") and "수정본" in s.get("name", "") and s["content"]:
                               original_novel += s["content"] + "\n\n"
                   
                   original_words = len(original_novel.split())
                   edited_words = len(stage_content.split())
                   
                   logger.info(f"편집 결과: {original_words}단어 → {edited_words}단어")
                   
                   # 편집으로 20% 이상 삭제되었다면 원본 사용
                   if edited_words < original_words * 0.8:
                       logger.warning(f"편집자가 과도하게 삭제함 ({100 - (edited_words/original_words*100):.1f}% 삭제). 원본 유지.")
                       stage_content = original_novel
                       stages[stage_idx]["content"] = stage_content
                       stages[stage_idx]["word_count"] = original_words
                       stages[stage_idx]["note"] = "편집 과도로 원본 유지"
               
               stages[stage_idx]["status"] = "complete"
               NovelDatabase.save_stage(
                   self.current_session_id, stage_idx, stage_name, role,
                   stage_content, "complete", 
                   stages[stage_idx].get("progression_score", 0.0),
                   stages[stage_idx].get("repetition_score", 0.0),
                   stages[stage_idx].get("consistency_check", "")
               )
               
               # 서사 추적기 저장
               NovelDatabase.save_narrative_tracker(self.current_session_id, self.narrative_tracker)
               
               # 총 단어 수 업데이트
               total_words = NovelDatabase.get_total_words(self.current_session_id)
               
               # 단어 수 경고
               if role.startswith("writer") and stages[stage_idx]["word_count"] < MIN_WORDS_PER_WRITER:
                   logger.warning(f"단어 수 부족: {stage_name} - {stages[stage_idx]['word_count']}단어")
               
               yield f"✅ {stage_name} 완료 (총 {total_words:,}단어)", stages, self.current_session_id

           # 최종 소설 정리
           final_novel = NovelDatabase.get_writer_content(self.current_session_id)
           
           # 편집자가 처리한 내용이 있으면 그것을 사용
           edited_content = self.get_edited_content(stages)
           if edited_content:
               final_novel = edited_content
               
           final_word_count = len(final_novel.split())
           final_report = self.generate_literary_report(final_novel, query, language)
           
           # 품질 평가 저장
           self.save_quality_evaluation(final_report)
           
           NovelDatabase.update_final_novel(self.current_session_id, final_novel, final_report)
           
           # 최종 단어 수 확인
           if final_word_count < TARGET_WORDS:
               yield f"⚠️ 소설 완성! 총 {final_word_count:,}단어 (목표 미달: {TARGET_WORDS - final_word_count:,}단어 부족)", stages, self.current_session_id
           else:
               yield f"✅ 소설 완성! 총 {final_word_count:,}단어 (목표: {TARGET_WORDS:,}단어 달성!)", stages, self.current_session_id

       except Exception as e:
           logger.error(f"소설 생성 프로세스 오류: {e}", exc_info=True)
           yield f"❌ 오류 발생: {e}", stages if 'stages' in locals() else [], self.current_session_id

    def get_stage_prompt(self, stage_idx, role, query, language, stages):
        """단계별 프롬프트 생성"""
        if stage_idx == 0:
            # 첫 번째 단계 - 감독자 초기 기획
            return self.create_director_initial_prompt(query, language)
        
        elif stage_idx == 1:
            # 두 번째 단계 - 비평가가 감독자 기획 검토
            if role == "critic":
                return self.create_critic_consistency_prompt_enhanced(
                    stages[0]["content"], 
                    self.narrative_tracker,
                    query, 
                    language
                )
        
        elif stage_idx == 2:
            # 세 번째 단계 - 감독자 수정
            if role == "director":
                return self.create_director_revision_prompt(
                    stages[0]["content"],  # 초기 기획
                    stages[1]["content"],  # 비평
                    query,
                    language
                )
        
        else:
            # 작가 단계들
            if role.startswith("writer"):
                writer_num = int(re.search(r'\d+', role).group())
                
                # 이전 작가들의 내용 가져오기
                previous_content = ""
                if writer_num > 1:
                    # writer_num - 1까지의 모든 작가 내용
                    for i in range(1, writer_num):
                        for stage in stages:
                            if f"writer{i}" in stage.get("name", "") and stage["content"]:
                                previous_content += stage["content"] + "\n\n"
                
                # 감독자 플랜 가져오기
                director_plan = ""
                for stage in stages[:3]:  # 처음 3개 단계에서 감독자 플랜 찾기
                    if "감독자" in stage.get("name", "") and "수정" in stage.get("name", "") and stage["content"]:
                        director_plan = stage["content"]
                        break
                if not director_plan:  # 수정된 플랜이 없으면 초기 플랜 사용
                    director_plan = stages[0]["content"] if stages and stages[0]["content"] else ""
                
                # 서사 요약 생성
                narrative_summary = self.generate_narrative_summary(stages, writer_num)
                
                # 단계별 요구사항 생성
                phase_requirements = self.narrative_tracker.generate_phase_requirements(writer_num)
                
                # 사용된 요소들
                used_elements = list(self.narrative_tracker.used_expressions)
                
                # 초안인지 수정본인지 확인
                stage_name = stages[stage_idx]["name"] if stage_idx < len(stages) else ""
                if "초안" in stage_name:
                    return self.create_writer_prompt_enhanced(
                        writer_num,
                        director_plan,
                        previous_content,
                        phase_requirements,
                        narrative_summary,
                        language,
                        used_elements
                    )
                else:  # 수정본
                    # 해당 작가의 초안 찾기
                    initial_content = ""
                    critic_feedback = ""
                    
                    # 초안 찾기
                    for i, stage in enumerate(stages):
                        if f"writer{writer_num}" in stage.get("name", "") and "초안" in stage.get("name", ""):
                            initial_content = stage["content"]
                            break
                    
                    # 중간 비평 찾기
                    for i, stage in enumerate(stages):
                        if "critic" in stage.get("name", "") and "중간 검토" in stage.get("name", ""):
                            critic_feedback = stage["content"]
                            break
                    
                    return self.create_writer_revision_prompt(
                        writer_num,
                        initial_content,
                        critic_feedback,
                        language
                    )
            
            elif role == "critic":
                # 중간 비평가 검토
                if "중간 검토" in stages[stage_idx]["name"]:
                    # 모든 작가 콘텐츠 수집
                    all_content = ""
                    for stage in stages:
                        if "writer" in stage.get("name", "") and "초안" in stage.get("name", "") and stage["content"]:
                            all_content += stage["content"] + "\n\n"
                    
                    return self.create_critic_consistency_prompt_enhanced(
                        all_content,
                        self.narrative_tracker,
                        query,
                        language
                    )
                # 최종 비평
                else:
                    # 편집된 내용이 있으면 그것을, 없으면 모든 작가 수정본
                    final_content = ""
                    for stage in stages:
                        if "편집자" in stage.get("name", "") and stage["content"]:
                            final_content = stage["content"]
                            break
                    
                    if not final_content:
                        # 편집된 내용이 없으면 모든 작가 수정본 수집
                        for i in range(1, 11):
                            for stage in stages:
                                if f"writer{i}" in stage.get("name", "") and "수정본" in stage.get("name", "") and stage["content"]:
                                    final_content += stage["content"] + "\n\n"
                    
                    return self.create_critic_final_prompt(final_content, query, language)
            
            elif role == "editor":
                # 편집자 - 모든 작가 수정본 수집
                complete_novel = ""
                writer_contents = []
                for i in range(1, 11):
                    for stage in stages:
                        if f"writer{i}" in stage.get("name", "") and "수정본" in stage.get("name", "") and stage["content"]:
                            writer_contents.append(stage["content"])
                            complete_novel += stage["content"] + "\n\n"
                
                # 문제점 감지 - 매우 심각한 문제만
                issues = []
                
                # 완전히 동일한 문단 체크
                paragraphs = complete_novel.split('\n\n')
                seen_paragraphs = set()
                exact_duplicates = 0
                for para in paragraphs:
                    if para.strip() in seen_paragraphs and len(para.strip()) > 100:
                        exact_duplicates += 1
                    seen_paragraphs.add(para.strip())
                
                if exact_duplicates > 5:
                    issues.append(f"{exact_duplicates}개의 완전히 동일한 문단 발견")
                
                # 문제가 거의 없으면 편집 최소화
                if len(issues) == 0:
                    issues = ["원고 상태가 양호합니다. 편집을 최소화하세요."]
                
                return self.create_editor_prompt(complete_novel, issues, language)
        
        # 기본값 (에러 방지)
        return f"역할 {role}에 대한 프롬프트가 정의되지 않았습니다."
 

    def create_director_revision_prompt(self, initial_plan: str, critic_feedback: str, user_query: str, language: str) -> str:
       """감독자 수정 프롬프트"""
       lang_prompts = {
           "Korean": f"""비평을 반영하여 수정하세요.

**원 주제:** {user_query}

**비평 요점:**
{critic_feedback[:500]}

**수정 핵심:**
1. 10단계가 인과관계로 긴밀히 연결
2. 캐릭터 이름과 설정 처음부터 고정
3. 각 단계가 이전의 필연적 결과
4. 플롯의 자기복제 방지
5. 8,000단어 달성 전략

**구조 강화:**
- 외부 사건이 내적 변화를 촉발
- 선택의 결과가 다음 국면 결정
- 우연이 아닌 필연적 전개

치밀한 인과관계의 수정 계획을 제시하세요.""",
           
           "English": f"""Revise based on critique.

**Original Theme:** {user_query}

**Critique Points:**
{critic_feedback[:500]}

**Revision Focus:**
1. 10 phases tightly connected by causality
2. Character names/settings fixed from start
3. Each phase as necessary result of previous
4. Prevent plot self-replication
5. Strategy to achieve 8,000 words

**Structure Enhancement:**
- External events trigger internal changes
- Choices determine next phase
- Necessary, not coincidental development

Present revision plan with tight causality."""
       }
       
       return lang_prompts.get(language, lang_prompts["Korean"])

    def get_previous_writer_content(self, stages: List[Dict], current_writer: int) -> str:
       """이전 작가의 내용 가져오기"""
       if current_writer == 1:
           return ""
       
       # 이전 작가들의 내용 수집
       previous_content = []
       for i in range(1, current_writer):
           for stage in stages:
               if f"writer{i}" in stage.get("name", "") and stage["content"]:
                   previous_content.append(stage["content"])
                   break
       
       return "\n\n".join(previous_content)

    def get_all_writer_content(self, stages: List[Dict], up_to_stage: int) -> str:
       """특정 단계까지의 모든 작가 내용"""
       contents = []
       for i, s in enumerate(stages):
           if i <= up_to_stage and "writer" in s.get("name", "") and s["content"]:
               contents.append(s["content"])
       return "\n\n".join(contents)

    def get_edited_content(self, stages: List[Dict]) -> str:
       """편집된 내용 가져오기"""
       for s in stages:
           if "편집자" in s.get("name", "") and s["content"]:
               return s["content"]
       return ""

    def generate_narrative_summary(self, stages: List[Dict], up_to_writer: int) -> str:
       """현재까지의 서사 요약"""
       if up_to_writer == 1:
           return "첫 시작입니다."
       
       summary_parts = []
       for i in range(1, up_to_writer):
           if i in self.narrative_tracker.phase_summaries:
               summary_parts.append(f"[{NARRATIVE_PHASES[i-1]}]: {self.narrative_tracker.phase_summaries[i][:100]}...")
       
       return "\n".join(summary_parts) if summary_parts else "이전 내용을 이어받아 진행하세요."

    def update_narrative_tracker(self, content: str, writer_num: int):
       """서사 추적기 업데이트"""
       # 간단한 요약 생성 (실제로는 더 정교한 분석 필요)
       lines = content.split('\n')
       key_events = [line.strip() for line in lines if len(line.strip()) > 50][:3]
       
       if key_events:
           summary = " ".join(key_events[:2])[:200] + "..."
           self.narrative_tracker.phase_summaries[writer_num] = summary
           
       # 철학적 통찰 추출 (간단한 키워드 기반)
       philosophical_keywords = ['존재', '의미', '삶', '죽음', '인간', '고통', '희망', '사랑', 
                                'existence', 'meaning', 'life', 'death', 'human', 'suffering', 'hope', 'love']
       for keyword in philosophical_keywords:
           if keyword in content:
               self.narrative_tracker.philosophical_insights.append(f"Phase {writer_num}: {keyword} 탐구")
               break
               
       # 문학적 기법 감지
       literary_devices = []
       if '처럼' in content or 'like' in content or 'as if' in content:
           literary_devices.append('비유')
       if '...' in content or '—' in content:
           literary_devices.append('의식의 흐름')
       if content.count('"') > 4:
           literary_devices.append('대화')
       
       if literary_devices:
           self.narrative_tracker.literary_devices[writer_num] = literary_devices

    def detect_issues(self, content: str) -> List[str]:
       """문제점 감지 - 심각한 문제만"""
       issues = []
       
       # 완전히 동일한 문단만 감지
       paragraphs = content.split('\n\n')
       exact_duplicates = 0
       for i, para1 in enumerate(paragraphs):
           for j, para2 in enumerate(paragraphs[i+1:]):
               if para1.strip() == para2.strip() and len(para1.strip()) > 50:
                   exact_duplicates += 1
                   
       if exact_duplicates > 0:
           issues.append(f"{exact_duplicates}개의 완전히 동일한 문단 발견")
           
       # 5회 이상 반복되는 표현만 감지
       repetitive_phrases = ["습기가 찬 아침", "나라미 어플", "43만원", "개구리알을 바라보았다"]
       for phrase in repetitive_phrases:
           count = content.count(phrase)
           if count > 5:  # 임계값을 3에서 5로 상향
               issues.append(f"'{phrase}' 표현이 {count}회 과도하게 반복됨")
               
       # 심각한 캐릭터 이름 불일치만
       name_variations = ["나라미", "안정", "나"]
       found_names = [name for name in name_variations if content.count(name) > 10]
       if len(found_names) > 2:
           issues.append(f"주인공 이름 심각한 불일치: {', '.join(found_names)}")
           
       # 언어 오류 감지
       if re.search(r'[ぁ-んァ-ヶ一-龯]', content):
           issues.append("일본어/중국어 문자 발견")
           
       return issues[:3]  # 가장 심각한 3개만 반환

    def evaluate_progression(self, content: str, phase: int) -> float:
       """서사 진행도 평가"""
       score = 5.0
       
       # 분량 체크
       word_count = len(content.split())
       if word_count >= MIN_WORDS_PER_WRITER:
           score += 2.0
       
       # 새로운 요소 체크
       if phase > 1:
           prev_summary = self.narrative_tracker.phase_summaries.get(phase-1, "")
           if prev_summary and len(set(content.split()) - set(prev_summary.split())) > 100:
               score += 1.5
       
       # 변화 언급 체크
       change_keywords = ['변했', '달라졌', '새로운', '이제는', '더 이상', 
                         'changed', 'different', 'new', 'now', 'no longer']
       if any(keyword in content for keyword in change_keywords):
           score += 1.5
           
       # 철학적 깊이 체크
       philosophical_keywords = ['존재', '의미', '삶의', '인간의', '왜', 'existence', 'meaning', 'life', 'human', 'why']
       if any(keyword in content for keyword in philosophical_keywords):
           score += 0.5
           
       # 문학적 기법 체크
       if not any(phrase in content for phrase in ['느꼈다', '였다', 'felt', 'was']):
           score += 0.5  # 보여주기 기법 사용
       
       return min(10.0, score)

    def generate_literary_report(self, complete_novel: str, query: str, language: str) -> str:
       """최종 문학적 평가"""
       prompt = self.create_critic_final_prompt(complete_novel, query, language)
       try:
           report = self.call_llm_sync([{"role": "user", "content": prompt}], "critic", language)
           return report
       except Exception as e:
           logger.error(f"최종 보고서 생성 실패: {e}")
           return "보고서 생성 중 오류 발생"

    def check_single_narrative(self, content: str) -> bool:
        """단일 서사 구조 확인"""
        # 주인공 이름의 일관성 체크
        names = re.findall(r'[가-힣]{2,4}(?=이|가|은|는|을|를)', content)
        name_counts = {}
        for name in names:
            name_counts[name] = name_counts.get(name, 0) + 1
        
        # 가장 많이 등장하는 이름이 전체의 50% 이상인지
        if name_counts:
            max_count = max(name_counts.values())
            total_count = sum(name_counts.values())
            return max_count / total_count > 0.5
        return False
    
    def check_character_consistency_in_final(self, content: str) -> float:
        """최종 작품의 캐릭터 일관성 점수"""
        # 캐릭터 이름과 직업/설정의 일관성 체크
        consistency_score = 1.0
        
        # 같은 이름이 다른 설정으로 등장하는지 체크
        name_professions = {}
        patterns = [
            r'([가-힣]{2,4})(?:은|는|이|가)\s+(\w+(?:작가|기자|교사|의사|변호사))',
            r'(\w+(?:작가|기자|교사|의사|변호사))\s+([가-힣]{2,4})'
        ]
        
        for pattern in patterns:
            matches = re.findall(pattern, content)
            for match in matches:
                name = match[0] if '가' <= match[0][0] <= '힣' else match[1]
                profession = match[1] if '가' <= match[0][0] <= '힣' else match[0]
                
                if name in name_professions and name_professions[name] != profession:
                    consistency_score -= 0.2  # 불일치마다 감점
                else:
                    name_professions[name] = profession
        
        return max(0, consistency_score)

    def save_quality_evaluation(self, report: str):
       """품질 평가 저장"""
       try:
           # 점수 추출 (간단한 패턴 매칭)
           score_match = re.search(r'총점:\s*(\d+(?:\.\d+)?)/100', report)
           score = float(score_match.group(1)) if score_match else 0.0
           
           NovelDatabase.save_quality_evaluation(
               self.current_session_id,
               "final_evaluation",
               score,
               report
           )
       except Exception as e:
           logger.error(f"품질 평가 저장 실패: {e}")


# --- 유틸리티 함수들 ---
def process_query(query: str, language: str, session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str], None, None]:
   """메인 쿼리 처리 함수"""
   if not query.strip():
       yield "", "", "❌ 주제를 입력해주세요.", session_id
       return
   
   system = ProgressiveLiterarySystem()
   stages_markdown = ""
   novel_content = ""
   
   for status, stages, current_session_id in system.process_novel_stream(query, language, session_id):
       stages_markdown = format_stages_display(stages)
       
       # 최종 소설 내용 가져오기
       if stages and all(s.get("status") == "complete" for s in stages[-10:]):
           novel_content = NovelDatabase.get_writer_content(current_session_id)
           # 편집된 내용이 있으면 그것을 사용
           edited = system.get_edited_content(stages)
           if edited:
               novel_content = edited
           novel_content = format_novel_display(novel_content)
       
       yield stages_markdown, novel_content, status or "🔄 처리 중...", current_session_id

def get_active_sessions(language: str) -> List[str]:
    """활성 세션 목록"""
    sessions = NovelDatabase.get_active_sessions()
    result = []
    for s in sessions:
        # None 값 체크 추가
        session_id = s.get('session_id', '')
        user_query = s.get('user_query', '')
        created_at = s.get('created_at', '')
        total_words = s.get('total_words', 0) or 0  # None일 경우 0으로 처리
        
        if session_id and user_query:  # 필수 값이 있는 경우만 추가
            result.append(
                f"{session_id[:8]}... - {user_query[:50]}... ({created_at}) [{total_words:,}단어]"
            )
    return result

def auto_recover_session(language: str) -> Tuple[Optional[str], str]:
   """최근 세션 자동 복구"""
   sessions = NovelDatabase.get_active_sessions()
   if sessions:
       latest_session = sessions[0]
       return latest_session['session_id'], f"세션 {latest_session['session_id'][:8]}... 복구됨"
   return None, "복구할 세션이 없습니다."

def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str, str], None, None]:
   """세션 재개"""
   if not session_id:
       yield "", "", "❌ 세션 ID가 없습니다.", session_id
       return
   
   if "..." in session_id:
       session_id = session_id.split("...")[0]
   
   session = NovelDatabase.get_session(session_id)
   if not session:
       yield "", "", "❌ 세션을 찾을 수 없습니다.", None
       return
   
   yield from process_query(session['user_query'], session['language'], session_id)

def download_novel(novel_text: str, format_type: str, language: str, session_id: str) -> Optional[str]:
   """소설 다운로드 파일 생성"""
   if not novel_text or not session_id:
       return None
   
   timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
   filename = f"novel_{session_id[:8]}_{timestamp}"
   
   try:
       if format_type == "DOCX" and DOCX_AVAILABLE:
           return export_to_docx(novel_text, filename, language, session_id)
       else:
           return export_to_txt(novel_text, filename)
   except Exception as e:
       logger.error(f"파일 생성 실패: {e}")
       return None

def format_stages_display(stages: List[Dict]) -> str:
   """단계별 진행 상황 표시"""
   markdown = "## 🎬 진행 상황\n\n"
   
   # 총 단어 수 계산
   total_words = sum(s.get('word_count', 0) for s in stages if 'writer' in s.get('name', ''))
   progress_percent = (total_words / TARGET_WORDS) * 100 if TARGET_WORDS > 0 else 0
   
   markdown += f"**총 단어 수: {total_words:,} / {TARGET_WORDS:,}**\n"
   markdown += f"**진행률: {progress_percent:.1f}%**\n"
   markdown += f"{'█' * int(progress_percent // 5)}{'░' * (20 - int(progress_percent // 5))}\n\n"
   
   for i, stage in enumerate(stages):
       status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
       markdown += f"{status_icon} **{stage['name']}**"
       
       if stage.get('word_count', 0) > 0:
           markdown += f" ({stage['word_count']:,}단어)"
           
           # 작가 단계에서 단어 수 부족 경고
           if 'writer' in stage.get('name', '') and stage['word_count'] < MIN_WORDS_PER_WRITER:
               markdown += f" ⚠️ **분량 부족!**"
       
       # 진행도와 반복도 점수 표시
       if stage.get('progression_score', 0) > 0:
           markdown += f" [진행도: {stage['progression_score']:.1f}/10]"
       if stage.get('repetition_score', 0) > 0:
           markdown += f" [반복도: {stage['repetition_score']:.1f}/10]"
       
       # 일관성 체크 표시
       if stage.get('consistency_check'):
           if stage['consistency_check'] == "통과":
               markdown += " ✔️"
           else:
               markdown += f" ⚠️ {stage['consistency_check']}"
       
       markdown += "\n"
       
       if stage['content']:
           preview = stage['content'][:200] + "..." if len(stage['content']) > 200 else stage['content']
           markdown += f"> {preview}\n\n"
   
   return markdown

def format_novel_display(novel_text: str) -> str:
   """소설 내용 표시"""
   if not novel_text:
       return "아직 완성된 내용이 없습니다."
   
   formatted = "# 📖 완성된 소설\n\n"
   
   # 단어 수 표시
   word_count = len(novel_text.split())
   formatted += f"**총 분량: {word_count:,}단어 (목표: {TARGET_WORDS:,}단어)**\n\n"
   
   if word_count < TARGET_WORDS:
       shortage = TARGET_WORDS - word_count
       formatted += f"⚠️ **주의: 목표 분량에 {shortage:,}단어 부족합니다.**\n\n"
   else:
       formatted += f"✅ **목표 분량 달성!**\n\n"
       
   formatted += "---\n\n"
   
   # 각 단계를 구분하여 표시
   sections = novel_text.split('\n\n')
   for i, section in enumerate(sections):
       if section.strip():
           formatted += f"{section}\n\n"
   
   return formatted

def export_to_docx(content: str, filename: str, language: str, session_id: str) -> str:
   """DOCX 파일로 내보내기"""
   doc = Document()
   
   # 페이지 설정
   section = doc.sections[0]
   section.page_height = Inches(11)
   section.page_width = Inches(8.5)
   section.top_margin = Inches(1)
   section.bottom_margin = Inches(1)
   section.left_margin = Inches(1.25)
   section.right_margin = Inches(1.25)
   
   # 세션 정보
   session = NovelDatabase.get_session(session_id)
   
   # 제목 페이지
   title_para = doc.add_paragraph()
   title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
   
   if session:
       title_run = title_para.add_run(session["user_query"])
       title_run.font.size = Pt(24)
       title_run.bold = True
   
   # 메타 정보
   doc.add_paragraph()
   meta_para = doc.add_paragraph()
   meta_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
   meta_para.add_run(f"생성일: {datetime.now().strftime('%Y년 %m월 %d일')}\n")
   meta_para.add_run(f"총 단어 수: {len(content.split()):,}단어")
   
   # 페이지 나누기
   doc.add_page_break()
   
   # 본문 스타일 설정
   style = doc.styles['Normal']
   style.font.name = 'Calibri'
   style.font.size = Pt(11)
   style.paragraph_format.line_spacing = 1.5
   style.paragraph_format.space_after = Pt(6)
   
   # 본문 추가
   paragraphs = content.split('\n\n')
   for para_text in paragraphs:
       if para_text.strip():
           para = doc.add_paragraph(para_text.strip())
   
   # 파일 저장
   filepath = f"{filename}.docx"
   doc.save(filepath)
   return filepath

def export_to_txt(content: str, filename: str) -> str:
   """TXT 파일로 내보내기"""
   filepath = f"{filename}.txt"
   with open(filepath, 'w', encoding='utf-8') as f:
       f.write(content)
   return filepath


# CSS 스타일
custom_css = """
.gradio-container {
   background: linear-gradient(135deg, #1e3c72 0%, #2a5298 50%, #1e3c72 100%);
   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;
   border: 1px solid rgba(255, 255, 255, 0.2);
}

.progress-note {
   background-color: rgba(255, 223, 0, 0.1);
   border-left: 3px solid #ffd700;
   padding: 15px;
   margin: 20px 0;
   border-radius: 8px;
   color: #fff;
}

.improvement-note {
   background-color: rgba(0, 255, 127, 0.1);
   border-left: 3px solid #00ff7f;
   padding: 15px;
   margin: 20px 0;
   border-radius: 8px;
   color: #fff;
}

.warning-note {
   background-color: rgba(255, 69, 0, 0.1);
   border-left: 3px solid #ff4500;
   padding: 15px;
   margin: 20px 0;
   border-radius: 8px;
   color: #fff;
}

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

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

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

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

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

/* 진행 표시기 스타일 */
.progress-bar {
   background-color: #e0e0e0;
   height: 20px;
   border-radius: 10px;
   overflow: hidden;
   margin: 10px 0;
}

.progress-fill {
   background-color: #4CAF50;
   height: 100%;
   transition: width 0.3s ease;
}

/* 점수 표시 스타일 */
.score-badge {
   display: inline-block;
   padding: 2px 8px;
   border-radius: 12px;
   font-size: 0.9em;
   font-weight: bold;
   margin-left: 5px;
}

.score-high {
   background-color: #4CAF50;
   color: white;
}

.score-medium {
   background-color: #FF9800;
   color: white;
}

.score-low {
   background-color: #F44336;
   color: white;
}

/* 일관성 체크 표시 */
.consistency-pass {
   color: #4CAF50;
   font-weight: bold;
}

.consistency-fail {
   color: #F44336;
   font-weight: bold;
}

/* 보고서 표시 스타일 */
#report-display {
   background-color: rgba(255, 255, 255, 0.95);
   padding: 20px;
   border-radius: 12px;
   max-height: 600px;
   overflow-y: auto;
   box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
}

/* 분량 경고 스타일 */
.word-count-warning {
   background-color: #FFF3CD;
   border-left: 4px solid #FFC107;
   padding: 10px 15px;
   margin: 10px 0;
   border-radius: 4px;
}
"""

# Gradio 인터페이스 생성
def create_interface():
   with gr.Blocks(css=custom_css, title="AI 진행형 장편소설 생성 시스템 v3.1") as interface:
       gr.HTML("""
       <div class="main-header">
           <h1 style="font-size: 2.5em; margin-bottom: 10px;">
               📚 AI 진행형 장편소설 생성 시스템 v3.1
           </h1>
           <h3 style="color: #ddd; margin-bottom: 20px;">
               목표 분량 달성을 위한 최적화 버전
           </h3>
           <p style="font-size: 1.1em; color: #eee; max-width: 800px; margin: 0 auto;">
               10개의 유기적으로 연결된 단계를 통해 하나의 완전한 이야기를 만들어냅니다.
               <br>
               각 단계는 이전 단계의 필연적 결과로 이어지며, 인물의 변화와 성장을 추적합니다.
           </p>
           <div class="progress-note">
               ⚡ 반복이 아닌 축적, 순환이 아닌 진행을 통한 진정한 장편 서사
           </div>
           <div class="improvement-note">
               🆕 v3.1 핵심 개선사항:
               <ul style="text-align: left; margin: 10px auto; max-width: 600px;">
                   <li>목표 단어 수 8,000단어로 조정</li>
                   <li>프롬프트 간소화로 생성 공간 확보</li>
                   <li>단어 수 부족 시 자동 재생성</li>
                   <li>실시간 진행률 표시</li>
                   <li>분량 미달 경고 시스템</li>
                   <li>프롬프트 자동 증강 기능</li>
                   <li>인과관계와 캐릭터 일관성 강화</li>
               </ul>
           </div>
           <div class="warning-note">
               ⚠️ 분량 목표: 각 작가당 최소 800단어, 전체 8,000단어 이상
           </div>
       </div>
       """)
       
       # 상태 관리
       current_session_id = gr.State(None)
       
       with gr.Row():
           with gr.Column(scale=1):
               with gr.Group(elem_classes=["input-section"]):
                   query_input = gr.Textbox(
                       label="소설 주제 / Novel Theme",
                       placeholder="중편소설의 주제를 입력하세요. 인물의 변화와 성장이 중심이 되는 이야기...\nEnter the theme for your novella. Focus on character transformation and growth...",
                       lines=4
                   )
                   
                   language_select = gr.Radio(
                       choices=["Korean", "English"],
                       value="Korean",
                       label="언어 / Language"
                   )
                   
                   with gr.Row():
                       submit_btn = gr.Button("🚀 소설 생성 시작", variant="primary", scale=2)
                       clear_btn = gr.Button("🗑️ 초기화", scale=1)
                   
                   status_text = gr.Textbox(
                       label="상태",
                       interactive=False,
                       value="🔄 준비 완료"
                   )
                   
                   # 세션 관리
                   with gr.Group(elem_classes=["session-section"]):
                       gr.Markdown("### 💾 진행 중인 세션")
                       session_dropdown = gr.Dropdown(
                           label="세션 선택",
                           choices=[],
                           interactive=True
                       )
                       with gr.Row():
                           refresh_btn = gr.Button("🔄 목록 새로고침", scale=1)
                           resume_btn = gr.Button("▶️ 선택 재개", variant="secondary", scale=1)
                           auto_recover_btn = gr.Button("♻️ 최근 세션 복구", scale=1)
       
       with gr.Column(scale=2):
           with gr.Tab("📝 창작 진행"):
               stages_display = gr.Markdown(
                   value="창작 과정이 여기에 표시됩니다...",
                   elem_id="stages-display"
               )
           
           with gr.Tab("📖 완성된 소설"):
               novel_output = gr.Markdown(
                   value="완성된 소설이 여기에 표시됩니다...",
                   elem_id="novel-output"
               )
               
               with gr.Group(elem_classes=["download-section"]):
                   gr.Markdown("### 📥 소설 다운로드")
                   with gr.Row():
                       format_select = gr.Radio(
                           choices=["DOCX", "TXT"],
                           value="DOCX" if DOCX_AVAILABLE else "TXT",
                           label="형식"
                       )
                       download_btn = gr.Button("⬇️ 다운로드", variant="secondary")
                   
                   download_file = gr.File(
                       label="다운로드된 파일",
                       visible=False
                   )
                   
           with gr.Tab("📊 평가 보고서"):
               report_display = gr.Markdown(
                   value="평가 보고서가 여기에 표시됩니다...",
                   elem_id="report-display"
               )
       
       # 숨겨진 상태
       novel_text_state = gr.State("")
       
       # 예제
       with gr.Row():
           gr.Examples(
               examples=[
                   ["기초생활수급자가 된 청년의 생존과 존엄성 찾기"],
                   ["실직한 중년 남성이 새로운 삶의 의미를 찾아가는 여정"],
                   ["도시에서 시골로 이주한 청년의 적응과 성장 이야기"],
                   ["세 세대가 함께 사는 가족의 갈등과 화해"],
                   ["A middle-aged woman's journey to rediscover herself after divorce"],
                   ["The transformation of a cynical journalist through unexpected encounters"],
                   ["작은 서점을 운영하는 노부부의 마지막 1년"],
                   ["AI 시대에 일자리를 잃은 번역가의 새로운 도전"],
                   ["재개발로 사라져가는 동네에서의 마지막 계절"]
               ],
               inputs=query_input,
               label="💡 주제 예시"
           )
       
       # 이벤트 핸들러
       def refresh_sessions():
           try:
               sessions = get_active_sessions("Korean")
               return gr.update(choices=sessions)
           except Exception as e:
               logger.error(f"Error refreshing sessions: {str(e)}")
               logger.error(f"Full error: {e}", exc_info=True)  # 전체 스택 트레이스 로깅
               return gr.update(choices=[])
       
       def handle_auto_recover(language):
           session_id, message = auto_recover_session(language)
           return session_id, message
       
       def update_displays(stages_md, novel_md, status, session_id):
           """모든 디스플레이 업데이트"""
           # 평가 보고서 가져오기
           report = ""
           if session_id:
               session = NovelDatabase.get_session(session_id)
               if session and session.get('literary_report'):
                   report = session['literary_report']
           
           return stages_md, novel_md, status, session_id, report
       
       # 이벤트 연결
       submit_btn.click(
           fn=process_query,
           inputs=[query_input, language_select, current_session_id],
           outputs=[stages_display, novel_output, status_text, current_session_id]
       ).then(
           fn=lambda s, n, st, sid: (s, n, st, sid, NovelDatabase.get_session(sid).get('literary_report', '') if sid and NovelDatabase.get_session(sid) else ''),
           inputs=[stages_display, novel_output, status_text, current_session_id],
           outputs=[stages_display, novel_output, status_text, current_session_id, report_display]
       )
       
       novel_output.change(
           fn=lambda x: x,
           inputs=[novel_output],
           outputs=[novel_text_state]
       )
       
       resume_btn.click(
           fn=lambda x: x.split("...")[0] if x and "..." in x else 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, current_session_id]
       ).then(
           fn=lambda s, n, st, sid: (s, n, st, sid, NovelDatabase.get_session(sid).get('literary_report', '') if sid and NovelDatabase.get_session(sid) else ''),
           inputs=[stages_display, novel_output, status_text, current_session_id],
           outputs=[stages_display, novel_output, status_text, current_session_id, report_display]
       )
       
       auto_recover_btn.click(
           fn=handle_auto_recover,
           inputs=[language_select],
           outputs=[current_session_id, status_text]
       ).then(
           fn=resume_session,
           inputs=[current_session_id, language_select],
           outputs=[stages_display, novel_output, status_text, current_session_id]
       ).then(
           fn=lambda s, n, st, sid: (s, n, st, sid, NovelDatabase.get_session(sid).get('literary_report', '') if sid and NovelDatabase.get_session(sid) else ''),
           inputs=[stages_display, novel_output, status_text, current_session_id],
           outputs=[stages_display, novel_output, status_text, current_session_id, report_display]
       )
       
       refresh_btn.click(
           fn=refresh_sessions,
           outputs=[session_dropdown]
       )
       
       clear_btn.click(
           fn=lambda: ("", "", "🔄 준비 완료", "", None, ""),
           outputs=[stages_display, novel_output, status_text, novel_text_state, current_session_id, report_display]
       )
       
       def handle_download(format_type, language, session_id, novel_text):
           if not session_id or not novel_text:
               return gr.update(visible=False)
           
           file_path = download_novel(novel_text, format_type, language, session_id)
           if file_path:
               return gr.update(value=file_path, visible=True)
           else:
               return gr.update(visible=False)
       
       download_btn.click(
           fn=handle_download,
           inputs=[format_select, language_select, current_session_id, novel_text_state],
           outputs=[download_file]
       )
       
       # 시작 시 세션 로드
       interface.load(
           fn=refresh_sessions,
           outputs=[session_dropdown]
       )
   
   return interface


# 메인 실행
if __name__ == "__main__":
   logger.info("AI 진행형 장편소설 생성 시스템 v3.1 시작...")
   logger.info("=" * 60)
   
   # 환경 확인
   logger.info(f"API 엔드포인트: {API_URL}")
   logger.info(f"목표 분량: {TARGET_WORDS:,}단어")
   logger.info(f"작가당 최소 분량: {MIN_WORDS_PER_WRITER:,}단어")
   logger.info("주요 개선사항:")
   logger.info("- 분량 목표 8,000단어로 조정")
   logger.info("- 프롬프트 간소화")
   logger.info("- 단어 수 부족 시 자동 재생성")
   logger.info("- 실시간 진행률 표시")
   logger.info("- 프롬프트 자동 증강 기능")
   logger.info("- 인과관계와 캐릭터 일관성 강화")
   
   if BRAVE_SEARCH_API_KEY:
       logger.info("웹 검색이 활성화되었습니다.")
   else:
       logger.warning("웹 검색이 비활성화되었습니다.")
   
   if DOCX_AVAILABLE:
       logger.info("DOCX 내보내기가 활성화되었습니다.")
   else:
       logger.warning("DOCX 내보내기가 비활성화되었습니다.")
   
   logger.info("=" * 60)
   
   # 데이터베이스 초기화
   logger.info("데이터베이스 초기화 중...")
   NovelDatabase.init_db()
   logger.info("데이터베이스 초기화 완료.")
   
   # 인터페이스 생성 및 실행
   interface = create_interface()
   
   interface.launch(
       server_name="0.0.0.0",
       server_port=7860,
       share=False,
       debug=True
   )