Update app.py

app.py

@@ -1,238 +1,835 @@
+# app.py
 import os
-import json
 import asyncio
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+import tempfile
+import threading
+import time
 from functools import wraps
-from flask import Flask, request, redirect, session, url_for, render_template, jsonify, flash
-from google_auth_oauthlib.flow import Flow
-from telethon.sync import TelegramClient
-from telethon.sessions import StringSession
-from telethon.errors import SessionPasswordNeededError, PhoneCodeInvalidError, ApiIdInvalidError, ApiIdPublishedFloodError
-
-from telegram_youtube_workflow import TelegramYouTubeWorkflow, logger
-
-# Initialize Flask App
+from flask import Flask, render_template, request, redirect, url_for, flash, session, jsonify
+from werkzeug.security import check_password_hash, generate_password_hash
+import secrets
+# Required libraries
+from telethon import TelegramClient, errors
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from googleapiclient.http import MediaFileUpload
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+import firebase_admin
+from firebase_admin import credentials, firestore
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 app = Flask(__name__)
-app.secret_key = os.environ.get('FLASK_SECRET_KEY', 'a-strong-dev-secret-key-for-local-runs')
-
-# --- Configuration & DB Logic ---
-def setup_configuration():
-    """Loads secrets from environment variables and writes them to files at runtime."""
-    client_secrets_content = os.environ.get('CLIENT_SECRETS_CONTENT')
-    if client_secrets_content:
-        with open('client_secrets.json', 'w') as f: f.write(client_secrets_content)
-        logger.info("Successfully created client_secrets.json.")
-
-    firebase_key_content = os.environ.get('FIREBASE_KEY_CONTENT')
-    if firebase_key_content:
-        with open('firebase_service_account.json', 'w') as f: f.write(firebase_key_content)
-        logger.info("Successfully created firebase_service_account.json.")
-
-    # The session string will now be loaded from the database
-    session_string = load_telegram_session_from_db()
-
-    return {
-        "telegram": {
-            "api_id": os.environ.get('TELEGRAM_API_ID'),
-            "api_hash": os.environ.get('TELEGRAM_API_HASH'),
-            "session_string": session_string,
-            "channel_username": os.environ.get('TELEGRAM_CHANNEL_USERNAME')
-        },
-        "youtube": { "client_secrets_file": "client_secrets.json" },
-        "firebase": { "service_account_key": "firebase_service_account.json", "collection_name": os.environ.get('FIREBASE_COLLECTION_NAME', 'processed_videos') },
-        "download_directory": "downloads",
-        "video_settings": {
-            "title_prefix": os.environ.get('VIDEO_TITLE_PREFIX', ''), "description_template": os.environ.get('VIDEO_DESCRIPTION', 'Video from Telegram channel'),
-            "tags": os.environ.get('VIDEO_TAGS', 'telegram,video').split(','), "category_id": os.environ.get('VIDEO_CATEGORY_ID', '22'),
-            "privacy_status": os.environ.get('VIDEO_PRIVACY_STATUS', 'private')
-        }
-    }
+app.secret_key = os.environ.get('FLASK_SECRET_KEY', secrets.token_hex(32))
 
-workflow = TelegramYouTubeWorkflow(setup_configuration())
+# --- Add this section for User Configuration ---
+USER_CONFIG_FILE = 'user_config.json'
 
-def save_telegram_session_to_db(session_string):
-    """Saves the Telethon session string to Firestore."""
-    try:
-        if not workflow.firestore_db:
-            logger.error("Firestore is not initialized. Cannot save session.")
-            return
-        doc_ref = workflow.firestore_db.collection('app_config').document('telegram_credentials')
-        doc_ref.set({'session_string': session_string})
-        logger.info("Successfully saved Telethon session to Firestore.")
-    except Exception as e:
-        logger.error(f"Failed to save session to Firestore: {e}")
+def load_user_config():
+    """Load user configuration from file."""
+    config = {}
+    if os.path.exists(USER_CONFIG_FILE):
+        try:
+            with open(USER_CONFIG_FILE, 'r') as f:
+                config = json.load(f)
+        except Exception as e:
+            logger.error(f"Error loading user config: {e}")
+    return config
 
-def load_telegram_session_from_db():
-    """Loads the Telethon session string from Firestore."""
+def save_user_config(config):
+    """Save user configuration to file."""
     try:
-        if not workflow.firestore_db: return None
-        doc_ref = workflow.firestore_db.collection('app_config').document('telegram_credentials')
-        doc = doc_ref.get()
-        if doc.exists:
-            logger.info("Loaded Telethon session from Firestore.")
-            return doc.to_dict().get('session_string')
-        return None
+        # Basic validation could be added here
+        with open(USER_CONFIG_FILE, 'w') as f:
+            json.dump(config, f, indent=4)
+        logger.info("User configuration saved successfully.")
     except Exception as e:
