Update app.py

app.py

@@ -1,1141 +1,897 @@
-# -*- coding: utf-8 -*-
+# app.py
 import gradio as gr
+import soundfile as sf
+import torch
+from IPython.display import display, Audio, HTML
+import soundfile as sf
 import os
-import shutil
-import requests
-import io
-import time
-import re
+from moviepy.editor import VideoFileClip, AudioFileClip, ImageClip
+from PIL import Image
+import tempfile
 import random
+import cv2
 import math
-import tempfile
-import traceback
-import numpy as np
-import soundfile as sf
-# import pysrt # Not strictly needed if embedding captions directly
-import cv2 # OpenCV for potential image processing, though PIL is often enough
+import os, requests, io, time, re, random
 from moviepy.editor import (
-    VideoFileClip, AudioFileClip, ImageClip, concatenate_videoclips,
-    CompositeVideoClip, TextClip, CompositeAudioClip, ColorClip
+    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
+    CompositeVideoClip, TextClip, CompositeAudioClip
 )
 import moviepy.video.fx.all as vfx
-import moviepy.audio.fx.all as afx # Import audio effects
+import moviepy.config as mpy_config
 from pydub import AudioSegment
+from pydub.generators import Sine
 from PIL import Image, ImageDraw, ImageFont
+import numpy as np
 from bs4 import BeautifulSoup
+import base64
 from urllib.parse import quote
+import pysrt
 from gtts import gTTS
-import logging
+import shutil
+import webbrowser # This won't work in HF Spaces, but keep for local testing reference
+import sys
 
-# --- Configuration ---
-# WARNING: Hardcoding keys is generally discouraged due to security risks.
-# Anyone who can see this code can use your keys.
+# --- API Keys (Embed directly as requested for private space) ---
 PEXELS_API_KEY = 'BhJqbcdm9Vi90KqzXKAhnEHGsuFNv4irXuOjWtT761U49lRzo03qBGna'
-OPENROUTER_API_KEY = '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'
+OPENROUTER_API_KEY = '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'
+OPENROUTER_MODEL = "mistralai/mistral-small-3.1-24b-instruct:free"
 
-OPENROUTER_MODEL = "mistralai/mistral-7b-instruct:free" # Using a known free model
-# OPENROUTER_MODEL = "mistralai/mistral-small-latest" # Or a small paid one if needed
-
-TEMP_FOLDER_BASE = "/tmp/ai_doc_generator" # Use /tmp inside container
-OUTPUT_VIDEO_FILENAME = "final_documentary.mp4"
+# --- Global Configuration ---
+TEMP_FOLDER = "temp_video_processing"
+OUTPUT_VIDEO_FILENAME = "final_video.mp4"
 USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-# Try a very common font likely available in the base python image or installed via apt
-# If text fails, consider installing specific font packages in Dockerfile (e.g., fonts-freefont-ttf)
-DEFAULT_FONT = "DejaVuSans.ttf" # Or try "FreeSans.ttf" if fonts-freefont-ttf is installed
-BGM_FILE = "background_music.mp3" # Optional: Place a royalty-free mp3 here
-BGM_VOLUME = 0.1 # Background music volume multiplier (0.0 to 1.0)
-
-# --- Logging Setup ---
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# --- Kokoro TTS Initialization (Optional - Keep commented unless installed) ---
-# KOKORO_ENABLED = False
-# pipeline = None
-# try:
-#     from kokoro import KPipeline
-#     device = 'cpu' # Default to CPU
-#     pipeline = KPipeline(lang_code='a', device=device)
-#     KOKORO_ENABLED = True
-#     logging.info("✅ Kokoro TTS Initialized.")
-# except ImportError:
-#     logging.warning("Kokoro library not found. Falling back to gTTS.")
-#     pipeline = None
-# except Exception as e:
-#     logging.warning(f"⚠️ Error initializing Kokoro TTS: {e}. Using gTTS fallback.")
-#     pipeline = None
-
-# --- Helper Functions --- (Keep all helper functions from the previous version)
-def generate_script(topic, api_key, model):
-    """Generates a documentary script using OpenRouter API."""
-    logging.info(f"Generating script for topic: {topic}")
-    # Check if API key is placeholder or empty
-    if not api_key or "sk-or-v1-" not in api_key:
-         logging.error("❌ Script generation failed: OpenRouter API Key is missing or invalid.")
-         return None
-
-    prompt = f"""Create a short documentary script about '{topic}'.
-The script should be structured as a sequence of scenes and narrations.
-Each scene description should be enclosed in [SCENE: description] tags. The description should be concise and suggest visuals (e.g., 'drone shot of mountains', 'close up of a historical artifact', 'archival footage of protests').
-Each narration segment should follow its corresponding scene and be enclosed in [NARRATION: text] tags. The narration should be engaging and informative, broken into short sentences suitable for ~5-10 second clips.
-Keep the total number of scenes between 5 and 8.
-
-Example:
-[SCENE: Time-lapse of a bustling city street at night]
-[NARRATION: Cities are centers of human activity, constantly evolving.]
-[SCENE: Close up on intricate gears of an old clock]
-[NARRATION: But how do we measure the relentless march of time?]
-
-Generate the script now:
-"""
+
+# --- Initialize Kokoro TTS pipeline (if compatible with HF CPU) ---
+# NOTE: Kokoro might be too resource-intensive for free CPU spaces.
+# If it causes issues, you might need to remove it and rely solely on gTTS.
+try:
+    from kokoro import KPipeline
+    pipeline = KPipeline(lang_code='a')  # Use voice 'af_heart' for American English
+    print("Kokoro TTS pipeline initialized.")
+except ImportError:
+    print("Kokoro library not found or failed to initialize. Will rely on gTTS.")
+    pipeline = None
+except Exception as e:
+    print(f"Error initializing Kokoro: {e}. Will rely on gTTS.")
+    pipeline = None
+
+
+# Ensure ImageMagick binary is set (might need adjustment for HF Spaces)
+# This path might differ in the HF environment.
+# If this causes issues, you might need to use a Dockerfile or configure the space differently.
+mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
+
+# --- Helper Functions (from original script) ---
+
+def generate_script(user_input):
+    """Generate documentary script with proper OpenRouter handling."""
     headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-        "HTTP-Referer": "http://localhost", # Some APIs require Referer
-        "X-Title": "AI Documentary Generator" # Optional custom title
+        'Authorization': f'Bearer {OPENROUTER_API_KEY}',
+        'HTTP-Referer': 'https://your-domain.com',
+        'X-Title': 'AI Documentary Maker'
     }
-    data = {
-        "model": model,
-        "messages": [{"role": "user", "content": prompt}],
-        "max_tokens": 1000, # Adjust as needed
-    }
-    try:
-        response = requests.post("https://openrouter.ai/api/v1/chat/completions", headers=headers, json=data, timeout=90) # Increased timeout
-        logging.debug(f"OpenRouter Request: Headers={headers}, Data={data}")
-        logging.debug(f"OpenRouter Response Status: {response.status_code}")
-        logging.debug(f"OpenRouter Response Body: {response.text[:500]}...") # Log beginning of response
 
