app.py

"""
Full Code: Orbit Video Engine with Dynamic Clip Editor and Video Output Download

This script implements a Gradio Blocks UI that:
  1. Accepts a video topic or a full script.
  2. Generates a documentary-style script using an AI API.
  3. Parses the script into clip data.
  4. Dynamically creates an editor for each clip, where users can:
      - Edit the visual prompt.
      - Edit the TTS (narration) text.
      - Upload their own image/video to override the generated media.
  5. Provides video settings (resolution, render speed, clip preferences, background music, subtitle settings).
  6. Renders the video and displays it so you can preview it and download the final MP4 file.
  
Make sure you have all required dependencies installed.
"""

# ------------------- IMPORTS -------------------
from kokoro import KPipeline
import soundfile as sf
import torch
import os, time, random, math, json, tempfile, shutil, re, requests
from moviepy.editor import (VideoFileClip, AudioFileClip, ImageClip, concatenate_videoclips,
                            CompositeVideoClip, TextClip, CompositeAudioClip)
import moviepy.video.fx.all as vfx
import moviepy.config as mpy_config
from pydub import AudioSegment
from PIL import Image
import numpy as np
from bs4 import BeautifulSoup
from urllib.parse import quote
import pysrt
from gtts import gTTS
import cv2
import gradio as gr

# ------------------- GLOBAL CONFIGURATION -------------------
pipeline = KPipeline(lang_code='a')  # American English voice (uses 'af_heart')
mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})

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 Chrome/91.0.4472.124 Safari/537.36"

# These globals will be set for each run
TARGET_RESOLUTION = None
CAPTION_COLOR = None
TEMP_FOLDER = None

# ------------------- HELPER FUNCTIONS -------------------

def generate_script(user_input):
    """Generate a documentary script using the OpenRouter API."""
    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 an 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:
            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

def parse_script(script_text):
    """
    Parse the generated script into a list of elements.
    Each clip (segment) is represented as a pair of elements:
      - A media element with a 'prompt'
      - A TTS element with narration text and duration
    """
    sections = {}
    current_title = None
    current_text = ""
    try:
        for line in script_text.splitlines():
            line = line.strip()
            if line.startswith("[") and "]" in line:
                bracket_start = line.find("[")
                bracket_end = line.find("]", bracket_start)
                if bracket_start != -1 and bracket_end != -1:
                    if current_title is not None:
                        sections[current_title] = current_text.strip()
                    current_title = line[bracket_start+1:bracket_end]
                    current_text = line[bracket_end+1:].strip()
            elif current_title:
                current_text += line + " "
        if current_title:
            sections[current_title] = current_text.strip()
        elements = []
        for title, narration in sections.items():
            if not title or not narration:
                continue
            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):
    """Search for a video on Pexels by query and return a random HD video link."""
    headers = {'Authorization': pexels_api_key}
    base_url = "https://api.pexels.com/videos/search"
    num_pages = 3
    videos_per_page = 15
    max_retries = 3
    retry_delay = 1
    search_query = query
    all_videos = []
    for page in range(1, num_pages + 1):
        for attempt in range(max_retries):
            try:
                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...")
                    time.sleep(retry_delay)
                    retry_delay *= 2
                else:
                    print(f"Error fetching videos: {response.status_code} {response.text}")
                    if attempt < max_retries - 1:
                        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:
                    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.")
        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"}
    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...")
                time.sleep(retry_delay)
                retry_delay *= 2
            else:
                print(f"Error fetching images: {response.status_code} {response.text}")
                if attempt < max_retries - 1:
                    time.sleep(retry_delay)
                    retry_delay *= 2
        except requests.exceptions.RequestException as e:
            print(f"Request exception: {e}")
            if attempt < max_retries - 1:
                time.sleep(retry_delay)
                retry_delay *= 2
    print(f"No Pexels images found for query: {query}")
    return None

