app.py

import os
import re
import uuid
import json
import time
import random
import shutil
import requests
import asyncio
import gradio as gr
from pathlib import Path
import edge_tts
from gtts import gTTS
import numpy as np
import g4f
from g4f.client import Client
import assemblyai as aai
from moviepy.editor import *
from moviepy.video.fx.all import crop
from moviepy.audio.fx.all import volumex
from concurrent.futures import ThreadPoolExecutor

# Constants
TEMP_DIR = Path("temp")
OUTPUT_DIR = Path("output")
MUSIC_DIR = Path("music")

# Ensure directories exist
TEMP_DIR.mkdir(exist_ok=True)
OUTPUT_DIR.mkdir(exist_ok=True)
MUSIC_DIR.mkdir(exist_ok=True)

# Add a sample music file if none exists
if not list(MUSIC_DIR.glob("*.mp3")):
    # Create a simple silent audio file as placeholder
    silent_clip = AudioClip(lambda t: 0, duration=10)
    silent_clip.write_audiofile(MUSIC_DIR / "silence.mp3", fps=44100)

# Utility functions
def info(msg):
    return gr.Info(msg)

def warning(msg):
    return gr.Warning(msg)

def error(msg):
    return gr.Error(msg)

def generate_id():
    return str(uuid.uuid4())

def choose_random_music():
    music_files = list(MUSIC_DIR.glob("*.mp3"))
    if not music_files:
        return MUSIC_DIR / "silence.mp3"
    return random.choice(music_files)

def parse_model(model_name):
    """Parse model name for g4f"""
    if model_name == "gpt-4":
        return g4f.models.gpt_4
    elif model_name == "gpt-3.5-turbo":
        return g4f.models.gpt_35_turbo
    else:
        return model_name