-        response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
-        result = response.json()
+    prompt = f"""Short Documentary Script GeneratorInstructions:
 
-        if not result.get('choices') or not result['choices'][0].get('message') or not result['choices'][0]['message'].get('content'):
-            logging.error("❌ Script generation failed: Unexpected API response format (missing content).")
-            logging.debug(f"Full API response: {result}")
-            return None
+If I say "use this," just output the script exactly as I gave it.
+If I only give topics, generate a script based on them.
+If I provide a full script, rewrite it without any changes. Make everything short simple and humarous funny and act as serious but humarous. And don't say anything off topic. Also alway say a funny statement to subscribe based on the video topic at the end. Use normal conversational text like a normal person talking and avoid AI phase make the statements humanize and normal conversational
+And always talk negative views don't really wants any positive statement and the full script will be one video about one topic so keep in mind
+Formatting Rules:
 
-        script_content = result['choices'][0]['message']['content']
-        logging.info("✅ Script generated successfully.")
-        # Basic validation
-        if "[SCENE:" not in script_content or "[NARRATION:" not in script_content:
-             logging.error("❌ Script generation failed: Output format incorrect.")
-             logging.debug(f"Raw script output: {script_content}")
-             # Return the raw content anyway, maybe parsing can salvage something
-             # return None
-             return script_content # Let parsing try
-        return script_content
-    except requests.exceptions.Timeout:
-        logging.error("❌ Script generation failed: API request timed out.")
-        return None
-    except requests.exceptions.HTTPError as e:
-        logging.error(f"❌ Script generation failed: HTTP error: {e.response.status_code} - {e.response.text}")
-        return None
-    except requests.exceptions.RequestException as e:
-        logging.error(f"❌ Script generation failed: API request error: {e}")
-        return None
-    except (KeyError, IndexError, TypeError) as e:
-         logging.error(f"❌ Script generation failed: Error processing API response: {e}")
-         logging.debug(f"Raw API response text: {response.text}")
-         return None
-    except Exception as e:
-        logging.error(f"❌ Script generation failed: An unexpected error occurred: {e}")
-        traceback.print_exc()
-        return None
 
-def parse_script(script_text):
-    """Parses the generated script into scene prompts and narration text."""
-    logging.info("Parsing script...")
-    if not script_text:
-        logging.error("❌ Script parsing failed: Input script text is empty.")
-        return None
+Title in Square Brackets:
 
-    # Regex to find scene and narration blocks, more tolerant to whitespace variations
-    pattern = re.compile(r"\[SCENE:\s*(.*?)\s*\]\s*\[NARRATION:\s*(.*?)\s*\]", re.DOTALL | re.IGNORECASE)
-    matches = pattern.findall(script_text)
-
-    if not matches:
-        # Try a simpler split if the strict pattern fails, maybe format was slightly off
-        logging.warning("⚠️ Strict [SCENE]/[NARRATION] parsing failed. Attempting fallback split.")
-        elements_temp = re.split(r'\[(SCENE|NARRATION):\s*', script_text, flags=re.IGNORECASE)
-        if len(elements_temp) > 1:
-            elements_temp = [el.strip().rstrip(']') for el in elements_temp if el and el.strip() not in ['SCENE', 'NARRATION']]
-            # Try to pair them up
-            paired_elements = []
-            for i in range(0, len(elements_temp) - 1, 2):
-                 # Basic check if first looks like scene and second like narration
-                 if len(elements_temp[i]) < 100 and len(elements_temp[i+1]) > 10: # Heuristic
-                     paired_elements.append({"type": "scene", "prompt": elements_temp[i]})
-                     paired_elements.append({"type": "narration", "text": elements_temp[i+1].replace('\n', ' ')})
-            if paired_elements:
-                 logging.info(f"✅ Fallback parsing successful, found {len(paired_elements)//2} pairs.")
-                 return paired_elements
-            else:
-                 logging.error("❌ Fallback script parsing also failed.")
-                 logging.debug(f"Script content for parsing: {script_text}")
-                 return None
-        else:
-            logging.error("❌ Script parsing failed: No [SCENE]/[NARRATION] pairs found, and fallback split failed.")
-            logging.debug(f"Script content for parsing: {script_text}")
-            return None
 
+Each section starts with a one-word title inside [ ] (max two words if necessary).
+This title will be used as a search term for Pexels footage.
 
-    elements = []
-    for scene_desc, narration_text in matches:
-        scene_desc = scene_desc.strip()
-        narration_text = narration_text.strip().replace('\n', ' ').replace('"', "'") # Clean up narration, replace double quotes
-        if scene_desc and narration_text:
-            elements.append({"type": "scene", "prompt": scene_desc})
-            elements.append({"type": "narration", "text": narration_text})
-        else:
-            logging.warning(f"⚠️ Skipping invalid pair: Scene='{scene_desc}', Narration='{narration_text}'")
 
 
-    logging.info(f"✅ Script parsed into {len(elements)//2} scene/narration pairs.")
-    return elements
+Casual & Funny Narration:
 
-def search_pexels(query, api_key, media_type="videos", per_page=5, orientation="any"):
-    """Searches Pexels API for videos or photos."""
-    if not api_key or api_key == "YOUR_PEXELS_API_KEY_HERE": # Check actual key too
-        logging.warning("⚠️ Pexels API key not configured. Skipping search.")
-        return []
-    logging.info(f"Searching Pexels {media_type} for: '{query}' (Orientation: {orientation})")
-    base_url = f"https://api.pexels.com/{media_type}/search"
-    headers = {"Authorization": api_key}
-    params = {"query": query, "per_page": per_page}
-    if orientation != "any":
-        params["orientation"] = orientation # landscape or portrait
 
-    try:
-        response = requests.get(base_url, headers=headers, params=params, timeout=30) # Increased timeout
-        response.raise_for_status()
-        data = response.json()
-
-        results = []
-        media_key = 'videos' if media_type == 'videos' else 'photos'
-        link_key = 'video_files' if media_type == 'videos' else 'src'
-        items = data.get(media_key, [])
-
-        if not items:
-             logging.info(f"No Pexels {media_type} results found for '{query}'.")
-             return []
-
-        for item in items:
-            if media_type == 'videos':
-                video_links = sorted([vf for vf in item.get(link_key, []) if vf.get('link')], key=lambda x: x.get('width', 0), reverse=True)
-                if video_links:
-                    # Prefer HD (1920 or 1280 width) or highest quality
-                    hd_link = next((link['link'] for link in video_links if link.get('width') in [1920, 1280]), None)
-                    if hd_link:
-                        results.append({'url': hd_link, 'type': 'video', 'width': next(link['width'] for link in video_links if link['link'] == hd_link), 'height': next(link['height'] for link in video_links if link['link'] == hd_link)})
-                    elif video_links[0].get('link'): # Fallback to highest available
-                         link_data = video_links[0]
-                         results.append({'url': link_data['link'], 'type': 'video', 'width': link_data.get('width'), 'height': link_data.get('height')})
-            else: # photos
-                img_links = item.get(link_key, {})
-                # Prioritize larger sizes
-                chosen_url = img_links.get('large2x') or img_links.get('large') or img_links.get('original') or img_links.get('medium')
-                if chosen_url:
-                    results.append({'url': chosen_url, 'type': 'image', 'width': item.get('width'), 'height': item.get('height')})
-
-        logging.info(f"✅ Found {len(results)} Pexels {media_type} results for '{query}'.")
-        return results
-
-    except requests.exceptions.Timeout:
-        logging.error(f"❌ Pexels API request timed out for '{query}'.")
-        return []
-    except requests.exceptions.HTTPError as e:
-        logging.error(f"❌ Pexels API HTTP error for '{query}': {e.response.status_code} - {e.response.text}")
-        return []
-    except requests.exceptions.RequestException as e:
-        logging.error(f"❌ Pexels API request error for '{query}': {e}")
-        return []
-    except Exception as e:
-        logging.error(f"❌ Error processing Pexels response for '{query}': {e}")
-        traceback.print_exc()
-        return []
+Each section has 5-10 words of narration.
+Keep it natural, funny, and unpredictable (not robotic, poetic, or rhythmic).
 
-def download_media(url, save_dir):
-    """Downloads media (video or image) from a URL."""
-    logging.info(f"Downloading media from: {url[:100]}...") # Log truncated URL
-    try:
-        response = requests.get(url, stream=True, timeout=120, headers={'User-Agent': USER_AGENT}) # Increased timeout
-        response.raise_for_status()
 
-        # Try to get filename
-        filename = None
-        cd = response.headers.get('content-disposition')
-        if cd:
-            fname = re.findall('filename="?(.+)"?', cd)
-            if fname:
-                filename = fname[0]
-
-        if not filename:
-            # Basic filename from URL path
-            filename = url.split('/')[-1].split('?')[0]
-            # Clean filename and ensure extension
-            filename = re.sub(r'[^\w\.\-]', '_', filename) # Replace invalid chars
-            if '.' not in filename[-5:]: # Check last 5 chars for extension
-                 # Guess extension from content type
-                 content_type = response.headers.get('content-type', '').lower()
-                 ext = '.vid' # default video extension
-                 if 'jpeg' in content_type or 'jpg' in content_type: ext = '.jpg'
-                 elif 'png' in content_type: ext = '.png'
-                 elif 'mp4' in content_type: ext = '.mp4'
-                 elif 'video' in content_type: ext = '.mp4' # Guess mp4 for generic video
-                 elif 'image' in content_type: ext = '.jpg' # Guess jpg for generic image
-                 filename = f"media_{int(time.time())}{ext}"
-
-        # Ensure filename is not excessively long
-        if len(filename) > 100:
-            name, ext = os.path.splitext(filename)
-            filename = name[:95] + ext
-
-
-        save_path = os.path.join(save_dir, filename)
-        logging.info(f"Saving media to: {save_path}")
-
-        with open(save_path, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192*4): # Larger chunk size
-                f.write(chunk)
 
-        # Verify file size (basic check)
-        file_size = os.path.getsize(save_path)
-        if file_size < 1024: # Less than 1KB might indicate an issue
-             logging.warning(f"⚠️ Downloaded media file size is small ({file_size} bytes). Check file: {save_path}")
+No Special Formatting:
 
-        logging.info(f"✅ Media downloaded successfully ({file_size / 1024:.1f} KB).")
-        return save_path
-    except requests.exceptions.Timeout:
-        logging.error(f"❌ Media download timed out: {url}")
-        return None
-    except requests.exceptions.RequestException as e:
-        logging.error(f"❌ Media download failed: Request error: {e}")
-        return None
-    except Exception as e:
-        logging.error(f"❌ Media download failed: An unexpected error occurred: {e}")
-        traceback.print_exc()
-        return None
 
-def generate_tts(text, lang, save_dir, segment_index):
-    """Generates TTS audio using gTTS."""
-    filename = f"narration_{segment_index}.mp3"
-    filepath = os.path.join(save_dir, filename)
-    # Clean text for TTS - remove characters that might cause issues
-    text = re.sub(r'[\[\]\*#]', '', text) # Remove brackets, asterisks, hash
-    text = text.strip()
-    if not text:
-        logging.error(f"❌ TTS failed for segment {segment_index}: Text is empty after cleaning.")
-        return None, 0
+No bold, italics, or special characters. You are a assistant AI your task is to create script. You aren't a chatbot. So, don't write extra text
 
-    logging.info(f"Generating TTS for segment {segment_index}: '{text[:60]}...'")
 
-    audio_duration = 0
-    success = False
 
-    try:
-        logging.info("Attempting TTS generation with gTTS...")
-        tts = gTTS(text=text, lang=lang, slow=False) # Use slow=False for normal speed
-        tts.save(filepath)
-        # Get duration using soundfile as primary method
-        try:
-            audio_info = sf.info(filepath)
-            audio_duration = audio_info.duration
-            if audio_duration < 0.1: # Check for invalid duration from sf.info
-                 raise ValueError("Soundfile reported near-zero duration")
-        except Exception as e_dur_sf:
-             logging.warning(f"⚠️ Could not get accurate duration using soundfile ({e_dur_sf}). Trying pydub...")
-             try:
-                 # Ensure file is written before pydub tries to read
-                 time.sleep(0.1)
-                 audio_seg = AudioSegment.from_mp3(filepath)
-                 audio_duration = len(audio_seg) / 1000.0
-             except Exception as e_dur_pd:
-                 logging.error(f"❌ Failed to get duration with pydub as well ({e_dur_pd}). Estimating duration.")
-                 # Estimate duration based on words (rough fallback)
-                 words_per_minute = 140 # Adjusted estimate
-                 num_words = len(text.split())
-                 audio_duration = max(1.0, (num_words / words_per_minute) * 60) # Ensure at least 1 second
-
-        # Final duration sanity check
-        if audio_duration < 0.5:
-             logging.warning(f"⚠️ Calculated audio duration is very short ({audio_duration:.2f}s). Setting minimum to 1.0s.")
-             audio_duration = 1.0
-
-
-        logging.info(f"✅ gTTS generated successfully ({audio_duration:.2f}s).")
-        success = True
-    except gTTS.gTTSError as e_gtts:
-         logging.error(f"❌ gTTS API Error: {e_gtts}")
-         success = False
-    except Exception as e:
-        logging.error(f"❌ gTTS failed with unexpected error: {e}")
-        traceback.print_exc()
-        success = False
+Generalized Search Terms:
 
-    return filepath if success else None, audio_duration if success else 0
 
+If a term is too specific, make it more general for Pexels search.
 
-def resize_media_to_fill(clip, target_size):
-    """Resizes a MoviePy clip (video or image) to fill the target size, cropping if necessary."""
-    target_w, target_h = target_size
-    if target_w == 0 or target_h == 0:
-        logging.error("Target size cannot have zero dimensions.")
-        return clip # Return original clip
 
-    target_aspect = target_w / target_h
 
-    # Ensure clip has size attribute
-    if not hasattr(clip, 'size'):
-        logging.error("Input clip does not have 'size' attribute.")
-        return clip
-    clip_w, clip_h = clip.size
-    if clip_w == 0 or clip_h == 0:
-         logging.warning("Input clip has zero dimensions. Cannot resize.")
-         # Return a black clip of target size instead?
-         return ColorClip(size=target_size, color=(0,0,0), duration=clip.duration if hasattr(clip, 'duration') else 1)
+Scene-Specific Writing:
 
 
-    clip_aspect = clip_w / clip_h
+Each section describes only what should be shown in the video.
 
-    if abs(clip_aspect - target_aspect) < 0.01: # Aspect ratios are close enough
-        # Just resize to fit width, height should scale correctly
-        return clip.resize(width=target_w)
 
-    if clip_aspect > target_aspect:
-        # Clip is wider than target: Resize based on height, then crop width
-        resized_clip = clip.resize(height=target_h)
-        # Calculate crop coordinates
-        crop_x_center = resized_clip.w / 2
-        crop_x1 = max(0, int(crop_x_center - target_w / 2))
-        crop_x2 = min(resized_clip.w, int(crop_x_center + target_w / 2))
-        # Adjust width if rounding caused issues
-        if crop_x2 - crop_x1 != target_w:
-            crop_x2 = crop_x1 + target_w
-            if crop_x2 > resized_clip.w: # Ensure it doesn't go out of bounds
-                crop_x2 = resized_clip.w
-                crop_x1 = max(0, crop_x2 - target_w)
-
-        return resized_clip.fx(vfx.crop, x1=crop_x1, y1=0, width=target_w, height=target_h)
-    else:
-        # Clip is taller than target: Resize based on width, then crop height
-        resized_clip = clip.resize(width=target_w)
-        # Calculate crop coordinates
-        crop_y_center = resized_clip.h / 2
-        crop_y1 = max(0, int(crop_y_center - target_h / 2))
-        crop_y2 = min(resized_clip.h, int(crop_y_center + target_h / 2))
-         # Adjust height if rounding caused issues
-        if crop_y2 - crop_y1 != target_h:
-            crop_y2 = crop_y1 + target_h
-            if crop_y2 > resized_clip.h: # Ensure it doesn't go out of bounds
-                crop_y2 = resized_clip.h
-                crop_y1 = max(0, crop_y2 - target_h)
-
-        return resized_clip.fx(vfx.crop, x1=0, y1=crop_y1, width=target_w, height=target_h)
-
-
-def apply_ken_burns(image_clip, duration, target_size, zoom_factor=1.15, direction='zoom_out'):
-    """Applies Ken Burns effect (zoom in/out, simple pan) to an ImageClip."""
-    if not isinstance(image_clip, ImageClip):
-        logging.warning("Ken Burns effect can only be applied to ImageClips.")
-        return image_clip.set_duration(duration) # Just set duration if not image
-
-    # Ensure the input clip already matches the target size (or resize it)
-    if image_clip.size != target_size:
-         logging.info("Applying Ken Burns: Resizing image to fill target size first.")
-         image_clip = resize_media_to_fill(image_clip, target_size)
-
-    # Make sure the base clip has the correct duration before applying effects
-    image_clip = image_clip.set_duration(duration)
-
-    img_w, img_h = image_clip.size
-
-    # Define the resize function based on time `t`
-    def resize_func(t):
-        if direction == 'zoom_out':
-            # Zoom out: start at zoom_factor, end at 1.0
-            current_zoom = 1 + (zoom_factor - 1) * (1 - t / duration)
-        elif direction == 'zoom_in':
-             # Zoom in: start at 1.0, end at zoom_factor
-             current_zoom = 1 + (zoom_factor - 1) * (t / duration)
-        else: # No zoom
-            current_zoom = 1.0
-        return current_zoom
-
-    # Apply zoom effect
-    zoomed_clip = image_clip.fx(vfx.resize, resize_func)
-
-    # Simple Pan (optional, can be randomized)
-    # Example: Pan slightly horizontally
-    pan_intensity = 0.05 # Fraction of width/height to pan
-    start_x_offset = 0
-    end_x_offset = pan_intensity * img_w * random.choice([-1, 1]) # Pan left or right
-    start_y_offset = 0
-    end_y_offset = pan_intensity * img_h * random.choice([-1, 1]) # Pan up or down
-
-    def position_func(t):
-        current_x = start_x_offset + (end_x_offset - start_x_offset) * (t / duration)
-        current_y = start_y_offset + (end_y_offset - start_y_offset) * (t / duration)
-        # Position is relative to the zoomed clip's center
-        center_x = zoomed_clip.w / 2 - current_x
-        center_y = zoomed_clip.h / 2 - current_y
-        return (center_x - target_size[0]/2, center_y - target_size[1]/2) # Top-left corner for crop
-
-    # Apply cropping based on the calculated position
-    # Use a function for position to simulate pan
-    final_clip = zoomed_clip.fx(vfx.crop, x1=lambda t: position_func(t)[0], y1=lambda t: position_func(t)[1], width=target_size[0], height=target_size[1])
-
-    return final_clip.set_duration(duration)
-
-
-def find_font(preferred_font=DEFAULT_FONT):
-    """Tries to find a usable font file."""
-    # 1. Check if preferred font exists directly (e.g., uploaded)
-    if os.path.exists(preferred_font):
-        logging.info(f"Using specified font: {preferred_font}")
-        return preferred_font
-
-    # 2. Common system font paths (Linux)
-    font_paths = [
-        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
-        "/usr/share/fonts/truetype/freefont/FreeSans.ttf",
-        "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
-        "/usr/share/fonts/truetype/msttcorefonts/Arial.ttf", # If installed
-        # Add more paths if needed
-    ]
-    for path in font_paths:
-        if os.path.exists(path):
-            logging.info(f"Found system font: {path}")
-            return path
-
-    # 3. Use MoviePy's default if nothing else is found
-    logging.warning(f"Could not find specified font '{preferred_font}' or common system fonts. Relying on MoviePy's default.")
-    return None # Let MoviePy use its internal default
-
-
-def create_caption_clip(text, duration, clip_size, font_size=None, font_path=None, color='white', stroke_color='black', stroke_width=1.5, position=('center', 'bottom'), margin_percent=5):
-    """Creates a MoviePy TextClip for captions with wrapping and background."""
-    width, height = clip_size
-    max_text_width = width * 0.85 # Allow text to occupy 85% of the width
-    margin = int(height * (margin_percent / 100)) # Margin based on percentage of height
-
-    if font_size is None:
-        font_size = max(20, int(height / 28)) # Dynamic font size based on height
-
-    actual_font_path = find_font(font_path or DEFAULT_FONT)
-
-    # Use Pillow for reliable text wrapping (MoviePy's can be inconsistent)
-    try:
-        pil_font = ImageFont.truetype(actual_font_path, font_size) if actual_font_path else ImageFont.load_default()
-    except IOError:
-        logging.warning(f"Failed to load font '{actual_font_path}' with Pillow. Using default.")
-        pil_font = ImageFont.load_default()
-        font_size = 18 # Reset font size if using default
-
-    words = text.split()
-    lines = []
-    current_line = ""
-
-    # Simple greedy word wrapping using Pillow's textlength
-    for word in words:
-        test_line = f"{current_line} {word}".strip()
-        # Use textlength for more accurate width calculation
-        line_width = pil_font.getlength(test_line)
-        if line_width <= max_text_width:
-            current_line = test_line
-        else:
-            if current_line: # Add the previous line if it wasn't empty
-                 lines.append(current_line)
-            current_line = word # Start new line with the current word
-            # Handle case where a single word is too long
-            if pil_font.getlength(current_line) > max_text_width:
-                 logging.warning(f"Word '{current_line}' might be too long for caption width.")
-                 # Basic split for very long words (optional)
-                 # while pil_font.getlength(current_line) > max_text_width:
-                 #     for i in range(len(current_line)-1, 0, -1):
-                 #         if pil_font.getlength(current_line[:i]) <= max_text_width:
-                 #             lines.append(current_line[:i] + '-')
-                 #             current_line = current_line[i:]
-                 #             break
-                 #     else: # Cannot split further
-                 #         break # Avoid infinite loop
-
-    if current_line: # Add the last line
-        lines.append(current_line)
-
-    wrapped_text = "\n".join(lines)
-
-    # Create the TextClip
-    try:
-        caption = TextClip(
-            wrapped_text,
-            fontsize=font_size,
-            color=color,
-            font=actual_font_path if actual_font_path else 'Arial', # Provide a common fallback font name
-            stroke_color=stroke_color,
-            stroke_width=stroke_width,
-            method='caption', # Use caption method for potential internal wrapping
-            size=(int(max_text_width), None), # Constrain width for wrapping
-            align='center'
-        )
 
-        # Add a semi-transparent background for better readability
-        bg_color = (0, 0, 0) # Black background
-        bg_opacity = 0.5
-        # Create a ColorClip slightly larger than the text
-        txt_width, txt_height = caption.size
-        bg_padding = int(font_size * 0.3) # Padding around text
-        bg_clip = ColorClip(
-            size=(txt_width + 2 * bg_padding, txt_height + 2 * bg_padding),
-            color=bg_color,
-            ismask=False,
-            duration=duration
-        ).set_opacity(bg_opacity)
-
-        # Composite text on background
-        caption_with_bg = CompositeVideoClip([
-            bg_clip.set_position('center'),
-            caption.set_position('center')
-        ], size=bg_clip.size).set_duration(duration)
+Output Only the Script, and also make it funny and humarous and helirous and also add to subscribe with a funny statement like subscribe now or .....
 
 
-    except Exception as e:
-         logging.error(f"Error creating TextClip (maybe font issue?): {e}. Using simple TextClip.")
-         traceback.print_exc()
-         # Fallback to simpler TextClip without stroke/bg if needed
-         caption_with_bg = TextClip(wrapped_text, fontsize=font_size, color=color, method='caption', size=(int(max_text_width), None), align='center').set_duration(duration)
-
-
-    # Set position with margin
-    # MoviePy position can be tricky, calculate manually
-    final_pos = ['center', 'center'] # Default
-    caption_w, caption_h = caption_with_bg.size
-
-    if isinstance(position, tuple) or isinstance(position, list):
-        pos_x, pos_y = position
-        # Horizontal positioning
-        if 'left' in pos_x: final_pos[0] = margin
-        elif 'right' in pos_x: final_pos[0] = width - caption_w - margin
-        else: final_pos[0] = (width - caption_w) / 2 # Center default
-        # Vertical positioning
-        if 'top' in pos_y: final_pos[1] = margin
-        elif 'bottom' in pos_y: final_pos[1] = height - caption_h - margin
-        else: final_pos[1] = (height - caption_h) / 2 # Center default
-
-    # Ensure positions are integers
-    final_pos = (int(final_pos[0]), int(final_pos[1]))
-
-    caption_with_bg = caption_with_bg.set_position(final_pos).set_duration(duration)
-    return caption_with_bg
-
-
-def create_clip(media_path, media_type, audio_path, audio_duration, target_size, add_captions, narration_text, segment_index):
-    """Creates a single video clip from media, audio, and optional captions."""
-    logging.info(f"--- Creating Clip {segment_index + 1} ---")
-    logging.info(f"Type: {media_type}, Audio Duration: {audio_duration:.2f}s, Target Size: {target_size}")
-    main_clip = None
-    audio_clip = None
+No extra text, just the script.
+
+
+
+Example Output:
+[North Korea]
+
+Top 5 unknown facts about North Korea.
+
+[Invisibility]
+
+North Korea’s internet speed is so fast… it doesn’t exist.
+
+[Leadership]
+
+Kim Jong-un once won an election with 100% votes… against himself.
+
+[Magic]
+
+North Korea discovered time travel. That’s why their news is always from the past.
+
+[Warning]
+
+Subscribe now, or Kim Jong-un will send you a free one-way ticket… to North Korea.
+
+[Freedom]
+
+North Korean citizens can do anything… as long as it's government-approved.
+Now here is the Topic/scrip: {user_input}
+"""
+
+    data = {
+        'model': OPENROUTER_MODEL,
+        'messages': [{'role': 'user', 'content': prompt}],
+        'temperature': 0.4,
+        'max_tokens': 5000
+    }
 
     try:
-        # --- Load Audio ---
-        logging.info("Loading audio...")
-        audio_clip = AudioFileClip(audio_path)
-        # Verify audio duration and clamp if necessary
-        if abs(audio_clip.duration - audio_duration) > 0.2: # Allow slightly larger diff
-             logging.warning(f"Audio file duration ({audio_clip.duration:.2f}s) differs significantly from expected ({audio_duration:.2f}s). Using file duration.")
-             audio_duration = audio_clip.duration
-        # Ensure minimum duration
-        if audio_duration < 0.5:
-            logging.warning(f"Audio duration is very short ({audio_duration:.2f}s). Clamping to 0.5s.")
-            audio_duration = 0.5
-        # Trim audio clip precisely
-        audio_clip = audio_clip.subclip(0, audio_duration)
-        logging.info("Audio loaded.")
-
-        # --- Load Media (Video, Image, or Color) ---
-        if media_type == 'video':
-            logging.info(f"Loading video: {media_path}")
-            try:
-                # Load with target resolution hint, disable audio from video file
-                video_clip_raw = VideoFileClip(media_path, audio=False, target_resolution=(target_size[1], target_size[0]))
+        response = requests.post(
+            'https://openrouter.ai/api/v1/chat/completions',
+            headers=headers,
+            json=data,
+            timeout=30
+        )
 
