Update app.py

app.py

@@ -1,155 +1,412 @@
-
+# Import necessary libraries
+from kokoro import KPipeline
 import soundfile as sf
 import torch
 import os
-from moviepy.editor import VideoFileClip, AudioFileClip, ImageClip
-from PIL import Image
-import tempfile
-import random
-import cv2
-import math
-import time
-import re
-import requests
-from moviepy.editor import concatenate_videoclips, CompositeVideoClip, TextClip
+from moviepy.editor import (
+    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
+    CompositeVideoClip, TextClip, concatenate_audioclips
+)
+import moviepy.video.fx.all as vfx
 import moviepy.config as mpy_config
 from pydub import AudioSegment
+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 gradio as gr
+import tempfile
+import random
+import cv2
+import math
+import requests
+import time
+import re
 import shutil
 
-pipeline = KPipeline(lang_code='a')
+# 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"})
 
+# ---------------- Global Configuration ---------------- #
 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"
 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"
 
+# Global variables to be set per run
 TARGET_RESOLUTION = None
 TEMP_FOLDER = None
 
+# ---------------- Helper Functions ---------------- #
 def generate_script(user_input):
-    headers = {'Authorization': f'Bearer {OPENROUTER_API_KEY}','HTTP-Referer': 'https://your-domain.com','X-Title': 'AI Documentary Maker'}
-    prompt = f"Short Documentary Script Generator Instructions: {user_input}"
-    data = {'model': OPENROUTER_MODEL,'messages': [{'role': 'user', 'content': prompt}],'temperature': 0.4,'max_tokens': 5000}
+    headers = {
+        'Authorization': f'Bearer {OPENROUTER_API_KEY}',
+        'HTTP-Referer': 'https://your-domain.com',
+        'X-Title': 'AI Documentary Maker'
+    }
+    prompt = f"""Short Documentary Script GeneratorInstructions:
+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}
+"""
+    data = {
+        'model': OPENROUTER_MODEL,
+        'messages': [{'role': 'user', 'content': prompt}],
+        'temperature': 0.4,
+        'max_tokens': 5000
+    }
     try:
-        response = requests.post('https://openrouter.ai/api/v1/chat/completions', headers=headers, json=data, timeout=30)
-        if response.status_code == 200: return response.json()['choices'][0]['message']['content']
+        response = requests.post(
+            'https://openrouter.ai/api/v1/chat/completions',
+            headers=headers,
+            json=data,
+            timeout=30
+        )
+        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:
+            print(f"API Error {response.status_code}: {response.text}")
+            return None
+    except Exception as e:
+        print(f"Request failed: {str(e)}")
         return None
-    except: return None
 
 def parse_script(script_text):
     sections = {}
     current_title = None
     current_text = ""
-    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: 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
+    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}")
+        return []
 
 def search_pexels_videos(query, pexels_api_key):
     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, 4):
-        params = {"query": query, "per_page": 15, "page": page}
-        response = requests.get(base_url, headers=headers, params=params, timeout=10)
-        if response.status_code == 200:
-            for video in response.json().get("videos", []):
-                for file in video.get("video_files", []):
-                    if file.get("quality") == "hd":
-                        all_videos.append(file.get("link"))
+    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
-    return random.choice(all_videos) if all_videos else None
+                    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.")
+        return None
 
 def search_pexels_images(query, pexels_api_key):
     headers = {'Authorization': pexels_api_key}
     url = "https://api.pexels.com/v1/search"
     params = {"query": query, "per_page": 5, "orientation": "landscape"}
-    response = requests.get(url, headers=headers, params=params, timeout=10)
-    if response.status_code == 200:
-        photos = response.json().get("photos", [])
-        if photos: return random.choice(photos[:5]).get("src", {}).get("original")
+    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
+            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 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
+        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"No Pexels images found for query: {query} after all attempts")
     return None
 
+def search_google_images(query):
+    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:
+            print(f"No Google Images found for query: {query}")
+            return None
+    except Exception as e:
+        print(f"Error in Google Images search: {e}")
+        return None
+
 def download_image(image_url, filename):
     try:
-        response = requests.get(image_url, stream=True, timeout=15)
+        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.raise_for_status()
         with open(filename, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192): f.write(chunk)