-        logger.error(f"Failed to load session from Firestore: {e}")
-        return None
+        logger.error(f"Error saving user config: {e}")
+        raise # Re-raise to be handled by the route
+
+# Global variables for workflow state
+workflow_instance = None
+processing_status = {
+    'is_running': False,
+    'current_batch': 0,
+    'processed_count': 0,
+    'failed_count': 0,
+    'waiting_for_confirmation': False,
+    'confirmation_message': '',
+    'logs': []
+}
+
+class WebAppLogger:
+    """Custom logger to capture logs for web display"""
+    def __init__(self):
+        self.logs = []
+        self.max_logs = 100
+    def add_log(self, level, message):
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        log_entry = {
+            'timestamp': timestamp,
+            'level': level,
+            'message': message
+        }
+        self.logs.append(log_entry)
+        if len(self.logs) > self.max_logs:
+            self.logs.pop(0)
+        # Also log to console
+        if level == 'INFO':
+            logger.info(message)
+        elif level == 'ERROR':
+            logger.error(message)
+        elif level == 'WARNING':
+            logger.warning(message)
+    def get_logs(self):
+        return self.logs
+    def clear_logs(self):
+        self.logs = []
+
+web_logger = WebAppLogger()
+
+class TelegramYouTubeWorkflow:
+    def __init__(self):
+        """Initialize the workflow with environment variables and user config"""
+        self.telegram_client = None
+        self.youtube_service = None
+        self.firestore_db = None
+        self.download_dir = Path(tempfile.gettempdir()) / 'telegram_downloads'
+        self.download_dir.mkdir(exist_ok=True)
+        # YouTube API scopes
+        self.SCOPES = ['https://www.googleapis.com/auth/youtube.upload', 'https://www.googleapis.com/auth/youtube']
+        # --- Load User Configuration ---
+        self.user_config = load_user_config()
+        # Initialize Firebase
+        self.setup_firebase()
+
+    def create_file_from_env(self, env_var_name, filename):
+        """Create file from environment variable content"""
+        content = os.environ.get(env_var_name)
+        if not content:
+            raise ValueError(f"Environment variable {env_var_name} not found")
+        filepath = Path(filename)
+        with open(filepath, 'w') as f:
+            f.write(content)
+        web_logger.add_log('INFO', f"Created {filename} from environment variable")
+        return str(filepath)
+
+    def setup_firebase(self):
+        """Initialize Firebase connection"""
+        try:
+            # Create Firebase service account key from environment variable
+            service_account_path = self.create_file_from_env('FIREBASE_SERVICE_ACCOUNT_KEY', 'firebase_service_account.json')
+            # Initialize Firebase Admin SDK
+            if not firebase_admin._apps:
+                cred = credentials.Certificate(service_account_path)
+                firebase_admin.initialize_app(cred)
+            self.firestore_db = firestore.client()
+            self.collection_name = os.environ.get('FIREBASE_COLLECTION_NAME', 'processed_videos')
+            web_logger.add_log('INFO', "Firebase connection established successfully")
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error setting up Firebase: {e}")
+            raise
+
+    async def setup_telegram_client(self):
+        """Initialize and connect to Telegram"""
+        try:
+            api_id = os.environ.get('TELEGRAM_API_ID')
+            api_hash = os.environ.get('TELEGRAM_API_HASH')
+            phone_number = os.environ.get('TELEGRAM_PHONE_NUMBER')
+            if not all([api_id, api_hash, phone_number]):
+                raise ValueError("Missing Telegram credentials in environment variables")
+            self.telegram_client = TelegramClient('session', int(api_id), api_hash)
+            # Check if session exists, if not, we need OTP authentication
+            if not os.path.exists('session.session'):
+                web_logger.add_log('INFO', "No existing session found. Starting authentication...")
+                await self.telegram_client.start(phone=phone_number)
+            else:
+                await self.telegram_client.start()
+            web_logger.add_log('INFO', "Connected to Telegram successfully")
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error setting up Telegram client: {e}")
+            raise
+
+    def get_youtube_auth_url(self):
+        """Get YouTube OAuth authorization URL"""
+        try:
+            # Create client secrets file from environment variable
+            client_secrets_path = self.create_file_from_env('YOUTUBE_CLIENT_SECRETS', 'client_secrets.json')
+            # Create OAuth2 flow
+            flow = InstalledAppFlow.from_client_secrets_file(client_secrets_path, self.SCOPES)
+            flow.redirect_uri = 'http://127.0.0.1:8080'
+            # Generate authorization URL
+            auth_url, _ = flow.authorization_url(
+                prompt='consent',
+                access_type='offline',
+                include_granted_scopes='true'
+            )
+            # Store flow in session for later use
+            session['oauth_flow_state'] = flow.state
+            return auth_url
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error generating YouTube auth URL: {e}")
+            raise
+
+    def complete_youtube_auth(self, auth_code):
+        """Complete YouTube OAuth with authorization code"""
+        try:
+            client_secrets_path = self.create_file_from_env('YOUTUBE_CLIENT_SECRETS', 'client_secrets.json')
+            flow = InstalledAppFlow.from_client_secrets_file(client_secrets_path, self.SCOPES)
+            flow.redirect_uri = 'http://127.0.0.1:8080'
+            # Exchange code for credentials
+            flow.fetch_token(code=auth_code)
+            creds = flow.credentials
+            # Save credentials
+            with open('token.json', 'w') as token:
+                token.write(creds.to_json())
+            # Build YouTube service
+            self.youtube_service = build('youtube', 'v3', credentials=creds)
+            web_logger.add_log('INFO', "YouTube authentication completed successfully")
+            return True
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error completing YouTube authentication: {e}")
+            return False
+
+    def setup_youtube_client(self):
+        """Initialize YouTube API client"""
+        try:
+            creds = None
+            token_file = 'token.json'
+            # Load existing credentials
+            if os.path.exists(token_file):
+                creds = Credentials.from_authorized_user_file(token_file, self.SCOPES)
+            # Check if credentials are valid
+            if not creds or not creds.valid:
+                if creds and creds.expired and creds.refresh_token:
+                    try:
+                        creds.refresh(Request())
+                        web_logger.add_log('INFO', "Refreshed existing YouTube credentials")
+                    except Exception as e:
+                        web_logger.add_log('ERROR', f"Failed to refresh credentials: {e}")
+                        return False
+                else:
+                    web_logger.add_log('WARNING', "No valid YouTube credentials found. Please authenticate.")
+                    return False
+            self.youtube_service = build('youtube', 'v3', credentials=creds)
+            web_logger.add_log('INFO', "YouTube API client initialized successfully")
+            return True
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error setting up YouTube client: {e}")
+            return False
+
+    def is_video_processed(self, channel_username, message_id):
+        """Check if video is already processed using Firebase"""
+        try:
+            doc_id = f"{channel_username}_{message_id}"
+            doc_ref = self.firestore_db.collection(self.collection_name).document(doc_id)
+            doc = doc_ref.get()
+            return doc.exists
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error checking processed video: {e}")
+            return False
+
+    def mark_video_processed(self, channel_username, message_id, youtube_id=None, telegram_url=None):
+        """Mark video as processed in Firebase"""
+        try:
+            doc_id = f"{channel_username}_{message_id}"
+            doc_data = {
+                'channel_username': channel_username,
+                'telegram_message_id': message_id,
+                'telegram_url': telegram_url or f"https://t.me/{channel_username.replace('@', '')}/{message_id}",
+                'youtube_video_id': youtube_id,
+                'processed_at': firestore.SERVER_TIMESTAMP,
+                'status': 'completed' if youtube_id else 'failed'
+            }
+            doc_ref = self.firestore_db.collection(self.collection_name).document(doc_id)
+            doc_ref.set(doc_data)
+            web_logger.add_log('INFO', f"Marked video {message_id} as processed in Firebase")
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error marking video as processed: {e}")
+
+    def get_processed_videos_count(self):
+        """Get count of processed videos from Firebase"""
+        try:
+            collection_ref = self.firestore_db.collection(self.collection_name)
+            docs = collection_ref.where('status', '==', 'completed').stream()
+            count = sum(1 for _ in docs)
+            return count
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error getting processed videos count: {e}")
+            return 0
+
+    async def get_channel_videos(self, limit=10, offset=0):
+        """Get videos from Telegram channel with offset support"""
+        # Use user config or fall back to env var
+        channel_username = self.user_config.get('TELEGRAM_CHANNEL_USERNAME') or os.environ.get('TELEGRAM_CHANNEL_USERNAME')
+        if not channel_username:
+             web_logger.add_log('ERROR', "TELEGRAM_CHANNEL_USERNAME is not set in user config or environment variables.")
+             # Return empty result or raise an error
+             return {
+                'videos': [],
+                'processed_count': 0,
+                'total_checked': 0,
+                'last_message_id': None
+            }
+        try:
+            entity = await self.telegram_client.get_entity(channel_username)
+            videos = []
+            processed_count = 0
+            total_checked = 0
+            last_message_id = None
+            async for message in self.telegram_client.iter_messages(entity, limit=limit, offset_id=offset):
+                total_checked += 1
+                last_message_id = message.id
+                # Check if message has video
+                if message.video and message.video.mime_type.startswith('video/'):
+                    telegram_url = f"https://t.me/{channel_username.replace('@', '')}/{message.id}"
+                    if self.is_video_processed(channel_username, message.id):
+                        processed_count += 1
+                        web_logger.add_log('INFO', f"Skipping already processed video: {message.id}")
+                        continue
+                    else:
+                        videos.append({
+                            'id': message.id,
+                            'message': message,
+                            'video': message.video,
+                            'caption': message.text or '',
+                            'date': message.date,
+                            'telegram_url': telegram_url,
+                            'channel_username': channel_username
+                        })
+            web_logger.add_log('INFO', f"Found {len(videos)} new videos, {processed_count} already processed")
+            return {
+                'videos': videos,
+                'processed_count': processed_count,
+                'total_checked': total_checked,
+                'last_message_id': last_message_id
+            }
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error getting channel videos: {e}")
+            return {
+                'videos': [],
+                'processed_count': 0,
+                'total_checked': 0,
+                'last_message_id': None
+            }
+
+    async def download_video(self, video_info):
+        """Download video from Telegram"""
+        try:
+            message = video_info['message']
+            video_id = video_info['id']
+            filename = f"video_{video_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+            filepath = self.download_dir / filename
+            web_logger.add_log('INFO', f"Downloading video {video_id}...")
+            await message.download_media(file=str(filepath))
+            web_logger.add_log('INFO', f"Downloaded: {filepath}")
+            return str(filepath)
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error downloading video {video_info['id']}: {e}")
+            return None
+
+    def upload_to_youtube(self, video_path, video_info):
+        """Upload video to YouTube"""
+        try:
+            # Use user config or fall back to env vars
+            title_prefix = self.user_config.get('YOUTUBE_TITLE_PREFIX', os.environ.get('YOUTUBE_TITLE_PREFIX', ''))
+            description_template = self.user_config.get('YOUTUBE_DESCRIPTION_TEMPLATE', os.environ.get('YOUTUBE_DESCRIPTION_TEMPLATE', 'Video from Telegram channel'))
+            tags_str = self.user_config.get('YOUTUBE_TAGS', os.environ.get('YOUTUBE_TAGS', 'telegram,video'))
+            category_id = self.user_config.get('YOUTUBE_CATEGORY_ID', os.environ.get('YOUTUBE_CATEGORY_ID', '22'))
+            privacy_status = self.user_config.get('YOUTUBE_PRIVACY_STATUS', os.environ.get('YOUTUBE_PRIVACY_STATUS', 'private'))
+
+            # Process tags
+            tags = [tag.strip() for tag in tags_str.split(',') if tag.strip()]
 
