Update app.py

app.py

@@ -1,173 +1,118 @@
-
-
 # Import necessary libraries
-from kokoro import KPipeline
+from kokoro import KPipeline # Assuming kokoro is installed and working
 
 import soundfile as sf
 import torch
-
-import soundfile as sf
 import os
-from moviepy.editor import VideoFileClip, AudioFileClip, ImageClip
-from PIL import Image
 import tempfile
 import random
-import cv2
 import math
-import os, requests, io, time, re, random
-from moviepy.editor import (
-    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
-    CompositeVideoClip, TextClip, CompositeAudioClip
-)
-import gradio as gr
+import time
+import re
+import requests
+import io
 import shutil
-import os
-import moviepy.video.fx.all as vfx
-import moviepy.config as mpy_config
-from pydub import AudioSegment
-from pydub.generators import Sine
-
-from PIL import Image, ImageDraw, ImageFont
+from urllib.parse import quote
 import numpy as np
 from bs4 import BeautifulSoup
 import base64
-from urllib.parse import quote
-import pysrt
 from gtts import gTTS
-import gradio as gr  # Import Gradio
+import gradio as gr
+from PIL import Image, ImageDraw, ImageFont
+import cv2 # OpenCV for image processing in Ken Burns
 
-# Initialize Kokoro TTS pipeline (using American English)
-pipeline = KPipeline(lang_code='a')  # Use voice 'af_heart' for American English
-# Ensure ImageMagick binary is set
-mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
+# MoviePy imports
+from moviepy.editor import (
+    VideoFileClip, AudioFileClip, ImageClip, CompositeVideoClip, TextClip,
+    concatenate_videoclips, CompositeAudioClip
+)
+import moviepy.video.fx.all as vfx
+# No longer importing moviepy.config or calling change_settings for ImageMagick
+
+# Pydub imports (for potential gTTS fallback format conversion)
+from pydub import AudioSegment
+from pydub.generators import Sine # Might not be needed if TTS works
 
 # ---------------- Global Configuration ---------------- #
+# --- API Keys (Replace with your actual keys) ---
 PEXELS_API_KEY = 'BhJqbcdm9Vi90KqzXKAhnEHGsuFNv4irXuOjWtT761U49lRzo03qBGna'
 OPENROUTER_API_KEY = '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'
 OPENROUTER_MODEL = "mistralai/mistral-small-3.1-24b-instruct:free"
 OUTPUT_VIDEO_FILENAME = "final_video.mp4"
+# --- Web Request Settings ---
 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"
 
-
-
-# Additional global variables needed for the Gradio interface
-selected_voice = 'af_heart'  # Default voice
-voice_speed = 0.9  # Default voice speed
-font_size = 45  # Default font size
-video_clip_probability = 0.25  # Default probability for video clips
-bg_music_volume = 0.08  # Default background music volume
-fps = 30  # Default FPS
-preset = "veryfast"  # Default preset
-TARGET_RESOLUTION = None
-CAPTION_COLOR = None
-TEMP_FOLDER = None
-
+# --- Gradio Controlled Variables (with defaults) ---
+selected_voice = 'af_heart'  # Default voice (Kokoro American Female)
+voice_speed = 0.9          # Default voice speed
+font_size = 45             # Default caption font size
+video_clip_probability = 0.25 # Default probability for using video clips (25%)
+bg_music_volume = 0.08     # Default background music volume
+fps = 30                   # Default video frames per second
+preset = "veryfast"        # Default video export preset (faster, lower quality)
+caption_style_bg_color = 'rgba(0, 0, 0, 0.6)' # Background for captions
+caption_style_text_color = 'yellow' # Text color for captions
+caption_font = 'Arial-Bold' # Font for captions (ensure it's available)
+
+# --- Runtime Variables (set per execution) ---
+TARGET_RESOLUTION = None   # Will be set based on Gradio input (e.g., (1920, 1080))
+TEMP_FOLDER = None         # Will be created temporarily for each run
+USE_CAPTIONS = True        # Will be set based on Gradio input
+
+# ---------------- Kokoro TTS Initialization ---------------- #
+try:
+    # Initialize Kokoro TTS pipeline (using American English default)
+    pipeline = KPipeline(lang_code='a')
+    print("Kokoro TTS Pipeline initialized.")
+except Exception as e:
+    print(f"Warning: Failed to initialize Kokoro TTS Pipeline: {e}")
+    print("TTS generation will rely on gTTS.")
+    pipeline = None
 
 # ---------------- Helper Functions ---------------- #
-# (Your existing helper functions remain unchanged: generate_script, parse_script,
-# search_pexels_videos, search_pexels_images, search_google_images, download_image,
-# download_video, generate_media, generate_tts, apply_kenburns_effect,
-# resize_to_fill, find_mp3_files, add_background_music, create_clip,
-# fix_imagemagick_policy)
-
-# Define these globally as they were in your original code but will be set per run
-TARGET_RESOLUTION = None
-CAPTION_COLOR = None
-TEMP_FOLDER = None
 
 def generate_script(user_input):
-    """Generate documentary script with proper OpenRouter handling."""
+    """Generate documentary script using OpenRouter API."""
     headers = {
         'Authorization': f'Bearer {OPENROUTER_API_KEY}',
-        'HTTP-Referer': 'https://your-domain.com',
-        'X-Title': 'AI Documentary Maker'
+        'Content-Type': 'application/json',
+        # Optional but recommended:
+        'HTTP-Referer': 'http://localhost:7860', # Or your app's URL
+        'X-Title': 'AI Documentary Maker Gradio'
     }
 
-    prompt = f"""Short Documentary Script GeneratorInstructions:
+    prompt = f"""Create a short, humorous, slightly negative, and conversational documentary-style script based on the following topic or instructions: '{user_input}'.
 
-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:
-
-
-Title in Square Brackets:
-
-
-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.
-
-
-
-Casual & Funny Narration:
-
-
-Each section has 5-10 words of narration.
-Keep it natural, funny, and unpredictable (not robotic, poetic, or rhythmic).
-
-
-
-No Special Formatting:
-
-
-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
-
-
-
-Generalized Search Terms:
-
-
-If a term is too specific, make it more general for Pexels search.
-
-
-
-Scene-Specific Writing:
-
-
-Each section describes only what should be shown in the video.
-
-
-
-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 .....
-
-
-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}
+1. Start each distinct visual scene/idea with a title in square brackets `[Like This]`. This title will be used for searching visuals. Keep titles concise (1-3 words).
+2. After the bracketed title, write 1-2 short sentences (5-15 words total) of narration for that scene.
+3. Keep the narration casual, funny, maybe a bit sarcastic or critical, and human-like. Avoid sounding like a robotic AI.
+4. Do NOT use any other formatting like bold, italics, or bullet points.
+5. Ensure search terms in brackets are general enough for stock footage searches (e.g., use "[Technology]" instead of "[Quantum Supercomputer]").
+6. End the *entire* script with a funny, topic-related call to subscribe, also enclosed in brackets like `[Subscribe CTA]`.
+7. Focus on one core topic for the entire script.
+8. Output *only* the formatted script, nothing else.
+
+Example:
+[Cats]
+So, you think cats are cute? Let's investigate.
+[Sleeping]
+They spend 90% of their lives asleep. Lazy, much?
+[Judgment]
+The other 10%? Judging your life choices. Harsh.
+[Boxes]
+Their obsession with boxes remains unexplained. Weirdos.
+[Subscribe CTA]
+Subscribe now, or a cat will knock your coffee over.
+
+Now generate the script based on: {user_input}
 """
 
     data = {
         'model': OPENROUTER_MODEL,
         'messages': [{'role': 'user', 'content': prompt}],
-        'temperature': 0.4,
-        'max_tokens': 5000
+        'temperature': 0.6, # Slightly more creative for humor
+        'max_tokens': 600  # Adjust as needed
     }
 
     try:
@@ -175,806 +120,961 @@ Now here is the Topic/scrip: {user_input}
             'https://openrouter.ai/api/v1/chat/completions',
             headers=headers,
             json=data,
-            timeout=30
+            timeout=45 # Increased timeout
         )
 
-        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
+        response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
+
+        response_data = response.json()
+        if 'choices' in response_data and len(response_data['choices']) > 0:
+            script_content = response_data['choices'][0]['message']['content']
+            # Basic cleaning: remove potential preamble/postamble if AI didn't follow instructions perfectly
+            script_content = re.sub(r"^.*?\n?\[", "[", script_content, flags=re.DOTALL) # Remove anything before the first bracket
+            script_content = script_content.strip()
+            print("Script generated successfully.")
+            return script_content
         else:
-            print(f"API Error {response.status_code}: {response.text}")
+            print(f"API Error: Unexpected response format: {response_data}")
             return None
 
+    except requests.exceptions.Timeout:
+        print("API Error: Request timed out.")
+        return None
+    except requests.exceptions.RequestException as e:
+        print(f"API Error: Request failed: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"API Response Status Code: {e.response.status_code}")
+            print(f"API Response Text: {e.response.text}")
+        return None
     except Exception as e:
-        print(f"Request failed: {str(e)}")
+        print(f"Error during script generation: {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.
+    Parse the generated script into a list of dictionaries,
+    each representing a segment with a visual prompt and narration.
     """
