Update engine.py

engine.py

@@ -1,44 +1,39 @@
 # ==============================================================================
-# engine.py - [ADVANCED PARTNER EDITION]
-# FEATURES: Edge-TTS (Human Voice), Background Music, Smart Transitions
+# engine.py - [FINAL CORRECTED VERSION FOR HUGGING FACE]
+# CHANGE 1: API Keys environment variables se load hongi.
+# CHANGE 2: Sabhi folder paths (data, uploads, outputs) absolute hain.
 # ==============================================================================
-
+# engine.py के शुरुआत में
 import os
 import time
 import json
 import uuid
+import threading
 import subprocess
 import requests
 import sqlite3
 import random
 import shutil
 import re
-import asyncio
-import edge_tts  # NEW: For Human-like voice
+from gtts import gTTS
 from werkzeug.utils import secure_filename
 
 # ==============================================================================
-# 1. Global Setup and Database Functions
+# 1. Global Setup and Database Functions (FINAL CORRECTED VERSION)
 # ==============================================================================
-
-# प्रोजेक्ट की रूट डायरेक्टरी (Docker या Local Environment के लिए)
+# <<<--- YAHAN SE BADLAV SHURU HAI --- >>>
+# प्रोजेक्ट की रूट डायरेक्टरी को एब्सोल्यूट पाथ के रूप में सेट करें
 APP_ROOT = '/code'
-
-# सभी ज़रूरी फोल्डरों के लिए एब्सोल्यूट पाथ
+# सभी ज़रूरी फोल्डरों के लिए एब्सोल्यूट पाथ बनाएँ
 DATA_FOLDER = os.path.join(APP_ROOT, 'data')
 UPLOAD_FOLDER = os.path.join(APP_ROOT, 'uploads')
 OUTPUT_FOLDER = os.path.join(APP_ROOT, 'outputs')
-ASSETS_FOLDER = os.path.join(APP_ROOT, 'assets')  # NEW: Assets folder
-MUSIC_FOLDER = os.path.join(ASSETS_FOLDER, 'music') # NEW: Background Music folder
-
-# डेटाबेस फाइल का पाथ
+# डेटाबेस फाइल का पूरा एब्सोल्यूट पाथ सेट करें
 DATABASE_FILE = os.path.join(DATA_FOLDER, 'tasks.db')
-
-# सुनिश्चित करें कि सभी फोल्डर मौजूद हैं
-for folder in [DATA_FOLDER, UPLOAD_FOLDER, OUTPUT_FOLDER, ASSETS_FOLDER, MUSIC_FOLDER]:
-    os.makedirs(folder, exist_ok=True)
+# <<<--- BADLAV YAHAN KHATM HOTA HAI --- >>>
 
 def get_db_connection():
+    # अब यह सही पाथ का उपयोग करेगा: /code/data/tasks.db
     conn = sqlite3.connect(DATABASE_FILE, check_same_thread=False)
     conn.row_factory = sqlite3.Row
     return conn
@@ -50,7 +45,7 @@ def init_db():
     conn.close()
 
 def create_task(task_id):
-    log_message = "मिशन शुरू हो रहा है... (Advanced Mode)\n"
+    log_message = "मिशन शुरू हो रहा है...\n"
     conn = get_db_connection()
     conn.execute('INSERT INTO tasks (id, status, progress, log) VALUES (?, ?, ?, ?)', (task_id, 'processing', 0, log_message))
     conn.commit()
@@ -64,33 +59,28 @@ def get_task(task_id):
 
 def update_task_log(task_id, message, progress):
     conn = get_db_connection()
-    try:
-        current_log = conn.execute('SELECT log FROM tasks WHERE id = ?', (task_id,)).fetchone()['log']
-        new_log = current_log + message + "\n"
-        conn.execute('UPDATE tasks SET log = ?, progress = ? WHERE id = ?', (new_log, progress, task_id))
-        conn.commit()
-    except Exception as e:
-        print(f"Database Log Error: {e}")
-    finally:
-        conn.close()
+    current_log = conn.execute('SELECT log FROM tasks WHERE id = ?', (task_id,)).fetchone()['log']
+    new_log = current_log + message + "\n"
+    conn.execute('UPDATE tasks SET log = ?, progress = ? WHERE id = ?', (new_log, progress, task_id))
+    conn.commit()
+    conn.close()
 
 def update_task_final_status(task_id, status, error_message=None, output_filename=None):
     conn = get_db_connection()