-# --- Login Protection Decorator ---
+            # Prepare video metadata
+            title = f"{title_prefix}{video_info['caption'][:100]}"
+            if not title.strip():
+                title = f"Video from Telegram - {video_info['date'].strftime('%Y-%m-%d')}"
+            description = f"{description_template}\n"
+            description += f"Original Telegram post: {video_info['telegram_url']}\n"
+            description += f"Caption: {video_info['caption']}"
+            body = {
+                'snippet': {
+                    'title': title,
+                    'description': description,
+                    'tags': tags,
+                    'categoryId': category_id
+                },
+                'status': {
+                    'privacyStatus': privacy_status
+                }
+            }
+            # Upload video
+            media = MediaFileUpload(video_path, chunksize=-1, resumable=True)
+            request = self.youtube_service.videos().insert(
+                part=','.join(body.keys()),
+                body=body,
+                media_body=media
+            )
+            web_logger.add_log('INFO', f"Uploading {os.path.basename(video_path)} to YouTube...")
+            response = None
+            error = None
+            retry = 0
+            while response is None:
+                try:
+                    status, response = request.next_chunk()
+                    if status:
+                        progress = int(status.progress() * 100)
+                        web_logger.add_log('INFO', f"Upload progress: {progress}%")
+                except HttpError as e:
+                    if e.resp.status in [500, 502, 503, 504]:
+                        error = f"A retriable HTTP error {e.resp.status} occurred"
+                        retry += 1
+                        if retry > 3:
+                            break
+                    else:
+                        raise
+            if response is not None:
+                video_id = response['id']
+                web_logger.add_log('INFO', f"Video uploaded successfully! YouTube ID: {video_id}")
+                return video_id
+            else:
+                web_logger.add_log('ERROR', f"Upload failed: {error}")
+                return None
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error uploading to YouTube: {e}")
+            return None
+
+    def cleanup_video(self, video_path):
+        """Delete downloaded video file"""
+        try:
+            os.remove(video_path)
+            web_logger.add_log('INFO', f"Cleaned up: {video_path}")
+        except Exception as e:
+            web_logger.add_log('ERROR', f"Error cleaning up {video_path}: {e}")
+
+# Authentication decorator
 def login_required(f):
     @wraps(f)
     def decorated_function(*args, **kwargs):
