Remove media files from git and add to .gitignore

.gitignore

@@ -3,3 +3,8 @@ cookies.txt
 *.mp4
 *.mp3
 wireguard/wg_confs/wg0.conf
+*.jpg
+*.png
+*.info.json
+/cache/
+/tmp/

bot/cache.py

@@ -1,9 +1,17 @@
 import hashlib
-import os
 
-def cache_key(url, quality, audio=False):
-    raw = f"{url}:{quality}:{audio}"
-    return hashlib.sha256(raw.encode()).hexdigest()
 
-def cache_path(cache_dir, key, ext):
-    return os.path.join(cache_dir, f"{key}.{ext}")
+def cache_key(url: str, quality: str, audio: bool = False) -> str:
+    """Генерирует ключ кэша на основе URL, качества и типа"""
+    key_str = f"{url}_{quality}_{audio}"
+    return hashlib.sha256(key_str.encode()).hexdigest()
+
+
+def cache_path(cache_dir: str, key: str, extension: str) -> str:
+    """Создает путь к файлу в кэше"""
+    # Создаем вложенную структуру для лучшей организации
+    subdir = key[:2]
+    import os
+    full_dir = os.path.join(cache_dir, subdir)
+    os.makedirs(full_dir, exist_ok=True)
+    return os.path.join(full_dir, f"{key}.{extension}")

bot/downloader.py

@@ -2,6 +2,10 @@ import yt_dlp
 import threading
 import os
 import logging
+import subprocess
+import json
+import shutil
+from typing import List, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -15,13 +19,13 @@ def _progress_hook(cancel_event, progress_cb):
         if cancel_event.is_set():
             raise DownloadCancelled("Cancelled by user")
 
-        if d["status"] == "downloading":
+        if d["status"] in ["downloading", "finished"] and progress_cb:
             progress_cb(d)
 
     return hook
 
 
