Update app.py

app.py

@@ -16,25 +16,11 @@ from contextlib import contextmanager
 from dataclasses import dataclass, field, asdict
 from collections import defaultdict
 import random
-from huggingface_hub import HfApi, upload_file, hf_hub_download
 
 # --- Logging setup ---
 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, Mm
-   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.")
-
 # --- Environment variables and constants ---
 FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY", "")
 BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
@@ -42,7 +28,7 @@ API_URL = "https://api.fireworks.ai/inference/v1/chat/completions"
 MODEL_ID = "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507"
 DB_PATH = "screenplay_sessions_v2.db"
 
-# Enhanced screenplay length settings for longer content
+# Enhanced screenplay length settings
 SCREENPLAY_LENGTHS = {
    "movie": {"pages": 120, "description": "Feature Film (110-130 pages)", "min_pages": 110},
    "tv_drama": {"pages": 60, "description": "TV Drama Episode (55-65 pages)", "min_pages": 55},
@@ -61,7 +47,7 @@ if not BRAVE_SEARCH_API_KEY:
 # --- Global variables ---
 db_lock = threading.Lock()
 
-# Enhanced genre templates with more detailed structure
+# Enhanced genre templates
 GENRE_TEMPLATES = {
    "action": {
        "pacing": "fast",
@@ -69,8 +55,8 @@ GENRE_TEMPLATES = {
        "dialogue_ratio": 0.3,
        "key_elements": ["set pieces", "physical conflict", "urgency", "stakes escalation", "hero moments"],
        "structure_beats": ["explosive opening", "pursuit/chase", "confrontation", "climactic battle", "hero's triumph"],
-       "scene_density": 1.2,  # More scenes per page
-       "action_description_ratio": 0.6  # More action lines
+       "scene_density": 1.2,
+       "action_description_ratio": 0.6
    },
    "thriller": {
        "pacing": "fast",
@@ -128,102 +114,86 @@ GENRE_TEMPLATES = {
    }
 }
 
-# Enhanced screenplay stages with more detail phases
+# Enhanced screenplay stages
 SCREENPLAY_STAGES = [
     ("producer", "🎬 Producer: Concept Development & Market Analysis"),
-    ("story_developer", "📖 Story Developer: Extended Synopsis & Detailed Three-Act Structure"),
-    ("character_designer", "👥 Character Designer: Deep Character Profiles & Relationships"),
-    ("world_builder", "🌍 World Builder: Setting, Atmosphere & Visual Design"),
-    ("critic_structure", "🔍 Structure Critic: Comprehensive Story & Character Review"),
-    ("scene_planner", "🎯 Scene Planner: Detailed Scene-by-Scene Breakdown"),
+    ("story_developer", "📖 Story Developer: Extended Synopsis & Three-Act Structure"),
+    ("character_designer", "👥 Character Designer: Deep Character Profiles"),
+    ("world_builder", "🌍 World Builder: Setting & Atmosphere"),
+    ("critic_structure", "🔍 Structure Critic: Story Review"),
+    ("scene_planner", "🎯 Scene Planner: Detailed Scene Breakdown"),
     
-    # Act 1 - 4 stages: Draft -> Polish -> Review -> Final
-    ("screenwriter", "✍️ Screenwriter: Act 1 - Setup (25%) - Initial Draft"),
-    ("screenwriter", "✍️ Screenwriter: Act 1 - Polish & Expand"),
-    ("script_doctor", "🔧 Script Doctor: Act 1 Comprehensive Review"),
-    ("screenwriter", "✍️ Screenwriter: Act 1 - Final Extended Version"),
+    # Act 1 - 4 stages
+    ("screenwriter", "✍️ Act 1 - Setup (25%) - Initial Draft"),
+    ("screenwriter", "✍️ Act 1 - Polish & Expand"),
+    ("script_doctor", "🔧 Act 1 - Review & Notes"),
+    ("screenwriter", "✍️ Act 1 - Final Extended Version"),
     
     # Act 2A - 4 stages
-    ("screenwriter", "✍️ Screenwriter: Act 2A - Rising Action (25%) - Initial Draft"),
-    ("screenwriter", "✍️ Screenwriter: Act 2A - Polish & Expand"),
-    ("script_doctor", "🔧 Script Doctor: Act 2A Comprehensive Review"),
-    ("screenwriter", "✍️ Screenwriter: Act 2A - Final Extended Version"),
+    ("screenwriter", "✍️ Act 2A - Rising Action (25%) - Initial Draft"),
+    ("screenwriter", "✍️ Act 2A - Polish & Expand"),
+    ("script_doctor", "🔧 Act 2A - Review & Notes"),
+    ("screenwriter", "✍️ Act 2A - Final Extended Version"),
     
     # Act 2B - 4 stages
-    ("screenwriter", "✍️ Screenwriter: Act 2B - Complications (25%) - Initial Draft"),
-    ("screenwriter", "✍️ Screenwriter: Act 2B - Polish & Expand"),
-    ("script_doctor", "🔧 Script Doctor: Act 2B Comprehensive Review"),
-    ("screenwriter", "✍️ Screenwriter: Act 2B - Final Extended Version"),
+    ("screenwriter", "✍️ Act 2B - Complications (25%) - Initial Draft"),
+    ("screenwriter", "✍️ Act 2B - Polish & Expand"),
+    ("script_doctor", "🔧 Act 2B - Review & Notes"),
+    ("screenwriter", "✍️ Act 2B - Final Extended Version"),
     
     # Act 3 - 4 stages
-    ("screenwriter", "✍️ Screenwriter: Act 3 - Resolution (25%) - Initial Draft"),
-    ("screenwriter", "✍️ Screenwriter: Act 3 - Polish & Expand"),
-    ("script_doctor", "🔧 Script Doctor: Act 3 Comprehensive Review"),
-    ("screenwriter", "✍️ Screenwriter: Act 3 - Final Extended Version"),
+    ("screenwriter", "✍️ Act 3 - Resolution (25%) - Initial Draft"),
+    ("screenwriter", "✍️ Act 3 - Polish & Expand"),
+    ("script_doctor", "🔧 Act 3 - Review & Notes"),
+    ("screenwriter", "✍️ Act 3 - Final Extended Version"),
     
-    ("dialogue_specialist", "💬 Dialogue Specialist: Dialogue Enhancement & Subtext"),
-    ("final_reviewer", "🎭 Final Review: Complete Professional Screenplay Analysis"),
+    ("dialogue_specialist", "💬 Dialogue Enhancement"),
+    ("final_reviewer", "🎭 Final Review & Polish"),
 ]
 
-# Enhanced Save the Cat Beat Sheet with more detail
+# Save the Cat Beat Sheet
 SAVE_THE_CAT_BEATS = {
-   1: {"name": "Opening Image", "percentage": "0-1%", "description": "Visual that represents the struggle & tone"},
-   2: {"name": "Setup", "percentage": "1-10%", "description": "Introduce hero, stakes, and goals"},
-   3: {"name": "Theme Stated", "percentage": "5%", "description": "What the story is really about"},
-   4: {"name": "Catalyst", "percentage": "10%", "description": "The moment that begins the journey"},
-   5: {"name": "Debate", "percentage": "10-20%", "description": "Should I stay or should I go?"},
-   6: {"name": "Break into Two", "percentage": "20%", "description": "Hero enters the new world"},
-   7: {"name": "B Story", "percentage": "22%", "description": "Love story or relationship subplot"},
-   8: {"name": "Fun and Games", "percentage": "20-50%", "description": "The promise of the premise"},
-   9: {"name": "Midpoint", "percentage": "50%", "description": "Stakes are raised, time clock appears"},
-   10: {"name": "Bad Guys Close In", "percentage": "50-75%", "description": "Problems intensify"},
-   11: {"name": "All Is Lost", "percentage": "75%", "description": "The lowest point"},
-   12: {"name": "Dark Night of the Soul", "percentage": "75-80%", "description": "Hero hits rock bottom"},
-   13: {"name": "Break into Three", "percentage": "80%", "description": "Solution discovered"},
-   14: {"name": "Finale", "percentage": "80-99%", "description": "Hero conquers the problem"},
-   15: {"name": "Final Image", "percentage": "99-100%", "description": "Opposite of opening image"}
+   1: {"name": "Opening Image", "percentage": "0-1%"},
+   2: {"name": "Setup", "percentage": "1-10%"},
+   3: {"name": "Theme Stated", "percentage": "5%"},
+   4: {"name": "Catalyst", "percentage": "10%"},
+   5: {"name": "Debate", "percentage": "10-20%"},
+   6: {"name": "Break into Two", "percentage": "20%"},
+   7: {"name": "B Story", "percentage": "22%"},
+   8: {"name": "Fun and Games", "percentage": "20-50%"},
+   9: {"name": "Midpoint", "percentage": "50%"},
+   10: {"name": "Bad Guys Close In", "percentage": "50-75%"},
+   11: {"name": "All Is Lost", "percentage": "75%"},
+   12: {"name": "Dark Night of the Soul", "percentage": "75-80%"},
+   13: {"name": "Break into Three", "percentage": "80%"},
+   14: {"name": "Finale", "percentage": "80-99%"},
+   15: {"name": "Final Image", "percentage": "99-100%"}
 }
 
 # --- Data classes ---
 @dataclass
 class ScreenplayBible:
-   """Enhanced screenplay bible for maintaining consistency"""
+   """Enhanced screenplay bible"""
    title: str = ""
    logline: str = ""
    genre: str = ""
    subgenre: str = ""
    tone: str = ""
    themes: List[str] = field(default_factory=list)
-   
-   # Characters
    protagonist: Dict[str, Any] = field(default_factory=dict)
    antagonist: Dict[str, Any] = field(default_factory=dict)
    supporting_cast: Dict[str, Dict[str, Any]] = field(default_factory=dict)
-   character_arcs: Dict[str, str] = field(default_factory=dict)
-   
-   # Structure
    three_act_structure: Dict[str, str] = field(default_factory=dict)
    save_the_cat_beats: Dict[int, str] = field(default_factory=dict)
-   
-   # World
    time_period: str = ""
    primary_locations: List[Dict[str, str]] = field(default_factory=list)
    world_rules: List[str] = field(default_factory=list)
-   atmosphere: str = ""
-   
-   # Visual style
    visual_style: str = ""
    key_imagery: List[str] = field(default_factory=list)
-   color_palette: str = ""
-   
-   # Dialogue style
-   dialogue_style: str = ""
-   vernacular: str = ""
-   period_appropriate: bool = True
 
 @dataclass
 class SceneBreakdown:
-   """Enhanced scene information"""
+   """Scene information"""
    scene_number: int
    act: int
    location: str
@@ -231,16 +201,13 @@ class SceneBreakdown:
    characters: List[str]
    purpose: str
    conflict: str
-   emotional_arc: str
-   visual_notes: str
-   dialogue_focus: str
    page_count: float
    beat: str = ""
    transition: str = "CUT TO:"
 
 @dataclass
 class CharacterProfile:
-   """Enhanced character profile"""
+   """Character profile"""
    name: str
    role: str
    archetype: str
@@ -252,36 +219,22 @@ class CharacterProfile:
    character_arc: str
    relationships: Dict[str, str] = field(default_factory=dict)
    first_appearance: str = ""
-   motivation: str = ""
-   internal_conflict: str = ""
-   external_conflict: str = ""
-   transformation: str = ""
-   key_dialogue_samples: List[str] = field(default_factory=list)
 
 # --- Core logic classes ---
 class ScreenplayTracker:
-    """Enhanced screenplay tracker with more detailed tracking"""
+    """Screenplay tracker"""
     def __init__(self):
         self.screenplay_bible = ScreenplayBible()
         self.scenes: List[SceneBreakdown] = []
         self.characters: Dict[str, CharacterProfile] = {}
         self.page_count = 0
         self.act_pages = {"1": 0, "2A": 0, "2B": 0, "3": 0}
-        self.dialogue_action_ratio = 0.0
-        self.scene_count = 0
-        self.location_list: Set[str] = set()
-        self.time_of_day_distribution = defaultdict(int)
         
     def add_scene(self, scene: SceneBreakdown):
-        """Add scene to tracker"""
         self.scenes.append(scene)
         self.page_count += scene.page_count
-        self.scene_count += 1
-        self.location_list.add(scene.location)
-        self.time_of_day_distribution[scene.time_of_day] += 1
         
     def add_character(self, character: CharacterProfile):
-        """Add character to tracker"""
         self.characters[character.name] = character
         if character.role == "protagonist":
             self.screenplay_bible.protagonist = asdict(character)
@@ -291,62 +244,41 @@ class ScreenplayTracker:
             self.screenplay_bible.supporting_cast[character.name] = asdict(character)
         
     def update_bible(self, key: str, value: Any):
-        """Update screenplay bible"""
         if hasattr(self.screenplay_bible, key):
             setattr(self.screenplay_bible, key, value)
-            
-    def get_act_page_target(self, act: str, total_pages: int) -> int:
-        """Get target pages for each act"""
-        if act == "1":
-            return int(total_pages * 0.25)
-        elif act in ["2A", "2B"]:
-            return int(total_pages * 0.25)
-        elif act == "3":
-            return int(total_pages * 0.25)
-        return 0
 
 class ScreenplayDatabase:
-    """Enhanced database management for screenplay sessions"""
+    """Database management"""
     @staticmethod
     def init_db():
         with sqlite3.connect(DB_PATH) as conn:
             conn.execute("PRAGMA journal_mode=WAL")
             cursor = conn.cursor()
             
-            # Enhanced screenplay sessions table
             cursor.execute('''
                 CREATE TABLE IF NOT EXISTS screenplay_sessions (
                     session_id TEXT PRIMARY KEY,
                     user_query TEXT NOT NULL,
                     screenplay_type TEXT NOT NULL,
                     genre TEXT NOT NULL,
-                    subgenre TEXT,
                     target_pages INTEGER,
-                    min_pages INTEGER,
                     language TEXT NOT NULL,
                     title TEXT,
                     logline TEXT,
                     synopsis TEXT,
-                    extended_synopsis TEXT,
                     three_act_structure TEXT,
                     character_profiles TEXT,
                     scene_breakdown TEXT,
                     screenplay_bible TEXT,
-                    world_building TEXT,
-                    dialogue_notes TEXT,
                     final_screenplay TEXT,
-                    pdf_path TEXT,
                     created_at TEXT DEFAULT (datetime('now')),
                     updated_at TEXT DEFAULT (datetime('now')),
                     status TEXT DEFAULT 'active',
                     current_stage INTEGER DEFAULT 0,
-                    total_pages REAL DEFAULT 0,
-                    actual_pages REAL DEFAULT 0,
-                    quality_score REAL DEFAULT 0
+                    total_pages REAL DEFAULT 0
                 )
             ''')
             
-            # Enhanced stages table
             cursor.execute('''
                 CREATE TABLE IF NOT EXISTS screenplay_stages (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -355,55 +287,24 @@ class ScreenplayDatabase:
                     stage_name TEXT NOT NULL,
                     role TEXT NOT NULL,
                     content TEXT,
-                    enhanced_content TEXT,
                     page_count REAL DEFAULT 0,
-                    word_count INTEGER DEFAULT 0,
-                    dialogue_count INTEGER DEFAULT 0,
-                    action_count INTEGER DEFAULT 0,
                     status TEXT DEFAULT 'pending',
-                    quality_notes TEXT,
                     created_at TEXT DEFAULT (datetime('now')),
-                    updated_at TEXT DEFAULT (datetime('now')),
                     FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id),
                     UNIQUE(session_id, stage_number)
                 )
             ''')
             
-            # Enhanced scenes table
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS scenes (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    session_id TEXT NOT NULL,
-                    act_number INTEGER NOT NULL,
-                    scene_number INTEGER NOT NULL,
-                    location TEXT NOT NULL,
-                    time_of_day TEXT NOT NULL,
-                    characters TEXT,
-                    purpose TEXT,
-                    emotional_arc TEXT,
-                    visual_notes TEXT,
-                    dialogue_focus TEXT,
-                    conflict_level INTEGER,
-                    content TEXT,
-                    page_count REAL,
-                    created_at TEXT DEFAULT (datetime('now')),
-                    FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id)
-                )
-            ''')
-            
-            # Enhanced characters table
             cursor.execute('''
-                CREATE TABLE IF NOT EXISTS characters (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    session_id TEXT NOT NULL,
-                    character_name TEXT NOT NULL,
-                    character_data TEXT,
-                    dialogue_samples TEXT,
-                    arc_progression TEXT,
-                    relationship_map TEXT,
-                    created_at TEXT DEFAULT (datetime('now')),
-                    FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id),
-                    UNIQUE(session_id, character_name)
+                CREATE TABLE IF NOT EXISTS screenplay_themes_library (
+                    theme_id TEXT PRIMARY KEY,
+                    theme_text TEXT NOT NULL,
+                    screenplay_type TEXT NOT NULL,
+                    genre TEXT NOT NULL,
+                    language TEXT NOT NULL,
+                    title TEXT,
+                    logline TEXT,
+                    generated_at TEXT DEFAULT (datetime('now'))
                 )
             ''')
             
@@ -424,14 +325,13 @@ class ScreenplayDatabase:
     def create_session(user_query: str, screenplay_type: str, genre: str, language: str) -> str:
         session_id = hashlib.md5(f"{user_query}{screenplay_type}{datetime.now()}".encode()).hexdigest()
         target_pages = SCREENPLAY_LENGTHS[screenplay_type]["pages"]
-        min_pages = SCREENPLAY_LENGTHS[screenplay_type]["min_pages"]
         
         with ScreenplayDatabase.get_db() as conn:
             conn.cursor().execute(
                 '''INSERT INTO screenplay_sessions 
-                   (session_id, user_query, screenplay_type, genre, target_pages, min_pages, language) 
-                   VALUES (?, ?, ?, ?, ?, ?, ?)''',
-                (session_id, user_query, screenplay_type, genre, target_pages, min_pages, language)
+                   (session_id, user_query, screenplay_type, genre, target_pages, language) 
+                   VALUES (?, ?, ?, ?, ?, ?)''',
+                (session_id, user_query, screenplay_type, genre, target_pages, language)
             )
             conn.commit()
         return session_id
@@ -440,8 +340,6 @@ class ScreenplayDatabase:
     def save_stage(session_id: str, stage_number: int, stage_name: str,
                    role: str, content: str, status: str = 'complete'):
         page_count = 0
-        word_count = len(content.split()) if content else 0
-        
         if role == "screenwriter" and content:
             page_count = ScreenplayGenerationSystem.calculate_screenplay_pages(content)
         
@@ -449,32 +347,16 @@ class ScreenplayDatabase:
             cursor = conn.cursor()
             cursor.execute('''
                 INSERT INTO screenplay_stages 
-                (session_id, stage_number, stage_name, role, content, page_count, word_count, status)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                (session_id, stage_number, stage_name, role, content, page_count, status)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(session_id, stage_number)
-                DO UPDATE SET content=?, page_count=?, word_count=?, status=?, updated_at=datetime('now')
-            ''', (session_id, stage_number, stage_name, role, content, page_count, word_count, status,
-                  content, page_count, word_count, status))
-            
-            if role == "screenwriter" and "Final" in stage_name:
-                cursor.execute('''
-                    UPDATE screenplay_sessions 
-                    SET actual_pages = (
-                        SELECT SUM(page_count) 
-                        FROM screenplay_stages 
-                        WHERE session_id = ? 
-                        AND role = 'screenwriter' 
-                        AND stage_name LIKE '%Final%'
-                    ),
-                    updated_at = datetime('now')
-                    WHERE session_id = ?
-                ''', (session_id, session_id))
-            
+                DO UPDATE SET content=?, page_count=?, status=?, created_at=datetime('now')
+            ''', (session_id, stage_number, stage_name, role, content, page_count, status,
+                  content, page_count, status))
             conn.commit()
 
     @staticmethod
     def get_screenplay_content(session_id: str) -> str:
-        """Get complete screenplay content - only final versions"""
         with ScreenplayDatabase.get_db() as conn:
             rows = conn.cursor().execute('''
                 SELECT content FROM screenplay_stages 
@@ -495,65 +377,44 @@ class ScreenplayDatabase:
                 return '\n\n'.join(row['content'] for row in rows if row['content'])
         return ""
 
-class WebSearchIntegration:
-   """Web search functionality for screenplay research"""
-   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"Web search API error: {e}")
-           return []
+    @staticmethod
+    def get_active_sessions() -> List[Dict]:
+        with ScreenplayDatabase.get_db() as conn:
+            rows = conn.cursor().execute(
+                '''SELECT session_id, title, user_query, screenplay_type, genre, 
+                          created_at, current_stage, total_pages 
+                   FROM screenplay_sessions 
+                   WHERE status = 'active' 
+                   ORDER BY updated_at DESC 
+                   LIMIT 10'''
+            ).fetchall()
+            return [dict(row) for row in rows]
 