-        if 'logged_in' not in session:
+        if 'user_authenticated' not in session:
             return redirect(url_for('login'))
         return f(*args, **kwargs)
     return decorated_function
 
-# --- Web Routes ---
+# Routes
+@app.route('/')
+def index():
+    if 'user_authenticated' not in session:
+        return redirect(url_for('login'))
+    return redirect(url_for('dashboard'))
 
 @app.route('/login', methods=['GET', 'POST'])
 def login():
     if request.method == 'POST':
+        username = request.form['username']
+        password = request.form['password']
+        # Check credentials from environment variables
         app_username = os.environ.get('APP_USERNAME')
         app_password = os.environ.get('APP_PASSWORD')
-        if not app_username or not app_password:
-            flash('Application credentials are not configured on the server.', 'danger')
-            return render_template('login.html')
-        if request.form['username'] == app_username and request.form['password'] == app_password:
-            session['logged_in'] = True
-            return redirect(url_for('index'))
+        if username == app_username and password == app_password:
+            session['user_authenticated'] = True
+            flash('Login successful!', 'success')
+            return redirect(url_for('dashboard'))
         else:
-            flash('Invalid username or password.', 'danger')
+            flash('Invalid username or password!', 'error')
     return render_template('login.html')
 
-@app.route('/')
+@app.route('/logout')
+def logout():
+    session.clear()
+    flash('Logged out successfully!', 'success')
+    return redirect(url_for('login'))
+
+# --- Modify the dashboard route to pass user config ---
+@app.route('/dashboard')
 @login_required
-def index():
-    # Re-check configuration on every visit to the index
-    workflow.config = setup_configuration()
-    if not workflow.config['telegram']['session_string']:
-        return redirect(url_for('telegram_auth'))
-    if not os.path.exists('token.json'):
-        return redirect(url_for('youtube_auth'))
-    return render_template('index.html')
+def dashboard():
+    global workflow_instance
+    if not workflow_instance:
+        workflow_instance = TelegramYouTubeWorkflow()
 
