Delete plugins/muxer.py as part of folder deletion for plugins/

plugins/muxer.py

@@ -1,1131 +0,0 @@
-from pyrogram import Client, filters
-from helper_func.progress_bar import progress_bar
-from helper_func.dbhelper import Database as Db
-from helper_func.mux import softmux_vid, hardmux_vid, format_time_duration, active_processes, check_active_process, set_process_status, clear_process_status
-from config import Config
-from encoding_defaults import EncodingDefaults
-import time
-import os
-import asyncio
-import logging
-import re
-
-db = Db()
-
-# Add a dictionary to store user encoding settings
-user_settings = {}
-
-# Add skip status tracking
-skipped_sub = set()  # Store user IDs who skipped subtitle
-
-# Define valid presets and CRF ranges
-VALID_PRESETS = ['ultrafast', 'superfast', 'veryfast', 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow']
-MIN_CRF = 0
-MAX_CRF = 51
-
-# Define resolution options
-RESOLUTIONS = {
-    '8k': '7680x4320',
-    '4k': '3840x2160',
-    '1440p': '2560x1440',
-    '1080p': '1920x1080',
-    '720p': '1280x720',
-    '480p': '854x480',
-    '360p': '640x360',
-    '240p': '426x240',
-    '144p': '256x144',
-    'original': 'original'
-}
-
-# Define codec options
-CODECS = {
-    'h264': {
-        'ffmpeg_codec': 'libx264',
-        'description': 'H.264 (AVC) - Widely compatible'
-    },
-    'h265': {
-        'ffmpeg_codec': 'libx265',
-        'description': 'H.265 (HEVC) - Better compression, smaller file size'
-    }
-}
-
-# Add frame rate options after CODECS definition
-FRAME_RATES = {
-    '60': '60',
-    '50': '50',
-    '30': '30',
-    '25': '25',
-    '24': '24',
-    'original': 'original'
-}
-
-# At the top with other global variables
-active_processes = {}  # Store user IDs and their current process (download/encode/upload)
-
-async def _check_user(filt, c, m):
-    chat_id = str(m.from_user.id)
-    if chat_id in Config.ALLOWED_USERS:
-        return True
-    else:
-        return False
-
-check_user = filters.create(_check_user)
-
-@Client.on_message(filters.command('nosubs') & check_user & filters.private)
-async def nosubs(client, message):
-    chat_id = message.from_user.id
-    
-    # Send initial processing message
-    processing_msg = await client.send_message(chat_id, '⚙️ Processing...')
-    
-    # Check for active process
-    if await check_active_process(client, chat_id, processing_msg.id):
-        return
-    
-    if not db.check_video(chat_id):
-        await processing_msg.edit("❌ Send video file first!")
-        return
-    
-    # Check if subtitle exists and delete it
-    sub_filename = db.get_sub_filename(chat_id)
-    if sub_filename:
-        # Delete subtitle file from server
-        sub_path = os.path.join(Config.DOWNLOAD_DIR, sub_filename)
-        if os.path.exists(sub_path):
-            try:
-                os.remove(sub_path)
-                logging.info(f"Deleted subtitle file {sub_filename} after /nosubs command")
-            except Exception as e:
-                logging.error(f"Error deleting subtitle file after /nosubs: {e}")
-        
-        # Update database to remove subtitle reference properly
-        # Get the current video filename and final filename to preserve them
-        vid_filename = db.get_vid_filename(chat_id)
-        final_filename = db.get_filename(chat_id)
-        
-        # First erase the complete record
-        db.erase(chat_id)
-        
-        # Then restore just the video data without subtitle
-        db.put_video(chat_id, vid_filename, final_filename)
-        
-        await processing_msg.edit("🗑️ Previous subtitle file deleted. Proceeding with encoding without subtitles...")
-        await asyncio.sleep(2)
-    
-    # Add user to skipped subtitle set
-    skipped_sub.add(chat_id)
-    
-    # Initialize encoding settings with defaults
-    user_settings[chat_id] = {
-        'crf': '23',
-        'preset': 'medium',
-        'resolution': 'original',
-        'fps': 'original',
-        'codec': 'h264',
-        'audio_bitrate': '128k',
-        'audio_track': 'all',
-        'filename': None,
-        'waiting_for': 'resolution'
-    }
-    
-    # Ask user for resolution
-    resolution_text = (
-        '🎬 <b>Choose Video Resolution:</b>\n\n'
-        '• <code>8K</code> - 7680x4320\n'
-        '• <code>4K</code> - 3840x2160\n'
-        '• <code>1440p</code> - 2560x1440\n'
-        '• <code>1080p</code> - 1920x1080\n'
-        '• <code>720p</code> - 1280x720\n'
-        '• <code>480p</code> - 854x480\n'
-        '• <code>360p</code> - 640x360\n'
-        '• <code>240p</code> - 426x240\n'
-        '• <code>144p</code> - 256x144\n'
-        '• <code>original</code> - Keep original resolution\n\n'
-        '💡 Type resolution or /default for original'
-    )
-    
-    await processing_msg.edit(resolution_text)
-
-@Client.on_message(filters.command('clear') & check_user & filters.private)
-async def clear_user_data(client, message):
-    chat_id = message.from_user.id
-    
-    # Send initial processing message
-    processing_msg = await client.send_message(chat_id, '⚙️ Processing...')
-    
-    # Check for active process
-    if await check_active_process(client, chat_id, processing_msg.id):
-        return
-    
-    # Remove from skip list if exists
-    if chat_id in skipped_sub:
-        skipped_sub.remove(chat_id)
-    
-    # Remove from encoding settings if exists
-    if chat_id in user_settings:
-        del user_settings[chat_id]
-    
-    # Delete files if they exist
-    path = Config.DOWNLOAD_DIR + '/'
-    files_deleted = False
-    
-    # Get filenames from database
-    vid_file = db.get_vid_filename(chat_id)
-    sub_file = db.get_sub_filename(chat_id)
-    
-    # Delete video file if exists
-    if vid_file and os.path.exists(path + vid_file):
-        try:
-            os.remove(path + vid_file)
-            files_deleted = True
-        except Exception as e:
-            print(f"Error deleting video file: {e}")
-    
-    # Delete subtitle file if exists
-    if sub_file and os.path.exists(path + sub_file):
-        try:
-            os.remove(path + sub_file)
-            files_deleted = True
-        except Exception as e:
-            print(f"Error deleting subtitle file: {e}")
-            
-    # Delete any in-progress encoding files
-    try:
-        for filename in os.listdir(path):
-            # Check for temporary encoding files that match the pattern
-            if filename.startswith(str(round(time.time()))[:5]) or \
-               (vid_file and filename.startswith(vid_file.split('.')[0])) or \
-               filename.endswith('_VidSub.mp4') or \
-               filename.endswith('1.mkv'):
-                try:
-                    os.remove(path + filename)
-                    files_deleted = True
-                except Exception as e:
-                    print(f"Error deleting encoding file {filename}: {e}")
-    except Exception as e:
-        print(f"Error scanning directory: {e}")
-    
-    # Clear database entry
-    db.erase(chat_id)
-    
-    # Clear active process status
-    if chat_id in active_processes:
-        del active_processes[chat_id]
-    
-    # Send appropriate message
-    if files_deleted:
-        await processing_msg.edit(
-            '🗑 All your data has been cleared:\n'
-            '• Video and subtitle files deleted\n'
-            '• Encoding settings reset\n'
-            '• Database entries removed\n\n'
-            'Send a new video file to start over!'
-        )
-    else:
-        await processing_msg.edit(
-            '🔄 Your session has been reset:\n'
-            '• Encoding settings cleared\n'
-            '• Database entries removed\n\n'
-            'Send a video file to start over!'
-        )
-
-@Client.on_message(filters.command('softcode') & check_user & filters.private)
-async def softmux(client, message):
-    chat_id = message.from_user.id
-    
-    # Send initial processing message
-    processing_msg = await client.send_message(chat_id, '⚙️ Processing...')
-    
-    # Check for active process
-    if await check_active_process(client, chat_id, processing_msg.id):
-        return
-    
-    # Check if user skipped subtitle
-    if chat_id in skipped_sub:
-        await processing_msg.edit(
-            '❌ Softcode encoding is not available because you skipped the subtitle file.\n\n'
-            'Use /clear to start over and upload both video and subtitle files.'
-        )
-        return
-    
-    og_vid_filename = db.get_vid_filename(chat_id)
-    og_sub_filename = db.get_sub_filename(chat_id)
-    text = ''
-    if not og_vid_filename :
-        text += '❌ No video file found! Please send a video first.\n'
-    if not og_sub_filename :
-        text += '❌ No subtitle file found! Please send subtitles.'
-
-    if not (og_sub_filename and og_vid_filename):
-        await processing_msg.edit(text)
-        return
-
-    text = (
-        '🎬 <b>Starting Soft Subtitle Encoding</b>\n\n'
-        '• Adding subtitles without re-encoding\n'
-        '• This process should be quick\n'
-        '• Please wait a moment...'
-    )
-    await processing_msg.edit(text)
-    await asyncio.sleep(1)
-
-    # Start encoding time tracking
-    encoding_start = time.time()
-    softmux_filename = await softmux_vid(og_vid_filename, og_sub_filename, processing_msg)
-    if not softmux_filename:
-        return
-    
-    # Calculate encoding time
-    encoding_time = round(time.time() - encoding_start)
-
-    # Create user-specific directory if it doesn't exist
-    user_dir = os.path.join(Config.DOWNLOAD_DIR, str(chat_id))
-    if not os.path.exists(user_dir):
-        os.makedirs(user_dir)
-    
-    # Get the filename from the database
-    final_filename = db.get_filename(chat_id)
-    
-    # Extract just the original filename part (remove timestamp_random_ prefix)
-    if '_' in final_filename:
-        # Find the second underscore (after timestamp_random_)
-        parts = final_filename.split('_', 2)  # Split on first 2 underscores
-        if len(parts) >= 3:
-            original_filename = parts[2]  # Get everything after the second underscore
-        else:
-            original_filename = final_filename  # Fallback if format is unexpected
-    else:
-        original_filename = final_filename  # Fallback if no underscore
-    
-    # Get custom filename if available
-    custom_filename = None
-    if chat_id in user_settings and user_settings[chat_id].get('filename'):
-        custom_filename = user_settings[chat_id].get('filename')
-    
-    # For softmux, always use .mkv extension
-    if custom_filename:
-        # Ensure the extension is .mkv
-        if not custom_filename.lower().endswith('.mkv'):
-            name_without_ext = os.path.splitext(custom_filename)[0]
-            destination_filename = name_without_ext + '.mkv'
-        else:
-            destination_filename = custom_filename
-    else:
-        # Ensure the extension is .mkv
-        if not original_filename.lower().endswith('.mkv'):
-            name_without_ext = os.path.splitext(original_filename)[0]
-            destination_filename = name_without_ext + '.mkv'
-        else:
-            destination_filename = original_filename
-    
-    # Move file to user directory with the appropriate filename
-    source_path = os.path.join(Config.DOWNLOAD_DIR, softmux_filename)
-    destination_path = os.path.join(user_dir, destination_filename)
-    
-    # Make sure the source file exists before trying to move it
-    if os.path.exists(source_path):
-        os.rename(source_path, destination_path)
-        logging.info(f"Moved file from {source_path} to {destination_path}")
-    else:
-        logging.error(f"Source file not found: {source_path}")
-        await client.send_message(
-            chat_id, 
-            '❌ <b>Error</b>\n\n'
-            'Could not find the encoded file. Please try again.'
-        )
-        return
-    
-    # Clean up settings AFTER moving the file
-    if chat_id in user_settings:
-        del user_settings[chat_id]
-    
-    # Start upload time tracking
-    upload_start = time.time()
-    try:
-        # Set active process to upload
-        set_process_status(chat_id, 'upload')
-        
-        await client.send_document(
-                chat_id, 
-                progress = progress_bar, 
-                progress_args = (
-                'Uploading',
-                    processing_msg,
-                    upload_start
-                    ), 
-                document = destination_path,
-                caption = f'📁 {destination_filename}'
-        )
-        # Calculate upload time
-        upload_time = round(time.time() - upload_start)
-        text = (
-            '✅ <b>File Successfully Uploaded!</b>\n\n'
-            f'⚡ Encoding Time: {format_time_duration(encoding_time)}\n'
-            f'📤 Upload Time: {format_time_duration(upload_time)}\n'
-            f'⏱️ Total Time: {format_time_duration(encoding_time + upload_time)}'
-        )
-        await processing_msg.edit(text)
-
-        # Cleanup inside try block AFTER successful upload
-        path = Config.DOWNLOAD_DIR+'/'
-        
-        # Delete source files
-        if og_sub_filename and os.path.exists(path + og_sub_filename):
-            os.remove(path + og_sub_filename)
-            logging.info(f"Deleted subtitle file: {og_sub_filename}")
-            
-        if og_vid_filename and os.path.exists(path + og_vid_filename):
-            os.remove(path + og_vid_filename)
-            logging.info(f"Deleted video file: {og_vid_filename}")
-        
-        # Delete the final encoded file from user directory
-        if os.path.exists(destination_path):
-            os.remove(destination_path)
-            logging.info(f"Deleted final encoded file: {destination_path}")
-        
-        # Try to remove user directory if it exists
-        try:
-            if os.path.exists(user_dir):
-                if len(os.listdir(user_dir)) == 0:
-                    os.rmdir(user_dir)
-                    logging.info(f"Removed empty user directory: {user_dir}")
-                else:
-                    logging.warning(f"User directory not empty, cannot remove: {user_dir}")
-        except Exception as e:
-            logging.error(f"Error removing user directory: {e}")
-        
-        db.erase(chat_id)
-
-    except Exception as e:
-        print(e)
-        await client.send_message(
-            chat_id, 
-            '❌ <b>Upload Failed!</b>\n\n'
-            'An error occurred while uploading the file.\n'
-            'Please check logs for details.'
-        )
-    finally:
-        # Clear process status at the end
-        clear_process_status(chat_id)
-
-@Client.on_message(filters.command(['hardcode', 'quick']) & check_user & filters.private)
-async def hardmux(client, message):
-    chat_id = message.from_user.id
-    command = message.text.split()[0].lower()  # Get the actual command used
-    
-    # Send initial processing message
-    processing_msg = await client.send_message(chat_id, '⚙️ Processing...')
-    
-    # Check for active process
-    if await check_active_process(client, chat_id, processing_msg.id):
-        return
-    
-    # Handle /quick separately
-    if command == '/quick':
-        logging.info(f"User {chat_id} used /quick command")
-        
-        # Check if video exists
-        if not db.check_video(chat_id):
-            await processing_msg.edit("❌ Send video file first!")
-            return
-        
-        # Apply default encoding settings
-        user_settings[chat_id] = EncodingDefaults.DEFAULT_ENCODING.copy()
-        
-        # Add filename and waiting_for fields
-        user_settings[chat_id]['filename'] = None
-        user_settings[chat_id]['waiting_for'] = 'filename'
-        
-        # Get current filename from database to show as default
-        final_filename = db.get_filename(chat_id)
-        
-        # Extract just the original filename part (remove timestamp_random_ prefix)
-        if '_' in final_filename:
-            # Find the second underscore (after timestamp_random_)
-            parts = final_filename.split('_', 2)  # Split on first 2 underscores
-            if len(parts) >= 3:
-                original_filename = parts[2]  # Get everything after the second underscore
-            else:
-                original_filename = final_filename  # Fallback if format is unexpected
-        else:
-            original_filename = final_filename  # Fallback if no underscore
-        
-        filename_text = (
-            '📝 <b>Choose Output Filename:</b>\n\n'
-            '• You can change the output filename\n'
-            '• Must end with .mp4 or .mkv or .webm extension\n'
-            '• Maximum length: 60 characters\n\n'
-            f'Current filename: <code>{original_filename}</code>\n\n'
-            '💡 Type a new filename or /default to keep current'
-        )
-        
-        await processing_msg.edit(filename_text)
-        return
-    
-    # Original hardcode logic continues below
-    og_vid_filename = db.get_vid_filename(chat_id)
-    og_sub_filename = db.get_sub_filename(chat_id)
-    
-    # Check if video exists
-    if not og_vid_filename:
-        await processing_msg.edit('❌ No video file found! Please send a video first.')
-        return
-    
-    # Check if subtitle exists or was skipped
-    if not og_sub_filename and chat_id not in skipped_sub:
-        await processing_msg.edit(
-            '❌ No subtitle file found!\n\n'
-            'Either:\n'
-            '• Send a subtitle file\n'
-            '• Use /nosubs to encode without subtitles'
-        )
-        return
-    
-    # Initialize encoding settings with defaults
-    user_settings[chat_id] = {
-        'crf': '23',
-        'preset': 'medium',
-        'resolution': 'original',
-        'fps': 'original',
-        'codec': 'h264',
-        'audio_bitrate': '128k',
-        'audio_track': 'all',
-        'filename': None,
-        'waiting_for': 'resolution'
-    }
-    
-    # Ask user for resolution
-    resolution_text = (
-        '🎬 <b>Choose Video Resolution:</b>\n\n'
-        '• <code>8K</code> - 7680x4320\n'
-        '• <code>4K</code> - 3840x2160\n'
-        '• <code>1440p</code> - 2560x1440\n'
-        '• <code>1080p</code> - 1920x1080\n'
-        '• <code>720p</code> - 1280x720\n'
-        '• <code>480p</code> - 854x480\n'
-        '• <code>360p</code> - 640x360\n'
-        '• <code>240p</code> - 426x240\n'
-        '• <code>144p</code> - 256x144\n'
-        '• <code>original</code> - Keep original resolution\n\n'
-        '💡 Type resolution or /default for original'
-    )
-    
-    await processing_msg.edit(resolution_text)
-    return
-
-@Client.on_message(filters.text & check_user & filters.private)
-async def handle_encoding_settings(client, message):
-    chat_id = message.from_user.id
-    
-    # Check if we're waiting for encoding settings from this user
-    if chat_id not in user_settings:
-        return
-    
-    # Get what we're waiting for
-    waiting_for = user_settings[chat_id]['waiting_for']
-    
-    # Handle resolution input
-    if waiting_for == 'resolution':
-        text = message.text.strip().lower()
-        
-        # Handle default case
-        if text == '/default':
-            resolution = 'original'
-        else:
-            # Validate resolution
-            if text not in RESOLUTIONS:
-                return await client.send_message(
-                    chat_id, 
-                    '❌ <b>Invalid Resolution</b>\n\n'
-                    'Please choose from the list or use /default\n'
-                    'for original resolution.'
-                )
-            resolution = text
-        
-        # Save resolution and ask for frame rate
-        user_settings[chat_id]['resolution'] = resolution
-        user_settings[chat_id]['waiting_for'] = 'fps'
-        
-        # Ask user for frame rate
-        fps_text = (
-            '🎥 <b>Choose Frame Rate:</b>\n\n'
-            '• <code>60</code> - 60 FPS\n'
-            '• <code>50</code> - 50 FPS\n'
-            '• <code>30</code> - 30 FPS\n'
-            '• <code>25</code> - 25 FPS\n'
-            '• <code>24</code> - 24 FPS\n'
-            '• <code>original</code> - Keep original FPS\n'
-            '• Custom FPS value between 1 and 120\n\n'
-            '💡 Type FPS value or /default for original'
-        )
-        
-        await client.send_message(chat_id, fps_text)
-        return
-    
-    # Handle frame rate input
-    elif waiting_for == 'fps':
-        text = message.text.strip().lower()
-        
-        # Handle default case
-        if text == '/default':
-            fps = 'original'
-        else:
-            # Check if it's one of the preset options
-            if text in FRAME_RATES:
-                fps = text
-            else:
-                # Try to parse custom frame rate
-                try:
-                    fps_value = float(text)
-                    if 1 <= fps_value <= 120:
-                        fps = str(fps_value)
-                    else:
-                        return await client.send_message(
-                            chat_id,
-                            '❌ <b>Invalid Frame Rate</b>\n\n'
-                            '• Must be between 1 and 120 FPS\n'
-                            '• Choose from the list or\n'
-                            '• Enter a custom value\n'
-                            '• Use /default for original FPS'
-                        )
-                except ValueError:
-                    return await client.send_message(
-                        chat_id,
-                        '❌ <b>Invalid Frame Rate</b>\n\n'
-                        '• Must be between 1 and 120 FPS\n'
-                        '• Choose from the list or\n'
-                        '• Enter a custom value\n'
-                        '• Use /default for original FPS'
-                    )
-        
-        # Save frame rate and ask for audio bitrate
-        user_settings[chat_id]['fps'] = fps
-        user_settings[chat_id]['waiting_for'] = 'audio_bitrate'
-        
-        # Ask user for audio bitrate
-        audio_bitrate_text = (
-            '🔊 <b>Choose Audio Bitrate:</b>\n\n'
-            '• <code>64k</code> - Lower quality, smaller file\n'
-            '• <code>128k</code> - Standard quality (recommended)\n'
-            '• <code>192k</code> - Higher quality\n'
-            '• <code>256k</code> - High quality\n'
-            '• <code>320k</code> - Very high quality\n\n'
-            '💡 Type a value (e.g., 128k) or /default for 128k'
-        )
-        
-        await client.send_message(chat_id, audio_bitrate_text)
-        return
-    
-    # Handle audio bitrate input
-    elif waiting_for == 'audio_bitrate':
-        text = message.text.strip().lower()
-        
-        # Handle default case
-        if text == '/default':
-            audio_bitrate = '128k'
-        else:
-            # Validate audio bitrate format
-            if re.match(r'^\d+k$', text):
-                # Extract the number part
-                bitrate_value = int(text.rstrip('k'))
-                if 32 <= bitrate_value <= 320:
-                    audio_bitrate = text
-                else:
-                    return await client.send_message(
-                        chat_id,
-                        '❌ <b>Invalid Audio Bitrate</b>\n\n'
-                        '• Must be between 32k and 320k\n'
-                        '• Format example: 128k\n'
-                        '• Use /default for 128k'
-                    )
-            else:
-                return await client.send_message(
-                    chat_id,
-                    '❌ <b>Invalid Audio Bitrate Format</b>\n\n'
-                    '• Must be in format like 128k\n'
-                    '• Use /default for 128k'
-                )
-        
-        # Save audio bitrate and ask for codec
-        user_settings[chat_id]['audio_bitrate'] = audio_bitrate
-        user_settings[chat_id]['waiting_for'] = 'codec'
-        
-        # Ask user for codec
-        codec_text = (
-            '🎞️ <b>Choose Video Codec:</b>\n\n'
-            '• H.264 (AVC) - Better compatibility\n'
-            '• H.265 (HEVC) - Smaller file size\n\n'
-            '💡 Type <code>h264</code>/<code>h265</code> or /default for H.264'
-        )
-        
-        await client.send_message(chat_id, codec_text)
-        return
-    
-    # Handle codec input
-    elif waiting_for == 'codec':
-        text = message.text.strip().lower()
-        
-        # Handle default case
-        if text == '/default':
-            codec = 'h264'
-        else:
-            # Validate codec
-            if text not in CODECS:
-                return await client.send_message(
-                    chat_id, 
-                    '❌ <b>Invalid Codec</b>\n\n'
-                    'Please type <code>h264</code>/<code>h265</code> or /default.'
-                )
-            codec = text
-        
-        # Save codec and ask for CRF
-        user_settings[chat_id]['codec'] = codec
-        user_settings[chat_id]['waiting_for'] = 'crf'
-        
-        # Ask user for CRF value
-        crf_text = (
-            '📊 <b>Set Video Quality (CRF):</b>\n\n'
-            '• Lower value = Higher quality, larger file\n'
-            '• Higher value = Lower quality, smaller file\n'
-            '• Recommended: 18-28\n'
-            '• Range: 0-51\n\n'
-            '💡 Type a number or /default for 23'
-        )
-        
-        await client.send_message(chat_id, crf_text)
-        return
-    
-    # Handle CRF input
-    elif waiting_for == 'crf':
-        text = message.text.strip()
-        
-        # Handle default case
-        if text.lower() == '/default':
-            crf = '23'
-        else:
-            # Validate CRF value
-            try:
-                crf_value = int(text)
-                if crf_value < MIN_CRF or crf_value > MAX_CRF:
-                    return await client.send_message(
-                        chat_id, 
-                        '❌ <b>Invalid CRF Value</b>\n\n'
-                        f'• Must be between {MIN_CRF} and {MAX_CRF}\n'
-                        '• Lower = Better quality\n'
-                        '• Higher = Smaller file\n'
-                        '• Use /default for 23'
-                    )
-                crf = str(crf_value)
-            except ValueError:
-                return await client.send_message(
-                    chat_id, 
-                    '❌ <b>Invalid CRF Value</b>\n\n'
-                    f'• Must be between {MIN_CRF} and {MAX_CRF}\n'
-                    '• Lower = Better quality\n'
-                    '• Higher = Smaller file\n'
-                    '• Use /default for 23'
-                )
-        
-        # Save CRF value and ask for preset
-        user_settings[chat_id]['crf'] = crf
-        user_settings[chat_id]['waiting_for'] = 'preset'
-        
-        preset_text = (
-            '⚙️ <b>Choose Encoding Preset:</b>\n\n'
-            '• <code>ultrafast</code> - Fastest, lowest compression\n'
-            '• <code>superfast</code> - Very fast encoding\n'
-            '• <code>veryfast</code> - Fast encoding\n'
-            '• <code>faster</code> - Quick encoding\n'
-            '• <code>fast</code> - Good balance\n'
-            '• <code>medium</code> - Default preset\n'
-            '• <code>slow</code> - Better compression\n'
-            '• <code>slower</code> - High compression\n'
-            '• <code>veryslow</code> - Best compression\n\n'
-            '💡 Type preset or /default for medium'
-        )
-        
-        await client.send_message(chat_id, preset_text)
-        return
-
-    # Handle preset input
-    elif waiting_for == 'preset':
-        text = message.text.strip().lower()
-        
-        # Handle default case
-        if text == '/default':
-            preset = 'medium'
-        else:
-            # Validate preset
-            if text not in VALID_PRESETS:
-                return await client.send_message(
-                    chat_id, 
-                    '❌ <b>Invalid Preset</b>\n\n'
-                    'Please choose from the list or use /default\n'
-                    'for medium encoding.'
-                )
-            preset = text
-        
-        # Save preset and now ask for audio track
-        user_settings[chat_id]['preset'] = preset
-        user_settings[chat_id]['waiting_for'] = 'audio_track'
-        
-        # Ask user for audio track
-        audio_track_text = (
-            '🔊 <b>Choose Audio Track:</b>\n\n'
-            '• <code>all</code> - Keep all audio tracks\n'
-            '• <code>1</code> - First audio track only\n'
-            '• <code>2</code> - Second audio track only\n'
-            '• <code>3</code> - Third audio track only\n'
-            '• etc.\n\n'
-            '💡 Type <code>all</code> or track number or /default for all tracks'
-        )
-        
-        await client.send_message(chat_id, audio_track_text)
-        return
-        
-    # Add handler for audio track input
-    elif waiting_for == 'audio_track':
-        text = message.text.strip().lower()
-        
-        # Handle default case
-        if text == '/default':
-            audio_track = 'all'
-        elif text == 'all':
-            audio_track = 'all'
-        else:
-            # Try to parse as a track number
-            try:
-                track_num = int(text)
-                if track_num < 1:
-                    return await client.send_message(
-                        chat_id,
-                        '❌ <b>Invalid Track Number</b>\n\n'
-                        'Track numbers start from 1.\n'
-                        'Use <code>all</code> or /default to keep all tracks.'
-                    )
-                audio_track = str(track_num)
-            except ValueError:
-                return await client.send_message(
-                    chat_id,
-                    '❌ <b>Invalid Audio Track Selection</b>\n\n'
-                    'Please choose <code>all</code> or enter a track number (1, 2, 3, etc.)\n'
-                    'Use /default to keep all tracks.'
-                )
-        
-        # Save audio track and ask for filename
-        user_settings[chat_id]['audio_track'] = audio_track
-        user_settings[chat_id]['waiting_for'] = 'filename'
-        
-        # Get current filename from database to show as default
-        final_filename = db.get_filename(chat_id)
-        
-        # Extract just the original filename part (remove timestamp_random_ prefix)
-        if '_' in final_filename:
-            # Find the second underscore (after timestamp_random_)
-            parts = final_filename.split('_', 2)  # Split on first 2 underscores
-            if len(parts) >= 3:
-                original_filename = parts[2]  # Get everything after the second underscore
-            else:
-                original_filename = final_filename  # Fallback if format is unexpected
-        else:
-            original_filename = final_filename  # Fallback if no underscore
-        
-        filename_text = (
-            '📝 <b>Choose Output Filename:</b>\n\n'
-            '• You can change the output filename\n'
-            '• Must end with .mp4 or .mkv or .webm extension\n'
-            '• Maximum length: 60 characters\n\n'
-            f'Current filename: <code>{original_filename}</code>\n\n'
-            '💡 Type a new filename or /default to keep current'
-        )
-        
-        await client.send_message(chat_id, filename_text)
-        return
-
-    # Modify the filename handler to go directly to confirmation
-    elif waiting_for == 'filename':
-        text = message.text.strip()
-        
-        # Handle default case
-        if text.lower() == '/default':
-            # Get current filename from database
-            final_filename = db.get_filename(chat_id)
-            
-            # Extract just the original filename part
-            if '_' in final_filename:
-                parts = final_filename.split('_', 2)
-                if len(parts) >= 3:
-                    original_filename = parts[2]
-                else:
-                    original_filename = final_filename
-            else:
-                original_filename = final_filename
-            
-            user_settings[chat_id]['filename'] = original_filename
-        else:
-            # Validate filename
-            if len(text) > 60:
-                return await client.send_message(
-                    chat_id,
-                    '❌ <b>Filename Too Long</b>\n\n'
-                    'Please keep the filename under 60 characters.'
-                )
-            
-            # Check for valid extension
-            if not (text.lower().endswith('.mp4') or text.lower().endswith('.mkv') or text.lower().endswith('.webm')):
-                return await client.send_message(
-                    chat_id,
-                    '❌ <b>Invalid Filename Extension</b>\n\n'
-                    'Filename must end with .mp4 or .mkv or .webm extension.'
-                )
-                
-            # Check for illegal characters
-            illegal_chars = ['\\', '/', ':', '*', '?', '"', '<', '>', '|']
-            if any(char in text for char in illegal_chars):
-                return await client.send_message(
-                    chat_id,
-                    '❌ <b>Invalid Filename</b>\n\n'
-                    'Filename cannot contain any of these characters:\n'
-                    '<code>\\ / : * ? " < > |</code>'
-                )
-            
-            # Save the new filename
-            user_settings[chat_id]['filename'] = text
-        
-        # Move to confirmation
-        user_settings[chat_id]['waiting_for'] = 'confirmation'
-        
-        # Show settings and ask for confirmation
-        resolution_display = user_settings[chat_id]['resolution']
-        codec_display = user_settings[chat_id]['codec'].upper()
-        fps_display = user_settings[chat_id]['fps']
-        audio_bitrate_display = user_settings[chat_id]['audio_bitrate']
-        audio_track_display = user_settings[chat_id]['audio_track']
-        filename_display = user_settings[chat_id]['filename']
-        
-        # Check if subtitles will be included
-        has_subtitle = db.check_sub(chat_id) and chat_id not in skipped_sub
-        subtitle_status = "Will be hardcoded" if has_subtitle else "No subtitles"
-        
-        # Create confirmation text with conditional skip option
-        confirm_text = (
-            '📝 <b>Review Encoding Settings:</b>\n\n'
-            f'• Resolution: {resolution_display}\n'
-            f'• Frame Rate: {fps_display}\n'
-            f'• Audio Bitrate: {audio_bitrate_display}\n'
-            f'• Audio Track: {audio_track_display}\n'
-            f'• Codec: {codec_display}\n'
-            f'• CRF: {user_settings[chat_id]["crf"]}\n'
-            f'• Preset: {user_settings[chat_id]["preset"]}\n'
-            f'• Subtitles: {subtitle_status}\n'
-            f'• Filename: {filename_display}\n\n'
-            '⚡️ <b>Available Commands:</b>\n'
-            '• /confirm - Start encoding\n'
-            '• /reset - Choose settings again\n'
-        )
-        
-        # Only add skip option if subtitle exists
-        if has_subtitle:
-            confirm_text += '• /nosubs - Encode without subtitles\n'
-            
-        # Add the last option always
-        confirm_text += '• /clear - Clear all data'
-        
-        await client.send_message(chat_id, confirm_text)
-        return
-
-    # Handle confirmation
-    elif waiting_for == 'confirmation':
-        command = message.text.strip().lower()
-        
-        if command == '/confirm':
-            # Update waiting_for to None to prevent further processing
-            user_settings[chat_id]['waiting_for'] = None
-            
-            # Send starting message
-            sent_msg = await client.send_message(
-                chat_id,
-                '🎬 <b>Starting Encoding Process</b>\n\nThis might take some time depending on your settings...'
-            )
-            await asyncio.sleep(1)
-            
-            # Start encoding with the selected settings
-            og_vid_filename = db.get_vid_filename(chat_id)
-            og_sub_filename = db.get_sub_filename(chat_id)
-            
-            encoding_start = time.time()
-            hardmux_filename = await hardmux_vid(
-                og_vid_filename, 
-                og_sub_filename, 
-                sent_msg,
-                crf=user_settings[chat_id]['crf'],
-                preset=user_settings[chat_id]['preset'],
-                resolution=user_settings[chat_id]['resolution'],
-                codec=user_settings[chat_id]['codec'],
-                fps=user_settings[chat_id]['fps'],
-                audio_bitrate=user_settings[chat_id]['audio_bitrate'],
-                audio_track=user_settings[chat_id]['audio_track'],
-                custom_filename=user_settings[chat_id]['filename']
-            )
-            
-            # Calculate encoding time
-            encoding_time = round(time.time() - encoding_start)
-            
-            # Get custom filename before cleaning up settings
-            custom_filename = user_settings[chat_id].get('filename')
-            
-            # Clean up settings
-            del user_settings[chat_id]
-            
-            if not hardmux_filename:
-                return
-            
-            # Create user-specific directory if it doesn't exist
-            user_dir = os.path.join(Config.DOWNLOAD_DIR, str(chat_id))
-            if not os.path.exists(user_dir):
-                os.makedirs(user_dir)
-            
-            # Move file to user-specific directory with the custom filename
-            source_path = os.path.join(Config.DOWNLOAD_DIR, hardmux_filename)
-            
-            # Use custom filename if provided, otherwise use extracted original filename
-            if custom_filename:
-                destination_filename = custom_filename
-            else:
-                # Get the filename from the database
-                final_filename = db.get_filename(chat_id)
-                
-                # Extract just the original filename part (remove timestamp_random_ prefix)
-                if '_' in final_filename:
-                    # Find the second underscore (after timestamp_random_)
-                    parts = final_filename.split('_', 2)  # Split on first 2 underscores
-                    if len(parts) >= 3:
-                        destination_filename = parts[2]  # Get everything after the second underscore
-                    else:
-                        destination_filename = final_filename  # Fallback if format is unexpected
-                else:
-                    destination_filename = final_filename  # Fallback if no underscore
-            
-            destination_path = os.path.join(user_dir, destination_filename)
-            os.rename(source_path, destination_path)
-            
-            # Start upload time tracking
-            upload_start = time.time()
-            try:
-                # Set active process to upload
-                set_process_status(chat_id, 'upload')
-                
-                await client.send_document(
-                    chat_id, 
-                    progress = progress_bar, 
-                    progress_args = (
-                        'Uploading',
-                        sent_msg,
-                        upload_start
-                    ), 
-                    document = destination_path,
-                    caption = f'📁 {destination_filename}'
-                )
-                upload_time = round(time.time() - upload_start)
-                text = (
-                    '✅ <b>File Successfully Uploaded!</b>\n\n'
-                    f'⚡ Encoding Time: {format_time_duration(encoding_time)}\n'
-                    f'📤 Upload Time: {format_time_duration(upload_time)}\n'
-                    f'⏱️ Total Time: {format_time_duration(encoding_time + upload_time)}'
-                )
-                await sent_msg.edit(text)
-                
-                # Cleanup inside try block AFTER successful upload
-                path = Config.DOWNLOAD_DIR+'/'
-                
-                # Delete source files
-                if og_vid_filename and os.path.exists(path + og_vid_filename):
-                    os.remove(path + og_vid_filename)
-                    logging.info(f"Deleted video file: {og_vid_filename}")
-                    
-                if og_sub_filename and os.path.exists(path + og_sub_filename):
-                    os.remove(path + og_sub_filename)
-                    logging.info(f"Deleted subtitle file: {og_sub_filename}")
-                
-                # Delete the final encoded file from user directory
-                if os.path.exists(destination_path):
-                    os.remove(destination_path)
-                    logging.info(f"Deleted final encoded file: {destination_path}")
-                
-                # Try to remove user directory if it exists
-                try:
-                    if os.path.exists(user_dir):
-                        if len(os.listdir(user_dir)) == 0:
-                            os.rmdir(user_dir)
-                            logging.info(f"Removed empty user directory: {user_dir}")
-                        else:
-                            logging.warning(f"User directory not empty, cannot remove: {user_dir}")
-                except Exception as e:
-                    logging.error(f"Error removing user directory: {e}")
-                
-                db.erase(chat_id)
-                if chat_id in skipped_sub:
-                    skipped_sub.remove(chat_id)
-            
-            except Exception as e:
-                print(e)
-                await client.send_message(
-                    chat_id, 
-                    '❌ <b>Upload Failed!</b>\n\n'
-                    'An error occurred while uploading the file.\n'
-                    'Please check logs for details.'
-                )
-            finally:
-                # Clear process status at the end
-                clear_process_status(chat_id)
-            
-        elif command == '/reset':
-            # Reset to initial settings and start over with resolution
-            user_settings[chat_id] = {
-                'crf': '23',
-                'preset': 'medium',
-                'resolution': 'original',
-                'fps': 'original',
-                'codec': 'h264',
-                'audio_bitrate': '128k',
-                'audio_track': 'all',
-                'filename': None,
-                'waiting_for': 'resolution'
-            }
-            
-            # Show resolution options again
-            resolution_text = (
-                '🎬 <b>Choose Video Resolution:</b>\n\n'
-                '• <code>8K</code> - 7680x4320\n'
-                '• <code>4K</code> - 3840x2160\n'
-                '• <code>1440p</code> - 2560x1440\n'
-                '• <code>1080p</code> - 1920x1080\n'
-                '• <code>720p</code> - 1280x720\n'
-                '• <code>480p</code> - 854x480\n'
-                '• <code>360p</code> - 640x360\n'
-                '• <code>240p</code> - 426x240\n'
-                '• <code>144p</code> - 256x144\n'
-                '• <code>original</code> - Keep original resolution\n\n'
-                '💡 Type resolution or /default for original'
-            )
-            
-            await client.send_message(chat_id, resolution_text)
-            return
-            
-        elif command == '/clear':
-            # Call the existing clear function
-            await clear_user_data(client, message)
-            return
-            
-        else:
-            # Invalid command
-            await client.send_message(
-                chat_id,
-                '⚠️ <b>Invalid Command</b>\n\n'
-                '📝 <b>Available Commands:</b>\n'
-                '• /confirm - Start encoding\n'
-                '• /reset - Choose settings again\n'
-                '• /nosubs - Encode without subtitles\n'
-                '• /clear - Clear all data'
-            )
-            return