-# ---------------- VIDEO ----------------
+# ---------------- STANDARD VIDEO ----------------
 
 def download_video(
     url: str,
@@ -32,26 +36,233 @@ def download_video(
     progress_cb,
 ):
     ydl_opts = {
-        "format": quality,
+        "format": f"best[height<={quality}]/best",
         "outtmpl": out_path,
         "merge_output_format": "mp4",
         "cookiefile": cookies,
         "progress_hooks": [_progress_hook(cancel_event, progress_cb)],
         "quiet": True,
         "no_warnings": True,
-        # Настройки для TikTok
         "extractor_args": {
-            "tiktok": {
-                "skip_impersonation": True  # Пропускаем имитацию если зависимости не установлены
-            }
+            "tiktok": {"skip_impersonation": True},
+            "instagram": {"skip_impersonation": True},
         },
+        "concurrent_fragment_downloads": 4,
+        "http_chunk_size": 10485760,
     }
 
     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
         ydl.download([url])
 
 
-# ---------------- AUDIO FROM VIDEO ----------------
+# ---------------- ORIGINAL QUALITY ----------------
+
+def download_original_quality(
+    url: str,
+    out_path: str,
+    cookies: str | None,
+    cancel_event: threading.Event,
+    progress_cb,
+):
+    """Скачивает видео в оригинальном качестве"""
+    ydl_opts = {
+        "format": "best",
+        "outtmpl": out_path,
+        "merge_output_format": "mp4",
+        "cookiefile": cookies,
+        "progress_hooks": [_progress_hook(cancel_event, progress_cb)],
+        "quiet": True,
+        "no_warnings": True,
+        "extractor_args": {
+            "tiktok": {"skip_impersonation": True},
+            "instagram": {"skip_impersonation": True},
+        },
+        "format_sort": ["quality", "res", "codec", "size"],
+        "concurrent_fragment_downloads": 4,
+        "http_chunk_size": 10485760,
+    }
+
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([url])
+
+
+# ---------------- TIKTOK MUSIC ONLY ----------------
+
+def download_tiktok_music(
+    url: str,
+    out_path: str,
+    cookies: str | None,
+    cancel_event: threading.Event,
+    progress_cb,
+):
+    """Скачивает только звук из TikTok"""
+    ydl_opts = {
+        "format": "bestaudio/best",
+        "outtmpl": out_path.replace('.mp3', ''),
+        "cookiefile": cookies,
+        "progress_hooks": [_progress_hook(cancel_event, progress_cb)],
+        "postprocessors": [
+            {
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": "192",
+            },
+        ],
+        "quiet": True,
+        "no_warnings": True,
+        "extractor_args": {
+            "tiktok": {"skip_impersonation": True},
+        },
+        "concurrent_fragment_downloads": 4,
+        "http_chunk_size": 10485760,
+    }
+
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([url])
+
+
+# ---------------- ADD METADATA TO AUDIO ----------------
+
+def add_metadata_to_audio(
+    input_path: str,
+    output_path: str,
+    metadata: dict,
+):
+    """Добавляет метаданные к аудио файлу"""
+    try:
+        # Проверяем metadata
+        if metadata is None:
+            metadata = {}
+            
+        if not input_path.lower().endswith('.mp3'):
+            shutil.copy2(input_path, output_path)
+            return
+        
+        metadata_args = []
+        
+        # Добавляем метаданные
+        if metadata.get('title'):
+            metadata_args.extend(['-metadata', f'title={metadata["title"][:100]}'])
+        
+        if metadata.get('artist'):
+            metadata_args.extend(['-metadata', f'artist={metadata["artist"][:100]}'])
+        
+        if metadata.get('album'):
+            metadata_args.extend(['-metadata', f'album={metadata["album"][:100]}'])
+        
+        cmd = [
+            'ffmpeg',
+            '-i', input_path,
+            '-c', 'copy',
+            '-id3v2_version', '3',
+            '-loglevel', 'error',
+            '-y',
+            *metadata_args,
+            output_path
+        ]
+        
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        if result.returncode != 0:
+            shutil.copy2(input_path, output_path)
+            
+    except Exception as e:
+        logger.error(f"Metadata error: {e}")
+        shutil.copy2(input_path, output_path)
+
+
+# ---------------- PLAYLIST DOWNLOAD ----------------
+
+def download_playlist_videos(
+    playlist_info: dict,
+    output_dir: str,
+    cookies: str | None,
+    cancel_event: threading.Event,
+    progress_cb,
+) -> List[str]:
+    """Скачивает все видео из плейлиста"""
+    downloaded_files = []
+    
+    ydl_opts = {
+        "format": "best[height<=1080]/best",
+        "outtmpl": os.path.join(output_dir, "%(title)s [%(id)s].%(ext)s"),
+        "merge_output_format": "mp4",
+        "cookiefile": cookies,
+        "progress_hooks": [_progress_hook(cancel_event, progress_cb)],
+        "quiet": True,
+        "no_warnings": True,
+        "ignoreerrors": True,
+        "extract_flat": False,
+        "nooverwrites": True,
+        "concurrent_fragment_downloads": 4,
+        "http_chunk_size": 10485760,
+    }
+
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            entries = playlist_info.get('entries', [])
+            total_videos = len(entries)
+            
+            logger.info(f"Starting playlist download with {total_videos} videos")
+            
+            for i, entry in enumerate(entries, 1):
+                if cancel_event.is_set():
+                    raise DownloadCancelled("Cancelled by user")
+                
+                if not entry.get('url'):
+                    logger.warning(f"Entry {i} has no URL, skipping")
+                    continue
+                
+                video_url = entry['url']
+                video_title = entry.get('title', f'Video {i}')
+                
+                logger.info(f"Downloading video {i}/{total_videos}: {video_title}")
+                
+                try:
+                    # Загружаем видео
+                    info = ydl.extract_info(video_url, download=True)
+                    
+                    if not info:
+                        logger.error(f"Failed to extract info for video {i}")
+                        continue
+                    
+                    # Получаем имя фактически созданного файла
+                    filename = ydl.prepare_filename(info)
+                    
+                    # Проверяем существование файла
+                    if os.path.exists(filename):
+                        downloaded_files.append(filename)
+                        logger.info(f"Successfully downloaded: {os.path.basename(filename)}")
+                    else:
+                        # Ищем файл с другим расширением
+                        base_name = filename.rsplit('.', 1)[0]
+                        for ext in ['.mp4', '.mkv', '.webm', '.flv']:
+                            alt_path = base_name + ext
+                            if os.path.exists(alt_path):
+                                downloaded_files.append(alt_path)
+                                logger.info(f"Found file with extension {ext}: {os.path.basename(alt_path)}")
+                                break
+                        else:
+                            logger.error(f"File not found for video {i}")
+                            
+                except Exception as e:
+                    logger.error(f"Error downloading video {i} ({video_title}): {e}")
+                    continue
+        
+        logger.info(f"Playlist download complete. Downloaded {len(downloaded_files)} files")
+        return downloaded_files
+        
+    except Exception as e:
+        logger.error(f"Error downloading playlist: {e}")
+        raise
+
+
+# ---------------- STANDARD AUDIO ----------------
 
 def download_audio(
     url: str,
@@ -69,20 +280,17 @@ def download_audio(
             {
                 "key": "FFmpegExtractAudio",
                 "preferredcodec": "mp3",
-                "preferredquality": "320",
+                "preferredquality": "192",
             },
-            {"key": "FFmpegMetadata"},
-            {"key": "EmbedThumbnail"},
         ],
-        "writethumbnail": True,
         "quiet": True,
         "no_warnings": True,
-        # Настройки для TikTok
         "extractor_args": {
-            "tiktok": {
-                "skip_impersonation": True
-            }
+            "tiktok": {"skip_impersonation": True},
+            "instagram": {"skip_impersonation": True},
         },
+        "concurrent_fragment_downloads": 4,
+        "http_chunk_size": 10485760,
     }
 
     with yt_dlp.YoutubeDL(ydl_opts) as ydl:

bot/info.py

@@ -1,12 +1,93 @@
 import yt_dlp
+import re
 
-def extract_info(url, cookies):
-    opts = {
+
+def extract_info(url: str, cookies_file: str = None) -> dict:
+    """Извлекает информацию о видео"""
+    ydl_opts = {
         "quiet": True,
-        "skip_download": True,
+        "no_warnings": True,
+        "cookiefile": cookies_file,
+        "extractor_args": {
+            "tiktok": {"skip_impersonation": True},
+            "instagram": {"skip_impersonation": True},
+        },
     }
-    if cookies:
-        opts["cookiefile"] = cookies
+    
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        try:
+            return ydl.extract_info(url, download=False)
+        except:
+            return None
 
-    with yt_dlp.YoutubeDL(opts) as ydl:
-        return ydl.extract_info(url, download=False)
+
+def is_playlist(url: str) -> bool:
+    """Проверяет, является ли ссылка плейлистом"""
+    # Паттерны для плейлистов
+    playlist_patterns = [
+        r"youtube\.com/playlist",  # YouTube плейлист
+        r"youtube\.com/watch.*list=",  # YouTube видео из плейлиста
+        r"youtu\.be/.*list=",  # Сокращенная ссылка YouTube
+    ]
+    
+    for pattern in playlist_patterns:
+        if re.search(pattern, url, re.IGNORECASE):
+            return True
+    
+    # Используем yt-dlp для более точной проверки
+    try:
+        ydl_opts = {"quiet": True, "no_warnings": True}
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=False, process=False)
+            return info.get('_type') == 'playlist'
+    except:
+        return False
+
+
+def get_platform_info(url: str) -> str:
+    """Определяет платформу по ссылке"""
+    patterns = {
+        "youtube": r"(youtube\.com|youtu\.be)",
+        "tiktok": r"tiktok\.com",
+        "instagram": r"(instagram\.com|instagr\.am)",
+        "twitter": r"(twitter\.com|x\.com)",
+        "facebook": r"facebook\.com",
+        "vk": r"vk\.com",
+        "rutube": r"rutube\.ru",
+        "vimeo": r"vimeo\.com",
+        "twitch": r"twitch\.tv",
+        "dailymotion": r"dailymotion\.com",
+    }
+    
+    for platform, pattern in patterns.items():
+        if re.search(pattern, url, re.IGNORECASE):
+            return platform
+    
+    return "other"
+
+
+def get_playlist_info(url: str) -> dict:
+    """Получает информацию о плейлисте"""
+    ydl_opts = {
+        "quiet": True,
+        "no_warnings": True,
+        "extract_flat": True,
+        "playlistend": 50,  # Ограничиваем количество видео (можно изменить)
+    }
+    
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        try:
+            return ydl.extract_info(url, download=False)
+        except:
+            return None
+
+
+def get_first_video_from_playlist(url: str) -> str:
+    """Получает первую ссылку на видео из плейлиста"""
+    playlist_info = get_playlist_info(url)
+    
+    if playlist_info and playlist_info.get('entries'):
+        first_video = playlist_info['entries'][0]
+        return first_video.get('url')
+    
+    return None

bot/keyboards.py

@@ -2,27 +2,88 @@ from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
 
 
 def quality_keyboard():
-    return InlineKeyboardMarkup(
-        inline_keyboard=[
-            [
-                InlineKeyboardButton(text="480p", callback_data="q:best[height<=480]"),
-                InlineKeyboardButton(text="720p", callback_data="q:best[height<=720]"),
-            ],
-            [
-                InlineKeyboardButton(text="1080p", callback_data="q:best[height<=1080]"),
-                InlineKeyboardButton(text="4K", callback_data="q:bestvideo+bestaudio"),
-            ],
-            [
-                InlineKeyboardButton(text="🎧 Аудио из видео", callback_data="audio"),
-            ]
+    """Клавиатура выбора качества"""
+    keyboard = [
+        [
+            InlineKeyboardButton(text="📹 480p", callback_data="q:480"),
+            InlineKeyboardButton(text="📹 720p", callback_data="q:720"),
+            InlineKeyboardButton(text="🎬 1080p", callback_data="q:1080"),
+            InlineKeyboardButton(text="🎥 1440p", callback_data="q:1440"),
+        ],
+        [
+            InlineKeyboardButton(text="🎧 Аудио", callback_data="audio"),
+            InlineKeyboardButton(text="❌ Отмена", callback_data="cancel"),
         ]
-    )
-
+    ]
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 
 def cancel_keyboard():
-    return InlineKeyboardMarkup(
-        inline_keyboard=[
-            [InlineKeyboardButton(text="❌ Отменить", callback_data="cancel")]
+    """Клавиатура с кнопкой отмены"""
+    keyboard = [
+        [InlineKeyboardButton(text="⛔ Отменить загрузку", callback_data="cancel")]
+    ]
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def playlist_keyboard(confirm=False):
+    """Клавиатура для плейлистов"""
+    if confirm:
+        keyboard = [
+            [
+                InlineKeyboardButton(text="✅ Да, загрузить все", callback_data="playlist_confirm_yes"),
+                InlineKeyboardButton(text="❌ Нет, отменить", callback_data="playlist_confirm_no"),
+            ]
         ]
-    )
+    else:
+        keyboard = [
+            [
+                InlineKeyboardButton(text="📁 Загрузить все видео", callback_data="playlist_all"),
+                InlineKeyboardButton(text="🎬 Только первое видео", callback_data="playlist_first"),
+            ],
+            [
+                InlineKeyboardButton(text="❌ Отмена", callback_data="cancel"),
+            ]
+        ]
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def platform_keyboard(platform):
+    """Клавиатура для Instagram"""
+    keyboard = [
+        [
+            InlineKeyboardButton(text=f"🎬 Оригинальное качество", callback_data="original_quality"),
+        ],
+        [
+            InlineKeyboardButton(text="📹 480p", callback_data="q:480"),
+            InlineKeyboardButton(text="📹 720p", callback_data="q:720"),
+            InlineKeyboardButton(text="🎬 1080p", callback_data="q:1080"),
+        ],
+        [
+            InlineKeyboardButton(text="🎧 Аудио", callback_data="audio"),
+            InlineKeyboardButton(text="❌ Отмена", callback_data="cancel"),
+        ]
+    ]
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def tiktok_keyboard():
+    """Специальная клавиатура для TikTok"""
+    keyboard = [
+        [
+            InlineKeyboardButton(text="🎬 Оригинальное качество", callback_data="original_quality"),
+        ],
+        [
+            InlineKeyboardButton(text="📹 480p", callback_data="q:480"),
+            InlineKeyboardButton(text="📹 720p", callback_data="q:720"),
+            InlineKeyboardButton(text="🎬 1080p", callback_data="q:1080"),
+        ],
+        [
+            InlineKeyboardButton(text="🎧 Аудио из видео", callback_data="audio"),
+            InlineKeyboardButton(text="🎵 Только звук (TikTok)", callback_data="tiktok_music"),
+        ],
+        [
+            InlineKeyboardButton(text="❌ Отмена", callback_data="cancel"),
+        ]
+    ]
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)

bot/main.py

@@ -5,9 +5,10 @@ import logging
 import subprocess
 import time
 from datetime import datetime
+from typing import Optional
 
 from aiogram import Bot, Dispatcher, F
-from aiogram.types import Message, CallbackQuery, FSInputFile
+from aiogram.types import Message, CallbackQuery, FSInputFile, InputMediaDocument
 from aiogram.client.session.aiohttp import AiohttpSession
 from aiogram.client.telegram import TelegramAPIServer
 
@@ -21,11 +22,25 @@ from config import (
     CACHE_MAX_AGE_DAYS,
     CACHE_MAX_SIZE_MB,
 )
-from keyboards import quality_keyboard, cancel_keyboard
-from downloader import download_video, download_audio, DownloadCancelled
+from keyboards import (
+    quality_keyboard, 
+    cancel_keyboard, 
+    playlist_keyboard,
+    platform_keyboard,
+    tiktok_keyboard,
+)
+from downloader import (
+    download_video, 
+    download_audio, 
+    download_original_quality,
+    download_playlist_videos,
+    download_tiktok_music,
+    add_metadata_to_audio,  # Только для аудио
+    DownloadCancelled,
+)
 from middleware import PrivateMiddleware
 from rate_limit import check_rate_limit
-from info import extract_info
+from info import extract_info, is_playlist, get_platform_info
 from cache import cache_key, cache_path
 from cleanup import cleanup_tmp
 
@@ -55,6 +70,7 @@ dp.message.middleware(private_middleware)
 dp.callback_query.middleware(private_middleware)
 
 USER_URLS: dict[int, str] = {}
+USER_DATA: dict[int, dict] = {}
 ACTIVE_DOWNLOADS: dict[int, dict] = {}
 
 # -------------------- cache cleaning --------------------
@@ -106,7 +122,7 @@ def cleanup_old_cache():
                 files_with_mtime.sort(key=lambda x: x[1])
                 
                 # Удаляем старые файлы пока не достигнем лимита
-                target_size_mb = CACHE_MAX_SIZE_MB * 0.8  # Оставляем 80% от лимита
+                target_size_mb = CACHE_MAX_SIZE_MB * 0.8
                 
                 for file_path, mtime, size in files_with_mtime:
                     if total_size_mb <= target_size_mb:
@@ -186,13 +202,11 @@ def make_progress_cb(loop, message):
             downloaded = d.get("downloaded_bytes", 0)
             total = d.get("total_bytes") or d.get("total_bytes_estimate") or 1
             
-            # Избегаем деления на ноль
             if total <= 0:
                 return
                 
             percent = min(100, downloaded * 100 / total)
 
-            # Обновляем раз в ~2% и не чаще чем раз в 2 секунды
             current_time = time.time()
             if percent - last_percent["value"] < 2 and current_time - last_update["time"] < 2:
                 return
@@ -203,7 +217,6 @@ def make_progress_cb(loop, message):
             bar = render_bar(percent)
             eta = d.get("eta")
             
-            # Безопасное форматирование ETA
             if eta is None or eta == "?":
                 eta_str = "?"
             else:
@@ -232,11 +245,47 @@ def make_progress_cb(loop, message):
     return cb
 
 
+def make_playlist_progress_cb(loop, message, total_videos: int):
+    current_video = {"value": 0}
+    last_update = {"time": 0}
+
+    async def update(d):
+        try:
+            current_time = time.time()
+            if current_time - last_update["time"] < 3:
+                return
+                
+            last_update["time"] = current_time
+
+            if d.get("status") == "finished":
+                current_video["value"] += 1
+                
+                text = (
+                    f"📁 <b>Загрузка плейлиста</b>\n"
+                    f"📹 Видео: {current_video['value']}/{total_videos}\n"
+                    f"⏳ Продолжаем загрузку..."
+                )
+
+                await message.edit_text(
+                    text,
+                    parse_mode="HTML"
+                )
+        except Exception as e:
+            logger.error(f"Error updating playlist progress: {e}")
+
+    def cb(d):
+        asyncio.run_coroutine_threadsafe(update(d), loop)
+
+    return cb
+
+
 def optimize_for_telegram(input_path: str, output_path: str) -> bool:
     """
-    Оптимизирует видео для телеграма
+    Оптимизирует видео для телеграма (без метаданных)
     """
     try:
+        import shutil
+        
         # Проверяем размер файла
         file_size_mb = os.path.getsize(input_path) / (1024 * 1024)
         
@@ -245,7 +294,7 @@ def optimize_for_telegram(input_path: str, output_path: str) -> bool:
             crf = 28
         else:
             crf = 23
-            
+        
         cmd = [
             'ffmpeg',
             '-i', input_path,
@@ -269,7 +318,6 @@ def optimize_for_telegram(input_path: str, output_path: str) -> bool:
         
         if result.returncode != 0:
             logger.error(f"FFmpeg error: {result.stderr}")
-            import shutil
             shutil.copy2(input_path, output_path)
             return False
             
@@ -282,6 +330,28 @@ def optimize_for_telegram(input_path: str, output_path: str) -> bool:
         return False
 
 
+def get_video_info_for_audio(video_info: dict) -> dict:
+    """Получает информацию о видео для метаданных аудио"""
+    if not video_info:
+        return {}
+    
+    metadata = {
+        'title': video_info.get('title', ''),
+        'artist': video_info.get('uploader', ''),
+        'album': video_info.get('title', '')[:50],
+        'url': video_info.get('webpage_url', ''),
+    }
+    
+    # Для TikTok добавляем информацию о музыке
+    if video_info.get('extractor') == 'TikTok':
+        if video_info.get('track'):
+            metadata['title'] = video_info.get('track', metadata['title'])
+        if video_info.get('artist'):
+            metadata['artist'] = video_info.get('artist', metadata['artist'])
+    
+    return metadata
+
+
 # -------------------- handlers --------------------
 
 @dp.message(F.text == "/start")
@@ -289,12 +359,37 @@ async def start(message: Message):
     await message.answer(
         "👋 <b>Привет!</b>\n\n"
         "📥 Я скачиваю <b>видео</b> и <b>звук из видео</b> по ссылке.\n\n"
-        "🔄 Кэш автоматически очищается раз в сутки\n"
+        "✨ <b>Новые возможности:</b>\n"
+        "• 🎬 Оригинальное качество (Instagram, TikTok)\n"
+        "• 📁 Плейлисты YouTube\n"
+        "• 🎵 Отдельный звук для TikTok\n"
+        "• 🔄 Автоочистка кэша\n\n"
         "👉 Просто отправь ссылку.",
         parse_mode="HTML"
     )
 
 
+@dp.message(F.text == "/help")
+async def help_command(message: Message):
+    await message.answer(
+        "📚 <b>Справка по командам:</b>\n\n"
+        "• <code>/start</code> - Начать работу\n"
+        "• <code>/help</code> - Эта справка\n"
+        "• <code>/cache_stats</code> - Статистика кэша\n\n"
+        "✨ <b>Поддерживаемые платформы:</b>\n"
+        "• YouTube (видео и плейлисты)\n"
+        "• TikTok (оригинальное качество + звук отдельно)\n"
+        "• Instagram (Reels, видео, IGTV)\n"
+        "• Twitter/X, Facebook, VK и другие\n\n"
+        "🎯 <b>Особенности:</b>\n"
+        "• 🎵 TikTok: можно скачать отдельно звук\n"
+        "• 🎬 Instagram/TikTok: оригинальное качество\n"
+        "• 📁 Плейлисты: загрузка всех видео\n"
+        "• 🎧 Аудио: извлечение звука из любого видео",
+        parse_mode="HTML"
+    )
+
+
 @dp.message(F.text == "/cache_stats")
 async def cache_stats(message: Message):
     """Показывает статистику кэша"""
@@ -305,36 +400,11 @@ async def cache_stats(message: Message):
         for root, dirs, files in os.walk(CACHE_DIR):
             file_count += len(files)
         
-        # Получаем время последнего изменения самого старого файла
-        oldest_time = None
-        newest_time = None
-        
-        for root, dirs, files in os.walk(CACHE_DIR):
-            for file in files:
-                file_path = os.path.join(root, file)
-                try:
-                    mtime = os.path.getmtime(file_path)
-                    if oldest_time is None or mtime < oldest_time:
-                        oldest_time = mtime
-                    if newest_time is None or mtime > newest_time:
-                        newest_time = mtime
-                except:
-                    pass
-        
-        if oldest_time:
-            oldest_str = datetime.fromtimestamp(oldest_time).strftime("%d.%m.%Y %H:%M")
-            newest_str = datetime.fromtimestamp(newest_time).strftime("%d.%m.%Y %H:%M")
-            age_info = f"🗓 Самый старый: {oldest_str}\n" \
-                      f"🆕 Самый новый: {newest_str}"
-        else:
-            age_info = "🗓 Кэш пуст"
-        
         await message.answer(
             f"📊 <b>Статистика кэша:</b>\n\n"
             f"📁 Файлов: {file_count}\n"
             f"💾 Размер: {total_size_mb:.2f} МБ\n"
-            f"⏰ Очистка: ежедневно в 3:00\n\n"
-            f"{age_info}",
+            f"⏰ Очистка: ежедневно в 3:00",
             parse_mode="HTML"
         )
     except Exception as e:
@@ -345,12 +415,55 @@ async def cache_stats(message: Message):
 @dp.message(F.text.startswith("http"))
 async def handle_link(message: Message):
     url = message.text.strip()
-    USER_URLS[message.from_user.id] = url
-    await message.answer(
-        "🔽 <b>Выбери формат загрузки:</b>",
-        reply_markup=quality_keyboard(),
-        parse_mode="HTML"
-    )
+    user_id = message.from_user.id
+    
+    USER_URLS[user_id] = url
+    
+    # Определяем платформу
+    platform_info = await asyncio.to_thread(get_platform_info, url)
+    
+    # Для TikTok показываем специальное меню
+    if platform_info == "tiktok":
+        USER_DATA[user_id] = {"platform": platform_info}
+        await message.answer(
+            f"🎵 <b>Ссылка с TikTok</b>\n\n"
+            "Выберите что скачать:",
+            reply_markup=tiktok_keyboard(),
+            parse_mode="HTML"
+        )
+        return
+    
+    # Проверяем, является ли ссылка плейлистом (кроме TikTok)
+    try:
+        is_playlist_url = await asyncio.to_thread(is_playlist, url)
+        if is_playlist_url:
+            USER_DATA[user_id] = {"is_playlist": True}
+            await message.answer(
+                "📁 <b>Обнаружен плейлист!</b>\n\n"
+                "Выберите действие:",
+                reply_markup=playlist_keyboard(),
+                parse_mode="HTML"
+            )
+            return
+    except:
+        pass
+    
+    # Для Instagram предлагаем оригинальное качество
+    if platform_info == "instagram":
+        USER_DATA[user_id] = {"platform": platform_info}
+        await message.answer(
+            f"📸 <b>Ссылка с Instagram</b>\n\n"
+            "Выберите качество загрузки:",
+            reply_markup=platform_keyboard(platform_info),
+            parse_mode="HTML"
+        )
+    else:
+        # Для других платформ обычное меню
+        await message.answer(
+            "🔽 <b>Выбери формат загрузки:</b>",
+            reply_markup=quality_keyboard(),
+            parse_mode="HTML"
+        )
 
 
 @dp.callback_query(F.data == "cancel")
@@ -366,7 +479,241 @@ async def cancel_download(callback: CallbackQuery):
         await callback.answer("❌ Нет активной загрузки", show_alert=True)
 
 
-# ---------------- VIDEO ----------------
+# ---------------- TIKTOK SPECIAL HANDLERS ----------------
+
+@dp.callback_query(F.data == "tiktok_music")
+async def handle_tiktok_music(callback: CallbackQuery):
+    """Отдельная загрузка звука из TikTok"""
+    await callback.answer()
+    user_id = callback.from_user.id
+    url = USER_URLS.get(user_id)
+    
+    if not url:
+        await callback.message.answer("❌ Ссылка не найдена")
+        return
+    
+    if not check_rate_limit(user_id, RATE_LIMIT_SECONDS):
+        await callback.message.answer("⏳ Подожди немного перед следующим запросом")
+        return
+    
+    await callback.message.edit_reply_markup(reply_markup=None)
+    status = await callback.message.answer("🎵 <b>Извлекаю звук из TikTok…</b>", parse_mode="HTML")
+    
+    key = cache_key(url, "tiktok_music", audio=True)
+    final_path = cache_path(CACHE_DIR, key, "mp3")
+    tmp_path = os.path.join(TMP_DIR, f"{key}.mp3")
+    
+    # Создаем директории если не существуют
+    os.makedirs(TMP_DIR, exist_ok=True)
+    os.makedirs(os.path.dirname(final_path), exist_ok=True)
+    
+    # Проверяем кэш
+    if os.path.exists(final_path):
+        await status.edit_text("📤 <b>Отправляю звук из кэша…</b>", parse_mode="HTML")
+        try:
+            await callback.message.answer_audio(FSInputFile(final_path))
+            size_mb = os.path.getsize(final_path) / 1024 / 1024
+            await callback.message.answer(
+                f"✅ <b>Готово! (Звук из TikTok)</b>\n📦 Размер: {size_mb:.1f} МБ",
+                parse_mode="HTML"
+            )
+        except Exception as e:
+            logger.error(f"Error sending cached audio: {e}")
+            await status.edit_text("❌ Ошибка при отправке звука")
+        return
+    
+    cancel_event = threading.Event()
+    ACTIVE_DOWNLOADS[user_id] = {"cancel": cancel_event}
+    loop = asyncio.get_running_loop()
+    progress_cb = make_progress_cb(loop, status)
+    
+    try:
+        # Загружаем звук из TikTok
+        await asyncio.to_thread(
+            download_tiktok_music,
+            url,
+            tmp_path,
+            COOKIES_FILE,
+            cancel_event,
+            progress_cb,
+        )
+        
+        # Проверяем, был ли отменен процесс
+        if cancel_event.is_set():
+            await status.edit_text("⛔ Загрузка отменена")
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+            return
+        
+        # Проверяем, создан ли файл
+        if not os.path.exists(tmp_path):
+            raise Exception("Аудио файл не был создан")
+            
+        # Проверяем размер файла
+        file_size = os.path.getsize(tmp_path)
+        if file_size == 0:
+            os.remove(tmp_path)
+            raise Exception("Создан пустой аудио файл")
+        
+        # Добавляем метаданные к аудио
+        try:
+            info = await asyncio.to_thread(extract_info, url, COOKIES_FILE)
+            if info:
+                metadata = get_video_info_for_audio(info)
+                await asyncio.to_thread(add_metadata_to_audio, tmp_path, tmp_path + "_meta.mp3", metadata)
+                if os.path.exists(tmp_path + "_meta.mp3"):
+                    os.remove(tmp_path)
+                    os.rename(tmp_path + "_meta.mp3", tmp_path)
+        except Exception as e:
+            logger.error(f"Error adding metadata to audio: {e}")
+        
+        # Перемещаем файл в кэш
+        if os.path.exists(final_path):
+            os.remove(final_path)
+        os.rename(tmp_path, final_path)
+        
+    except DownloadCancelled:
+        await status.edit_text("⛔ Загрузка отменена")
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+        return
+    except Exception as e:
+        logger.error(f"Error downloading TikTok music: {str(e)}")
+        await status.edit_text(f"❌ Ошибка: {str(e)[:100]}")
+        if os.path.exists(tmp_path):
+            try:
+                os.remove(tmp_path)
+            except:
+                pass
+        return
+    finally:
+        ACTIVE_DOWNLOADS.pop(user_id, None)
+    
+    await status.edit_text("📤 <b>Отправляю звук…</b>", parse_mode="HTML")
+    
+    try:
+        await callback.message.answer_audio(FSInputFile(final_path))
+        size_mb = os.path.getsize(final_path) / 1024 / 1024
+        await callback.message.answer(
+            f"✅ <b>Готово! (Звук из TikTok)</b>\n📦 Размер: {size_mb:.1f} МБ",
+            parse_mode="HTML"
+        )
+    except Exception as e:
+        logger.error(f"Error sending audio: {e}")
+        await status.edit_text("❌ Ошибка при отправке звука")
+    
+    cleanup_tmp(TMP_DIR)
+
+
+# ---------------- ORIGINAL QUALITY HANDLERS ----------------
+
+@dp.callback_query(F.data == "original_quality")
+async def handle_original_quality(callback: CallbackQuery):
+    await callback.answer()
+    user_id = callback.from_user.id
+    url = USER_URLS.get(user_id)
+    
+    if not url:
+        await callback.message.answer("❌ Ссылка не найдена")
+        return
+    
+    if not check_rate_limit(user_id, RATE_LIMIT_SECONDS):
+        await callback.message.answer("⏳ Подожди немного перед следующим запросом")
+        return
+    
+    await callback.message.edit_reply_markup(reply_markup=None)
+    status = await callback.message.answer("🎬 <b>Загрузка в оригинальном качестве…</b>", parse_mode="HTML")
+    
+    key = cache_key(url, "original", audio=False)
+    final_path = cache_path(CACHE_DIR, key, "mp4")
+    tmp_path = os.path.join(TMP_DIR, f"{key}.mp4")
+    
+    # Проверяем кэш
+    if os.path.exists(final_path):
+        await status.edit_text("📤 <b>Отправляю файл из кэша…</b>", parse_mode="HTML")
+        try:
+            await callback.message.answer_video(FSInputFile(final_path))
+            size_mb = os.path.getsize(final_path) / 1024 / 1024
+            await callback.message.answer(
+                f"✅ <b>Готово! (Оригинальное качество)</b>\n📦 Размер: {size_mb:.1f} МБ",
+                parse_mode="HTML"
+            )
+        except Exception as e:
+            logger.error(f"Error sending cached file: {e}")
+            await status.edit_text("❌ Ошибка при отправке файла")
+        return
+    
+    cancel_event = threading.Event()
+    ACTIVE_DOWNLOADS[user_id] = {"cancel": cancel_event}
+    loop = asyncio.get_running_loop()
+    progress_cb = make_progress_cb(loop, status)
+    
+    try:
+        await asyncio.to_thread(
+            download_original_quality,
+            url,
+            tmp_path,
+            COOKIES_FILE,
+            cancel_event,
+            progress_cb,
+        )
+        
+        if cancel_event.is_set():
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+            await status.edit_text("⛔ Загрузка отменена")
+            return
+            
+        os.rename(tmp_path, final_path)
+        
+    except DownloadCancelled:
+        await status.edit_text("⛔ Загрузка отменена")
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+        return
+    except Exception as e:
+        logger.error(f"Error downloading original quality: {e}")
+        await status.edit_text(
+            "❌ Не удалось скачать в оригинальном качестве\n"
+            "💡 Попробуй обычное качество"
+        )
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+        return
+    finally:
+        ACTIVE_DOWNLOADS.pop(user_id, None)
+    
+    await status.edit_text("📤 <b>Отправляю видео…</b>", parse_mode="HTML")
+    
+    try:
+        await callback.message.answer_video(
+            FSInputFile(final_path),
+            supports_streaming=True
+        )
+        size_mb = os.path.getsize(final_path) / 1024 / 1024
+        await callback.message.answer(
+            f"✅ <b>Готово! (Оригинальное качество)</b>\n📦 Размер: {size_mb:.1f} МБ",
+            parse_mode="HTML"
+        )
+    except Exception as e:
+        logger.error(f"Error sending video: {e}")
+        try:
+            await callback.message.answer_document(FSInputFile(final_path))
+            size_mb = os.path.getsize(final_path) / 1024 / 1024
+            await callback.message.answer(
+                f"✅ <b>Отправлено как документ (Оригинальное качество)</b>\n📦 Размер: {size_mb:.1f} МБ",
+                parse_mode="HTML"
+            )
+        except Exception as e2:
+            logger.error(f"Error sending as document: {e2}")
+            await status.edit_text("❌ Ошибка при отправке файла")
+            if os.path.exists(final_path):
+                os.remove(final_path)
+    
+    cleanup_tmp(TMP_DIR)
+
+
+# ---------------- STANDARD VIDEO HANDLER ----------------
 
 @dp.callback_query(F.data.startswith("q:"))
 async def handle_video(callback: CallbackQuery):
@@ -386,17 +733,6 @@ async def handle_video(callback: CallbackQuery):
     await callback.message.edit_reply_markup(reply_markup=None)
     status = await callback.message.answer("🔍 <b>Анализирую ссылку…</b>", parse_mode="HTML")
 
-    # Извлекаем информацию о видео
-    try:
-        info = await asyncio.to_thread(extract_info, url, COOKIES_FILE)
-        if not info:
-            await status.edit_text("❌ Не удалось получить информацию о видео")
-            return
-    except Exception as e:
-        logger.error(f"Error extracting info: {e}")
-        await status.edit_text("❌ Ошибка при анализе ссылки")
-        return
-
     key = cache_key(url, quality, audio=False)
     final_path = cache_path(CACHE_DIR, key, "mp4")
     tmp_path = os.path.join(TMP_DIR, f"{key}.mp4")
@@ -439,16 +775,20 @@ async def handle_video(callback: CallbackQuery):
                 os.remove(tmp_path)
             await status.edit_text("⛔ Загрузка отменена")
             return
-            
-        # Оптимизируем видео для телеграма
-        await status.edit_text("⚙️ <b>Оптимизирую видео для телеграма…</b>", parse_mode="HTML")
-        await asyncio.to_thread(optimize_for_telegram, tmp_path, optimized_path)
         
-        # Удаляем исходный файл и используем оптимизированный
-        if os.path.exists(tmp_path):
-            os.remove(tmp_path)
+        # Оптимизируем видео для телеграма (кроме оригинального качества)
+        if quality != "original":
+            await status.edit_text("⚙️ <b>Оптимизирую видео для телеграма…</b>", parse_mode="HTML")
+            await asyncio.to_thread(optimize_for_telegram, tmp_path, optimized_path)
             
-        os.rename(optimized_path, final_path)
+            # Удаляем исходный файл и используем оптимизированный
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+                
+            os.rename(optimized_path, final_path)
+        else:
+            # Для оригинального качества не оптимизируем
+            os.rename(tmp_path, final_path)
         
     except DownloadCancelled:
         await status.edit_text("⛔ Загрузка отменена")
@@ -499,7 +839,7 @@ async def handle_video(callback: CallbackQuery):
     cleanup_tmp(TMP_DIR)
 
 
-# ---------------- AUDIO FROM VIDEO ----------------
+# ---------------- STANDARD AUDIO HANDLER ----------------
 
 @dp.callback_query(F.data == "audio")
 async def handle_audio(callback: CallbackQuery):
@@ -518,6 +858,13 @@ async def handle_audio(callback: CallbackQuery):
     await callback.message.edit_reply_markup(reply_markup=None)
     status = await callback.message.answer("🎧 <b>Подготовка аудио…</b>", parse_mode="HTML")
 
+    # Получаем информацию о видео для метаданных
+    video_info = None
+    try:
+        video_info = await asyncio.to_thread(extract_info, url, COOKIES_FILE)
+    except:
+        pass
+
     key = cache_key(url, "audio", audio=True)
     final_path = cache_path(CACHE_DIR, key, "mp3")
     tmp_path = os.path.join(TMP_DIR, f"{key}.mp3")
@@ -573,6 +920,14 @@ async def handle_audio(callback: CallbackQuery):
             os.remove(tmp_path)
             raise Exception("Создан пустой аудио файл")
         
+        # Добавляем метаданные к аудио
+        if video_info:
+            metadata = get_video_info_for_audio(video_info)
+            await asyncio.to_thread(add_metadata_to_audio, tmp_path, tmp_path + "_meta.mp3", metadata)
+            if os.path.exists(tmp_path + "_meta.mp3"):
+                os.remove(tmp_path)
+                os.rename(tmp_path + "_meta.mp3", tmp_path)
+        
         # Перемещаем файл в кэш
         if os.path.exists(final_path):
             os.remove(final_path)
@@ -611,6 +966,216 @@ async def handle_audio(callback: CallbackQuery):
     cleanup_tmp(TMP_DIR)
 
 
+# ---------------- PLAYLIST HANDLERS ----------------
+
+@dp.callback_query(F.data == "playlist_all")
+async def handle_playlist_all(callback: CallbackQuery):
+    await callback.answer()
+    user_id = callback.from_user.id
+    url = USER_URLS.get(user_id)
+    
+    if not url:
+        await callback.message.answer("❌ Ссылка не найдена")
+        return
+    
+    if not check_rate_limit(user_id, RATE_LIMIT_SECONDS * 3):
+        await callback.message.answer("⏳ Подожди немного перед следующим запросом")
+        return
+    
+    await callback.message.edit_reply_markup(reply_markup=None)
+    status = await callback.message.answer("📁 <b>Анализирую плейлист…</b>", parse_mode="HTML")
+    
+    try:
+        # Получаем информацию о плейлисте
+        from info import get_playlist_info
+        playlist_info = await asyncio.to_thread(get_playlist_info, url)
+        
+        if not playlist_info or 'entries' not in playlist_info:
+            await status.edit_text("❌ Не удалось получить информацию о плейлисте")
+            return
+        
+        video_count = len(playlist_info['entries'])
+        if video_count == 0:
+            await status.edit_text("❌ Плейлист пуст")
+            return
+        
+        # Подтверждение для больших плейлистов
+        if video_count > 10:
+            await callback.message.answer(
+                f"⚠️ <b>Внимание!</b>\n\n"
+                f"Плейлист содержит <b>{video_count}</b> видео.\n"
+                f"Это может занять много времени и места.\n\n"
+                f"Продолжить загрузку?",
+                reply_markup=playlist_keyboard(confirm=True),
+                parse_mode="HTML"
+            )
+            USER_DATA[user_id] = {"playlist_info": playlist_info, "status_message": status}
+            return
+        
+        await download_playlist_confirm(callback, user_id, playlist_info, status)
+        
+    except Exception as e:
+        logger.error(f"Error analyzing playlist: {e}")
+        await status.edit_text("❌ Ошибка при анализе плейлиста")
+
+
+@dp.callback_query(F.data == "playlist_confirm_yes")
+async def handle_playlist_confirm(callback: CallbackQuery):
+    await callback.answer()
+    user_id = callback.from_user.id
+    
+    data = USER_DATA.get(user_id, {})
+    playlist_info = data.get("playlist_info")
+    status = data.get("status_message")
+    
+    if not playlist_info or not status:
+        await callback.message.answer("❌ Данные плейлиста не найдены")
+        return
+    
+    await callback.message.edit_reply_markup(reply_markup=None)
+    await download_playlist_confirm(callback, user_id, playlist_info, status)
+
+
+async def download_playlist_confirm(callback, user_id, playlist_info, status):
+    """Загружает плейлист после подтверждения"""
+    try:
+        import uuid
+        import shutil
+        
+        video_count = len(playlist_info['entries'])
+        playlist_title = playlist_info.get('title', 'Плейлист')
+        
+        await status.edit_text(
+            f"📁 <b>Начинаю загрузку плейлиста</b>\n\n"
+            f"🎬 Название: {playlist_title}\n"
+            f"📹 Видео: {video_count}\n"
+            f"⏳ Подготовка...",
+            parse_mode="HTML"
+        )
+        
+        cancel_event = threading.Event()
+        ACTIVE_DOWNLOADS[user_id] = {"cancel": cancel_event}
+        loop = asyncio.get_running_loop()
+        progress_cb = make_playlist_progress_cb(loop, status, video_count)
+        
+        # Создаем временную директорию для плейлиста
+        playlist_dir = os.path.join(TMP_DIR, f"playlist_{uuid.uuid4().hex[:8]}")
+        os.makedirs(playlist_dir, exist_ok=True)
+        
+        # Загружаем плейлист
+        downloaded_files = await asyncio.to_thread(
+            download_playlist_videos,
+            playlist_info,
+            playlist_dir,
+            COOKIES_FILE,
+            cancel_event,
+            progress_cb
+        )
+        
+        if cancel_event.is_set():
+            await status.edit_text("⛔ Загрузка плейлиста отменена")
+            shutil.rmtree(playlist_dir, ignore_errors=True)
+            return
+        
+        if not downloaded_files:
+            await status.edit_text("❌ Не удалось загрузить видео из плейлиста")
+            shutil.rmtree(playlist_dir, ignore_errors=True)
+            return
+        
+        # Отправляем файлы частями
+        await status.edit_text(f"📤 <b>Отправляю {len(downloaded_files)} видео…</b>", parse_mode="HTML")
+        
+        # Сортируем файлы по размеру (сначала маленькие)
+        downloaded_files.sort(key=lambda x: os.path.getsize(x))
+        
+        sent_count = 0
+        for i, file_path in enumerate(downloaded_files, 1):
+            if cancel_event.is_set():
+                break
+                
+            try:
+                file_name = os.path.basename(file_path)
+                # Убираем расширение для имени файла
+                display_name = os.path.splitext(file_name)[0]
+                
+                # Отправляем файл с номером в подписи
+                await callback.message.answer_document(
+                    FSInputFile(file_path),
+                    caption=f"🎬 Видео {i}/{len(downloaded_files)}\n📁 {display_name[:50]}"
+                )
+                sent_count += 1
+                
+                # Небольшая пауза между отправками
+                await asyncio.sleep(1)
+                
+            except Exception as e:
+                logger.error(f"Error sending file {file_path}: {e}")
+                continue
+        
+        total_size = sum(os.path.getsize(f) for f in downloaded_files)
+        total_size_mb = total_size / (1024 * 1024)
+        
+        await callback.message.answer(
+            f"✅ <b>Плейлист загружен!</b>\n\n"
+            f"📁 Видео в плейлисте: {video_count}\n"
+            f"📤 Отправлено: {sent_count}\n"
+            f"💾 Общий размер: {total_size_mb:.1f} МБ\n"
+            f"🎬 Название: {playlist_title}",
+            parse_mode="HTML"
+        )
+        
+        # Очищаем временные файлы
+        shutil.rmtree(playlist_dir, ignore_errors=True)
+        
+    except DownloadCancelled:
+        await status.edit_text("⛔ Загрузка плейлиста отменена")
+    except Exception as e:
+        logger.error(f"Error downloading playlist: {e}")
+        await status.edit_text(f"❌ Ошибка: {str(e)[:100]}")
+    finally:
+        ACTIVE_DOWNLOADS.pop(user_id, None)
+        cleanup_tmp(TMP_DIR)
+
+
+@dp.callback_query(F.data == "playlist_confirm_no")
+async def handle_playlist_cancel(callback: CallbackQuery):
+    await callback.answer("Отменено", show_alert=True)
+    await callback.message.edit_reply_markup(reply_markup=None)
+
+
+@dp.callback_query(F.data == "playlist_first")
+async def handle_playlist_first(callback: CallbackQuery):
+    await callback.answer()
+    user_id = callback.from_user.id
+    url = USER_URLS.get(user_id)
+    
+    if not url:
+        await callback.message.answer("❌ Ссылка не найдена")
+        return
+    
+    # Получаем первое видео из плейлиста
+    try:
+        from info import get_first_video_from_playlist
+        video_url = await asyncio.to_thread(get_first_video_from_playlist, url)
+        
+        if not video_url:
+            await callback.message.answer("❌ Не удалось получить видео из плейлиста")
+            return
+        
+        # Сохраняем новую ссылку и показываем меню выбора качества
+        USER_URLS[user_id] = video_url
+        await callback.message.edit_reply_markup(reply_markup=None)
+        await callback.message.answer(
+            "🔽 <b>Выбери формат загрузки для первого видео:</b>",
+            reply_markup=quality_keyboard(),
+            parse_mode="HTML"
+        )
+        
+    except Exception as e:
+        logger.error(f"Error getting first video: {e}")
+        await callback.message.answer("❌ Ошибка при получении видео из плейлиста")
+
+
 # -------------------- entrypoint --------------------
 
 async def main():