-        img = Image.open(filename)
-        if img.mode != 'RGB': 
-            img = img.convert('RGB')
-            img.save(filename)
-        return filename
-    except: return None
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        print(f"Image 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
+    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 download_video(video_url, filename):
     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)
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write仰chunk)
+        print(f"Video downloaded successfully to: {filename}")
         return filename
-    except: return None
+    except Exception as e:
+        print(f"Video download error: {e}")
+        if os.path.exists(filename):
+            os.remove(filename)
+        return None
 
-def generate_media(prompt):
+def generate_media(prompt, temp_folder, user_upload=None):
     safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
-    video_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_video.mp4")
-    video_url = search_pexels_videos(prompt, PEXELS_API_KEY)
-    if video_url: 
-        if download_video(video_url, video_file): return {"path": video_file, "asset_type": "video"}
-    image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}.jpg")
+    if user_upload:
+        file_ext = os.path.splitext(user_upload)[1].lower()
+        if file_ext in ['.mp4', '.mov', '.avi']:
+            shutil.copy(user_upload, os.path.join(temp_folder, f"{safe_prompt}{file_ext}"))
+            return {"path": os.path.join(temp_folder, f"{safe_prompt}{file_ext}"), "asset_type": "video"}
+        elif file_ext in ['.jpg', '.jpeg', '.png']:
+            shutil.copy(user_upload, os.path.join(temp_folder, f"{safe_prompt}.jpg"))
+            return {"path": os.path.join(temp_folder, f"{safe_prompt}.jpg"), "asset_type": "image"}
+    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"}
+    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:
+                print(f"Video asset saved to {downloaded_video}")
+                return {"path": downloaded_video, "asset_type": "video"}
+    image_file = os.path.join(temp_folder, f"{safe_prompt}.jpg")
     image_url = search_pexels_images(prompt, PEXELS_API_KEY)
-    if image_url: 
-        if download_image(image_url, image_file): return {"path": image_file, "asset_type": "image"}
+    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"}
+    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"}
+    print(f"Failed to generate visual asset for prompt: {prompt}")
     return None
 
-def generate_tts(text, voice):
-    file_path = os.path.join(TEMP_FOLDER, f"tts_{text[:10]}.wav")
+def generate_tts(text, voice, temp_folder):
+    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:
-        generator = pipeline(text, voice='af_heart', speed=0.9, split_pattern=r'\n+')
-        audio_segments = [audio for _, _, audio in generator]
+        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:
+    except Exception as e:
+        print(f"Error with Kokoro TTS: {e}")
         try:
+            print("Falling back to gTTS...")
             tts = gTTS(text=text, lang='en')
-            mp3_path = os.path.join(TEMP_FOLDER, f"tts_{text[:10]}.mp3")
+            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: return None
+        except Exception as fallback_error:
+            print(f"Both TTS methods failed: {fallback_error}")
+            return generate_silent_audio(max(3, len(text.split()) * 0.5), temp_folder)
 
-def apply_kenburns_effect(clip, target_resolution):
+def generate_silent_audio(duration, temp_folder, sample_rate=24000):
+    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 apply_kenburns_effect(clip, target_resolution, effect_type=None):
     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)
+    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)
@@ -157,16 +414,51 @@ def apply_kenburns_effect(clip, target_resolution):
     clip = clip.resize(newsize=(new_width, new_height))
     max_offset_x = new_width - target_w
     max_offset_y = new_height - target_h
-    effect_type = random.choice(["zoom-in", "zoom-out", "pan-left", "pan-right", "up-left"])
+    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 = 0.9 + (1.1 - 0.9) * 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 = (new_width / 2) + (max_offset_x * ratio)
-        current_center_y = (new_height / 2) + (max_offset_y * ratio)
+        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
@@ -186,92 +478,449 @@ def resize_to_fill(clip, target_resolution):
         clip = clip.crop(x1=0, x2=clip.w, y1=crop_amount, y2=clip.h - crop_amount)
     return clip
 
-def create_custom_clip(media_path, tts_path, text, text_color, bg_color, font_size, position, duration):
+def find_mp3_files():
+    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.08):
+    try:
+        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
+            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
+    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, customizations, target_resolution, temp_folder):
     try:
-        if media_path.endswith(('.mp4', '.mov')):
+        print(f"Creating clip 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
+        audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2)
+        audio_duration = audio_clip.duration
+        target_duration = audio_duration + 0.2
+        if asset_type == "video":
             clip = VideoFileClip(media_path)
-            clip = resize_to_fill(clip, TARGET_RESOLUTION)
-            if clip.duration < duration: clip = clip.loop(duration=duration)
-            else: clip = clip.subclip(0, duration)
+            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 customizations.get('video_brightness', 1.0) != 1.0:
+                clip = clip.fx(vfx.colorx, customizations['video_brightness'])
+            if customizations.get('video_contrast', 1.0) != 1.0:
+                clip = clip.fx(vfx.contrast, customizations['video_contrast'])
+            if customizations.get('video_speed', 1.0) != 1.0:
+                clip = clip.fx(vfx.speedx, customizations['video_speed'])
+        elif asset_type == "image":
+            img = Image.open(media_path)
+            if img.mode != 'RGB':
+                with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False, dir=temp_folder) 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, customizations.get('kenburns_effect', 'random'))
+            clip = clip.fadein(customizations.get('fade_in_duration', 0.3)).fadeout(customizations.get('fade_out_duration', 0.3))
+            if customizations.get('image_brightness', 1.0) != 1.0:
+                clip = clip.fx(vfx.colorx, customizations['image_brightness'])
+            if customizations.get('image_contrast', 1.0) != 1.0:
+                clip = clip.fx(vfx.contrast, customizations['image_contrast'])
         else:
-            clip = ImageClip(media_path).set_duration(duration)
-            clip = apply_kenburns_effect(clip, TARGET_RESOLUTION)
-        text_clip = TextClip(text, fontsize=font_size, font='Arial-Bold', color=text_color, bg_color=bg_color, size=(TARGET_RESOLUTION[0]*0.9, None))
-        y_pos = {"Bottom": TARGET_RESOLUTION[1]*0.85, "Middle": 'center', "Top": TARGET_RESOLUTION[1]*0.15}[position]
-        text_clip = text_clip.set_position(('center', y_pos)).set_duration(duration)
-        video_clip = CompositeVideoClip([clip, text_clip])
-        audio_clip = AudioFileClip(tts_path)
-        return video_clip.set_audio(audio_clip)
-    except: return None
+            return None
+        if customizations.get('text_color') != "transparent":
+            try:
+                words = customizations['text'].split()
+                chunks = []
+                current_chunk = []
+                for word in words:
+                    current_chunk.append(word)
+                    if len(current_chunk) >= customizations.get('text_words_per_chunk', 5):
+                        chunks.append(' '.join(current_chunk))
+                        current_chunk = []
+                if current_chunk:
+                    chunks.append(' '.join(current_chunk))
+                chunk_duration = audio_duration / len(chunks) if chunks else audio_duration
+                subtitle_clips = []
+                subtitle_y = target_resolution[1] * customizations.get('text_position_y', 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=customizations.get('text_size', 45),
+                        font=customizations.get('text_font', 'Arial-Bold'),
+                        color=customizations.get('text_color', 'white'),
+                        bg_color=customizations.get('bg_color', 'rgba(0, 0, 0, 0.25)'),
+                        method='caption',
+                        align=customizations.get('text_alignment', 'center'),
+                        stroke_width=customizations.get('text_stroke_width', 2),
+                        stroke_color=customizations.get('text_stroke_color', 'white'),
+                        size=(target_resolution[0] * customizations.get('text_width_ratio', 0.8), None)
+                    ).set_start(start_time).set_end(end_time)
+                    txt_clip = txt_clip.set_position((customizations.get('text_alignment', 'center'), subtitle_y))
+                    subtitle_clips.append(txt_clip)
+                clip = CompositeVideoClip([clip] + subtitle_clips)
+            except Exception as sub_error:
+                print(f"Subtitle error: {sub_error}")
+                txt_clip = TextClip(
+                    customizations['text'],
+                    fontsize=customizations.get('text_size', 45),
+                    font=customizations.get('text_font', 'Arial-Bold'),
+                    color=customizations.get('text_color', 'white'),
+                    align=customizations.get('text_alignment', 'center'),
+                    size=(target_resolution[0] * customizations.get('text_width_ratio', 0.8), None)
+                ).set_position((customizations.get('text_alignment', '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:
+        print(f"Error in create_clip: {str(e)}")
+        return None
+
+def fix_imagemagick_policy():
+    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
 
-def generate_editable_script(script_text):
-    elements = parse_script(script_text)
+# ---------------- Gradio Interface Logic ---------------- #
+def generate_initial_clips(user_input, resolution):
+    global TARGET_RESOLUTION, TEMP_FOLDER
+    if resolution == "Full":
+        TARGET_RESOLUTION = (1920, 1080)
+    elif resolution == "Short":
+        TARGET_RESOLUTION = (1080, 1920)
+    else:
+        TARGET_RESOLUTION = (1920, 1080)
+    TEMP_FOLDER = tempfile.mkdtemp()
+    fix_imagemagick_policy()
+    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.")
     paired_elements = []
     for i in range(0, len(elements), 2):
         if i + 1 < len(elements):
-            paired_elements.append({"media_prompt": elements[i]['prompt'], "text": elements[i+1]['text'], "duration": elements[i+1]['duration']})
-    return paired_elements
+            paired_elements.append((elements[i], elements[i + 1]))
+    if not paired_elements:
+        print("No valid script segments found.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None, [], ""
+    clips_data = []
+    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'], TEMP_FOLDER)
+        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'], TEMP_FOLDER)
+        if not tts_path:
+            print(f"Skipping segment {idx+1} due to TTS generation failure.")
+            continue
+        clips_data.append({
+            'media_path': media_asset['path'],
+            'asset_type': media_asset['asset_type'],
+            'tts_path': tts_path,
+            'text': tts_elem['text'],
+            'customizations': {
+                'text_color': '#FFFFFF',
+                'text_size': 45,
+                'text_font': 'Arial-Bold',
+                'text_alignment': 'center',
+                'text_position_y': 0.70,
+                'text_width_ratio': 0.8,
+                'text_words_per_chunk': 5,
+                'text_stroke_width': 2,
+                'text_stroke_color': '#FFFFFF',
+                'bg_color': 'rgba(0, 0, 0, 0.25)',
+                'video_brightness': 1.0,
+                'video_contrast': 1.0,
+                'video_speed': 1.0,
+                'image_brightness': 1.0,
+                'image_contrast': 1.0,
+                'kenburns_effect': 'random',
+                'fade_in_duration': 0.3,
+                'fade_out_duration': 0.3
+            }
+        })
+    if not clips_data:
+        print("No clips were successfully created.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None, [], ""
+    return clips_data, [clip['text'] for clip in clips_data], script
 
-def process_initial_input(prompt, resolution, text_color, bg_color, font_size):
-    global TARGET_RESOLUTION, TEMP_FOLDER
-    TARGET_RESOLUTION = (1920, 1080) if resolution == "Full (16:9)" else (1080, 1920)
-    TEMP_FOLDER = tempfile.mkdtemp()
-    script = generate_script(prompt)
-    if not script: raise gr.Error("Failed to generate script")
-    clips_data = generate_editable_script(script)
-    for clip in clips_data: clip.update({"text_color": text_color, "bg_color": bg_color, "font_size": font_size, "position": "Bottom"})
-    return gr.Column.update(visible=False), gr.Column.update(visible=True), clips_data
+def update_clips(clips_data, text_inputs, media_uploads, global_customizations, per_clip_customizations):
+    for i, (text, upload, per_clip_cust) in enumerate(zip(text_inputs, media_uploads, per_clip_customizations)):
+        if i < len(clips_data):
+            clips_data[i]['text'] = text
+            if upload:
+                media_asset = generate_media(clips_data[i]['customizations']['prompt'] if 'prompt' in clips_data[i]['customizations'] else f"clip_{i}", TEMP_FOLDER, upload)
+                if media_asset:
+                    clips_data[i]['media_path'] = media_asset['path']
+                    clips_data[i]['asset_type'] = media_asset['asset_type']
+            # Update customizations: per-clip overrides global
+            clips_data[i]['customizations'] = {**global_customizations, **per_clip_cust}
+            clips_data[i]['customizations']['text'] = text
+    return clips_data
 
-def generate_final_video(clips_data, bg_music=None, bg_volume=0.1):
-    try:
-        all_clips = []
-        for clip_info in clips_data:
-            media_path = clip_info.get('media')
-            if not media_path: 
-                media_asset = generate_media(clip_info['media_prompt'])
-                media_path = media_asset['path'] if media_asset else None
-            if not media_path: continue
-            tts_path = generate_tts(clip_info['text'], 'en')
-            clip = create_custom_clip(media_path, tts_path, clip_info['text'], clip_info['text_color'], clip_info['bg_color'], clip_info['font_size'], clip_info['position'], clip_info['duration'])
-            if clip: all_clips.append(clip)
-        if not all_clips: raise gr.Error("Failed to create clips")
-        final_video = concatenate_videoclips(all_clips, method="compose")
-        if bg_music: 
-            bg_audio = AudioFileClip(bg_music).volumex(bg_volume)
-            final_video = final_video.set_audio(CompositeAudioClip([final_video.audio, bg_audio]))
-        output_path = os.path.join(TEMP_FOLDER, "final_video.mp4")
-        final_video.write_videofile(output_path, codec='libx264', fps=24, preset='veryfast')
-        return output_path
-    except Exception as e: raise gr.Error(str(e))
-    finally: 
-        if 'final_video' in locals(): final_video.close()
-        shutil.rmtree(TEMP_FOLDER, ignore_errors=True)
+def generate_final_video(clips_data):
+    clips = []
+    for clip_data in clips_data:
+        clip = create_clip(
+            media_path=clip_data['media_path'],
+            asset_type=clip_data['asset_type'],
+            tts_path=clip_data['tts_path'],
+            duration=AudioFileClip(clip_data['tts_path']).duration,
+            customizations=clip_data['customizations'],
+            target_resolution=TARGET_RESOLUTION,
+            temp_folder=TEMP_FOLDER
+        )
+        if clip:
+            clips.append(clip)
+        else:
+            print(f"Clip creation failed for segment.")
+    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=0.08)
+    print(f"Exporting final video to {OUTPUT_VIDEO_FILENAME}...")
+    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=24, preset='veryfast')
+    print(f"Final video saved as {OUTPUT_VIDEO_FILENAME}")
+    print("Cleaning up temporary files...")
+    shutil.rmtree(TEMP_FOLDER)
+    print("Temporary files removed.")
+    return OUTPUT_VIDEO_FILENAME
 
-with gr.Blocks(title="AI Documentary Maker Pro", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 📽️ AI Documentary Maker Pro")
-    with gr.Column(visible=True, elem_id="input_section") as input_section:
+# ---------------- Gradio Interface ---------------- #
+with gr.Blocks() as iface:
+    gr.Markdown("# Highly Customizable AI Video Generator")
+    gr.Markdown("Input a concept, edit AI-generated clips, customize extensively, and generate your video!")
+    
+    # Step 1: Prompt Input and Script Generation
+    with gr.Row():
+        user_input = gr.Textbox(label="Video Concept", placeholder="Enter your video concept here...")
+        resolution = gr.Radio(["Full", "Short"], label="Resolution", value="Full")
+    generate_script_btn = gr.Button("Generate Script and Clips")
+    
+    # Display Generated Script
+    script_output = gr.Textbox(label="Generated Script", interactive=False)
+    
+    # Global Customization Options
+    with gr.Group():
+        gr.Markdown("## Global Customization Options")
         with gr.Row():
-            prompt = gr.Textbox(label="Documentary Topic")
-            resolution = gr.Radio(["Full (16:9)", "Short (9:16)"], label="Aspect Ratio", value="Full (16:9)")
-        with gr.Accordion("Advanced Styling", open=False):
-            with gr.Row():
-                text_color = gr.ColorPicker(label="Text Color", value="#FFFFFF")
-                bg_color = gr.ColorPicker(label="Background", value="#00000000")
-                font_size = gr.Slider(20, 80, value=40, label="Font Size")
-        submit_btn = gr.Button("Generate Script & Preview", variant="primary")
-    with gr.Column(visible=False, elem_id="edit_section") as edit_section:
-        clips_ui = gr.State()
-        clips_group = gr.Column()
-        with gr.Accordion("Background Music", open=False):
-            bg_music = gr.Audio(label="Upload Music", type="filepath")
-            bg_volume = gr.Slider(0, 1, value=0.1, label="Volume")
-        generate_btn = gr.Button("Generate Final Video", variant="primary")
-        video_output = gr.Video(label="Final Video")
-        back_btn = gr.Button("Back to Start")
-
-    submit_btn.click(process_initial_input, [prompt, resolution, text_color, bg_color, font_size], [input_section, edit_section, clips_ui]).then(lambda x: [gr.File(label=f"Clip {i+1} Media") for i, _ in enumerate(x)], clips_ui, clips_group)
-    generate_btn.click(generate_final_video, [clips_ui, bg_music, bg_volume], video_output)
-    back_btn.click(lambda: [gr.Column.update(visible=True), gr.Column.update(visible=False)], outputs=[input_section, edit_section])
+            global_text_color = gr.ColorPicker(label="Text Color", value="#FFFFFF")
+            global_text_size = gr.Slider(20, 100, step=1, label="Text Size", value=45)
+            global_text_font = gr.Dropdown(["Arial-Bold", "Times-Roman", "Courier"], label="Text Font", value="Arial-Bold")
+        with gr.Row():
+            global_text_alignment = gr.Dropdown(["center", "left", "right"], label="Text Alignment", value="center")
+            global_text_position_y = gr.Slider(0.1, 0.9, step=0.05, label="Text Y Position", value=0.70)
+            global_text_width_ratio = gr.Slider(0.5, 1.0, step=0.05, label="Text Width Ratio", value=0.8)
+        with gr.Row():
+            global_text_words_per_chunk = gr.Slider(3, 10, step=1, label="Words per Subtitle Chunk", value=5)
+            global_text_stroke_width = gr.Slider(0, 5, step=1, label="Text Stroke Width", value=2)
+            global_text_stroke_color = gr.ColorPicker(label="Text Stroke Color", value="#FFFFFF")
+        with gr.Row():
+            global_bg_color = gr.ColorPicker(label="Background Color", value="rgba(0, 0, 0, 0.25)")
+            global_video_brightness = gr.Slider(0.5, 1.5, step=0.05, label="Video Brightness", value=1.0)
+            global_video_contrast = gr.Slider(0.5, 1.5, step=0.05, label="Video Contrast", value=1.0)
+        with gr.Row():
+            global_video_speed = gr.Slider(0.5, 2.0, step=0.1, label="Video Speed", value=1.0)
+            global_image_brightness = gr.Slider(0.5, 1.5, step=0.05, label="Image Brightness", value=1.0)
+            global_image_contrast = gr.Slider(0.5, 1.5, step=0.05, label="Image Contrast", value=1.0)
+        with gr.Row():
+            global_kenburns_effect = gr.Dropdown(["random", "zoom-in", "zoom-out", "pan-left", "pan-right", "up-left"], label="Ken Burns Effect", value="random")
+            global_fade_in_duration = gr.Slider(0.1, 1.0, step=0.1, label="Fade In Duration", value=0.3)
+            global_fade_out_duration = gr.Slider(0.1, 1.0, step=0.1, label="Fade Out Duration", value=0.3)
+    
+    # Clip Editing Interface
+    clip_state = gr.State()
+    text_inputs = gr.State([])
+    with gr.Column():
+        gr.Markdown("## Edit Clips")
+        clip_editors = gr.Column()
+    
+    def create_clip_editors(clips_data, text_list, script):
+        if not clips_data:
+            return gr.update(visible=False), clips_data, text_list
+        with clip_editors:
+            editors = []
+            text_inputs_list = []
+            media_uploads_list = []
+            per_clip_customizations = []
+            for i, clip in enumerate(clips_data):
+                with gr.Group():
+                    gr.Markdown(f"### Clip {i+1}: {clip['customizations'].get('prompt', 'Untitled')}")
+                    text_input = gr.Textbox(label="Narration Text", value=clip['text'], interactive=True)
+                    media_upload = gr.File(label="Upload Image/Video (Optional)", type="filepath")
+                    with gr.Accordion("Advanced Customization", open=False):
+                        text_color = gr.ColorPicker(label="Text Color (Override)", value=clip['customizations']['text_color'])
+                        text_size = gr.Slider(20, 100, step=1, label="Text Size (Override)", value=clip['customizations']['text_size'])
+                        text_font = gr.Dropdown(["Arial-Bold", "Times-Roman", "Courier"], label="Text Font (Override)", value=clip['customizations']['text_font'])
+                        text_alignment = gr.Dropdown(["center", "left", "right"], label="Text Alignment (Override)", value=clip['customizations']['text_alignment'])
+                        text_position_y = gr.Slider(0.1, 0.9, step=0.05, label="Text Y Position (Override)", value=clip['customizations']['text_position_y'])
+                        text_width_ratio = gr.Slider(0.5, 1.0, step=0.05, label="Text Width Ratio (Override)", value=clip['customizations']['text_width_ratio'])
+                        text_words_per_chunk = gr.Slider(3, 10, step=1, label="Words per Chunk (Override)", value=clip['customizations']['text_words_per_chunk'])
+                        text_stroke_width = gr.Slider(0, 5, step=1, label="Text Stroke Width (Override)", value=clip['customizations']['text_stroke_width'])
+                        text_stroke_color = gr.ColorPicker(label="Text Stroke Color (Override)", value=clip['customizations']['text_stroke_color'])
+                        bg_color = gr.ColorPicker(label="Background Color (Override)", value=clip['customizations']['bg_color'])
+                        video_brightness = gr.Slider(0.5, 1.5, step=0.05, label="Video Brightness (Override)", value=clip['customizations']['video_brightness'])
+                        video_contrast = gr.Slider(0.5, 1.5, step=0.05, label="Video Contrast (Override)", value=clip['customizations']['video_contrast'])
+                        video_speed = gr.Slider(0.5, 2.0, step=0.1, label="Video Speed (Override)", value=clip['customizations']['video_speed'])
+                        image_brightness = gr.Slider(0.5, 1.5, step=0.05, label="Image Brightness (Override)", value=clip['customizations']['image_brightness'])
+                        image_contrast = gr.Slider(0.5, 1.5, step=0.05, label="Image Contrast (Override)", value=clip['customizations']['image_contrast'])
+                        kenburns_effect = gr.Dropdown(["random", "zoom-in", "zoom-out", "pan-left", "pan-right", "up-left"], label="Ken Burns Effect (Override)", value=clip['customizations']['kenburns_effect'])
+                        fade_in_duration = gr.Slider(0.1, 1.0, step=0.1, label="Fade In Duration (Override)", value=clip['customizations']['fade_in_duration'])
+                        fade_out_duration = gr.Slider(0.1, 1.0, step=0.1, label="Fade Out Duration (Override)", value=clip['customizations']['fade_out_duration'])
+                    editors.append([text_input, media_upload, text_color, text_size, text_font, text_alignment, text_position_y, text_width_ratio, text_words_per_chunk, text_stroke_width, text_stroke_color, bg_color, video_brightness, video_contrast, video_speed, image_brightness, image_contrast, kenburns_effect, fade_in_duration, fade_out_duration])
+                    text_inputs_list.append(text_input)
+                    media_uploads_list.append(media_upload)
+                    per_clip_customizations.append({
+                        'text_color': text_color,
+                        'text_size': text_size,
+                        'text_font': text_font,
+                        'text_alignment': text_alignment,
+                        'text_position_y': text_position_y,
+                        'text_width_ratio': text_width_ratio,
+                        'text_words_per_chunk': text_words_per_chunk,
+                        'text_stroke_width': text_stroke_width,
+                        'text_stroke_color': text_stroke_color,
+                        'bg_color': bg_color,
+                        'video_brightness': video_brightness,
+                        'video_contrast': video_contrast,
+                        'video_speed': video_speed,
+                        'image_brightness': image_brightness,
+                        'image_contrast': image_contrast,
+                        'kenburns_effect': kenburns_effect,
+                        'fade_in_duration': fade_in_duration,
+                        'fade_out_duration': fade_out_duration
+                    })
+            return gr.update(visible=True), clips_data, text_inputs_list
+        return gr.update(visible=False), clips_data, text_list
+    
+    generate_script_btn.click(
+        fn=generate_initial_clips,
+        inputs=[user_input, resolution],
+        outputs=[clip_state, text_inputs, script_output]
+    ).then(
+        fn=create_clip_editors,
+        inputs=[clip_state, text_inputs, script_output],
+        outputs=[clip_editors, clip_state, text_inputs]
+    )
+    
+    # Generate Video Button
+    generate_video_btn = gr.Button("Generate Final Video")
+    video_output = gr.Video(label="Generated Video")
+    
+    def gather_inputs_and_generate(clips_data, *args):
+        text_inputs = args[:len(clips_data)]
+        media_uploads = args[len(clips_data):2*len(clips_data)]
+        per_clip_cust_inputs = args[2*len(clips_data):2*len(clips_data) + 18*len(clips_data)]
+        global_cust_inputs = args[2*len(clips_data) + 18*len(clips_data):]
+        per_clip_customizations = []
+        for i in range(len(clips_data)):
+            start_idx = i * 18
+            per_clip_customizations.append({
+                'text_color': per_clip_cust_inputs[start_idx],
+                'text_size': per_clip_cust_inputs[start_idx + 1],
+                'text_font': per_clip_cust_inputs[start_idx + 2],
+                'text_alignment': per_clip_cust_inputs[start_idx + 3],
+                'text_position_y': per_clip_cust_inputs[start_idx + 4],
+                'text_width_ratio': per_clip_cust_inputs[start_idx + 5],
+                'text_words_per_chunk': per_clip_cust_inputs[start_idx + 6],
+                'text_stroke_width': per_clip_cust_inputs[start_idx + 7],
+                'text_stroke_color': per_clip_cust_inputs[start_idx + 8],
+                'bg_color': per_clip_cust_inputs[start_idx + 9],
+                'video_brightness': per_clip_cust_inputs[start_idx + 10],
+                'video_contrast': per_clip_cust_inputs[start_idx + 11],
+                'video_speed': per_clip_cust_inputs[start_idx + 12],
+                'image_brightness': per_clip_cust_inputs[start_idx + 13],
+                'image_contrast': per_clip_cust_inputs[start_idx + 14],
+                'kenburns_effect': per_clip_cust_inputs[start_idx + 15],
+                'fade_in_duration': per_clip_cust_inputs[start_idx + 16],
+                'fade_out_duration': per_clip_cust_inputs[start_idx + 17]
+            })
+        global_customizations = {
+            'text_color': global_cust_inputs[0],
+            'text_size': global_cust_inputs[1],
+            'text_font': global_cust_inputs[2],
+            'text_alignment': global_cust_inputs[3],
+            'text_position_y': global_cust_inputs[4],
+            'text_width_ratio': global_cust_inputs[5],
+            'text_words_per_chunk': global_cust_inputs[6],
+            'text_stroke_width': global_cust_inputs[7],
+            'text_stroke_color': global_cust_inputs[8],
+            'bg_color': global_cust_inputs[9],
+            'video_brightness': global_cust_inputs[10],
+            'video_contrast': global_cust_inputs[11],
+            'video_speed': global_cust_inputs[12],
+            'image_brightness': global_cust_inputs[13],
+            'image_contrast': global_cust_inputs[14],
+            'kenburns_effect': global_cust_inputs[15],
+            'fade_in_duration': global_cust_inputs[16],
+            'fade_out_duration': global_cust_inputs[17]
+        }
+        updated_clips = update_clips(clips_data, text_inputs, media_uploads, global_customizations, per_clip_customizations)
+        return generate_final_video(updated_clips)
+    
+    generate_video_btn.click(
+        fn=gather_inputs_and_generate,
+        inputs=[clip_state] + text_inputs.value + [gr.File(type="filepath")] * len(text_inputs.value) + [gr.ColorPicker(), gr.Slider(), gr.Dropdown(), gr.Dropdown(), gr.Slider(), gr.Slider(), gr.Slider(), gr.Slider(), gr.ColorPicker(), gr.ColorPicker(), gr.Slider(), gr.Slider(), gr.Slider(), gr.Slider(), gr.Slider(), gr.Dropdown(), gr.Slider(), gr.Slider()] * len(text_inputs.value) + [global_text_color, global_text_size, global_text_font, global_text_alignment, global_text_position_y, global_text_width_ratio, global_text_words_per_chunk, global_text_stroke_width, global_text_stroke_color, global_bg_color, global_video_brightness, global_video_contrast, global_video_speed, global_image_brightness, global_image_contrast, global_kenburns_effect, global_fade_in_duration, global_fade_out_duration],
+        outputs=video_output
+    )
 
-if __name__ == "__main__":
-    demo.launch(share=True)
+iface.launch(share=True)