-    sections = {}
+    segments = []
     current_title = None
-    current_text = ""
+    current_narration = ""
 
-    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
-
-            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)
-
-        return elements
-    except Exception as e:
-        print(f"Error parsing script: {e}")
+    if not script_text:
+        print("Error: Script text is empty.")
         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
+    lines = script_text.strip().splitlines()
 
-    max_retries = 3
-    retry_delay = 1
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
 
-    search_query = query
-    all_videos = []
+        title_match = re.match(r'^\[(.*?)\](.*)', line)
+
+        if title_match:
+            # If we were processing a previous title, save it
+            if current_title is not None and current_narration.strip():
+                segments.append({
+                    "prompt": current_title,
+                    "narration": current_narration.strip()
+                })
+
+            # Start the new segment
+            current_title = title_match.group(1).strip()
+            current_narration = title_match.group(2).strip() + " " # Add space for potential multi-line narration
+        elif current_title is not None:
+            # Append to the current narration if it's not a new title line
+            current_narration += line + " "
+
+    # Add the last segment
+    if current_title is not None and current_narration.strip():
+        segments.append({
+            "prompt": current_title,
+            "narration": current_narration.strip()
+        })
+
+    if not segments:
+        print("Error: Could not parse any segments from the script.")
+        # Attempt a simpler parse if the strict format failed
+        simple_segments = []
+        for i, line in enumerate(lines):
+             if line.strip():
+                 simple_segments.append({"prompt": f"Scene {i+1}", "narration": line.strip()})
+        if simple_segments:
+             print("Warning: Using simplified script parsing.")
+             return simple_segments
+        else:
+             return []
 
