videoDownloadTGbot/bot.py

import os
import re
import logging
import asyncio
import sqlite3
import time
from pathlib import Path
from urllib.parse import urlparse
from datetime import datetime

import httpx
from telegram import Update
from telegram.ext import Application, MessageHandler, filters, ContextTypes, CommandHandler

# Настройка логирования
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

# Токен бота и имя бота из переменных окружения
TELEGRAM_BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
TELEGRAM_BOT_USERNAME = os.getenv('TELEGRAM_BOT_USERNAME', 'vrubelVideoDownload_bot')

# URL сервисов для скачивания видео
YOUTUBE_DOWNLOADER_URL = os.getenv('YOUTUBE_DOWNLOADER_URL', 'http://localhost:5557')
INSTAGRAM_DOWNLOADER_URL = os.getenv('INSTAGRAM_DOWNLOADER_URL', 'http://localhost:5556')
VK_DOWNLOADER_URL = os.getenv('VK_DOWNLOADER_URL', 'http://localhost:5555')

# Базовая директория проекта (абсолютный путь), чтобы не зависеть от рабочей директории процесса
BASE_DIR = Path(__file__).resolve().parent

# Директория для временных файлов
DOWNLOADS_DIR = BASE_DIR / 'video'
DOWNLOADS_DIR.mkdir(parents=True, exist_ok=True)

# База данных (внутри папки data)
DATA_DIR = BASE_DIR / 'data'
DATA_DIR.mkdir(parents=True, exist_ok=True)
DB_FILE = DATA_DIR / 'bot.db'


def init_database():
    """Инициализирует базу данных и создает таблицы если их нет"""
    try:
        conn = sqlite3.connect(str(DB_FILE))
        cursor = conn.cursor()
        
        # Таблица пользователей
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS users (
                chat_id INTEGER PRIMARY KEY,
                username TEXT,
                first_name TEXT,
                first_seen TEXT NOT NULL,
                last_seen TEXT NOT NULL
            )
        ''')
        
        # Таблица статистики
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS stats (
                id INTEGER PRIMARY KEY CHECK (id = 1),
                total_downloads INTEGER DEFAULT 0
            )
        ''')
        
        # Инициализируем stats если его нет
        cursor.execute('SELECT COUNT(*) FROM stats')
        if cursor.fetchone()[0] == 0:
            cursor.execute('INSERT INTO stats (id, total_downloads) VALUES (1, 0)')
        
        conn.commit()
        conn.close()
        logger.info("База данных инициализирована")
    except Exception as e:
        logger.error(f"Ошибка при инициализации базы данных: {e}")

def get_total_downloads() -> int:
    """Возвращает общее количество скачанных видео"""
    try:
        conn = sqlite3.connect(str(DB_FILE))
        cursor = conn.cursor()
        cursor.execute('SELECT total_downloads FROM stats WHERE id = 1')
        result = cursor.fetchone()
        conn.close()
        return result[0] if result else 0
    except Exception as e:
        logger.error(f"Ошибка при получении количества скачанных видео: {e}")
        return 0

def increment_downloads():
    """Увеличивает счетчик скачанных видео"""
    try:
        conn = sqlite3.connect(str(DB_FILE))
        cursor = conn.cursor()
        cursor.execute('UPDATE stats SET total_downloads = total_downloads + 1 WHERE id = 1')
        conn.commit()
        new_total = get_total_downloads()
        conn.close()
        logger.info(f"Общее количество скачанных видео: {new_total}")
    except Exception as e:
        logger.error(f"Ошибка при увеличении счетчика скачанных видео: {e}")

def get_total_users() -> int:
    """Возвращает общее количество уникальных пользователей"""
    try:
        conn = sqlite3.connect(str(DB_FILE))
        cursor = conn.cursor()
        cursor.execute('SELECT COUNT(*) FROM users')
        result = cursor.fetchone()
        conn.close()
        return result[0] if result else 0
    except Exception as e:
        logger.error(f"Ошибка при получении количества пользователей: {e}")
        return 0