-    try:
-        current_log = conn.execute('SELECT log FROM tasks WHERE id = ?', (task_id,)).fetchone()['log']
-        if status == 'error':
-            final_log = current_log + f"\n\n🚨 FATAL ERROR: {error_message}"
-            conn.execute('UPDATE tasks SET status = ?, log = ? WHERE id = ?', (status, final_log, task_id))
-        elif status == 'complete':
-            final_log = current_log + "🎉 मिशन शानदार तरीके से पूरा हुआ!"
-            conn.execute('UPDATE tasks SET status = ?, progress = ?, output_filename = ?, log = ? WHERE id = ?', (status, 100, output_filename, final_log, task_id))
-        conn.commit()
-    except Exception as e:
-        print(f"Database Status Error: {e}")
-    finally:
-        conn.close()
+    current_log = conn.execute('SELECT log FROM tasks WHERE id = ?', (task_id,)).fetchone()['log']
+    if status == 'error':
+        final_log = current_log + f"\n\n��� FATAL ERROR: {error_message}"
+        conn.execute('UPDATE tasks SET status = ?, log = ? WHERE id = ?', (status, final_log, task_id))
+    elif status == 'complete':
+        final_log = current_log + "🎉 मिशन पूरा हुआ!"
+        conn.execute('UPDATE tasks SET status = ?, progress = ?, output_filename = ?, log = ? WHERE id = ?', (status, 100, output_filename, final_log, task_id))
+    conn.commit()
+    conn.close()
 
 def load_api_keys(prefix):
+    """
+    सिस्टम के एनवायरनमेंट वेरिएबल्स से API कीज़ लोड करता है।
+    """
     try:
         prefix_lower = prefix.lower()
         keys = [v for k, v in os.environ.items() if k.lower().startswith(prefix_lower)]
@@ -102,33 +92,9 @@ def load_api_keys(prefix):
         return []
 
 # ==============================================================================
-# 2. Advanced Audio Functions (NEW)
+# 2. All API and Worker Classes
+# (Is section mein koi badlav nahi hai)
 # ==============================================================================
-
-async def generate_edge_tts_audio(text, output_file, voice="hi-IN-SwaraNeural"):
-    """
-    Microsoft Edge TTS का उपयोग करके इंसानी जैसी आवाज़ बनाता है।
-    Voices: hi-IN-SwaraNeural (Female), hi-IN-MadhurNeural (Male)
-    """
-    communicate = edge_tts.Communicate(text, voice)
-    await communicate.save(output_file)
-
-def get_random_background_music():
-    """
-    assets/music फोल्डर से एक रैंडम म्यूजिक फाइल चुनता है।
-    """
-    if not os.path.exists(MUSIC_FOLDER):
-        return None
-    music_files = [f for f in os.listdir(MUSIC_FOLDER) if f.endswith(('.mp3', '.wav'))]
-    if not music_files:
-        return None
-    selected = random.choice(music_files)
-    return os.path.join(MUSIC_FOLDER, selected)
-
-# ==============================================================================
-# 3. All API Classes
-# ==============================================================================
-
 class GroqAPI:
     def __init__(self, api_keys): self.api_keys, self.api_url, self.model, self._key_index = api_keys, "https://api.groq.com/openai/v1/audio/transcriptions", "whisper-large-v3", 0
     def transcribe_audio(self, audio_path):
@@ -138,11 +104,9 @@ class GroqAPI:
         headers = {'Authorization': f'Bearer {api_key}'}
         try:
             with open(audio_path, 'rb') as audio_file:
-                files = {'file': (os.path.basename(audio_path), audio_file, 'audio/mpeg')}
-                print(f"-> Groq API: Transcribing audio for timestamps...")
+                files = {'file': (os.path.basename(audio_path), audio_file, 'audio/mpeg')}; print(f"-> Groq API को शब्द-स्तर पर टाइमस्टैम्प के लिए भेजा जा रहा है...")
                 response = requests.post(self.api_url, headers=headers, data=data, files=files, timeout=120); response.raise_for_status()
-                words_data = response.json().get('words', [])
-                return words_data
+                words_data = response.json().get('words', []); print(f"-> ट्रांसक्रिप्शन सफल: {len(words_data)} शब्दों के टाइमस्टैम्प मिले।"); return words_data
         except Exception as e: raise Exception(f"Groq API Error: {e}")
 
 class PexelsAPI:
@@ -150,36 +114,39 @@ class PexelsAPI:
         if not api_keys: raise Exception("Pexels API key not found.")
         self.api_key = api_keys[0]; self.api_url = "https://api.pexels.com/videos/search"
     def search_and_download(self, query, download_path, orientation, search_page=1):
+        print(f"-> Pexels पर खोजा जा रहा है (Direct API): '{query}' (Page: {search_page}, Orientation: {orientation})")
         headers = {'Authorization': self.api_key}; params = {'query': query, 'page': search_page, 'per_page': 1, 'orientation': orientation}
         try:
             response = requests.get(self.api_url, headers=headers, params=params, timeout=60); response.raise_for_status(); data = response.json()