-@app.route('/telegram-auth', methods=['GET', 'POST'])
+    status = processing_status.copy()
+
+    # Get processed videos count
+    try:
+        status['total_processed'] = workflow_instance.get_processed_videos_count()
+    except:
+        status['total_processed'] = 0
+
+    # Load current user config to display in the form
+    current_config = load_user_config()
+
+    return render_template('dashboard.html', status=status, config=current_config)
+
+# --- Add the new route to save configuration ---
+@app.route('/save_config', methods=['POST'])
 @login_required
-def telegram_auth():
-    stage = session.get('telegram_auth_stage', 'credentials')
+def save_config():
+    try:
+        # Get form data
+        config_data = {
+            'TELEGRAM_CHANNEL_USERNAME': request.form.get('telegram_channel_username', '').strip(),
+            'YOUTUBE_TITLE_PREFIX': request.form.get('youtube_title_prefix', '').strip(),
+            'YOUTUBE_DESCRIPTION_TEMPLATE': request.form.get('youtube_description_template', '').strip(),
+            'YOUTUBE_TAGS': request.form.get('youtube_tags', '').strip(), # Will be processed on load/save
+            'YOUTUBE_CATEGORY_ID': request.form.get('youtube_category_id', '22').strip(),
+            'YOUTUBE_PRIVACY_STATUS': request.form.get('youtube_privacy_status', 'private').strip().lower(),
+        }
 
-    if request.method == 'POST':
-        api_id = session.get('api_id') or request.form.get('api_id')
-        api_hash = session.get('api_hash') or request.form.get('api_hash')
+        # Basic validation (optional but good)
+        if config_data['TELEGRAM_CHANNEL_USERNAME'] and not config_data['TELEGRAM_CHANNEL_USERNAME'].startswith('@'):
+            return jsonify({'success': False, 'message': 'Telegram channel username must start with @'}), 400
 
-        if not api_id or not api_hash:
-            flash("API ID and Hash are required.", "danger")
-            return render_template('telegram_auth.html', stage='credentials')
+        if config_data['YOUTUBE_PRIVACY_STATUS'] not in ['public', 'private', 'unlisted']:
+             return jsonify({'success': False, 'message': 'Invalid YouTube privacy status. Use public, private, or unlisted.'}), 400
 
-        session['api_id'] = api_id
-        session['api_hash'] = api_hash
-        client = TelegramClient(StringSession(), int(api_id), api_hash)
-        loop = asyncio.get_event_loop()
+        if not config_data['YOUTUBE_CATEGORY_ID'].isdigit():
+             return jsonify({'success': False, 'message': 'YouTube category ID must be a number.'}), 400
 
-        try:
-            async def do_login():
-                await client.connect()
-                if stage == 'credentials':
-                    phone = request.form['phone']
-                    session['phone'] = phone
-                    result = await client.send_code_request(phone)
-                    session['phone_code_hash'] = result.phone_code_hash
-                    session['telegram_auth_stage'] = 'otp'
-                    flash("An OTP code has been sent to your Telegram account.", "info")
-                elif stage == 'otp':
-                    phone = session['phone']
-                    phone_code_hash = session['phone_code_hash']
-                    otp = request.form['otp']
-                    try:
-                        await client.sign_in(phone, otp, phone_code_hash=phone_code_hash)
-                        final_session_string = client.session.save()
-                        save_telegram_session_to_db(final_session_string)
-                        session.pop('telegram_auth_stage', None)
-                        flash("Telegram authentication successful!", "success")
-                    except SessionPasswordNeededError:
-                        session['telegram_auth_stage'] = 'password'
-                elif stage == 'password':
-                    password = request.form['password']
-                    await client.sign_in(password=password)
-                    final_session_string = client.session.save()
-                    save_telegram_session_to_db(final_session_string)
-                    session.pop('telegram_auth_stage', None)
-                    flash("Telegram authentication successful!", "success")
-
-            loop.run_until_complete(do_login())
-        except (ApiIdInvalidError, ApiIdPublishedFloodError):
-            flash("The API ID/Hash is invalid or blocked. Please check your credentials.", "danger")
-            session.pop('telegram_auth_stage', None)
-        except PhoneCodeInvalidError:
-            flash("Invalid OTP code. Please try again.", "danger")
-            session['telegram_auth_stage'] = 'otp' # Stay on OTP stage
-        except Exception as e:
-            flash(f"An error occurred: {str(e)}", "danger")
-            session.pop('telegram_auth_stage', None)
-        finally:
-            if client.is_connected():
-                loop.run_until_complete(client.disconnect())
-        return redirect(url_for('index'))
-
-    is_configured = bool(load_telegram_session_from_db())
-    if is_configured:
-        return redirect(url_for('index'))
-    return render_template('telegram_auth.html', stage=session.get('telegram_auth_stage', 'credentials'))
-
-@app.route('/youtube-auth')
+        save_user_config(config_data)
+        # Optionally, update the workflow instance's config if it exists
+        global workflow_instance
+        if workflow_instance:
+            workflow_instance.user_config = config_data
+        return jsonify({'success': True, 'message': 'Configuration saved successfully!'})
+    except Exception as e:
+        web_logger.add_log('ERROR', f"Error saving config: {e}")
+        return jsonify({'success': False, 'message': f'Error saving configuration: {str(e)}'}), 500
+
+@app.route('/youtube_auth')
 @login_required
 def youtube_auth():