-                # Trim or loop video to match audio duration
-                if video_clip_raw.duration >= audio_duration:
-                    video_clip_timed = video_clip_raw.subclip(0, audio_duration)
-                else:
-                    # Loop the video if it's shorter
-                    logging.info(f"Video duration ({video_clip_raw.duration:.2f}s) shorter than audio ({audio_duration:.2f}s). Looping video.")
-                    # Use fx.loop for cleaner looping
-                    video_clip_timed = video_clip_raw.fx(vfx.loop, duration=audio_duration)
-                    # Fallback: manual concatenate (less efficient)
-                    # num_loops = math.ceil(audio_duration / video_clip_raw.duration)
-                    # video_clip_timed = concatenate_videoclips([video_clip_raw] * num_loops).subclip(0, audio_duration)
-
-                main_clip = resize_media_to_fill(video_clip_timed, target_size)
-                logging.info("Video processed.")
-                # Clean up raw clip explicitly? Moviepy should handle it, but just in case
-                # video_clip_raw.close() # Might cause issues if timed clip still references it
-
-            except Exception as e:
-                logging.error(f"❌ Failed to load/process video '{media_path}': {e}. Using black clip.")
-                traceback.print_exc()
-                main_clip = ColorClip(size=target_size, color=(0,0,0), duration=audio_duration)
-
-        elif media_type == 'image':
-            logging.info(f"Loading image: {media_path}")
-            try:
-                img_clip_base = ImageClip(media_path)
-                # Apply Ken Burns effect (includes resizing and duration setting)
-                main_clip = apply_ken_burns(img_clip_base, audio_duration, target_size)
-                logging.info("Image processed with Ken Burns effect.")
-            except Exception as e:
-                logging.error(f"❌ Failed to load/process image '{media_path}': {e}. Using black clip.")
-                traceback.print_exc()
-                main_clip = ColorClip(size=target_size, color=(0,0,0), duration=audio_duration)
-
-        else: # Includes 'color' type or any unexpected type
-             logging.info(f"Media type is '{media_type}'. Using black background.")
-             main_clip = ColorClip(size=target_size, color=(0,0,0), duration=audio_duration)
-
-        # --- Combine Video/Image and Audio ---
-        if main_clip and audio_clip:
-             # Ensure main_clip has correct duration before setting audio
-             main_clip = main_clip.set_duration(audio_duration)
-             main_clip = main_clip.set_audio(audio_clip)
-             logging.info("Audio attached to visual clip.")
-        elif main_clip:
-             logging.warning("Audio clip was not loaded successfully. Video will be silent.")
-             main_clip = main_clip.set_duration(audio_duration)
+        print("API Response Status:", response.status_code)
+        if response.status_code == 200:
+            response_data = response.json()
+            if 'choices' in response_data and len(response_data['choices']) > 0:
+                return response_data['choices'][0]['message']['content']
+            else:
+                print("Unexpected response format:", response_data)
+                return None
         else:
-             logging.error("❌ Failed to create main visual clip. Skipping segment.")
-             if audio_clip: audio_clip.close()
-             return None
+            print(f"API Error {response.status_code}: {response.text}")
+            return None
+
+    except Exception as e:
+        print(f"Request failed: {str(e)}")
+        return None
+
+def parse_script(script_text):
+    """
+    Parse the generated script into a list of elements.
+    For each section, create two elements:
+      - A 'media' element using the section title as the visual prompt.
+      - A 'tts' element with the narration text, voice info, and computed duration.
+    """
+    sections = {}
+    current_title = None
+    current_text = ""
 
+    try:
+        for line in script_text.splitlines():
+            line = line.strip()
+            if line.startswith("[") and "]" in line:
+                bracket_start = line.find("[")
+                bracket_end = line.find("]", bracket_start)
+                if bracket_start != -1 and bracket_end != -1:
+                    if current_title is not None:
+                        sections[current_title] = current_text.strip()
+                    current_title = line[bracket_start+1:bracket_end]
+                    current_text = line[bracket_end+1:].strip()
+            elif current_title:
+                current_text += line + " "
+
+        if current_title:
+            sections[current_title] = current_text.strip()
+
+        elements = []
+        for title, narration in sections.items():
+            if not title or not narration:
+                continue
 
-        # --- Add Captions (if enabled) ---
-        final_composite_clip = main_clip # Start with the main clip
+            media_element = {"type": "media", "prompt": title, "effects": "fade-in"}
+            words = narration.split()
+            duration = max(3, len(words) * 0.5)
+            tts_element = {"type": "tts", "text": narration, "voice": "en", "duration": duration}
+            elements.append(media_element)
+            elements.append(tts_element)
 
-        if add_captions and narration_text:
-            logging.info("Adding captions...")
+        return elements
+    except Exception as e:
+        print(f"Error parsing script: {e}")
+        return []
+
+def search_pexels_videos(query, pexels_api_key):
+    """Search for a video on Pexels by query and return a random HD video."""
+    headers = {'Authorization': pexels_api_key}
+    base_url = "https://api.pexels.com/videos/search"
+    num_pages = 3
+    videos_per_page = 15
+    max_retries = 3
+    retry_delay = 1
+    search_query = query
+    all_videos = []
+
+    for page in range(1, num_pages + 1):
+        for attempt in range(max_retries):
             try:
-                caption_clip = create_caption_clip(
-                    narration_text,
-                    audio_duration,
-                    target_size,
-                    font_path=DEFAULT_FONT # Pass the default font path
-                )
-                # Composite caption on top of the main clip
-                final_composite_clip = CompositeVideoClip([main_clip, caption_clip], size=target_size)
-                logging.info("Captions added.")
-            except Exception as e:
-                 logging.error(f"❌ Failed to create or composite captions: {e}")
-                 traceback.print_exc()
-                 # Proceed without captions if creation failed
-                 final_composite_clip = main_clip
-        else:
-            logging.info("Captions disabled or no narration text.")
+                params = {"query": search_query, "per_page": videos_per_page, "page": page}
+                response = requests.get(base_url, headers=headers, params=params, timeout=10)
+
+                if response.status_code == 200:
+                    data = response.json()
+                    videos = data.get("videos", [])
+                    if not videos:
+                        break
+                    for video in videos:
+                        video_files = video.get("video_files", [])
+                        for file in video_files:
+                            if file.get("quality") == "hd":
+                                all_videos.append(file.get("link"))
+                                break
+                    break
+                elif response.status_code == 429:
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+                else:
+                    if attempt < max_retries - 1:
+                        time.sleep(retry_delay)
+                        retry_delay *= 2
+                    else:
+                        break
+            except requests.exceptions.RequestException as e:
+                if attempt < max_retries - 1:
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+                else:
+                    break
 