-    for page in range(1, num_pages + 1):
-        for attempt in range(max_retries):
-            try:
-                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:
-                        print(f"No videos found on page {page}.")
-                        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:
-                    print(f"Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
-                    time.sleep(retry_delay)
-                    retry_delay *= 2
-                else:
-                    print(f"Error fetching videos: {response.status_code} {response.text}")
-                    if attempt < max_retries - 1:
-                        print(f"Retrying in {retry_delay} seconds...")
-                        time.sleep(retry_delay)
-                        retry_delay *= 2
-                    else:
-                        break
-
-            except requests.exceptions.RequestException as e:
-                print(f"Request exception: {e}")
-                if attempt < max_retries - 1:
-                    print(f"Retrying in {retry_delay} seconds...")
-                    time.sleep(retry_delay)
-                    retry_delay *= 2
-                else:
-                    break
 
-    if all_videos:
-        random_video = random.choice(all_videos)
-        print(f"Selected random video from {len(all_videos)} HD videos")
-        return random_video
-    else:
-        print("No suitable videos found after searching all pages.")
+    print(f"Parsed {len(segments)} segments from script.")
+    return segments
+
+def search_pexels(query, api_key, search_type="videos"):
+    """Search Pexels for videos or images."""
+    if not api_key:
+        print(f"Pexels API key not provided. Skipping Pexels {search_type} search.")
         return None
 
-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"}
+    base_url = f"https://api.pexels.com/{search_type}/search"
+    headers = {'Authorization': api_key}
+    params = {"query": query, "per_page": 15, "orientation": "landscape"}
+    if search_type == "videos":
+        params["size"] = "medium" # Request medium or large, HD might not always be available
 
     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:
-                    print(f"No images found for query: {query}")
-                    return None
+            response = requests.get(base_url, headers=headers, params=params, timeout=15)
+            response.raise_for_status() # Check for HTTP errors
 
-            elif response.status_code == 429:
-                print(f"Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
-                time.sleep(retry_delay)
-                retry_delay *= 2
+            data = response.json()
+            items = data.get(search_type, [])
+
+            if not items:
+                print(f"No Pexels {search_type} found for query: {query}")
+                return None
+
+            valid_items = []
+            if search_type == "videos":
+                for video in items:
+                    # Prefer HD or Large, fallback to Medium
+                    hd_link = next((f['link'] for f in video.get('video_files', []) if f.get('quality') == 'hd' and f.get('width', 0) >= 1080), None)
+                    large_link = next((f['link'] for f in video.get('video_files', []) if f.get('quality') == 'large' and f.get('width', 0) >= 1080), None)
+                    medium_link = next((f['link'] for f in video.get('video_files', []) if f.get('quality') == 'medium'), None)
+                    link = hd_link or large_link or medium_link
+                    if link:
+                        valid_items.append(link)
+            else: # images
+                for photo in items:
+                    link = photo.get("src", {}).get("large2x") or photo.get("src", {}).get("original")
+                    if link:
+                        valid_items.append(link)
+
+            if valid_items:
+                print(f"Found {len(valid_items)} Pexels {search_type} for '{query}'. Selecting one.")
+                return random.choice(valid_items)
             else:
-                print(f"Error fetching images: {response.status_code} {response.text}")
-                if attempt < max_retries - 1:
-                    print(f"Retrying in {retry_delay} seconds...")
-                    time.sleep(retry_delay)
-                    retry_delay *= 2
+                print(f"No suitable quality Pexels {search_type} found for query: {query}")
+                return None
 
+        except requests.exceptions.Timeout:
+            print(f"Pexels API timeout (attempt {attempt+1}/{max_retries})...")
+            time.sleep(retry_delay)
+            retry_delay *= 2
         except requests.exceptions.RequestException as e:
-            print(f"Request exception: {e}")
-            if attempt < max_retries - 1:
-                print(f"Retrying in {retry_delay} seconds...")
-                time.sleep(retry_delay)
-                retry_delay *= 2
+            print(f"Pexels API error (attempt {attempt+1}/{max_retries}): {e}")
+            if response is not None and response.status_code == 429: # Rate limit
+                 print("Rate limit hit, waiting longer...")
+                 time.sleep(retry_delay * 2)
+                 retry_delay *= 2
+            else:
+                 time.sleep(retry_delay)
+                 retry_delay *= 2
+        except Exception as e:
+            print(f"Unexpected error during Pexels search: {e}")
+            break # Don't retry on unexpected errors
 
-    print(f"No Pexels images found for query: {query} after all attempts")
+    print(f"Pexels {search_type} search failed for '{query}' after {max_retries} attempts.")
     return None
 
 def search_google_images(query):
-    """Search for images on Google Images (for news-related queries)"""
+    """Search for images on Google Images (use sparingly and ethically)."""
+    print(f"Attempting Google Image search for: {query} (Use with caution)")
     try:
-        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch"
+        # Using a simple search URL, might be fragile
+        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch&safe=active"
         headers = {"User-Agent": USER_AGENT}
         response = requests.get(search_url, headers=headers, timeout=10)
+        response.raise_for_status()
         soup = BeautifulSoup(response.text, "html.parser")
 
         img_tags = soup.find_all("img")
         image_urls = []
+
+        # Look for potential image URLs, prioritizing data-src or src containing http
         for img in img_tags:
-            src = img.get("src", "")
-            if src.startswith("http") and "gstatic" not in src:
-                image_urls.append(src)
+            src = img.get("data-src") or img.get("src")
+            if src and src.startswith("http") and not "gstatic" in src and not src.startswith("data:image"):
+                 # Basic check for likely image file extensions
+                 if any(ext in src.lower() for ext in ['.jpg', '.jpeg', '.png', '.webp']):
+                    image_urls.append(src)
 
         if image_urls:
-            return random.choice(image_urls[:5]) if len(image_urls) >= 5 else image_urls[0]
+            # Return a random one from the first few results
+            print(f"Found {len(image_urls)} potential Google Images for '{query}'.")
+            return random.choice(image_urls[:min(len(image_urls), 10)])
         else:
-            print(f"No Google Images found for query: {query}")
+            print(f"No suitable Google Images found for query: {query}")
             return None
+    except requests.exceptions.RequestException as e:
+        print(f"Error during Google Images search request: {e}")
+        return None
     except Exception as e:
-        print(f"Error in Google Images search: {e}")
+        print(f"Error parsing Google Images search results: {e}")
         return None
 
-def download_image(image_url, filename):
-    """Download an image from a URL to a local file with enhanced error handling."""
+def download_media(media_url, filename_prefix, target_folder):
+    """Download media (image or video) from a URL."""
     try:
         headers = {"User-Agent": USER_AGENT}
-        print(f"Downloading image from: {image_url} to {filename}")
-        response = requests.get(image_url, headers=headers, stream=True, timeout=15)
+        response = requests.get(media_url, headers=headers, stream=True, timeout=30)
         response.raise_for_status()
 
+        # Try to determine file extension from URL or Content-Type
+        content_type = response.headers.get('content-type')
+        file_extension = ".jpg" # Default
+        if 'video' in content_type:
+            file_extension = ".mp4"
+        elif 'image/jpeg' in content_type:
+            file_extension = ".jpg"
+        elif 'image/png' in content_type:
+            file_extension = ".png"
+        elif 'image/webp' in content_type:
+            file_extension = ".webp"
+        else: # Guess from URL
+            if '.mp4' in media_url: file_extension = ".mp4"
+            elif '.mov' in media_url: file_extension = ".mov" # May need conversion later
+            elif '.jpg' in media_url or '.jpeg' in media_url: file_extension = ".jpg"
+            elif '.png' in media_url: file_extension = ".png"
+            elif '.webp' in media_url: file_extension = ".webp"
+
+
+        filename = os.path.join(target_folder, f"{filename_prefix}{file_extension}")
+
         with open(filename, 'wb') as f:
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
 
-        print(f"Image downloaded successfully to: {filename}")
+        print(f"Media downloaded successfully to: {filename}")
 
-        try:
-            img = Image.open(filename)
-            img.verify()
-            img = Image.open(filename)
-            if img.mode != 'RGB':
-                img = img.convert('RGB')
-                img.save(filename)
-            print(f"Image validated and processed: {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
+        # Basic validation for images
+        if file_extension in [".jpg", ".png", ".webp"]:
+            try:
+                img = Image.open(filename)
+                img.verify() # Check if it's a valid image file
+                img.close()
+                 # Re-open and convert to RGB if necessary (MoviePy prefers RGB)
+                img = Image.open(filename)
+                if img.mode != 'RGB':
+                    print(f"Converting image {filename} to RGB.")
+                    rgb_img = img.convert('RGB')
+                    # Overwrite if JPG, save as JPG if PNG/WEBP for consistency
+                    jpg_filename = os.path.join(target_folder, f"{filename_prefix}.jpg")
+                    rgb_img.save(jpg_filename, "JPEG")
+                    rgb_img.close()
+                    img.close()
+                    if filename != jpg_filename: # Remove original if format changed
+                        os.remove(filename)
+                    return jpg_filename # Return path to the JPG
+                else:
+                    img.close()
+
+            except Exception as e_validate:
+                print(f"Downloaded file {filename} is not a valid image or conversion failed: {e_validate}")
+                if os.path.exists(filename): os.remove(filename)
+                return None
+
+        return filename # Return original path for videos or already RGB images
 
     except requests.exceptions.RequestException as e_download:
-        print(f"Image download error: {e_download}")
-        if os.path.exists(filename):
-            os.remove(filename)
+        print(f"Media download error from {media_url}: {e_download}")
         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 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)
-        print(f"Video downloaded successfully to: {filename}")
-        return filename
-    except Exception as e:
-        print(f"Video download error: {e}")
-        if os.path.exists(filename):
-            os.remove(filename)
+        print(f"General error during media download/processing: {e_general}")
         return None
 
-def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
+def generate_media(prompt):
     """
-    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'}.
+    Find and download a visual asset (video or image) based on the prompt.
+    Prioritizes Pexels Video, then Pexels Image, then Google Image as fallback.
     """
     safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
+    filename_prefix = f"{safe_prompt}_{int(time.time())}" # Add timestamp for uniqueness
 
-    if "news" in prompt.lower():
-        print(f"News-related query detected: {prompt}. Using Google Images...")
-        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:
-                print(f"News image saved to {downloaded_image}")
-                return {"path": downloaded_image, "asset_type": "image"}
-        else:
-            print(f"Google Images search failed for prompt: {prompt}")
-
+    # 1. Try Pexels Video (if probability met)
     if random.random() < video_clip_probability:
-        video_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_video.mp4")
-        video_url = search_pexels_videos(prompt, PEXELS_API_KEY)
+        print(f"Searching Pexels Video for: {prompt}")
+        video_url = search_pexels(prompt, PEXELS_API_KEY, search_type="videos")
         if video_url:
-            downloaded_video = download_video(video_url, video_file)
-            if downloaded_video:
-                print(f"Video asset saved to {downloaded_video}")
-                return {"path": downloaded_video, "asset_type": "video"}
+            downloaded_path = download_media(video_url, filename_prefix + "_vid", TEMP_FOLDER)
+            if downloaded_path:
+                return {"path": downloaded_path, "asset_type": "video"}
         else:
-            print(f"Pexels video search failed for prompt: {prompt}")
+            print("Pexels video search failed or no suitable video found.")
 
-    image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}.jpg")
-    image_url = search_pexels_images(prompt, PEXELS_API_KEY)
+    # 2. Try Pexels Image
+    print(f"Searching Pexels Image for: {prompt}")
+    image_url = search_pexels(prompt, PEXELS_API_KEY, search_type="photos")
     if image_url:
-        downloaded_image = download_image(image_url, image_file)
-        if downloaded_image:
-            print(f"Image asset saved to {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:
-        print(f"Trying fallback image search with term: {term}")
-        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:
-                print(f"Fallback image saved to {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}")
+        downloaded_path = download_media(image_url, filename_prefix + "_img", TEMP_FOLDER)
+        if downloaded_path:
+            return {"path": downloaded_path, "asset_type": "image"}
+    else:
+        print("Pexels image search failed.")
+
+    # 3. Fallback: Try Google Images (especially for specific/newsy terms)
+    print(f"Falling back to Google Image search for: {prompt}")
+    google_image_url = search_google_images(prompt)
+    if google_image_url:
+        downloaded_path = download_media(google_image_url, filename_prefix + "_gimg", TEMP_FOLDER)
+        if downloaded_path:
+            return {"path": downloaded_path, "asset_type": "image"}
+    else:
+        print("Google image search failed.")
 
-    print(f"Failed to generate visual asset for prompt: {prompt}")
-    return None
+    # 4. Absolute Fallback: Generic Image
+    print("All searches failed. Using absolute fallback: 'technology'")
+    fallback_url = search_pexels("technology", PEXELS_API_KEY, search_type="photos")
+    if fallback_url:
+        downloaded_path = download_media(fallback_url, filename_prefix + "_fallback", TEMP_FOLDER)
+        if downloaded_path:
+            return {"path": downloaded_path, "asset_type": "image"}
 
-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
+    print(f"FATAL: Could not retrieve any media for prompt: {prompt}")
+    return None # Indicate failure
 
-def generate_tts(text, voice):
+def generate_tts(text, voice_id, speed):
     """
-    Generate TTS audio using Kokoro, falling back to gTTS or silent audio if needed.
+    Generate TTS audio using Kokoro, falling back to gTTS.
     """
-    safe_text = re.sub(r'[^\w\s-]', '', text[:10]).strip().replace(' ', '_')
-    file_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.wav")
+    # Sanitize text for filename (simple approach)
+    safe_text_prefix = re.sub(r'[^\w\s-]', '', text[:20]).strip().replace(' ', '_')
+    output_filename = os.path.join(TEMP_FOLDER, f"tts_{safe_text_prefix}_{voice_id}.wav")
 
-    if os.path.exists(file_path):
-        print(f"Using cached TTS for text '{text[:10]}...'")
-        return file_path
-
-    try:
-        kokoro_voice = selected_voice if voice == 'en' else voice
-        generator = pipeline(text, voice=kokoro_voice, speed=voice_speed, 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}")
+    # --- Try Kokoro TTS First ---
+    if pipeline: # Check if Kokoro was initialized
         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")
-            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}")
-            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 movement pattern."""
-    target_w, target_h = target_resolution
-    clip_aspect = clip.w / clip.h
-    target_aspect = target_w / target_h
+            print(f"Generating TTS with Kokoro (Voice: {voice_id}, Speed: {speed}) for: '{text[:30]}...'")
+            # Generate audio segment(s)
+            generator = pipeline(text, voice=voice_id, speed=speed) # Removed split_pattern for simplicity
+            audio_segments = []
+            # Kokoro's generator might yield differently depending on version/setup
+            # Assuming it yields tuples or directly the audio array
+            for item in generator:
+                if isinstance(item, tuple) and len(item) > 0 and isinstance(item[-1], np.ndarray):
+                    audio_segments.append(item[-1]) # Assume audio is the last element
+                elif isinstance(item, np.ndarray):
+                     audio_segments.append(item) # Assume it yields audio directly
+                # Add more checks if Kokoro's output structure is different
+
+            if not audio_segments:
+                 raise ValueError("Kokoro TTS returned no audio segments.")
+
+            # Concatenate if multiple segments
+            full_audio = np.concatenate(audio_segments) if len(audio_segments) > 0 else audio_segments[0]
+
+            # Ensure audio is float32 for soundfile if needed (Kokoro usually outputs float32)
+            if full_audio.dtype != np.float32:
+                full_audio = full_audio.astype(np.float32)
+                # Normalize if necessary after type conversion
+                max_val = np.max(np.abs(full_audio))
+                if max_val > 1.0:
+                    full_audio /= max_val
+
+            sf.write(output_filename, full_audio, 24000) # Kokoro default sample rate
+            print(f"Kokoro TTS audio saved to {output_filename}")
+            return output_filename
+        except Exception as e:
+            print(f"Error with Kokoro TTS: {e}. Falling back to gTTS.")
+            # Fall through to gTTS block
+
+    # --- Fallback to gTTS ---
+    try:
+        print(f"Generating TTS with gTTS for: '{text[:30]}...'")
+        tts = gTTS(text=text, lang='en', slow= (speed < 0.9) ) # gTTS speed is boolean (slow/normal)
+        mp3_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text_prefix}_gtts.mp3")
+        wav_path = output_filename # Reuse the intended output filename
+        tts.save(mp3_path)
+
+        # Convert MP3 to WAV using pydub
+        audio = AudioSegment.from_mp3(mp3_path)
+        audio.export(wav_path, format="wav")
+        os.remove(mp3_path) # Clean up temporary mp3
+
+        print(f"gTTS audio saved and converted to {wav_path}")
+        return wav_path
+    except ImportError:
+        print("Error: gTTS or pydub might not be installed. Cannot use gTTS fallback.")
+        return None
+    except Exception as fallback_error:
+        print(f"Error with gTTS fallback: {fallback_error}")
+        return None
 
-    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))
-        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."""
+def apply_kenburns_effect(clip, target_resolution, duration):
+    """Apply a randomized Ken Burns effect (zoom/pan) to an image clip."""
     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)