-    return render_template('auth.html')
+    global workflow_instance
+    if not workflow_instance:
+        workflow_instance = TelegramYouTubeWorkflow()
+    # Check if already authenticated
+    if workflow_instance.setup_youtube_client():
+        flash('YouTube is already authenticated!', 'success')
+        return redirect(url_for('dashboard'))
+    try:
+        auth_url = workflow_instance.get_youtube_auth_url()
+        return render_template('youtube_auth.html', auth_url=auth_url)
+    except Exception as e:
+        flash(f'Error generating auth URL: {str(e)}', 'error')
+        return redirect(url_for('dashboard'))
 
-@app.route('/authorize')
+@app.route('/youtube_callback', methods=['POST'])
 @login_required
-def authorize():
-    if not os.path.exists('client_secrets.json'):
-        return "Error: YouTube client secrets are not configured on the server.", 500
-    flow = Flow.from_client_secrets_file(
-        'client_secrets.json', scopes=workflow.SCOPES, redirect_uri=url_for('oauth2callback', _external=True)
-    )
-    authorization_url, state = flow.authorization_url(access_type='offline', include_granted_scopes='true', prompt='consent')
-    session['state'] = state
-    return redirect(authorization_url)
-
-@app.route('/oauth2callback')
+def youtube_callback():
+    global workflow_instance
+    auth_code = request.form.get('auth_code')
+    if not auth_code:
+        flash('Authorization code is required!', 'error')
+        return redirect(url_for('youtube_auth'))
+    if workflow_instance.complete_youtube_auth(auth_code):
+        flash('YouTube authentication successful!', 'success')
+    else:
+        flash('YouTube authentication failed!', 'error')
+    return redirect(url_for('dashboard'))
+
+@app.route('/telegram_auth')
 @login_required
-def oauth2callback():
-    state = session.get('state')
-    if not state: return "Authentication error: session state is missing.", 400
-    flow = Flow.from_client_secrets_file(
-        'client_secrets.json', scopes=workflow.SCOPES, state=state, redirect_uri=url_for('oauth2callback', _external=True)
-    )
-    flow.fetch_token(authorization_response=request.url)
-    with open('token.json', 'w') as token_file:
-        token_file.write(flow.credentials.to_json())
-    logger.info("Successfully received and stored YouTube API token.")
-    return redirect(url_for('index'))
-
-@app.route('/start-workflow', methods=['POST'])
+def telegram_auth():
+    return render_template('telegram_auth.html')
+
+# --- Add routes for Telegram auth via web ---
+# Global variables for Telegram auth
+temp_telegram_client = None
+temp_phone_number = None # Store phone number for sign_in
+
+@app.route('/initiate_telegram_auth', methods=['POST'])
 @login_required