+    if all_videos:
+        random_video = random.choice(all_videos)
+        return random_video
+    else:
+        return None
 
-        logging.info(f"✅ Clip {segment_index + 1} created successfully.")
-        # Return the final composited clip (with or without captions)
-        return final_composite_clip
+def search_pexels_images(query, pexels_api_key):
+    """Search for an image on Pexels by query."""
+    headers = {'Authorization': pexels_api_key}
+    url = "https://api.pexels.com/v1/search"
+    params = {"query": query, "per_page": 5, "orientation": "landscape"}
+    max_retries = 3
+    retry_delay = 1
 
+    for attempt in range(max_retries):
+        try:
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            if response.status_code == 200:
+                data = response.json()
+                photos = data.get("photos", [])
+                if photos:
+                    photo = random.choice(photos[:min(5, len(photos))])
+                    img_url = photo.get("src", {}).get("original")
+                    return img_url
+                else:
+                    return None
+            elif response.status_code == 429:
+                time.sleep(retry_delay)
+                retry_delay *= 2
+            else:
+                if attempt < max_retries - 1:
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+        except requests.exceptions.RequestException as e:
+            if attempt < max_retries - 1:
+                time.sleep(retry_delay)
+                retry_delay *= 2
+
+    return None
+
+def search_google_images(query):
+    """Search for images on Google Images (for news-related queries)"""
+    try:
+        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch"
+        headers = {"User-Agent": USER_AGENT}
+        response = requests.get(search_url, headers=headers, timeout=10)
+        soup = BeautifulSoup(response.text, "html.parser")
+        img_tags = soup.find_all("img")
+        image_urls = []
+        for img in img_tags:
+            src = img.get("src", "")
+            if src.startswith("http") and "gstatic" not in src:
+                image_urls.append(src)
+        if image_urls:
+            return random.choice(image_urls[:5]) if len(image_urls) >= 5 else image_urls[0]
+        else:
+            return None
     except Exception as e:
-        logging.error(f"❌ Failed to create clip {segment_index + 1}: {e}")
-        traceback.print_exc()
-        # Ensure cleanup on error
-        if main_clip and hasattr(main_clip, 'close'): main_clip.close()
-        if audio_clip and hasattr(audio_clip, 'close'): audio_clip.close()
+        print(f"Error in Google Images search: {e}")
         return None
 