def search_google_images(query):
    """Search for images on Google Images (useful for news-like queries)."""
    try:
        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch"
        headers = {"User-Agent": USER_AGENT}
        response = requests.get(search_url, headers=headers, timeout=10)
        soup = BeautifulSoup(response.text, "html.parser")
        img_tags = soup.find_all("img")
        image_urls = []
        for img in img_tags:
            src = img.get("src", "")
            if src.startswith("http") and "gstatic" not in src:
                image_urls.append(src)
        if image_urls:
            return random.choice(image_urls[:5]) if len(image_urls) >= 5 else image_urls[0]
        else:
            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):
    """Download an image from a URL to a local file and verify it."""
    try:
        headers = {"User-Agent": USER_AGENT}
        print(f"Downloading image from: {image_url}")
        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)
        print(f"Image downloaded to: {filename}")
        try:
            img = Image.open(filename)
            img.verify()
            img = Image.open(filename)
            if img.mode != 'RGB':
                img = img.convert('RGB')
                img.save(filename)
            return filename
        except Exception as e_validate:
            print(f"Invalid image file: {e_validate}")
            if os.path.exists(filename):
                os.remove(filename)
            return None
    except Exception as e:
        print(f"Image download error: {e}")
        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)
        return filename
    except Exception as e:
        print(f"Video download error: {e}")
        if os.path.exists(filename):
            os.remove(filename)
        return None

def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
    """
    Generate a visual asset for the clip.
    If a user_image (custom media) is provided, it is used directly.
    Otherwise, use Pexels (or Google Images for news queries) with fallbacks.
    """
    safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
    if user_image is not None:
        print(f"Using custom media for prompt: {prompt}")
        return {"path": user_image, "asset_type": "image"}
    if "news" in prompt.lower():
        image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_news.jpg")
        image_url = search_google_images(prompt)
        if image_url:
            downloaded_image = download_image(image_url, image_file)
            if downloaded_image:
                return {"path": downloaded_image, "asset_type": "image"}
    if random.random() < 0.25:
        video_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_video.mp4")
        video_url = search_pexels_videos(prompt, PEXELS_API_KEY)
        if video_url:
            downloaded_video = download_video(video_url, video_file)
            if downloaded_video:
                return {"path": downloaded_video, "asset_type": "video"}
    image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}.jpg")
    image_url = search_pexels_images(prompt, PEXELS_API_KEY)
    if image_url:
        downloaded_image = download_image(image_url, image_file)
        if downloaded_image:
            return {"path": downloaded_image, "asset_type": "image"}
    fallback_terms = ["nature", "people", "landscape", "technology", "business"]
    for term in fallback_terms:
        fallback_file = os.path.join(TEMP_FOLDER, f"fallback_{term}.jpg")
        fallback_url = search_pexels_images(term, PEXELS_API_KEY)
        if fallback_url:
            downloaded_fallback = download_image(fallback_url, fallback_file)
            if downloaded_fallback:
                return {"path": downloaded_fallback, "asset_type": "image"}
    print(f"Failed to generate asset for prompt: {prompt}")
    return None

def generate_silent_audio(duration, sample_rate=24000):
    """Generate a silent WAV audio file of given duration."""
    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)
    return silent_path