class YouTubeGenerator:
    def __init__(self):
        self.reset()
    
    def reset(self):
        """Reset all generation state"""
        self.subject = ""
        self.script = ""
        self.metadata = {"title": "", "description": ""}
        self.image_prompts = []
        self.images = []
        self.tts_path = ""
        self.video_path = ""
    
    def clean_temp_files(self, keep_video=False):
        """Clean temporary files except final video if requested"""
        for img in self.images:
            if os.path.exists(img):
                os.remove(img)
        
        if self.tts_path and os.path.exists(self.tts_path):
            os.remove(self.tts_path)
            
        if not keep_video and self.video_path and os.path.exists(self.video_path):
            os.remove(self.video_path)
    
    def generate_response(self, prompt, model="gpt-4"):
        """Generate response using G4F"""
        try:
            response = g4f.ChatCompletion.create(
                model=parse_model(model),
                messages=[{"role": "user", "content": prompt}]
            )
            return response
        except Exception as e:
            error(f"Error generating response: {str(e)}")
            return ""

    def generate_topic(self, niche):
        """Generate a topic based on the niche"""
        prompt = f"Please generate a specific video idea that takes about the following topic: {niche}. Make it exactly one sentence. Only return the topic, nothing else."
        completion = self.generate_response(prompt)
        
        if not completion:
            raise ValueError("Failed to generate topic")
            
        self.subject = completion
        return completion

    def generate_script(self, subject, language):
        """Generate video script based on subject"""
        prompt = f"""
        Generate a script for youtube shorts video, depending on the subject of the video.

        The script is to be returned as a string with the specified number of paragraphs.

        Here is an example of a string:
        "This is an example string."

        Do not under any circumstance reference this prompt in your response.

        Get straight to the point, don't start with unnecessary things like, "welcome to this video".

        Obviously, the script should be related to the subject of the video.
        
        YOU MUST NOT INCLUDE ANY TYPE OF MARKDOWN OR FORMATTING IN THE SCRIPT, NEVER USE A TITLE.
        YOU MUST WRITE THE SCRIPT IN THE LANGUAGE SPECIFIED IN [LANGUAGE].
        ONLY RETURN THE RAW CONTENT OF THE SCRIPT. DO NOT INCLUDE "VOICEOVER", "NARRATOR" OR SIMILAR INDICATORS OF WHAT SHOULD BE SPOKEN AT THE BEGINNING OF EACH PARAGRAPH OR LINE. YOU MUST NOT MENTION THE PROMPT, OR ANYTHING ABOUT THE SCRIPT ITSELF. ALSO, NEVER TALK ABOUT THE AMOUNT OF PARAGRAPHS OR LINES. JUST WRITE THE SCRIPT
        
        Subject: {subject}
        Language: {language}
        """
        completion = self.generate_response(prompt)
        
        # Apply regex to remove *
        completion = re.sub(r"\*", "", completion)
        
        if not completion:
            raise ValueError("The generated script is empty")
        
        if len(completion) > 5000:
            raise ValueError("Generated script is too long (>5000 chars)")
        
        self.script = completion
        return completion

    def generate_metadata(self, subject):
        """Generate title and description"""
        title_prompt = f"Please generate a YouTube Video Title for the following subject, including hashtags: {subject}. Only return the title, nothing else. Limit the title under 100 characters."
        title = self.generate_response(title_prompt)
        
        if len(title) > 100:
            title = title[:97] + "..."
        
        desc_prompt = f"Please generate a YouTube Video Description for the following script: {self.script}. Only return the description, nothing else."
        description = self.generate_response(desc_prompt)
        
        self.metadata = {
            "title": title,
            "description": description
        }
        
        return self.metadata

    def generate_prompts(self, subject, script):
        """Generate image prompts for the script"""
        n_prompts = 5
        prompt = f"""
        Generate {n_prompts} Image Prompts for AI Image Generation,
        depending on the subject of a video.
        Subject: {subject}

        The image prompts are to be returned as
        a JSON-Array of strings.

        Each search term should consist of a full sentence,
        always add the main subject of the video.

        Be emotional and use interesting adjectives to make the
        Image Prompt as detailed as possible.
        
        YOU MUST ONLY RETURN THE JSON-ARRAY OF STRINGS.
        YOU MUST NOT RETURN ANYTHING ELSE. 
        YOU MUST NOT RETURN THE SCRIPT.
        
        The search terms must be related to the subject of the video.
        Here is an example of a JSON-Array of strings:
        ["image prompt 1", "image prompt 2", "image prompt 3"]

        For context, here is the full text:
        {script}
        """
        
        completion = str(self.generate_response(prompt, model="gpt-4"))
        completion = completion.replace("```json", "").replace("```", "")
        
        image_prompts = []
        
        try:
            # First try to parse as JSON directly
            image_prompts = json.loads(completion)
            if isinstance(image_prompts, dict) and "image_prompts" in image_prompts:
                image_prompts = image_prompts["image_prompts"]
        except Exception:
            # If that fails, try to extract array from the text
            try:
                # Get everything between [ and ], and turn it into a list
                r = re.compile(r"\[.*\]", re.DOTALL)
                matches = r.findall(completion)
                if matches:
                    image_prompts = json.loads(matches[0])
            except Exception as e:
                raise ValueError(f"Failed to parse image prompts: {str(e)}")
        
        # Ensure we have prompts and they're in the right format
        if not image_prompts or not isinstance(image_prompts, list):
            raise ValueError("No valid image prompts were generated")
            
        # Limit to 5 prompts
        image_prompts = image_prompts[:5]
        
        self.image_prompts = image_prompts
        return image_prompts

    def generate_image(self, prompt, provider="g4f", model="sdxl-turbo"):
        """Generate an image using the specified provider"""
        try:
            if provider == "g4f":
                client = Client()
                response = client.images.generate(
                    model=model,
                    prompt=prompt,
                    response_format="url"
                )
                
                if response and response.data and len(response.data) > 0:
                    image_url = response.data[0].url
                    image_response = requests.get(image_url)
                    
                    if image_response.status_code == 200:
                        image_path = str(TEMP_DIR / f"{generate_id()}.png")
                        with open(image_path, "wb") as f:
                            f.write(image_response.content)
                        self.images.append(image_path)
                        return image_path
                    
                raise ValueError(f"Failed to download image from {image_url}")
                        
            elif provider == "prodia":
                s = requests.Session()
                headers = {
                    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
                }
                
                # Generate job
                resp = s.get(
                    "https://api.prodia.com/generate",
                    params={
                        "new": "true",
                        "prompt": prompt,
                        "model": model,
                        "negative_prompt": "verybadimagenegative_v1.3",
                        "steps": "20",
                        "cfg": "7",
                        "seed": random.randint(1, 10000),
                        "sample": "DPM++ 2M Karras",
                        "aspect_ratio": "square"
                    },
                    headers=headers
                )
                
                job_id = resp.json().get('job')
                if not job_id:
                    raise ValueError("Failed to get job ID from Prodia")
                
                # Wait for job to complete
                for _ in range(30):  # Timeout after 30 attempts (150 seconds)
                    time.sleep(5)
                    status = s.get(f"https://api.prodia.com/job/{job_id}", headers=headers).json()
                    if status.get("status") == "succeeded":
                        img_data = s.get(f"https://images.prodia.xyz/{job_id}.png?download=1", headers=headers).content
                        image_path = str(TEMP_DIR / f"{generate_id()}.png")
                        with open(image_path, "wb") as f:
                            f.write(img_data)
                        self.images.append(image_path)
                        return image_path
                
                raise ValueError("Prodia image generation timed out")
                
            elif provider == "pollinations":
                response = requests.get(f"https://image.pollinations.ai/prompt/{prompt}{random.randint(1,10000)}")
                if response.status_code == 200:
                    image_path = str(TEMP_DIR / f"{generate_id()}.png")
                    with open(image_path, "wb") as f:
                        f.write(response.content)
                    self.images.append(image_path)
                    return image_path
                else:
                    raise ValueError(f"Pollinations request failed: {response.status_code}")
                    
            else:
                raise ValueError(f"Unsupported image provider: {provider}")
                
        except Exception as e:
            raise ValueError(f"Image generation failed: {str(e)}")

    async def generate_edge_tts(self, text, voice):
        """Generate speech using Edge TTS"""
        try:
            audio_path = str(TEMP_DIR / f"{generate_id()}.mp3")
            communicate = edge_tts.Communicate(text, voice)
            await communicate.save(audio_path)
            self.tts_path = audio_path
            return audio_path
        except Exception as e:
            # Try an alternative voice if the specified one fails
            try:
                fallback_voice = "en-US-ChristopherNeural"
                communicate = edge_tts.Communicate(text, fallback_voice)
                audio_path = str(TEMP_DIR / f"{generate_id()}.mp3")
                await communicate.save(audio_path)
                self.tts_path = audio_path
                return audio_path
            except Exception as nested_e:
                raise ValueError(f"Edge TTS failed with both voices: {str(e)}, fallback: {str(nested_e)}")

    def generate_gtts(self, text, lang='en'):
        """Generate speech using Google TTS"""
        try:
            audio_path = str(TEMP_DIR / f"{generate_id()}.mp3")
            tts = gTTS(text=text, lang=lang, slow=False)
            tts.save(audio_path)
            self.tts_path = audio_path
            return audio_path
        except Exception as e:
            raise ValueError(f"Google TTS failed: {str(e)}")

    def generate_speech(self, text, engine="edge", voice="en-US-ChristopherNeural"):
        """Generate speech from text using selected engine"""
        # Clean text
        text = re.sub(r'[^\w\s.?!]', '', text)
        
        if engine == "edge":
            # Edge TTS is async, so we need to run it in an event loop
            return asyncio.run(self.generate_edge_tts(text, voice))
        elif engine == "gtts":
            return self.generate_gtts(text, lang=voice)
        else:
            raise ValueError(f"Unsupported TTS engine: {engine}")

    def generate_subtitles(self, audio_path, api_key):
        """Generate word-highlighted subtitles"""
        try:
            # Set API key
            aai.settings.api_key = api_key
            
            # Configure transcription
            config = aai.TranscriptionConfig(
                speaker_labels=False, 
                word_boost=[], 
                format_text=True
            )
            
            # Create transcriber and transcribe audio
            transcriber = aai.Transcriber(config=config)
            transcript = transcriber.transcribe(audio_path)
            
            # Process word-level information
            wordlevel_info = []
            for word in transcript.words:
                word_data = {
                    "word": word.text.strip(),
                    "start": word.start / 1000.0,
                    "end": word.end / 1000.0
                }
                wordlevel_info.append(word_data)
            
            # Split text into lines based on character count and duration
            MAX_CHARS = 30
            MAX_DURATION = 3.0
            MAX_GAP = 2.5
            
            subtitles = []
            line = []
            line_duration = 0
            
            for idx, word_data in enumerate(wordlevel_info):
                word = word_data["word"]
                start = word_data["start"]
                end = word_data["end"]
                
                line.append(word_data)
                line_duration += end - start
                temp = " ".join(item["word"] for item in line)
                new_line_chars = len(temp)
                duration_exceeded = line_duration > MAX_DURATION
                chars_exceeded = new_line_chars > MAX_CHARS
                
                if idx > 0:
                    gap = word_data['start'] - wordlevel_info[idx - 1]['end']
                    maxgap_exceeded = gap > MAX_GAP
                else:
                    maxgap_exceeded = False
                
                # Check if any condition is exceeded to finalize the current line
                if duration_exceeded or chars_exceeded or maxgap_exceeded:
                    if line:
                        subtitle_line = {
                            "text": " ".join(item["word"] for item in line),
                            "start": line[0]["start"],
                            "end": line[-1]["end"],
                            "words": line
                        }
                        subtitles.append(subtitle_line)
                        line = []
                        line_duration = 0
            
            # Add the remaining words as the last subtitle line if any
            if line:
                subtitle_line = {
                    "text": " ".join(item["word"] for item in line),
                    "start": line[0]["start"],
                    "end": line[-1]["end"],
                    "words": line
                }
                subtitles.append(subtitle_line)
            
            # Create subtitle clips
            all_subtitle_clips = []
            
            # Define formatting constants
            FONT = 'Helvetica-Bold'
            FONTSIZE = 80
            COLOR = 'white'
            BG_COLOR = 'blue'
            FRAME_SIZE = (1080, 1920)
            
            for subtitle in subtitles:
                full_duration = subtitle['end'] - subtitle['start']
                
                word_clips = []
                xy_textclips_positions = []
                
                # Dynamic vertical positioning (moved to bottom)
                frame_width, frame_height = FRAME_SIZE
                x_pos = 0
                y_pos = frame_height * 0.85  # Position at 85% of frame height
                x_buffer = frame_width * 1 / 10
                y_buffer = 10  # Small vertical buffer
                
                line_height = 0
                current_line_height = 0
                
                for index, wordJSON in enumerate(subtitle['words']):
                    duration = wordJSON['end'] - wordJSON['start']
                    word_clip = TextClip(wordJSON['word'], font=FONT, fontsize=FONTSIZE, color=COLOR).set_start(subtitle['start']).set_duration(full_duration)
                    word_width, word_height = word_clip.size
                    
                    # Track line height for multi-line support
                    line_height = max(line_height, word_height)
                    
                    # Check if the current word exceeds the frame width, move to the next line
                    if x_pos + word_width > frame_width - 2 * x_buffer:
                        x_pos = 0
                        y_pos += line_height + y_buffer
                        current_line_height += line_height + y_buffer
                    
                    # Store the position and other details for highlighting
                    xy_textclips_positions.append({
                        "x_pos": x_pos + x_buffer,
                        "y_pos": y_pos + y_buffer,
                        "width": word_width,
                        "height": word_height,
                        "word": wordJSON['word'],
                        "start": wordJSON['start'],
                        "end": wordJSON['end'],
                        "duration": duration
                    })
                    
                    # Set the position of the word clip
                    word_clip = word_clip.set_position((x_pos + x_buffer, y_pos + y_buffer))
                    word_clips.append(word_clip)
                    x_pos = x_pos + word_width + 10
                
                # Create highlighted word clips
                for highlight_word in xy_textclips_positions:
                    word_clip_highlight = TextClip(highlight_word['word'], font=FONT, fontsize=FONTSIZE, color=COLOR, bg_color=BG_COLOR).set_start(highlight_word['start']).set_duration(highlight_word['duration'])
                    word_clip_highlight = word_clip_highlight.set_position((highlight_word['x_pos'], highlight_word['y_pos']))
                    word_clips.append(word_clip_highlight)
                
                # Add all word clips to the list of subtitle clips
                all_subtitle_clips.extend(word_clips)
            
            return all_subtitle_clips
        except Exception as e:
            print(f"Subtitle generation error: {str(e)}")
            return []  # Return empty list if subtitles fail

    def combine_video(self, include_subtitles=True, subtitles_api_key=""):
        """Combine all elements into final video"""
        try:
            output_path = str(TEMP_DIR / f"{generate_id()}.mp4")
            
            # Load audio
            tts_clip = AudioFileClip(self.tts_path)
            max_duration = tts_clip.duration
            
            # Calculate duration per image
            req_dur = max_duration / len(self.images)
            
            # Create video clips from images
            clips = []
            tot_dur = 0
            
            while tot_dur < max_duration:
                for image_path in self.images:
                    clip = ImageClip(image_path)
                    clip.duration = req_dur
                    clip = clip.set_fps(30)
                    
                    # Intelligent cropping for different aspect ratios
                    aspect_ratio = 9/16  # Standard vertical video ratio
                    if clip.w / clip.h < aspect_ratio:
                        clip = crop(
                            clip, 
                            width=clip.w, 
                            height=round(clip.w / aspect_ratio), 
                            x_center=clip.w / 2, 
                            y_center=clip.h / 2
                        )
                    else:
                        clip = crop(
                            clip, 
                            width=round(aspect_ratio * clip.h), 
                            height=clip.h, 
                            x_center=clip.w / 2, 
                            y_center=clip.h / 2
                        )
                    
                    clip = clip.resize((1080, 1920))  # Hardcoded frame size for shorts
                    
                    clips.append(clip)
                    tot_dur += clip.duration
                    
                    # Break if we have enough duration
                    if tot_dur >= max_duration:
                        break
            
            # Concatenate all clips
            final_clip = concatenate_videoclips(clips)
            final_clip = final_clip.set_fps(30)
            
            # Add background music
            random_music = choose_random_music()
            random_music_clip = AudioFileClip(str(random_music))
            random_music_clip = random_music_clip.fx(volumex, 0.1)
            random_music_clip = random_music_clip.set_duration(max_duration)
            
            # Generate subtitles if requested
            word_highlighted_clips = []
            if include_subtitles and subtitles_api_key:
                word_highlighted_clips = self.generate_subtitles(self.tts_path, subtitles_api_key)
            
            # Combine audio
            comp_audio = CompositeAudioClip([
                tts_clip,
                random_music_clip
            ])
            
            # Set audio and duration
            final_clip = final_clip.set_audio(comp_audio)
            final_clip = final_clip.set_duration(tts_clip.duration)
            
            # Add subtitles if we have them
            if word_highlighted_clips:
                final_clip = CompositeVideoClip([final_clip] + word_highlighted_clips)
            
            # Write video file
            final_clip.write_videofile(output_path, threads=4)
            
            # Save to output directory with a more descriptive name
            safe_title = re.sub(r'[^\w\s-]', '', self.metadata["title"])
            safe_title = re.sub(r'[-\s]+', '-', safe_title).strip('-_')
            final_output = str(OUTPUT_DIR / f"{safe_title}_{int(time.time())}.mp4")
            shutil.copy2(output_path, final_output)
            
            self.video_path = final_output
            return final_output
        except Exception as e:
            raise ValueError(f"Video generation failed: {str(e)}")