-            if not data.get('videos'): return None
+            if not data.get('videos'): print(f"-> Pexels पर '{query}' के लिए कोई परिणाम नहीं मिला।"); return None
             video_data = data['videos'][0]; video_files = video_data.get('video_files', []); best_link = None
             for video_file in video_files:
                 if video_file.get('quality') == 'hd': best_link = video_file.get('link'); break
             if not best_link and video_files: best_link = video_files[0].get('link')
-            if not best_link: return None
-            download_response = requests.get(best_link, stream=True, timeout=60); download_response.raise_for_status()
+            if not best_link: print(f"-> Pexels परिणाम में क���ई डाउनलोड करने योग्य लिंक नहीं मिला।"); return None
+            print(f"-> Pexels से वीडियो डाउनलोड किया जा रहा है..."); download_response = requests.get(best_link, stream=True, timeout=60); download_response.raise_for_status()
             with open(download_path, 'wb') as f:
                 for chunk in download_response.iter_content(chunk_size=8192): f.write(chunk)
-            return download_path
-        except Exception as e: print(f"Pexels Error: {e}"); return None
+            print(f"-> सफलतापूर्वक सहेजा गया: {download_path}"); return download_path
+        except requests.exceptions.RequestException as e: print(f"🚨 Pexels API में त्रुटि: {e}"); return None
+        except Exception as e: print(f"🚨 Pexels वीडियो डाउनलोड करने में अज्ञात त्रुटि: {e}"); return None
 
 class PixabayAPI:
     def __init__(self, api_keys):
         if not api_keys: raise Exception("Pixabay API key not found.")
         self.api_key = api_keys[0]; self.api_url = "https://pixabay.com/api/videos/"
     def search_and_download(self, query, download_path, orientation, max_clip_length, search_index=0):
+        print(f"-> Pixabay पर खोजा जा रहा है: '{query}' (Index: {search_index})")
         params = {'key': self.api_key, 'q': query, 'per_page': 5, 'orientation': orientation, 'max_duration': int(max_clip_length)}
         try:
             response = requests.get(self.api_url, params=params, timeout=60); response.raise_for_status(); results = response.json()
-            if not results['hits'] or len(results['hits']) <= search_index: return None
-            video_url = results['hits'][search_index]['videos']['medium']['url']
+            if not results['hits'] or len(results['hits']) <= search_index: print(f"-> Pixabay पर '{query}' के लिए index {search_index} पर कोई परिणाम नहीं मिला।"); return None
+            video_url = results['hits'][search_index]['videos']['medium']['url']; print(f"-> Pixabay से वीडियो डाउनलोड किया जा रहा है...")
             response = requests.get(video_url, stream=True, timeout=60); response.raise_for_status()
             with open(download_path, 'wb') as f:
                 for chunk in response.iter_content(chunk_size=8192): f.write(chunk)
-            return download_path
-        except Exception as e: print(f"Pixabay Error: {e}"); return None
+            print(f"-> सफलतापूर्वक सहेजा गया: {download_path}"); return download_path
+        except Exception as e: print(f"🚨 Pixabay API में त्रुटि: {e}"); return None
 
 class GeminiTeam:
     MODELS_LIST_URL = "https://generativelanguage.googleapis.com/v1beta/models"
@@ -187,256 +154,137 @@ class GeminiTeam:
         self.api_keys = api_keys
         if not self.api_keys: raise Exception("Gemini API key not found.")
         self.model_name = self._find_best_model()
+        if not self.model_name: raise Exception("Could not dynamically find a suitable Gemini 'flash' model from any of the provided keys.")
         self.api_url = f"https://generativelanguage.googleapis.com/v1beta/{self.model_name}:generateContent"
-
+        print(f"✅ स्मार्ट मॉडल हंटर सफल: '{self.model_name}' का उपयोग किया जाएगा।")
     def _find_best_model(self):
-        print("-> Smart Model Hunter: Looking for best Gemini flash model...")
+        print("-> स्मार्ट मॉडल हंटर: सबसे अच्छे 'gemini-*-flash' मॉडल को खोजा जा रहा है...")
         for api_key in self.api_keys:
             try:
+                print(f"-> API Key के अंतिम 4 अक्षरों से कोशिश की जा रही है: ...{api_key[-4:]}")
                 response = requests.get(f"{self.MODELS_LIST_URL}?key={api_key}", timeout=20); response.raise_for_status(); data = response.json()
