Upload app.py

app.py

@@ -1,533 +1,425 @@
-# app.py
-import nest_asyncio
-nest_asyncio.apply()
-
-import os
-import random
-import shutil
-import asyncio
-import traceback
-import re
-import base64
-import io
-import json
-import pickle
-import time
-import numpy as np
-
-# Thư viện cho Web Server và Bot
-import httpx
-from fastapi import FastAPI, BackgroundTasks
-from pydantic import BaseModel
-from contextlib import asynccontextmanager
-import uvicorn
-
-# Import các module đã tách
-from utils.telegram_utils import send_telegram_message, edit_telegram_message_text, answer_telegram_callback_query
-
-# Thư viện cho xử lý video
-from moviepy.editor import (VideoFileClip, AudioFileClip, CompositeVideoClip, ImageClip, 
-                            ColorClip, CompositeAudioClip, vfx, TextClip)
-from moviepy.video.fx.all import colorx, lum_contrast, speedx, blackwhite
-import yt_dlp
-
-# Thư viện cho DNS fix
-import socket
-import aiodns
-
-# Thư viện cho Google Drive API
-from google.auth.transport.requests import Request as GoogleRequest
-from google.oauth2.credentials import Credentials
-from googleapiclient.discovery import build
-from googleapiclient.http import MediaFileUpload, MediaIoBaseDownload
-
-# ==============================================================================
-# CẤU HÌNH
-# ==============================================================================
-WORKER_URL = os.environ.get("WORKER_URL")
-TOKEN_BASE64 = os.environ.get("TOKEN_BASE64")
-
-DRIVE_OUTPUT_FOLDER_ID = "1n0-J6p3pdRuYKPUVwqvjjjzrwNvxig-c"
-DRIVE_MUSIC_FOLDER_ID = "1n3Wo62mQB0kuHjsWVnrQSN4HnCWUqtKu"
-
-LOCAL_TEMP_FOLDER = "temp_processing"
-
-# Biến toàn cục để lưu trữ trạng thái các phiên làm việc của người dùng
-USER_SESSIONS = {}
-
-# ==============================================================================
-# DNS FIX (Giữ nguyên)
-# ==============================================================================
-original_getaddrinfo = socket.getaddrinfo
-async def custom_getaddrinfo_async(host, port, family=0, type=0, proto=0, flags=0):
-    resolver = aiodns.DNSResolver(nameservers=['8.8.8.8', '8.8.4.4'])
-    try:
-        result = await resolver.query(host, 'A')
-        addrlist = []
-        for record in result:
-            addrlist.append((socket.AF_INET, socket.SOCK_STREAM, 6, '', (record.host, port)))
-        return addrlist
-    except aiodns.error.DNSError:
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, original_getaddrinfo, host, port, family, type, proto, flags)
-
-def custom_getaddrinfo_sync(*args, **kwargs):
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    return loop.run_until_complete(custom_getaddrinfo_async(*args, **kwargs))
-socket.getaddrinfo = custom_getaddrinfo_sync
-
-async def send_telegram_video(chat_id, video_path, caption):
-    url = f"{WORKER_URL}"
-    with open(video_path, 'rb') as video_file:
-        files = { 'video': (os.path.basename(video_path), video_file, 'video/mp4') }
-        data = { 'action': 'sendVideo', 'chat_id': str(chat_id), 'caption': caption }
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.post(url, data=data, files=files, timeout=300)
-                response.raise_for_status()
-                telegram_response = response.json()
-                if not telegram_response.get("ok", False):
-                    error_msg = telegram_response.get("description", "Unknown Telegram error")
-                    raise Exception(f"Telegram API error: {error_msg}")
-        except Exception as e:
-            error_msg = f"Lỗi khi gửi video qua Worker: {e}"
-            print(f"ERROR: {error_msg}")
-            await send_telegram_message(chat_id, f"❌ Đã xảy ra lỗi khi gửi video thành phẩm: {e}")
-
-# ==============================================================================
-# CÁC HÀM TIỆN ÍCH KHÁC
-# ==============================================================================
-def cleanup():
-    if os.path.exists(LOCAL_TEMP_FOLDER):
-        shutil.rmtree(LOCAL_TEMP_FOLDER)
-    os.makedirs(LOCAL_TEMP_FOLDER, exist_ok=True)
-
-def ensure_base_assets_exist():
-    pass
-
-# ==============================================================================
-# COLOR GRADING HELPERS (Không thay đổi)
-# ==============================================================================
-def _apply_saturation_frame(frame: np.ndarray, factor: float) -> np.ndarray:
-    f = frame.astype(np.float32) / 255.0
-    luminance = (0.299 * f[:, :, 0] + 0.587 * f[:, :, 1] + 0.114 * f[:, :, 2])
-    luminance = luminance[:, :, None]
-    f = luminance + (f - luminance) * factor
-    f = np.clip(f, 0.0, 1.0)
-    return (f * 255.0).astype(np.uint8)
-
-def _apply_contrast_frame(frame: np.ndarray, factor: float) -> np.ndarray:
-    f = frame.astype(np.float32) / 255.0
-    f = (f - 0.5) * factor + 0.5
-    f = np.clip(f, 0.0, 1.0)
-    return (f * 255.0).astype(np.uint8)
-
-def _apply_gamma_frame(frame: np.ndarray, gamma: float) -> np.ndarray:
-    if gamma <= 0: return frame
-    f = frame.astype(np.float32) / 255.0
-    f = np.power(f, gamma)
-    f = np.clip(f, 0.0, 1.0)
-    return (f * 255.0).astype(np.uint8)
-
-def _apply_gray_world_balance_frame(frame: np.ndarray) -> np.ndarray:
-    f = frame.astype(np.float32)
-    means = np.maximum(f.reshape(-1, 3).mean(axis=0), 1e-6)
-    gray = means.mean()
-    gains = gray / means
-    f = f * gains[None, None, 🙂
-    f = np.clip(f, 0.0, 255.0)
-    return f.astype(np.uint8)
-
-def _apply_tint_frame(frame: np.ndarray, multipliers: tuple[float, float, float]) -> np.ndarray:
-    f = frame.astype(np.float32)
-    r_mul, g_mul, b_mul = multipliers
-    f[:, :, 0] *= r_mul
-    f[:, :, 1] *= g_mul
-    f[:, :, 2] *= b_mul
-    f = np.clip(f, 0.0, 255.0)
-    return f.astype(np.uint8)
-
-# ==============================================================================
-# GOOGLE DRIVE & XỬ LÝ VIDEO (Không thay đổi)
-# ==============================================================================
-def get_drive_service():
-    if not TOKEN_BASE64: raise ValueError("Secret 'TOKEN_BASE64' chưa được thiết lập.")
-    try:
-        decoded_token = base64.b64decode(TOKEN_BASE64)
-        creds = pickle.loads(decoded_token)
-    except Exception as e:
-        raise ValueError(f"Lỗi khi giải mã TOKEN_BASE64: {e}")
-    if creds and creds.expired and creds.refresh_token:
-        try:
-            creds.refresh(GoogleRequest())
-            print("✅ Token Google đã được làm mới.")
-        except Exception as e:
-            raise Exception(f"Không thể làm mới token Google: {e}")
-    return build('drive', 'v3', credentials=creds)
-
-def download_file_from_drive(service, file_id, destination):
-    request = service.files().get_media(fileId=file_id)
-    fh = io.FileIO(destination, 'wb')
-    downloader = MediaIoBaseDownload(fh, request)
-    done = False
-    while not done: status, done = downloader.next_chunk()
-    return destination
-
-def get_random_music_from_drive(service, folder_id, destination_folder):
-    query = f"'{folder_id}' in parents and mimeType contains 'audio/'"
-    results = service.files().list(q=query, fields="files(id, name)").execute()
-    items = results.get('files', [])
-    if not items: raise FileNotFoundError("Không tìm thấy file nhạc nào trong thư mục Google Drive.")
-    random_file = random.choice(items)
-    local_path = os.path.join(destination_folder, random_file['name'])
-    return download_file_from_drive(service, random_file['id'], local_path)
-
-def upload_to_google_drive(service, file_path, folder_id):
-    file_metadata = {'name': os.path.basename(file_path), 'parents': [folder_id]}
-    media = MediaFileUpload(file_path, mimetype='video/mp4', resumable=True)
-    request = service.files().create(body=file_metadata, media_body=media, fields='id, webViewLink')
-    response = None
-    while response is None: status, response = request.next_chunk()
-    file_id = response.get('id')
-    service.permissions().create(fileId=file_id, body={'type': 'anyone', 'role': 'reader'}).execute()
-    file_info = service.files().get(fileId=file_id, fields='webViewLink').execute()
-    return file_info.get('webViewLink')
-
-def download_video_from_url(url, output_path):
-    YTDLP_HEADERS = {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
-        'Accept-Language': 'en-US,en;q=0.9,vi;q=0.8'
-    }
-    ydl_opts = {
-        'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
-        'outtmpl': os.path.join(output_path, '%(id)s.%(ext)s'),
-        'merge_output_format': 'mp4',
-        'noplaylist': True,
-        'cookiefile': 'cookies.txt',
-        'http_headers': YTDLP_HEADERS
-    }
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        info = ydl.extract_info(url, download=True)
-        return ydl.prepare_filename(info)
-
-# ==============================================================================
-# HÀM XỬ LÝ VIDEO CHÍNH (ĐÃ NÂNG CẤP)
-# ==============================================================================
-def process_video(video_path, output_path, keep_original_audio=True, music_path=None, speed_factor=1.0, filter_choice='default', ratio_choice='9_16', frame_choice='frame1'):
-    clip = VideoFileClip(video_path)
-    output_size = (1080, 1920)
-
-    # 1. Xử lý tỷ lệ khung hình và tạo base_clip
-    if ratio_choice == 'keep':
-        base_clip = clip
-    else:
-        background = ColorClip(size=output_size, color=(0, 0, 0), duration=clip.duration)
-        video_resized = clip.resize(width=output_size[0])
-        base_clip = CompositeVideoClip([background, video_resized.set_position('center')])
-
-    # 2. Xử lý âm thanh và t���c độ
-    final_audio = None
-    if keep_original_audio:
-        original_audio = base_clip.audio
-        if original_audio:
-            final_audio = original_audio.fx(speedx, factor=speed_factor)
-    else:
-        if music_path and os.path.exists(music_path):
-            background_music = AudioFileClip(music_path)
-            video_duration_after_speedup = base_clip.duration / speed_factor
-            final_audio = background_music.subclip(0, video_duration_after_speedup) if background_music.duration > video_duration_after_speedup else background_music
-    
-    final_clip_with_audio = base_clip.set_audio(final_audio)
-
-    # 3. Thêm Frame (ĐÃ NÂNG CẤP)
-    # Ánh xạ lựa chọn frame tới tên file
-    frame_map = {
-        "frame1": "frame.png",
-        "frame2": "frame1.png",
-        "frame3": "frame2.png",
-        "frame4": "frame3.png",
-    }
-    
-    base_dir = os.path.dirname(os.path.abspath(_file_))
-    # Lấy tên file từ map, nếu không có thì mặc định là frame.png
-    frame_filename = frame_map.get(frame_choice, "frame.png")
-    frame_path = os.path.join(base_dir, frame_filename)
-    
-    # *NÂNG CẤP*: Luôn áp dụng frame nếu file tồn tại, không còn phụ thuộc vào ratio_choice
-    if os.path.exists(frame_path):
-        frame_clip = ImageClip(frame_path).set_duration(final_clip_with_audio.duration).resize(final_clip_with_audio.size)
-        final_video = CompositeVideoClip([final_clip_with_audio, frame_clip])
-    else:
-        print(f"CẢNH BÁO: Không tìm thấy file frame '{frame_filename}'. Video sẽ được xuất mà không có khung.")
-        final_video = final_clip_with_audio
-
-    # 4. Xây dựng chuỗi lệnh FFmpeg để tăng tốc và chỉnh màu
-    ffmpeg_video_filters = []
-    ffmpeg_audio_filters = []
-
-    if abs(speed_factor - 1.0) > 1e-6:
-        ffmpeg_video_filters.append(f"setpts=PTS/{speed_factor}")
-    
-    if filter_choice == 'bw':
-        ffmpeg_video_filters.append("format=gray")
-    elif filter_choice == 'sharpen':
-        ffmpeg_video_filters.append("eq=contrast=1.12:saturation=1.08")
-    elif filter_choice == 'vintage':
-        ffmpeg_video_filters.append("curves=r='0/0.1':g='0/0.05':b='0/0.2', eq=contrast=0.95:saturation=1.1")
-    elif filter_choice == 'action_film':
-        ffmpeg_video_filters.append("curves=preset=cross_process, eq=contrast=1.35")
-    elif filter_choice == 'cyber_blue':
-        ffmpeg_video_filters.append("eq=contrast=1.25, curves=r='0/0 0.5/0.4 1/1':b='0/0 0.5/0.6 1/1'")
-    elif filter_choice == 'bleach_bypass':
-        ffmpeg_video_filters.append("eq=contrast=1.6:saturation=0.6")
-    else: # default
-        ffmpeg_video_filters.append("eq=contrast=1.05:saturation=1.06")
-
-    ffmpeg_params_list = ['-pix_fmt', 'yuv420p']
-    if ffmpeg_video_filters:
-        ffmpeg_params_list.extend(['-vf', ",".join(ffmpeg_video_filters)])
-    if ffmpeg_audio_filters:
-         ffmpeg_params_list.extend(['-af', ",".join(ffmpeg_audio_filters)])
-
-    # 5. Xuất video
-    final_video_path = os.path.join(output_path, f"processed_{os.path.basename(video_path)}")
-    final_video.write_videofile(final_video_path, 
-                                codec="libx264", 
-                                audio_codec="aac", 
-                                threads=4, 
-                                ffmpeg_params=ffmpeg_params_list)
-    clip.close()
-    return final_video_path
-
-# ==============================================================================
-# WORKFLOW CHÍNH (Không thay đổi)
-# ==============================================================================
-async def part1_download_and_ask_audio(chat_id: int, url: str):
-    task_id = str(int(time.time()))
-    task_temp_folder = os.path.join(LOCAL_TEMP_FOLDER, task_id)
-    os.makedirs(task_temp_folder, exist_ok=True)
-    
-    try:
-        await send_telegram_message(chat_id, "✅ Đã nhận yêu cầu. Bắt đầu tải video từ link...")
-        loop = asyncio.get_running_loop()
-        downloaded_path = await loop.run_in_executor(None, download_video_from_url, url, task_temp_folder)
-        
-        if not downloaded_path: raise Exception("Tải video thất bại.")
-        await send_telegram_message(chat_id, "✅ Tải video thành công!")
-
-        USER_SESSIONS[chat_id] = {
-            "step": "awaiting_audio_choice",
-            "data": {
-                "task_id": task_id,
-                "task_temp_folder": task_temp_folder,
-                "original_video_path": downloaded_path,
-                "original_url": url,
-            }
-        }
-        
-        keyboard = { "inline_keyboard": [[{"text": "✅ Giữ nhạc gốc", "callback_data": "keep_audio"}], [{"text": "🎵 Thay nhạc mới", "callback_data": "replace_audio"}]] }
-        await send_telegram_message(chat_id, "Bạn có muốn giữ lại âm thanh gốc của video không?", reply_markup=keyboard)
-
-    except Exception as e:
-        error_message = f"❌ Đã xảy ra lỗi ở bước tải video: {str(e)}"
-        print(error_message)
-        traceback.print_exc()
-        await send_telegram_message(chat_id, error_message)
-        if chat_id in USER_SESSIONS: del USER_SESSIONS[chat_id]
-
-async def part2_process_and_upload(chat_id: int):
-    session = USER_SESSIONS.get(chat_id)
-    if not session or "data" not in session:
-        return await send_telegram_message(chat_id, "❌ Phiên làm việc đã hết hạn, vui lòng gửi lại link.")
-
-    data = session["data"]
-    loop = asyncio.get_running_loop()
-    service = None
-    
-    try:
-        task_temp_folder = data["task_temp_folder"]
-        downloaded_path = data["original_video_path"]
-        url = data["original_url"]
-        keep_audio = data["keep_audio"]
-        speed_factor = data.get("speed_factor", 1.0)
-        filter_choice = data.get("filter_choice", "default")
-        ratio_choice = data.get("ratio_choice", "9_16")
-        # *NÂNG CẤP*: Lấy frame_choice từ session
-        frame_choice = data.get("frame_choice", "frame1")
-        music_path = None
-        
-        await send_telegram_message(chat_id, "⚙️ Bắt đầu xử lý video với các tùy chọn của bạn...")
-        
-        if not keep_audio:
-            await send_telegram_message(chat_id, "☁️ Kết nối Google Drive để lấy nhạc...")
-            service = await loop.run_in_executor(None, get_drive_service)
-            music_path = await loop.run_in_executor(None, get_random_music_from_drive, service, DRIVE_MUSIC_FOLDER_ID, task_temp_folder)
-
-        processed_path = await loop.run_in_executor(
-            None, 
-            process_video, 
-            downloaded_path, 
-            task_temp_folder, 
-            keep_audio, 
-            music_path,
-            speed_factor,
-            filter_choice,
-            ratio_choice,
-            # *NÂNG CẤP*: Truyền frame_choice vào hàm xử lý
-            frame_choice
-        )
-        if not processed_path: raise Exception("Xử lý video thất bại.")
-
-        await send_telegram_message(chat_id, "✅ Xử lý xong! Đang gửi video cho bạn...")
-        await send_telegram_video(chat_id, processed_path, caption=f"Video của bạn từ link: {url}")
-
-        await send_telegram_message(chat_id, "☁️ Bắt đầu tải video lên Google Drive...")
-        if not service: service = await loop.run_in_executor(None, get_drive_service)
-        drive_link = await loop.run_in_executor(None, upload_to_google_drive, service, processed_path, DRIVE_OUTPUT_FOLDER_ID)
-        
-        if drive_link:
-            await send_telegram_message(chat_id, f"🎉 Tải lên Google Drive thành công!\n\n🔗 Link:\n{drive_link}")
-        else:
-            await send_telegram_message(chat_id, "❌ Lỗi khi tải video lên Google Drive.")
-
-    except Exception as e:
-        error_message = f"❌ Đã xảy ra lỗi: {str(e)}"
-        print(error_message)
-        traceback.print_exc()
-        await send_telegram_message(chat_id, error_message)
-    finally:
-        if os.path.exists(data.get("task_temp_folder", "")): shutil.rmtree(data["task_temp_folder"])
-        if chat_id in USER_SESSIONS: del USER_SESSIONS[chat_id]
-
-# ==============================================================================
-# FASTAPI APP (ĐÃ NÂNG CẤP LUỒNG HỘI THOẠI)
-# ==============================================================================
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    print("🚀 Server đang khởi động...")
-    cleanup()
-    ensure_base_assets_exist()
-    print("✅ Bot đã sẵn sàng nhận yêu cầu.")
-    yield
-    print("👋 Server đã tắt.")
-
-app = FastAPI(lifespan=lifespan)
-
-class TelegramUpdate(BaseModel):
-    message: dict | None = None
-    callback_query: dict | None = None
-
-@app.post("/webhook")
-async def handle_webhook(update: TelegramUpdate, background_tasks: BackgroundTasks):
-    main_keyboard = { "keyboard": [[{"text": "👽 Reddit"}, {"text": "🎵 TikTok"}], [{"text": "🐦 X / Twitter"}, {"text": "▶️ YouTube"}]], "resize_keyboard": True }
-
-    if update.callback_query:
-        chat_id = update.callback_query["message"]["chat"]["id"]
-        message_id = update.callback_query["message"]["message_id"]
-        callback_data = update.callback_query["data"]
-        
-        session = USER_SESSIONS.get(chat_id)
-        if not session:
-            await answer_telegram_callback_query(update.callback_query["id"], "Phiên làm việc đã hết hạn. Vui lòng /start lại.")
-            return {"status": "ok, session expired"}
-        
-        current_step = session.get("step")
-        await edit_telegram_message_text(chat_id, message_id, update.callback_query["message"]["text"], reply_markup={})
-
-        if current_step == "awaiting_audio_choice":
-            session["data"]["keep_audio"] = (callback_data == "keep_audio")
-            session["step"] = "awaiting_ratio_choice"
-            keyboard = json.dumps({"inline_keyboard": [[{"text": "9:16 (Dọc)", "callback_data": "ratio_9_16"}, {"text": "Giữ nguyên", "callback_data": "ratio_keep"}]]})
-            await edit_telegram_message_text(chat_id, message_id, "OK. Giờ hãy chọn tỷ lệ khung hình:", reply_markup=keyboard)
-
-        elif current_step == "awaiting_ratio_choice":
-            try:
-                # *NÂNG CẤP*: Chuyển sang bước chọn Frame
-                ratio_choice = callback_data.split('_', 1)[1]
-                session["data"]["ratio_choice"] = ratio_choice
-                session["step"] = "awaiting_frame_choice" # <-- THAY ĐỔI
-                keyboard = json.dumps({"inline_keyboard": [
-                    [{"text": "Frame 1", "callback_data": "frame_frame1"}, {"text": "Frame 2", "callback_data": "frame_frame2"}], 
-                    [{"text": "Frame 3", "callback_data": "frame_frame3"}, {"text": "Frame 4", "callback_data": "frame_frame4"}]
-                ]})
-                await edit_telegram_message_text(chat_id, message_id, "Tuyệt vời! Bây giờ hãy chọn khung (frame) cho video:", reply_markup=keyboard)
-            except (ValueError, IndexError):
-                await send_telegram_message(chat_id, "⚠️ Lựa chọn tỷ lệ không hợp lệ, vui lòng thử lại từ đầu.")
-        
-        # *NÂNG CẤP*: Thêm bước xử lý lựa chọn Frame
-        elif current_step == "awaiting_frame_choice":
-            try:
-                frame_choice = callback_data.split('_', 1)[1]
-                session["data"]["frame_choice"] = frame_choice
-                session["step"] = "awaiting_speed_choice" # <-- Chuyển tiếp tới bước chọn tốc độ
-                keyboard = json.dumps({"inline_keyboard": [
-                    [{"text": "1.0x (Gốc)", "callback_data": "speed_1.0"}, {"text": "1.05x", "callback_data": "speed_1.05"}], 
-                    [{"text": "1.2x", "callback_data": "speed_1.2"}, {"text": "1.5x", "callback_data": "speed_1.5"}]
-                ]})
-                await edit_telegram_message_text(chat_id, message_id, "Tiếp theo, chọn tốc độ cho video:", reply_markup=keyboard)
-            except (ValueError, IndexError):
-                await send_telegram_message(chat_id, "⚠️ Lựa chọn frame không hợp lệ, vui lòng thử lại từ đầu.")
-
-        elif current_step == "awaiting_speed_choice":
-            try:
-                speed_factor = float(callback_data.split('_')[1])
-                session["data"]["speed_factor"] = speed_factor
-                session["step"] = "awaiting_filter_choice"
-                keyboard = json.dumps({ "inline_keyboard": [
-                    [{"text": "Mặc định ✨", "callback_data": "filter_default"}, {"text": "Cổ điển 🎞️", "callback_data": "filter_vintage"}],
-                    [{"text": "Phim Hành Động 💥", "callback_data": "filter_action_film"}, {"text": "Xanh Neon Lạnh 🥶", "callback_data": "filter_cyber_blue"}],
-                    [{"text": "Bleach Bypass 🎬", "callback_data": "filter_bleach_bypass"}, {"text": "Đen Trắng 🎥", "callback_data": "filter_bw"}]
-                ]})
-                await edit_telegram_message_text(chat_id, message_id, "Sắp xong rồi! Cuối cùng, hãy chọn một hiệu ứng màu (filter):", reply_markup=keyboard)
-            except (ValueError, IndexError):
-                await send_telegram_message(chat_id, "⚠️ Lựa chọn tốc độ không hợp lệ, vui lòng thử lại từ đầu.")
-
-        elif current_step == "awaiting_filter_choice":
-            filter_choice = callback_data.split('_')[1]
-            session["data"]["filter_choice"] = filter_choice
-            session["step"] = "processing"
-            await edit_telegram_message_text(chat_id, message_id, "✅ Đã nhận đủ thông tin. Bot bắt đầu làm việc, bạn chờ nhé! Quá trình này có thể mất vài phút.")
-            background_tasks.add_task(part2_process_and_upload, chat_id)
-
-    elif update.message:
-        chat_id = update.message["chat"]["id"]
-        text = update.message.get("text", "")
-        session = USER_SESSIONS.get(chat_id)
-
-        if text == "/start":
-            if chat_id in USER_SESSIONS: del USER_SESSIONS[chat_id]
-            await send_telegram_message(chat_id, "👋 Chào bạn! Vui lòng chọn một nguồn từ bàn phím bên dưới để bắt đầu.", reply_markup=main_keyboard)
-            return {"status": "ok"}
-        
-        source_buttons = ["👽 Reddit", "🎵 TikTok", "🐦 X / Twitter", "▶️ YouTube"]
-        if text in source_buttons:
-            source_name = text.split(" ")[1]
-            USER_SESSIONS[chat_id] = {"step": "awaiting_link", "source": source_name}
-            await send_telegram_message(chat_id, f"✅ Đã chọn: *{source_name}*. \n\nBây giờ, hãy gửi link video từ nguồn này:")
-            return {"status": "ok, source selected"}
-
-        if session and session.get("step") == "awaiting_link":
-            url_pattern = r'https?://[^\s]+'
-            match = re.search(url_pattern, text)
-            if match:
-                background_tasks.add_task(part1_download_and_ask_audio, chat_id, match.group(0))
-            else:
-                await send_telegram_message(chat_id, "⚠️ Link không hợp lệ. Vui lòng gửi một link video hợp lệ.")
-            return {"status": "ok, link received"}
-
-        if session and session.get("step") != "processing":
-            await send_telegram_message(chat_id, "⏳ Bạn đang trong một quy trình, vui lòng hoàn tất các lựa chọn hiện tại hoặc gõ /start để bắt đầu lại.", reply_markup=main_keyboard)
-        elif session and session.get("step") == "processing":
-             await send_telegram_message(chat_id, "⏳ Bot đang xử lý yêu cầu trước đó của bạn. Vui lòng chờ một chút nhé.", reply_markup=main_keyboard)
-        else:
-            await send_telegram_message(chat_id, "Vui lòng chọn một tùy chọn từ bàn phím hoặc gõ /start để bắt đầu.", reply_markup=main_keyboard)
-            
-    return {"status": "ok"}
-
-@app.get("/")
-def read_root(): return {"message": "Telegram Bot is running."}
+# app.py (Modified for Hugging Face + Telegram + Cloudflare)
+import nest_asyncio
+nest_asyncio.apply()
+
+import os
+import shutil
+import asyncio
+import traceback
+import re
+import time
+from pathlib import Path
+
+# Web Server & Bot
+import httpx
+from fastapi import FastAPI, BackgroundTasks
+from pydantic import BaseModel
+from contextlib import asynccontextmanager
+import uvicorn
+
+# Video Processing
+try:
+    from moviepy.editor import VideoFileClip
+except ImportError:
+    print("FATAL ERROR: moviepy is not installed. Run: pip install moviepy")
+    # You might want to handle this more gracefully depending on HF deployment
+    sys.exit(1)
+import yt_dlp
+
+# DNS Fix (Keep from reference)
+import socket
+import aiodns
+original_getaddrinfo = socket.getaddrinfo
+async def custom_getaddrinfo_async(host, port, family=0, type=0, proto=0, flags=0):
+    resolver = aiodns.DNSResolver(nameservers=['8.8.8.8', '8.8.4.4'])
+    try:
+        result = await resolver.query(host, 'A'); addrlist = []
+        for record in result: addrlist.append((socket.AF_INET, socket.SOCK_STREAM, 6, '', (record.host, port)))
+        return addrlist
+    except aiodns.error.DNSError:
+        loop = asyncio.get_running_loop(); return await loop.run_in_executor(None, original_getaddrinfo, host, port, family, type, proto, flags)
+def custom_getaddrinfo_sync(*args, **kwargs):
+    try: loop = asyncio.get_running_loop()
+    except RuntimeError: loop = asyncio.new_event_loop(); asyncio.set_event_loop(loop)
+    return loop.run_until_complete(custom_getaddrinfo_async(*args, **kwargs))
+socket.getaddrinfo = custom_getaddrinfo_sync
+
+# --- CONFIGURATION ---
+WORKER_URL = os.environ.get("WORKER_URL") # Get Worker URL from HF Secrets
+LOCAL_TEMP_FOLDER = "temp_processing"
+# Ensure the temp folder exists at startup
+os.makedirs(LOCAL_TEMP_FOLDER, exist_ok=True)
+
+# User session storage
+USER_SESSIONS = {}
+
+# --- TELEGRAM UTILS (Assumed to exist in utils/telegram_utils.py or similar) ---
+# You need functions that POST to your WORKER_URL
+# Example (replace with your actual implementation):
+async def send_telegram_message(chat_id, text, reply_markup=None):
+    url = f"{WORKER_URL}"
+    payload = {'action': 'sendMessage', 'chat_id': str(chat_id), 'text': text}
+    if reply_markup:
+        payload['reply_markup'] = json.dumps(reply_markup)
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload, timeout=60)
+            response.raise_for_status()
+            print(f"Sent message to {chat_id}: {response.json()}")
+    except Exception as e:
+        print(f"ERROR sending message to {chat_id}: {e}")
+
+async def send_telegram_video(chat_id, video_path, caption):
+    url = f"{WORKER_URL}"
+    with open(video_path, 'rb') as video_file:
+        files = { 'video': (os.path.basename(video_path), video_file, 'video/mp4') }
+        data = { 'action': 'sendVideo', 'chat_id': str(chat_id), 'caption': caption }
+        try:
+            async with httpx.AsyncClient() as client:
+                # Increased timeout for potentially large files
+                response = await client.post(url, data=data, files=files, timeout=600)
+                response.raise_for_status()
+                print(f"Sent video to {chat_id}: {response.json()}")
+                return True # Indicate success
+        except Exception as e:
+            print(f"ERROR sending video to {chat_id}: {e}")
+            await send_telegram_message(chat_id, f"❌ Lỗi khi gửi file video: {e}")
+            return False # Indicate failure
+
+async def answer_telegram_callback_query(callback_query_id, text="OK"):
+    url = f"{WORKER_URL}"
+    payload = {'action': 'answerCallbackQuery', 'callback_query_id': callback_query_id, 'text': text}
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload, timeout=30)
+            response.raise_for_status()
+    except Exception as e:
+        print(f"ERROR answering callback query {callback_query_id}: {e}")
+
+async def edit_telegram_message_text(chat_id, message_id, text, reply_markup=None):
+    url = f"{WORKER_URL}"
+    payload = {'action': 'editMessageText', 'chat_id': str(chat_id), 'message_id': message_id, 'text': text}
+    if reply_markup:
+        payload['reply_markup'] = json.dumps(reply_markup)
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload, timeout=60)
+            response.raise_for_status()
+    except Exception as e:
+        print(f"ERROR editing message {message_id} in chat {chat_id}: {e}")
+
+
+# --- VIDEO PROCESSING FUNCTIONS (Adapted from GUI code) ---
+
+# Helper to get script directory (important for finding cookies.txt)
+def get_script_dir():
+    # In HF Spaces, the current working directory is usually the repo root
+    return os.getcwd()
+
+async def mute_video_with_moviepy_hf(original_video_path, chat_id):
+    """ Mutes video using MoviePy, sends status messages via Telegram. """
+    await send_telegram_message(chat_id, f"   Bắt đầu tắt tiếng: {os.path.basename(original_video_path)}")
+    original_path = Path(original_video_path)
+    muted_filename = original_path.parent / f"{original_path.stem}_MUTED.mp4"
+    video_clip = None
+    loop = asyncio.get_running_loop()
+
+    try:
+        def sync_mute_copy():
+            nonlocal video_clip # Allow modifying outer scope variable
+            video_clip = VideoFileClip(str(original_path))
+            final_clip = video_clip.set_audio(None)
+            final_clip.write_videofile(str(muted_filename), codec='copy', logger=None)
+
+        await send_telegram_message(chat_id, "      Đang thử tắt tiếng (copy - nhanh)...")
+        await loop.run_in_executor(None, sync_mute_copy) # Run synchronous moviepy code in executor
+        await send_telegram_message(chat_id, f"      Tắt tiếng (copy) thành công: {muted_filename.name}")
+
+    except Exception as e:
+        await send_telegram_message(chat_id, f"      Lỗi 'codec=copy': {str(e)}. Đang thử nén lại (chậm hơn)...")
+        try:
+            def sync_mute_reencode():
+                # Need to reopen the clip within the executor context
+                clip_retry = VideoFileClip(str(original_path))
+                final_clip_retry = clip_retry.set_audio(None)
+                final_clip_retry.write_videofile(
+                    str(muted_filename), threads=4, codec="libx264", audio_codec="aac", logger=None
+                )
+                clip_retry.close() # Close the clip explicitly
+
+            # Close the original clip if it exists before retrying
+            if video_clip: video_clip.close(); video_clip = None
+
+            await loop.run_in_executor(None, sync_mute_reencode) # Run re-encode in executor
+            await send_telegram_message(chat_id, f"      Tắt tiếng (nén lại) thành công: {muted_filename.name}")
+            return (True, str(muted_filename))
+        except Exception as e2:
+            # Explicitly close clip on re-encode error if it's still somehow open
+            # (though sync_mute_reencode should handle it)
+            if 'clip_retry' in locals() and locals()['clip_retry']: locals()['clip_retry'].close()
+
+            await send_telegram_message(chat_id, f"      LỖI MOVIEPY (lần 2):\n{str(e2)}")
+            return (False, f"LỖI MOVIEPY:\n{str(e2)}")
+    finally:
+        if video_clip: video_clip.close()
+    return (True, str(muted_filename))
+
+async def download_single_video_hf(url, output_path, chat_id):
+    """ Downloads a single video using yt-dlp, sends status via Telegram.
+        Uses COOKIE_STRING secret instead of cookies.txt file. """
+    await send_telegram_message(chat_id, f"Bắt đầu tải: {url}")
+    original_filename = None
+    loop = asyncio.get_running_loop()
+
+    # === THAY ĐỔI: Lấy cookie từ Secret ===
+    cookie_string = os.environ.get("COOKIE_STRING")
+    if not cookie_string:
+        await send_telegram_message(chat_id, "❌ LỖI NGHIÊM TRỌNG: Secret 'COOKIE_STRING' chưa được thiết lập trên Hugging Face!")
+        return (False, "Lỗi Server: Thiếu Secret Cookie", None)
+    # =======================================
+
+    # Giữ nguyên Headers khác, nhưng thêm header 'Cookie'
+    YTDLP_HEADERS = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+        'Accept-Language': 'en-US,en;q=0.9,vi;q=0.8',
+        # === THAY ĐỔI: Thêm header Cookie ===
+        'Cookie': cookie_string
+        # =======================================
+    }
+    output_template = os.path.join(output_path, '%(title)s - %(id)s.%(ext)s')
+    downloaded_file_holder = []
+
+    def progress_hook(d):
+        if d['status'] == 'finished':
+            filepath = d.get('filename') or d.get('info_dict', {}).get('_filename')
+            if filepath and filepath not in downloaded_file_holder:
+                 downloaded_file_holder.append(filepath)
+
+    ydl_opts = {
+        'format': 'best',
+        'outtmpl': output_template,
+        'merge_output_format': 'mp4',
+        'noplaylist': True,
+        # 'cookiefile': cookie_file_path, # <<<=== XÓA DÒNG NÀY
+        'http_headers': YTDLP_HEADERS, # Headers giờ đã chứa cookie
+        'quiet': True, 'verbose': False, 'no_warnings': True,
+        'ignoreerrors': False,
+        'progress_hooks': [progress_hook],
+        'paths': {'temp': os.path.join(LOCAL_TEMP_FOLDER, 'ytdlp_temp')},
+        'fragment_retries': 10,
+        'retries': 10,
+    }
+
+    try:
+        def sync_download():
+             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                 ydl.download([url])
+
+        await loop.run_in_executor(None, sync_download)
+
+        if not downloaded_file_holder:
+             raise yt_dlp.utils.DownloadError("Không xác định được tên file đã tải.")
+        original_filename = downloaded_file_holder[0]
+        await send_telegram_message(chat_id, f"   ✅ Tải gốc xong: {os.path.basename(original_filename)}")
+        return (True, "Tải gốc OK", original_filename)
+
+    except Exception as e:
+        error_message = str(e)
+        await send_telegram_message(chat_id, f"   ❌ LỖI KHI TẢI GỐC:\n{error_message}")
+        # Specific error checking
+        # === THAY ĐỔI: Kiểm tra lỗi cookie kỹ hơn ===
+        if "HTTP Error 403" in error_message or "401 Unauthorized" in error_message or "Fresh cookies" in error_message:
+            return (False, "Lỗi: Cookies hết hạn hoặc không hợp lệ (kiểm tra Secret).", None)
+        # ===========================================
+        if "Unsupported URL" in error_message: return (False, "Lỗi: Link không hỗ trợ.", None)
+        if "Private video" in error_message: return (False, "Lỗi: Video riêng tư.", None)
+        if "Video unavailable" in error_message: return (False, "Lỗi: Video không khả dụng.", None)
+        # General error
+        return (False, f"Lỗi tải: {error_message[:100]}...", None)
+
+# --- Background Task for Processing ---
+async def process_links_task(chat_id, urls, is_muting):
+    """ Background task to download and optionally mute multiple videos. """
+    success_count = 0
+    fail_count = 0
+    mute_fail_count = 0
+    total_links = len(urls)
+    processed_files_info = [] # Store tuples of (original_path, muted_path_or_error)
+
+    # Create a unique temp folder for this task
+    task_temp_folder = os.path.join(LOCAL_TEMP_FOLDER, f"task_{chat_id}_{int(time.time())}")
+    os.makedirs(task_temp_folder, exist_ok=True)
+
+    await send_telegram_message(chat_id, f"🚀 Bắt đầu xử lý {total_links} link...")
+
+    for i, url in enumerate(urls):
+        await send_telegram_message(chat_id, f"--- Xử lý link {i+1}/{total_links} ---")
+        original_filepath = None
+        muted_filepath_or_error = None
+        try:
+            # Download to the task's temp folder
+            dl_success, dl_msg, original_filepath = await download_single_video_hf(url, task_temp_folder, chat_id)
+
+            if dl_success:
+                if is_muting:
+                    mute_success, mute_result = await mute_video_with_moviepy_hf(original_filepath, chat_id)
+                    if mute_success:
+                        muted_filepath_or_error = mute_result
+                    else:
+                        mute_fail_count += 1
+                        muted_filepath_or_error = f"Lỗi mute: {mute_result}" # Store mute error
+                        # Still counts as a download success
+                success_count += 1
+                processed_files_info.append((original_filepath, muted_filepath_or_error))
+            else:
+                fail_count += 1
+                # dl_msg contains the error message from download_single_video_hf
+                await send_telegram_message(chat_id, f"⚠️ Lỗi với link {i+1}: {dl_msg}")
+
+        except Exception as e:
+             fail_count += 1
+             await send_telegram_message(chat_id, f"❌ Lỗi hệ thống nghiêm trọng khi xử lý link {i+1}: {e}")
+             traceback.print_exc() # Print full traceback to server logs
+
+        # Optional: Short delay between downloads
+        await asyncio.sleep(1)
+
+    # --- Sending results back ---
+    await send_telegram_message(chat_id, f"--- Hoàn tất tải {success_count}/{total_links} video gốc ---")
+    if is_muting:
+         await send_telegram_message(chat_id, f"--- B��t đầu gửi {success_count} video (bản gốc hoặc đã tắt tiếng) ---")
+
+    sent_count = 0
+    send_errors = 0
+    for i, (orig_path, mute_path_or_err) in enumerate(processed_files_info):
+        file_to_send = None
+        caption = os.path.basename(orig_path or "video")
+
+        if is_muting:
+            if isinstance(mute_path_or_err, str) and not mute_path_or_err.startswith("Lỗi mute"):
+                file_to_send = mute_path_or_err # Send muted version if success
+                caption = os.path.basename(mute_path_or_err) + " (Đã tắt tiếng)"
+            else:
+                file_to_send = orig_path # Send original if muting failed
+                caption += f" (Lỗi tắt tiếng: {mute_path_or_err})"
+        else:
+            file_to_send = orig_path # Send original if not muting
+
+        if file_to_send and os.path.exists(file_to_send):
+            await send_telegram_message(chat_id, f"   Đang gửi video {i+1}/{len(processed_files_info)}...")
+            if await send_telegram_video(chat_id, file_to_send, caption):
+                sent_count += 1
+            else:
+                send_errors += 1
+        else:
+            # This case means download failed, already logged earlier
+            pass
+
+    # --- Final Summary ---
+    summary_message = f"🏁 Hoàn thành!\n- Tải thành công: {success_count}/{total_links}"
+    if fail_count > 0: summary_message += f"\n- Tải thất bại: {fail_count}"
+    if is_muting:
+        if mute_fail_count > 0: summary_message += f"\n- Lỗi tắt tiếng: {mute_fail_count}"
+    if send_errors > 0: summary_message += f"\n- Lỗi gửi file: {send_errors}"
+
+    await send_telegram_message(chat_id, summary_message)
+
+    # --- Cleanup ---
+    if chat_id in USER_SESSIONS: del USER_SESSIONS[chat_id]
+    try:
+        shutil.rmtree(task_temp_folder)
+        print(f"Cleaned up temp folder: {task_temp_folder}")
+    except Exception as e:
+        print(f"ERROR cleaning up temp folder {task_temp_folder}: {e}")
+
+
+# --- FastAPI Setup ---
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    print("🚀 Server is starting...")
+    # Initial cleanup just in case
+    if os.path.exists(LOCAL_TEMP_FOLDER): shutil.rmtree(LOCAL_TEMP_FOLDER)
+    os.makedirs(LOCAL_TEMP_FOLDER, exist_ok=True)
+    print("✅ Bot ready.")
+    yield
+    print("👋 Server shutting down.")
+
+app = FastAPI(lifespan=lifespan)
+
+class TelegramUpdate(BaseModel):
+    message: dict | None = None
+    callback_query: dict | None = None
+
+@app.post("/webhook")
+async def handle_webhook(update: TelegramUpdate, background_tasks: BackgroundTasks):
+    if update.callback_query:
+        # --- Handle Button Clicks ---
+        callback_query = update.callback_query
+        chat_id = callback_query["message"]["chat"]["id"]
+        message_id = callback_query["message"]["message_id"]
+        callback_data = callback_query["data"]
+        callback_id = callback_query["id"]
+
+        session = USER_SESSIONS.get(chat_id)
+        if not session or session.get("step") != "awaiting_mute_choice":
+            await answer_telegram_callback_query(callback_id, "⚠️ Lựa chọn đã hết hạn hoặc không hợp lệ. Gửi lại link nhé.")
+            return {"status": "ok, session invalid"}
+
+        # Remove the inline keyboard from the original message
+        await edit_telegram_message_text(chat_id, message_id, callback_query["message"]["text"], reply_markup={})
+        await answer_telegram_callback_query(callback_id, "OK, bắt đầu xử lý!") # Acknowledge button press
+
+        # Store mute choice and start background task
+        is_muting = (callback_data == "mute_yes")
+        session["is_muting"] = is_muting
+        session["step"] = "processing"
+
+        background_tasks.add_task(process_links_task, chat_id, session["urls"], is_muting)
+        return {"status": "ok, processing started"}
+
+    elif update.message:
+        # --- Handle Incoming Messages ---
+        message = update.message
+        chat_id = message["chat"]["id"]
+        text = message.get("text", "").strip()
+
+        if text == "/start":
+            if chat_id in USER_SESSIONS: del USER_SESSIONS[chat_id]
+            await send_telegram_message(chat_id, "👋 Chào bạn! Gửi 1 hoặc nhiều link video (Douyin/XHS), mỗi link một dòng.")
+            return {"status": "ok, start message"}
+
+        # Check if currently processing for this user
+        if USER_SESSIONS.get(chat_id, {}).get("step") == "processing":
+             await send_telegram_message(chat_id, "⏳ Bot đang xử lý yêu cầu trước đó của bạn. Vui lòng chờ nhé.")
+             return {"status": "ok, busy"}
+
+        # Extract URLs from the message
+        url_pattern = r'https?://[^\s]+'
+        urls = [match.group(0) for match in re.finditer(url_pattern, text)]
+
+        if not urls:
+            await send_telegram_message(chat_id, "���️ Không tìm thấy link hợp lệ nào. Vui lòng gửi link video.")
+            return {"status": "ok, no links found"}
+
+        # Store URLs and ask about muting
+        USER_SESSIONS[chat_id] = {
+            "step": "awaiting_mute_choice",
+            "urls": urls
+        }
+        keyboard = { "inline_keyboard": [
+            [{"text": "🔇 Có, tắt tiếng", "callback_data": "mute_yes"}],
+            [{"text": "🔊 Không, giữ nguyên", "callback_data": "mute_no"}]
+        ]}
+        await send_telegram_message(chat_id, f"Tìm thấy {len(urls)} link. Bạn có muốn tạo thêm bản *tắt tiếng* cho video không?", reply_markup=keyboard)
+        return {"status": "ok, links received, asking mute"}
+
+    return {"status": "ok, ignored"} # Ignore other update types
+
+
+@app.get("/")
+def read_root(): return {"message": "Downloader Bot is running."}
+
+# --- To run locally (optional) ---
+# if __name__ == "__main__":
+#    uvicorn.run(app, host="0.0.0.0", port=7860)