def add_user(chat_id: int, username: str = None, first_name: str = None):
    """Добавляет пользователя в базу данных или обновляет информацию о нем"""
    try:
        now = datetime.now().isoformat()
        conn = sqlite3.connect(str(DB_FILE))
        cursor = conn.cursor()
        
        # Проверяем, существует ли пользователь
        cursor.execute('SELECT chat_id FROM users WHERE chat_id = ?', (chat_id,))
        exists = cursor.fetchone()
        
        if exists:
            # Обновляем last_seen
            cursor.execute(
                'UPDATE users SET last_seen = ?, username = ?, first_name = ? WHERE chat_id = ?',
                (now, username, first_name, chat_id)
            )
        else:
            # Добавляем нового пользователя
            cursor.execute(
                'INSERT INTO users (chat_id, username, first_name, first_seen, last_seen) VALUES (?, ?, ?, ?, ?)',
                (chat_id, username, first_name, now, now)
            )
            total_users = get_total_users()
            logger.info(f"Добавлен новый пользователь (chat_id: {chat_id}). Всего пользователей: {total_users}")
        
        conn.commit()
        conn.close()
    except Exception as e:
        logger.error(f"Ошибка при добавлении пользователя: {e}")


def detect_video_source(url: str) -> str:
    """Определяет источник видео по URL"""
    domain = urlparse(url).netloc.lower()
    
    if 'youtube.com' in domain or 'youtu.be' in domain:
        return 'youtube'
    elif 'instagram.com' in domain:
        return 'instagram'
    elif 'vk.com' in domain or 'vkontakte.ru' in domain:
        return 'vk'
    else:
        return 'unknown'


def extract_urls_from_text(text: str) -> list[str]:
    """Извлекает все URL из текста сообщения"""
    # Регулярное выражение для поиска URL (http/https)
    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]]+'
    urls = re.findall(url_pattern, text)
    return urls


def cleanup_old_files():
    """Удаляет только .part файлы (недокачанные) из папки загрузок"""
    try:
        for file_path in DOWNLOADS_DIR.glob('*'):
            if not file_path.is_file():
                continue
            
            # Удаляем только .part файлы (недокачанные)
            if file_path.suffix == '.part':
                try:
                    file_path.unlink()
                    logger.info(f"Удален .part файл: {file_path.name}")
                except Exception as e:
                    logger.warning(f"Не удалось удалить .part файл {file_path.name}: {e}")
    except Exception as e:
        logger.error(f"Ошибка при очистке .part файлов: {e}")


async def download_youtube_video(url: str, chat_id: int, max_retries: int = 3) -> str:
    """Скачивает видео с YouTube через внешний сервис"""
    logger.info(f"YouTube: отправка запроса на внешний сервис {YOUTUBE_DOWNLOADER_URL}")
    
    last_error = None
    for attempt in range(max_retries):
        try:
            async with httpx.AsyncClient(timeout=600.0) as client:  # Увеличенный таймаут для YouTube
                # Отправляем запрос на YouTube сервис
                response = await client.post(
                    f"{YOUTUBE_DOWNLOADER_URL}/download/stream",
                    json={"url": url},
                    headers={"Content-Type": "application/json"}
                )
                
                if response.status_code != 200:
                    error_text = response.text
                    try:
                        error_json = response.json()
                        error_text = error_json.get('error', error_text)
                    except:
                        pass
                    raise Exception(f"YouTube сервис вернул ошибку {response.status_code}: {error_text}")
                
                # Сохраняем видео во временный файл
                video_data = response.content
                video_ext = 'mp4'  # По умолчанию mp4
                
                # Пробуем определить расширение из заголовков
                content_type = response.headers.get('Content-Type', '')
                if 'video/' in content_type:
                    video_ext = content_type.split('/')[-1].split(';')[0]
                
                # Получаем имя файла из заголовка или создаем случайное
                filename = response.headers.get('Content-Disposition', '')
                if filename and 'filename=' in filename:
                    video_filename = filename.split('filename=')[1].strip('"\'')
                else:
                    video_filename = f'{chat_id}_youtube_video.{video_ext}'
                
                # Сохраняем файл
                video_path = DOWNLOADS_DIR / video_filename
                with open(video_path, 'wb') as f:
                    f.write(video_data)
                
                logger.info(f"YouTube: видео скачано через внешний сервис: {video_path}")
                return str(video_path)
                
        except httpx.TimeoutException:
            last_error = Exception(f"Таймаут при запросе к YouTube сервису (попытка {attempt + 1}/{max_retries})")
            logger.warning(f"YouTube: таймаут при запросе к сервису: {last_error}")
        except Exception as e:
            last_error = e
            logger.warning(f"YouTube: попытка {attempt + 1}/{max_retries} не удалась: {e}")
        
        if attempt < max_retries - 1:
            await asyncio.sleep((attempt + 1) * 2)
    
    raise last_error or Exception("Неизвестная ошибка при скачивании с YouTube через внешний сервис")