-   def extract_relevant_info(self, results: List[Dict], max_chars: int = 2000) -> str:
-       if not results:
-           return ""
-       extracted = []
-       total_chars = 0
-       for i, result in enumerate(results[:5], 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)
+    @staticmethod
+    def save_random_theme(theme_text: str, screenplay_type: str, genre: str, language: str) -> str:
+        theme_id = hashlib.md5(f"{theme_text}{datetime.now()}".encode()).hexdigest()[:12]
+        
+        with ScreenplayDatabase.get_db() as conn:
+            conn.cursor().execute('''
+                INSERT INTO screenplay_themes_library 
+                (theme_id, theme_text, screenplay_type, genre, language)
+                VALUES (?, ?, ?, ?, ?)
+            ''', (theme_id, theme_text, screenplay_type, genre, language))
+            conn.commit()
+        
+        return theme_id
 
 class ScreenplayGenerationSystem:
-    """Enhanced professional screenplay generation system"""
+    """Professional screenplay generation system"""
     def __init__(self):
         self.api_key = FIREWORKS_API_KEY
         self.api_url = API_URL
         self.model_id = MODEL_ID
         self.screenplay_tracker = ScreenplayTracker()
-        self.web_search = WebSearchIntegration()
         self.current_session_id = None
         ScreenplayDatabase.init_db()
 
     def create_headers(self):