def generate_full_pipeline(
    niche, 
    language, 
    img_provider, 
    img_model, 
    tts_engine, 
    tts_voice, 
    include_subtitles, 
    assemblyai_key,
    progress=gr.Progress()
):
    progress(0, desc="Initializing")
    generator = YouTubeGenerator()
    
    try:
        # Step 1: Generate topic
        progress(0.05, desc="Generating topic")
        topic = generator.generate_topic(niche)
        
        # Step 2: Generate script
        progress(0.1, desc="Generating script")
        script = generator.generate_script(topic, language)
        
        # Step 3: Generate metadata
        progress(0.15, desc="Generating metadata")
        metadata = generator.generate_metadata(topic)
        
        # Step 4: Generate image prompts
        progress(0.2, desc="Generating image prompts")
        image_prompts = generator.generate_prompts(topic, script)
        
        # Step 5: Generate images
        progress(0.3, desc="Generating images")
        images = []
        total_images = len(image_prompts)
        
        for i, prompt in enumerate(image_prompts):
            progress(0.3 + (0.3 * i/total_images), desc=f"Generating image {i+1}/{total_images}")
            img_path = generator.generate_image(prompt, provider=img_provider, model=img_model)
            images.append(img_path)
        
        # Step 6: Generate speech
        progress(0.6, desc="Generating speech")
        tts_path = generator.generate_speech(script, engine=tts_engine, voice=tts_voice)
        
        # Step 7: Combine into video
        progress(0.8, desc="Creating video")
        video_path = generator.combine_video(
            include_subtitles=include_subtitles,
            subtitles_api_key=assemblyai_key if include_subtitles else ""
        )
        
        progress(1.0, desc="Complete!")
        
        return {
            "topic": topic,
            "script": script,
            "title": metadata["title"],
            "description": metadata["description"],
            "image_prompts": "\n\n".join([f"{i+1}. {prompt}" for i, prompt in enumerate(image_prompts)]),
            "images": images,
            "audio": tts_path,
            "video": video_path,
            "video_html": f'
'
        }
    
    except Exception as e:
        generator.clean_temp_files()
        error_msg = str(e)
        return {
            "topic": f"ERROR: {error_msg}",
            "script": "",
            "title": "",
            "description": "",
            "image_prompts": "",
            "images": [],
            "audio": None,
            "video": None,
            "video_html": f'
Video generation failed: {error_msg}
'
        }