-                available_models = [m['name'] for m in data.get('models', []) if 'flash' in m['name'] and 'generateContent' in m.get('supportedGenerationMethods', [])]
-                if available_models:
-                    available_models.sort(reverse=True)
-                    print(f"-> Selected Model: {available_models[0]}")
-                    return available_models[0]
-            except: continue
-        return "models/gemini-1.5-flash" # Fallback
-
+                available_models = [m['name'] for m in data.get('models', []) if 'flash' in m['name'] and 'generateContent' in m.get('supportedGenerationMethods', []) and 'exp' not in m['name']]
+                if not available_models: continue
+                available_models.sort(reverse=True); print(f"-> उपलब्ध 'flash' मॉडल मिले: {available_models}"); return available_models[0]
+            except requests.exceptions.RequestException as e: print(f"🚨 API Key ...{api_key[-4:]} के साथ त्रुटि: {e}. अगली की आजमाई जा रही है..."); continue
+        print("🚨 स्मार्ट मॉडल हंटर में गंभीर त्रुटि: कोई भी Gemini API Key काम नहीं कर रही है।"); return None
     def _make_resilient_api_call(self, prompt, timeout=120):
         headers = {'Content-Type': 'application/json'}; payload = {'contents': [{'parts': [{'text': prompt}]}]}
         for api_key in self.api_keys:
             try:
+                print(f"-> Gemini को अनुरोध भेजा जा रहा है (Key: ...{api_key[-4:]}, Model: {self.model_name.split('/')[-1]})")
                 response = requests.post(f"{self.api_url}?key={api_key}", headers=headers, json=payload, timeout=timeout); response.raise_for_status(); result = response.json()
-                if 'candidates' in result and result['candidates']: return result
-            except: continue
-        raise Exception("Gemini API Error: All keys failed.")
-
+                if 'candidates' not in result or not result['candidates']: print(f"🚨 चेतावनी: Key ...{api_key[-4:]} से कोई कैंडिडेट नहीं मिला (संभवतः सुरक्षा ब्लॉक)। अगली की आजमाई जा रही है..."); continue
+                return result
+            except requests.exceptions.RequestException as e: print(f"🚨 API कॉल में त्रुटि (Key: ...{api_key[-4:]}): {e}. अगली की आजमाई जा रही है...");
+        raise Exception("Gemini API Error: All available API keys failed. Please check your keys and quotas.")
     def extract_keywords(self, script_text):
-        prompt = f"""Analyze this script. Create a JSON list of objects for each scene. Each object: {{"scene_description": "...", "primary_query": "English search query", "fallback_query": "Simple English query"}}. Script: "{script_text}" """
+        prompt = f"""You are a search query expert. Analyze the script below and for each scene, create a JSON object. Each object must contain: 1. "scene_description": A brief description of the scene. 2. "primary_query": A highly creative, emotional, and cinematic search query in English. This is the main attempt. 3. "fallback_query": A simple, literal, and direct search query in English. Use this if the primary query fails. RULES: - Your response MUST be ONLY a JSON list of objects. - All queries must be in English. Script: "{script_text}" Example: [ {{"scene_description": "A person looking at a mountain.", "primary_query": "inspirational mountain peak cinematic hope", "fallback_query": "man looking at mountain"}} ] Generate the JSON:"""
         result = self._make_resilient_api_call(prompt)
+        json_str = result['candidates'][0]['content']['parts'][0]['text']
+        clean_str = json_str[json_str.find('['):json_str.rfind(']') + 1]; scenes = json.loads(clean_str)
         try:
-            json_str = result['candidates'][0]['content']['parts'][0]['text']
-            clean_str = json_str[json_str.find('['):json_str.rfind(']') + 1]
-            return json.loads(clean_str)
-        except: return []
-
+            log_file_path = os.path.join(OUTPUT_FOLDER, 'gemini_analysis_log.json')
+            with open(log_file_path, 'w', encoding='utf-8') as f: json.dump(scenes, f, ensure_ascii=False, indent=4)
+            print(f"-> Gemini का विश्लेषण सफलतापूर्वक '{log_file_path}' में सहेजा गया।")
+        except Exception as e: print(f"🚨 चेतावनी: Gemini विश्लेषण लॉग करने में विफल: {e}")
+        print(f"-> Gemini ने सफलतापूर्वक {len(scenes)} प्राथमिक/फ़ॉलबैक दृश्य निकाले।"); return scenes
     def create_master_timeline(self, word_timestamps, enriched_scenes_with_paths):