+    img_w, img_h = clip.size
+
+    # Resize image slightly larger than target to allow movement
+    # Maintain aspect ratio, fit to cover target dimensions + margin
+    scale_factor = 1.2 # Zoom margin
+    scaled_w, scaled_h = img_w * scale_factor, img_h * scale_factor
+
+    # Determine resize dimensions to cover target + margin
+    if scaled_w / scaled_h > target_w / target_h:
+        # Wider than target aspect ratio -> fit height
+        final_h = target_h * scale_factor
+        final_w = final_h * (img_w / img_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 any MP3 files in the current directory and subdirectories."""
-    mp3_files = []
-    for root, dirs, files in os.walk('.'):
-        for file in files:
-            if file.endswith('.mp3'):
-                mp3_path = os.path.join(root, file)
-                mp3_files.append(mp3_path)
-                print(f"Found MP3 file: {mp3_path}")
-    return mp3_files[0] if mp3_files else None
-
-def add_background_music(final_video, bg_music_volume=0.10):
-    """Add background music to the final video using any MP3 file found."""
+        # Taller than target aspect ratio -> fit width
+        final_w = target_w * scale_factor
+        final_h = final_w * (img_h / img_w)
+
+    final_w, final_h = int(final_w), int(final_h)
+
+    # Create a resized version for the animation base
+    # Using Pillow for resizing before passing to MoviePy might be more reliable for high-res
     try:
-        bg_music_path = "music.mp3"
-        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
-            mixed_audio = CompositeAudioClip([video_audio, bg_music])
-            final_video = final_video.set_audio(mixed_audio)
-            print("Background music added successfully")
-        else:
-            print("No MP3 files found, skipping background music")
-        return final_video
+        pil_img = Image.fromarray(clip.get_frame(0)) # Get frame as numpy array, convert to PIL
+        resized_pil = pil_img.resize((final_w, final_h), Image.Resampling.LANCZOS)
+        resized_clip = ImageClip(np.array(resized_pil)).set_duration(duration)
     except Exception as e:
-        print(f"Error adding background music: {e}")
-        print("Continuing without background music")
-        return final_video
+        print(f"Warning: Error during high-quality resize for Ken Burns, using MoviePy default: {e}")
+        # Fallback to moviepy resize (might be lower quality for stills)
+        resized_clip = clip.resize(newsize=(final_w, final_h)).set_duration(duration)
+
+
+    # Define start and end zoom/position parameters randomly
+    max_move_x = final_w - target_w
+    max_move_y = final_h - target_h
+
+    # Choose effect type
+    effect = random.choice(['zoom_in', 'zoom_out', 'pan_lr', 'pan_rl', 'pan_td', 'pan_dt'])
+
+    if effect == 'zoom_in':
+        zoom_start, zoom_end = 1.0, scale_factor
+        x_start, x_end = max_move_x / 2, max_move_x / 2
+        y_start, y_end = max_move_y / 2, max_move_y / 2
+    elif effect == 'zoom_out':
+        zoom_start, zoom_end = scale_factor, 1.0
+        x_start, x_end = max_move_x / 2, max_move_x / 2
+        y_start, y_end = max_move_y / 2, max_move_y / 2
+    elif effect == 'pan_lr': # Pan Left to Right
+        zoom_start, zoom_end = scale_factor, scale_factor # Constant zoom while panning
+        x_start, x_end = 0, max_move_x
+        y_start, y_end = max_move_y / 2, max_move_y / 2 # Center vertically
+    elif effect == 'pan_rl': # Pan Right to Left
+        zoom_start, zoom_end = scale_factor, scale_factor
+        x_start, x_end = max_move_x, 0
+        y_start, y_end = max_move_y / 2, max_move_y / 2
+    elif effect == 'pan_td': # Pan Top to Down
+        zoom_start, zoom_end = scale_factor, scale_factor
+        x_start, x_end = max_move_x / 2, max_move_x / 2 # Center horizontally
+        y_start, y_end = 0, max_move_y
+    else: # Pan Down to Top
+        zoom_start, zoom_end = scale_factor, scale_factor
+        x_start, x_end = max_move_x / 2, max_move_x / 2
+        y_start, y_end = max_move_y, 0
+
+    # Define the function for fl_image
+    def make_frame(t):
+        # Linear interpolation for time
+        interp = t / duration if duration else 0
+
+        # Interpolate zoom and position
+        current_zoom = zoom_start + (zoom_end - zoom_start) * interp
+        current_x = x_start + (x_end - x_start) * interp
+        current_y = y_start + (y_end - y_start) * interp
+
+        # Calculate the crop box dimensions based on current zoom
+        # The size of the box to crop from the *resized_clip*
+        crop_w = target_w / (current_zoom / scale_factor) # Adjust target by zoom relative to initial scale
+        crop_h = target_h / (current_zoom / scale_factor)
+
+        # Ensure crop dimensions are valid
+        crop_w = max(1, int(crop_w))
+        crop_h = max(1, int(crop_h))
+
+        # Calculate the top-left corner of the crop box
+        # current_x/y is the center offset in the scaled image
+        # We need top-left corner (x1, y1)
+        x1 = current_x # Assume current_x/y are already top-left offsets
+        y1 = current_y
+
+        # Clamp coordinates to stay within bounds
+        x1 = max(0, min(x1, final_w - crop_w))
+        y1 = max(0, min(y1, final_h - crop_h))
+
+        # Get the frame from the *potentially pre-resized* clip
+        frame = resized_clip.get_frame(t)
+
+        # Crop the frame
+        # Note: MoviePy's crop uses x1,y1,x2,y2 or x_center, y_center, width, height
+        # Using numpy slicing might be easier here
+        cropped_frame = frame[int(y1):int(y1 + crop_h), int(x1):int(x1 + crop_w)]
+
+        # Resize the cropped frame to the final target resolution
+        # Using OpenCV for potentially better resizing quality
+        final_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
+
+        return final_frame
+
+    # Apply the transformation using fl
+    return resized_clip.fl(make_frame, apply_to=['mask']) # Apply to mask if exists
 
+def resize_to_fill(clip, target_resolution):
+    """Resize and crop a video clip to fill the target resolution."""
+    target_w, target_h = target_resolution
+    target_aspect = target_w / target_h
 
+    # Use MoviePy's resize and crop fx
+    # Resize to fit the smaller dimension to cover the target area
+    if clip.w / clip.h > target_aspect:
+        # Clip is wider than target -> resize based on height
+        resized_clip = clip.resize(height=target_h)
+    else:
+        # Clip is taller or equal aspect -> resize based on width
+        resized_clip = clip.resize(width=target_w)
 
+    # Crop the excess from the center
+    crop_x = max(0, (resized_clip.w - target_w) / 2)
+    crop_y = max(0, (resized_clip.h - target_h) / 2)
 
+    cropped_clip = resized_clip.crop(x1=crop_x, y1=crop_y, width=target_w, height=target_h)
+    return cropped_clip
 
+def add_background_music(video_clip, music_file_path, volume):
+    """Add background music, looping if necessary."""
+    if not music_file_path or not os.path.exists(music_file_path):
+        print("No background music file found or provided. Skipping.")
+        return video_clip
 
-def fix_imagemagick_policy():
-    """Fix ImageMagick security policies."""
     try:
-        print("Attempting to fix ImageMagick security policies...")
-        policy_paths = [
-            "/etc/ImageMagick-6/policy.xml",
-            "/etc/ImageMagick-7/policy.xml",
-            "/etc/ImageMagick/policy.xml",
-            "/usr/local/etc/ImageMagick-7/policy.xml"
-        ]
-        found_policy = next((path for path in policy_paths if os.path.exists(path)), None)
-        if not found_policy:
-            print("No policy.xml found. Using alternative subtitle method.")
-            return False
-        print(f"Modifying policy file at {found_policy}")
-        os.system(f"sudo cp {found_policy} {found_policy}.bak")
-        os.system(f"sudo sed -i 's/rights=\"none\"/rights=\"read|write\"/g' {found_policy}")
-        os.system(f"sudo sed -i 's/<policy domain=\"path\" pattern=\"@\*\"[^>]*>/<policy domain=\"path\" pattern=\"@*\" rights=\"read|write\"/g' {found_policy}")
-        os.system(f"sudo sed -i 's/<policy domain=\"coder\" rights=\"none\" pattern=\"PDF\"[^>]*>/<!-- <policy domain=\"coder\" rights=\"none\" pattern=\"PDF\"> -->/g' {found_policy}")
-        print("ImageMagick policies updated successfully.")
-        return True
-    except Exception as e:
-        print(f"Error fixing policies: {e}")
-        return False
-
-
-
-
+        print(f"Adding background music from: {music_file_path}")
+        bg_music = AudioFileClip(music_file_path)
+
+        if bg_music.duration > video_clip.duration:
+            # Trim music to video duration
+            bg_music = bg_music.subclip(0, video_clip.duration)
+        elif bg_music.duration < video_clip.duration:
+            # Loop music to fit video duration
+            loops_needed = math.ceil(video_clip.duration / bg_music.duration)
+            bg_music = concatenate_audioclips([bg_music] * loops_needed)
+            bg_music = bg_music.subclip(0, video_clip.duration) # Trim precisely
+
+        # Apply volume adjustment
+        bg_music = bg_music.volumex(volume)
+
+        # Combine with existing audio (if any)
+        final_audio = CompositeAudioClip([video_clip.audio, bg_music])
+        video_clip = video_clip.set_audio(final_audio)
+        print("Background music added successfully.")
+        return video_clip
 
+    except Exception as e:
+        print(f"Error adding background music: {e}. Skipping.")
+        return video_clip # Return original clip
 
 
-def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, narration_text=None, segment_index=0):
-    """Create a video clip with synchronized subtitles and narration."""
+def create_segment_clip(media_info, tts_path, narration_text):
+    """Create a single video segment (clip) with visuals, audio, and subtitles."""
     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
+        media_path = media_info['path']
+        asset_type = media_info['asset_type']
+        print(f"Creating clip segment: Type={asset_type}, Media={os.path.basename(media_path)}")
 
-        audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2)
-        audio_duration = audio_clip.duration
-        target_duration = audio_duration + 0.2
+        # --- 1. Load Audio ---
+        if not os.path.exists(tts_path):
+            print(f"Error: TTS file not found: {tts_path}")
+            return None
+        audio_clip = AudioFileClip(tts_path)
+        # Add tiny silence buffer at start/end for transitions
+        segment_duration = audio_clip.duration + 0.3 # Add buffer
 
-        # Handle media (video or image)
+        # --- 2. Create Visual Clip ---
         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)
+            if not os.path.exists(media_path):
+                print(f"Error: Video file not found: {media_path}")
+                return None
+            video_clip = VideoFileClip(media_path)
+            # Ensure video covers segment duration, looping if needed
+            if video_clip.duration < segment_duration:
+                # Loop the video
+                loops = math.ceil(segment_duration / video_clip.duration)
+                video_clip = concatenate_videoclips([video_clip] * loops)
+            # Trim to exact segment duration
+            video_clip = video_clip.subclip(0, segment_duration)
+            # Resize/crop to fit target resolution
+            visual_clip = resize_to_fill(video_clip, TARGET_RESOLUTION)
+
         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)
+            if not os.path.exists(media_path):
+                 print(f"Error: Image file not found: {media_path}")
+                 return None
+            # Create ImageClip and apply Ken Burns
+            img_clip = ImageClip(media_path).set_duration(segment_duration)
+            # Apply Ken Burns effect
+            visual_clip = apply_kenburns_effect(img_clip, TARGET_RESOLUTION, segment_duration)
+            # Ensure final size is correct after effects
+            visual_clip = visual_clip.resize(newsize=TARGET_RESOLUTION)
+
         else:
+            print(f"Error: Unknown asset type: {asset_type}")
             return None
 
-        # Add subtitles if enabled
-        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)
-                subtitle_clips = []
-                subtitle_y_position = int(TARGET_RESOLUTION[1] * 0.70)
+        # Add fade-in/out for smoother transitions between segments
+        visual_clip = visual_clip.fadein(0.15).fadeout(0.15)
+
+        # --- 3. Add Subtitles (Chunk-based, No ImageMagick) ---
+        subtitle_clips = []
+        if USE_CAPTIONS and narration_text:
+            words = narration_text.split()
+            # Simple chunking: group words, max ~5 per chunk or based on duration
+            max_words_per_chunk = 5
+            chunks = []
+            current_chunk = []
+            for word in words:
+                current_chunk.append(word)
+                if len(current_chunk) >= max_words_per_chunk:
+                    chunks.append(" ".join(current_chunk))
+                    current_chunk = []
+            if current_chunk: # Add any remaining words
+                chunks.append(" ".join(current_chunk))
+
+            if not chunks: # Handle empty narration case
+                 print("Warning: Narration text is empty, skipping subtitles for this segment.")
+
+            else:
+                num_chunks = len(chunks)
+                chunk_duration = audio_clip.duration / num_chunks # Duration per text chunk
+                start_time = 0.1 # Small delay before first subtitle
 
                 for i, chunk_text in enumerate(chunks):
-                    start_time = i * chunk_duration
-                    end_time = (i + 1) * chunk_duration
+                    end_time = start_time + chunk_duration
+                    # Ensure end_time doesn't exceed the visual clip duration slightly
+                    end_time = min(end_time, segment_duration - 0.1)
+
                     txt_clip = TextClip(
-                        chunk_text,
+                        txt=chunk_text,
                         fontsize=font_size,
-                        font='DejaVu-Sans',  # Hugging Face friendly
-                        color=CAPTION_COLOR,
-                        stroke_width=2,
-                        stroke_color='black'  # Outline for readability
-                    ).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}")
-                txt_clip = TextClip(
-                    narration_text,
-                    fontsize=font_size,
-                    font='DejaVu-Sans',
-                    color=CAPTION_COLOR,
-                    stroke_width=2,
-                    stroke_color='black'
-                ).set_position(('center', int(TARGET_RESOLUTION[1] / 3))).set_duration(clip.duration)
-                clip = CompositeVideoClip([clip, txt_clip])
-
-        # Set audio
-        clip = clip.set_audio(audio_clip)
-        print(f"Clip created: {clip.duration:.1f}s")
-        return clip
-
-    except Exception as e:
-        print(f"Error in create_clip: {str(e)}")
-        return None
-
+                        font=caption_font, # Ensure this font is available or use default
+                        color=caption_style_text_color,
+                        bg_color=caption_style_bg_color, # Semi-transparent background
+                        method='label', # Use 'label' - simpler, less likely ImageMagick dependency
+                        align='center',
+                        size=(TARGET_RESOLUTION[0] * 0.8, None) # Width constraint
+                    )
+                    # Position: center horizontally, lower part of the screen
+                    txt_clip = txt_clip.set_position(('center', TARGET_RESOLUTION[1] * 0.80))
+                    txt_clip = txt_clip.set_start(start_time).set_duration(end_time - start_time)
+                    # txt_clip = txt_clip.fadein(0.1).fadeout(0.1) # Optional fade for text
 
+                    subtitle_clips.append(txt_clip)
+                    start_time = end_time # Next chunk starts where the last one ended
 
+        # --- 4. Combine Visuals, Audio, and Subtitles ---
+        if subtitle_clips:
+            final_clip = CompositeVideoClip([visual_clip] + subtitle_clips)
+        else:
+            final_clip = visual_clip # No subtitles
 
+        # Set the audio for the final segment clip
+        final_clip = final_clip.set_audio(audio_clip.set_start(0.15)) # Start audio slightly after visual fade-in
 
+        print(f"Clip segment created successfully. Duration: {final_clip.duration:.2f}s")
+        return final_clip
 
+    except Exception as e:
+        print(f"Error creating clip segment: {e}")
+        import traceback
+        traceback.print_exc() # Print detailed traceback for debugging
+        return None
 
+# ---------------- Main Video Generation Function ---------------- #
 
+def generate_full_video(user_input, resolution_choice, caption_choice, music_file_info):
+    """
+    Main function orchestrating the video generation process.
+    Uses global variables set by Gradio for configuration.
+    """
+    global TARGET_RESOLUTION, TEMP_FOLDER, USE_CAPTIONS
 
+    print("\n--- Starting Video Generation ---")
+    start_time = time.time()
 
+    # 1. Setup Environment
+    if resolution_choice == "Short (9:16)":
+        TARGET_RESOLUTION = (1080, 1920)
+        print("Resolution set to: Short (1080x1920)")
+    else: # Default to Full HD
+        TARGET_RESOLUTION = (1920, 1080)
+        print("Resolution set to: Full HD (1920x1080)")
 
+    USE_CAPTIONS = (caption_choice == "Yes")
+    print(f"Captions Enabled: {USE_CAPTIONS}")
 
+    # Create unique temporary folder for this run
+    TEMP_FOLDER = tempfile.mkdtemp(prefix="aivideo_")
+    print(f"Temporary folder created: {TEMP_FOLDER}")
 
+    # Handle uploaded music file
+    music_file_path = None
+    if music_file_info is not None:
+        try:
+            # Copy uploaded file to a predictable location (or use directly if safe)
+            # Using a fixed name in the temp folder is often easier
+            music_file_path = os.path.join(TEMP_FOLDER, "background_music.mp3")
+            shutil.copy(music_file_info.name, music_file_path)
+            print(f"Background music copied to: {music_file_path}")
+        except Exception as e:
+            print(f"Error handling uploaded music file: {e}")
+            music_file_path = None # Ensure it's None if copy failed
 
 
+    # --- No ImageMagick Fix Needed ---
+    # print("Skipping ImageMagick policy check as alternative subtitles are used.")
 
 
+    # 2. Generate Script
+    print("\nStep 1: Generating script...")
+    script_text = generate_script(user_input)
+    if not script_text:
+        print("ERROR: Failed to generate script. Aborting.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None, "Error: Script generation failed. Check API keys and OpenRouter status." # Return error message for Gradio
+    print("Script Generated:\n", script_text)
 
 
+    # 3. Parse Script
+    print("\nStep 2: Parsing script...")
+    segments = parse_script(script_text)
+    if not segments:
+        print("ERROR: Failed to parse script into segments. Aborting.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None, "Error: Script parsing failed. Check script format."
+    print(f"Successfully parsed {len(segments)} segments.")
+
+
+    # 4. Generate Media and TTS for each segment
+    print("\nStep 3: Generating media and TTS for each segment...")
+    segment_clips = []
+    total_segments = len(segments)
+    for i, segment in enumerate(segments):
+        print(f"\n--- Processing Segment {i+1}/{total_segments} ---")
+        print(f"  Prompt: {segment['prompt']}")
+        print(f"  Narration: {segment['narration']}")
+
+        # Generate Media
+        media_info = generate_media(segment['prompt'])
+        if not media_info:
+            print(f"Warning: Failed to get media for segment {i+1}. Skipping segment.")
+            continue # Skip this segment if media fails
+
+        # Generate TTS
+        tts_path = generate_tts(segment['narration'], selected_voice, voice_speed)
+        if not tts_path:
+            print(f"Warning: Failed to generate TTS for segment {i+1}. Skipping segment.")
+            # Clean up downloaded media if TTS failed
+            if media_info and os.path.exists(media_info['path']):
+                 try: os.remove(media_info['path'])
+                 except OSError: pass
+            continue # Skip this segment if TTS fails
+
+        # Create the actual MoviePy clip for this segment
+        clip = create_segment_clip(media_info, tts_path, segment['narration'])
+        if clip:
+            segment_clips.append(clip)
+        else:
+            print(f"Warning: Failed to create video clip for segment {i+1}. Skipping.")
+            # Clean up files for this failed segment
+            if media_info and os.path.exists(media_info['path']):
+                 try: os.remove(media_info['path'])
+                 except OSError: pass
+            if tts_path and os.path.exists(tts_path):
+                 try: os.remove(tts_path)
+                 except OSError: pass
+
+
+    if not segment_clips:
+        print("ERROR: No video clips were successfully created. Aborting.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None, "Error: Failed to create any video segments. Check logs."
 
 
-# ---------------- Main Video Generation Function ---------------- #
-def generate_video(user_input, resolution, caption_option):
-    """Generate a video based on user input via Gradio."""
-    global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
-    
-    # Set resolution
-    if resolution == "Full":
-        TARGET_RESOLUTION = (1920, 1080)
-    elif resolution == "Short":
-        TARGET_RESOLUTION = (1080, 1920)
-    else:
-        TARGET_RESOLUTION = (1920, 1080)  # Default
-
-    # Set caption color
-    CAPTION_COLOR = "white" if caption_option == "Yes" else "transparent"
+    # 5. Concatenate Clips
+    print("\nStep 4: Concatenating video segments...")
+    try:
+        final_video = concatenate_videoclips(segment_clips, method="compose")
+        print("Segments concatenated successfully.")
+    except Exception as e:
+        print(f"ERROR: Failed to concatenate video clips: {e}")
+        shutil.rmtree(TEMP_FOLDER)
+        return None, f"Error: Concatenation failed: {e}"
 
-    # Create a unique temporary folder
-    TEMP_FOLDER = tempfile.mkdtemp()
 
-    # Fix ImageMagick policy
-    fix_success = fix_imagemagick_policy()
+    # 6. Add Background Music
+    print("\nStep 5: Adding background music...")
+    final_video = add_background_music(final_video, music_file_path, bg_music_volume)
 
-    if not fix_success:
-        print("Will use alternative methods if needed")
 
-    print("Generating script from API...")
-    script = generate_script(user_input)
-    if not script:
-        print("Failed to generate script.")
-        shutil.rmtree(TEMP_FOLDER)
-        return None
-    print("Generated Script:\n", script)
-    elements = parse_script(script)
-    if not elements:
-        print("Failed to parse script into elements.")
-        shutil.rmtree(TEMP_FOLDER)
-        return None
-    print(f"Parsed {len(elements)//2} script segments.")
+    # 7. Export Final Video
+    print(f"\nStep 6: Exporting final video to '{OUTPUT_VIDEO_FILENAME}'...")
+    try:
+        final_video.write_videofile(
+            OUTPUT_VIDEO_FILENAME,
+            codec='libx264',    # Good balance of quality/compatibility
+            audio_codec='aac', # Standard audio codec
+            fps=fps,
+            preset=preset,      # Controls encoding speed vs compression
+            threads=4,          # Use multiple threads for faster encoding
+            logger='bar'        # Show progress bar
+        )
+        print(f"Final video saved successfully as {OUTPUT_VIDEO_FILENAME}")
+        export_success = True
+    except Exception as e:
+        print(f"ERROR: Failed to write final video file: {e}")
+        import traceback
+        traceback.print_exc()
+        export_success = False
 
-    paired_elements = []
-    for i in range(0, len(elements), 2):
-        if i + 1 < len(elements):
-            paired_elements.append((elements[i], elements[i + 1]))
 
-    if not paired_elements:
-        print("No valid script segments found.")
+    # 8. Cleanup
+    print("\nStep 7: Cleaning up temporary files...")
+    try:
         shutil.rmtree(TEMP_FOLDER)
-        return None
-
-    clips = []
-    for idx, (media_elem, tts_elem) in enumerate(paired_elements):
-        print(f"\nProcessing segment {idx+1}/{len(paired_elements)} with prompt: '{media_elem['prompt']}'")
-        media_asset = generate_media(media_elem['prompt'], current_index=idx, total_segments=len(paired_elements))
-        if not media_asset:
-            print(f"Skipping segment {idx+1} due to missing media asset.")
-            continue
-        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
-        clip = create_clip(
-            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
-        )
-        if clip:
-            clips.append(clip)
-        else:
-            print(f"Clip creation failed for segment {idx+1}.")
+        print(f"Temporary folder {TEMP_FOLDER} removed.")
+    except Exception as e:
+        print(f"Warning: Failed to remove temporary folder {TEMP_FOLDER}: {e}")
 
-    if not clips:
-        print("No clips were successfully created.")
-        shutil.rmtree(TEMP_FOLDER)
-        return None
 
-    print("\nConcatenating clips...")
-    final_video = concatenate_videoclips(clips, method="compose")
-    final_video = add_background_music(final_video, bg_music_volume=bg_music_volume)
+    end_time = time.time()
+    total_time = end_time - start_time
+    print(f"\n--- Video Generation Finished ---")
+    print(f"Total time: {total_time:.2f} seconds")
 
-    print(f"Exporting final video to {OUTPUT_VIDEO_FILENAME}...")
-    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=fps, preset=preset)
-    print(f"Final video saved as {OUTPUT_VIDEO_FILENAME}")
+    if export_success:
+        return OUTPUT_VIDEO_FILENAME, f"Video generation complete! Time: {total_time:.2f}s"
+    else:
+        return None, f"Error: Video export failed. Check logs. Time: {total_time:.2f}s"
 
-    # Clean up
-    print("Cleaning up temporary files...")
-    shutil.rmtree(TEMP_FOLDER)
-    print("Temporary files removed.")
 
-    return OUTPUT_VIDEO_FILENAME
+# ---------------- Gradio Interface Definition ---------------- #
 
-# ---------------- Gradio Interface ---------------- #
+# Kokoro Voice Choices (Example subset, add more as needed)
 VOICE_CHOICES = {
-    'Emma (Female)': 'af_heart',
-    'Bella (Female)': 'af_bella',
-    'Nicole (Female)': 'af_nicole',
-    'Aoede (Female)': 'af_aoede',
-    'Kore (Female)': 'af_kore',
-    'Sarah (Female)': 'af_sarah',
-    'Nova (Female)': 'af_nova',
-    'Sky (Female)': 'af_sky',
-    'Alloy (Female)': 'af_alloy',
-    'Jessica (Female)': 'af_jessica',
-    'River (Female)': 'af_river',
-    'Michael (Male)': 'am_michael',
-    'Fenrir (Male)': 'am_fenrir',
-    'Puck (Male)': 'am_puck',
-    'Echo (Male)': 'am_echo',
-    'Eric (Male)': 'am_eric',
-    'Liam (Male)': 'am_liam',
-    'Onyx (Male)': 'am_onyx',
-    'Santa (Male)': 'am_santa',
-    'Adam (Male)': 'am_adam',
-    'Emma 🇬🇧 (Female)': 'bf_emma',
-    'Isabella 🇬🇧 (Female)': 'bf_isabella',
-    'Alice 🇬🇧 (Female)': 'bf_alice',
-    'Lily 🇬🇧 (Female)': 'bf_lily',
-    'George 🇬🇧 (Male)': 'bm_george',
-    'Fable 🇬🇧 (Male)': 'bm_fable',
-    'Lewis 🇬🇧 (Male)': 'bm_lewis',
-    'Daniel 🇬🇧 (Male)': 'bm_daniel'
+    # American English
+    'Emma (US Female)': 'af_heart',
+    'Bella (US Female)': 'af_bella',
+    'Nicole (US Female)': 'af_nicole',
+    'Sarah (US Female)': 'af_sarah',
+    'Michael (US Male)': 'am_michael',
+    'Eric (US Male)': 'am_eric',
+    'Adam (US Male)': 'am_adam',
+    # British English
+    'Emma (UK Female)': 'bf_emma',
+    'Alice (UK Female)': 'bf_alice',
+    'George (UK Male)': 'bm_george',
+    'Daniel (UK Male)': 'bm_daniel',
 }
 
-def generate_video_with_options(user_input, resolution, caption_option, music_file, voice, vclip_prob, bg_vol, video_fps, video_preset, v_speed, caption_size):
+def gradio_interface_handler(
+    user_prompt, resolution, captions, bg_music,
+    voice_name, video_prob, music_vol, video_fps, export_preset,
+    tts_speed, caption_size):
+    """Wrapper function to connect Gradio inputs to the main generation logic."""
+
+    print("\n--- Received Request from Gradio ---")
+    print(f"Prompt: {user_prompt[:50]}...")
+    print(f"Resolution: {resolution}")
+    print(f"Captions: {captions}")
+    print(f"Music File: {'Provided' if bg_music else 'None'}")
+    print(f"Voice: {voice_name}")
+    print(f"Video Probability: {video_prob}%")
+    print(f"Music Volume: {music_vol}")
+    print(f"FPS: {video_fps}")
+    print(f"Preset: {export_preset}")
+    print(f"TTS Speed: {tts_speed}")
+    print(f"Caption Size: {caption_size}")
+
+    # Update global settings based on Gradio inputs
     global selected_voice, voice_speed, font_size, video_clip_probability, bg_music_volume, fps, preset
-    
-    # Update global variables with user selections
-    selected_voice = VOICE_CHOICES[voice]
-    voice_speed = v_speed
+    selected_voice = VOICE_CHOICES.get(voice_name, 'af_heart') # Get voice ID from name
+    voice_speed = tts_speed
     font_size = caption_size
-    video_clip_probability = vclip_prob / 100  # Convert from percentage to decimal
-    bg_music_volume = bg_vol
+    video_clip_probability = video_prob / 100.0 # Convert percentage to probability
+    bg_music_volume = music_vol
     fps = video_fps
-    preset = video_preset
-    
-    # Handle music upload
-    if music_file is not None:
-        target_path = "music.mp3"
-        shutil.copy(music_file.name, target_path)
-        print(f"Uploaded music saved as: {target_path}")
-    
-    # Generate the video
-    return generate_video(user_input, resolution, caption_option)
-
-# Create the Gradio interface
-iface = gr.Interface(
-    fn=generate_video_with_options,
-    inputs=[
-        gr.Textbox(label="Video Concept", placeholder="Enter your video concept here..."),
-        gr.Radio(["Full", "Short"], label="Resolution", value="Full"),
-        gr.Radio(["Yes", "No"], label="Captions", value="Yes"),
-        gr.File(label="Upload Background Music (MP3)", file_types=[".mp3"]),
-        gr.Dropdown(choices=list(VOICE_CHOICES.keys()), label="Choose Voice", value="Emma (Female)"),
-        gr.Slider(0, 100, value=25, step=1, label="Video Clip Usage Probability (%)"),
-        gr.Slider(0.0, 1.0, value=0.08, step=0.01, label="Background Music Volume"),
-        gr.Slider(10, 60, value=30, step=1, label="Video FPS"),
-        gr.Dropdown(choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow"], 
-                   value="veryfast", label="Export Preset"),
-        gr.Slider(0.5, 1.5, value=0.9, step=0.05, label="Voice Speed"),
-        gr.Slider(20, 100, value=45, step=1, label="Caption Font Size")
-    ],
-    outputs=gr.Video(label="Generated Video"),
-    title="AI Documentary Video Generator",
-    description="Create short documentary videos with AI. Upload music, choose voice, and customize settings."
-)
+    preset = export_preset
+
+    # Call the main video generation function
+    video_path, status_message = generate_full_video(user_prompt, resolution, captions, bg_music)
+
+    print(f"Gradio Handler Status: {status_message}")
+
+    # Return the video path (or None if failed) and the status message
+    return video_path, status_message
+
+
+# Create Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft()) as iface:
+    gr.Markdown("# 🎬 AI Documentary Video Generator")
+    gr.Markdown("Enter a topic or detailed instructions, customize settings, and generate a short documentary-style video. Uses AI for script, TTS, and finds relevant stock footage.")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            prompt_input = gr.Textbox(
+                label="Video Concept / Topic / Script",
+                placeholder="e.g., 'The history of coffee', 'Top 5 strangest animals', or paste a full script following the format.",
+                lines=4
+            )
+            submit_button = gr.Button("Generate Video", variant="primary")
+            status_output = gr.Textbox(label="Status", interactive=False)
+
+        with gr.Column(scale=1):
+            video_output = gr.Video(label="Generated Video")
+
+
+    with gr.Accordion("⚙️ Advanced Settings", open=False):
+        gr.Markdown("### Video & Audio Settings")
+        with gr.Row():
+            resolution_dd = gr.Dropdown(["Full HD (16:9)", "Short (9:16)"], label="Resolution", value="Full HD (16:9)")
+            caption_dd = gr.Radio(["Yes", "No"], label="Generate Captions", value="Yes")
+            music_upload = gr.File(label="Upload Background Music (MP3)", file_types=[".mp3"])
+
+        gr.Markdown("### Voice & Narration")
+        with gr.Row():
+            voice_dd = gr.Dropdown(choices=list(VOICE_CHOICES.keys()), label="Narration Voice", value="Emma (US Female)")
+            speed_slider = gr.Slider(0.5, 1.5, value=0.9, step=0.05, label="Voice Speed")
+
+        gr.Markdown("### Visuals & Style")
+        with gr.Row():
+            video_prob_slider = gr.Slider(0, 100, value=35, step=5, label="Video Clip % (vs. Images)")
+            caption_size_slider = gr.Slider(20, 80, value=45, step=1, label="Caption Font Size")
+
+        gr.Markdown("### Export Settings")
+        with gr.Row():
+            music_vol_slider = gr.Slider(0.0, 1.0, value=0.08, step=0.01, label="Background Music Volume")
+            fps_slider = gr.Slider(15, 60, value=30, step=1, label="Video FPS")
+            preset_dd = gr.Dropdown(
+                choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"],
+                value="veryfast", label="Export Quality/Speed Preset"
+            )
+
+    # Connect components
+    submit_button.click(
+        fn=gradio_interface_handler,
+        inputs=[
+            prompt_input, resolution_dd, caption_dd, music_upload,
+            voice_dd, video_prob_slider, music_vol_slider, fps_slider, preset_dd,
+            speed_slider, caption_size_slider
+        ],
+        outputs=[video_output, status_output]
+    )
 
 # Launch the interface
 if __name__ == "__main__":
-    iface.launch(share=True)
+    print("Launching Gradio Interface...")
+    # Make sure to replace API keys at the top before running!
+    if PEXELS_API_KEY == 'YOUR_PEXELS_API_KEY' or OPENROUTER_API_KEY == 'YOUR_OPENROUTER_API_KEY':
+        print("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+        print("!!! WARNING: API Keys not set in the script.         !!!")
+        print("!!! Please replace 'YOUR_PEXELS_API_KEY' and         !!!")
+        print("!!! 'YOUR_OPENROUTER_API_KEY' with your actual keys. !!!")
+        print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n")
+
+    iface.launch(share=True, debug=True) # Share=True for public link, Debug=True for more logs