def ui_component():
    # Define UI components
    with gr.Blocks(theme=gr.themes.Soft()) as app:
        gr.Markdown("# YouTube Shorts Generator")
        gr.Markdown("Generate complete YouTube Shorts videos with AI")
        
        with gr.Tabs():
            with gr.TabItem("Generate Video"):
                with gr.Row():
                    with gr.Column():
                        # Input parameters
                        niche_input = gr.Textbox(label="Video Niche/Topic", placeholder="Historical Facts", value="Historical Facts")
                        language_input = gr.Dropdown(
                            label="Language", 
                            choices=["English", "Spanish", "French", "German", "Italian", "Portuguese", "Russian", "Japanese", "Chinese", "Korean", "Arabic"],
                            value="English"
                        )
                        
                        with gr.Accordion("Image Generation Settings", open=False):
                            img_provider = gr.Dropdown(
                                label="Image Provider", 
                                choices=["g4f", "prodia", "pollinations"],
                                value="g4f"
                            )
                            
                            img_model = gr.Dropdown(
                                label="Image Model",
                                choices=["sdxl-turbo", "sdxl", "stable-diffusion-3", "kandinsky-2.2", "midjourney"],
                                value="sdxl-turbo"
                            )
                            
                        with gr.Accordion("TTS Settings", open=False):
                            tts_engine = gr.Dropdown(
                                label="TTS Engine",
                                choices=["edge", "gtts"],
                                value="edge"
                            )
                            
                            tts_voice = gr.Dropdown(
                                label="TTS Voice",
                                choices=["en-US-ChristopherNeural", "en-US-GuyNeural", "en-US-JennyNeural", "en-US-AriaNeural", "en-GB-SoniaNeural", "en"],
                                value="en-US-ChristopherNeural"
                            )
                        
                        with gr.Accordion("Subtitle Settings", open=False):
                            include_subtitles = gr.Checkbox(label="Generate Word-Level Subtitles", value=False)
                            assemblyai_key = gr.Textbox(
                                label="AssemblyAI API Key (required for subtitles)", 
                                placeholder="Your AssemblyAI API Key",
                                type="password"
                            )
                        
                        generate_btn = gr.Button("Generate Video", variant="primary")
                    
                    with gr.Column():
                        # Output display
                        with gr.Accordion("Generated Content", open=True):
                            topic_output = gr.Textbox(label="Generated Topic")
                            script_output = gr.Textbox(label="Generated Script", lines=10)
                            title_output = gr.Textbox(label="Video Title")
                            description_output = gr.Textbox(label="Video Description", lines=5)
                        
                        with gr.Accordion("Generated Assets", open=True):
                            prompts_output = gr.Textbox(label="Image Prompts", lines=5)
                            gallery_output = gr.Gallery(label="Generated Images")
                            audio_output = gr.Audio(label="Generated Speech")
                            video_output = gr.Video(label="Final Video")
                            
                            video_html = gr.HTML(label="Video Player")
                
                # Connect button to function
                generate_btn.click(
                    generate_full_pipeline,
                    inputs=[
                        niche_input, 
                        language_input, 
                        img_provider, 
                        img_model, 
                        tts_engine, 
                        tts_voice, 
                        include_subtitles, 
                        assemblyai_key
                    ],
                    outputs={
                        "topic": topic_output,
                        "script": script_output,
                        "title": title_output,
                        "description": description_output,
                        "image_prompts": prompts_output,
                        "images": gallery_output,
                        "audio": audio_output,
                        "video": video_output,
                        "video_html": video_html
                    }
                )
            
            with gr.TabItem("Settings"):
                gr.Markdown("## Advanced Settings")
                
                with gr.Accordion("Storage Settings", open=True):
                    temp_dir = gr.Textbox(label="Temporary Directory", value=str(TEMP_DIR))
                    output_dir = gr.Textbox(label="Output Directory", value=str(OUTPUT_DIR))
                    music_dir = gr.Textbox(label="Music Directory", value=str(MUSIC_DIR))
                    
                    def update_dirs(temp, output, music):
                        global TEMP_DIR, OUTPUT_DIR, MUSIC_DIR
                        TEMP_DIR = Path(temp)
                        OUTPUT_DIR = Path(output)
                        MUSIC_DIR = Path(music)
                        
                        # Ensure directories exist
                        TEMP_DIR.mkdir(exist_ok=True)
                        OUTPUT_DIR.mkdir(exist_ok=True)
                        MUSIC_DIR.mkdir(exist_ok=True)
                        
                        return f"Directories updated: {temp}, {output}, {music}"
                    
                    update_dirs_btn = gr.Button("Update Directories")
                    dirs_status = gr.Textbox(label="Status")
                    
                    update_dirs_btn.click(
                        update_dirs,
                        inputs=[temp_dir, output_dir, music_dir],
                        outputs=dirs_status
                    )
                
                with gr.Accordion("Add Background Music", open=True):
                    music_file = gr.File(label="Upload Music File (MP3)")
                    
                    def add_music(file):
                        if file is None:
                            return "No file selected"
                        
                        try:
                            filename = os.path.basename(file.name)
                            dest_path = MUSIC_DIR / filename
                            shutil.copy2(file.name, dest_path)
                            return f"Music file added: {filename}"
                        except Exception as e:
                            return f"Error adding music: {str(e)}"
                    
                    add_music_btn = gr.Button("Add Music")
                    music_status = gr.Textbox(label="Status")
                    
                    add_music_btn.click(
                        add_music,
                        inputs=music_file,
                        outputs=music_status
                    )
                
                with gr.Accordion("Cleanup", open=True):
                    def clean_temp():
                        try:
                            for file in TEMP_DIR.glob("*"):
                                file.unlink()
                            return "Temporary files cleaned successfully"
                        except Exception as e:
                            return f"Error cleaning files: {str(e)}"
                    
                    clean_temp_btn = gr.Button("Clean Temporary Files")
                    clean_status = gr.Textbox(label="Status")
                    
                    clean_temp_btn.click(
                        clean_temp,
                        outputs=clean_status
                    )
            
            with gr.TabItem("Help"):
                gr.Markdown("""
                # Help & Troubleshooting
                
                ## Common Issues
                
                ### Image Generation
                
                - **G4F Issues**: If image generation with G4F fails, try switching to "prodia" or "pollinations" provider
                - **Model Compatibility**: Not all models work with all providers. If you get errors, try a different model/provider combination
                
                ### TTS Issues
                
                - **Edge TTS Voice Error**: If you get "No audio was received" error, try a different voice like "en-US-ChristopherNeural"
                - **Google TTS**: For simplicity, use Google TTS with language code "en" if Edge TTS isn't working
                
                ### Video Generation
                
                - **Video Creation Errors**: Make sure all images were successfully generated before creating the video
                - **Subtitle Issues**: Subtitles require an AssemblyAI API key. You can get a free one at [AssemblyAI](https://www.assemblyai.com/)
                
                ## Tips for Best Results
                
                1. **Topics**: Be specific with your niche/topic for better results
                2. **Images**: SDXL Turbo is fastest, but other models may give better quality
                3. **TTS**: Edge TTS generally gives the best quality voice with "en-US-ChristopherNeural"
                4. **Background Music**: Add your own music files for better video quality
                """)
        
    return app

if __name__ == "__main__":
    app = ui_component()
    app.launch()