Update app.py

app.py

@@ -5,6 +5,7 @@ from core.visual_engine import VisualEngine
 from core.prompt_engineering import (
     create_cinematic_treatment_prompt,
     construct_dalle_prompt,
+    construct_text_to_video_prompt, # Import new function
     create_narration_script_prompt_enhanced,
     create_scene_regeneration_prompt,
     create_visual_regeneration_prompt
@@ -17,7 +18,6 @@ st.set_page_config(page_title="CineGen AI Ultra+", layout="wide", initial_sideba
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# <<< ADDED/MODIFIED START >>>
 # --- Global Definitions for New Features ---
 SHOT_TYPES_OPTIONS = [
     "Director's Choice", "Establishing Shot", "Long Shot", "Full Shot",
@@ -26,9 +26,9 @@ SHOT_TYPES_OPTIONS = [
     "Over the Shoulder", "Tracking Shot", "Dolly Zoom", "Crane Shot",
     "Aerial Shot", "Static Shot", "Dutch Angle", "Whip Pan"
 ]
-DEFAULT_SCENE_DURATION_SECS = 5  # Default duration in seconds for each scene
+DEFAULT_SCENE_DURATION_SECS = 5
 DEFAULT_SHOT_TYPE = "Director's Choice"
-# <<< ADDED/MODIFIED END >>>
+ASSET_TYPE_OPTIONS = ["Auto (Director's Choice)", "Image", "Video Clip"] # For user selection
 
 
 # --- Global State Variables & API Key Setup ---
@@ -52,6 +52,7 @@ if 'services_initialized' not in st.session_state:
     st.session_state.ELEVENLABS_API_KEY = load_api_key("ELEVENLABS_API_KEY", "ELEVENLABS_API_KEY", "ElevenLabs")
     st.session_state.PEXELS_API_KEY = load_api_key("PEXELS_API_KEY", "PEXELS_API_KEY", "Pexels")
     st.session_state.ELEVENLABS_VOICE_ID_CONFIG = load_api_key("ELEVENLABS_VOICE_ID", "ELEVENLABS_VOICE_ID", "ElevenLabs Voice ID")
+    st.session_state.RUNWAY_API_KEY = load_api_key("RUNWAY_API_KEY", "RUNWAY_API_KEY", "RunwayML") # Load Runway Key
 
     if not st.session_state.GEMINI_API_KEY:
         st.error("CRITICAL: Gemini API Key is essential and missing!"); logger.critical("Gemini API Key missing. Halting."); st.stop()
@@ -62,15 +63,16 @@ if 'services_initialized' not in st.session_state:
     except Exception as e: st.error(f"Failed to init GeminiHandler: {e}"); logger.critical(f"GeminiHandler init failed: {e}", exc_info=True); st.stop()
 
     try:
-        default_voice_id = "Rachel" # A common fallback if no secret is set
+        default_voice_id = "Rachel"
         configured_voice_id = st.session_state.ELEVENLABS_VOICE_ID_CONFIG or default_voice_id
         st.session_state.visual_engine = VisualEngine(
             output_dir="temp_cinegen_media",
-            default_elevenlabs_voice_id=configured_voice_id # Pass it to __init__
+            default_elevenlabs_voice_id=configured_voice_id
         )
         st.session_state.visual_engine.set_openai_api_key(st.session_state.OPENAI_API_KEY)
         st.session_state.visual_engine.set_elevenlabs_api_key(st.session_state.ELEVENLABS_API_KEY, voice_id_from_secret=st.session_state.ELEVENLABS_VOICE_ID_CONFIG)
         st.session_state.visual_engine.set_pexels_api_key(st.session_state.PEXELS_API_KEY)
+        st.session_state.visual_engine.set_runway_api_key(st.session_state.RUNWAY_API_KEY) # Set Runway Key
         logger.info("VisualEngine initialized and API keys set (or attempted).")
     except Exception as e:
         st.error(f"Failed to init VisualEngine or set its API keys: {e}"); logger.critical(f"VisualEngine init/key setting failed: {e}", exc_info=True)
@@ -78,30 +80,86 @@ if 'services_initialized' not in st.session_state:
     st.session_state.services_initialized = True; logger.info("Service initialization sequence complete.")
 
 # Initialize other session state variables
+# <<< MODIFIED START >>> : Renamed generated_visual_paths to generated_scene_assets
 for key, default_val in [
-    ('story_treatment_scenes', []), ('scene_dalle_prompts', []), ('generated_visual_paths', []),
+    ('story_treatment_scenes', []), ('scene_prompts', []), ('generated_scene_assets', []), # Stores dicts: {'path':..., 'type':...}
     ('video_path', None), ('character_definitions', {}), ('global_style_additions', ""),
     ('overall_narration_audio_path', None), ('narration_script_display', "")
 ]:
     if key not in st.session_state: st.session_state[key] = default_val
 
 def initialize_new_project():
-    st.session_state.story_treatment_scenes, st.session_state.scene_dalle_prompts, st.session_state.generated_visual_paths = [], [], []
+    st.session_state.story_treatment_scenes = []
+    st.session_state.scene_prompts = [] # Stores DALL-E or Text-to-Video prompts
+    st.session_state.generated_scene_assets = [] # Stores dicts {'path': ..., 'type': ..., 'error': ...}
     st.session_state.video_path, st.session_state.overall_narration_audio_path, st.session_state.narration_script_display = None, None, ""
     logger.info("New project initialized.")
-
-def generate_visual_for_scene_core(scene_index, scene_data, version=1):
-    dalle_prompt = construct_dalle_prompt(scene_data, st.session_state.character_definitions, st.session_state.global_style_additions)
-    if not dalle_prompt: logger.error(f"DALL-E prompt construction failed for scene {scene_data.get('scene_number', scene_index+1)}"); return False
-    while len(st.session_state.scene_dalle_prompts) <= scene_index: st.session_state.scene_dalle_prompts.append("")
-    while len(st.session_state.generated_visual_paths) <= scene_index: st.session_state.generated_visual_paths.append(None)
-    st.session_state.scene_dalle_prompts[scene_index] = dalle_prompt
-    filename = f"scene_{scene_data.get('scene_number', scene_index+1)}_visual_v{version}.png"
-    img_path = st.session_state.visual_engine.generate_image_visual(dalle_prompt, scene_data, filename)
-    if img_path and os.path.exists(img_path):
-        st.session_state.generated_visual_paths[scene_index] = img_path; logger.info(f"Visual generated for Scene {scene_data.get('scene_number', scene_index+1)}: {os.path.basename(img_path)}"); return True
+# <<< MODIFIED END >>>
+
+# <<< MODIFIED START >>> : Updated function to use generate_scene_asset
+def generate_asset_for_scene_core(scene_index, scene_data, version=1, user_selected_asset_type="Auto (Director's Choice)"):
+    """
+    Generates a visual asset (image or video clip) for a scene.
+    Returns True on success, False on failure.
+    """
+    # Determine asset type: user override > Gemini suggestion > default to image
+    final_asset_type_decision = "image" # Default
+    gemini_suggested_type = scene_data.get('suggested_asset_type_감독', 'image').lower()
+
+    if user_selected_asset_type == "Image":
+        final_asset_type_decision = "image"
+    elif user_selected_asset_type == "Video Clip":
+        final_asset_type_decision = "video_clip"
+    elif user_selected_asset_type == "Auto (Director's Choice)":
+        final_asset_type_decision = gemini_suggested_type if gemini_suggested_type == "video_clip" else "image"
+
+    generate_as_video = (final_asset_type_decision == "video_clip")
+    prompt_text_for_visual = ""
+
+    if generate_as_video:
+        # Construct prompt for text-to-video (e.g., RunwayML)
+        prompt_text_for_visual = construct_text_to_video_prompt(scene_data, st.session_state.character_definitions, st.session_state.global_style_additions)
+        # Note: seed_image_path could be an enhancement if DALL-E image is generated first
+    else:
+        # Construct prompt for DALL-E (image)
+        prompt_text_for_visual = construct_dalle_prompt(scene_data, st.session_state.character_definitions, st.session_state.global_style_additions)
+
+    if not prompt_text_for_visual:
+        logger.error(f"Visual prompt construction failed for scene {scene_data.get('scene_number', scene_index+1)} (Type: {final_asset_type_decision})")
+        return False
+
+    # Ensure session state lists are long enough
+    while len(st.session_state.scene_prompts) <= scene_index: st.session_state.scene_prompts.append("")
+    while len(st.session_state.generated_scene_assets) <= scene_index: st.session_state.generated_scene_assets.append(None)
+
+    st.session_state.scene_prompts[scene_index] = prompt_text_for_visual
+
+    # Filename base (extension will be added by visual_engine)
+    filename_base = f"scene_{scene_data.get('scene_number', scene_index+1)}_asset_v{version}"
+    runway_duration = scene_data.get('video_clip_duration_estimate_secs_감독', DEFAULT_SCENE_DURATION_SECS)
+    if runway_duration <= 0 : runway_duration = DEFAULT_SCENE_DURATION_SECS # Ensure positive duration
+
+    asset_result = st.session_state.visual_engine.generate_scene_asset(
+        image_prompt_text=prompt_text_for_visual, # This is generic, used for DALL-E or T2V
+        scene_data=scene_data,
+        scene_identifier_filename_base=filename_base,
+        generate_as_video_clip=generate_as_video,
+        runway_target_duration=runway_duration
+        # input_image_for_runway=None # TODO: Could be an enhancement
+    )
+
+    st.session_state.generated_scene_assets[scene_index] = asset_result # Store the whole dict
+
+    if asset_result and not asset_result['error'] and asset_result.get('path') and os.path.exists(asset_result['path']):
+        logger.info(f"Asset ({asset_result.get('type')}) generated for Scene {scene_data.get('scene_number', scene_index+1)}: {os.path.basename(asset_result['path'])}")
+        return True
     else:
-        st.session_state.generated_visual_paths[scene_index] = None; logger.warning(f"Visual generation FAILED for Scene {scene_data.get('scene_number', scene_index+1)}. img_path was: {img_path}"); return False
+        err_msg = asset_result.get('error_message', 'Unknown error') if asset_result else 'Asset result is None'
+        logger.warning(f"Asset generation FAILED for Scene {scene_data.get('scene_number', scene_index+1)}. Type attempted: {final_asset_type_decision}. Path was: {asset_result.get('path') if asset_result else 'N/A'}. Error: {err_msg}")
+        # Store a failure state
+        st.session_state.generated_scene_assets[scene_index] = {'path': None, 'type': 'none', 'error': True, 'error_message': err_msg, 'prompt_used': prompt_text_for_visual}
+        return False
+# <<< MODIFIED END >>>
 
 # --- UI Sidebar ---
 with st.sidebar:
@@ -110,7 +168,7 @@ with st.sidebar:
     user_idea = st.text_area("Core Story Idea / Theme:", "A lone wanderer searches for a mythical oasis in a vast, post-apocalyptic desert, haunted by mirages and mechanical scavengers.", height=120, key="user_idea_main_v5")
     genre = st.selectbox("Primary Genre:", ["Cyberpunk", "Sci-Fi", "Fantasy", "Noir", "Thriller", "Western", "Post-Apocalyptic", "Historical Drama", "Surreal"], index=6, key="genre_main_v5")
     mood = st.selectbox("Overall Mood:", ["Hopeful yet Desperate", "Mysterious & Eerie", "Gritty & Tense", "Epic & Awe-Inspiring", "Melancholy & Reflective", "Whimsical & Lighthearted"], index=0, key="mood_main_v5")
-    num_scenes = st.slider("Number of Key Scenes:", 1, 10, 3, key="num_scenes_main_v5") # MODIFIED: Increased max scenes
+    num_scenes = st.slider("Number of Key Scenes:", 1, 10, 2, key="num_scenes_main_v5")
     creative_guidance_options = {"Standard Director": "standard", "Artistic Visionary": "more_artistic", "Experimental Storyteller": "experimental_narrative"}
     selected_creative_guidance_key = st.selectbox("AI Creative Director Style:", options=list(creative_guidance_options.keys()), key="creative_guidance_select_v5")
     actual_creative_guidance = creative_guidance_options[selected_creative_guidance_key]
@@ -122,47 +180,50 @@ with st.sidebar:
             with st.status("AI Director is envisioning your masterpiece...", expanded=True) as status:
                 try:
                     status.write("Phase 1: Gemini crafting cinematic treatment... 📜"); logger.info("Phase 1: Cinematic Treatment Gen.")
-                    # Note: Consider updating create_cinematic_treatment_prompt to also ask Gemini
-                    # for 'suggested_shot_type' and 'estimated_duration_secs' for each scene.
                     treatment_prompt = create_cinematic_treatment_prompt(user_idea, genre, mood, num_scenes, actual_creative_guidance)
-                    treatment_result_json_raw = st.session_state.gemini_handler.generate_story_breakdown(treatment_prompt)
-                    if not isinstance(treatment_result_json_raw, list) or not treatment_result_json_raw: raise ValueError("Gemini returned invalid scene list.")
+                    treatment_result_json_raw = st.session_state.gemini_handler.generate_story_breakdown(treatment_prompt) # Expect list of dicts
+                    if not isinstance(treatment_result_json_raw, list) or not treatment_result_json_raw: raise ValueError("Gemini returned invalid scene list format.")
 
-                    # <<< ADDED/MODIFIED START >>>
-                    # Process raw scenes and add default shot type and duration
                     processed_scenes = []
                     for scene_data_from_gemini in treatment_result_json_raw:
-                        scene_data_from_gemini['shot_type'] = scene_data_from_gemini.get('suggested_shot_type', DEFAULT_SHOT_TYPE) # Use Gemini's suggestion if available
-                        scene_data_from_gemini['scene_duration_secs'] = scene_data_from_gemini.get('estimated_duration_secs', DEFAULT_SCENE_DURATION_SECS) # Use Gemini's suggestion if available
+                        scene_data_from_gemini['user_shot_type'] = scene_data_from_gemini.get('PROACTIVE_camera_work_감독', DEFAULT_SHOT_TYPE) # Default from Gemini's suggestion
+                        scene_data_from_gemini['user_scene_duration_secs'] = scene_data_from_gemini.get('video_clip_duration_estimate_secs_감독', DEFAULT_SCENE_DURATION_SECS)
+                        if scene_data_from_gemini['user_scene_duration_secs'] <=0: scene_data_from_gemini['user_scene_duration_secs'] = DEFAULT_SCENE_DURATION_SECS
+                        scene_data_from_gemini['user_selected_asset_type'] = "Auto (Director's Choice)" # Default for UI
                         processed_scenes.append(scene_data_from_gemini)
                     st.session_state.story_treatment_scenes = processed_scenes
-                    # <<< ADDED/MODIFIED END >>>
 
                     num_gen_scenes = len(st.session_state.story_treatment_scenes)
-                    st.session_state.scene_dalle_prompts = [""]*num_gen_scenes; st.session_state.generated_visual_paths = [None]*num_gen_scenes
+                    # <<< MODIFIED START >>>
+                    st.session_state.scene_prompts = [""]*num_gen_scenes
+                    st.session_state.generated_scene_assets = [None]*num_gen_scenes # Initialize list for asset dicts
+                    # <<< MODIFIED END >>>
                     logger.info(f"Phase 1 complete. {num_gen_scenes} scenes."); status.update(label="Treatment complete! ✅ Generating visuals...", state="running")
 
-                    status.write("Phase 2: Creating visuals (DALL-E/Pexels)... 🖼️"); logger.info("Phase 2: Visual Gen.")
+                    status.write("Phase 2: Creating visual assets (Image/Video)... 🖼️🎬"); logger.info("Phase 2: Visual Asset Gen.")
                     visual_successes = 0
                     for i, sc_data in enumerate(st.session_state.story_treatment_scenes):
                         sc_num_log = sc_data.get('scene_number', i+1)
-                        status.write(f"  Visual for Scene {sc_num_log}..."); logger.info(f"  Processing visual for Scene {sc_num_log}.")
-                        if generate_visual_for_scene_core(i, sc_data, version=1): visual_successes += 1
+                        status.write(f"  Asset for Scene {sc_num_log}..."); logger.info(f"  Processing asset for Scene {sc_num_log}.")
+                        # <<< MODIFIED START >>> : Calling new function
+                        if generate_asset_for_scene_core(i, sc_data, version=1): # Default to 'Auto' asset type for initial gen
+                            visual_successes += 1
+                        # <<< MODIFIED END >>>
 
-                    current_status_label_ph2 = "Visuals ready! "
+                    current_status_label_ph2 = "Visual assets ready! "
                     next_step_state = "running"
                     if visual_successes == 0 and num_gen_scenes > 0:
-                        logger.error("Visual gen failed all scenes."); current_status_label_ph2 = "Visual gen FAILED for all scenes."; next_step_state="error";
+                        logger.error("Visual asset gen failed for all scenes."); current_status_label_ph2 = "Asset gen FAILED for all scenes."; next_step_state="error";
                         status.update(label=current_status_label_ph2, state=next_step_state, expanded=True); st.stop()
                     elif visual_successes < num_gen_scenes:
-                        logger.warning(f"Visuals partial ({visual_successes}/{num_gen_scenes})."); current_status_label_ph2 = f"Visuals partially generated ({visual_successes}/{num_gen_scenes}). "
+                        logger.warning(f"Assets partially generated ({visual_successes}/{num_gen_scenes})."); current_status_label_ph2 = f"Assets partially generated ({visual_successes}/{num_gen_scenes}). "
                     status.update(label=f"{current_status_label_ph2}Generating narration script...", state=next_step_state)
                     if next_step_state == "error": st.stop()
 
                     status.write("Phase 3: Generating narration script..."); logger.info("Phase 3: Narration Script Gen.")
                     voice_style_for_prompt = st.session_state.get("selected_voice_style_for_generation", "cinematic_trailer")
                     narr_prompt = create_narration_script_prompt_enhanced(st.session_state.story_treatment_scenes, mood, genre, voice_style_for_prompt)
-                    st.session_state.narration_script_display = st.session_state.gemini_handler.generate_image_prompt(narr_prompt) # Assuming this is correct for narration text
+                    st.session_state.narration_script_display = st.session_state.gemini_handler.generate_image_prompt(narr_prompt) # This generates a string
                     logger.info("Narration script generated."); status.update(label="Narration script ready! Synthesizing voice...", state="running")
 
                     status.write("Phase 4: Synthesizing voice (ElevenLabs)... 🔊"); logger.info("Phase 4: Voice Synthesis.")
@@ -180,6 +241,7 @@ with st.sidebar:
                 except Exception as e: logger.error(f"Unhandled Exception: {e}", exc_info=True); status.update(label=f"An unexpected error occurred: {e}", state="error", expanded=True);
 
     st.markdown("---"); st.markdown("### Fine-Tuning Options")
+    # ... (Character, Global Style, Voice expanders - no changes needed here for this fix) ...
     with st.expander("Define Characters", expanded=False):
         char_name = st.text_input("Character Name", key="char_name_adv_ultra_v5"); char_desc = st.text_area("Visual Description", key="char_desc_adv_ultra_v5", height=100, placeholder="e.g., Jax: rugged male astronaut...")
         if st.button("Save Character", key="add_char_adv_ultra_v5"):
@@ -225,6 +287,7 @@ with st.sidebar:
             st.success(f"Narrator Voice ID set to: {final_voice_id_to_use}. Script Style: {sel_prompt_v_style_key}")
             logger.info(f"User updated ElevenLabs Voice ID to: {final_voice_id_to_use}, Script Style: {sel_prompt_v_style_key}")
 
+
 # --- Main Content Area ---
 st.header("🎬 Cinematic Storyboard & Treatment")
 if st.session_state.narration_script_display:
@@ -234,169 +297,221 @@ if not st.session_state.story_treatment_scenes: st.info("Use the sidebar to gene
 else:
     for i_main, scene_content_display in enumerate(st.session_state.story_treatment_scenes):
         scene_n = scene_content_display.get('scene_number', i_main + 1); scene_t = scene_content_display.get('scene_title', 'Untitled')
-        key_base = f"s{scene_n}_{''.join(filter(str.isalnum, scene_t[:10]))}_v5_{i_main}" # Ensure unique key base with index
+        key_base = f"s{scene_n}_{''.join(filter(str.isalnum, scene_t[:10]))}_v5_{i_main}"
         if "director_note" in scene_content_display and scene_content_display['director_note']: st.info(f"🎬 Director Note S{scene_n}: {scene_content_display['director_note']}")
         st.subheader(f"SCENE {scene_n}: {scene_t.upper()}"); col_d, col_v = st.columns([0.45, 0.55])
-        with col_d:
-            with st.expander("📝 Scene Treatment & Controls", expanded=True): # MODIFIED Expander Title
-                st.markdown(f"**Beat:** {scene_content_display.get('emotional_beat', 'N/A')}"); st.markdown(f"**Setting:** {scene_content_display.get('setting_description', 'N/A')}"); st.markdown(f"**Chars:** {', '.join(scene_content_display.get('characters_involved', ['N/A']))}"); st.markdown(f"**Focus Moment:** _{scene_content_display.get('character_focus_moment', 'N/A')}_"); st.markdown(f"**Plot Beat:** {scene_content_display.get('key_plot_beat', 'N/A')}"); st.markdown(f"**Dialogue Hook:** `\"{scene_content_display.get('suggested_dialogue_hook', '...')}\"`"); st.markdown("---"); st.markdown(f"**Dir. Visual Style:** _{scene_content_display.get('PROACTIVE_visual_style_감독', 'N/A')}_"); st.markdown(f"**Dir. Camera:** _{scene_content_display.get('PROACTIVE_camera_work_감독', 'N/A')}_"); st.markdown(f"**Dir. Sound:** _{scene_content_display.get('PROACTIVE_sound_design_감독', 'N/A')}_")
 
-                # <<< ADDED/MODIFIED START >>>
+        with col_d: # Treatment and Controls Column
+            with st.expander("📝 Scene Treatment & Controls", expanded=True):
+                # Display scene textual details (emotional_beat, setting, etc.)
+                st.markdown(f"**Beat:** {scene_content_display.get('emotional_beat', 'N/A')}")
+                st.markdown(f"**Setting:** {scene_content_display.get('setting_description', 'N/A')}")
+                st.markdown(f"**Chars:** {', '.join(scene_content_display.get('characters_involved', ['N/A']))}")
+                st.markdown(f"**Focus Moment:** _{scene_content_display.get('character_focus_moment', 'N/A')}_")
+                st.markdown(f"**Plot Beat:** {scene_content_display.get('key_plot_beat', 'N/A')}")
+                st.markdown(f"**Dialogue Hook:** `\"{scene_content_display.get('suggested_dialogue_hook', '...')}\"`")
+                st.markdown("---")
+                st.markdown(f"**Dir. Visual Style:** _{scene_content_display.get('PROACTIVE_visual_style_감독', 'N/A')}_")
+                st.markdown(f"**Dir. Camera:** _{scene_content_display.get('PROACTIVE_camera_work_감독', 'N/A')}_")
+                st.markdown(f"**Dir. Sound:** _{scene_content_display.get('PROACTIVE_sound_design_감독', 'N/A')}_")
                 st.markdown("---")
-                st.markdown("##### Shot & Pacing Controls")
+                st.markdown("##### Shot, Pacing & Asset Controls")
+
+                # User Shot Type (Camera Angle)
+                current_shot_type = st.session_state.story_treatment_scenes[i_main].get('user_shot_type', DEFAULT_SHOT_TYPE)
+                try: shot_type_index = SHOT_TYPES_OPTIONS.index(current_shot_type)
+                except ValueError: shot_type_index = SHOT_TYPES_OPTIONS.index(DEFAULT_SHOT_TYPE)
+                new_shot_type = st.selectbox("Dominant Shot Type:", options=SHOT_TYPES_OPTIONS, index=shot_type_index, key=f"shot_type_widget_{key_base}")
+                if new_shot_type != current_shot_type:
+                    st.session_state.story_treatment_scenes[i_main]['user_shot_type'] = new_shot_type
+                    # Consider if a re-run is needed or if DALL-E prompt should be updated based on this
+
+                # User Scene Duration
+                current_duration = st.session_state.story_treatment_scenes[i_main].get('user_scene_duration_secs', DEFAULT_SCENE_DURATION_SECS)
+                new_duration = st.number_input("Scene Duration (seconds):", min_value=1, max_value=300, value=current_duration, step=1, key=f"duration_widget_{key_base}")
+                if new_duration != current_duration:
+                    st.session_state.story_treatment_scenes[i_main]['user_scene_duration_secs'] = new_duration
+
+                # <<< MODIFIED START >>> : User Asset Type Selection
+                current_user_asset_type = st.session_state.story_treatment_scenes[i_main].get('user_selected_asset_type', "Auto (Director's Choice)")
+                try: asset_type_idx = ASSET_TYPE_OPTIONS.index(current_user_asset_type)
+                except ValueError: asset_type_idx = 0 # Default to Auto
+                new_user_asset_type = st.selectbox("Asset Type Override:", ASSET_TYPE_OPTIONS, index=asset_type_idx, key=f"asset_type_sel_{key_base}",
+                                                   help="Choose 'Image' or 'Video Clip'. 'Auto' uses Gemini's suggestion.")
+                if new_user_asset_type != current_user_asset_type:
+                    st.session_state.story_treatment_scenes[i_main]['user_selected_asset_type'] = new_user_asset_type
+                    # This change will be picked up by regeneration buttons
+                # <<< MODIFIED END >>>
 
-                # Shot Type Selection
-                current_shot_type = st.session_state.story_treatment_scenes[i_main].get('shot_type', DEFAULT_SHOT_TYPE)
-                try:
-                    shot_type_index = SHOT_TYPES_OPTIONS.index(current_shot_type)
-                except ValueError:
-                    shot_type_index = SHOT_TYPES_OPTIONS.index(DEFAULT_SHOT_TYPE) # Fallback if value is somehow invalid
-
-                new_shot_type = st.selectbox(
-                    "Dominant Shot Type:",
-                    options=SHOT_TYPES_OPTIONS,
-                    index=shot_type_index,
-                    key=f"shot_type_widget_{key_base}",
-                    help="Suggests the primary camera shot for this scene. Influences visual generation style if DALL-E prompt is ever made aware of it."
-                )
-                if new_shot_type != st.session_state.story_treatment_scenes[i_main]['shot_type']:
-                    st.session_state.story_treatment_scenes[i_main]['shot_type'] = new_shot_type
-                    # No st.rerun() needed unless other UI elements immediately depend on this change
-
-                # Scene Duration Control
-                current_duration = st.session_state.story_treatment_scenes[i_main].get('scene_duration_secs', DEFAULT_SCENE_DURATION_SECS)
-                new_duration = st.number_input(
-                    "Scene Duration (seconds):",
-                    min_value=1,
-                    max_value=300, # Max 5 minutes per scene image
-                    value=current_duration,
-                    step=1,
-                    key=f"duration_widget_{key_base}",
-                    help="Approximate duration this scene's visual will be shown in the final animatic."
-                )
-                if new_duration != st.session_state.story_treatment_scenes[i_main]['scene_duration_secs']:
-                    st.session_state.story_treatment_scenes[i_main]['scene_duration_secs'] = new_duration
-                    # No st.rerun() needed unless other UI elements immediately depend on this change
                 st.markdown("---")
-                # <<< ADDED/MODIFIED END >>>
+                # Display generated prompt for the asset
+                current_prompt_for_asset = st.session_state.scene_prompts[i_main] if i_main < len(st.session_state.scene_prompts) else None
+                if current_prompt_for_asset:
+                     with st.popover("👁️ View Asset Generation Prompt"):
+                        st.markdown(f"**Prompt used for current asset:**"); st.code(current_prompt_for_asset, language='text')
 
-                cur_d_prompt = st.session_state.scene_dalle_prompts[i_main] if i_main < len(st.session_state.scene_dalle_prompts) else None
-                if cur_d_prompt:
-                     with st.popover("👁️ DALL-E Prompt"): st.markdown(f"**DALL-E Prompt:**"); st.code(cur_d_prompt, language='text')
                 pexels_q = scene_content_display.get('pexels_search_query_감독', None)
                 if pexels_q: st.caption(f"Pexels Fallback Query: `{pexels_q}`")
 
-        with col_v:
-            cur_img_p = st.session_state.generated_visual_paths[i_main] if i_main < len(st.session_state.generated_visual_paths) else None
-            if cur_img_p and os.path.exists(cur_img_p): st.image(cur_img_p, caption=f"Scene {scene_n}: {scene_t}")
-            else:
-                if st.session_state.story_treatment_scenes: st.caption("Visual pending/failed.")
+        with col_v: # Visuals Column
+            # <<< MODIFIED START >>> : Display logic for different asset types
+            current_asset_data = st.session_state.generated_scene_assets[i_main] if i_main < len(st.session_state.generated_scene_assets) else None
+            if current_asset_data and not current_asset_data.get('error') and current_asset_data.get('path') and os.path.exists(current_asset_data['path']):
+                asset_path = current_asset_data['path']
+                asset_type = current_asset_data.get('type', 'image') # Default to image if type missing
+                if asset_type == 'image':
+                    st.image(asset_path, caption=f"Scene {scene_n} ({asset_type}): {scene_t}")
+                elif asset_type == 'video':
+                    try:
+                        with open(asset_path, 'rb') as vf: video_bytes = vf.read()
+                        st.video(video_bytes, format="video/mp4", start_time=0)
+                        st.caption(f"Scene {scene_n} ({asset_type}): {scene_t}")
+                    except Exception as e_vid:
+                        st.error(f"Error displaying video {asset_path}: {e_vid}")
+                        logger.error(f"Error displaying video {asset_path}: {e_vid}", exc_info=True)
+                else:
+                    st.warning(f"Unknown asset type '{asset_type}' for Scene {scene_n}.")
+            else: # No asset, or error during generation
+                if st.session_state.story_treatment_scenes: # Check if treatment exists
+                    error_msg = current_asset_data.get('error_message', 'Visual pending or failed.') if current_asset_data else 'Visual pending or failed.'
+                    st.caption(error_msg)
+            # <<< MODIFIED END >>>
 
             with st.popover(f"✏️ Edit Scene {scene_n} Treatment"):
                 fb_script = st.text_area("Changes to treatment:", key=f"treat_fb_{key_base}", height=150)
                 if st.button(f"🔄 Update Scene {scene_n} Treatment", key=f"regen_treat_btn_{key_base}"):
                     if fb_script:
-                        with st.status(f"Updating Scene {scene_n}...", expanded=True) as s_treat_regen:
+                        with st.status(f"Updating Scene {scene_n} Treatment & Asset...", expanded=True) as s_treat_regen:
+                            # Preserve user's shot type, duration, and asset type choices
+                            user_shot_type = st.session_state.story_treatment_scenes[i_main]['user_shot_type']
+                            user_duration = st.session_state.story_treatment_scenes[i_main]['user_scene_duration_secs']
+                            user_asset_type_choice = st.session_state.story_treatment_scenes[i_main]['user_selected_asset_type']
+
                             prompt_text = create_scene_regeneration_prompt(scene_content_display, fb_script, st.session_state.story_treatment_scenes)
                             try:
-                                updated_sc_data_raw = st.session_state.gemini_handler.regenerate_scene_script_details(prompt_text) # This is just the script part
-
-                                # <<< ADDED/MODIFIED START >>>
-                                # Preserve user-set shot type and duration
-                                original_shot_type = st.session_state.story_treatment_scenes[i_main].get('shot_type', DEFAULT_SHOT_TYPE)
-                                original_duration = st.session_state.story_treatment_scenes[i_main].get('scene_duration_secs', DEFAULT_SCENE_DURATION_SECS)
+                                updated_sc_data_from_gemini = st.session_state.gemini_handler.regenerate_scene_script_details(prompt_text)
+                                # Merge, but prioritize user's UI choices for duration/shot/asset type
+                                updated_sc_data = {**updated_sc_data_from_gemini} # Start with Gemini's new script
+                                updated_sc_data['user_shot_type'] = user_shot_type
+                                updated_sc_data['user_scene_duration_secs'] = user_duration
+                                updated_sc_data['user_selected_asset_type'] = user_asset_type_choice
+                                # Gemini might re-suggest asset type/duration, but user's direct settings take precedence for next gen
+                                # We can log if Gemini's suggestion differs from user's explicit choice.
+                                if updated_sc_data.get('suggested_asset_type_감독') != user_asset_type_choice and user_asset_type_choice != "Auto (Director's Choice)":
+                                    logger.info(f"Scene {scene_n}: User asset choice '{user_asset_type_choice}' overrides Gemini suggestion '{updated_sc_data.get('suggested_asset_type_감독')}'.")
 
-                                # Merge Gemini's script updates with existing scene data, preserving our custom fields
-                                updated_sc_data = {**st.session_state.story_treatment_scenes[i_main], **updated_sc_data_raw}
-                                updated_sc_data['shot_type'] = updated_sc_data_raw.get('suggested_shot_type', original_shot_type) # If Gemini suggests it, use it, else keep old
-                                updated_sc_data['scene_duration_secs'] = updated_sc_data_raw.get('estimated_duration_secs', original_duration) # Same for duration
 
                                 st.session_state.story_treatment_scenes[i_main] = updated_sc_data
-                                # <<< ADDED/MODIFIED END >>>
+                                s_treat_regen.update(label="Treatment updated! Regenerating asset...", state="running")
 
-                                s_treat_regen.update(label="Treatment updated! Regenerating visual...", state="running")
                                 v_num = 1
-                                if cur_img_p and os.path.exists(cur_img_p):
-                                    try: b,_=os.path.splitext(os.path.basename(cur_img_p)); v_num = int(b.split('_v')[-1])+1 if '_v' in b else 2
-                                    except (ValueError, IndexError, TypeError): v_num = 2
+                                if current_asset_data and current_asset_data.get('path') and os.path.exists(current_asset_data['path']):
+                                    try: b,_=os.path.splitext(os.path.basename(current_asset_data['path'])); v_num = int(b.split('_v')[-1])+1 if '_v' in b else 2
+                                    except: v_num = 2
                                 else: v_num = 1
-                                if generate_visual_for_scene_core(i_main, updated_sc_data, version=v_num): s_treat_regen.update(label="Treatment & Visual Updated! 🎉", state="complete", expanded=False)
-                                else: s_treat_regen.update(label="Treatment updated, visual failed.", state="complete", expanded=False)
+                                # <<< MODIFIED START >>> : Call new function, pass user_selected_asset_type
+                                if generate_asset_for_scene_core(i_main, updated_sc_data, version=v_num, user_selected_asset_type=user_asset_type_choice):
+                                    s_treat_regen.update(label="Treatment & Asset Updated! 🎉", state="complete", expanded=False)
+                                else: s_treat_regen.update(label="Treatment updated, asset failed.", state="complete", expanded=False)
+                                # <<< MODIFIED END >>>
                                 st.rerun()
                             except Exception as e_regen: s_treat_regen.update(label=f"Error: {e_regen}", state="error"); logger.error(f"Scene treatment regen error: {e_regen}", exc_info=True)
                     else: st.warning("Please provide feedback.")
 
             with st.popover(f"🎨 Edit Scene {scene_n} Visual Prompt"):
-                d_prompt_edit = st.session_state.scene_dalle_prompts[i_main] if i_main < len(st.session_state.scene_dalle_prompts) else "No DALL-E prompt."
-                st.caption("Current DALL-E Prompt:"); st.code(d_prompt_edit, language='text')
-                fb_visual = st.text_area("Changes for DALL-E prompt:", key=f"visual_fb_{key_base}", height=150)
-                if st.button(f"🔄 Update Scene {scene_n} Visual", key=f"regen_visual_btn_{key_base}"):
+                prompt_to_edit = st.session_state.scene_prompts[i_main] if i_main < len(st.session_state.scene_prompts) else "No prompt generated yet."
+                st.caption("Current Asset Generation Prompt:"); st.code(prompt_to_edit, language='text')
+                fb_visual = st.text_area("Changes for asset generation prompt:", key=f"visual_fb_{key_base}", height=150)
+                if st.button(f"🔄 Update Scene {scene_n} Asset", key=f"regen_visual_btn_{key_base}"):
                     if fb_visual:
-                        with st.status(f"Refining prompt & visual for Scene {scene_n}...", expanded=True) as s_visual_regen:
-                            ref_req_prompt = create_visual_regeneration_prompt(d_prompt_edit, fb_visual, scene_content_display,
-                                st.session_state.character_definitions, st.session_state.global_style_additions)
-                            try:
-                                refined_d_prompt = st.session_state.gemini_handler.generate_image_prompt(ref_req_prompt)
-                                st.session_state.scene_dalle_prompts[i_main] = refined_d_prompt
-                                s_visual_regen.update(label="DALL-E prompt refined! Regenerating visual...", state="running")
-                                v_num = 1
-                                if cur_img_p and os.path.exists(cur_img_p):
-                                    try: b,_=os.path.splitext(os.path.basename(cur_img_p)); v_num = int(b.split('_v')[-1])+1 if '_v' in b else 2
-                                    except (ValueError, IndexError, TypeError): v_num=2
-                                else: v_num = 1
-                                # Pass the current scene_content_display, as DALL-E prompt is separate from treatment text
-                                if generate_visual_for_scene_core(i_main, st.session_state.story_treatment_scenes[i_main], version=v_num): s_visual_regen.update(label="Visual Updated! 🎉", state="complete", expanded=False)
-                                else: s_visual_regen.update(label="Prompt refined, visual failed.", state="complete", expanded=False)
-                                st.rerun()
-                            except Exception as e_regen_vis: s_visual_regen.update(label=f"Error: {e_regen_vis}", state="error"); logger.error(f"Visual prompt regen error: {e_regen_vis}", exc_info=True)
+                        with st.status(f"Refining prompt & asset for Scene {scene_n}...", expanded=True) as s_visual_regen:
+                            user_asset_type_choice = st.session_state.story_treatment_scenes[i_main]['user_selected_asset_type']
+                            is_video_prompt = (user_asset_type_choice == "Video Clip") or \
+                                              (user_asset_type_choice == "Auto (Director's Choice)" and \
+                                               scene_content_display.get('suggested_asset_type_감독') == 'video_clip')
+
+                            # Note: Visual regeneration prompt is primarily for DALL-E (images).
+                            # For video, we might need a different refinement strategy or just regenerate with the same prompt construction.
+                            # For simplicity here, if it's a video, we'll regenerate the prompt using standard construction.
+                            # If it's an image, we use Gemini to refine the DALL-E prompt.
+                            new_asset_gen_prompt = ""
+                            if not is_video_prompt : # Refining an image prompt
+                                ref_req_prompt_for_gemini = create_visual_regeneration_prompt(prompt_to_edit, fb_visual, scene_content_display,
+                                    st.session_state.character_definitions, st.session_state.global_style_additions)
+                                try:
+                                    new_asset_gen_prompt = st.session_state.gemini_handler.refine_image_prompt_from_feedback(ref_req_prompt_for_gemini)
+                                    st.session_state.scene_prompts[i_main] = new_asset_gen_prompt
+                                    s_visual_regen.update(label="Image prompt refined by Gemini! Regenerating asset...", state="running")
+                                except Exception as e_gemini_refine:
+                                    s_visual_regen.update(label=f"Error refining prompt: {e_gemini_refine}", state="error");
+                                    logger.error(f"Visual prompt refinement error: {e_gemini_refine}", exc_info=True)
+                                    continue # Skip asset generation if prompt refinement failed
+                            else: # For video, or auto choosing video, reconstruct the prompt
+                                new_asset_gen_prompt = construct_text_to_video_prompt(scene_content_display, st.session_state.character_definitions, st.session_state.global_style_additions)
+                                st.session_state.scene_prompts[i_main] = new_asset_gen_prompt
+                                s_visual_regen.update(label="Video prompt reconstructed! Regenerating asset...", state="running")
+
+
+                            v_num = 1
+                            if current_asset_data and current_asset_data.get('path') and os.path.exists(current_asset_data['path']):
+                                try: b,_=os.path.splitext(os.path.basename(current_asset_data['path'])); v_num = int(b.split('_v')[-1])+1 if '_v' in b else 2
+                                except: v_num=2
+                            else: v_num = 1
+
+                            # <<< MODIFIED START >>> : Call new function
+                            # Pass the current scene_content_display as its prompt might have changed.
+                            # User asset type choice from the scene data for consistency
+                            if generate_asset_for_scene_core(i_main, st.session_state.story_treatment_scenes[i_main], version=v_num, user_selected_asset_type=user_asset_type_choice):
+                                s_visual_regen.update(label="Asset Updated! 🎉", state="complete", expanded=False)
+                            else: s_visual_regen.update(label="Prompt updated, asset regeneration failed.", state="complete", expanded=False)
+                            # <<< MODIFIED END >>>
+                            st.rerun()
                     else: st.warning("Please provide feedback.")
         st.markdown("---")
 
-    if st.session_state.story_treatment_scenes and any(p for p in st.session_state.generated_visual_paths if p is not None):
+    # Video Assembly Button
+    # <<< MODIFIED START >>> : Check generated_scene_assets and use its data
+    if st.session_state.story_treatment_scenes and any(asset_info and not asset_info.get('error') and asset_info.get('path') for asset_info in st.session_state.generated_scene_assets if asset_info is not None):
         if st.button("🎬 Assemble Narrated Cinematic Animatic", key="assemble_ultra_video_btn_v5", type="primary", use_container_width=True):
             with st.status("Assembling Ultra Animatic...", expanded=True) as status_vid:
-                img_data_vid = []
+                assets_for_video_assembly = []
                 for i_v, sc_c in enumerate(st.session_state.story_treatment_scenes):
-                    img_p_v = st.session_state.generated_visual_paths[i_v] if i_v < len(st.session_state.generated_visual_paths) else None
-                    if img_p_v and os.path.exists(img_p_v):
-                        # <<< ADDED/MODIFIED START >>>
-                        scene_duration = sc_c.get('scene_duration_secs', DEFAULT_SCENE_DURATION_SECS)
-                        img_data_vid.append({
-                            'path': img_p_v,
+                    asset_info = st.session_state.generated_scene_assets[i_v] if i_v < len(st.session_state.generated_scene_assets) else None
+                    if asset_info and not asset_info.get('error') and asset_info.get('path') and os.path.exists(asset_info['path']):
+                        assets_for_video_assembly.append({
+                            'path': asset_info['path'],
+                            'type': asset_info.get('type', 'image'), # Default to image if type missing
                             'scene_num': sc_c.get('scene_number', i_v + 1),
                             'key_action': sc_c.get('key_plot_beat', ''),
-                            'duration': scene_duration # Use per-scene duration
+                            'duration': sc_c.get('user_scene_duration_secs', DEFAULT_SCENE_DURATION_SECS) # Use user-set duration
                         })
-                        status_vid.write(f"Adding Scene {sc_c.get('scene_number', i_v + 1)} (Duration: {scene_duration}s).")
-                        # <<< ADDED/MODIFIED END >>>
+                        status_vid.write(f"Adding Scene {sc_c.get('scene_number', i_v + 1)} ({asset_info.get('type')}).")
                     else:
-                        logger.warning(f"Skipping Scene {sc_c.get('scene_number', i_v + 1)} for video assembly: No valid visual path.")
-
+                        logger.warning(f"Skipping Scene {sc_c.get('scene_number', i_v+1)} for video: No valid asset.")
 
-                if img_data_vid:
+                if assets_for_video_assembly:
                     status_vid.write("Calling video engine...");
-                    # <<< ADDED/MODIFIED START >>>
-                    # IMPORTANT: Assumes visual_engine.create_video_from_images is updated to accept
-                    # images_data (list of dicts with 'path' and 'duration') and no longer needs duration_per_image.
-                    st.session_state.video_path = st.session_state.visual_engine.create_video_from_images(
-                        images_data=img_data_vid, # Pass the list of dicts
+                    st.session_state.video_path = st.session_state.visual_engine.assemble_animatic_from_assets( # Changed method name
+                        asset_data_list=assets_for_video_assembly, # Pass the list of asset dicts
                         overall_narration_path=st.session_state.overall_narration_audio_path,
                         output_filename="cinegen_ultra_animatic.mp4",
-                        fps=24 # Keep FPS or make it configurable
+                        fps=24
                     )
-                    # <<< ADDED/MODIFIED END >>>
-                    if st.session_state.video_path and os.path.exists(st.session_state.video_path): status_vid.update(label="Ultra animatic assembled! 🎉", state="complete", expanded=False); st.balloons()
-                    else: status_vid.update(label="Video assembly failed. Check logs.", state="error", expanded=False); logger.error("Video assembly returned None or file does not exist.")
-                else: status_vid.update(label="No valid images with duration for video.", state="error", expanded=False); logger.warning("No valid images found for video assembly.")
-    elif st.session_state.story_treatment_scenes: st.info("Generate visuals before assembling video.")
+                    if st.session_state.video_path and os.path.exists(st.session_state.video_path):
+                        status_vid.update(label="Ultra animatic assembled! 🎉", state="complete", expanded=False); st.balloons()
+                    else:
+                        status_vid.update(label="Video assembly failed. Check logs.", state="error", expanded=False); logger.error("Video assembly returned None or file does not exist.")
+                else:
+                    status_vid.update(label="No valid assets for video assembly.", state="error", expanded=False); logger.warning("No valid assets found for video assembly.")
+    elif st.session_state.story_treatment_scenes: st.info("Generate visual assets before assembling video.")
+    # <<< MODIFIED END >>>
 
     if st.session_state.video_path and os.path.exists(st.session_state.video_path):
         st.header("🎬 Generated Cinematic Animatic");
         try:
             with open(st.session_state.video_path, 'rb') as vf_obj: video_bytes = vf_obj.read()
             st.video(video_bytes, format="video/mp4")
-            with open(st.session_state.video_path, "rb") as fp_dl:
-                st.download_button(label="Download Ultra Animatic", data=fp_dl, file_name=os.path.basename(st.session_state.video_path), mime="video/mp4", use_container_width=True, key="download_ultra_video_btn_v5" )
+            st.download_button(label="Download Ultra Animatic", data=video_bytes, file_name=os.path.basename(st.session_state.video_path), mime="video/mp4", use_container_width=True, key="download_ultra_video_btn_v5" )
         except Exception as e: st.error(f"Error displaying video: {e}"); logger.error(f"Error displaying video: {e}", exc_info=True)
 
 # --- Footer ---