async def download_instagram_video(url: str, chat_id: int, max_retries: int = 3) -> str:
    """Скачивает видео с Instagram через внешний сервис"""
    logger.info(f"Instagram: отправка запроса на внешний сервис {INSTAGRAM_DOWNLOADER_URL}")
    
    last_error = None
    for attempt in range(max_retries):
        try:
            async with httpx.AsyncClient(timeout=600.0) as client:  # Увеличенный таймаут для Instagram
                # Отправляем запрос на Instagram сервис
                response = await client.post(
                    f"{INSTAGRAM_DOWNLOADER_URL}/download/stream",
                    json={"url": url},
                    headers={"Content-Type": "application/json"}
                )
                
                if response.status_code != 200:
                    error_text = response.text
                    try:
                        error_json = response.json()
                        error_text = error_json.get('error', error_text)
                    except:
                        pass
                    raise Exception(f"Instagram сервис вернул ошибку {response.status_code}: {error_text}")
                
                # Сохраняем видео во временный файл
                video_data = response.content
                video_ext = 'mp4'  # По умолчанию mp4
                
                # Пробуем определить расширение из заголовков
                content_type = response.headers.get('Content-Type', '')
                if 'video/' in content_type:
                    video_ext = content_type.split('/')[-1].split(';')[0]
                
                # Получаем имя файла из заголовка или создаем случайное
                filename = response.headers.get('Content-Disposition', '')
                if filename and 'filename=' in filename:
                    video_filename = filename.split('filename=')[1].strip('"\'')
                else:
                    video_filename = f'{chat_id}_instagram_video.{video_ext}'
                
                # Сохраняем файл
                video_path = DOWNLOADS_DIR / video_filename
                with open(video_path, 'wb') as f:
                    f.write(video_data)
                
                logger.info(f"Instagram: видео скачано через внешний сервис: {video_path}")
                return str(video_path)
                
        except httpx.TimeoutException:
            last_error = Exception(f"Таймаут при запросе к Instagram сервису (попытка {attempt + 1}/{max_retries})")
            logger.warning(f"Instagram: таймаут при запросе к сервису: {last_error}")
        except Exception as e:
            last_error = e
            logger.warning(f"Instagram: попытка {attempt + 1}/{max_retries} не удалась: {e}")
        
        if attempt < max_retries - 1:
            await asyncio.sleep((attempt + 1) * 2)
    
    raise last_error or Exception("Неизвестная ошибка при скачивании с Instagram через внешний сервис")