-        full_script_text = " ".join([w['word'] for w in word_timestamps]); duration = word_timestamps[-1]['end']
-        prompt = f"""Create a timeline JSON. Script: "{full_script_text}". Total Duration: {duration}s. Scenes: {json.dumps(enriched_scenes_with_paths)}. Timestamps: {json.dumps(word_timestamps)}.
-        Response: List of objects {{"start": float, "end": float, "matched_clip": "path", "start_offset_seconds": float}}. Cover 0 to {duration}. No Gaps."""
+        full_script_text = " ".join([word['word'] for word in word_timestamps]); total_duration = word_timestamps[-1]['end'] if word_timestamps else 0
+        prompt = f"""You are an expert AI video editor. Create a frame-perfect timeline JSON.
+Assets:
+1. **Full Script:** "{full_script_text}"
+2. **Total Audio Duration:** {total_duration:.2f} seconds.
+3. **Available Scene Clips:** {json.dumps(enriched_scenes_with_paths, indent=2)}
+4. **Word-Level Timestamps (with Pauses):** {json.dumps(word_timestamps, indent=2)}.
+
+RULES:
+1. Your response MUST be ONLY a list of JSON objects.
+2. Each object must have "start", "end", "matched_clip", and "start_offset_seconds".
+3. **CRITICAL:** The timeline MUST cover the entire audio duration from 0 to {total_duration:.2f} seconds. There should be NO GAPS.
+4. **CRITICAL:** You MUST use each video from the 'Available Scene Clips' list only once. Do not repeat clips.
+5. **NEW CRITICAL RULE:** In the 'Word-Level Timestamps', you will find special words like '[PAUSE]'. This represents a deliberate silence in the narration. Treat this as a creative opportunity! It is the perfect moment for a beautiful transition between two clips or to let a cinematic shot play out for its full emotional impact. DO NOT repeat the previous clip to fill a pause. Use the pause to enhance the video's pacing.
+
+Create the final timeline JSON:"""
         result = self._make_resilient_api_call(prompt, timeout=180)
-        try:
-            json_str = result['candidates'][0]['content']['parts'][0]['text']
-            clean_str = json_str[json_str.find('['):json_str.rfind(']') + 1]
-            return json.loads(clean_str)
-        except: return []
-
+        json_str = result['candidates'][0]['content']['parts'][0]['text']
+        clean_str = json_str[json_str.find('['):json_str.rfind(']') + 1]; final_timeline = json.loads(clean_str)
+        print(f"-> Gemini Master Editor ने सफलतापूर्वक {len(final_timeline)} क्लिप्स की टाइमलाइन और ऑफसेट बना दी है।"); return final_timeline
     def generate_script(self, topic, video_length):
-        len_map = {"short": "75 words", "medium": "150 words", "long": "300 words"}
-        prompt = f"""Write a Hindi script for a video about '{topic}'. Length: {len_map.get(video_length, "150 words")}. Output ONLY the spoken text (Narration). No scene descriptions."""
+        word_count_map = {"short": "~75 शब्द", "medium": "~150 शब्द", "long": "~300 शब्द"}; target_word_count = word_count_map.get(video_length, "~150 शब्द")
+        prompt = f"""आप 'स्पार्कलिंग ज्ञान' के लिए एक विशेषज्ञ हिंदी स्क्रिप्ट राइटर हैं।
+विषय: "{topic}".
+निर्देश:
+1. इस विषय पर एक आकर्षक, {target_word_count} की स्क्रिप्ट लिखें।
+2. भाषा सरल और बोलचाल वाली हो।
+3. हर 2-3 लाइनों के बाद एक नया विज़ुअल या सीन दिखाया जा सके, इस तरह से लिखें।
+4. **CRITICAL RULE:** आपका आउटपुट सिर्फ और सिर्फ बोले जाने वाले डायलॉग्स (narration) होने चाहिए। किसी भी तरह के विज़ुअल निर्देश, सीन डिस्क्रिप्शन या ब्रैकेट () [] में लिखी कोई भी जानकारी आउटपुट में नहीं होनी चाहिए। सिर्फ वो टेक्स्ट दें जो ऑडियो में बोला जाएगा।
+
+अब, स्क्रिप्ट लिखें:"""
         result = self._make_resilient_api_call(prompt)
-        return result['candidates'][0]['content']['parts'][0]['text'].strip()
+        generated_script = result['candidates'][0]['content']['parts'][0]['text']
+        print("-> Gemini ने सफलतापूर्वक स्क्रिप्ट जेनरेट कर दी है।"); return generated_script.strip()
 
-# ==============================================================================
-# 4. Video Assembler (The Director)
-# ==============================================================================
 class VideoAssembler:
     TRANSITION_DURATION = 0.5
-    
     def __init__(self, timeline, narration_audio, output_path, width, height, mute_audio, temp_dir):
-        self.timeline = timeline
-        self.narration_audio = narration_audio
-        self.output_path = output_path
-        self.width = width
-        self.height = height
-        self.mute_audio = mute_audio
+        self.timeline = timeline; self.narration_audio = narration_audio; self.output_path = output_path; self.width = width; self.height = height; self.mute_audio = mute_audio
         self.temp_dir = temp_dir
