v3.0: Radical fix - yt-dlp first strategy with working clients

- Rewrote downloader.py: yt-dlp with tv_embedded/android_vr/mediaconnect/android as primary
- Removed dead clients: mweb, ios, web, web_creator (all fail from datacenter IPs)
- Fixed format specs: bestvideo+bestaudio/best (tested and working)
- Simplified anti_ban.py: removed unnecessary delays, focused on working clients
- Updated fallback_downloader.py: Invidious as backup only with short timeouts
- Updated main.py: better error handling, shorter timeouts, clear Arabic messages
- Updated Dockerfile: added Deno JS runtime for yt-dlp 2025+

Dockerfile

@@ -7,28 +7,34 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     git \
     ffmpeg \
+    unzip \
     && rm -rf /var/lib/apt/lists/*
 
 # 3. تثبيت لغة Rust داخل الحاوية لتخطي مشكلة بناء مكتبة pydantic-core
 RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
 ENV PATH="/root/.cargo/bin:${PATH}"
 
-# 4. تحديد مجلد العمل الافتراضي داخل السيرفر السحابي
+# 4. تثبيت Deno (JavaScript runtime مطلوب لـ yt-dlp 2025+)
+RUN curl -fsSL https://deno.land/install.sh | sh
+ENV DENO_INSTALL="/root/.deno"
+ENV PATH="${DENO_INSTALL}/bin:${PATH}"
+
+# 5. تحديد مجلد العمل الافتراضي داخل السيرفر السحابي
 WORKDIR /app
 
-# 5. تهيئة بيئة المجلد المؤقت للتحميلات
+# 6. تهيئة بيئة المجلد المؤقت للتحميلات
 RUN mkdir -p /tmp/downloads && chmod 777 /tmp/downloads
 
-# 6. نسخ ملف المكتبات وتحديث أدوات التثبيت
+# 7. نسخ ملف المكتبات وتحديث أدوات التثبيت
 COPY requirements.txt .
 RUN pip install --no-cache-dir --upgrade pip setuptools wheel
 RUN pip install --no-cache-dir -r requirements.txt
 
-# 7. نسخ باقي ملفات المشروع بالكامل إلى داخل السيرفر
+# 8. نسخ باقي ملفات المشروع بالكامل إلى داخل السيرفر
 COPY . .
 
-# 8. فتح المنفذ (Port) الافتراضي المتوافق مع الكود الخاص بك
+# 9. فتح المنفذ (Port) الافتراضي المتوافق مع الكود الخاص بك
 EXPOSE 8555
 
-# 9. أمر تشغيل خادم FastAPI
+# 10. أمر تشغيل خادم FastAPI
 CMD ["python", "desktop/main.py"]

core/anti_ban.py

@@ -1,9 +1,11 @@
 """
-استراتيجيات تجنب حظر يوتيوب - نسخة محسنة للنشر السحابي
-Anti-Ban Strategies for YouTube Downloads - Cloud-Enhanced Version
+استراتيجيات تجنب حظر يوتيوب - نسخة مبسطة وفعالة يونيو 2026
+Anti-Ban Strategies - Simplified & Effective
 
-يدعم: mweb, ios, android, tv_embedded, web_creator, web
-مع نظام Fallback للعملاء وتتبع الناجحين والفاشلين
+التغييرات الرئيسية:
+- إزالة التأخيرات غير الضرورية (yt-dlp شغال مباشرة!)
+- العملاء الشغالين فقط: tv_embedded, android_vr, mediaconnect, android
+- إزالة العملاء الفاشلين: mweb, ios, web, web_creator
 """
 
 import random
@@ -17,246 +19,127 @@ from .cookie_manager import cookie_manager
 logger = logging.getLogger(__name__)
 
 
-# قائمة User-Agents متعددة للتدوير
+# العملاء الشغالين فعلياً من datacenter IPs (مختبرين يونيو 2026)
+CLIENT_PRIORITY = ["tv_embedded", "android_vr", "mediaconnect", "android"]
+
+# User-Agents للتدوير
 USER_AGENTS = [
-    # Android
+    # Smart TV (مناسب لـ tv_embedded)
+    "Mozilla/5.0 (CrKey armv7l 1.5.16041) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.0 Safari/537.36",
+    "Mozilla/5.0 (Web0S; Linux/SmartTV) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.34 Safari/537.36",
+    # Android VR (مناسب لـ android_vr)
+    "Mozilla/5.0 (Linux; Android 14; Quest 3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.6422.113 Safari/537.36",
     "Mozilla/5.0 (Linux; Android 14; Pixel 8 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.6422.113 Mobile Safari/537.36",
+    # Android
     "Mozilla/5.0 (Linux; Android 14; SM-S928B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.6367.179 Mobile Safari/537.36",
     "Mozilla/5.0 (Linux; Android 13; SM-S908B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.6312.118 Mobile Safari/537.36",
-    "Mozilla/5.0 (Linux; Android 14; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.6367.179 Mobile Safari/537.36",
-    # iOS
-    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1",
-    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1",
-    "Mozilla/5.0 (iPad; CPU OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1",
-    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Mobile/15E148 Safari/604.1",
-    # Chrome - Windows
+    # Chrome
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-    # Chrome - macOS
     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-    # Firefox
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:126.0) Gecko/20100101 Firefox/126.0",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:125.0) Gecko/20100101 Firefox/125.0",
-    # Smart TV
-    "Mozilla/5.0 (CrKey armv7l 1.5.16041) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.0 Safari/537.36",
-    "Mozilla/5.0 (Web0S; Linux/SmartTV) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.34 Safari/537.36",
 ]
 
-# ترتيب العملاء حسب الأولوية - بناءً على اختبارات حقيقية يونيو 2026
-# tv_embedded و android_vr و mediaconnect هم الأكثر فعالية
-# android يعطي 5 صيغ فقط لكنه قد يعمل من datacenter IPs
-CLIENT_PRIORITY = ["tv_embedded", "android_vr", "mediaconnect", "android", "web"]
-
-YOUTUBE_CLIENTS = CLIENT_PRIORITY
-
 ACCEPT_LANGUAGES = [
     "en-US,en;q=0.9,ar;q=0.8",
     "ar-SA,ar;q=0.9,en;q=0.8",
-    "en-GB,en;q=0.9,ar;q=0.7",
+    "en-GB,en;q=0.9",
     "fr-FR,fr;q=0.9,en;q=0.8",
-    "de-DE,de;q=0.9,en;q=0.8",
-    "es-ES,es;q=0.9,en;q=0.8",
 ]
 
 
 class AntiBanManager:
     """
-    مدير استراتيجيات تجنب الحظر - نسخة محسنة للسحابة
+    مدير استراتيجيات تجنب الحظر - نسخة مبسطة
+    yt-dlp مع العملاء الشغالين لا يحتاج تأخيرات كبيرة
     """
 
     def __init__(self):
-        self._last_request_time: float = 0
-        self._request_count: int = 0
-        self._session_start: float = time.time()
         self._current_user_agent: Optional[str] = None
         self._current_client: Optional[str] = None
         self._current_accept_lang: Optional[str] = None
-        self._cooldown_until: float = 0
+        self._request_count: int = 0
         self._failed_attempts: int = 0
         self._consecutive_429: int = 0
+        self._cooldown_until: float = 0
 
-        # تتبع العملاء الفاشلين والناجحين
+        # تتبع العملاء
         self._failed_clients: List[str] = []
         self._working_client: Optional[str] = None
 
-        self._has_cookies_cache = cookie_manager.is_active()
-
-        # إعدادات الحد الأقصى
-        self.max_requests_per_session = 50 if self._has_cookies_cache else 25
-        self.max_requests_per_hour = 30 if self._has_cookies_cache else 15
-        self.session_duration_limit = 7200 if self._has_cookies_cache else 3600
-
-        # تأخيرات
-        self.min_delay = 3.0 if self._has_cookies_cache else 5.0
-        self.max_delay = 6.0 if self._has_cookies_cache else 12.0
-        self.subtitle_to_video_delay = 2.0 if self._has_cookies_cache else 8.0
-
-    def _has_cookies(self) -> bool:
-        """هل توجد كوكيز نشطة؟"""
-        return cookie_manager.is_active()
-
     def get_random_user_agent(self) -> str:
-        """الحصول على User-Agent عشوائي"""
         self._current_user_agent = random.choice(USER_AGENTS)
         return self._current_user_agent
 
     def get_current_user_agent(self) -> str:
-        """الحصول على User-Agent الحالي"""
         if not self._current_user_agent:
             return self.get_random_user_agent()
         return self._current_user_agent
 
     def _get_next_client(self) -> str:
-        """الحصول على العميل التالي - يفضل العملاء الناجحين"""
-        if self._working_client and random.random() < 0.7:
+        """الحصول على العميل التالي - نفضل الشغال"""
+        if self._working_client and random.random() < 0.8:
             return self._working_client
 
         available = [c for c in CLIENT_PRIORITY if c not in self._failed_clients]
         if not available:
             self._failed_clients.clear()
-            available = CLIENT_PRIORITY
+            available = CLIENT_PRIORITY.copy()
 
-        # نفضل العملاء الأوائل (mweb, ios) لأنهم أقل حظراً
-        weights = [len(available) - i for i in range(len(available))]
-        client = random.choices(available, weights=weights, k=1)[0]
-        return client
+        return available[0]  # نبدأ بالأول (tv_embedded)
 
     def rotate_user_agent(self) -> str:
-        """تدوير User-Agent و Client جديد"""
-        old_ua = self._current_user_agent
+        old = self._current_user_agent
         new_ua = random.choice(USER_AGENTS)
         attempts = 0
-        while new_ua == old_ua and attempts < 10:
+        while new_ua == old and attempts < 5:
             new_ua = random.choice(USER_AGENTS)
             attempts += 1
         self._current_user_agent = new_ua
         self._current_client = self._get_next_client()
         self._current_accept_lang = random.choice(ACCEPT_LANGUAGES)
-        logger.info(
-            f"Rotated: UA={new_ua[:30]}... Client={self._current_client} Lang={self._current_accept_lang[:15]}..."
-        )
         return new_ua
 
     def get_current_client(self) -> str:
-        """الحصول على YouTube Client الحالي"""
         if not self._current_client:
             self._current_client = self._get_next_client()
         return self._current_client
 
-    def get_current_accept_lang(self) -> str:
-        """الحصول على Accept-Language الحالي"""
-        if not self._current_accept_lang:
-            self._current_accept_lang = random.choice(ACCEPT_LANGUAGES)
-        return self._current_accept_lang
-
     async def wait_before_request(self):
-        """انتظار قبل الطلب لتجنب كشف البوت"""
+        """انتظار قصير جداً قبل الطلب - yt-dlp شغال مباشرة"""
         self.rotate_user_agent()
 
         now = time.time()
-
         if now < self._cooldown_until:
             wait_time = self._cooldown_until - now
-            logger.info(f"In cooldown period. Waiting {wait_time:.1f}s")
+            logger.info(f"In cooldown. Waiting {wait_time:.1f}s")
             await asyncio.sleep(wait_time)
             self.rotate_user_agent()
 
-        time_since_last = now - self._last_request_time
-        delay = self._calculate_delay()
-
-        if time_since_last < delay:
-            wait_time = delay - time_since_last
-            jitter = random.uniform(0, 3.0)
-            total_wait = wait_time + jitter
-            logger.info(f"Rate limiting: waiting {total_wait:.1f}s before next request")
-            await asyncio.sleep(total_wait)
-
-        self._last_request_time = time.time()
         self._request_count += 1
 
-    async def wait_between_subtitle_and_video(self):
-        """انتظار بين تحميل الترجمة والفيديو"""
-        base_delay = self.subtitle_to_video_delay
-        jitter = random.uniform(3.0, 8.0)
-        total_delay = base_delay + jitter
-
-        logger.info(f"Waiting {total_delay:.1f}s between subtitle and video download (anti-ban)")
-        await asyncio.sleep(total_delay)
-        self.rotate_user_agent()
-
-    def _calculate_delay(self) -> float:
-        """حساب التأخير بناءً على عدد الطلبات السابقة"""
-        base_delay = random.uniform(self.min_delay, self.max_delay)
-
-        if self._request_count > 3:
-            base_delay *= 1.3
-        if self._request_count > 8:
-            base_delay *= 1.5
-        if self._request_count > 15:
-            base_delay *= 2.0
-
-        if self._failed_attempts > 0:
-            base_delay *= (1 + self._failed_attempts * 0.5)
-
-        return min(base_delay, 60.0)
-
     def check_session_limits(self) -> bool:
-        """التحقق من حدود الجلسة"""
-        now = time.time()
-        session_duration = now - self._session_start
-
-        if self._consecutive_429 >= 3:
-            logger.warning(f"Too many 429 errors ({self._consecutive_429}). Blocking session.")
+        """التحقق من حدود الجلسة - متساهل أكثر"""
+        if self._consecutive_429 >= 5:
             return False
-
-        if self._request_count >= self.max_requests_per_session:
-            logger.warning("Session request limit reached. Need cooldown.")
-            return False
-
-        if session_duration >= self.session_duration_limit:
-            logger.warning("Session duration limit reached. Need cooldown.")
+        if self._request_count >= 100:
             return False
-
         return True
 
-    def apply_cooldown(self, duration: Optional[float] = None):
-        """تطبيق فترة تبريد"""
-        has_cookies = self._has_cookies()
-        if duration is None:
-            duration = random.uniform(30, 60) if has_cookies else random.uniform(60, 180)
-        self._cooldown_until = time.time() + duration
-        logger.info(f"Applied cooldown for {duration:.1f}s")
-        self.rotate_user_agent()
-
     def report_failure(self, status_code: Optional[int] = None):
-        """الإبلاغ عن فشل في الطلب"""
-        has_cookies = self._has_cookies()
+        """الإبلاغ عن فشل"""
         self._failed_attempts += 1
-
-        # إضافة العميل الحالي لقائمة الفاشلين
         current = self._current_client
         if current and current not in self._failed_clients:
             self._failed_clients.append(current)
-            logger.warning(f"Client '{current}' failed. Failed clients: {self._failed_clients}")
-        self._working_client = None
 
         if status_code == 429:
             self._consecutive_429 += 1
-            logger.warning(f"HTTP 429 Too Many Requests! Total: {self._consecutive_429}")
-            cooldown_time = random.uniform(10, 30) if has_cookies else random.uniform(30, 120) * self._consecutive_429
-            self.apply_cooldown(cooldown_time)
+            logger.warning(f"HTTP 429! Total: {self._consecutive_429}")
+            self._cooldown_until = time.time() + random.uniform(10, 30)
         else:
             self._consecutive_429 = max(0, self._consecutive_429 - 1)
-            logger.warning(f"Request failed (status={status_code}). Total failures: {self._failed_attempts}")
-
-        max_fails = 5 if has_cookies else 3
-        if self._failed_attempts >= max_fails:
-            self.apply_cooldown(random.uniform(30, 60) if has_cookies else random.uniform(60, 180))
-            self.rotate_user_agent()
 
     def report_success(self):
-        """الإبلاغ عن نجاح الطلب"""
+        """الإبلاغ عن نجاح"""
         self._failed_attempts = max(0, self._failed_attempts - 1)
         self._consecutive_429 = max(0, self._consecutive_429 - 1)
         if self._current_client:
@@ -264,88 +147,46 @@ class AntiBanManager:
             if self._current_client in self._failed_clients:
                 self._failed_clients.remove(self._current_client)
 
-    def get_ydl_headers(self) -> dict:
-        """الحصول على headers لـ yt-dlp"""
-        ua = self.get_current_user_agent()
-        accept_lang = self._current_accept_lang or random.choice(ACCEPT_LANGUAGES)
-        headers = {
-            "User-Agent": ua,
-            "Accept-Language": accept_lang,
-        }
-        if self._has_cookies():
-            headers["Origin"] = "https://www.youtube.com"
-            headers["Referer"] = "https://www.youtube.com/"
-        return headers
-
     def get_ydl_opts_additions(self) -> dict:
-        """الحصول على خيارات yt-dlp إضافية مع تبديل الـ Client"""
+        """الحصول على خيارات yt-dlp مع العميل المناسب"""
         client = self.get_current_client()
-        has_cookies = self._has_cookies()
-        logger.info(f"Using YouTube client: {client} (cookies={has_cookies})")
+        has_cookies = cookie_manager.is_active()
+        logger.info(f"Using YouTube client: {client}")
 
         opts = {
-            "http_headers": self.get_ydl_headers(),
-            "extractor_retries": 5,
-            "file_access_retries": 5,
-            "fragment_retries": 5,
-            "socket_timeout": 60,
+            "http_headers": self._get_headers(),
+            "extractor_retries": 3,
+            "file_access_retries": 3,
+            "fragment_retries": 3,
+            "socket_timeout": 30,
+            "extractor_args": {"youtube": {"player_client": [client]}},
         }
 
-        if has_cookies:
-            opts["retry_sleep_functions"] = {
-                "http": lambda n: random.uniform(1, 3) * n,
-                "fragment": lambda n: random.uniform(1, 2) * n,
-            }
-        else:
-            opts["retry_sleep_functions"] = {
-                "http": lambda n: random.uniform(3, 8) * n,
-                "fragment": lambda n: random.uniform(2, 5) * n,
-            }
-
         if has_cookies:
             cookies_path = cookie_manager.get_cookies_path()
             if cookies_path:
                 opts["cookiefile"] = cookies_path
-                logger.info(f"Using cookies from: {cookies_path}")
-
-        # إضافة extractor_args حسب نوع العميل
-        if client == "mweb":
-            opts["extractor_args"] = {"youtube": {"player_client": ["mweb"]}}
-        elif client == "ios":
-            opts["extractor_args"] = {"youtube": {"player_client": ["ios"]}}
-        elif client == "tv_embedded":
-            opts["extractor_args"] = {"youtube": {"player_client": ["tv_embedded"]}}
-        elif client == "android_vr":
-            opts["extractor_args"] = {"youtube": {"player_client": ["android_vr"]}}
-        elif client == "mediaconnect":
-            opts["extractor_args"] = {"youtube": {"player_client": ["mediaconnect"]}}
-        elif client == "android":
-            opts["extractor_args"] = {"youtube": {"player_client": ["android"]}}
-        elif client == "web_creator":
-            opts["extractor_args"] = {"youtube": {"player_client": ["web_creator"]}}
-        else:
-            # default - لا نحدد عميل، yt-dlp يختار الأنسب
-            pass
 
         return opts
 
-    def get_fallback_clients(self) -> List[str]:
-        """الحصول على قائمة العملاء البديلين"""
-        current = self._current_client
-        fallback = [c for c in CLIENT_PRIORITY if c != current and c not in self._failed_clients]
-        return fallback
+    def _get_headers(self) -> dict:
+        ua = self.get_current_user_agent()
+        lang = self._current_accept_lang or random.choice(ACCEPT_LANGUAGES)
+        return {
+            "User-Agent": ua,
+            "Accept-Language": lang,
+        }
 
     def reset_session(self):
         """إعادة تعيين الجلسة"""
         self._request_count = 0
-        self._session_start = time.time()
         self._failed_attempts = 0
         self._consecutive_429 = 0
         self._cooldown_until = 0
         self._failed_clients.clear()
         self._working_client = None
         self.rotate_user_agent()
-        logger.info("Session reset with new User-Agent and Client")
+        logger.info("Session reset")
 
 
 anti_ban = AntiBanManager()

core/downloader.py

@@ -1,15 +1,19 @@
 """
-محمل الفيديوهات الرئيسي - نسخة السحابة المحسنة
-YouTube Video Downloader with Invidious-First Strategy
-
-نظام التحميل الذكي (مُعاد تصميمه بناءً على اختبارات يونيو 2026):
-1. جلب معلومات الفيديو من Invidious (لا يستهلك حدود YouTube)
-2. تحميل الفيديو من Invidious (جميع الجودات عبر adaptive formats + FFmpeg)
-3. لو فشل Invidious → yt-dlp مع tv_embedded client كـ fallback
-4. الترجمات: Invidious captions → yt-dlp كـ fallback
+محمل الفيديوهات الرئيسي - نسخة محسنة يونيو 2026
+YouTube Video Downloader - yt-dlp First Strategy
+
+الاستراتيجية المُختبرة فعلياً:
+1. yt-dlp مع tv_embedded (الأسرع - أقل من ثانية)
+2. yt-dlp مع android_vr (fallback سريع)
+3. yt-dlp مع mediaconnect
+4. yt-dlp مع android
+5. Invidious كـ backup أخير فقط (معظم السيرفرات ميتة)
+
+ملاحظة مهمة: العملاء mweb, ios, web, web_creator يفشلون من datacenter IPs
 """
 
 import os
+import re
 import asyncio
 import logging
 import time
@@ -20,7 +24,8 @@ from enum import Enum
 
 from .anti_ban import anti_ban
 from .subtitle_handler import SubtitleConverter, SubtitleInfo
-from .fallback_downloader import FallbackDownloader, FallbackVideoInfo
+
+logger = logging.getLogger(__name__)
 
 
 class CancelledError(Exception):
@@ -28,9 +33,6 @@ class CancelledError(Exception):
     pass
 
 
-logger = logging.getLogger(__name__)
-
-
 def _extract_429_status(e: Exception) -> Optional[int]:
     """استخراج status_code 429 من رسالة الخطأ"""
     msg = str(e)
@@ -44,9 +46,7 @@ class DownloadStatus(Enum):
     IDLE = "idle"
     FETCHING_INFO = "fetching_info"
     DOWNLOADING_SUBTITLE = "downloading_subtitle"
-    WAITING_ANTI_BAN = "waiting_anti_ban"
     DOWNLOADING_VIDEO = "downloading_video"
-    FALLBACK_DOWNLOAD = "fallback_download"
     MERGING_VIDEO = "merging_video"
     COMPLETED = "completed"
     CANCELLED = "cancelled"
@@ -65,10 +65,7 @@ class VideoInfo:
     view_count: int = 0
     available_subtitles: List[SubtitleInfo] = field(default_factory=list)
     formats: List[Dict[str, Any]] = field(default_factory=list)
-    # مصدر المعلومات
-    info_source: str = "youtube"
-    # captions من Invidious
-    captions: List[Dict] = field(default_factory=list)
+    info_source: str = "yt_dlp"
 
 
 @dataclass
@@ -82,16 +79,35 @@ class DownloadProgress:
     total_bytes: int = 0
     filename: str = ""
     message: str = ""
-    source: str = ""  # مصدر التحميل الحالي
+    source: str = ""
+
+
+# العملاء الشغالين فعلياً من datacenter IPs (مختبرين يونيو 2026)
+WORKING_CLIENTS = ["tv_embedded", "android_vr", "mediaconnect", "android"]
+
+# عملاء يفشلون من datacenter IPs - لا نستخدمهم
+# mweb: "Requested format is not available"
+# ios: "Requested format is not available"
+# web: "Requested format is not available"
+# web_creator: "Please sign in"
+
+# فورمات التحميل حسب الجودة (مُختبرة فعلياً)
+QUALITY_FORMATS = {
+    "best": "bestvideo+bestaudio/best",
+    "medium": "bestvideo[height<=720]+bestaudio/best[height<=720]/best",
+    "low": "bestvideo[height<=480]+bestaudio/best[height<=480]/best",
+}
 
 
 class YouTubeDownloader:
     """
-    محمل فيديوهات يوتيوب - Invidious أولاً
-    الاستراتيجية:
-    - معلومات الفيديو: Invidious → yt-dlp
-    - تحميل الفيديو: Invidious (direct/adaptive+FFmpeg) → yt-dlp
-    - الترجمات: Invidious captions → yt-dlp
+    محمل فيديوهات يوتيوب - yt-dlp أولاً
+    
+    الاستراتيجية المُختبرة:
+    - معلومات الفيديو: yt-dlp (tv_embedded → android_vr → mediaconnect → android)
+    - تحميل الفيديو: yt-dlp بنفس العملاء
+    - الترجمات: yt-dlp
+    - Invidious: backup أخير فقط
     """
 
     def __init__(self, download_dir: str = "/tmp/youtube_downloads"):
@@ -101,7 +117,10 @@ class YouTubeDownloader:
         self.progress = DownloadProgress()
         self._progress_callback: Optional[Callable] = None
         self.subtitle_converter = SubtitleConverter()
-        self.fallback = FallbackDownloader(download_dir=download_dir)
+
+        # تتبع العميل الشغال
+        self._working_client: Optional[str] = None
+        self._failed_clients: List[str] = []
 
         os.makedirs(download_dir, exist_ok=True)
 
@@ -130,87 +149,36 @@ class YouTubeDownloader:
             except Exception:
                 pass
 
-    def _convert_fallback_info(self, fallback_info: FallbackVideoInfo) -> VideoInfo:
-        """تحويل معلومات الفيديو من FallbackVideoInfo إلى VideoInfo"""
-        subtitles = []
-
-        # استخراج الترجمات من captions (أكثر فعالية)
-        if fallback_info.captions:
-            for cap in fallback_info.captions:
-                subtitles.append(SubtitleInfo(
-                    language=cap.get("language", ""),
-                    language_code=cap.get("language_code", ""),
-                    auto_generated=cap.get("auto_generated", False),
-                    url=cap.get("url", ""),
-                ))
-
-        # كمان subtitles
-        for sub in fallback_info.available_subtitles:
-            if not any(s.language_code == sub.get("language_code") for s in subtitles):
-                subtitles.append(SubtitleInfo(
-                    language=sub.get("language", ""),
-                    language_code=sub.get("language_code", ""),
-                    auto_generated=sub.get("auto_generated", False),
-                    url=sub.get("url", ""),
-                ))
-
-        return VideoInfo(
-            title=fallback_info.title,
-            video_id=fallback_info.video_id,
-            duration=fallback_info.duration,
-            thumbnail=fallback_info.thumbnail,
-            description=fallback_info.description,
-            uploader=fallback_info.uploader,
-            view_count=fallback_info.view_count,
-            available_subtitles=subtitles,
-            info_source="invidious",
-            captions=fallback_info.captions or [],
-        )
+    def _get_clients_to_try(self) -> List[str]:
+        """الحصول على قائمة العملاء للتجربة"""
+        # نبدأ بالعميل الشغال لو معروف
+        if self._working_client and self._working_client not in self._failed_clients:
+            return [self._working_client] + [c for c in WORKING_CLIENTS if c != self._working_client and c not in self._failed_clients]
+        
+        # العملاء اللي ما فشلوش
+        available = [c for c in WORKING_CLIENTS if c not in self._failed_clients]
+        if not available:
+            # لو كلهم فشلوا، نعيد المحاولة مع الكل
+            self._failed_clients.clear()
+            available = WORKING_CLIENTS.copy()
+        
+        return available
 
     async def fetch_video_info(self, url: str) -> VideoInfo:
         """
-        جلب معلومات الفيديو - Invidious أولاً
+        جلب معلومات الفيديو - yt-dlp أولاً (سريع جداً)
         """
         self._cancelled = False
         self._update_progress(
             status=DownloadStatus.FETCHING_INFO,
-            message="جاري جلب معلومات الفيديو من Invidious...",
-            source="invidious",
-        )
-
-        # ═══ المحاولة 1: Invidious (لا يستهلك حدود YouTube) ═══
-        try:
-            fallback_info = await asyncio.wait_for(
-                self.fallback.get_video_info(url),
-                timeout=20,
-            )
-            if fallback_info and fallback_info.title:
-                info = self._convert_fallback_info(fallback_info)
-                info.info_source = "invidious"
-                logger.info(f"Got video info from Invidious: {info.title}")
-                self._update_progress(
-                    status=DownloadStatus.IDLE,
-                    message="تم جلب المعلومات بنجاح من Invidious",
-                )
-                return info
-        except asyncio.TimeoutError:
-            logger.warning("Invidious timeout for video info, trying yt-dlp...")
-        except Exception as e:
-            logger.warning(f"Invidious failed for video info: {e}, trying yt-dlp...")
-
-        # ═══ المحاولة 2: yt-dlp مع tv_embedded client ═══
-        self._update_progress(
-            message="Invidious فشل، جاري المحاولة بـ yt-dlp...",
+            message="جاري جلب معلومات الفيديو...",
             source="yt_dlp",
         )
 
-        await anti_ban.wait_before_request()
-
-        # نستخدم tv_embedded و android_vr لأنهم الأكثر فعالية
-        clients_to_try = ["tv_embedded", "android_vr", "mediaconnect", "android", "web"]
+        clients = self._get_clients_to_try()
         last_error = None
 
-        for client in clients_to_try:
+        for client in clients:
             if self._cancelled:
                 raise CancelledError("تم إلغاء التحميل")
 
@@ -218,6 +186,10 @@ class YouTubeDownloader:
                 import yt_dlp
 
                 anti_ban._current_client = client
+                self._update_progress(
+                    message=f"جاري جلب المعلومات ({client})...",
+                    source="yt_dlp",
+                )
                 logger.info(f"Trying yt-dlp client: {client} for video info")
 
                 ydl_opts = {
@@ -233,11 +205,20 @@ class YouTubeDownloader:
                     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                         return ydl.extract_info(url, download=False)
 
-                info = await loop.run_in_executor(None, _extract_info)
+                info = await asyncio.wait_for(
+                    loop.run_in_executor(None, _extract_info),
+                    timeout=15,
+                )
 
                 if not info:
                     raise Exception("لم يتم العثور على معلومات الفيديو")
 
+                # نجاح! نسجل العميل الشغال
+                self._working_client = client
+                if client in self._failed_clients:
+                    self._failed_clients.remove(client)
+                anti_ban.report_success()
+
                 video_info = VideoInfo(
                     title=info.get('title', 'غير معروف'),
                     video_id=info.get('id', ''),
@@ -274,27 +255,59 @@ class YouTubeDownloader:
                             ))
                             break
 
-                anti_ban.report_success()
                 self._update_progress(
                     status=DownloadStatus.IDLE,
-                    message="تم جلب المعلومات بنجاح من yt-dlp",
+                    message="تم جلب المعلومات بنجاح",
                 )
+                logger.info(f"Got video info from yt-dlp ({client}): {video_info.title}")
                 return video_info
 
+            except asyncio.TimeoutError:
+                logger.warning(f"yt-dlp client '{client}' timed out for video info")
+                last_error = Exception("انتهت مهلة الاتصال. حاول مرة أخرى.")
+                self._failed_clients.append(client)
+                continue
+
             except CancelledError:
                 raise
+
             except Exception as e:
                 last_error = e
                 status_code = _extract_429_status(e)
                 anti_ban.report_failure(status_code=status_code)
+                self._failed_clients.append(client)
                 logger.warning(f"yt-dlp client '{client}' failed: {e}")
 
-                if client != clients_to_try[-1]:
-                    wait = random.uniform(2, 5) if status_code != 429 else random.uniform(5, 15)
+                if client != clients[-1]:
+                    # انتظار قصير قبل العميل التالي
+                    wait = random.uniform(1, 3) if status_code != 429 else random.uniform(5, 10)
                     await asyncio.sleep(wait)
                     continue
-                else:
-                    break
+
+        # ═══ كل العملاء فشلوا - نحاول Invidious كـ last resort ═══
+        self._update_progress(message="yt-dlp فشل، جاري المحاولة عبر Invidious...")
+        try:
+            from .fallback_downloader import FallbackDownloader
+            fallback = FallbackDownloader(download_dir=self.download_dir)
+            fallback_info = await asyncio.wait_for(
+                fallback.get_video_info(url),
+                timeout=10,
+            )
+            if fallback_info and fallback_info.title:
+                info = VideoInfo(
+                    title=fallback_info.title,
+                    video_id=fallback_info.video_id,
+                    duration=fallback_info.duration,
+                    thumbnail=fallback_info.thumbnail,
+                    description=fallback_info.description,
+                    uploader=fallback_info.uploader,
+                    view_count=fallback_info.view_count,
+                    info_source="invidious",
+                )
+                self._update_progress(status=DownloadStatus.IDLE, message="تم جلب المعلومات من Invidious")
+                return info
+        except Exception as e:
+            logger.warning(f"Invidious also failed: {e}")
 
         # ═══ كل الطرق فشلت ═══
         error_msg = str(last_error) if last_error else "فشل جلب المعلومات"
@@ -314,112 +327,114 @@ class YouTubeDownloader:
         """تحميل الترجمة"""
         self._update_progress(
             status=DownloadStatus.DOWNLOADING_SUBTITLE,
-            message=f"جاري تحميل الترجمة ({language_code}) من Invidious...",
+            message=f"جاري تحميل الترجمة ({language_code})...",
             percent=0,
-            source="invidious",
+            source="yt_dlp",
         )
 
         if self._cancelled:
             return None
 
-        # ═══ المحاولة 1: Invidious captions ═══
-        try:
-            sub_content = await asyncio.wait_for(
-                self.fallback.get_subtitle_content(url, language_code),
-                timeout=15,
-            )
-            if sub_content:
-                content = self.subtitle_converter.format_subtitle(sub_content, subtitle_format)
+        clients = self._get_clients_to_try()
 
-                final_path = os.path.join(self.download_dir, f"subtitle_{language_code}.{subtitle_format}")
-                with open(final_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
+        for client in clients:
+            if self._cancelled:
+                return None
 
-                logger.info(f"Subtitle downloaded from Invidious: {final_path}")
-                self._update_progress(
-                    status=DownloadStatus.DOWNLOADING_SUBTITLE,
-                    percent=100,
-                    message="تم تحميل الترجمة من Invidious",
-                )
-                return final_path
-        except Exception as e:
-            logger.warning(f"Invidious subtitle failed: {e}, trying yt-dlp...")
+            try:
+                import yt_dlp
 
-        # ═══ المحاولة 2: yt-dlp ═══
-        self._update_progress(
-            message="Invidious فشل للترجمة، جاري المحاولة بـ yt-dlp...",
-            source="yt_dlp",
-        )
+                anti_ban._current_client = client
 
-        await anti_ban.wait_before_request()
+                sub_format = "vtt" if subtitle_format == "vtt" else "srt"
+                subtitle_path = os.path.join(self.download_dir, "subtitle_temp")
 
-        try:
-            import yt_dlp
-
-            sub_format = "vtt" if subtitle_format == "vtt" else "srt"
-            subtitle_path = os.path.join(self.download_dir, "subtitle_temp")
-
-            ydl_opts = {
-                **anti_ban.get_ydl_opts_additions(),
-                'quiet': True,
-                'no_warnings': True,
-                'skip_download': True,
-                'writesubtitles': not auto_generated,
-                'writeautomaticsub': auto_generated,
-                'subtitleslangs': [language_code],
-                'subtitlesformat': sub_format,
-                'outtmpl': subtitle_path,
-                'postprocessors': [{
-                    'key': 'FFmpegSubtitlesConvertor',
-                    'format': sub_format,
-                }] if sub_format != 'vtt' else [],
-            }
-
-            loop = asyncio.get_event_loop()
-
-            def _download_sub():
-                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                    return ydl.download([url])
-
-            await loop.run_in_executor(None, _download_sub)
+                ydl_opts = {
+                    **anti_ban.get_ydl_opts_additions(),
+                    'quiet': True,
+                    'no_warnings': True,
+                    'skip_download': True,
+                    'writesubtitles': not auto_generated,
+                    'writeautomaticsub': auto_generated,
+                    'subtitleslangs': [language_code],
+                    'subtitlesformat': sub_format,
+                    'outtmpl': subtitle_path,
+                    'postprocessors': [{
+                        'key': 'FFmpegSubtitlesConvertor',
+                        'format': sub_format,
+                    }] if sub_format != 'vtt' else [],
+                }
 
-            self._update_progress(
-                status=DownloadStatus.DOWNLOADING_SUBTITLE,
-                percent=100,
-                message="تم تحميل الترجمة من yt-dlp",
-            )
-            anti_ban.report_success()
+                loop = asyncio.get_event_loop()
 
-            subtitle_file = self._find_subtitle_file(language_code, sub_format)
+                def _download_sub():
+                    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                        return ydl.download([url])
 
-            if subtitle_file and os.path.exists(subtitle_file):
-                with open(subtitle_file, 'r', encoding='utf-8') as f:
-                    content = f.read()
+                await asyncio.wait_for(
+                    loop.run_in_executor(None, _download_sub),
+                    timeout=30,
+                )
 
-                content = self.subtitle_converter.format_subtitle(content, subtitle_format)
+                self._working_client = client
+                anti_ban.report_success()
 
-                final_path = os.path.join(self.download_dir, f"subtitle_{language_code}.{sub_format}")
-                with open(final_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
+                subtitle_file = self._find_subtitle_file(language_code, sub_format)
 
-                try:
-                    os.remove(subtitle_file)
-                except Exception:
-                    pass
+                if subtitle_file and os.path.exists(subtitle_file):
+                    with open(subtitle_file, 'r', encoding='utf-8') as f:
+                        content = f.read()
 
-                return final_path
+                    content = self.subtitle_converter.format_subtitle(content, subtitle_format)
 
-            return None
+                    final_path = os.path.join(self.download_dir, f"subtitle_{language_code}.{sub_format}")
+                    with open(final_path, 'w', encoding='utf-8') as f:
+                        f.write(content)
 
-        except Exception as e:
-            if self._cancelled:
-                return None
-            anti_ban.report_failure(status_code=_extract_429_status(e))
-            self._update_progress(
-                status=DownloadStatus.FAILED,
-                message=f"فشل تحميل الترجمة: {str(e)}",
+                    try:
+                        os.remove(subtitle_file)
+                    except Exception:
+                        pass
+
+                    self._update_progress(
+                        status=DownloadStatus.DOWNLOADING_SUBTITLE,
+                        percent=100,
+                        message="تم تحميل الترجمة",
+                    )
+                    return final_path
+
+            except asyncio.TimeoutError:
+                logger.warning(f"Subtitle download timed out with client {client}")
+                continue
+            except Exception as e:
+                if self._cancelled:
+                    return None
+                anti_ban.report_failure(status_code=_extract_429_status(e))
+                logger.warning(f"yt-dlp client '{client}' failed for subtitle: {e}")
+                continue
+
+        # لو yt-dlp فشل للترجمة، نحاول Invidious
+        try:
+            from .fallback_downloader import FallbackDownloader
+            fallback = FallbackDownloader(download_dir=self.download_dir)
+            sub_content = await asyncio.wait_for(
+                fallback.get_subtitle_content(url, language_code),
+                timeout=10,
             )
-            raise
+            if sub_content:
+                content = self.subtitle_converter.format_subtitle(sub_content, subtitle_format)
+                final_path = os.path.join(self.download_dir, f"subtitle_{language_code}.{subtitle_format}")
+                with open(final_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                return final_path
+        except Exception as e:
+            logger.warning(f"Invidious subtitle also failed: {e}")
+
+        self._update_progress(
+            status=DownloadStatus.FAILED,
+            message=f"فشل تحميل الترجمة",
+        )
+        return None
 
     async def download_video(
         self,
@@ -428,134 +443,22 @@ class YouTubeDownloader:
         output_filename: Optional[str] = None,
     ) -> Optional[str]:
         """
-        تحميل الفيديو - Invidious أولاً ثم yt-dlp
+        تحميل الفيديو - yt-dlp أولاً (سريع وموثوق)
         """
         self._update_progress(
             status=DownloadStatus.DOWNLOADING_VIDEO,
-            message="جاري تحميل الفيديو من Invidious...",
-            percent=0,
-            source="invidious",
-        )
-
-        if self._cancelled:
-            return None
-
-        # ═══ المحاولة 1: Invidious ═══
-        video_file = await self._try_invidious_download(url, quality, output_filename)
-        if video_file:
-            return video_file
-
-        if self._cancelled:
-            return None
-
-        # ═══ المحاولة 2: yt-dlp ═══
-        logger.info("Invidious failed, trying yt-dlp...")
-        self._update_progress(
-            status=DownloadStatus.DOWNLOADING_VIDEO,
-            message="Invidious فشل، جاري المحاولة بـ yt-dlp...",
+            message="جاري تحميل الفيديو...",
             percent=0,
             source="yt_dlp",
         )
 
-        video_file = await self._try_ytdlp_download(url, quality, output_filename)
-        if video_file:
-            return video_file
-
         if self._cancelled:
             return None
 
-        self._update_progress(
-            status=DownloadStatus.FAILED,
-            message="فشل تحميل الفيديو من جميع المصادر. جرب فيديو آخر أو حاول لاحقاً.",
-        )
-        return None
-
-    async def _try_invidious_download(
-        self,
-        url: str,
-        quality: str = "best",
-        output_filename: Optional[str] = None,
-    ) -> Optional[str]:
-        """تحميل الفيديو من Invidious"""
-        try:
-            result = await self.fallback.get_download_url(url, quality)
-            if not result:
-                logger.warning("Invidious returned no download URL")
-                return None
-
-            needs_merge = result.get("needs_merge", False)
-
-            if needs_merge:
-                # تحميل فيديو + صوت منفصلين ودمجهم
-                video_url = result.get("video_url", "")
-                audio_url = result.get("audio_url", "")
-                filename = result.get("filename", "video.mp4")
-
-                if output_filename:
-                    filename = output_filename
-
-                self._update_progress(
-                    status=DownloadStatus.FALLBACK_DOWNLOAD,
-                    percent=10,
-                    message=f"جاري تحميل الفيديو بجودة {result.get('quality', '?')} من Invidious...",
-                    source="invidious_adaptive",
-                )
-
-                filepath = await self.fallback.download_and_merge(
-                    video_url, audio_url, filename
-                )
-
-                if filepath:
-                    self._update_progress(
-                        status=DownloadStatus.COMPLETED,
-                        percent=100,
-                        message=f"تم تحميل الفيديو بنجاح من Invidious! (جودة: {result.get('quality', '?')})",
-                        filename=filepath,
-                    )
-                    return filepath
+        format_spec = QUALITY_FORMATS.get(quality, QUALITY_FORMATS["best"])
+        clients = self._get_clients_to_try()
 
-            else:
-                # تحميل مباشر (فيديو + صوت معاً)
-                download_url = result["url"]
-                filename = result.get("filename", "video.mp4")
-
-                if output_filename:
-                    filename = output_filename
-
-                self._update_progress(
-                    status=DownloadStatus.FALLBACK_DOWNLOAD,
-                    percent=10,
-                    message=f"جاري تحميل الفيديو بجودة {result.get('quality', '?')} من Invidious...",
-                    source="invidious_direct",
-                )
-
-                filepath = await self.fallback.download_from_url(download_url, filename)
-
-                if filepath:
-                    self._update_progress(
-                        status=DownloadStatus.COMPLETED,
-                        percent=100,
-                        message=f"تم تحميل الفيديو بنجاح من Invidious! (جودة: {result.get('quality', '?')})",
-                        filename=filepath,
-                    )
-                    return filepath
-
-        except Exception as e:
-            logger.error(f"Invidious download failed: {e}")
-
-        return None
-
-    async def _try_ytdlp_download(
-        self,
-        url: str,
-        quality: str = "best",
-        output_filename: Optional[str] = None,
-    ) -> Optional[str]:
-        """محاولة التحميل بـ yt-dlp"""
-        # tv_embedded و android_vr هم الأكثر فعالية
-        clients_to_try = ["tv_embedded", "android_vr", "mediaconnect", "android", "web"]
-
-        for client in clients_to_try:
+        for client in clients:
             if self._cancelled:
                 return None
 
@@ -570,25 +473,11 @@ class YouTubeDownloader:
                 else:
                     outtmpl = os.path.join(self.download_dir, '%(title)s.%(ext)s')
 
-                # تحديد الجودة
-                if quality == "best":
-                    format_spec = 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best'
-                elif quality == "medium":
-                    format_spec = 'bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/best[height<=720]/best'
-                elif quality == "low":
-                    format_spec = 'bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/best[height<=480]/best'
-                else:
-                    format_spec = 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best'
-
                 ydl_opts = {
                     **anti_ban.get_ydl_opts_additions(),
                     'format': format_spec,
                     'outtmpl': outtmpl,
                     'merge_output_format': 'mp4',
-                    'postprocessors': [{
-                        'key': 'FFmpegVideoConvertor',
-                        'preferedformat': 'mp4',
-                    }],
                     'progress_hooks': [self._progress_hook],
                 }
 
@@ -598,7 +487,10 @@ class YouTubeDownloader:
                     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                         return ydl.download([url])
 
-                await loop.run_in_executor(None, _download_video)
+                await asyncio.wait_for(
+                    loop.run_in_executor(None, _download_video),
+                    timeout=300,  # 5 دقائق كحد أقصى
+                )
 
                 if self._cancelled:
                     return None
@@ -606,26 +498,66 @@ class YouTubeDownloader:
                 video_file = self._find_video_file()
 
                 if video_file:
+                    self._working_client = client
+                    anti_ban.report_success()
                     self._update_progress(
                         status=DownloadStatus.COMPLETED,
                         percent=100,
-                        message="تم تحميل الفيديو بنجاح من yt-dlp!",
+                        message="تم تحميل الفيديو بنجاح!",
                         filename=video_file,
                     )
-                    anti_ban.report_success()
                     return video_file
 
+            except asyncio.TimeoutError:
+                logger.warning(f"Video download timed out with client {client}")
+                self._failed_clients.append(client)
+                continue
+
             except CancelledError:
                 return None
+
             except Exception as e:
                 anti_ban.report_failure(status_code=_extract_429_status(e))
+                self._failed_clients.append(client)
                 logger.warning(f"yt-dlp client '{client}' failed for download: {e}")
 
-                if client != clients_to_try[-1] and not self._cancelled:
-                    wait = random.uniform(2, 5) if _extract_429_status(e) != 429 else random.uniform(5, 15)
+                if client != clients[-1] and not self._cancelled:
+                    wait = random.uniform(1, 3) if _extract_429_status(e) != 429 else random.uniform(5, 10)
                     await asyncio.sleep(wait)
                     continue
 
+        # ═══ yt-dlp فشل - نحاول Invidious كـ last resort ═══
+        self._update_progress(message="yt-dlp فشل، جاري المحاولة عبر Invidious...")
+        try:
+            from .fallback_downloader import FallbackDownloader
+            fallback = FallbackDownloader(download_dir=self.download_dir)
+            result = await asyncio.wait_for(
+                fallback.get_download_url(url, quality),
+                timeout=10,
+            )
+            if result:
+                if result.get("needs_merge"):
+                    filepath = await fallback.download_and_merge(
+                        result["video_url"], result.get("audio_url", ""), result.get("filename", "video.mp4")
+                    )
+                else:
+                    filepath = await fallback.download_from_url(result["url"], result.get("filename", "video.mp4"))
+                
+                if filepath:
+                    self._update_progress(
+                        status=DownloadStatus.COMPLETED,
+                        percent=100,
+                        message="تم تحميل الفيديو من Invidious!",
+                        filename=filepath,
+                    )
+                    return filepath
+        except Exception as e:
+            logger.warning(f"Invidious download also failed: {e}")
+
+        self._update_progress(
+            status=DownloadStatus.FAILED,
+            message="فشل تحميل الفيديو من جميع المصادر. جرب فيديو آخر أو حاول لاحقاً.",
+        )
         return None
 
     async def download_full(
@@ -644,9 +576,6 @@ class YouTubeDownloader:
         }
 
         try:
-            if not anti_ban.check_session_limits():
-                raise Exception("تم تجاوز حد الجلسة. يرجى الانتظار قبل المحاولة مرة أخرى.")
-
             info = await self.fetch_video_info(url)
             results["info"] = info
 
@@ -698,7 +627,7 @@ class YouTubeDownloader:
                 eta=eta,
                 downloaded_bytes=d.get('downloaded_bytes', 0),
                 total_bytes=d.get('total_bytes') or d.get('total_bytes_estimate', 0),
-                message=f"جاري التحميل من yt-dlp... {percent}%",
+                message=f"جاري التحميل... {percent}%",
                 source="yt_dlp",
             )
 
@@ -707,14 +636,12 @@ class YouTubeDownloader:
 
     def _find_subtitle_file(self, lang_code: str, fmt: str) -> Optional[str]:
         """البحث عن ملف الترجمة المحمل"""
-        import re
-        precise_pattern = re.compile(rf'(^|[\W_]){re.escape(lang_code)}[\W_]')
         for filename in os.listdir(self.download_dir):
-            if filename.endswith(f'.{fmt}') and precise_pattern.search(filename):
+            if filename.endswith(f'.{fmt}') and lang_code in filename:
                 return os.path.join(self.download_dir, filename)
 
         for filename in os.listdir(self.download_dir):
-            if filename.endswith(f'.{fmt}'):
+            if filename.endswith(f'.{fmt}') and 'subtitle' in filename:
                 return os.path.join(self.download_dir, filename)
 
         return None
@@ -726,7 +653,7 @@ class YouTubeDownloader:
         latest_time = 0
 
         for filename in os.listdir(self.download_dir):
-            if filename.endswith(video_extensions):
+            if filename.endswith(video_extensions) and not filename.startswith('_temp_'):
                 filepath = os.path.join(self.download_dir, filename)
                 mtime = os.path.getmtime(filepath)
                 if mtime > latest_time:

core/fallback_downloader.py

@@ -1,45 +1,36 @@
 """
-نظام التحميل البديل - Invidious-First Strategy
-تم إعادة كتابته بالكامل بناءً على اختبارات حقيقية يونيو 2026
-
-المصادر العاملة:
-- Invidious (inv.thepixora.com): ✅ معلومات + تحميل بجميع الجودات
-- اكتشاف ديناميكي للسيرفرات من api.invidious.io
-- Cobalt: ❌ ميت (API v7 أُغلق)
-- Piped: ❌ كل السيرفرات ميتة
+نظام التحميل البديل - Invidious كـ backup فقط
+يُستخدم فقط عندما yt-dlp يفشل (نادراً)
+
+ملاحظة يونيو 2026: معظم سيرفرات Invidious ميتة
+نحتفظ به كـ last resort مع timeout قصير
 """
 
 import os
 import re
 import asyncio
 import logging
-import random
 import time
 import subprocess
-import tempfile
 from typing import Optional, Dict, Any, List
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 
 import httpx
 
 logger = logging.getLogger(__name__)
 
 
-# ═══════════════════════════════════════════════════
-# سيرفرات InvidIOUS المعروفة (يتم تحديثها ديناميكياً)
-# ═══════════════════════════════════════════════════
-
-# سيرفرات أولية ثابتة (مختبرة وفعّالة)
-SEED_INVIDIOUS_INSTANCES = [
+# سيرفرات Invidious ثابتة - نحاولها بسرعة
+SEED_INSTANCES = [
     "https://inv.thepixora.com",
+    "https://invidious.nerdvpn.de",
+    "https://iv.ggtyler.dev",
+    "https://vid.puffyan.us",
+    "https://invidious.privacyredirect.com",
 ]
 
-# سيرفرات إضافية يتم اكتشافها من api.invidious.io
-DISCOVERED_INSTANCES: List[str] = []
-
-# فترة تحديث السيرفرات (كل 30 دقيقة)
-INSTANCE_REFRESH_INTERVAL = 1800
-_last_instance_refresh: float = 0
+# timeout قصير جداً - لا نضيع وقت المستخدم
+FAST_TIMEOUT = 5.0  # 5 ثواني فقط لكل سيرفر
 
 
 @dataclass
@@ -81,142 +72,30 @@ def _extract_video_id(url: str) -> Optional[str]:
     return None
 
 
-def _get_all_instances() -> List[str]:
-    """الحصول على قائمة كل السيرفرات المتاحة"""
-    global DISCOVERED_INSTANCES, _last_instance_refresh
-
-    now = time.time()
-    instances = SEED_INVIDIOUS_INSTANCES.copy()
-
-    # أضف السيرفرات المكتشفة
-    instances.extend([i for i in DISCOVERED_INSTANCES if i not in instances])
-
-    return instances
-
-
-async def refresh_instances():
-    """اكتشاف سيرفرات Invidious نشطة من API الرسمي"""
-    global DISCOVERED_INSTANCES, _last_instance_refresh
-
-    now = time.time()
-    if now - _last_instance_refresh < INSTANCE_REFRESH_INTERVAL:
-        return
-
-    logger.info("Refreshing Invidious instance list from official API...")
-    try:
-        async with httpx.AsyncClient(timeout=15, follow_redirects=True) as client:
-            response = await client.get("https://api.invidious.io/instances.json")
-            if response.status_code == 200:
-                data = response.json()
-                discovered = []
-                for item in data:
-                    if not isinstance(item, list) or len(item) < 2:
-                        continue
-                    info = item[1] if len(item) > 1 else {}
-                    if not info or not isinstance(info, dict):
-                        continue
-                    uri = info.get("uri", "")
-                    monitor = info.get("monitor") or {}
-                    down = monitor.get("down", True)
-                    api_enabled = info.get("api", False)
-                    uptime = monitor.get("uptime", 0)
-
-                    # نأخذ السيرفرات اللي مو down ولها API أو uptime عالي
-                    if uri and not down and (api_enabled or uptime > 80):
-                        if uri.startswith("https://") and uri not in SEED_INVIDIOUS_INSTANCES:
-                            discovered.append(uri)
-
-                if discovered:
-                    DISCOVERED_INSTANCES = discovered
-                    logger.info(f"Discovered {len(discovered)} Invidious instances")
-
-    except Exception as e:
-        logger.warning(f"Failed to refresh Invidious instances: {e}")
-
-    _last_instance_refresh = now
-
-
 class InvidiousDownloader:
-    """
-    محمل عبر Invidious API - المصدر الرئيسي للتحميل
-    يوفر: معلومات الفيديو + روابط تحميل مباشرة لجميع الجودات + ترجمات
-    """
+    """محمل عبر Invidious - backup فقط"""
 
     def __init__(self):
         self._working_instance: Optional[str] = None
-        self._failed_instances: List[str] = []
-        self._instance_tested: bool = False
-
-    async def _get_instances(self) -> List[str]:
-        """الحصول على قائمة السيرفرات مرتبة"""
-        await refresh_instances()
-
-        instances = _get_all_instances()
-
-        # نبدأ بالسيرفر الشغال
-        if self._working_instance and self._working_instance not in self._failed_instances:
-            instances = [self._working_instance] + [i for i in instances if i != self._working_instance]
-
-        # نزيل السيرفرات الفاشلة (بس نحتفظ بيهم كـ fallback أخير)
-        available = [i for i in instances if i not in self._failed_instances]
-        failed_but_maybe_ok = [i for i in instances if i in self._failed_instances]
-
-        return available + failed_but_maybe_ok
-
-    async def _test_instance(self, instance: str) -> bool:
-        """اختبار سيرفر Invidious"""
-        try:
-            async with httpx.AsyncClient(timeout=8, follow_redirects=True) as client:
-                r = await client.get(
-                    f"{instance}/api/v1/videos/dQw4w9WgXcQ",
-                    params={"fields": "title"},
-                )
-                if r.status_code == 200:
-                    try:
-                        data = r.json()
-                        return bool(data.get("title"))
-                    except Exception:
-                        return False
-                return False
-        except Exception:
-            return False
-
-    async def _find_working_instance(self) -> Optional[str]:
-        """البحث عن سيرفر شغال"""
-        if self._working_instance:
-            # تحقق أنه لسه شغال
-            if await self._test_instance(self._working_instance):
-                return self._working_instance
-            else:
-                self._working_instance = None
-
-        instances = await self._get_instances()
-        for instance in instances:
-            if await self._test_instance(instance):
-                self._working_instance = instance
-                logger.info(f"Found working Invidious instance: {instance}")
-                return instance
-
-        logger.error("No working Invidious instance found!")
-        return None
 
     async def get_video_info(self, url: str) -> Optional[FallbackVideoInfo]:
-        """جلب معلومات الفيديو من Invidious"""
+        """جلب معلومات الفيديو من Invidious - محاولة سريعة"""
         video_id = _extract_video_id(url)
         if not video_id:
-            logger.error(f"Cannot extract video ID from: {url}")
             return None
 
-        instances = await self._get_instances()
+        instances = SEED_INSTANCES.copy()
+        # نبدأ بالشغال لو معروف
+        if self._working_instance and self._working_instance in instances:
+            instances.remove(self._working_instance)
+            instances.insert(0, self._working_instance)
 
         for instance in instances:
             try:
-                async with httpx.AsyncClient(timeout=15, follow_redirects=True) as client:
+                async with httpx.AsyncClient(timeout=FAST_TIMEOUT, follow_redirects=True) as client:
                     response = await client.get(
                         f"{instance}/api/v1/videos/{video_id}",
-                        params={
-                            "fields": "title,lengthSeconds,videoThumbnails,author,viewCount,description,subtitles,captions,formatStreams,adaptiveFormats"
-                        },
+                        params={"fields": "title,lengthSeconds,videoThumbnails,author,viewCount,description,captions,formatStreams,adaptiveFormats"},
                     )
 
                     if response.status_code == 200:
@@ -224,7 +103,6 @@ class InvidiousDownloader:
                         self._working_instance = instance
                         logger.info(f"Invidious video info success with {instance}")
 
-                        # استخراج الصورة المصغرة
                         thumbnail = ""
                         thumbnails = data.get("videoThumbnails", [])
                         for t in thumbnails:
@@ -234,17 +112,6 @@ class InvidiousDownloader:
                         if not thumbnail and thumbnails:
                             thumbnail = thumbnails[0].get("url", "")
 
-                        # استخراج الترجمات (captions = فعّالة أكثر من subtitles)
-                        subtitles = []
-                        for sub in data.get("subtitles", []):
-                            subtitles.append({
-                                "language": sub.get("label", sub.get("language_code", "")),
-                                "language_code": sub.get("language_code", ""),
-                                "auto_generated": False,
-                                "url": sub.get("url", ""),
-                            })
-
-                        # استخراج captions (التلقائية واليدوية)
                         captions = []
                         for cap in data.get("captions", []):
                             captions.append({
@@ -262,108 +129,33 @@ class InvidiousDownloader:
                             uploader=data.get("author", ""),
                             view_count=data.get("viewCount", 0),
                             description=data.get("description", "")[:500] if data.get("description") else "",
-                            available_subtitles=subtitles,
                             captions=captions,
                             formats=data.get("formatStreams", []),
                             adaptive_formats=data.get("adaptiveFormats", []),
                         )
 
-                    elif response.status_code == 429:
-                        logger.warning(f"Invidious rate limited on {instance}")
-                        if instance not in self._failed_instances:
-                            self._failed_instances.append(instance)
-                        continue
-                    else:
-                        logger.warning(f"Invidious returned {response.status_code} from {instance}")
-                        if instance not in self._failed_instances:
-                            self._failed_instances.append(instance)
-                        continue
-
-            except (httpx.TimeoutException, httpx.ConnectError) as e:
-                logger.warning(f"Invidious connection error on {instance}: {e}")
-                if instance not in self._failed_instances:
-                    self._failed_instances.append(instance)
+            except (httpx.TimeoutException, httpx.ConnectError):
                 continue
             except Exception as e:
-                logger.warning(f"Invidious error on {instance}: {e}")
+                logger.debug(f"Invidious {instance} failed: {e}")
                 continue
 
-        # كل السيرفرات فشلت - حاول البحث عن سيرفر جديد
-        logger.warning("All instances failed, trying to find new working instance...")
-        new_instance = await self._find_working_instance()
-        if new_instance:
-            try:
-                async with httpx.AsyncClient(timeout=15, follow_redirects=True) as client:
-                    response = await client.get(
-                        f"{new_instance}/api/v1/videos/{video_id}",
-                        params={"fields": "title,lengthSeconds,videoThumbnails,author,viewCount,description,captions,formatStreams,adaptiveFormats"},
-                    )
-                    if response.status_code == 200:
-                        data = response.json()
-                        thumbnail = ""
-                        thumbnails = data.get("videoThumbnails", [])
-                        for t in thumbnails:
-                            if t.get("quality") == "medium":
-                                thumbnail = t.get("url", "")
-                                break
-                        if not thumbnail and thumbnails:
-                            thumbnail = thumbnails[0].get("url", "")
-
-                        subtitles = []
-                        for sub in data.get("subtitles", []):
-                            subtitles.append({
-                                "language": sub.get("label", sub.get("language_code", "")),
-                                "language_code": sub.get("language_code", ""),
-                                "auto_generated": False,
-                                "url": sub.get("url", ""),
-                            })
-
-                        captions = []
-                        for cap in data.get("captions", []):
-                            captions.append({
-                                "language": cap.get("label", ""),
-                                "language_code": cap.get("language_code", ""),
-                                "auto_generated": "(auto" in cap.get("label", "").lower(),
-                                "url": cap.get("url", ""),
-                            })
-
-                        return FallbackVideoInfo(
-                            title=data.get("title", ""),
-                            video_id=video_id,
-                            duration=data.get("lengthSeconds", 0),
-                            thumbnail=thumbnail,
-                            uploader=data.get("author", ""),
-                            view_count=data.get("viewCount", 0),
-                            description=data.get("description", "")[:500] if data.get("description") else "",
-                            available_subtitles=subtitles,
-                            captions=captions,
-                            formats=data.get("formatStreams", []),
-                            adaptive_formats=data.get("adaptiveFormats", []),
-                        )
-            except Exception as e:
-                logger.error(f"Even newly found instance failed: {e}")
-
-        logger.error("All Invidious instances failed for video info")
         return None
 
-    async def get_download_url(
-        self,
-        url: str,
-        quality: str = "best",
-    ) -> Optional[Dict[str, Any]]:
-        """
-        الحصول على روابط تحميل من Invidious
-        يرجع روابط فيديو + صوت منفصلة للدمج بـ FFmpeg
-        """
+    async def get_download_url(self, url: str, quality: str = "best") -> Optional[Dict[str, Any]]:
+        """الحصول على روابط تحميل من Invidious"""
         video_id = _extract_video_id(url)
         if not video_id:
             return None
 
-        instances = await self._get_instances()
+        instances = SEED_INSTANCES.copy()
+        if self._working_instance and self._working_instance in instances:
+            instances.remove(self._working_instance)
+            instances.insert(0, self._working_instance)
 
         for instance in instances:
             try:
-                async with httpx.AsyncClient(timeout=15, follow_redirects=True) as client:
+                async with httpx.AsyncClient(timeout=FAST_TIMEOUT, follow_redirects=True) as client:
                     response = await client.get(
                         f"{instance}/api/v1/videos/{video_id}",
                         params={"fields": "formatStreams,adaptiveFormats,title"},
@@ -372,40 +164,29 @@ class InvidiousDownloader:
                     if response.status_code == 200:
                         data = response.json()
                         self._working_instance = instance
-
-                        result = self._extract_best_format(data, quality, instance)
+                        result = self._extract_format(data, quality)
                         if result:
                             return result
 
-                    elif response.status_code == 429:
-                        if instance not in self._failed_instances:
-                            self._failed_instances.append(instance)
-                        continue
-
             except (httpx.TimeoutException, httpx.ConnectError):
                 continue
-            except Exception as e:
-                logger.warning(f"Invidious download error on {instance}: {e}")
+            except Exception:
                 continue
 
         return None
 
-    def _extract_best_format(
-        self, data: dict, quality: str, instance: str
-    ) -> Optional[Dict[str, Any]]:
-        """استخراج أفضل صيغة تحميل من بيانات Invidious"""
-
+    def _extract_format(self, data: dict, quality: str) -> Optional[Dict[str, Any]]:
+        """استخراج أفضل صيغة تحميل"""
         format_streams = data.get("formatStreams", [])
         adaptive_formats = data.get("adaptiveFormats", [])
         title = data.get("title", "video")
 
-        # ═══ الطريقة 1: Format Streams (فيديو + صوت معاً - أسهل) ═══
-        # هذه تحتوي على 360p عادةً فقط، لكنها جاهزة للتحميل مباشرة
+        # Format Streams (فيديو + صوت معاً)
         if format_streams:
             quality_order = {
-                "best": ["1080p", "720p", "480p", "360p"],
-                "medium": ["720p", "480p", "360p"],
-                "low": ["480p", "360p"],
+                "best": ["720p", "480p", "360p"],
+                "medium": ["480p", "360p"],
+                "low": ["360p"],
             }
             preferred = quality_order.get(quality, ["720p", "480p", "360p"])
 
@@ -423,7 +204,7 @@ class InvidiousDownloader:
                                 "needs_merge": False,
                             }
 
-            # أي format stream متاح
+            # أي format stream
             if format_streams and format_streams[0].get("url"):
                 fmt = format_streams[0]
                 safe_title = re.sub(r'[^\w\s-]', '', title)[:50]
@@ -435,104 +216,66 @@ class InvidiousDownloader:
                     "needs_merge": False,
                 }
 
-        # ═══ الطريقة 2: Adaptive Formats (فيديو منفصل + صوت منفصل + دمج FFmpeg) ═══
+        # Adaptive Formats
         if adaptive_formats:
-            return self._extract_adaptive_format(adaptive_formats, quality, title, instance)
+            video_formats = [f for f in adaptive_formats if f.get("type", "").startswith("video/") and f.get("url")]
+            audio_formats = [f for f in adaptive_formats if f.get("type", "").startswith("audio/") and f.get("url")]
 
-        return None
+            if video_formats:
+                quality_height_map = {"best": 1080, "medium": 720, "low": 480}
+                max_height = quality_height_map.get(quality, 1080)
 
-    def _extract_adaptive_format(
-        self, adaptive_formats: list, quality: str, title: str, instance: str
-    ) -> Optional[Dict[str, Any]]:
-        """استخراج أفضل فيديو + صوت منفصل للدمج"""
-
-        # فلترة الفيديو mp4 فقط
-        video_formats = [
-            f for f in adaptive_formats
-            if f.get("type", "").startswith("video/") and f.get("container") == "mp4" and f.get("url")
-        ]
-        # فلترة الصوت m4a فقط
-        audio_formats = [
-            f for f in adaptive_formats
-            if f.get("type", "").startswith("audio/") and f.get("container") == "m4a" and f.get("url")
-        ]
-
-        if not video_formats:
-            # جرّب webm كـ fallback
-            video_formats = [
-                f for f in adaptive_formats
-                if f.get("type", "").startswith("video/") and f.get("url")
-            ]
-        if not audio_formats:
-            audio_formats = [
-                f for f in adaptive_formats
-                if f.get("type", "").startswith("audio/") and f.get("url")
-            ]
-
-        if not video_formats:
-            return None
+                video_formats.sort(key=lambda x: x.get("bitrate", 0), reverse=True)
+                best_video = None
+                for fmt in video_formats:
+                    res_str = fmt.get("resolution", fmt.get("qualityLabel", "0p"))
+                    try:
+                        height = int(re.search(r'(\d+)', str(res_str)).group(1))
+                    except (AttributeError, ValueError):
+                        height = 0
+                    if height <= max_height:
+                        best_video = fmt
+                        break
 
-        # اختيار أفضل جودة فيديو حسب الطلب
-        quality_height_map = {"best": 2160, "medium": 720, "low": 480}
-        max_height = quality_height_map.get(quality, 2160)
+                if not best_video:
+                    best_video = video_formats[0]
 
-        # ترتيب حسب bitrate (أعلى = أفضل)
-        video_formats.sort(key=lambda x: x.get("bitrate", 0), reverse=True)
+                audio_formats.sort(key=lambda x: x.get("bitrate", 0), reverse=True)
+                best_audio = audio_formats[0] if audio_formats else None
 
-        best_video = None
-        for fmt in video_formats:
-            res_str = fmt.get("resolution", fmt.get("qualityLabel", "0p"))
-            height = 0
-            try:
-                height = int(re.search(r'(\d+)', str(res_str)).group(1))
-            except (AttributeError, ValueError):
-                pass
-
-            if height <= max_height:
-                best_video = fmt
-                break
-
-        if not best_video:
-            best_video = video_formats[0]
-
-        # أفضل صوت
-        audio_formats.sort(key=lambda x: x.get("bitrate", 0), reverse=True)
-        best_audio = audio_formats[0] if audio_formats else None
-
-        safe_title = re.sub(r'[^\w\s-]', '', title)[:50]
-
-        result = {
-            "filename": f"{safe_title}.mp4",
-            "source": "invidious_adaptive",
-            "quality": best_video.get("qualityLabel", best_video.get("resolution", "unknown")),
-            "needs_merge": True,
-            "video_url": best_video.get("url", ""),
-            "audio_url": best_audio.get("url", "") if best_audio else "",
-            "video_itag": best_video.get("itag", ""),
-            "audio_itag": best_audio.get("itag", "") if best_audio else "",
-        }
-
-        # لو مفيش صوت منفصل، نستخدم الفيديو المدمج
-        if not best_audio:
-            result["needs_merge"] = False
-            result["url"] = best_video.get("url", "")
-
-        return result
-
-    async def get_caption_content(
-        self, url: str, lang: str = "en", auto: bool = True
-    ) -> Optional[str]:
-        """تحميل محتوى الترجمة من Invidious captions"""
+                safe_title = re.sub(r'[^\w\s-]', '', title)[:50]
+
+                result = {
+                    "filename": f"{safe_title}.mp4",
+                    "source": "invidious_adaptive",
+                    "quality": best_video.get("qualityLabel", "unknown"),
+                    "needs_merge": bool(best_audio),
+                    "video_url": best_video.get("url", ""),
+                    "audio_url": best_audio.get("url", "") if best_audio else "",
+                }
+
+                if not best_audio:
+                    result["needs_merge"] = False
+                    result["url"] = best_video.get("url", "")
+
+                return result
+
+        return None
+
+    async def get_caption_content(self, url: str, lang: str = "en", auto: bool = True) -> Optional[str]:
+        """تحميل محتوى الترجمة من Invidious"""
         video_id = _extract_video_id(url)
         if not video_id:
             return None
 
-        instances = await self._get_instances()
+        instances = SEED_INSTANCES.copy()
+        if self._working_instance and self._working_instance in instances:
+            instances.remove(self._working_instance)
+            instances.insert(0, self._working_instance)
 
         for instance in instances:
             try:
-                # أولاً: جلب قائمة الترجمات
-                async with httpx.AsyncClient(timeout=10, follow_redirects=True) as client:
+                async with httpx.AsyncClient(timeout=FAST_TIMEOUT, follow_redirects=True) as client:
                     response = await client.get(
                         f"{instance}/api/v1/videos/{video_id}",
                         params={"fields": "captions,subtitles"},
@@ -545,38 +288,26 @@ class InvidiousDownloader:
                     captions = data.get("captions", [])
                     subtitles = data.get("subtitles", [])
 
-                    # البحث عن الترجمة المطلوبة
-                    target_caption = None
-
-                    # أولاً في subtitles
+                    target = None
                     for sub in subtitles:
                         if sub.get("language_code") == lang:
-                            target_caption = sub
+                            target = sub
                             break
 
-                    # ثم في captions
-                    if not target_caption:
+                    if not target:
                         for cap in captions:
                             lc = cap.get("language_code", "")
-                            label = cap.get("label", "")
                             if lc.startswith(lang.split("-")[0]):
-                                is_auto = "(auto" in label.lower()
-                                if auto and is_auto:
-                                    target_caption = cap
-                                    break
-                                elif not auto and not is_auto:
-                                    target_caption = cap
-                                    break
-
-                    # أي ترجمة متاحة
-                    if not target_caption and captions:
-                        target_caption = captions[0]
-
-                    if not target_caption:
+                                target = cap
+                                break
+
+                    if not target and captions:
+                        target = captions[0]
+
+                    if not target:
                         return None
 
-                    # تحميل محتوى الترجمة
-                    cap_url = target_caption.get("url", "")
+                    cap_url = target.get("url", "")
                     if not cap_url:
                         return None
 
@@ -587,58 +318,24 @@ class InvidiousDownloader:
                     if cap_response.status_code == 200 and cap_response.text.strip():
                         return cap_response.text
 
-            except Exception as e:
-                logger.warning(f"Caption download from {instance} failed: {e}")
+            except Exception:
                 continue
 
         return None
 
 
 class FallbackDownloader:
-    """
-    مدير التحميل البديل - Invidious أولاً
-    الاستراتيجية: Invidious (معلومات + تحميل) → yt-dlp (ترجمات)
-    """
+    """مدير التحميل البديل - Invidious backup"""
 
     def __init__(self, download_dir: str = "/tmp/downloads"):
         self.download_dir = download_dir
         self.invidious = InvidiousDownloader()
 
-        # إحصائيات
-        self.stats = {
-            "invidious_info_success": 0,
-            "invidious_download_success": 0,
-            "invidious_adaptive_success": 0,
-            "ffmpeg_merge_success": 0,
-            "ffmpeg_merge_fail": 0,
-            "total_fallbacks": 0,
-        }
-
     async def get_video_info(self, url: str) -> Optional[FallbackVideoInfo]:
-        """
-        جلب معلومات الفيديو من Invidious
-        """
-        info = await self.invidious.get_video_info(url)
-        if info and info.title:
-            self.stats["invidious_info_success"] += 1
-            return info
-        return None
+        return await self.invidious.get_video_info(url)
 
-    async def get_download_url(
-        self,
-        url: str,
-        quality: str = "best",
-    ) -> Optional[Dict[str, Any]]:
-        """الحصول على رابط تحميل من Invidious"""
-        result = await self.invidious.get_download_url(url, quality)
-        if result:
-            if result.get("needs_merge"):
-                self.stats["invidious_adaptive_success"] += 1
-            else:
-                self.stats["invidious_download_success"] += 1
-            self.stats["total_fallbacks"] += 1
-            return result
-        return None
+    async def get_download_url(self, url: str, quality: str = "best") -> Optional[Dict[str, Any]]:
+        return await self.invidious.get_download_url(url, quality)
 
     async def download_from_url(self, download_url: str, filename: str) -> Optional[str]:
         """تحميل ملف من رابط مباشر"""
@@ -648,18 +345,13 @@ class FallbackDownloader:
             async with httpx.AsyncClient(timeout=300, follow_redirects=True) as client:
                 async with client.stream("GET", download_url) as response:
                     if response.status_code != 200:
-                        logger.error(f"Download failed with status {response.status_code}")
                         return None
 
-                    total = int(response.headers.get("content-length", 0))
-                    downloaded = 0
-
                     with open(filepath, "wb") as f:
                         async for chunk in response.aiter_bytes(chunk_size=8192):
                             f.write(chunk)
-                            downloaded += len(chunk)
 
-                    logger.info(f"Downloaded {filename} ({downloaded} bytes)")
+                    logger.info(f"Downloaded {filename}")
                     return filepath
 
         except Exception as e:
@@ -668,64 +360,51 @@ class FallbackDownloader:
                 os.remove(filepath)
             return None
 
-    async def download_and_merge(
-        self, video_url: str, audio_url: str, filename: str
-    ) -> Optional[str]:
+    async def download_and_merge(self, video_url: str, audio_url: str, filename: str) -> Optional[str]:
         """تحميل فيديو + صوت منفصلين ودمجهم بـ FFmpeg"""
         output_path = os.path.join(self.download_dir, filename)
-
-        # مسارات مؤقتة
         video_temp = os.path.join(self.download_dir, f"_temp_video_{int(time.time())}.mp4")
         audio_temp = os.path.join(self.download_dir, f"_temp_audio_{int(time.time())}.m4a")
 
         try:
-            # تحميل الفيديو
-            logger.info(f"Downloading video stream for {filename}...")
             video_path = await self.download_from_url(video_url, os.path.basename(video_temp))
             if not video_path:
-                logger.error("Failed to download video stream")
                 return None
 
-            # تحميل الصوت
-            logger.info(f"Downloading audio stream for {filename}...")
-            audio_path = await self.download_from_url(audio_url, os.path.basename(audio_temp))
-            if not audio_path:
-                # لو الصوت فشل، نستخدم الفيديو فقط
-                logger.warning("Failed to download audio stream, using video only")
-                try:
-                    os.rename(video_path, output_path)
-                    self.stats["ffmpeg_merge_success"] += 1
-                    return output_path
-                except Exception:
-                    return video_path
-
-            # دمج بـ FFmpeg
-            logger.info(f"Merging video+audio with FFmpeg for {filename}...")
-            merge_result = self._ffmpeg_merge(video_path, audio_path, output_path)
-
-            # تنظيف الملفات المؤقتة
-            for temp_file in [video_path, audio_path]:
-                try:
-                    if os.path.exists(temp_file):
-                        os.remove(temp_file)
-                except Exception:
-                    pass
-
-            if merge_result:
-                self.stats["ffmpeg_merge_success"] += 1
+            if audio_url:
+                audio_path = await self.download_from_url(audio_url, os.path.basename(audio_temp))
+                if audio_path:
+                    # دمج بـ FFmpeg
+                    cmd = [
+                        "ffmpeg", "-y",
+                        "-i", video_path,
+                        "-i", audio_path,
+                        "-c:v", "copy",
+                        "-c:a", "aac",
+                        "-movflags", "+faststart",
+                        output_path,
+                    ]
+                    result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+
+                    for temp_file in [video_path, audio_path]:
+                        try:
+                            if os.path.exists(temp_file):
+                                os.remove(temp_file)
+                        except Exception:
+                            pass
+
+                    if result.returncode == 0 and os.path.exists(output_path):
+                        return output_path
+
+            # لو الصوت فشل أو الدمج فشل، نستخدم الفيديو فقط
+            try:
+                os.rename(video_path, output_path)
                 return output_path
-            else:
-                self.stats["ffmpeg_merge_fail"] += 1
-                # لو الدمج فشل، نرجع الفيديو بدون صوت
-                try:
-                    os.rename(video_path, output_path)
-                    return output_path
-                except Exception:
-                    return video_path
+            except Exception:
+                return video_path
 
         except Exception as e:
             logger.error(f"Download and merge failed: {e}")
-            # تنظيف
             for temp_file in [video_temp, audio_temp]:
                 try:
                     if os.path.exists(temp_file):
@@ -734,74 +413,10 @@ class FallbackDownloader:
                     pass
             return None
 
-    def _ffmpeg_merge(
-        self, video_path: str, audio_path: str, output_path: str
-    ) -> bool:
-        """دمج فيديو + صوت بـ FFmpeg"""
-        try:
-            cmd = [
-                "ffmpeg", "-y",
-                "-i", video_path,
-                "-i", audio_path,
-                "-c:v", "copy",
-                "-c:a", "aac",
-                "-movflags", "+faststart",
-                output_path,
-            ]
-
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=120,
-            )
-
-            if result.returncode == 0 and os.path.exists(output_path):
-                file_size = os.path.getsize(output_path)
-                logger.info(f"FFmpeg merge success: {output_path} ({file_size} bytes)")
-                return True
-            else:
-                logger.error(f"FFmpeg merge failed: {result.stderr[:300]}")
-                return False
-
-        except subprocess.TimeoutExpired:
-            logger.error("FFmpeg merge timed out")
-            return False
-        except FileNotFoundError:
-            logger.error("FFmpeg not found! Cannot merge video+audio")
-            return False
-        except Exception as e:
-            logger.error(f"FFmpeg merge error: {e}")
-            return False
-
     async def get_subtitle_content(self, url: str, lang: str = "ar") -> Optional[str]:
-        """تحميل محتوى الترجمة من Invidious"""
         return await self.invidious.get_caption_content(url, lang)
 
-    def get_stats(self) -> Dict[str, Any]:
-        """إحصائيات الاستخدام"""
-        stats = self.stats.copy()
-        stats["working_instance"] = self.invidious._working_instance
-        stats["failed_instances"] = len(self.invidious._failed_instances)
-        stats["discovered_instances"] = len(DISCOVERED_INSTANCES)
-        return stats
-
-    async def get_instance_status(self) -> Dict[str, Any]:
-        """حالة السيرفرات"""
-        await refresh_instances()
-        all_instances = _get_all_instances()
-
-        status = {
-            "working": self.invidious._working_instance,
-            "total_instances": len(all_instances),
-            "failed_instances": len(self.invidious._failed_instances),
-            "seed_instances": SEED_INVIDIOUS_INSTANCES,
-            "discovered_instances": DISCOVERED_INSTANCES[:5],
-        }
-
-        # اختبار سريع للسيرفر الشغال
-        if self.invidious._working_instance:
-            ok = await self.invidious._test_instance(self.invidious._working_instance)
-            status["working_instance_healthy"] = ok
-
-        return status
+
+async def refresh_instances():
+    """لا نفعل شيء - السيرفرات تُختبر عند الحاجة"""
+    pass

desktop/main.py

@@ -1,6 +1,8 @@
 """
 نسخة الكمبيوتر - خادم FastAPI مع واجهة ويب
 Desktop Version - FastAPI Server with Web UI
+
+يونيو 2026 - yt-dlp First Strategy
 """
 
 import os
@@ -8,7 +10,6 @@ import sys
 import json
 import asyncio
 import logging
-import tempfile
 from typing import Optional
 
 # إضافة مسار النواة المشتركة
@@ -19,7 +20,7 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 
-from core.downloader import YouTubeDownloader, DownloadStatus
+from core.downloader import YouTubeDownloader, DownloadStatus, WORKING_CLIENTS
 from core.models import DownloadRequest, SubtitleFormat, SubtitleLanguage, VideoQuality
 from core.anti_ban import anti_ban
 from core.cookie_manager import cookie_manager
@@ -31,7 +32,7 @@ logger = logging.getLogger(__name__)
 app = FastAPI(
     title="YouTube Downloader - Desktop",
     description="تطبيق تحميل فيديوهات يوتيوب مع الترجمات",
-    version="2.0.0",
+    version="3.0.0",
 )
 
 # CORS
@@ -54,19 +55,6 @@ downloader = YouTubeDownloader(download_dir=DOWNLOAD_DIR)
 ws_connections: list = []
 
 
-@app.on_event("startup")
-async def startup():
-    """تهيئة عند بدء الخادم"""
-    logger.info("🚀 Server starting up...")
-    # اكتشاف سيرفرات Invidious نشطة
-    try:
-        from core.fallback_downloader import refresh_instances
-        await refresh_instances()
-        logger.info("✅ Invidious instances refreshed")
-    except Exception as e:
-        logger.warning(f"⚠️ Failed to refresh Invidious instances: {e}")
-
-
 @app.get("/")
 async def index():
     """الصفحة الرئيسية"""
@@ -76,20 +64,23 @@ async def index():
 @app.get("/api/health")
 async def health():
     """فحص حالة الخادم"""
-    fallback_stats = downloader.fallback.get_stats()
     return {
         "status": "ok",
-        "version": "2.0.0",
-        "invidious_working": downloader.fallback.invidious._working_instance,
-        "fallback_stats": fallback_stats,
+        "version": "3.0.0",
+        "working_client": downloader._working_client,
+        "failed_clients": downloader._failed_clients,
+        "request_count": anti_ban._request_count,
     }
 
 
 @app.get("/api/video/info")
 async def get_video_info(url: str):
-    """جلب معلومات الفيديو"""
+    """جلب معلومات الفيديو - yt-dlp أولاً (سريع)"""
     try:
-        info = await downloader.fetch_video_info(url)
+        info = await asyncio.wait_for(
+            downloader.fetch_video_info(url),
+            timeout=20,
+        )
         return {
             "title": info.title,
             "video_id": info.video_id,
@@ -108,19 +99,28 @@ async def get_video_info(url: str):
                 for sub in info.available_subtitles
             ],
         }
+    except asyncio.TimeoutError:
+        raise HTTPException(
+            status_code=408,
+            detail="انتهت مهلة الاتصال. يوتيوب لا يستجيب حالياً. حاول مرة أخرى بعد قليل."
+        )
     except Exception as e:
         error_msg = str(e)
-        # رسائل خطأ أكثر وضوحاً
         if "429" in error_msg or "Too Many" in error_msg:
             raise HTTPException(
                 status_code=429,
-                detail="تم حظر الطلبات مؤقتاً من YouTube. انتظر قليلاً ثم حاول مرة أخرى."
+                detail="تم حظر الطلبات مؤقتاً من YouTube. انتظر بضع دقائق ثم حاول مرة أخرى."
             )
         elif "Video unavailable" in error_msg or "Private video" in error_msg:
             raise HTTPException(
                 status_code=400,
                 detail="الفيديو غير متاح أو خاص. تأكد من الرابط."
             )
+        elif "Sign in" in error_msg:
+            raise HTTPException(
+                status_code=403,
+                detail="يوتيوب يطلب تسجيل الدخول. جرب إضافة كوكيز أو حاول لاحقاً."
+            )
         else:
             raise HTTPException(status_code=400, detail=f"فشل جلب معلومات الفيديو: {error_msg}")
 
@@ -129,7 +129,6 @@ async def get_video_info(url: str):
 async def start_download(request: DownloadRequest):
     """بدء التحميل الكامل (ترجمة + فيديو)"""
     try:
-        # التحقق من حدود الجلسة
         if not anti_ban.check_session_limits():
             raise HTTPException(
                 status_code=429,
@@ -166,9 +165,18 @@ async def _download_task(request: DownloadRequest):
         })
 
     except Exception as e:
+        error_msg = str(e)
+        # رسائل واضحة للمستخدم
+        if "429" in error_msg:
+            user_msg = "تم حظر الطلبات مؤقتاً. انتظر بضع دقائق."
+        elif "Video unavailable" in error_msg:
+            user_msg = "الفيديو غير متاح."
+        else:
+            user_msg = f"فشل التحميل: {error_msg}"
+
         await _broadcast_ws({
             "type": "download_error",
-            "error": str(e),
+            "error": user_msg,
         })
 
 
@@ -181,11 +189,14 @@ async def download_subtitle_only(
 ):
     """تحميل الترجمة فقط"""
     try:
-        subtitle_file = await downloader.download_subtitle(
-            url=url,
-            language_code=lang.value,
-            subtitle_format=format.value,
-            auto_generated=auto,
+        subtitle_file = await asyncio.wait_for(
+            downloader.download_subtitle(
+                url=url,
+                language_code=lang.value,
+                subtitle_format=format.value,
+                auto_generated=auto,
+            ),
+            timeout=30,
         )
 
         if subtitle_file:
@@ -197,6 +208,8 @@ async def download_subtitle_only(
         else:
             raise HTTPException(status_code=404, detail="لم يتم العثور على ترجمة باللغة المطلوبة")
 
+    except asyncio.TimeoutError:
+        raise HTTPException(status_code=408, detail="انتهت مهلة تحميل الترجمة")
     except HTTPException:
         raise
     except Exception as e:
@@ -207,7 +220,10 @@ async def download_subtitle_only(
 async def download_video_only(url: str, quality: VideoQuality = VideoQuality.best):
     """تحميل الفيديو فقط"""
     try:
-        video_file = await downloader.download_video(url=url, quality=quality.value)
+        video_file = await asyncio.wait_for(
+            downloader.download_video(url=url, quality=quality.value),
+            timeout=300,
+        )
 
         if video_file:
             return {
@@ -216,8 +232,10 @@ async def download_video_only(url: str, quality: VideoQuality = VideoQuality.bes
                 "message": "تم تحميل الفيديو بنجاح"
             }
         else:
-            raise HTTPException(status_code=400, detail="فشل تحميل الفيديو من جميع المصادر. جرب فيديو آخر أو حاول لاحقاً.")
+            raise HTTPException(status_code=400, detail="فشل تحميل الفيديو. جرب فيديو آخر أو حاول لاحقاً.")
 
+    except asyncio.TimeoutError:
+        raise HTTPException(status_code=408, detail="انتهت مهلة تحميل الفيديو. قد يكون الملف كبيراً جداً.")
     except HTTPException:
         raise
     except Exception as e:
@@ -268,7 +286,7 @@ async def list_downloads():
 
 @app.get("/api/download/file")
 async def download_file(path: str):
-    """تحميل ملف (فتح نافذة حفظ باسم)"""
+    """تحميل ملف"""
     if not os.path.exists(path):
         raise HTTPException(status_code=404, detail="الملف غير موجود")
 
@@ -292,23 +310,14 @@ async def delete_file(path: str):
 @app.get("/api/anti-ban/status")
 async def anti_ban_status():
     """حالة مضاد الحظر"""
-    cookies_info = cookie_manager.get_info()
-    fallback_stats = downloader.fallback.get_stats()
     return {
         "request_count": anti_ban._request_count,
         "failed_attempts": anti_ban._failed_attempts,
         "session_active": anti_ban.check_session_limits(),
-        "current_user_agent": (anti_ban.get_current_user_agent() or "")[:50] + "...",
         "current_client": anti_ban.get_current_client(),
-        "failed_clients": anti_ban._failed_clients,
-        "working_client": anti_ban._working_client,
-        "fallback_stats": fallback_stats,
-        "cookies": {
-            "active": cookies_info.get("active", False),
-            "size": cookies_info.get("size", 0),
-            "lines": cookies_info.get("lines", 0),
-            "has_youtube": cookies_info.get("has_youtube", False),
-        },
+        "working_client": downloader._working_client,
+        "failed_clients": downloader._failed_clients,
+        "cookies_active": cookie_manager.is_active(),
     }
 
 
@@ -316,31 +325,14 @@ async def anti_ban_status():
 async def reset_anti_ban():
     """إعادة تعيين مضاد الحظر"""
     anti_ban.reset_session()
+    downloader._failed_clients.clear()
+    downloader._working_client = None
     return {"status": "reset", "message": "تم إعادة تعيين الجلسة"}
 
 
-@app.get("/api/fallback/status")
-async def fallback_status():
-    """حالة نظام التحميل البديل"""
-    try:
-        status = await downloader.fallback.get_instance_status()
-        stats = downloader.fallback.get_stats()
-        return {
-            "fallback_stats": stats,
-            "instance_status": status,
-            "yt_dlp_clients_tried": anti_ban._failed_clients,
-            "working_client": anti_ban._working_client,
-        }
-    except Exception as e:
-        return {
-            "error": str(e),
-            "fallback_stats": downloader.fallback.get_stats(),
-        }
-
-
 @app.post("/api/cookies/set")
 async def set_cookies(data: dict):
-    """حفظ الكوكيز عن طريق لصق المحتوى"""
+    """حفظ الكوكيز"""
     content = data.get("content", "")
     if not content:
         raise HTTPException(status_code=400, detail="المحتوى فارغ")
@@ -348,7 +340,7 @@ async def set_cookies(data: dict):
     success = cookie_manager.set_cookies(content)
     if success:
         return {"status": "ok", "message": "تم حفظ الكوكيز بنجاح", "info": cookie_manager.get_info()}
-    raise HTTPException(status_code=400, detail="فشل حفظ الكوكيز. تأكد من أن الملف يحتوي على كوكيز يوتيوب")
+    raise HTTPException(status_code=400, detail="فشل حفظ الكوكيز")
 
 
 @app.post("/api/cookies/upload")
@@ -365,13 +357,13 @@ async def upload_cookies_file(file: UploadFile = File(...)):
 
     success = cookie_manager.upload_cookies(text)
     if success:
-        return {"status": "ok", "message": "تم رفع الكوكيز بنجاح", "info": cookie_manager.get_info()}
-    raise HTTPException(status_code=400, detail="فشل حفظ الكوكيز. تأكد من أن الملف يحتوي على كوكيز يوتيوب")
+        return {"status": "ok", "message": "تم رفع الكوكيز بنجاح"}
+    raise HTTPException(status_code=400, detail="فشل حفظ الكوكيز")
 
 
 @app.get("/api/cookies/status")
 async def cookies_status():
-    """حالة الكوكيز الحالية"""
+    """حالة الكوكيز"""
     return cookie_manager.get_info()
 
 
@@ -390,7 +382,6 @@ async def websocket_endpoint(websocket: WebSocket):
     await websocket.accept()
     ws_connections.append(websocket)
 
-    # تعيين callback للتقدم
     def on_progress(progress):
         asyncio.create_task(_send_progress_ws(websocket, progress))
 
@@ -445,10 +436,11 @@ def main():
     """تشغيل الخادم"""
     import uvicorn
     print("=" * 60)
-    print("  YouTube Downloader v2.0 - Invidious-First")
+    print("  YouTube Downloader v3.0 - yt-dlp First")
     print("  تحميل فيديوهات يوتيوب مع الترجمات")
     print("=" * 60)
     print(f"\n  Download Directory: {DOWNLOAD_DIR}")
+    print(f"  Working Clients: {', '.join(WORKING_CLIENTS)}")
     print(f"  Server: http://0.0.0.0:8555")
     print(f"\n  Open your browser and go to: http://localhost:8555")
     print("=" * 60)