async def download_vk_video(url: str, chat_id: int, max_retries: int = 3) -> str:
    """Скачивает видео с VK через внешний сервис"""
    logger.info(f"VK: отправка запроса на внешний сервис {VK_DOWNLOADER_URL}")
    
    last_error = None
    for attempt in range(max_retries):
        try:
            async with httpx.AsyncClient(timeout=600.0) as client:  # Увеличенный таймаут для VK
                # Отправляем запрос на VK сервис
                response = await client.post(
                    f"{VK_DOWNLOADER_URL}/download/stream",
                    json={"url": url},
                    headers={"Content-Type": "application/json"}
                )
                
                if response.status_code != 200:
                    error_text = response.text
                    try:
                        error_json = response.json()
                        error_text = error_json.get('error', error_text)
                    except:
                        pass
                    raise Exception(f"VK сервис вернул ошибку {response.status_code}: {error_text}")
                
                # Сохраняем видео во временный файл
                video_data = response.content
                video_ext = 'mp4'  # По умолчанию mp4
                
                # Пробуем определить расширение из заголовков
                content_type = response.headers.get('Content-Type', '')
                if 'video/' in content_type:
                    video_ext = content_type.split('/')[-1].split(';')[0]
                
                # Получаем имя файла из заголовка или создаем случайное
                filename = response.headers.get('Content-Disposition', '')
                if filename and 'filename=' in filename:
                    video_filename = filename.split('filename=')[1].strip('"\'')
                else:
                    video_filename = f'{chat_id}_vk_video.{video_ext}'
                
                # Сохраняем файл
                video_path = DOWNLOADS_DIR / video_filename
                with open(video_path, 'wb') as f:
                    f.write(video_data)
                
                logger.info(f"VK: видео скачано через внешний сервис: {video_path}")
                return str(video_path)
                
        except httpx.TimeoutException:
            last_error = Exception(f"Таймаут при запросе к VK сервису (попытка {attempt + 1}/{max_retries})")
            logger.warning(f"VK: таймаут при запросе к сервису: {last_error}")
        except Exception as e:
            last_error = e
            logger.warning(f"VK: попытка {attempt + 1}/{max_retries} не удалась: {e}")
        
        if attempt < max_retries - 1:
            await asyncio.sleep((attempt + 1) * 2)
    
    raise last_error or Exception("Неизвестная ошибка при скачивании с VK через внешний сервис")


async def download_video(url: str, chat_id: int, max_retries: int = 3) -> str:
    """Главная функция скачивания - вызывает нужную функцию в зависимости от источника"""
    source = detect_video_source(url)
    logger.info(f"Определен источник: {source} для URL: {url}")
    
    if source == 'youtube':
        return await download_youtube_video(url, chat_id, max_retries)
    elif source == 'instagram':
        return await download_instagram_video(url, chat_id, max_retries)
    elif source == 'vk':
        return await download_vk_video(url, chat_id, max_retries)
    else:
        raise Exception("Пардон, не умеем работать с этим источником")