-        """Create headers for API request"""
         if not self.api_key or self.api_key == "dummy_token_for_testing":
             raise ValueError("Valid FIREWORKS_API_KEY is required")
         
@@ -563,407 +424,109 @@ class ScreenplayGenerationSystem:
             "Authorization": f"Bearer {self.api_key}"
         }
 
-    # Enhanced prompt generation functions with more detail
+    def create_producer_prompt(self, user_query: str, screenplay_type: str, 
+                              genre: str, language: str) -> str:
+        lang_prompts = {
+            "Korean": f"""당신은 할리우드 프로듀서입니다. {screenplay_type} 컨셉을 개발하세요.
+
+**요청사항:** {user_query}
+**타입:** {SCREENPLAY_LENGTHS[screenplay_type]['description']}
+**장르:** {genre}
+
+**필수 제공 항목:**
+1. **제목 (TITLE)** - 기억하기 쉽고 마케팅 가능한 제목
+2. **로그라인 (LOGLINE)** - 25단어 이내 한 문장
+3. **장르 분석** - 주 장르와 서브 장���
+4. **타겟 관객** - 연령대와 관심사
+5. **비교 작품 (COMPS)** - 성공한 유사 프로젝트 3개
+6. **고유 판매 포인트 (USP)** - 독특한 점
+7. **비주얼 컨셉** - 핵심 이미지 3개""",
+
+            "English": f"""You are a Hollywood producer. Develop a {screenplay_type} concept.
+
+**Request:** {user_query}
+**Type:** {SCREENPLAY_LENGTHS[screenplay_type]['description']}
+**Genre:** {genre}
+
+**Required Elements:**
+1. **TITLE** - Memorable and marketable
+2. **LOGLINE** - One sentence, 25 words max
+3. **GENRE ANALYSIS** - Primary and sub-genre
+4. **TARGET AUDIENCE** - Age range and interests
+5. **COMPARABLE FILMS (COMPS)** - 3 successful similar projects
+6. **UNIQUE SELLING POINT (USP)** - What makes it unique
+7. **VISUAL CONCEPT** - 3 key visual images"""
+        }
+        return lang_prompts.get(language, lang_prompts["English"])
+
     def create_screenwriter_prompt(self, act: str, scene_breakdown: str, 
                                   characters: str, previous_acts: str,
                                   screenplay_type: str, genre: str, language: str,
                                   is_polish: bool = False, is_final: bool = False) -> str:
