Update app.py

app.py

@@ -1,565 +1,238 @@
-import time
 import os
-import asyncio
 import json
-import logging
-from datetime import datetime
-from pathlib import Path
-import tempfile
-import threading
-import uuid
-from io import StringIO
-
-# --- Flask and Jinja Imports ---
-from flask import Flask, render_template, request, redirect, url_for, flash
-from jinja2 import BaseLoader, TemplateNotFound
-
-# --- Core Workflow Imports (Embedded) ---
-from telethon import TelegramClient
-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, db
-
-# --- Custom Exception for Auth Flow ---
-class GoogleAuthError(Exception):
-    pass
-
-# --- Custom Jinja Loader for Embedded Templates ---
-class StringLoader(BaseLoader):
-    """A Jinja loader that loads templates from a dictionary."""
-    def __init__(self, templates):
-        self.templates = templates
+import asyncio
+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
 
-    def get_source(self, environment, template):
-        if template in self.templates:
-            source = self.templates[template]
-            return source, None, lambda: True
-        raise TemplateNotFound(template)
+from telegram_youtube_workflow import TelegramYouTubeWorkflow, logger
 
-# --- Flask App Setup ---
+# Initialize Flask App
 app = Flask(__name__)
-app.secret_key = 'your_strong_secret_key_change_this_for_production'
-
-# --- In-Memory Storage for Logs & Status ---
-global_logs = {}
-processing_status = {}
-
-# --- Custom Logging Handler for Web Capture ---
-class InMemoryHandler(logging.Handler):
-    """Custom logging handler to capture logs in memory for a specific run."""
-    def __init__(self, run_id):
-        super().__init__()
-        self.run_id = run_id
-
-    def emit(self, record):
-        log_entry = self.format(record)
-        if self.run_id not in global_logs:
-            global_logs[self.run_id] = []
-        global_logs[self.run_id].append(log_entry)
-
-# --- Embedded Core Workflow Code ---
-workflow_logger = logging.getLogger('workflow_logger')
-workflow_logger.setLevel(logging.INFO)
-if not workflow_logger.handlers:
-    workflow_logger.addHandler(logging.StreamHandler())
-
-class TelegramYouTubeWorkflow:
-    def __init__(self, config_dict, logger_instance=None):
-        self.config = config_dict
-        self.logger = logger_instance if logger_instance else workflow_logger
-        self.telegram_client = None
-        self.youtube_service = None
-        self.firebase_db = None
-        self.download_dir = Path(self.config.get('download_directory', 'downloads'))
-        self.download_dir.mkdir(exist_ok=True)
-        self.SCOPES = ['https://www.googleapis.com/auth/youtube.upload']
-
-    def setup_firebase(self, service_account_content, database_url):
-        try:
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
-                tmp.write(service_account_content)
-                tmp_path = tmp.name
-            try:
-                if not firebase_admin._apps:
-                    cred = credentials.Certificate(tmp_path)
-                    firebase_admin.initialize_app(cred, {'databaseURL': database_url})
-                self.firebase_db = db
-                self.logger.info("Connected to Firebase successfully")
-            finally:
-                os.unlink(tmp_path)
-        except Exception as e:
-            self.logger.error(f"Failed to connect to Firebase: {e}")
-            raise
-
-    async def setup_telegram_client(self):
-        # ... (rest of the class methods are unchanged)
-        telegram_config = self.config['telegram']
-        self.telegram_client = TelegramClient(
-            'session',
-            telegram_config['api_id'],
-            telegram_config['api_hash']
-        )
-        await self.telegram_client.start(phone=telegram_config['phone_number'])
-        self.logger.info("Connected to Telegram successfully")
-
-    def setup_youtube_client(self, client_secrets_content, token_path, auth_code=None):
-        """Initialize YouTube API client using console flow for headless environments."""
-        creds = None
-        if os.path.exists(token_path) and os.path.getsize(token_path) > 0:
-            creds = Credentials.from_authorized_user_file(token_path, self.SCOPES)
-
-        if not creds or not creds.valid:
-            if creds and creds.expired and creds.refresh_token:
-                self.logger.info("Refreshing expired YouTube token...")
-                creds.refresh(Request())
-            else:
-                self.logger.info("No valid YouTube token found. Attempting console auth flow.")
-                with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
-                    tmp.write(client_secrets_content)
-                    secrets_path = tmp.name
-                
-                try:
-                    # Use the out-of-band (oob) redirect URI for the copy-paste flow
-                    flow = InstalledAppFlow.from_client_secrets_file(
-                        secrets_path, self.SCOPES, redirect_uri='urn:ietf:wg:oauth:2.0:oob'
-                    )
-                    
-                    if not auth_code:
-                        # If no code is provided, generate URL and stop
-                        auth_url, _ = flow.authorization_url(prompt='consent')
-                        self.logger.error("="*80)
-                        self.logger.error("USER ACTION REQUIRED FOR AUTHENTICATION:")
-                        self.logger.error(f"\n1. Open this URL in your browser:\n\n{auth_url}\n")
-                        self.logger.error("2. Authenticate and grant permissions.")
-                        self.logger.error("3. Copy the authorization code Google provides.")
-                        self.logger.error("4. Paste the code into the 'Google Auth Code' field on the main page and resubmit.")
-                        self.logger.error("="*80)
-                        time.sleep(30)
-                    else:
-                        # If code is provided, fetch the token
-                        self.logger.info("Authorization code provided. Fetching token...")
-                        flow.fetch_token(code=auth_code)
-                        creds = flow.credentials
-                finally:
-                    os.unlink(secrets_path)
-            
-            # Save the new credentials
-            with open(token_path, 'w') as token:
-                token.write(creds.to_json())
-            self.logger.info("YouTube token saved successfully.")
-
-        self.youtube_service = build('youtube', 'v3', credentials=creds)
-        self.logger.info("YouTube API client initialized successfully")
-
-    def is_video_processed(self, telegram_video_id, channel_username):
-        try:
-            ref = self.firebase_db.reference(f'processed_videos/{channel_username}/{telegram_video_id}')
-            return ref.get() is not None
-        except Exception as e:
-            self.logger.error(f"Error checking processed video: {e}")
-            return False
-
-    def save_processed_video(self, telegram_video_id, channel_username, youtube_video_id=None, video_info=None):
-        try:
-            telegram_url = f"https://t.me/{channel_username.lstrip('@')}/{telegram_video_id}"
-            document = {
-                "telegram_video_id": telegram_video_id,
-                "channel_username": channel_username,
-                "telegram_url": telegram_url,
-                "youtube_video_id": youtube_video_id,
-                "processed_at": datetime.utcnow().isoformat(),
-                "status": "uploaded" if youtube_video_id else "failed"
-            }
-            if video_info:
-                document.update({
-                    "video_title": video_info.get('caption', '')[:100],
-                    "video_date": video_info.get('date').isoformat(),
-                    "video_size": getattr(video_info.get('video'), 'size', None),
-                    "video_duration": getattr(video_info.get('video'), 'duration', None)
-                })
-            ref = self.firebase_db.reference(f'processed_videos/{channel_username}/{telegram_video_id}')
-            ref.set(document)
-            self.logger.info(f"Saved processed video info to Firebase: {telegram_url}")
-        except Exception as e:
-            self.logger.error(f"Error saving processed video info: {e}")
-
-    def get_processed_videos_stats(self):
-        try:
-            ref = self.firebase_db.reference('processed_videos')
-            all_videos = ref.get()
-            if not all_videos: return {"total": 0, "uploaded": 0, "failed": 0}
-            total = 0
-            uploaded = 0
-            for channel in all_videos.values():
-                for video in channel.values():
-                    total += 1
-                    if video.get("status") == "uploaded":
-                        uploaded += 1
-            failed = total - uploaded
-            self.logger.info(f"DB stats - Total: {total}, Uploaded: {uploaded}, Failed: {failed}")
-            return {"total": total, "uploaded": uploaded, "failed": failed}
-        except Exception as e:
-            self.logger.error(f"Error getting stats: {e}")
-            return None
-
-    async def get_channel_videos(self, limit=10):
-        channel_username = self.config['telegram']['channel_username']
-        try:
-            entity = await self.telegram_client.get_entity(channel_username)
-            videos = []
-            async for message in self.telegram_client.iter_messages(entity, limit=limit):
-                if message.video and not self.is_video_processed(message.id, channel_username):
-                    videos.append({
-                        'id': message.id, 'message': message, 'video': message.video,
-                        'caption': message.text or '', 'date': message.date,
-                        'telegram_url': f"https://t.me/{channel_username.lstrip('@')}/{message.id}"
-                    })
-            self.logger.info(f"Found {len(videos)} new videos to process.")
-            return videos
-        except Exception as e:
-            self.logger.error(f"Error getting channel videos: {e}")
-            return []
-
-    async def download_video(self, video_info):
-        try:
-            filename = f"video_{video_info['id']}.mp4"
-            filepath = self.download_dir / filename
-            self.logger.info(f"Downloading video {video_info['id']}...")
-            await video_info['message'].download_media(file=str(filepath))
-            self.logger.info(f"Downloaded to: {filepath}")
-            return str(filepath)
-        except Exception as e:
-            self.logger.error(f"Error downloading video {video_info['id']}: {e}")
-            return None
-
-    def upload_to_youtube(self, video_path, video_info):
-        try:
-            video_settings = self.config['video_settings']
-            title = f"{video_settings.get('title_prefix', '')}{video_info['caption'][:100]}" or f"Video from Telegram {video_info['date'].strftime('%Y-%m-%d')}"
-            body = {
-                'snippet': {
-                    'title': title,
-                    'description': f"{video_settings.get('description_template', '')}\n\n{video_info['caption']}",
-                    'tags': video_settings.get('tags', []),
-                    'categoryId': video_settings.get('category_id', '22')
-                },
-                'status': {'privacyStatus': video_settings.get('privacy_status', 'private')}
-            }
-            media = MediaFileUpload(video_path, chunksize=-1, resumable=True)
-            request = self.youtube_service.videos().insert(part=','.join(body.keys()), body=body, media_body=media)
-            
-            self.logger.info(f"Uploading {os.path.basename(video_path)} to YouTube...")
-            response = None
-            while response is None:
-                status, response = request.next_chunk()
-                if status:
-                    self.logger.info(f"Upload progress: {int(status.progress() * 100)}%")
-            
-            self.logger.info(f"Video uploaded successfully! YouTube ID: {response['id']}")
-            return response['id']
-        except HttpError as e:
-            self.logger.error(f"HTTP error during upload: {e.content}")
-            return None
-        except Exception as e:
-            self.logger.error(f"Error uploading to YouTube: {e}")
-            return None
-
-    def cleanup_video(self, video_path):
-        try:
-            os.remove(video_path)
-            self.logger.info(f"Cleaned up: {video_path}")
-        except Exception as e:
-            self.logger.error(f"Error cleaning up {video_path}: {e}")
-
-    async def process_videos(self, limit=5):
-        self.logger.info("Starting video processing workflow...")
-        try:
-            await self.setup_telegram_client()
-            self.get_processed_videos_stats()
-            videos = await self.get_channel_videos(limit)
-            if not videos:
-                self.logger.info("No new videos found.")
-                return
-
-            for video_info in videos:
-                video_path = None
-                youtube_id = None
-                try:
-                    self.logger.info(f"Processing video: {video_info['telegram_url']}")
-                    video_path = await self.download_video(video_info)
-                    if video_path:
-                        youtube_id = self.upload_to_youtube(video_path, video_info)
-                except Exception as e:
-                    self.logger.error(f"Unhandled error processing video {video_info['id']}: {e}")
-                finally:
-                    self.save_processed_video(
-                        video_info['id'], self.config['telegram']['channel_username'],
-                        youtube_video_id=youtube_id, video_info=video_info
-                    )
-                    if video_path:
-                        self.cleanup_video(video_path)
-        except Exception as e:
-            self.logger.error(f"Core workflow error: {e}", exc_info=True)
-        finally:
-            if self.telegram_client and self.telegram_client.is_connected():
-                await self.telegram_client.disconnect()
-            self.logger.info("Workflow finished.")
-
-# --- Flask Threading Function ---
+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')
+        }
+    }
 