-def start_workflow():
-    if not os.path.exists('token.json'):
-        return jsonify({"error": "Not authenticated with YouTube. Please re-authorize."}), 401
+def initiate_telegram_auth():
+    """Initiates the Telegram authentication flow, potentially requesting OTP"""
+    global workflow_instance, temp_telegram_client, temp_phone_number
+    if not workflow_instance:
+        workflow_instance = TelegramYouTubeWorkflow()
+
+    try:
+        # Create a temporary client instance for auth
+        api_id = os.environ.get('TELEGRAM_API_ID')
+        api_hash = os.environ.get('TELEGRAM_API_HASH')
+        phone_number = os.environ.get('TELEGRAM_PHONE_NUMBER')
+
+        if not all([api_id, api_hash, phone_number]):
+            flash('Missing Telegram credentials in environment variables', 'error')
+            return redirect(url_for('telegram_auth'))
+
+        temp_phone_number = phone_number # Store for later use in callback
+        temp_telegram_client = TelegramClient('session', int(api_id), api_hash)
+
+        # Run the connection attempt asynchronously
+        asyncio.run(_attempt_telegram_connection(temp_telegram_client, phone_number))
+
+        # If we reach here without exception, auth might be complete or code needed
+        # Check if OTP is needed by seeing if the session file was created or flag is set
+        if os.path.exists('session.session'):
+             # Session file exists, likely authenticated
+             flash('Telegram connected successfully!', 'success')
+             # Clean up temp client
+             temp_telegram_client = None
+             temp_phone_number = None
+             session.pop('telegram_needs_code', None) # Ensure flag is cleared
+             return redirect(url_for('dashboard'))
+        else:
+             # If session file doesn't exist, OTP is likely needed
+             # The _attempt_telegram_connection should have set the flag if code is sent
+             # Redirect to the auth page which will show the OTP form
+             return redirect(url_for('telegram_auth'))
+
+    except Exception as e:
+        # Clean up on error
+        temp_telegram_client = None
+        temp_phone_number = None
+        session.pop('telegram_needs_code', None)
+        flash(f'Error initiating Telegram connection: {str(e)}', 'error')
+        web_logger.add_log('ERROR', f"Error initiating Telegram connection: {e}")
+        return redirect(url_for('telegram_auth'))
+
+async def _attempt_telegram_connection(client, phone_number):
+    """Helper to attempt connection and signal if OTP is needed"""
+    try:
+        await client.connect()
+        if not await client.is_user_authorized():
+            # Send code request
+            await client.send_code_request(phone_number)
+            # Signal that OTP is needed
+            session['telegram_needs_code'] = True
+            web_logger.add_log('INFO', "Telegram code sent. Waiting for OTP input via web.")
+        # If already authorized, session file exists, connection is good
+    except errors.SessionPasswordNeededError:
+        # This means 2FA is enabled. The initial code request likely succeeded.
+        # We primarily rely on the 'code' callback for the initial OTP.
+        # Signal that OTP is needed (or handle password separately if needed).
+        session['telegram_needs_code'] = True
+        web_logger.add_log('INFO', "Telegram 2FA detected or code needed. Waiting for OTP input via web.")
+    except Exception as e:
+        web_logger.add_log('ERROR', f"Error during Telegram connection attempt: {e}")
+        raise e # Re-raise to be caught by initiate_telegram_auth
+
+@app.route('/telegram_callback', methods=['POST'])
+@login_required
+def telegram_callback():
+    """Handles the submission of the OTP code"""
+    global temp_telegram_client, temp_phone_number
+    otp_code = request.form.get('otp_code')
+
+    if not otp_code:
+        flash('OTP code is required!', 'error')
+        session['telegram_needs_code'] = True # Ensure OTP form is shown
+        return redirect(url_for('telegram_auth'))
+
+    if not temp_telegram_client or not temp_phone_number:
+        flash('Telegram authentication session expired. Please restart the process.', 'error')
+        session.pop('telegram_needs_code', None)
+        return redirect(url_for('telegram_auth'))
+
+    try:
+        # Sign in with the provided code using the temporary client
+        asyncio.run(temp_telegram_client.sign_in(temp_phone_number, otp_code))
+        web_logger.add_log('INFO', "Telegram sign-in successful with provided OTP.")
+        flash('Telegram authentication successful!', 'success')
+
+        # Clean up
+        temp_telegram_client = None
+        temp_phone_number = None
+        session.pop('telegram_needs_code', None)
+
+        return redirect(url_for('dashboard'))
+
+    except errors.SessionPasswordNeededError:
+        # OTP was correct, but 2FA password is needed
+        # This requires a more complex flow. For now, we'll simplify.
+        # A better implementation would prompt for the 2FA password on the web page.
+        # For this version, we'll assume OTP handles initial auth for simplicity,
+        # or inform the user that 2FA might require a restart if the session isn't fully established.
+        # Let's assume the sign_in with code was enough for basic auth if no error is raised after.
+        # If sign_in succeeds, the session should be valid.
+        # However, SessionPasswordNeededError implies sign_in didn't complete fully.
+        # A robust solution would involve another input step for the password.
+        # For now, let's clear the OTP flag and redirect, assuming the code was enough or user needs to retry.
+        flash('Sign-in might require a 2FA password. If connection fails, please retry Telegram auth.', 'warning')
+        web_logger.add_log('WARNING', "Telegram 2FA password potentially needed after OTP (OTP submitted). Check if connection is successful on dashboard.")
+        # Clean up
+        temp_telegram_client = None
+        temp_phone_number = None
+        session.pop('telegram_needs_code', None)
+        # Redirect to dashboard to let the user check status or retry
+        return redirect(url_for('dashboard'))
+    except Exception as e:
+        # Clean up on error
+        temp_telegram_client = None
+        temp_phone_number = None
+        session.pop('telegram_needs_code', None)
+        flash(f'Telegram authentication failed: {str(e)}', 'error')
+        web_logger.add_log('ERROR', f"Error signing in to Telegram with OTP: {e}")
+        return redirect(url_for('telegram_auth'))
+
+@app.route('/start_processing', methods=['POST'])
+@login_required
+def start_processing():
+    global processing_status, workflow_instance
+    if processing_status['is_running']:
+        return jsonify({'success': False, 'message': 'Processing is already running'})
     limit = int(request.form.get('limit', 5))
-    offset = int(request.form.get('offset', 0))
-    workflow.build_youtube_service()
-    if not workflow.config['telegram']['session_string']:
-        return jsonify({"error": "Telegram session is not configured. Please re-authenticate."}), 401
-    loop = asyncio.get_event_loop()
-    result = loop.run_until_complete(workflow.process_single_batch(limit=limit, offset_id=offset))
-    return jsonify(result)
+    # Start processing in background thread
+    def run_processing():
+        asyncio.run(process_videos_background(limit))
+    thread = threading.Thread(target=run_processing)
+    thread.daemon = True
+    thread.start()
+    return jsonify({'success': True, 'message': 'Processing started'})
 