-        """Enhanced screenwriter prompt with multiple phases"""
         
         act_pages = int(SCREENPLAY_LENGTHS[screenplay_type]['pages'] * 0.25)
-        min_lines = int(act_pages * 60)  # Increased from 55 to 60 lines per page
-        genre_template = GENRE_TEMPLATES.get(genre, GENRE_TEMPLATES["drama"])
+        min_lines = int(act_pages * 65)  # Enhanced for longer content
         
-        # Different requirements for different phases
         if is_final:
-            min_lines = int(min_lines * 1.3)  # 30% more for final version
-            instruction_focus = "final polished version with rich details"
+            min_lines = int(min_lines * 1.4)
+            instruction_focus = "final polished extended version"
         elif is_polish:
-            min_lines = int(min_lines * 1.15)  # 15% more for polish
-            instruction_focus = "enhanced version with added depth"
+            min_lines = int(min_lines * 1.2)
+            instruction_focus = "enhanced expanded version"
         else:
-            instruction_focus = "complete initial draft"
+            instruction_focus = "complete detailed draft"
         
         lang_prompts = {
-            "Korean": f"""당신은 할리우드 A급 시나리오 작가입니다. {act}의 {instruction_focus}을 작성하세요.
-
-**목표 분량:** {act_pages}페이지 (최소 {min_lines}줄 필수)
-**절대 규칙: {min_lines}줄 미만은 불합격입니다. 반드시 초과 달성하세요.**
-
-**씬 브레이크다운:**
-{scene_breakdown}
-
-**캐릭터 정보:**
-{characters}
-
-**이전 내용:**
-{previous_acts if previous_acts else "첫 막입니다."}
-
-**필수 작성 요구사항:**
-
-1. **분량 달성 전략**
-   - 각 씬: 최소 4-6페이지 (240-360줄)
-   - 대화 시퀀스: 각 15-25줄 (캐릭터간 충분한 교환)
-   - 액션 묘사: 각 비트당 5-8줄 (시네마틱한 디테일)
-   - 캐릭터 반응: 표정, 제스처, 침묵의 순간 포함
-   - 환경 묘사: 각 씬 오프닝 10-15줄
-
-2. **대화 작성 심화**
-   - 서브텍스트 3층 구조 (표면/의도/진짜 감정)
-   - 캐릭터별 고유 어휘와 말버릇
-   - 갈등의 점진적 고조 (5단계 에스컬레이션)
-   - 대화 사이 행동과 반응 삽입
-   - 파워 다이나믹스 표현
-
-3. **액션 라인 시네마틱 묘사**
-   - 카메라 앵글 암시 (클로즈업, 와이드샷 등)
-   - 조명과 그림자 활용
-   - 소리와 음향 효과 묘사
-   - 날씨와 시간대 변화
-   - 소품과 의상의 상징적 활용
-
-4. **{genre} 장르 마스터리**
-   - 페이싱: {genre_template['pacing']} (비트당 {genre_template['scene_length']})
-   - 핵심 요소 모두 포함: {', '.join(genre_template['key_elements'])}
-   - 장르 특유 분위기 조성
-   - 관객 기대치 충족 + 신선한 반전
-
-5. **감정적 레이어링**
-   - 각 씬의 감정 아크 (시작-중간-끝)
-   - 캐릭터 내면 갈등 표현
-   - 비언어적 커뮤니케이션
-   - 긴장과 이완의 리듬
-
-6. **시각적 스토리텔링**
-   - 'Show, Don't Tell' 원칙 철저 준수
-   - 메타포와 상징 활용
-   - 반복 모티프 설정
-   - 색깔과 톤의 일관성
-
-**포맷 규칙:**
-INT./EXT. 장소 - 시간
-
-(씬 설정과 분위기를 10줄 이상으로 묘사)
-
-캐릭터명
-(감정/톤 지시)
-대사는 자연스럽고 캐릭터에 충실하게.
-
-(캐릭터 액션과 반응을 상세히)
-
-**반드시 {min_lines}줄 이상, 가능하면 {int(min_lines * 1.2)}줄까지 작성하세요.**""",
-
-        "English": f"""You are an A-list Hollywood screenwriter. Write the {instruction_focus} of {act}.
-
-**Target Length:** {act_pages} pages (MINIMUM {min_lines} lines required)
-**ABSOLUTE RULE: Less than {min_lines} lines is failure. Must exceed target.**
-
-**Scene Breakdown:**
-{scene_breakdown}
-
-**Character Info:**
-{characters}
-
-**Previous Content:**
-{previous_acts if previous_acts else "This is the first act."}
-
-**Required Writing Elements:**
-
-1. **Volume Achievement Strategy**
-   - Each scene: minimum 4-6 pages (240-360 lines)
-   - Dialogue sequences: 15-25 lines each (sufficient exchanges)
-   - Action descriptions: 5-8 lines per beat (cinematic detail)
-   - Character reactions: expressions, gestures, silent moments
-   - Environment descriptions: 10-15 lines per scene opening
-
-2. **Advanced Dialogue Crafting**
-   - Three-layer subtext (surface/intent/true emotion)
-   - Unique vocabulary and speech patterns per character
-   - Gradual conflict escalation (5-stage progression)
-   - Actions and reactions between dialogue
-   - Power dynamics expression
-
-3. **Cinematic Action Lines**
-   - Camera angle implications (close-ups, wide shots)
-   - Lighting and shadow usage
-   - Sound and audio effects
-   - Weather and time changes
-   - Symbolic use of props and costumes
-
-4. **{genre} Genre Mastery**
-   - Pacing: {genre_template['pacing']} (per beat: {genre_template['scene_length']})
-   - Include all key elements: {', '.join(genre_template['key_elements'])}
-   - Genre-specific atmosphere
-   - Meet expectations + fresh twists
-
-5. **Emotional Layering**
-   - Emotional arc per scene (beginning-middle-end)
-   - Character internal conflicts
-   - Non-verbal communication
-   - Tension and release rhythm
-
-6. **Visual Storytelling**
-   - Strict 'Show, Don't Tell' principle
-   - Metaphor and symbol usage
-   - Recurring motifs
-   - Color and tone consistency
-
-**Format Rules:**
-INT./EXT. LOCATION - TIME
-
-(Describe scene setting and atmosphere in 10+ lines)
-
-CHARACTER NAME
-(emotion/tone direction)
-Natural dialogue true to character.
-
-(Detail character actions and reactions)
-
-**MUST write {min_lines}+ lines, ideally up to {int(min_lines * 1.2)} lines.**"""
-        }
-    
-        return lang_prompts.get(language, lang_prompts["English"])
-
-    def create_world_builder_prompt(self, producer_concept: str, story_structure: str,
-                                   screenplay_type: str, genre: str, language: str) -> str:
-        """World building prompt for atmosphere and setting"""
-        
-        lang_prompts = {
-            "Korean": f"""당신은 세계관 디자이너입니다. {screenplay_type}의 몰입감 있는 세계를 구축하세요.
-
-**프로듀서 컨셉:**
-{producer_concept}
-
-**스토리 구조:**
-{story_structure}
-
-**필수 구축 요소:**
-
-1. **시공간 설정**
-   - 시대: (구체적 연도/시대)
-   - 지리적 위치: (도시/국가/행성)
-   - 사회적 배경: (정치/경제/문화)
-   - 계절과 날씨 패턴:
-
-2. **주요 로케이션 (최소 8개)**
-   각 장소별:
-   - 이름과 설명:
-   - 시각적 특징:
-   - 분위기와 톤:
-   - 스토리 기능:
-   - 상징적 의미:
-
-3. **세계관 규칙**
-   - 물리 법칙: (현실적/판타지/SF)
-   - 사회 규칙과 관습:
-   - 기술 수준:
-   - 초자연적 요소: (있다면)
-
-4. **시각적 디자인**
-   - 전체 색상 팔레트:
-   - 조명 스타일:
-   - 카메라 스타일:
-   - 의상과 프로덕션 디자인:
-   - 참조 영화/시각 자료:
-
-5. **사운드스케이프**
-   - 환경음:
-   - 음악 스타일:
-   - 특징적 사운드:
-   - 침묵의 활용:
-
-6. **분위기와 톤**
-   - 전체적 무드:
-   - 장르별 분위기:
-   - 감정적 온도:
-   - 관객이 느낄 감각:
-
-7. **문화적 디테일**
-   - 언어와 방언:
-   - 관습과 전통:
-   - 음식과 일상:
-   - 종교/신념 체계:
-
-구체적이고 시각적으로 풍부한 세계를 만드세요.""",
-
-            "English": f"""You are a world builder. Create an immersive world for this {screenplay_type}.
-
-**Producer Concept:**
-{producer_concept}
-
-**Story Structure:**
-{story_structure}
-
-**Required Building Elements:**
-
-1. **Time & Space Setting**
-   - Era: (specific year/period)
-   - Geographic location: (city/country/planet)
-   - Social context: (political/economic/cultural)
-   - Season and weather patterns:
-
-2. **Key Locations (minimum 8)**
-   For each location:
-   - Name and description:
-   - Visual characteristics:
-   - Atmosphere and tone:
-   - Story function:
-   - Symbolic meaning:
-
-3. **World Rules**
-   - Physical laws: (realistic/fantasy/sci-fi)
-   - Social rules and customs:
-   - Technology level:
-   - Supernatural elements: (if any)
-
-4. **Visual Design**
-   - Overall color palette:
-   - Lighting style:
-   - Camera style:
-   - Costume and production design:
-   - Reference films/visuals:
-
-5. **Soundscape**
-   - Ambient sounds:
-   - Music style:
-   - Signature sounds:
-   - Use of silence:
-
-6. **Atmosphere & Tone**
-   - Overall mood:
-   - Genre-specific atmosphere:
-   - Emotional temperature:
-   - Audience sensory experience:
-
-7. **Cultural Details**
-   - Language and dialects:
-   - Customs and traditions:
-   - Food and daily life:
-   - Religion/belief systems:
-
-Create a specific, visually rich world."""
-        }
-        
-        return lang_prompts.get(language, lang_prompts["English"])
-
-    def create_dialogue_specialist_prompt(self, complete_screenplay: str, 
-                                         characters: str, genre: str, language: str) -> str:
-        """Dialogue enhancement specialist prompt"""
-        
-        lang_prompts = {
-            "Korean": f"""당신은 대화 전문가입니다. 시나리오의 대화를 한 단계 업그레이드하세요.
-
-**작성된 시나리오 검토 후 다음 개선:**
-
-1. **대화 자연스러움**
-   - 일상적 리듬과 호흡
-   - 말 끊김, 중복, 더듬기
-   - 자연스러운 전환
-
-2. **캐릭터 고유성**
-   - 각자의 어휘 수준
-   - 말투와 억양
-   - 습관적 표현
-   - 교육/배경 반영
-
-3. **서브텍스트 강화**
-   - 말하지 않는 것이 더 중요
-   - 이중적 의미
-   - 감정과 대사의 대비
-
-4. **갈등과 긴장**
-   - 대화를 통한 파워게임
-   - 숨겨진 의도
-   - 점진적 폭발
-
-5. **{genre} 장르 특화**
-   - 장르 관습 준수
-   - 기대되는 대사 스타일
-   - 명대사 창조
-
-6. **리듬과 페이싱**
-   - 짧고 긴 대사 균형
-   - 침묵의 활용
-   - 템포 변화
-
-각 캐릭터별 시그니처 대사 5개씩 제시하세요.""",
+            "Korean": f"""프로 시나리오 작가로서 {act}의 {instruction_focus}을 작성하세요.
 
-            "English": f"""You are a dialogue specialist. Elevate the screenplay's dialogue.
+**목표:** {act_pages}페이지 (최소 {min_lines}줄 필수)
 
-**After reviewing the screenplay, improve:**
+**씬 정보:** {scene_breakdown}
+**캐릭터:** {characters}
+**이전 내용:** {previous_acts if previous_acts else "첫 막입니다."}
 
-1. **Dialogue Naturalness**
-   - Everyday rhythm and breathing
-   - Interruptions, overlaps, stammers
-   - Natural transitions
+각 씬마다:
+- 최소 5-7페이지 분량
+- 충분한 대화와 액션
+- 디테일한 묘사
+- 감정적 깊이
 
-2. **Character Uniqueness**
-   - Individual vocabulary levels
-   - Speech patterns and accents
-   - Habitual expressions
-   - Education/background reflection
+반드시 {min_lines}줄 이상 작성하세요.""",
 
-3. **Subtext Enhancement**
-   - What's unsaid matters more
-   - Double meanings
-   - Emotion vs. dialogue contrast
+            "English": f"""As a professional screenwriter, write the {instruction_focus} of {act}.
 
-4. **Conflict and Tension**
-   - Power games through dialogue
-   - Hidden agendas
-   - Gradual explosion
+**Target:** {act_pages} pages (minimum {min_lines} lines required)
 
-5. **{genre} Genre Specialization**
-   - Genre convention adherence
-   - Expected dialogue style
-   - Memorable lines creation
+**Scene Info:** {scene_breakdown}
+**Characters:** {characters}
+**Previous:** {previous_acts if previous_acts else "This is Act 1."}
 
-6. **Rhythm and Pacing**
-   - Short and long dialogue balance
-   - Use of silence
-   - Tempo changes
+For each scene:
+- Minimum 5-7 pages
+- Sufficient dialogue and action
+- Detailed descriptions
+- Emotional depth
 
-Provide 5 signature lines per major character."""
+MUST write {min_lines}+ lines."""
         }
         
         return lang_prompts.get(language, lang_prompts["English"])
 