+def download_image(image_url, filename):
+    """Download an image from a URL to a local file with enhanced error handling."""
+    try:
+        headers = {"User-Agent": USER_AGENT}
+        response = requests.get(image_url, headers=headers, stream=True, timeout=15)
+        response.raise_for_status()
+        with open(filename, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        try:
+            img = Image.open(filename)
+            img.verify()
+            img = Image.open(filename)
+            if img.mode != 'RGB':
+                img = img.convert('RGB')
+                img.save(filename)
+            return filename
+        except Exception as e_validate:
+            print(f"Downloaded file is not a valid image: {e_validate}")
+            if os.path.exists(filename):
+                os.remove(filename)
+            return None
+    except requests.exceptions.RequestException as e_download:
+        print(f"Image download error: {e_download}")
+        if os.path.exists(filename):
+            os.remove(filename)
+        return None
+    except Exception as e_general:
+        print(f"General error during image processing: {e_general}")
+        if os.path.exists(filename):
+            os.remove(filename)
+        return None
 
-def add_background_music(video_clip, music_file=BGM_FILE, volume=BGM_VOLUME):
-    """Adds background music to the final video clip."""
-    if not os.path.exists(music_file):
-        logging.warning(f"Background music file '{music_file}' not found. Skipping BGM.")
-        return video_clip
-    # Check if file is empty or too small
-    if os.path.getsize(music_file) < 1024:
-        logging.warning(f"Background music file '{music_file}' is very small. Skipping BGM.")
-        return video_clip
+def download_video(video_url, filename):
+    """Download a video from a URL to a local file."""
+    try:
+        response = requests.get(video_url, stream=True, timeout=30)
+        response.raise_for_status()
+        with open(filename, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        return filename
+    except Exception as e:
+        print(f"Video download error: {e}")
+        if os.path.exists(filename):
+            os.remove(filename)
+        return None
 
+def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
+    """
+    Generate a visual asset by first searching for a video or using a specific search strategy.
+    For news-related queries, use Google Images.
+    Returns a dict: {'path': <file_path>, 'asset_type': 'video' or 'image'}.
+    """
+    safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
+
+    if "news" in prompt.lower():
+        image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_news.jpg")
+        image_url = search_google_images(prompt)
+        if image_url:
+            downloaded_image = download_image(image_url, image_file)
+            if downloaded_image:
+                return {"path": downloaded_image, "asset_type": "image"}
+        else:
+            print(f"Google Images search failed for prompt: {prompt}")
+
+    if random.random() < 0.25:
+        video_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_video.mp4")
+        video_url = search_pexels_videos(prompt, PEXELS_API_KEY)
+        if video_url:
+            downloaded_video = download_video(video_url, video_file)
+            if downloaded_video:
+                return {"path": downloaded_video, "asset_type": "video"}
+        else:
+            print(f"Pexels video search failed for prompt: {prompt}")
+
+    image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}.jpg")
+    image_url = search_pexels_images(prompt, PEXELS_API_KEY)
+    if image_url:
+        downloaded_image = download_image(image_url, image_file)
+        if downloaded_image:
+            return {"path": downloaded_image, "asset_type": "image"}
+        else:
+            print(f"Pexels image download failed for prompt: {prompt}")
+
+    fallback_terms = ["nature", "people", "landscape", "technology", "business"]
+    for term in fallback_terms:
+        fallback_file = os.path.join(TEMP_FOLDER, f"fallback_{term}.jpg")
+        fallback_url = search_pexels_images(term, PEXELS_API_KEY)
+        if fallback_url:
+            downloaded_fallback = download_image(fallback_url, fallback_file)
+            if downloaded_fallback:
+                return {"path": downloaded_fallback, "asset_type": "image"}
+            else:
+                print(f"Fallback image download failed for term: {term}")
+        else:
+            print(f"Fallback image search failed for term: {term}")
+
+    print(f"Failed to generate visual asset for prompt: {prompt}")
+    return None
+
+def generate_silent_audio(duration, sample_rate=24000):
+    """
+    Generate a silent WAV audio file lasting 'duration' seconds.
+    """
+    num_samples = int(duration * sample_rate)
+    silence = np.zeros(num_samples, dtype=np.float32)
+    silent_path = os.path.join(TEMP_FOLDER, f"silent_{int(time.time())}.wav")
+    sf.write(silent_path, silence, sample_rate)
+    print(f"Silent audio generated: {silent_path}")
+    return silent_path
+
+def generate_tts(text, voice):
+    """
+    Generate TTS audio using Kokoro, and if that fails, try gTTS.
+    If both fail, generate silent audio as a fallback.
+    """
+    safe_text = re.sub(r'[^\w\s-]', '', text[:10]).strip().replace(' ', '_')
+    file_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.wav")
+
+    if os.path.exists(file_path):
+        print(f"Using cached TTS for text '{text[:10]}...'")
+        return file_path
+
+    # Try Kokoro first
+    if pipeline:
+        try:
+            kokoro_voice = 'af_heart' if voice == 'en' else voice
+            generator = pipeline(text, voice=kokoro_voice, speed=0.9, split_pattern=r'\n+')
+            audio_segments = []
+            for i, (gs, ps, audio) in enumerate(generator):
+                audio_segments.append(audio)
+            full_audio = np.concatenate(audio_segments) if len(audio_segments) > 1 else audio_segments[0]
+            sf.write(file_path, full_audio, 24000)
+            print(f"TTS audio saved to {file_path} (Kokoro)")
+            return file_path
+        except Exception as e:
+            print(f"Error with Kokoro TTS: {e}")
 
-    logging.info(f"Adding background music from {music_file}")
-    bgm_clip = None
-    original_audio = video_clip.audio # Get existing audio first
+    # Fallback to gTTS
+    try:
+        print("Falling back to gTTS...")
+        tts = gTTS(text=text, lang='en')
+        mp3_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.mp3")
+        tts.save(mp3_path)
+        audio = AudioSegment.from_mp3(mp3_path)
+        audio.export(file_path, format="wav")
+        if os.path.exists(mp3_path):
+            os.remove(mp3_path)
+        print(f"Fallback TTS saved to {file_path} (gTTS)")
+        return file_path
+    except Exception as fallback_error:
+        print(f"Both TTS methods failed: {fallback_error}")
+        # Generate silent audio as fallback
+        return generate_silent_audio(duration=max(3, len(text.split()) * 0.5))
+
+def apply_kenburns_effect(clip, target_resolution, effect_type=None):
+    """
+    Apply a smooth Ken Burns effect with a single, clean movement pattern.
+    """
+    target_w, target_h = target_resolution
+    clip_aspect = clip.w / clip.h
+    target_aspect = target_w / target_h
+
+    if clip_aspect > target_aspect:
+        new_height = target_h
+        new_width = int(new_height * clip_aspect)
+    else:
+        new_width = target_w
+        new_height = int(new_width / clip_aspect)
+
+    clip = clip.resize(newsize=(new_width, new_height))
+
+    base_scale = 1.15
+    new_width = int(new_width * base_scale)
+    new_height = int(new_height * base_scale)
+    clip = clip.resize(newsize=(new_width, new_height))
+
+    max_offset_x = new_width - target_w
+    max_offset_y = new_height - target_h
+
+    available_effects = ["zoom-in", "zoom-out", "pan-left", "pan-right", "up-left"]
+    if effect_type is None or effect_type == "random":
+        effect_type = random.choice(available_effects)
+
+    if effect_type == "zoom-in":
+        start_zoom = 0.9
+        end_zoom = 1.1
+        start_center = (new_width / 2, new_height / 2)
+        end_center = start_center
+    elif effect_type == "zoom-out":
+        start_zoom = 1.1
+        end_zoom = 0.9
+        start_center = (new_width / 2, new_height / 2)
+        end_center = start_center
+    elif effect_type == "pan-left":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (max_offset_x + target_w / 2, (max_offset_y // 2) + target_h / 2)
+        end_center = (target_w / 2, (max_offset_y // 2) + target_h / 2)
+    elif effect_type == "pan-right":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (target_w / 2, (max_offset_y // 2) + target_h / 2)
+        end_center = (max_offset_x + target_w / 2, (max_offset_y // 2) + target_h / 2)
+    elif effect_type == "up-left":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (max_offset_x + target_w / 2, max_offset_y + target_h / 2)
+        end_center = (target_w / 2, target_h / 2)
+    else:
+        raise ValueError(f"Unsupported effect_type: {effect_type}")
+
+    def transform_frame(get_frame, t):
+        frame = get_frame(t)
+        ratio = t / clip.duration if clip.duration > 0 else 0
+        ratio = 0.5 - 0.5 * math.cos(math.pi * ratio)
+
+        current_zoom = start_zoom + (end_zoom - start_zoom) * ratio
+        crop_w = int(target_w / current_zoom)
+        crop_h = int(target_h / current_zoom)
+
+        current_center_x = start_center[0] + (end_center[0] - start_center[0]) * ratio
+        current_center_y = start_center[1] + (end_center[1] - start_center[1]) * ratio
+
+        min_center_x = crop_w / 2
+        max_center_x = new_width - crop_w / 2
+        min_center_y = crop_h / 2
+        max_center_y = new_height - crop_h / 2
+        current_center_x = max(min_center_x, min(current_center_x, max_center_x))
+        current_center_y = max(min_center_y, min(current_center_y, max_center_y))
+
+        # Ensure frame is numpy array and correct type for cv2
+        if isinstance(frame, Image.Image):
+            frame = np.array(frame)
+        if frame.dtype != np.uint8:
+             frame = frame.astype(np.uint8)
+
+        # Ensure frame has 3 channels for color images
+        if len(frame.shape) == 2: # Grayscale
+            frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)
+        elif frame.shape[2] == 4: # RGBA
+            frame = cv2.cvtColor(frame, cv2.COLOR_RGBA2BGR)
+
+        # Ensure crop dimensions are valid
+        crop_w = max(1, crop_w)
+        crop_h = max(1, crop_h)
+
+        # Ensure center point is valid for cv2.getRectSubPix
+        current_center_x = max(0, min(current_center_x, frame.shape[1] - 1))
+        current_center_y = max(0, min(current_center_y, frame.shape[0] - 1))
+
+        cropped_frame = cv2.getRectSubPix(frame, (crop_w, crop_h), (current_center_x, current_center_y))
+        resized_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
+
+        return resized_frame
+
+    return clip.fl(transform_frame)
+
+def resize_to_fill(clip, target_resolution):
+    """
+    Resize and crop a clip to fill the target resolution while maintaining aspect ratio.
+    """
+    target_w, target_h = target_resolution
+    clip_aspect = clip.w / clip.h
+    target_aspect = target_w / target_h
 
+    if clip_aspect > target_aspect:
+        clip = clip.resize(height=target_h)
+        crop_amount = (clip.w - target_w) / 2
+        clip = clip.crop(x1=crop_amount, x2=clip.w - crop_amount, y1=0, y2=clip.h)
+    else:
+        clip = clip.resize(width=target_w)
+        crop_amount = (clip.h - target_h) / 2
+        clip = clip.crop(x1=0, x2=clip.w, y1=crop_amount, y2=clip.h - crop_amount)
+
+    return clip
+
+def find_mp3_files():
+    """
+    Search for a background music file (e.g., background_music.mp3) in the current directory.
+    Returns the path to the first MP3 file found or None if none is found.
+    """
+    # Look for a specific file name first
+    bg_music_path = "background_music.mp3"
+    if os.path.exists(bg_music_path):
+        print(f"Found background music file: {bg_music_path}")
+        return bg_music_path
+
+    # If not found, search for any mp3 in the current directory
+    for file in os.listdir('.'):
+        if file.endswith('.mp3'):
+            print(f"Found background music file: {file}")
+            return file
+
+    print("No background music file found in the current directory.")
+    return None
+
+def add_background_music(final_video, bg_music_volume=0.08):
+    """Add background music to the final video using any MP3 file found in directories."""
     try:
-        bgm_clip = AudioFileClip(music_file)
-        video_duration = video_clip.duration
+        bg_music_path = find_mp3_files()
+        if bg_music_path and os.path.exists(bg_music_path):
+            print(f"Adding background music from: {bg_music_path}")
+            bg_music = AudioFileClip(bg_music_path)
+            if bg_music.duration < final_video.duration:
+                loops_needed = math.ceil(final_video.duration / bg_music.duration)
+                bg_segments = [bg_music] * loops_needed
+                bg_music = concatenate_audioclips(bg_segments)
+            bg_music = bg_music.subclip(0, final_video.duration)
+            bg_music = bg_music.volumex(bg_music_volume)
+
+            video_audio = final_video.audio
+            if video_audio:
+                mixed_audio = CompositeAudioClip([video_audio, bg_music])
+            else:
+                mixed_audio = bg_music
 
-        # Loop or trim BGM
-        if bgm_clip.duration < video_duration:
-            logging.info(f"Looping BGM (duration {bgm_clip.duration:.2f}s) for video ({video_duration:.2f}s)")
-            bgm_clip = bgm_clip.fx(afx.audio_loop, duration=video_duration)
+            final_video = final_video.set_audio(mixed_audio)
+            print("Background music added successfully")
         else:
-            bgm_clip = bgm_clip.subclip(0, video_duration)
-
-        # Adjust volume
-        bgm_clip = bgm_clip.volumex(volume)
-
-        # Combine with existing audio
-        if original_audio:
-             logging.info("Combining narration audio with BGM.")
-             # Ensure original audio has same duration as video clip for composite
-             if abs(original_audio.duration - video_duration) > 0.1:
-                 logging.warning("Original audio duration doesn't match video, trimming/padding original audio.")
-                 # This shouldn't happen if clips were created correctly, but as a safeguard:
-                 original_audio = original_audio.subclip(0, video_duration) # Trim if longer
-                 # Padding if shorter is harder, CompositeAudioClip might handle it
-
-             combined_audio = CompositeAudioClip([original_audio, bgm_clip])
-        else:
-             logging.warning("Video clip has no primary audio. Adding BGM only.")
-             combined_audio = bgm_clip
+            print("No suitable background music file found, skipping background music")
+
+        return final_video
+
+    except Exception as e:
+        print(f"Error adding background music: {e}")
+        print("Continuing without background music")
+        return final_video
+
+def create_clip(media_path, asset_type, tts_path, duration, effects, narration_text, segment_index, target_resolution, caption_color):
+    """Create a video clip with synchronized subtitles and properly timed narration."""
+    try:
+        print(f"Creating clip #{segment_index} with asset_type: {asset_type}, media_path: {media_path}")
+
+        if not os.path.exists(media_path) or not os.path.exists(tts_path):
+            print("Missing media or TTS file")
+            return None
 
-        video_clip_with_bgm = video_clip.set_audio(combined_audio)
-        logging.info("✅ Background music added.")
+        audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2)
+        audio_duration = audio_clip.duration
+        target_duration = audio_duration + 0.2
 
-        # Close intermediate clips AFTER successful composition
-        # bgm_clip.close() # CompositeAudioClip might still need it? Test this.
-        # if original_audio: original_audio.close() # Same potential issue
+        if asset_type == "video":
+            clip = VideoFileClip(media_path)
+            clip = resize_to_fill(clip, target_resolution)
+            if clip.duration < target_duration:
+                clip = clip.loop(duration=target_duration)
+            else:
+                clip = clip.subclip(0, target_duration)
+        elif asset_type == "image":
+            img = Image.open(media_path)
+            if img.mode != 'RGB':
+                with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as temp:
+                    img.convert('RGB').save(temp.name)
+                    media_path = temp.name
+                img.close()
+
+            clip = ImageClip(media_path).set_duration(target_duration)
+            clip = apply_kenburns_effect(clip, target_resolution)
+            clip = clip.fadein(0.3).fadeout(0.3)
+        else:
+            return None
 
-        return video_clip_with_bgm
+        # Add subtitles
+        if narration_text and caption_color != "transparent":
+            try:
+                words = narration_text.split()
+                chunks = []
+                current_chunk = []
+                for word in words:
+                    current_chunk.append(word)
+                    if len(current_chunk) >= 5:
+                        chunks.append(' '.join(current_chunk))
+                        current_chunk = []
+                if current_chunk:
+                    chunks.append(' '.join(current_chunk))
+
+                chunk_duration = audio_duration / len(chunks) if len(chunks) > 0 else audio_duration
+                subtitle_clips = []
+
+                subtitle_y_position = int(target_resolution[1] * 0.70)
+
+                for i, chunk_text in enumerate(chunks):
+                    start_time = i * chunk_duration
+                    end_time = (i + 1) * chunk_duration
+
+                    txt_clip = TextClip(
+                        chunk_text,
+                        fontsize=45,
+                        font='Arial-Bold',
+                        color=caption_color,
+                        bg_color='rgba(0, 0, 0, 0.25)',
+                        method='caption',
+                        align='center',
+                        stroke_width=2,
+                        stroke_color=caption_color,
+                        size=(target_resolution[0] * 0.8, None)
+                    ).set_start(start_time).set_end(end_time)
+
+                    txt_clip = txt_clip.set_position(('center', subtitle_y_position))
+                    subtitle_clips.append(txt_clip)
+
+                clip = CompositeVideoClip([clip] + subtitle_clips)
+
+            except Exception as sub_error:
+                print(f"Subtitle error: {sub_error}")
+                # Fallback to simpler subtitle if needed
+                txt_clip = TextClip(
+                    narration_text,
+                    fontsize=28,
+                    color=caption_color,
+                    align='center',
+                    size=(target_resolution[0] * 0.7, None)
+                ).set_position(('center', int(target_resolution[1] / 3))).set_duration(clip.duration)
+                clip = CompositeVideoClip([clip, txt_clip])
+
+        clip = clip.set_audio(audio_clip)
+        print(f"Clip created: {clip.duration:.1f}s")
+        return clip
 
     except Exception as e:
-        logging.error(f"❌ Failed to add background music: {e}")
-        traceback.print_exc()
-        # Clean up BGM clip if it was loaded
-        if bgm_clip and hasattr(bgm_clip, 'close'): bgm_clip.close()
-        # Return original clip without BGM on failure
-        return video_clip
-
-
-# --- Main Gradio Function ---
-def generate_video_process(topic, resolution_choice, add_captions_option, add_bgm_option, progress=gr.Progress(track_tqdm=True)):
-    """The main function called by Gradio to generate the video."""
-    start_time = time.time()
-    status_log = ["--- Starting Video Generation ---"]
-    temp_dir = None
-    final_video_path = None
-    clips = [] # Keep track of created clips for cleanup
-
-    # --- Setup ---
+        print(f"Error in create_clip: {str(e)}")
+        return None
+
+# --- Main Video Generation Function ---
+def generate_video(user_input, resolution_choice, caption_option, caption_color_input, progress=gr.Progress()):
+    """
+    Main function to orchestrate video generation based on Gradio inputs.
+    """
+    progress(0, desc="Starting video generation...")
+
+    # Set target resolution
+    if resolution_choice == "Full":
+        target_resolution = (1920, 1080)
+    elif resolution_choice == "Short":
+        target_resolution = (1080, 1920)
+    else:
+        return "Invalid resolution choice.", None
+
+    # Set caption color
+    caption_color = caption_color_input if caption_option == "Yes" else "transparent"
+
+    # Create temporary folder
+    if os.path.exists(TEMP_FOLDER):
+        shutil.rmtree(TEMP_FOLDER)
+    os.makedirs(TEMP_FOLDER)
+
     try:
-        temp_dir = tempfile.mkdtemp(prefix=TEMP_FOLDER_BASE + "_")
-        status_log.append(f"✅ Temporary directory created: {temp_dir}")
-        logging.info(f"Using temp directory: {temp_dir}")
-
-        target_size = (1920, 1080) if resolution_choice == "Full HD (16:9)" else (1080, 1920) # W, H
-        pexels_orientation = "landscape" if resolution_choice == "Full HD (16:9)" else "portrait"
-        status_log.append(f"⚙️ Target resolution: {target_size[0]}x{target_size[1]}")
-        status_log.append(f"⚙️ Pexels orientation: {pexels_orientation}")
-        status_log.append(f"⚙️ Add Captions: {add_captions_option}")
-        status_log.append(f"⚙️ Add BGM: {add_bgm_option}")
-
-        # --- 1. Generate Script ---
         progress(0.1, desc="Generating script...")
-        status_log.append("\n🔄 Generating script...")
-        script = generate_script(topic, OPENROUTER_API_KEY, OPENROUTER_MODEL)
+        script = generate_script(user_input)
         if not script:
-            status_log.append("❌ Script generation failed. Check API key, model, and connection.")
-            # No cleanup needed yet, just return
-            return "\n".join(status_log), None
-        status_log.append("✅ Script generated.")
-        # logging.debug(f"Raw Script:\n{script}") # Log full script for debugging
+            return "Failed to generate script.", None
+        print("Generated Script:\n", script)
 
-        # --- 2. Parse Script ---
         progress(0.2, desc="Parsing script...")
-        status_log.append("\n🔄 Parsing script...")
         elements = parse_script(script)
-        if not elements or len(elements) < 2:
-            status_log.append("❌ Script parsing failed. Check script format from LLM.")
-            return "\n".join(status_log), None
-        num_segments = len(elements) // 2
-        status_log.append(f"✅ Script parsed into {num_segments} segments.")
-
-        # --- 3. Process Segments ---
-        total_duration = 0
+        if not elements:
+            return "Failed to parse script into elements.", None
+        print(f"Parsed {len(elements)//2} script segments.")
+
+        paired_elements = []
         for i in range(0, len(elements), 2):
-            segment_index = i // 2
-            progress_val = 0.2 + (0.6 * (segment_index / num_segments))
-            progress(progress_val, desc=f"Processing segment {segment_index + 1}/{num_segments}")
+            if i + 1 < len(elements):
+                paired_elements.append((elements[i], elements[i+1]))
 
-            # Check if elements exist before accessing
-            if i + 1 >= len(elements):
-                 logging.warning(f"⚠️ Found scene element at index {i} but no corresponding narration. Skipping.")
-                 continue
+        if not paired_elements:
+            return "No valid script segments found.", None
 
-            scene_elem = elements[i]
-            narration_elem = elements[i+1]
+        clips = []
+        total_segments = len(paired_elements)
+        for idx, (media_elem, tts_elem) in enumerate(paired_elements):
+            progress(0.3 + (idx * 0.5 / total_segments), desc=f"Processing segment {idx+1}/{total_segments}...")
+            print(f"\nProcessing segment {idx+1}/{total_segments} with prompt: '{media_elem['prompt']}'")
 
-            # Validate element types (optional but good practice)
-            if scene_elem.get("type") != "scene" or narration_elem.get("type") != "narration":
-                logging.warning(f"⚠️ Unexpected element types at index {i}/{i+1}. Skipping segment.")
+            media_asset = generate_media(media_elem['prompt'], current_index=idx, total_segments=total_segments)
+            if not media_asset:
+                print(f"Skipping segment {idx+1} due to missing media asset.")
                 continue
 
-            scene_prompt = scene_elem.get('prompt', '').strip()
-            narration_text = narration_elem.get('text', '').strip()
-
-            if not scene_prompt or not narration_text:
-                 logging.warning(f"⚠️ Segment {segment_index + 1} has empty scene prompt or narration. Skipping.")
-                 status_log.append(f"\n--- Segment {segment_index + 1}/{num_segments}: SKIPPED (Empty prompt/narration) ---")
-                 continue
-
-            status_log.append(f"\n--- Segment {segment_index + 1}/{num_segments} ---")
-            status_log.append(f"📝 Scene: {scene_prompt}")
-            status_log.append(f"🗣️ Narration: {narration_text[:100]}...")
-
-            # 3a. Generate TTS
-            status_log.append("🔄 Generating narration...")
-            tts_path, tts_duration = generate_tts(narration_text, 'en', temp_dir, segment_index)
-            if not tts_path or tts_duration <= 0.1:
-                status_log.append(f"⚠️ TTS failed. Skipping segment.")
-                logging.warning(f"Skipping segment {segment_index+1} due to TTS failure.")
+            tts_path = generate_tts(tts_elem['text'], tts_elem['voice'])
+            if not tts_path:
+                print(f"Skipping segment {idx+1} due to TTS generation failure.")
                 continue
-            status_log.append(f"✅ Narration generated ({tts_duration:.2f}s)")
-            total_duration += tts_duration
-
-            # 3b. Search & Download Media
-            status_log.append("🔄 Finding media...")
-            media_path = None
-            media_type = None
-
-            # Try Pexels Video first with correct orientation
-            video_results = search_pexels(scene_prompt, PEXELS_API_KEY, media_type="videos", orientation=pexels_orientation)
-            if video_results:
-                selected_media = random.choice(video_results)
-                status_log.append(f"⬇️ Downloading Pexels video...")
-                media_path = download_media(selected_media['url'], temp_dir)
-                if media_path:
-                    media_type = 'video'
-                    status_log.append(f"✅ Video downloaded.")
-                else:
-                    status_log.append("⚠️ Video download failed.")
-
-            # Try Pexels Image if video fails/not found (correct orientation)
-            if not media_path:
-                status_log.append("🔄 No suitable video. Searching images...")
-                image_results = search_pexels(scene_prompt, PEXELS_API_KEY, media_type="photos", orientation=pexels_orientation)
-                if image_results:
-                    selected_media = random.choice(image_results)
-                    status_log.append(f"⬇️ Downloading Pexels image...")
-                    media_path = download_media(selected_media['url'], temp_dir)
-                    if media_path:
-                        media_type = 'image'
-                        status_log.append(f"✅ Image downloaded.")
-                    else:
-                         status_log.append("⚠️ Image download failed.")
 
-            # Fallback: Black screen
-            if not media_path:
-                status_log.append(f"⚠️ No media found for '{scene_prompt}'. Using black screen.")
-                media_type = 'color'
-                media_path = None # No path needed
-
-            # 3c. Create Clip
-            status_log.append(f"🎬 Creating clip...")
             clip = create_clip(
-                media_path=media_path,
-                media_type=media_type,
-                audio_path=tts_path,
-                audio_duration=tts_duration,
-                target_size=target_size,
-                add_captions=add_captions_option,
-                narration_text=narration_text,
-                segment_index=segment_index
+                media_path=media_asset['path'],
+                asset_type=media_asset['asset_type'],
+                tts_path=tts_path,
+                duration=tts_elem['duration'],
+                effects=media_elem.get('effects', 'fade-in'),
+                narration_text=tts_elem['text'],
+                segment_index=idx,
+                target_resolution=target_resolution,
+                caption_color=caption_color
             )
-
             if clip:
                 clips.append(clip)
-                status_log.append(f"✅ Clip created.")
             else:
-                status_log.append(f"❌ Failed to create clip. Skipping segment.")
-                logging.error(f"Failed to create clip {segment_index+1}, skipping.")
-
+                print(f"Clip creation failed for segment {idx+1}.")
 
         if not clips:
-            status_log.append("\n❌ No valid clips were created. Cannot generate video.")
-            # No cleanup needed beyond temp dir removal in finally block
-            return "\n".join(status_log), None
+            return "No clips were successfully created.", None
 
-        status_log.append(f"\n✅ Successfully created {len(clips)} video clips.")
-        status_log.append(f"⏱️ Estimated total video duration: {total_duration:.2f} seconds.")
+        progress(0.8, desc="Concatenating clips...")
+        final_video = concatenate_videoclips(clips, method="compose")
 
-        # --- 4. Concatenate Clips ---
-        progress(0.85, desc="Combining video clips...")
-        status_log.append("\n🔄 Combining video clips...")
-        final_clip = None # Define final_clip before try block
-        try:
-            # Use method="compose" - might be better for clips with varying sources/codecs
-            final_clip = concatenate_videoclips(clips, method="compose", padding = -0.1) # Small overlap?
-            status_log.append("✅ Clips combined successfully.")
-        except Exception as e:
-            status_log.append(f"❌ Error concatenating clips: {e}")
-            logging.error(f"Concatenation failed: {e}")
-            traceback.print_exc()
-            # Ensure final_clip is None if concatenation fails
-            final_clip = None
-            # Fall through to finally block for cleanup
-
-        # --- 5. Add Background Music (Optional) ---
-        if final_clip and add_bgm_option:
-            progress(0.9, desc="Adding background music...")
-            status_log.append("\n🔄 Adding background music...")
-            final_clip = add_background_music(final_clip, music_file=BGM_FILE, volume=BGM_VOLUME)
-            # Status logged within the function
-
-        # --- 6. Write Final Video ---
-        if final_clip:
-            progress(0.95, desc="Writing final video file...")
-            status_log.append("\n💾 Writing final video file (this may take time)...")
-            output_path = os.path.join(temp_dir, OUTPUT_VIDEO_FILENAME)
-            writer_logger = logging.getLogger("moviepy_writer")
-            writer_logger.setLevel(logging.WARNING) # Reduce moviepy verbosity during write
+        progress(0.9, desc="Adding background music...")
+        final_video = add_background_music(final_video, bg_music_volume=0.08)
 
-            try:
-                final_clip.write_videofile(
-                    output_path,
-                    codec='libx264',
-                    audio_codec='aac',
-                    temp_audiofile=os.path.join(temp_dir, 'temp_audio.aac'), # Explicit temp audio file
-                    remove_temp=True,
-                    preset='medium', # 'medium' is good balance, 'fast' or 'ultrafast' for speed
-                    fps=24,
-                    threads=max(1, os.cpu_count() // 2), # Use half available cores
-                    logger=None # Use None or 'bar', avoid default verbose logger
-                )
-                status_log.append(f"✅ Final video saved: {os.path.basename(output_path)}")
-                final_video_path = output_path # Set the path to be returned
-            except Exception as e:
-                status_log.append(f"❌ Error writing final video file: {e}")
-                logging.error(f"Final video write failed: {e}")
-                traceback.print_exc()
-                final_video_path = None # Ensure no path is returned on failure
-        else:
-             status_log.append("\n❌ Skipping final video write because clip combination failed.")
-             final_video_path = None
+        progress(0.95, desc="Exporting final video...")
+        output_path = os.path.join(TEMP_FOLDER, OUTPUT_VIDEO_FILENAME)
+        final_video.write_videofile(output_path, codec='libx264', fps=24, preset='veryfast')
 
+        progress(1.0, desc="Video generation complete.")
+        return "Video generated successfully!", output_path
 
     except Exception as e:
-        status_log.append(f"\n❌ An critical error occurred during video generation: {e}")
-        logging.error("An critical error occurred in generate_video_process:")
-        logging.error(traceback.format_exc())
-        final_video_path = None # Ensure failure state
+        print(f"An error occurred: {e}")
+        return f"An error occurred: {e}", None
 
     finally:
-        # --- 7. Cleanup ---
-        status_log.append("\n🧹 Cleaning up resources...")
-        # Close all individual clips first
-        for i, clip in enumerate(clips):
-            try:
-                if clip: clip.close()
-                logging.debug(f"Closed clip {i+1}")
-            except Exception as e_close:
-                logging.warning(f"Error closing clip {i+1}: {e_close}")
-        # Close the final concatenated clip if it exists
-        try:
-            if final_clip: final_clip.close()
-            logging.debug("Closed final clip")
-        except Exception as e_final_close:
-            logging.warning(f"Error closing final clip: {e_final_close}")
-
-        # Remove the temporary directory
-        if temp_dir and os.path.exists(temp_dir):
-            try:
-                # Add retries for shutil.rmtree on potential lingering file handles
-                attempts = 3
-                for attempt in range(attempts):
-                    try:
-                        shutil.rmtree(temp_dir)
-                        status_log.append(f"✅ Temporary directory removed: {os.path.basename(temp_dir)}")
-                        logging.info(f"Cleaned up temp directory: {temp_dir}")
-                        break # Success
-                    except OSError as e_rm:
-                        if attempt < attempts - 1:
-                            logging.warning(f"Attempt {attempt+1} failed to remove temp dir {temp_dir}: {e_rm}. Retrying in 1s...")
-                            time.sleep(1)
-                        else:
-                            raise # Raise the error on the last attempt
-            except Exception as e_clean:
-                status_log.append(f"⚠️ Error cleaning up temporary directory {temp_dir}: {e_clean}")
-                logging.error(f"Cleanup failed for {temp_dir}: {e_clean}")
-        else:
-            status_log.append("ℹ️ No temporary directory to remove or already removed.")
-
+        # Clean up temporary files
+        if os.path.exists(TEMP_FOLDER):
+            shutil.rmtree(TEMP_FOLDER)
+        print("Temporary files removed.")
 
-    end_time = time.time()
-    total_time = end_time - start_time
-    status_log.append(f"\n--- Generation Finished ---")
-    status_log.append(f"⏱️ Total time: {total_time:.2f} seconds")
-
-    progress(1.0, desc="Finished!")
-    return "\n".join(status_log), final_video_path
-
-
-# --- Gradio Interface Definition ---
-with gr.Blocks(css="footer {display: none !important}") as iface: # Hide Gradio footer
-    gr.Markdown("# 🤖 AI Documentary Generator v2")
-    gr.Markdown("Enter a topic, choose settings, and let AI create a short video. Uses OpenRouter for script, Pexels for media, gTTS for narration, and MoviePy for assembly.")
+# --- Gradio Interface ---
+with gr.Blocks() as demo:
+    gr.Markdown("# AI Documentary Video Generator")
+    gr.Markdown("Enter a concept, choose settings, and generate a short documentary video.")
 
     with gr.Row():
-        with gr.Column(scale=1):
-            topic_input = gr.Textbox(
-                label="Video Topic",
-                placeholder="e.g., The History of Coffee, Secrets of the Deep Ocean",
-                lines=2
-            )
-            resolution_input = gr.Radio(
-                label="Video Format",
-                choices=["Short (9:16)", "Full HD (16:9)"],
-                value="Short (9:16)"
-            )
-            captions_input = gr.Checkbox(label="Add Captions (with background)", value=True)
-
-            # Check for BGM file and enable checkbox accordingly
-            bgm_exists = os.path.exists(BGM_FILE) and os.path.getsize(BGM_FILE) > 1024
-            bgm_label = f"Add Background Music ({os.path.basename(BGM_FILE)})" if bgm_exists else f"Add Background Music (File '{BGM_FILE}' not found or empty)"
-            bgm_input = gr.Checkbox(label=bgm_label, value=bgm_exists, interactive=bgm_exists)
+        user_input = gr.Textbox(label="Video Concept", placeholder="e.g., The secret life of squirrels")
+        resolution_choice = gr.Radio(["Full", "Short"], label="Target Resolution", value="Short")
 
+    with gr.Row():
+        caption_option = gr.Radio(["Yes", "No"], label="Add Captions?", value="Yes")
+        caption_color_input = gr.Textbox(label="Caption Color (e.g., white, yellow)", value="white", visible=True)
+
+    # Update caption color visibility based on caption option
+    caption_option.change(
+        lambda x: gr.update(visible=x == "Yes"),
+        inputs=caption_option,
+        outputs=caption_color_input
+    )
 
-            generate_button = gr.Button("✨ Generate Video ✨", variant="primary")
-
-        with gr.Column(scale=2):
-            status_output = gr.Textbox(label="📜 Status Log", lines=20, interactive=False, autoscroll=True)
-            video_output = gr.Video(label="🎬 Generated Video")
+    generate_button = gr.Button("Generate Video")
+    status_output = gr.Textbox(label="Status", interactive=False)
+    video_output = gr.Video(label="Generated Video")
 
     generate_button.click(
-        fn=generate_video_process,
-        inputs=[topic_input, resolution_input, captions_input, bgm_input],
+        fn=generate_video,
+        inputs=[user_input, resolution_choice, caption_option, caption_color_input],
         outputs=[status_output, video_output]
     )
 
-    gr.Examples(
-        examples=[
-            ["The lifecycle of a monarch butterfly", "Short (9:16)", True, True],
-            ["The construction of the Eiffel Tower", "Full HD (16:9)", True, False],
-            ["The impact of renewable energy sources", "Short (9:16)", True, True],
-            ["A brief history of the internet", "Full HD (16:9)", True, True],
-        ],
-        inputs=[topic_input, resolution_input, captions_input, bgm_input],
-        label="Example Topics"
-    )
-
-# --- Launch the App ---
 if __name__ == "__main__":
-    # Create a silent placeholder BGM file if needed and BGM checkbox requires it
-    if not os.path.exists(BGM_FILE) or os.path.getsize(BGM_FILE) < 1024:
-         logging.warning(f"Background music file '{BGM_FILE}' not found or empty. Creating a silent placeholder.")
-         try:
-             silent_segment = AudioSegment.silent(duration=1000) # 1 second silence
-             silent_segment.export(BGM_FILE, format="mp3")
-             logging.info(f"Created silent placeholder BGM file: {BGM_FILE}")
-         except Exception as e:
-             logging.error(f"Could not create placeholder BGM file: {e}")
-
-
-    # Check for API keys (already hardcoded, but good practice)
-    if not PEXELS_API_KEY or len(PEXELS_API_KEY) < 50: # Basic length check
-        logging.warning("PEXELS_API_KEY seems invalid or missing.")
-    if not OPENROUTER_API_KEY or not OPENROUTER_API_KEY.startswith("sk-or-v1-"):
-        logging.warning("OPENROUTER_API_KEY seems invalid or missing.")
-
-    # Launch Gradio app
-    iface.queue().launch(debug=False, share=False) # Use queue for handling multiple requests, disable debug/share for production
+    # Ensure TEMP_FOLDER exists before starting
+    if not os.path.exists(TEMP_FOLDER):
+        os.makedirs(TEMP_FOLDER)
+    demo.launch()