-        self.bg_music = get_random_background_music() # Select music automatically
-
-    def _run_ffmpeg(self, command):
-        subprocess.run(command, check=True, capture_output=True, text=True)
-
+    def _run_ffmpeg_command(self, command, suppress_errors=False):
+        process = subprocess.run(command, capture_output=True, text=True)
+        if not suppress_errors and process.returncode != 0:
+            error_details = f"Return Code {process.returncode}"
+            if process.returncode == -9: error_details += " (SIGKILL): Process was killed, likely due to excessive memory usage."
+            raise Exception(f"FFmpeg Error ({error_details}):\nSTDERR:\n{process.stderr}")
+        return process
     def assemble_video(self, log_callback):
         if not self.timeline: return
-
-        # --- Stage 1: Prepare Individual Clips ---
-        log_callback("-> Stage 1/3: क्लिप्स तैयार की जा रही हैं...", 91)
+        log_callback("-> Stage 1/3: सभी क्लिप्स को व्यक्तिगत रूप से तैयार किया जा रहा है...", 91)
         prepared_clips = []
         for i, item in enumerate(self.timeline):
-            output_clip = os.path.join(self.temp_dir, f"prepared_{i:03d}.mp4")
-            duration = float(item['end']) - float(item['start'])
-            if i < len(self.timeline) - 1: duration += self.TRANSITION_DURATION
-            
-            cmd = [
-                'ffmpeg', '-y', '-ss', str(item.get('start_offset_seconds', 0)), '-i', item['matched_clip'],
-                '-t', str(duration),
-                '-vf', f"scale='w={self.width}:h={self.height}:force_original_aspect_ratio=increase',crop={self.width}:{self.height},setsar=1,fps=30",
-                '-c:v', 'libx264', '-preset', 'ultrafast', '-an', output_clip
-            ]
+            input_clip_path = item['matched_clip']
             try:
-                self._run_ffmpeg(cmd)
-                prepared_clips.append(output_clip)
+                ffprobe_command = ['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', input_clip_path]
+                duration_proc = self._run_ffmpeg_command(ffprobe_command)
+                actual_clip_duration = float(duration_proc.stdout.strip())
             except Exception as e:
-                log_callback(f"  ⚠️ Clip Error (skipped): {e}", 91)
-
-        # --- Stage 2: Merge with Transitions ---
-        log_callback("-> Stage 2/3: ट्रांजीशन जोड़े जा रहे हैं...", 94)
-        if not prepared_clips: raise Exception("No clips prepared.")
-        
-        current_video = prepared_clips[0]
-        for i in range(len(prepared_clips) - 1):
-            next_video = prepared_clips[i+1]
-            out_trans = os.path.join(self.temp_dir, f"trans_{i}.mp4")
-            
-            # Get duration for offset calculation
-            probe = subprocess.run(['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', current_video], capture_output=True, text=True)
-            dur = float(probe.stdout.strip())
-            offset = dur - self.TRANSITION_DURATION
-            
-            cmd = [
-                'ffmpeg', '-y', '-i', current_video, '-i', next_video,
-                '-filter_complex', f"[0:v][1:v]xfade=transition=fade:duration={self.TRANSITION_DURATION}:offset={offset},format=yuv420p",
-                '-c:v', 'libx264', '-preset', 'ultrafast', out_trans
+                log_callback(f"🚨 चेतावनी: क्लिप {os.path.basename(input_clip_path)} की अवधि का पता नहीं लगाया जा सका, इसे छोड़ दिया जाएगा। त्रुटि: {e}", 91)
+                continue
+            start_offset = float(item.get('start_offset_seconds', 0.0))
+            if start_offset >= actual_clip_duration:
+                log_callback(f"  -> 🚨 चेतावनी: AI द्वारा दिया गया स्टार्ट ऑफसेट ({start_offset}s) क्लिप की वास्तविक लंबाई ({actual_clip_duration:.2f}s) से अधिक है। ऑफसेट को 0 पर रीसेट किया जा रहा है।", 91)
+                start_offset = 0.0
+            is_last_clip = (i == len(self.timeline) - 1)
+            overlap = 0 if is_last_clip else self.TRANSITION_DURATION
+            duration = (float(item['end']) - float(item['start'])) + overlap
+            if duration <= 0: continue
+            output_clip_path = os.path.join(self.temp_dir, f"prepared_{i:03d}.mp4")
+            command = [
+                'ffmpeg', '-y', '-ss', str(start_offset), '-i', input_clip_path, '-t', str(duration),
+                '-vf', f"scale='w={self.width}:h={self.height}:force_original_aspect_ratio=increase',crop={self.width}:{self.height},setsar=1,fps=30",
+                '-c:v', 'libx264', '-preset', 'ultrafast', '-an', '-threads', '1', output_clip_path
             ]
-            self._run_ffmpeg(cmd)
-            current_video = out_trans
-        
-        visual_only_video = current_video
-
-        # --- Stage 3: Final Audio Mix (Narration + Music) ---
-        log_callback("-> Stage 3/3: ऑडियो मिक्सिंग (Voice + Music)...", 98)
-        
-        input_cmds = ['-i', visual_only_video]
-        if not self.mute_audio:
-            input_cmds.extend(['-i', self.narration_audio])
-            
-            filter_complex = "[1:a]volume=1.0[voice]" # Base voice volume
-            map_cmd = ["-map", "0:v", "-map", "[a_out]"]
-            
-            if self.bg_music:
-                log_callback(f"  🎵 Background Music Found: {os.path.basename(self.bg_music)}", 98)
-                input_cmds.extend(['-stream_loop', '-1', '-i', self.bg_music]) # Loop music
-                # Mix logic: Voice normal, Music 15% volume, mix them, cut when shortest input ends
-                filter_complex += ";[2:a]volume=0.15[bg];[voice][bg]amix=inputs=2:duration=first[a_out]"
-            else:
-                log_callback("  ℹ️ No Background Music found in assets/music.", 98)
-                filter_complex = "[1:a]volume=1.0[a_out]"
-
-            cmd = ['ffmpeg', '-y'] + input_cmds + ['-filter_complex', filter_complex] + map_cmd + ['-c:v', 'copy', '-c:a', 'aac', '-shortest', self.output_path]
-        else:
-            # Muted output
-            cmd = ['ffmpeg', '-y', '-i', visual_only_video, '-c:v', 'copy', '-an', self.output_path]
-
-        self._run_ffmpeg(cmd)
-
-# ==============================================================================
-# 5. Worker Function
-# ==============================================================================
-def run_ai_engine_worker(task_id, script_text, script_file_path, orientation, max_clip_length, mute_final_video):
-    log = lambda message, progress: update_task_log(task_id, message, progress)
-    temp_dir = os.path.join(UPLOAD_FOLDER, task_id)
-    
-    try:
-        # --- Step 0: Init ---
-        log("Step 0: सिस्टम चेक और चाबियाँ (Keys) लोड की जा रही हैं...", 2)
-        gemini_keys = load_api_keys("Gemini_Key")
-        if not gemini_keys: raise Exception("Gemini Keys missing.")
-        gemini = GeminiTeam(gemini_keys)
-
-        # --- Step 1: Audio Generation (Advanced) ---
-        log("Step 1: ऑडियो तैयार किया जा रहा है...", 10)
-        os.makedirs(temp_dir, exist_ok=True)
-        
-        if script_file_path:
-            narration_audio_path = script_file_path
-            log("-> यूजर द्वारा अपलोड की गई ऑडियो फाइल का उपयोग किया जा रहा है।", 12)
+            self._run_ffmpeg_command(command)
+            prepared_clips.append(output_clip_path)
+        log_callback("-> Stage 2/3: क्लिप्स को ट्रांजीशन के साथ जोड़ा जा रहा है...", 94)
+        if not prepared_clips: raise Exception("कोई भी क्लिप सफलतापूर्वक तैयार नहीं हो सकी।")
+        if len(prepared_clips) == 1:
+            shutil.copy(prepared_clips[0], self.output_path)
+            transitioned_video_path = self.output_path
         else:
-            # NEW: Edge-TTS Implementation
-            narration_audio_path = os.path.join(temp_dir, "narration_human.mp3")
-            clean_text = re.sub(r'\[.*?\]|\(.*?\)', '', script_text).strip()
-            log(f"-> Ultra-Realistic Voice जनरेट की जा रही है (Text: {clean_text[:30]}...)", 12)
-            asyncio.run(generate_edge_tts_audio(clean_text, narration_audio_path))
-            log("-> ✅ हाई-क्वालिटी ऑडियो तैयार है!", 15)
-
-        # --- Step 2: Transcribe ---
-        log("Step 2: ऑडियो का विश्लेषण (Groq)...", 18)
-        groq = GroqAPI(load_api_keys("Groq_Key"))
-        word_timestamps = groq.transcribe_audio(narration_audio_path)
-        
-        # Smart Pause Detection
-        timestamps_with_pauses = []
-        if word_timestamps:
-            timestamps_with_pauses.append(word_timestamps[0])
-            for i in range(len(word_timestamps) - 1):
-                gap = float(word_timestamps[i+1]['start']) - float(word_timestamps[i]['end'])
-                if gap > 1.5: timestamps_with_pauses.append({'word': '[PAUSE]', 'start': word_timestamps[i]['end'], 'end': word_timestamps[i+1]['start']})
-                timestamps_with_pauses.append(word_timestamps[i+1])
-
-        # --- Step 3: Visual Search ---
-        log("Step 3: विज़ुअल्स खोजे जा रहे हैं...", 30)
-        full_text = " ".join([w['word'] for w in timestamps_with_pauses])
-        scenes = gemini.extract_keywords(full_text)
-        
-        pexels = PexelsAPI(load_api_keys("Pexels_Key"))
-        pixabay = PixabayAPI(load_api_keys("Pixabay_Key"))
-        
-        successful_scenes = []
-        for i, scene in enumerate(scenes):
-            d_path = os.path.join(temp_dir, f"scene_{i}.mp4")
-            log(f"  -> Scene {i+1}: {scene['primary_query']}", 30+i)
-            
-            found = pexels.search_and_download(scene['primary_query'], d_path, orientation)
-            if not found: found = pixabay.search_and_download(scene['primary_query'], d_path, orientation, max_clip_length)
-            if not found: found = pexels.search_and_download(scene['fallback_query'], d_path, orientation) # Fallback
-            
-            if found:
-                scene['downloaded_path'] = found
-                successful_scenes.append(scene)
-        
-        if not successful_scenes: raise Exception("No videos found.")
-
-        # --- Step 4: Timeline & Assembly ---
-        log("Step 4: मास्टर टाइमलाइन बनाई जा रही है...", 70)
-        timeline = gemini.create_master_timeline(timestamps_with_pauses, successful_scenes)
-        
-        # Gap filling logic (simplified for brevity, keeping integrity)
-        final_timeline = []
-        if timeline:
-            timeline.sort(key=lambda x: float(x['start']))
-            for i, clip in enumerate(timeline):
-                # Ensure path is valid
-                real_path = clip.get('matched_clip')
-                if isinstance(real_path, dict): real_path = real_path.get('downloaded_path')
-                if not real_path or not os.path.exists(real_path): continue
-                
-                clip['matched_clip'] = real_path
-                # Extend to close gaps
-                if i < len(timeline)-1:
-                    next_start = float(timeline[i+1]['start'])
-                    if float(clip['end']) < next_start: clip['end'] = next_start
-                else:
-                    # Extend last clip
-                    if word_timestamps: clip['end'] = word_timestamps[-1]['end']
-                final_timeline.append(clip)
-
-        # --- Step 5: Final Render ---
-        log("Step 5: फाइनल रेंडरिंग (Magic happening)...", 90)
-        w, h = (1080, 1920) if orientation == 'vertical' else (1920, 1080)
-        out_file = f"{task_id}_final.mp4"
-        out_path = os.path.join(OUTPUT_FOLDER, out_file)
-        
-        assembler = VideoAssembler(final_timeline, narration_audio_path, out_path, w, h, mute_final_video, temp_dir)
-        assembler.assemble_video(log)
-        
-        update_task_final_status(task_id, 'complete', output_filename=out_file)
-
-    except Exception as e:
-        import traceback; traceback.print_exc()
-        update_task_final_status(task_id, 'error', error_message=str(e))
-    finally:
-        if os.path.exists(temp_dir): shutil.rmtree(temp_dir)
-
-def generate_script_with_ai(topic, video_length):
-    try:
-        return GeminiTeam(load_api_keys("Gemini_Key")).generate_script(topic, video_length)
-    except Exception as e: raise e
+            current_video = prepared_clips[0]
+            for i in range(len(prepared_clips) - 1):
+                next_video = prepared_clips[i+1]
+                output_path = os.path.join(self.temp_dir, f"transition_{i:03d}.mp4")
+                total_transitions = len(prepared_clips) - 1
+                progress = 94 + int((i / total_transitions) * 4) if total_transitions > 0 else 94
+                log_callback(f"  -> ट्रांजीशन बनाया जा रहा है: क्लिप {i+1} और {i+2}", progress)
+                ffprobe_command = ['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', current_video]
+                duration_proc = self._run_ffmpeg_command(ffprobe_command)
+                transition_offset = float(duration_proc.stdout.strip()) - self.TRANSITION_DURATION
+                command = [
+                    'ffmpeg', '-y', '-i', current_video, '-i', next_video,
+                    '-filter_complex', f"[0:v][1:v]xfade=transition=fade:duration={self.TRANSITION_DURATION}:offset={transition_offset},format=yuv420p",
+                    '-c:v', 'libx264', '-preset', 'ultrafast', output_path
+                ]
+                se