-    # Enhanced LLM call functions for Fireworks AI
-    def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
-        """Synchronous LLM call"""
-        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}")
-        return full_content
-
     def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, 
                           language: str) -> Generator[str, None, None]:
-        """Enhanced streaming with Fireworks AI"""
         try:
-            logger.info(f"Calling Fireworks AI for role: {role}, language: {language}")
-            
-            system_prompts = self.get_system_prompts(language)
-            system_content = system_prompts.get(role, "")
-            
-            if not system_content:
-                logger.warning(f"No system prompt found for role: {role}")
-                system_content = "You are a professional screenwriter."
+            system_content = f"You are a professional {role} creating high-quality screenplay content."
             
             full_messages = [
                 {"role": "system", "content": system_content}, 
                 *messages
             ]
             
-            # Increased max tokens for longer content
-            max_tokens = 15000
-            
             payload = {
                 "model": self.model_id,
                 "messages": full_messages,
-                "max_tokens": max_tokens,
-                "temperature": 0.8 if role in ["screenwriter", "dialogue_specialist"] else 0.7,
+                "max_tokens": 15000,
+                "temperature": 0.8 if role == "screenwriter" else 0.7,
                 "top_p": 1,
                 "top_k": 40,
                 "presence_penalty": 0.2,
@@ -978,247 +541,231 @@ Provide 5 signature lines per major character."""
                 headers=headers, 
                 json=payload, 
                 stream=True, 
-                timeout=300  # Increased timeout for longer responses
+                timeout=300
             )
             
-            logger.info(f"API Response Status: {response.status_code}")
-            
             if response.status_code != 200:
-                error_msg = f"API Error (Status Code: {response.status_code})"
-                try:
-                    error_data = response.json()
-                    logger.error(f"API Error Response: {error_data}")
-                    if isinstance(error_data, dict):
-                        if 'error' in error_data:
-                            error_msg += f" - {error_data['error']}"
-                except Exception as e:
-                    logger.error(f"Error parsing error response: {e}")
-                    error_msg += f" - {response.text[:200]}"
-                
-                yield f"❌ {error_msg}"
+                yield f"❌ API Error: {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
                     
-                    if not data_str:
-                        continue
-                    
                     data = json.loads(data_str)
-                    
                     if "choices" in data and len(data["choices"]) > 0:
-                        delta = data["choices"][0].get("delta", {})
-                        content = delta.get("content", "")
+                        content = data["choices"][0].get("delta", {}).get("content", "")
                         if content:
                             buffer += content
-                            
                             if len(buffer) >= 100 or '\n' in buffer:
                                 yield buffer
                                 buffer = ""
-                                
-                except Exception as e:
-                    logger.error(f"Error processing line: {str(e)}")
+                except:
                     continue
             
             if buffer:
                 yield buffer
                 
         except Exception as e:
-            logger.error(f"Streaming error: {type(e).__name__}: {str(e)}")
             yield f"❌ Error: {str(e)}"
 
-    def get_system_prompts(self, language: str) -> Dict[str, str]:
-        """Enhanced role-specific system prompts"""
-        
-        base_prompts = {
-            "Korean": {
-                "producer": """당신은 30년 경력의 할리우드 프로듀서입니다.
-상업적 성공과 예술적 완성도를 모두 달성한 작품들을 제작했습니다.
-시장 트렌드를 정확히 읽고 관객의 욕구를 파악합니다.
-혁신적이면서도 실현 가능한 프로젝트를 개발합니다.""",
-                
-                "story_developer": """당신은 아카데미상 수상 경력의 스토리 개발자입니다.
-복잡하고 다층적인 내러티브를 구축하는 전문가입니다.
-감정적 진실과 구조적 완벽함을 추구합니다.
-보편적 주제를 독창적으로 표현합니다.""",
-                
-                "character_designer": """당신은 method acting을 연구한 캐릭터 디자이너입니다.
-살아있는 인물을 창조하는 전문가입니다.
-심리학적 깊이와 행동적 일관성을 부여합니다.
-복잡한 인간 본성을 섬세하게 포착합니다.""",
-                
-                "world_builder": """당신은 프로덕션 디자이너이자 세계관 설계자입니다.
-몰입감 있는 세계를 창조하는 비주얼 스토리텔러입니다.
-디테일과 일관성으로 믿을 수 있는 세계를 구축합니다.
-시각적 은유와 상징을 능숙하게 활용합니다.""",
-                
-                "scene_planner": """당신은 편집 감각을 지닌 씬 구성 전문가입니다.
-각 씬이 전체 내러티브에 기여하도록 설계합니다.
-리듬, 페이싱, 긴장감을 마스터했습니다.
-시각적 스토리텔링을 극대화합니다.""",
-                
-                "screenwriter": """당신은 WGA 수상 경력의 시나리오 작가입니다.
-'보여주기'의 대가이며 서브텍스트의 마스터입니다.
-캐릭터의 목소리를 완벽하게 구현합니다.
-시네마틱한 비전과 실용적 제작 감각을 겸비했습니다.""",
-                
-                "script_doctor": """당신은 블록버스터 전문 스크립트 닥터입니다.
-약한 부분을 찾아 강화하는 전문가입니다.
-스토리의 잠재력을 200% 끌어냅니다.
-정확하고 실행 가능한 개선안을 제시합니다.""",
-                
-                "dialogue_specialist": """당신은 대화 전문 작가입니다.
-자연스러우면서도 의미 있는 대화를 창조합니다.
-각 캐릭터의 고유한 목소리를 만듭니다.
-서브텍스트와 감정의 뉘앙스를 완벽히 표현합니다.""",
-                
-                "critic_structure": """당신은 스토리 구조 분석가입니다.
-내러티브의 강점과 약점을 정확히 진단합니다.
-논리적 일관성과 감정적 임팩트를 평가합니다.
-구체적이고 실용적인 개선 방안을 제시합니다.""",
-                
-                "final_reviewer": """당신은 스튜디오 수석 리뷰어입니다.
-상업성과 예술성을 균형있게 평가합니다.
-제작, 배급, 마케팅 관점을 모두 고려합니다.
-건설적이면서도 정직한 피드백을 제공합니다."""
-            },
-            "English": {
-                "producer": """You are a Hollywood producer with 30 years experience.
-You've produced both commercial successes and artistic achievements.
-You accurately read market trends and understand audience desires.
-You develop innovative yet feasible projects.""",
-                
-                "story_developer": """You are an Academy Award-winning story developer.
-You're an expert at building complex, multi-layered narratives.
-You pursue emotional truth and structural perfection.
-You express universal themes in original ways.""",
-                
-                "character_designer": """You are a character designer who studied method acting.
-You're an expert at creating living, breathing characters.
-You provide psychological depth and behavioral consistency.
-You delicately capture complex human nature.""",
-                
-                "world_builder": """You are a production designer and world architect.
-You're a visual storyteller creating immersive worlds.
-You build believable worlds with detail and consistency.
-You skillfully utilize visual metaphors and symbols.""",
-                
-                "scene_planner": """You are a scene construction expert with editing sense.
-You design each scene to contribute to the overall narrative.
-You've mastered rhythm, pacing, and tension.
-You maximize visual storytelling.""",
-                
-                "screenwriter": """You are a WGA award-winning screenwriter.
-You're a master of 'showing' and subtext.
-You perfectly implement each character's voice.
-You combine cinematic vision with practical production sense.""",
-                
-                "script_doctor": """You are a blockbuster script doctor.
-You're an expert at finding and strengthening weak points.
-You draw out 200% of the story's potential.
-You provide accurate, actionable improvements.""",
-                
-                "dialogue_specialist": """You are a dialogue specialist writer.
-You create natural yet meaningful dialogue.
-You craft each character's unique voice.
-You perfectly express subtext and emotional nuance.""",
-                
-                "critic_structure": """You are a story structure analyst.
-You accurately diagnose narrative strengths and weaknesses.
-You evaluate logical consistency and emotional impact.
-You provide specific, practical improvement plans.""",
-                
-                "final_reviewer": """You are a studio senior reviewer.
-You evaluate commercial and artistic value in balance.
-You consider production, distribution, and marketing perspectives.
-You provide constructive yet honest feedback."""
-            }
-        }
-        
-        return base_prompts.get(language, base_prompts["English"])
-
     @staticmethod
     def calculate_screenplay_pages(content: str) -> float:
-        """Enhanced screenplay page calculation"""
         if not content:
             return 0.0
-            
         lines = content.split('\n')
-        total_line_count = 0
-        
-        for i, line in enumerate(lines):
-            stripped_line = line.strip()
-            
-            if not stripped_line:
-                total_line_count += 1
-                continue
-            
-            # Scene heading
-            if stripped_line.startswith(('INT.', 'EXT.')):
-                total_line_count += 3
-            
-            # Character name
-            elif stripped_line.isupper() and len(stripped_line.split()) <= 3:
-                total_line_count += 2
+        total_lines = len(lines)
+        return total_lines / 58.0
+
+    def process_screenplay_stream(self, query: str, screenplay_type: str, genre: str,
+                                language: str) -> Generator[Tuple[str, List[Dict], str], None, None]:
+        try:
+            self.current_session_id = ScreenplayDatabase.create_session(
+                query, screenplay_type, genre, language
+            )
             
-            # Parenthetical
-            elif stripped_line.startswith('(') and stripped_line.endswith(')'):
-                total_line_count += 1
+            stages = []
             
-            # Dialogue
-            elif len(stripped_line) < 60:
-                is_dialogue = False
-                for j in range(max(0, i-2), i):
-                    if j < len(lines):
-                        prev_line = lines[j].strip()
-                        if prev_line.isupper() and len(prev_line.split()) <= 3:
-                            is_dialogue = True
-                            break
+            for stage_idx in range(len(SCREENPLAY_STAGES)):
+                role, stage_name = SCREENPLAY_STAGES[stage_idx]
                 
-                if is_dialogue:
-                    total_line_count += 1
+                if stage_idx >= len(stages):
+                    stages.append({
+                        "name": stage_name, 
+                        "status": "active", 
+                        "content": "", 
+                        "page_count": 0
+                    })
                 else:
-                    wrapped_lines = len(stripped_line) / 60
-                    total_line_count += max(1, int(wrapped_lines))
-            
-            # Action lines
-            else:
-                wrapped_lines = len(stripped_line) / 60
-                total_line_count += max(1, int(wrapped_lines))
+                    stages[stage_idx]["status"] = "active"
+
+                yield f"🔄 Processing {stage_name}...", stages, self.current_session_id
+                
+                # Generate prompt based on stage
+                if stage_idx == 0:  # Producer
+                    prompt = self.create_producer_prompt(query, screenplay_type, genre, language)
+                elif "Act" in stage_name and role == "screenwriter":
+                    # Determine act and phase
+                    act = "Act 1" if stage_idx < 10 else "Act 2A" if stage_idx < 14 else "Act 2B" if stage_idx < 18 else "Act 3"
+                    is_polish = "Polish" in stage_name
+                    is_final = "Final" in stage_name
+                    prompt = self.create_screenwriter_prompt(
+                        act, "", "", "", screenplay_type, genre, language, is_polish, is_final
+                    )
+                else:
+                    prompt = f"Generate content for {stage_name}"
+                
+                stage_content = ""
+                
+                for chunk in self.call_llm_streaming(
+                    [{"role": "user", "content": prompt}], 
+                    role, language
+                ):
+                    stage_content += chunk
+                    stages[stage_idx]["content"] = stage_content
+                    if role == "screenwriter":
+                        stages[stage_idx]["page_count"] = len(stage_content.split('\n')) / 58
+                    yield f"🔄 {stage_name} in progress...", stages, self.current_session_id
+
+                stages[stage_idx]["status"] = "complete"
+                ScreenplayDatabase.save_stage(
+                    self.current_session_id, stage_idx, stage_name, role,
+                    stage_content, "complete"
+                )
+                
+                yield f"✅ {stage_name} completed", stages, self.current_session_id
+
+            final_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
+            yield f"✅ Screenplay completed!", stages, self.current_session_id
+
+        except Exception as e:
+            logger.error(f"Error: {e}")
+            yield f"❌ Error: {e}", stages if 'stages' in locals() else [], self.current_session_id
+
+# Utility functions
+def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str:
+    themes = {
+        'action': ['revenge mission', 'heist gone wrong', 'rescue operation'],
+        'thriller': ['conspiracy uncovered', 'false accusation', 'witness protection'],
+        'drama': ['family reunion', 'terminal diagnosis', 'second chance'],
+        'comedy': ['mistaken identity', 'wedding disaster', 'odd couple'],
+        'horror': ['haunted location', 'ancient curse', 'survival'],
+        'sci-fi': ['time paradox', 'AI awakening', 'space colony'],
+        'romance': ['enemies to lovers', 'second chance', 'forbidden love']
+    }
+    
+    theme_list = themes.get(genre, themes['drama'])
+    selected = random.choice(theme_list)
+    
+    if language == "Korean":
+        return f"**컨셉:** {selected}\n갈등과 캐릭터 성장이 있는 이야기"
+    else:
+        return f"**Concept:** {selected}\nA story with conflict and character growth"
+
+def format_screenplay_display(screenplay_text: str) -> str:
+    if not screenplay_text:
+        return "No screenplay content yet."
+    
+    formatted = "# 🎬 Screenplay\n\n"
+    
+    # Format scene headings
+    formatted_text = re.sub(
+        r'^(INT\.|EXT\.).*$',
+        r'**\g<0>**',
+        screenplay_text,
+        flags=re.MULTILINE
+    )
+    
+    # Format character names
+    formatted_text = re.sub(
+        r'^([A-Z][A-Z\s]+)$',
+        r'**\g<0>**',
+        formatted_text,
+        flags=re.MULTILINE
+    )
+    
+    # Calculate pages
+    page_count = len(screenplay_text.splitlines()) / 58
+    formatted = f"**Total Pages: {page_count:.1f}**\n\n" + formatted_text
+    
+    return formatted
+
+def format_stages_display(stages: List[Dict]) -> str:
+    markdown = "## 🎬 Production Progress\n\n"
+    
+    completed = sum(1 for s in stages if s.get('status') == 'complete')
+    total = len(stages)
+    markdown += f"**Progress: {completed}/{total} stages complete**\n\n"
+    
+    total_pages = sum(s.get('page_count', 0) for s in stages if s.get('page_count'))
+    if total_pages > 0:
+        markdown += f"**Current Page Count: {total_pages:.1f} pages**\n\n"
+    
+    markdown += "---\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']}**"
         
-        # Enhanced calculation for better accuracy
-        pages = total_line_count / 58.0  # Slightly adjusted for more accurate page count
+        if stage.get('page_count', 0) > 0:
+            markdown += f" ({stage['page_count']:.1f} pages)"
         
-        return pages
+        markdown += "\n"
+        
+        if stage['content'] and stage['status'] == 'complete':
+            preview = stage['content'][:200] + "..." if len(stage['content']) > 200 else stage['content']
+            markdown += f"> {preview}\n\n"
+        elif stage['status'] == 'active':
+            markdown += "> *In progress...*\n\n"
+    
+    return markdown
+
+def process_query(query: str, screenplay_type: str, genre: str, language: str) -> Generator[Tuple[str, str, str, str], None, None]:
+    if not query.strip():
+        yield "", "", "❌ Please enter a screenplay concept.", ""
+        return
+    
+    system = ScreenplayGenerationSystem()
+    stages_markdown = ""
+    screenplay_display = ""
+    
+    for status, stages, session_id in system.process_screenplay_stream(
+        query, screenplay_type, genre, language
+    ):
+        stages_markdown = format_stages_display(stages)
+        
+        if stages and all(s.get("status") == "complete" for s in stages[-4:]):
+            screenplay_text = ScreenplayDatabase.get_screenplay_content(session_id)
+            screenplay_display = format_screenplay_display(screenplay_text)
+        
+        yield stages_markdown, screenplay_display, status, session_id
 
-    # Main process functions continue...
-    # [Rest of the implementation remains similar with enhanced prompts and processing]
+def get_active_sessions_list() -> List[str]:
+    sessions = ScreenplayDatabase.get_active_sessions()
+    return [
+        f"{s['session_id'][:8]}... - {s.get('title', s['user_query'][:30])}... "
+        f"({s['screenplay_type']}/{s['genre']}) [{s['total_pages']:.1f} pages]"
+        for s in sessions
+    ]
 
-# Create enhanced Gradio interface
+# Create Gradio interface
 def create_interface():
-    """Create enhanced Gradio interface"""
-    
     css = """
-    /* Enhanced CSS styling */
     .main-header {
         text-align: center;
         margin-bottom: 2rem;
         padding: 2.5rem;
-        background: linear-gradient(135deg, #1a1a2e 0%, #0f1419 50%, #16213e 100%);
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
         border-radius: 15px;
         color: white;
         box-shadow: 0 10px 30px rgba(0,0,0,0.3);
@@ -1227,38 +774,18 @@ def create_interface():
     .header-title {
         font-size: 3.5rem;
         margin-bottom: 1rem;
-        background: linear-gradient(90deg, #ff6b6b, #4ecdc4, #45b7d1);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        animation: gradient 3s ease infinite;
-    }
-    
-    @keyframes gradient {
-        0% { background-position: 0% 50%; }
-        50% { background-position: 100% 50%; }
-        100% { background-position: 0% 50%; }
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
     }
     
     #screenplay-output {
-        font-family: 'Courier Prime', 'Courier New', monospace;
+        font-family: 'Courier New', monospace;
         white-space: pre-wrap;
-        background: linear-gradient(to bottom, #ffffff, #f8f9fa);
-        padding: 3rem;
+        background: white;
+        padding: 2rem;
         border: 2px solid #e0e0e0;
-        border-radius: 12px;
-        max-height: 900px;
+        border-radius: 10px;
+        max-height: 800px;
         overflow-y: auto;
-        box-shadow: 0 5px 15px rgba(0,0,0,0.1);
-    }
-    
-    .status-box {
-        padding: 1rem;
-        border-radius: 8px;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        font-weight: bold;
-        text-align: center;
-        margin: 1rem 0;
     }
     """
     
@@ -1266,31 +793,176 @@ def create_interface():
         gr.HTML("""
         <div class="main-header">
             <h1 class="header-title">🎬 AI Screenplay Generator Pro</h1>
-            <p class="header-description">
-                Professional-grade screenplay generation with extended content and cinematic depth.
-                Powered by advanced AI to create feature films, TV shows, and streaming content.
+            <p style="font-size: 1.2rem; opacity: 0.95;">
+                Professional screenplay generation powered by advanced AI<br>
+                Create feature films, TV shows, and streaming content with extended scenes and rich dialogue
             </p>
         </div>
         """)
         
-        # Rest of interface setup continues...
-        # [Interface implementation remains similar with enhanced features]
+        current_session_id = gr.State(None)
+        
+        with gr.Tabs():
+            with gr.Tab("✍️ Write Screenplay"):
+                with gr.Row():
+                    with gr.Column(scale=3):
+                        query_input = gr.Textbox(
+                            label="📝 Screenplay Concept",
+                            placeholder="""Describe your screenplay idea. For example:
+- A detective with memory loss must solve their own attempted murder
+- Two rival food truck owners forced to work together
+- A space station AI develops consciousness during a critical mission
+- A family reunion turns into a murder mystery during a hurricane""",
+                            lines=6
+                        )
+                    
+                    with gr.Column(scale=1):
+                        screenplay_type = gr.Radio(
+                            choices=list(SCREENPLAY_LENGTHS.keys()),
+                            value="movie",
+                            label="📽️ Screenplay Type",
+                            info="Choose your format"
+                        )
+                        
+                        genre_select = gr.Dropdown(
+                            choices=list(GENRE_TEMPLATES.keys()),
+                            value="drama",
+                            label="🎭 Primary Genre",
+                            info="Select main genre"
+                        )
+                        
+                        language_select = gr.Radio(
+                            choices=["English", "Korean"],
+                            value="English",
+                            label="🌍 Language"
+                        )
+                
+                with gr.Row():
+                    random_btn = gr.Button("🎲 Random Concept", scale=1)
+                    clear_btn = gr.Button("🗑️ Clear", scale=1)
+                    submit_btn = gr.Button("🎬 Start Writing", variant="primary", scale=2)
+                
+                status_text = gr.Textbox(
+                    label="📊 Status",
+                    interactive=False,
+                    value="Ready to create your screenplay"
+                )
+                
+                with gr.Row():
+                    with gr.Column():
+                        with gr.Tab("🎭 Writing Progress"):
+                            stages_display = gr.Markdown(
+                                value="*Your screenplay journey will unfold here...*"
+                            )
+                        
+                        with gr.Tab("📄 Screenplay"):
+                            screenplay_output = gr.Markdown(
+                                value="*Your formatted screenplay will appear here...*"
+                            )
+                            
+                            with gr.Row():
+                                format_select = gr.Radio(
+                                    choices=["PDF", "FDX", "FOUNTAIN", "TXT"],
+                                    value="TXT",
+                                    label="Export Format"
+                                )
+                                download_btn = gr.Button("📥 Download", variant="secondary")
+                
+                gr.Examples(
+                    examples=[
+                        ["A burned-out teacher discovers her students are being replaced by AI duplicates"],
+                        ["Two funeral home employees accidentally release a ghost who helps them solve murders"],
+                        ["A time-loop forces a wedding planner to relive the worst wedding"],
+                        ["An astronaut returns to Earth to find everyone has forgotten space exists"]
+                    ],
+                    inputs=query_input,
+                    label="💡 Example Concepts"
+                )
+            
+            with gr.Tab("📚 Saved Projects"):
+                gr.Markdown("### 📁 Your Screenplay Projects")
+                with gr.Row():
+                    session_dropdown = gr.Dropdown(
+                        label="Active Sessions",
+                        choices=[],
+                        interactive=True,
+                        scale=3
+                    )
+                    refresh_btn = gr.Button("🔄 Refresh", scale=1)
+                    load_btn = gr.Button("📂 Load", scale=1)
+        
+        # Event handlers
+        def handle_submit(query, s_type, genre, lang, session_id):
+            if not query:
+                yield "", "", "❌ Please enter a concept", session_id
+                return
+            
+            yield from process_query(query, s_type, genre, lang)
+        
+        def handle_random(s_type, genre, lang):
+            return generate_random_screenplay_theme(s_type, genre, lang)
+        
+        def handle_clear():
+            return "", "", "Ready to create your screenplay", None
+        
+        def handle_download(screenplay_text, format_type):
+            if not screenplay_text:
+                return None
+            
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"screenplay_{timestamp}.txt"
+            
+            with open(filename, 'w', encoding='utf-8') as f:
+                f.write(screenplay_text)
+            
+            return filename
+        
+        # Connect events
+        submit_btn.click(
+            fn=handle_submit,
+            inputs=[query_input, screenplay_type, genre_select, language_select, current_session_id],
+            outputs=[stages_display, screenplay_output, status_text, current_session_id]
+        )
+        
+        random_btn.click(
+            fn=handle_random,
+            inputs=[screenplay_type, genre_select, language_select],
+            outputs=[query_input]
+        )
+        
+        clear_btn.click(
+            fn=handle_clear,
+            outputs=[stages_display, screenplay_output, status_text, current_session_id]
+        )
+        
+        refresh_btn.click(
+            fn=get_active_sessions_list,
+            outputs=[session_dropdown]
+        )
+        
+        download_btn.click(
+            fn=handle_download,
+            inputs=[screenplay_output, format_select],
+            outputs=[gr.File(label="Download")]
+        )
+        
+        interface.load(
+            fn=get_active_sessions_list,
+            outputs=[session_dropdown]
+        )
     
     return interface
 
-# Main execution
+# Main
 if __name__ == "__main__":
-    logger.info("Enhanced Screenplay Generator Starting...")
     logger.info("=" * 60)
-    logger.info("Using Fireworks AI API")
-    logger.info(f"Model: {MODEL_ID}")
-    logger.info("Max tokens per request: 15000")
+    logger.info("AI Screenplay Generator Pro Starting...")
+    logger.info(f"Using Fireworks AI: {MODEL_ID}")
+    logger.info(f"Max tokens: 15000")
     logger.info("=" * 60)
     
-    # Initialize database
     ScreenplayDatabase.init_db()
     
-    # Create and launch interface
     interface = create_interface()
     interface.launch(
         server_name="0.0.0.0",