-def run_workflow_in_thread(run_id, config_data, client_secrets_content, service_account_content, num_videos, token_path, auth_code):
-    log_handler = InMemoryHandler(run_id)
-    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-    log_handler.setFormatter(formatter)
-    workflow_logger.addHandler(log_handler)
+workflow = TelegramYouTubeWorkflow(setup_configuration())
 
+def save_telegram_session_to_db(session_string):
+    """Saves the Telethon session string to Firestore."""
     try:
-        processing_status[run_id] = "Running..."
-        with tempfile.TemporaryDirectory() as temp_dir:
-            config_data['download_directory'] = os.path.join(temp_dir, 'downloads')
-            os.makedirs(config_data['download_directory'], exist_ok=True)
-            
-            original_cwd = os.getcwd()
-            try:
-                os.chdir(temp_dir)
-                workflow = TelegramYouTubeWorkflow(config_dict=config_data, logger_instance=workflow_logger)
-                workflow.setup_firebase(service_account_content, config_data['firebase']['database_url'])
-                workflow.setup_youtube_client(client_secrets_content, token_path, auth_code)
-                asyncio.run(workflow.process_videos(limit=num_videos))
-                processing_status[run_id] = "Completed."
-            except GoogleAuthError as e:
-                processing_status[run_id] = f"Authentication Required: {e}"
-                workflow_logger.error(f"Workflow stopped for user authentication.")
-            except Exception as e:
-                processing_status[run_id] = f"Failed: {str(e)}"
-                workflow_logger.error(f"Workflow thread failed: {e}", exc_info=True)
-            finally:
-                os.chdir(original_cwd)
+        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:
-        processing_status[run_id] = f"Setup Failed: {str(e)}"
-        workflow_logger.error(f"Thread setup failed: {e}", exc_info=True)
-    finally:
-        workflow_logger.removeHandler(log_handler)
-        log_handler.close()
+        logger.error(f"Failed to save session to Firestore: {e}")
 