-@app.route('/logout')
-def logout():
-    session.clear()
-    if os.path.exists('token.json'):
-        os.remove('token.json')
-    flash('You have been successfully logged out.')
-    return redirect(url_for('login'))
+@app.route('/batch_confirmation', methods=['POST'])
+@login_required
+def batch_confirmation():
+    global processing_status
+    action = request.form.get('action')  # 'continue' or 'stop'
+    if not processing_status['waiting_for_confirmation']:
+        return jsonify({'success': False, 'message': 'No confirmation pending'})
+    processing_status['user_decision'] = action
+    processing_status['waiting_for_confirmation'] = False
+    return jsonify({'success': True, 'message': f'Decision recorded: {action}'})
+
+@app.route('/status')
+@login_required
+def get_status():
+    global processing_status
+    status = processing_status.copy()
+    status['logs'] = web_logger.get_logs()[-20:]  # Last 20 logs
+    return jsonify(status)
+
+@app.route('/clear_logs', methods=['POST'])
+@login_required
+def clear_logs():
+    web_logger.clear_logs()
+    return jsonify({'success': True})
+
+async def process_videos_background(limit=5):
+    """Background processing function"""
+    global processing_status, workflow_instance
+    processing_status['is_running'] = True
+    processing_status['current_batch'] = 0
+    processing_status['processed_count'] = 0
+    processing_status['failed_count'] = 0
+    try:
+        # Setup clients
+        await workflow_instance.setup_telegram_client()
+        if not workflow_instance.setup_youtube_client():
+            web_logger.add_log('ERROR', 'YouTube not authenticated. Please authenticate first.')
+            return
+        batch_number = 1
+        offset = 0
+        while processing_status['is_running']:
+            processing_status['current_batch'] = batch_number
+            web_logger.add_log('INFO', f"Processing batch {batch_number} (limit: {limit})...")
+            # Get videos from Telegram
+            result = await workflow_instance.get_channel_videos(limit, offset)
+            videos = result['videos']
+            videos_already_processed = result['processed_count']
+            total_checked = result['total_checked']
+            last_message_id = result['last_message_id']
+            if not videos and videos_already_processed == 0:
+                web_logger.add_log('INFO', "No more videos found in the channel")
+                break
+            # Check if all videos were already processed
+            if not videos and videos_already_processed > 0:
+                # Ask user for confirmation
+                processing_status['waiting_for_confirmation'] = True
+                processing_status['confirmation_message'] = f"All {videos_already_processed} videos in batch {batch_number} have been processed previously. Continue to next batch?"
+                processing_status['user_decision'] = None
+                # Wait for user decision
+                while processing_status['waiting_for_confirmation'] and processing_status['is_running']:
+                    await asyncio.sleep(1)
+                if processing_status.get('user_decision') != 'continue':
+                    web_logger.add_log('INFO', "User chose not to continue. Stopping workflow.")
+                    break
+                batch_number += 1
+                offset = last_message_id
+                continue
+            # Process videos in current batch
+            if videos:
+                for video_info in videos:
+                    if not processing_status['is_running']:
+                        break
+                    try:
+                        web_logger.add_log('INFO', f"Processing video {video_info['id']}...")
+                        # Download video
+                        video_path = await workflow_instance.download_video(video_info)
+                        if not video_path:
+                            processing_status['failed_count'] += 1
+                            continue
+                        # Upload to YouTube
+                        youtube_id = workflow_instance.upload_to_youtube(video_path, video_info)
+                        if youtube_id:
+                            workflow_instance.mark_video_processed(
+                                video_info['channel_username'],
+                                video_info['id'],
+                                youtube_id,
+                                video_info['telegram_url']
+                            )
+                            processing_status['processed_count'] += 1
+                            web_logger.add_log('INFO', f"Successfully processed video {video_info['id']} -> {youtube_id}")
+                        else:
+                            workflow_instance.mark_video_processed(
+                                video_info['channel_username'],
+                                video_info['id'],
+                                None,
+                                video_info['telegram_url']
+                            )
+                            processing_status['failed_count'] += 1
+                        # Cleanup
+                        workflow_instance.cleanup_video(video_path)
+                        # Small delay
+                        await asyncio.sleep(2)
+                    except Exception as e:
+                        web_logger.add_log('ERROR', f"Error processing video {video_info['id']}: {e}")
+                        processing_status['failed_count'] += 1
+                        continue
+            # Check if we should continue to next batch
+            if total_checked < limit:
+                web_logger.add_log('INFO', "Reached end of channel messages")
+                break
+            # Ask user for next batch confirmation
+            processing_status['waiting_for_confirmation'] = True
+            processing_status['confirmation_message'] = f"Batch {batch_number} completed. Process next {limit} videos?"
+            processing_status['user_decision'] = None
+            # Wait for user decision
+            while processing_status['waiting_for_confirmation'] and processing_status['is_running']:
+                await asyncio.sleep(1)
+            if processing_status.get('user_decision') != 'continue':
+                web_logger.add_log('INFO', "User chose not to continue. Stopping workflow.")
+                break
+            batch_number += 1
+            offset = last_message_id
+        web_logger.add_log('INFO', f"Workflow completed! Processed: {processing_status['processed_count']}, Failed: {processing_status['failed_count']}")
+    except Exception as e:
+        web_logger.add_log('ERROR', f"Workflow error: {e}")
+    finally:
+        processing_status['is_running'] = False
+        processing_status['waiting_for_confirmation'] = False
+        if workflow_instance.telegram_client:
+            await workflow_instance.telegram_client.disconnect()
+
+@app.route('/stop_processing', methods=['POST'])
+@login_required
+def stop_processing():
+    global processing_status
+    processing_status['is_running'] = False
+    processing_status['waiting_for_confirmation'] = False
+    web_logger.add_log('INFO', "Processing stopped by user")
+    return jsonify({'success': True, 'message': 'Processing stopped'})
 
 if __name__ == '__main__':
-    port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port, debug=True)
+    port = int(os.environ.get('PORT', 5000))
+    app.run(host='0.0.0.0', port=port, debug=False)