def generate_tts(text, voice):
    """Generate TTS audio using Kokoro with fallback 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")
    if os.path.exists(file_path):
        return file_path
    try:
        kokoro_voice = 'af_heart' if voice == 'en' else voice
        generator = pipeline(text, voice=kokoro_voice, speed=0.9, split_pattern=r'\n+')
        audio_segments = []
        for i, (gs, ps, audio) in enumerate(generator):
            audio_segments.append(audio)
        full_audio = np.concatenate(audio_segments) if len(audio_segments) > 1 else audio_segments[0]
        sf.write(file_path, full_audio, 24000)
        return file_path
    except Exception as e:
        try:
            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)
            return file_path
        except Exception as 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 Ken Burns effect to the clip (used for images)."""
    target_w, target_h = target_resolution
    clip_aspect = clip.w / clip.h
    target_aspect = target_w / target_h
    if clip_aspect > target_aspect:
        new_height = target_h
        new_width = int(new_height * clip_aspect)
    else:
        new_width = target_w
        new_height = int(new_width / clip_aspect)
    clip = clip.resize(newsize=(new_width, new_height))
    base_scale = 1.15
    new_width = int(new_width * base_scale)
    new_height = int(new_height * base_scale)
    clip = clip.resize(newsize=(new_width, new_height))
    max_offset_x = new_width - target_w
    max_offset_y = new_height - target_h
    available_effects = ["zoom-in", "zoom-out", "pan-left", "pan-right", "up-left"]
    if effect_type is None or effect_type == "random":
        effect_type = random.choice(available_effects)
    if effect_type == "zoom-in":
        start_zoom = 0.9; end_zoom = 1.1; start_center = (new_width/2, new_height/2); end_center = start_center
    elif effect_type == "zoom-out":
        start_zoom = 1.1; end_zoom = 0.9; start_center = (new_width/2, new_height/2); end_center = start_center
    elif effect_type == "pan-left":
        start_zoom = 1.0; end_zoom = 1.0; start_center = (max_offset_x+target_w/2, (max_offset_y//2)+target_h/2); end_center = (target_w/2, (max_offset_y//2)+target_h/2)
    elif effect_type == "pan-right":
        start_zoom = 1.0; end_zoom = 1.0; start_center = (target_w/2, (max_offset_y//2)+target_h/2); end_center = (max_offset_x+target_w/2, (max_offset_y//2)+target_h/2)
    elif effect_type == "up-left":
        start_zoom = 1.0; end_zoom = 1.0; start_center = (max_offset_x+target_w/2, max_offset_y+target_h/2); end_center = (target_w/2, target_h/2)
    else:
        raise ValueError(f"Unsupported effect: {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."""
    target_w, target_h = target_resolution
    clip_aspect = clip.w / clip.h
    target_aspect = target_w / target_h
    if clip_aspect > target_aspect:
        clip = clip.resize(height=target_h)
        crop_amount = (clip.w - target_w) / 2
        clip = clip.crop(x1=crop_amount, x2=clip.w - crop_amount, y1=0, y2=clip.h)
    else:
        clip = clip.resize(width=target_w)
        crop_amount = (clip.h - target_h) / 2
        clip = clip.crop(x1=0, x2=clip.w, y1=crop_amount, y2=clip.h - crop_amount)
    return clip

def find_mp3_files():
    """Search for an MP3 file in the current directory (for background music)."""
    mp3_files = []
    for root, dirs, files in os.walk('.'):
        for file in files:
            if file.endswith('.mp3'):
                mp3_files.append(os.path.join(root, file))
    return mp3_files[0] if mp3_files else None

def add_background_music(final_video, bg_music_volume=0.08):
    """Add background music to the final video if an MP3 file is found."""
    try:
        bg_music_path = find_mp3_files()
        if bg_music_path and os.path.exists(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_videoclips(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)
        return final_video
    except Exception as e:
        print(f"Error adding background music: {e}")
        return final_video

def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, narration_text=None, segment_index=0):
    """Create a video clip from a media asset and TTS audio, and add subtitles if enabled."""
    try:
        if not os.path.exists(media_path) or not os.path.exists(tts_path):
            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 < target_duration:
                clip = clip.loop(duration=target_duration)
            else:
                clip = clip.subclip(0, target_duration)
        elif asset_type == "image":
            img = Image.open(media_path)
            if img.mode != 'RGB':
                with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as temp:
                    img.convert('RGB').save(temp.name)
                    media_path = temp.name
                img.close()
            clip = ImageClip(media_path).set_duration(target_duration)
            clip = apply_kenburns_effect(clip, TARGET_RESOLUTION)
            clip = clip.fadein(0.3).fadeout(0.3)
        else:
            return None
        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)
                for i, chunk_text in enumerate(chunks):
                    start_time = i * chunk_duration
                    end_time = (i + 1) * chunk_duration
                    txt_clip = TextClip(
                        chunk_text,
                        fontsize=45,
                        font='Arial-Bold',
                        color=CAPTION_COLOR,
                        bg_color='rgba(0, 0, 0, 0.25)',
                        method='caption',
                        align='center',
                        stroke_width=2,
                        stroke_color=CAPTION_COLOR,
                        size=(TARGET_RESOLUTION[0] * 0.8, None)
                    ).set_start(start_time).set_end(end_time)
                    txt_clip = txt_clip.set_position(('center', subtitle_y_position))
                    subtitle_clips.append(txt_clip)
                clip = CompositeVideoClip([clip] + subtitle_clips)
            except Exception as sub_error:
                txt_clip = TextClip(
                    narration_text,
                    fontsize=28,
                    color=CAPTION_COLOR,
                    align='center',
                    size=(TARGET_RESOLUTION[0] * 0.7, None)
                ).set_position(('center', int(TARGET_RESOLUTION[1] / 3))).set_duration(clip.duration)
                clip = CompositeVideoClip([clip, txt_clip])
        clip = clip.set_audio(audio_clip)
        return clip
    except Exception as e:
        print(f"Error in create_clip: {str(e)}")
        return None

def fix_imagemagick_policy():
    """Attempt to modify ImageMagick security policies if needed."""
    try:
        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:
            return False
        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}")
        return True
    except Exception as e:
        return False

def generate_video(user_input, resolution, caption_option):
    """
    Original video generation function.
    This version uses the generated script to create video clips.
    (Integration with custom clip edits could be extended further.)
    """
    global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
    if resolution == "Full HD (1920x1080)":
        TARGET_RESOLUTION = (1920, 1080)
    elif resolution == "Short (1080x1920)":
        TARGET_RESOLUTION = (1080, 1920)
    else:
        TARGET_RESOLUTION = (1920, 1080)
    CAPTION_COLOR = "white" if caption_option == "Yes" else "transparent"
    TEMP_FOLDER = tempfile.mkdtemp()
    fix_imagemagick_policy()
    print("Generating script from API...")
    script = generate_script(user_input)
    if not script:
        shutil.rmtree(TEMP_FOLDER)
        return None
    print("Generated Script:\n", script)
    elements = parse_script(script)
    if not elements:
        shutil.rmtree(TEMP_FOLDER)
        return None
    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:
        shutil.rmtree(TEMP_FOLDER)
        return None
    clips = []
    for idx, (media_elem, tts_elem) in enumerate(paired_elements):
        print(f"Processing segment {idx+1} with prompt: '{media_elem['prompt']}'")
        media_asset = generate_media(media_elem['prompt'])
        if not media_asset:
            continue
        tts_path = generate_tts(tts_elem['text'], tts_elem['voice'])
        if not tts_path:
            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)
    if not clips:
        shutil.rmtree(TEMP_FOLDER)
        return None
    final_video = concatenate_videoclips(clips, method="compose")
    final_video = add_background_music(final_video, bg_music_volume=0.08)
    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=24, preset='veryfast')
    shutil.rmtree(TEMP_FOLDER)
    return OUTPUT_VIDEO_FILENAME

# ------------------- NEW CALLBACKS FOR THE ADVANCED UI -------------------

# Global variable to store clip data from the script generation.
generated_clip_data = []

def generate_script_clips(topic_input, full_script):
    """
    Callback when "📝 Generate Script & Load Clips" is clicked.
    Uses the full_script if provided; otherwise, generates based on the topic.
    Returns the raw generated script and a JSON string containing the clip data.
    """
    input_text = full_script if full_script.strip() != "" else topic_input
    script = generate_script(input_text)
    if not script:
        return "Error: failed to generate script", "{}"
    elements = parse_script(script)
    clip_list = []
    for i in range(0, len(elements), 2):
        if i + 1 < len(elements):
            media_elem = elements[i]
            tts_elem = elements[i+1]
            clip_info = {
                "prompt": media_elem.get("prompt", ""),
                "narration": tts_elem.get("text", ""),
                "custom_media": ""  # initially empty; user may upload a file later
            }
            clip_list.append(clip_info)
    global generated_clip_data
    generated_clip_data = clip_list
    return script, json.dumps(clip_list)

def update_clip_editor(clip_json):
    """
    Dynamically build a UI editor for each clip.
    Each editor contains:
       - A textbox to edit the visual prompt.
       - A textbox to edit the TTS text.
       - A File uploader to allow custom media upload.
    Returns a list of dynamically generated Accordions.
    """
    clip_list = json.loads(clip_json)
    editors = []
    # Create a container for all clip editors.
    for idx, clip in enumerate(clip_list, start=1):
        with gr.Accordion(label=f"Clip {idx}: {clip['prompt']}", open=(idx<=2)) as acc:
            prompt_box = gr.Textbox(label="Visual Prompt", value=clip["prompt"])
            tts_box = gr.Textbox(label="TTS Text", value=clip["narration"], lines=3)
            custom_media_box = gr.File(label="Upload custom image/video", file_types=[".jpg", ".png", ".mp4"])
            # Pack values in a dictionary and return them later (here we simply display the components).
            # In a full integration you could use additional state to track these values.
            editors.append(acc)
    return editors

def generate_final_video(topic_input, full_script, clip_data_json, resolution, render_speed,
                         video_clip_percent, zoom_pan, bg_music_file, bg_music_volume,
                         subtitle_enabled, font_dropdown, font_size, outline_width,
                         font_color, outline_color, subtitle_position):
    """
    Callback when "🎬 Generate Video" is clicked.
    In a full implementation you would update each clip from the dynamic editors.
    Here, for demonstration purposes, we simply call the original generate_video function.
    The final video file is returned and used both for preview and download.
    """
    print("Final settings:")
    print(f"Resolution: {resolution}, Render Speed: {render_speed}, Video Clip %: {video_clip_percent}, Zoom/Pan: {zoom_pan}")
    if bg_music_file is not None:
        print("Custom background music provided.")
    video_file = generate_video(topic_input, resolution, "Yes")
    # Return the file path for both the video preview and the download component.
    return video_file, video_file

# ------------------- GRADIO BLOCKS UI -------------------
with gr.Blocks(title="🚀 Orbit Video Engine") as demo:
    with gr.Row():
        # Column 1: Content Input & Script Generation
        with gr.Column(scale=1):
            gr.Markdown("## 1. Content Input")
            topic_input = gr.Textbox(label="Topic Input", placeholder="Enter your video topic here...")
            full_script = gr.Textbox(label="Or Paste Full Script", placeholder="Paste full script (using [Title] etc.)", lines=5)
            generate_script_btn = gr.Button("📝 Generate Script & Load Clips")
            generated_script_disp = gr.Textbox(label="Generated Script", interactive=False, visible=False)
            # Hidden storage for clip JSON data
            clip_data_storage = gr.Textbox(visible=False)
        # Column 2: Dynamic Clip Editor
        with gr.Column(scale=1):
            gr.Markdown("## 2. Edit Clips")
            gr.Markdown("Modify each clip's Visual Prompt, TTS Text or upload your own media.")
            clip_editor_container = gr.Column(visible=False)
        # Column 3: Video Settings & Output
        with gr.Column(scale=1):
            gr.Markdown("## 3. Video Settings")
            resolution = gr.Radio(choices=["Short (1080x1920)", "Full HD (1920x1080)"],
                                  label="Resolution", value="Full HD (1920x1080)")
            render_speed = gr.Dropdown(choices=["ultrafast", "veryfast", "fast", "medium", "slow", "veryslow"],
                                       label="Render Speed", value="fast")
            video_clip_percent = gr.Slider(0, 100, step=5, label="Video Clip Percentage", value=25)
            zoom_pan = gr.Checkbox(label="Add Zoom/Pan Effect (Images)", value=True)
            with gr.Accordion("Background Music", open=False):
                bg_music_file = gr.File(label="Upload Background Music (MP3)", file_types=[".mp3"])
                bg_music_volume = gr.Slider(0.0, 1.0, step=0.05, label="BGM Volume", value=0.15)
            with gr.Accordion("Subtitle Settings", open=True):
                subtitle_enabled = gr.Checkbox(label="Enable Subtitles", value=True)
                font_dropdown = gr.Dropdown(choices=["Impact", "Arial", "Helvetica", "Times New Roman"],
                                            label="Font", value="Arial")
                font_size = gr.Number(label="Font Size", value=45)
                outline_width = gr.Number(label="Outline Width", value=2)
                font_color = gr.ColorPicker(label="Font Color", value="#FFFFFF")
                outline_color = gr.ColorPicker(label="Outline Color", value="#000000")
                subtitle_position = gr.Radio(choices=["center", "bottom", "top"], label="Subtitle Position", value="center")
            gr.Markdown("## 4. Output")
            generate_video_btn = gr.Button("🎬 Generate Video")
            # Two outputs: one for video preview, one for file download
            video_preview = gr.Video(label="Generated Video")
            download_video_file = gr.File(label="Download Video", interactive=False)
    
    # ------------------- INTERACTIONS -------------------
    # When "Generate Script & Load Clips" is clicked:
    generate_script_btn.click(
        fn=generate_script_clips,
        inputs=[topic_input, full_script],
        outputs=[generated_script_disp, clip_data_storage]
    ).then(
        fn=lambda script: gr.update(visible=True),
        inputs=[generated_script_disp],
        outputs=[generated_script_disp]
    ).then(
        fn=update_clip_editor,
        inputs=[clip_data_storage],
        outputs=[clip_editor_container]
    ).then(
        fn=lambda _: gr.update(visible=True),
        inputs=[clip_editor_container],
        outputs=[clip_editor_container]
    )
    
    # When "Generate Video" is clicked, call the video generation callback.
    generate_video_btn.click(
        fn=generate_final_video,
        inputs=[topic_input, full_script, clip_data_storage, resolution, render_speed,
                video_clip_percent, zoom_pan, bg_music_file, bg_music_volume,
                subtitle_enabled, font_dropdown, font_size, outline_width, font_color, outline_color, subtitle_position],
        outputs=[video_preview, download_video_file]
    )

demo.launch(share=True)