async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обрабатывает сообщения от пользователей"""
    if not update.message or not update.message.text:
        return
    
    text = update.message.text.strip()
    chat_id = update.message.chat_id
    chat_type = update.message.chat.type  # 'private', 'group', 'supergroup'
    username = update.message.from_user.username if update.message.from_user else None
    first_name = update.message.from_user.first_name if update.message.from_user else None
    
    # Добавляем пользователя в статистику при первом взаимодействии
    add_user(chat_id, username, first_name)
    
    # Извлекаем все URL из текста
    urls = extract_urls_from_text(text)
    
    # Если это личный чат и нет ссылок, отправляем инструкцию
    if not urls and chat_type == 'private':
        await update.message.reply_text(
            "Пожалуйста, отправьте ссылку на видео.\n"
            "Поддерживаемые источники:\n"
            "• YouTube (youtube.com, youtu.be)\n"
            "• Instagram (instagram.com)\n"
            "• VK (vk.com)\n\n"
            "Для других источников: Пардон, не умеем 😅"
        )
        return
    
    # Если нет ссылок в группе, просто игнорируем сообщение
    if not urls:
        return
    
    # Обрабатываем первую найденную ссылку
    url = urls[0]
    
    # Проверяем источник до начала обработки
    source = detect_video_source(url)
    if source == 'unknown':
        # В группах не отвечаем на неподдерживаемые источники, чтобы не спамить
        if chat_type == 'private':
            await update.message.reply_text("Пардон, не умеем работать с этим источником 😅")
        return
    
    # Отправляем сообщение о начале обработки
    status_message = await update.message.reply_text("🔍 Обрабатываю ссылку...")
    
    try:
        # Скачиваем видео
        await status_message.edit_text("⬇️ Скачиваю видео...")
        video_path = await download_video(url, chat_id)
        
        # Отправляем файл пользователю
        await status_message.edit_text("📤 Отправляю видео...")
        
        video_file = open(video_path, 'rb')
        caption = f"Видео скачано с @{TELEGRAM_BOT_USERNAME}"
        await update.message.reply_video(
            video=video_file,
            caption=caption,
            supports_streaming=True
        )
        video_file.close()
        
        # Увеличиваем счетчик скачанных видео
        increment_downloads()
        
        # Сохраняем видео в папку video (не удаляем)
        logger.info(f"Видео сохранено: {video_path}")
        
        # Удаляем статусное сообщение и исходное сообщение со ссылкой
        try:
            await status_message.delete()
            await update.message.delete()
            logger.info(f"Удалено сообщение пользователя с ссылкой (chat_id: {chat_id}, тип чата: {chat_type})")
        except Exception as e:
            logger.warning(f"Не удалось удалить сообщение: {e}")
            # Если не удалось удалить (нет прав), просто логируем
        
    except Exception as e:
        logger.error(f"Ошибка: {e}")
        error_msg = f"❌ Произошла ошибка при обработке видео:\n{str(e)}"
        try:
            await status_message.edit_text(error_msg)
        except:
            # Если status_message не существует, создаем новое сообщение
            await update.message.reply_text(error_msg)
        
        # При ошибке тоже пытаемся удалить временные файлы
        try:
            # Удаляем все .part файлы для этого chat_id
            for part_file in DOWNLOADS_DIR.glob(f'{chat_id}_*.part'):
                part_file.unlink()
                logger.info(f"Удален .part файл после ошибки: {part_file.name}")
        except Exception as cleanup_error:
            logger.warning(f"Не удалось удалить .part файлы после ошибки: {cleanup_error}")


async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обрабатывает команду /start"""
    # Добавляем пользователя в статистику
    chat_id = update.message.chat_id
    username = update.message.from_user.username if update.message.from_user else None
    first_name = update.message.from_user.first_name if update.message.from_user else None
    add_user(chat_id, username, first_name)
    
    await update.message.reply_text(
        "👋 Привет! Я бот для скачивания видео.\n\n"
        "Просто отправь мне ссылку на видео, и я скачаю его для тебя.\n\n"
        "Поддерживаемые источники:\n"
        "• YouTube (youtube.com, youtu.be)\n"
        "• Instagram (instagram.com)\n"
        "• VK (vk.com)\n\n"
        "👥 Работа в группах:\n"
        "Добавь меня в группу и дай права администратора (нужно право на удаление сообщений). "
        "После этого я буду автоматически находить ссылки на видео в сообщениях участников, "
        "скачивать их и отправлять прямо в группу, заменяя исходное сообщение со ссылкой.\n\n"
        "Команды:\n"
        "/start - Начать работу\n"
        "/stat - Статистика скачанных видео\n\n"
        "Отправь ссылку на видео:"
    )


async def stat_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обрабатывает команду /stat"""
    total_downloads = get_total_downloads()
    total_users = get_total_users()
    
    await update.message.reply_text(
        f"📊 Статистика бота:\n\n"
        f"👥 Всего пользователей: {total_users}\n"
        f"📹 Всего скачано видео: {total_downloads}"
    )


def main():
    """Главная функция для запуска бота"""
    if not TELEGRAM_BOT_TOKEN:
        logger.error("TELEGRAM_BOT_TOKEN не установлен!")
        return
    
    # Инициализируем базу данных
    init_database()
    
    # Очищаем .part файлы при старте
    logger.info("Очистка .part файлов при старте...")
    cleanup_old_files()  # Удаляем только недокачанные .part файлы
    
    # Создаем приложение
    application = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
    
    # Регистрируем обработчики
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    application.add_handler(CommandHandler("start", start_command))
    application.add_handler(CommandHandler("stat", stat_command))
    
    # Запускаем периодическую очистку файлов
    async def post_init(application: Application):
        """Выполняется после инициализации приложения"""
        # Запускаем периодическую очистку .part файлов (каждые 6 часов)
        async def periodic_cleanup():
            while True:
                await asyncio.sleep(6 * 3600)  # 6 часов
                cleanup_old_files()
                logger.info("Периодическая очистка .part файлов выполнена")
        
        asyncio.create_task(periodic_cleanup())
        logger.info("Фоновая задача периодической очистки файлов запущена")
    
    application.post_init = post_init
    
    # Запускаем бота
    logger.info("Бот запущен")
    application.run_polling(allowed_updates=Update.ALL_TYPES)


if __name__ == '__main__':
    main()