-# --- Flask Routes ---
-
-@app.route('/', methods=['GET', 'POST'])
-def index():
+def load_telegram_session_from_db():
+    """Loads the Telethon session string from Firestore."""
+    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
+    except Exception as e:
+        logger.error(f"Failed to load session from Firestore: {e}")
+        return None
+
+# --- Login Protection Decorator ---
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'logged_in' not in session:
+            return redirect(url_for('login'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+# --- Web Routes ---
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
     if request.method == 'POST':
-        try:
-            # --- Firebase ---
-            firebase_database_url = request.form['firebase_database_url']
-            firebase_service_account_file = request.files['firebase_service_account']
-            if not firebase_service_account_file or firebase_service_account_file.filename == '':
-                flash('Firebase service account file is required.', 'error')
-                return redirect(request.url)
-            service_account_content = firebase_service_account_file.read().decode('utf-8')
-
-            # --- YouTube ---
-            client_secrets_file = request.files['youtube_client_secrets']
-            if not client_secrets_file or client_secrets_file.filename == '':
-                flash('YouTube client secrets file is required.', 'error')
-                return redirect(request.url)
-            client_secrets_content = client_secrets_file.read().decode('utf-8')
-            
-            # --- Google Auth Code (for first run) ---
-            google_auth_code = request.form.get('google_auth_code', '').strip()
-
-            config_data = {
-                "telegram": {
-                    "api_id": int(request.form['telegram_api_id']),
-                    "api_hash": request.form['telegram_api_hash'],
-                    "phone_number": request.form['telegram_phone_number'],
-                    "channel_username": request.form['telegram_channel_username']
-                },
-                "firebase": { "database_url": firebase_database_url },
-                "video_settings": {
-                    "title_prefix": request.form.get('title_prefix', ''),
-                    "description_template": request.form.get('description_template', 'Video from Telegram'),
-                    "tags": [tag.strip() for tag in request.form.get('tags', 'telegram,video').split(',') if tag.strip()],
-                    "category_id": request.form.get('category_id', '22'),
-                    "privacy_status": request.form.get('privacy_status', 'private')
-                }
-            }
-            num_videos = int(request.form.get('num_videos', 5))
-            run_id = str(uuid.uuid4())
-            global_logs[run_id] = []
-            processing_status[run_id] = "Starting..."
-
-            token_fd, token_path = tempfile.mkstemp(suffix='.json', prefix='token_')
-            os.close(token_fd) 
-
-            thread = threading.Thread(
-                target=run_workflow_in_thread,
-                args=(run_id, config_data, client_secrets_content, service_account_content, num_videos, token_path, google_auth_code)
-            )
-            thread.start()
-
-            flash(f'Workflow started with ID: {run_id}', 'info')
-            return redirect(url_for('results', run_id=run_id))
-
-        except ValueError as e:
-            flash(f'Invalid input data: {e}', 'error')
-            return redirect(request.url)
-        except Exception as e:
-            flash(f'Error starting workflow: {e}', 'error')
-            app.logger.error(f"Form processing error: {e}", exc_info=True)
-            return redirect(request.url)
-
+        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'))
+        else:
+            flash('Invalid username or password.', 'danger')
+    return render_template('login.html')
+
+@app.route('/')
+@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')
 
-@app.route('/results/<run_id>')
-def results(run_id):
-    logs = global_logs.get(run_id, [])
-    status = processing_status.get(run_id, "Not Found")
-    return render_template('results.html', run_id=run_id, logs=logs, status=status)
+@app.route('/telegram-auth', methods=['GET', 'POST'])
+@login_required
+def telegram_auth():
+    stage = session.get('telegram_auth_stage', 'credentials')
 
-# --- HTML Templates as Strings ---
-
-index_template_content = '''<!doctype html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>Telegram to YouTube Uploader</title>
-    <style>
-        
-        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; margin: 2em; background-color: #f8f9fa; color: #212529; }
-        .container { max-width: 800px; margin: auto; background: #fff; padding: 2em; border-radius: 0.5em; box-shadow: 0 0 1em rgba(0,0,0,0.1); }
-        h1, h2 { color: #007bff; }
-        h2.auth-header { color: #dc3545; }
-        .form-group { margin-bottom: 1.5em; }
-        label { display: block; margin-bottom: 0.5em; font-weight: bold; }
-        input[type="text"], input[type="number"], input[type="password"], textarea, select {
-            width: 100%; padding: 0.75em; box-sizing: border-box; border: 1px solid #ced4da; border-radius: 0.25em;
-        }
-        button { background-color: #007bff; color: white; padding: 0.75em 1.5em; border: none; cursor: pointer; border-radius: 0.25em; font-size: 1em; }
-        button:hover { background-color: #0056b3; }
-        .flash-messages { margin-bottom: 1.5em; }
-        .flash-message { padding: 1em; margin-bottom: 1em; border-radius: 0.25em; }
-        .flash-message-info { background-color: #d1ecf1; border: 1px solid #bee5eb; color: #0c5460; }
-        .flash-message-error { background-color: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
-        small { color: #6c757d; }
-        .auth-box { border: 2px solid #fd7e14; padding: 1em; border-radius: 0.5em; margin-bottom: 1.5em; background-color: #fff3cd; }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>Telegram to YouTube Uploader</h1>
-        <div class="flash-messages">
-            {% with messages = get_flashed_messages(with_categories=true) %}
-              {% if messages %}
-                {% for category, message in messages %}
-                  <div class="flash-message flash-message-{{ category }}">{{ message }}</div>
-                {% endfor %}
-              {% endif %}
-            {% endwith %}
-        </div>
-        <form method="post" enctype="multipart/form-data">
-            <div class="auth-box">
-                <h2 class="auth-header">Google Authentication</h2>
-                <div class="form-group">
-                    <label for="google_auth_code">Google Auth Code (only needed for first time setup)</label>
-                    <input type="text" id="google_auth_code" name="google_auth_code" placeholder="Paste code here if requested in logs">
-                    <small>If the logs ask for an auth code, paste it here and resubmit the form.</small>
-                </div>
-            </div>
-            
-            <h2>Cloud Settings</h2>
-            <div class="form-group">
-                <label for="firebase_database_url">Firebase Realtime Database URL:</label>
-                <input type="text" id="firebase_database_url" name="firebase_database_url" required placeholder="https://your-project-id-default-rtdb.firebaseio.com">
-            </div>
-            <div class="form-group">
-                <label for="firebase_service_account">Firebase Service Account File (JSON):</label>
-                <input type="file" id="firebase_service_account" name="firebase_service_account" accept=".json" required>
-            </div>
-            <div class="form-group">
-                <label for="youtube_client_secrets">YouTube Client Secrets File (JSON):</label>
-                <input type="file" id="youtube_client_secrets" name="youtube_client_secrets" accept=".json" required>
-            </div>
+    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')
 
-            <h2>Telegram Settings</h2>
-            <div class="form-group"><label for="telegram_api_id">API ID:</label><input type="number" id="telegram_api_id" name="telegram_api_id" required></div>
-            <div class="form-group"><label for="telegram_api_hash">API Hash:</label><input type="text" id="telegram_api_hash" name="telegram_api_hash" required></div>
-            <div class="form-group"><label for="telegram_phone_number">Phone Number:</label><input type="text" id="telegram_phone_number" name="telegram_phone_number" placeholder="+1234567890" required></div>
-            <div class="form-group"><label for="telegram_channel_username">Channel Username:</label><input type="text" id="telegram_channel_username" name="telegram_channel_username" placeholder="@channelname" required></div>
-            
-            <h2>Processing Settings</h2>
-            <div class="form-group"><label for="num_videos">Videos to Check:</label><input type="number" id="num_videos" name="num_videos" value="5" min="1"></div>
-            <div class="form-group"><label for="title_prefix">YouTube Title Prefix:</label><input type="text" id="title_prefix" name="title_prefix"></div>
-            <div class="form-group"><label for="description_template">Description Template:</label><textarea id="description_template" name="description_template">Video from Telegram.</textarea></div>
-            <div class="form-group"><label for="tags">Tags (comma-separated):</label><input type="text" id="tags" name="tags" value="telegram,video,archive"></div>
-            <div class="form-group">
-                <label for="category_id">Category ID:</label><input type="text" id="category_id" name="category_id" value="22">
-            </div>
-            <div class="form-group">
-                <label for="privacy_status">Privacy Status:</label>
-                <select id="privacy_status" name="privacy_status"><option value="private" selected>Private</option><option value="public">Public</option><option value="unlisted">Unlisted</option></select>
-            </div>
-            <button type="submit">Start Workflow</button>
-        </form>
-    </div>
-</body>
-</html>
-'''
+        if not api_id or not api_hash:
+            flash("API ID and Hash are required.", "danger")
+            return render_template('telegram_auth.html', stage='credentials')
 
-results_template_content = '''<!doctype html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>Workflow Results - {{ run_id }}</title>
-    <style>
-        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; margin: 2em; background-color: #f8f9fa; color: #212529; }
-        .container { max-width: 900px; margin: auto; background: #fff; padding: 2em; border-radius: 0.5em; box-shadow: 0 0 1em rgba(0,0,0,0.1); }
-        h1, h2 { color: #007bff; }
-        pre { background-color: #e9ecef; padding: 1em; border: 1px solid #ced4da; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word; border-radius: 0.25em; }
-        .status { margin-bottom: 1.5em; padding: 1em; border-radius: 0.25em; font-weight: bold; }
-        .status-Running { background-color: #d1ecf1; border: 1px solid #bee5eb; color: #0c5460; }
-        .status-Completed { background-color: #d4edda; border: 1px solid #c3e6cb; color: #155724; }
-        .status-Failed, .status-Setup, .status-Authentication { background-color: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
-        .back-link { margin-top: 2em; display: inline-block; }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>Workflow Results</h1>
-        <p><strong>Run ID:</strong> {{ run_id }}</p>
-        <div class="status status-{{ status.split(':')[0] }}">
-            <strong>Status:</strong> {{ status }}
-        </div>
-        <div class="refresh-info">
-            <p>Page will auto-refresh every 5 seconds if the job is running.</p>
-        </div>
-        <h2>Logs:</h2>
-        {% if logs %}
-            <pre>{{ logs | join('\\n') }}</pre>
-        {% else %}
-            <p>No logs available yet. The process might be starting up.</p>
-        {% endif %}
-        <a href="{{ url_for('index') }}" class="back-link">Back to Start</a>
-    </div>
-    <script>
-        (function() {
-            const status = "{{ status }}";
-            if (status.includes("Running") || status.includes("Starting")) {
-                setTimeout(function() { location.reload(); }, 5000);
-            }
-        })();
-    </script>
-</body>
-</html>
-'''
+        session['api_id'] = api_id
+        session['api_hash'] = api_hash
+        client = TelegramClient(StringSession(), int(api_id), api_hash)
+        loop = asyncio.get_event_loop()
 
-# --- Use the custom StringLoader for our embedded templates ---
-app.jinja_loader = StringLoader({
-    'index.html': index_template_content,
-    'results.html': results_template_content,
-})
+        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')
+@login_required
+def youtube_auth():
+    return render_template('auth.html')
+
+@app.route('/authorize')
+@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')
+@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'])
+@login_required
+def start_workflow():
+    if not os.path.exists('token.json'):
+        return jsonify({"error": "Not authenticated with YouTube. Please re-authorize."}), 401
+    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)
+
+@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'))
+
+if __name__ == '__main__':
+    port = int(os.environ.get('PORT', 10000))
+    app.run(host='0.0.0.0', port=port, debug=True)