Update app.py

app.py

@@ -1,391 +1,313 @@
 import asyncio
-import json
 import logging
+import sqlite3
 import os
+import io
 import threading
 from pathlib import Path
 
 from aiogram import Bot, Dispatcher, types
-from aiogram.filters import CommandStart
-from aiogram.enums import ParseMode
-from aiogram.types import FSInputFile
-from aiogram.utils.markdown import html_escape
-from aiogram.exceptions import TelegramAPIError
+from aiogram.utils import executor
+from aiogram.types import InputFile, ParseMode
 
-from flask import Flask, request, render_template_string, redirect, url_for
-from werkzeug.utils import secure_filename
+from flask import Flask, request, render_template_string, redirect, url_for, flash
 
 # --- Configuration ---
 BOT_TOKEN = "7835463659:AAGNePbelZIAOeaglyQi1qulOqnjs4BGQn4"
 FLASK_HOST = "0.0.0.0"
 FLASK_PORT = 7860
-
-BASE_DIR = Path(__file__).resolve().parent
-SUBSCRIBED_USERS_FILE = BASE_DIR / "subscribed_users.json"
-UPLOAD_FOLDER = BASE_DIR / "uploads"
+DB_NAME = "subscribers.db"
+UPLOAD_FOLDER = 'uploads' # For temporary file storage if needed, though we'll use streams
 
 # --- Logging ---
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# --- Global Variables for Bot and Queue ---
-# These will be initialized in main_async
-bot_instance: Bot = None
-dp: Dispatcher = None
-message_queue: asyncio.Queue = None
-subscribed_users: set = set()
-bot_loop: asyncio.AbstractEventLoop = None # To run coroutines from Flask thread
-
-# --- User Persistence ---
-def load_subscribed_users():
-    global subscribed_users
-    if SUBSCRIBED_USERS_FILE.exists():
-        try:
-            with open(SUBSCRIBED_USERS_FILE, 'r') as f:
-                user_ids = json.load(f)
-                subscribed_users = set(user_ids)
-                logger.info(f"Loaded {len(subscribed_users)} subscribed users.")
-        except json.JSONDecodeError:
-            logger.error(f"Error decoding JSON from {SUBSCRIBED_USERS_FILE}. Starting with empty list.")
-            subscribed_users = set()
-        except Exception as e:
-            logger.error(f"Error loading subscribed users: {e}")
-            subscribed_users = set()
-    else:
-        logger.info("Subscribed users file not found. Starting with empty list.")
-        subscribed_users = set()
-
-def save_subscribed_users():
-    try:
-        with open(SUBSCRIBED_USERS_FILE, 'w') as f:
-            json.dump(list(subscribed_users), f)
-        logger.info(f"Saved {len(subscribed_users)} subscribed users.")
-    except Exception as e:
-        logger.error(f"Error saving subscribed users: {e}")
-
-# --- Aiogram Bot Logic ---
-async def send_notification_to_user(user_id: int, text: str, file_path: str = None, file_type: str = None):
-    """Sends a notification to a single user, handling potential errors."""
-    global bot_instance
+# --- Database Setup ---
+def init_db():
+    conn = sqlite3.connect(DB_NAME)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            user_id INTEGER PRIMARY KEY
+        )
+    ''')
+    conn.commit()
+    conn.close()
+    logger.info("Database initialized.")
+
+def add_user(user_id: int):
+    conn = sqlite3.connect(DB_NAME)
+    cursor = conn.cursor()
     try:
-        input_file = FSInputFile(file_path) if file_path else None
-        
-        if file_path and input_file:
-            if file_type == 'photo':
-                await bot_instance.send_photo(chat_id=user_id, photo=input_file, caption=text, parse_mode=ParseMode.HTML)
-            elif file_type == 'video':
-                await bot_instance.send_video(chat_id=user_id, video=input_file, caption=text, parse_mode=ParseMode.HTML)
-            elif file_type == 'document':
-                await bot_instance.send_document(chat_id=user_id, document=input_file, caption=text, parse_mode=ParseMode.HTML)
-            elif file_type == 'audio':
-                await bot_instance.send_audio(chat_id=user_id, audio=input_file, caption=text, parse_mode=ParseMode.HTML)
-            else: # Default to sending text if file_type is unknown or file couldn't be processed
-                await bot_instance.send_message(chat_id=user_id, text=text, parse_mode=ParseMode.HTML)
-                if file_path: logger.warning(f"Unknown file type '{file_type}' for {file_path}, sent as text.")
-        elif text:
-            await bot_instance.send_message(chat_id=user_id, text=text, parse_mode=ParseMode.HTML)
-        
-        logger.info(f"Sent notification to {user_id}")
+        cursor.execute("INSERT INTO users (user_id) VALUES (?)", (user_id,))
+        conn.commit()
+        logger.info(f"User {user_id} added to database.")
         return True
+    except sqlite3.IntegrityError:
+        logger.info(f"User {user_id} already exists in database.")
+        return False # Already exists
+    finally:
+        conn.close()
 
-    except TelegramAPIError as e:
-        logger.error(f"Telegram API Error sending to {user_id}: {e}")
-        if "bot was blocked by the user" in str(e) or "user is deactivated" in str(e) or "chat not found" in str(e):
-            logger.info(f"User {user_id} blocked the bot or is deactivated. Removing from subscribers.")
-            if user_id in subscribed_users:
-                subscribed_users.remove(user_id)
-                save_subscribed_users()
-        return False
-    except Exception as e:
-        logger.error(f"Unexpected error sending to {user_id}: {e}")
-        return False
-
-async def process_notifications_from_queue():
-    """Continuously processes messages from the queue and sends them."""
-    global message_queue
-    while True:
-        try:
-            notification_item = await message_queue.get()
-            text_content = notification_item.get("text")
-            file_path = notification_item.get("file_path")
-            file_type = notification_item.get("file_type")
-
-            logger.info(f"Processing notification: Text='{text_content[:50]}...', File='{file_path}'")
-            
-            # Create a copy of subscribed_users to iterate over, in case it's modified
-            current_subscribers = list(subscribed_users) 
-            
-            for user_id in current_subscribers:
-                await send_notification_to_user(user_id, text_content, file_path, file_type)
-                await asyncio.sleep(0.1) # Small delay to avoid hitting rate limits too hard
-
-            if file_path and os.path.exists(file_path):
-                try:
-                    os.remove(file_path)
-                    logger.info(f"Temporary file {file_path} deleted.")
-                except Exception as e:
-                    logger.error(f"Error deleting temporary file {file_path}: {e}")
-            
-            message_queue.task_done()
-        except asyncio.CancelledError:
-            logger.info("Notification processor task cancelled.")
-            break
-        except Exception as e:
-            logger.error(f"Error in notification processor: {e}")
-            # Potentially re-queue or handle the error, for now just log
-            if 'message_queue' in locals() and message_queue is not None: # Check if message_queue exists
-                 message_queue.task_done() # Ensure task_done is called even on error to prevent blocking
+def get_all_users():
+    conn = sqlite3.connect(DB_NAME)
+    cursor = conn.cursor()
+    cursor.execute("SELECT user_id FROM users")
+    users = [row[0] for row in cursor.fetchall()]
+    conn.close()
+    return users
 
-@dp.message(CommandStart())
-async def handle_start(message: types.Message):
-    user_id = message.from_user.id
-    if user_id not in subscribed_users:
-        subscribed_users.add(user_id)
-        save_subscribed_users()
-        logger.info(f"User {user_id} ({message.from_user.full_name}) subscribed.")
-        await message.reply("🎉 вы подписались на уведомления!")
-    else:
-        logger.info(f"User {user_id} ({message.from_user.full_name}) is already subscribed.")
-        await message.reply("Вы уже подписаны на уведомления. 👍")
+# --- Aiogram Bot Setup ---
+bot = Bot(token=BOT_TOKEN)
+dp = Dispatcher(bot)
 
-# --- Flask Admin Panel ---
+# --- Flask App Setup ---
 flask_app = Flask(__name__)
-flask_app.config['UPLOAD_FOLDER'] = str(UPLOAD_FOLDER) # Flask expects string path
-flask_app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # 50 MB limit for uploads
-
-# Ensure UPLOAD_FOLDER exists
-UPLOAD_FOLDER.mkdir(parents=True, exist_ok=True)
+flask_app.secret_key = os.urandom(24) # For flash messages
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
+flask_app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 
+# --- HTML Templates (Inline) ---
 ADMIN_PANEL_HTML = """
 <!DOCTYPE html>
 <html lang="ru">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Admin Panel - Telegram Notifier</title>
+    <title>Админ Панель Уведомлений</title>
     <style>
-        body { font-family: sans-serif; margin: 20px; background-color: #f4f4f9; color: #333; }
-        .container { background-color: #fff; padding: 20px; border-radius: 8px; box-shadow: 0 0 10px rgba(0,0,0,0.1); }
-        h1 { color: #5a5a5a; text-align: center; }
+        body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background-color: #f4f4f4; color: #333; }
+        .container { background-color: #fff; padding: 20px; border-radius: 8px; box-shadow: 0 0 10px rgba(0,0,0,0.1); max-width: 600px; margin: auto; }
+        h1 { text-align: center; color: #333; }
         label { display: block; margin-bottom: 8px; font-weight: bold; }
         textarea, input[type="file"] {
-            width: calc(100% - 22px); /* Adjust for padding and border */
+            width: calc(100% - 22px);
             padding: 10px;
             margin-bottom: 20px;
             border: 1px solid #ddd;
             border-radius: 4px;
-            box-sizing: border-box; /* Important for width calculation */
+            box-sizing: border-box;
         }
-        textarea { min-height: 100px; resize: vertical; }
         button {
-            background-color: #007bff; color: white; padding: 12px 20px;
-            border: none; border-radius: 4px; cursor: pointer; font-size: 16px;
-            transition: background-color 0.3s ease;
+            background-color: #007bff;
+            color: white;
+            padding: 10px 20px;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+            display: block;
+            width: 100%;
         }
         button:hover { background-color: #0056b3; }
-        .status {
-            margin-top: 20px; padding: 10px; border-radius: 4px;
-            text-align: center;
-        }
-        .status.success { background-color: #d4edda; color: #155724; border: 1px solid #c3e6cb; }
-        .status.error { background-color: #f8d7da; color: #721c24; border: 1px solid #f5c6cb; }
-        .loader {
-            border: 5px solid #f3f3f3; /* Light grey */
-            border-top: 5px solid #3498db; /* Blue */
-            border-radius: 50%;
-            width: 30px;
-            height: 30px;
-            animation: spin 1s linear infinite;
-            margin: 10px auto;
-            display: none; /* Hidden by default */
-        }
-        @keyframes spin {
-            0% { transform: rotate(0deg); }
-            100% { transform: rotate(360deg); }
+        .flash-messages { list-style: none; padding: 0; margin-bottom: 20px; }
+        .flash-messages li {
+            padding: 10px;
+            margin-bottom: 10px;
+            border-radius: 4px;
         }
+        .flash-success { background-color: #d4edda; color: #155724; border: 1px solid #c3e6cb; }
+        .flash-error { background-color: #f8d7da; color: #721c24; border: 1px solid #f5c6cb; }
+        #preview-container { margin-top: 15px; text-align: center; }
+        #media-preview { max-width: 100%; max-height: 200px; border: 1px solid #ddd; margin-top: 5px; }
     </style>
 </head>
 <body>
     <div class="container">
-        <h1>Отправить уведомление</h1>
-        <form id="notificationForm" enctype="multipart/form-data">
+        <h1>Отправить Уведомление</h1>
+        {% with messages = get_flashed_messages(with_categories=true) %}
+          {% if messages %}
+            <ul class="flash-messages">
+            {% for category, message in messages %}
+              <li class="flash-{{ category }}">{{ message }}</li>
+            {% endfor %}
+            </ul>
+          {% endif %}
+        {% endwith %}
+        <form method="POST" action="{{ url_for('send_notification_route') }}" enctype="multipart/form-data" onsubmit="return showLoader();">
             <div>
-                <label for="message_text">Текст сообщения (HTML поддерживается):</label>
-                <textarea id="message_text" name="message_text" rows="5" required></textarea>
+                <label for="message">Текст сообщения (HTML поддерживается):</label>
+                <textarea name="message" id="message" rows="5" placeholder="Введите ваше сообщение..."></textarea>
             </div>
             <div>
-                <label for="media_file">Прикрепить медиафайл (фото, видео, документ, аудио):</label>
-                <input type="file" id="media_file" name="media_file" accept="image/*,video/*,audio/*,.pdf,.doc,.docx,.txt,.zip">
+                <label for="media">Медиафайл (фото, видео, документ):</label>
+                <input type="file" name="media" id="media" onchange="previewFile()">
             </div>
-            <button type="submit">Отправить всем</button>
+            <div id="preview-container">
+                <img id="media-preview" src="#" alt="Предпросмотр медиа" style="display:none;"/>
+                <video id="video-preview" controls style="display:none; max-width: 100%; max-height: 200px;"></video>
+                <p id="file-name-preview" style="display:none;"></p>
+            </div>
+            <button type="submit" id="submit-button">Отправить Всем</button>
+            <div id="loader" style="display:none; text-align:center; margin-top:15px;">Отправка... Пожалуйста, подождите.</div>
         </form>
-        <div class="loader" id="loader"></div>
-        <div id="statusMessage" class="status" style="display:none;"></div>
     </div>
-
     <script>
-        document.getElementById('notificationForm').addEventListener('submit', async function(event) {
-            event.preventDefault();
-            const form = event.target;
-            const formData = new FormData(form);
-            const statusDiv = document.getElementById('statusMessage');
-            const loader = document.getElementById('loader');
-
-            statusDiv.style.display = 'none';
-            statusDiv.className = 'status'; // Reset class
-            loader.style.display = 'block'; // Show loader
-
-            try {
-                const response = await fetch('/send_notification', {
-                    method: 'POST',
-                    body: formData
-                });
-                const result = await response.json();
-
-                if (response.ok) {
-                    statusDiv.textContent = result.message || 'Уведомление успешно отправлено в очередь.';
-                    statusDiv.classList.add('success');
-                    form.reset(); // Clear the form
-                } else {
-                    statusDiv.textContent = result.error || 'Ошибка при отправке уведомления.';
-                    statusDiv.classList.add('error');
+        function previewFile() {
+            const preview = document.getElementById('media-preview');
+            const videoPreview = document.getElementById('video-preview');
+            const fileNamePreview = document.getElementById('file-name-preview');
+            const file = document.getElementById('media').files[0];
+            const reader = new FileReader();
+
+            preview.style.display = 'none';
+            videoPreview.style.display = 'none';
+            fileNamePreview.style.display = 'none';
+            videoPreview.src = ''; // Reset video src
+
+            if (file) {
+                reader.onloadend = function() {
+                    if (file.type.startsWith('image/')) {
+                        preview.src = reader.result;
+                        preview.style.display = 'block';
+                    } else if (file.type.startsWith('video/')) {
+                        videoPreview.src = reader.result;
+                        videoPreview.style.display = 'block';
+                    } else {
+                        fileNamePreview.textContent = "Выбран файл: " + file.name;
+                        fileNamePreview.style.display = 'block';
+                    }
                 }
-            } catch (error) {
-                console.error('Fetch error:', error);
-                statusDiv.textContent = 'Сетевая ошибка или ошибка сервера. Подробности в консоли.';
-                statusDiv.classList.add('error');
-            } finally {
-                loader.style.display = 'none'; // Hide loader
-                statusDiv.style.display = 'block';
+                reader.readAsDataURL(file);
             }
-        });
+        }
+        function showLoader() {
+            document.getElementById('submit-button').style.display = 'none';
+            document.getElementById('loader').style.display = 'block';
+            return true; // Proceed with form submission
+        }
     </script>
 </body>
 </html>
 """
 
+# --- Aiogram Handlers ---
+@dp.message_handler(commands=['start'])
+async def send_welcome(message: types.Message):
+    user_id = message.from_user.id
+    username = message.from_user.username or message.from_user.first_name
+    if add_user(user_id):
+        await message.reply("🎉 Вы успешно подписались на уведомления! 🎉")
+        logger.info(f"User {username} (ID: {user_id}) subscribed.")
+    else:
+        await message.reply("Вы уже подписаны на уведомления. 👍")
+        logger.info(f"User {username} (ID: {user_id}) tried to subscribe again.")
+
+# --- Flask Routes ---
 @flask_app.route('/', methods=['GET'])
-def admin_panel():
+def admin_panel_route():
     return render_template_string(ADMIN_PANEL_HTML)
 
-def get_file_type(filename: str) -> str:
-    """Determines file type based on extension."""
-    ext = filename.rsplit('.', 1)[-1].lower() if '.' in filename else ''
-    if ext in ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']:
-        return 'photo'
-    elif ext in ['mp4', 'mov', 'avi', 'mkv', 'webm']:
-        return 'video'
-    elif ext in ['mp3', 'ogg', 'wav', 'flac', 'm4a']:
-        return 'audio'
-    elif ext in ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt', 'zip', 'rar']:
-        return 'document'
-    return None # Unknown or unsupported for specific sending
-
 @flask_app.route('/send_notification', methods=['POST'])
-def handle_send_notification():
-    global message_queue, bot_loop
-    if not message_queue or not bot_loop:
-        logger.error("Bot components (queue or loop) not initialized for Flask.")
-        return {"error": "Серверная ошибка: компоненты бота не инициализированы."}, 500
+def send_notification_route():
+    message_text = request.form.get('message', '')
+    media_file = request.files.get('media')
 
-    message_text_html = request.form.get('message_text', '')
-    if not message_text_html and 'media_file' not in request.files:
-        return {"error": "Требуется текст сообщения или медиафайл."}, 400
+    if not message_text and not media_file:
+        flash("Сообщение не может быть пустым, если не прикреплен медиафайл.", "error")
+        return redirect(url_for('admin_panel_route'))
 
-    # HTML escape text if you don't trust the admin input for Telegram HTML parsing
-    # For this example, we assume admin can use basic HTML like <b>, <i>, <a>
-    # text_content = html_escape(message_text) # if you want to be super safe and send as plain text
-    text_content = message_text_html # Use as is, assuming admin knows HTML for Telegram
+    users = get_all_users()
+    if not users:
+        flash("Нет подписчиков для отправки уведомлений.", "error")
+        return redirect(url_for('admin_panel_route'))
 
-    file_path = None
-    file_type = None
-    
-    uploaded_file = request.files.get('media_file')
-    if uploaded_file and uploaded_file.filename != '':
-        filename = secure_filename(uploaded_file.filename)
-        file_path = str(UPLOAD_FOLDER / filename) # Store as string
+    sent_count = 0
+    error_count = 0
+
+    # We need to run async bot functions from this synchronous Flask thread
+    # Get the bot's event loop
+    loop = bot.loop # or dp.loop
+
+    for user_id in users:
         try:
-            uploaded_file.save(file_path)
-            file_type = get_file_type(filename)
-            if not file_type:
-                logger.warning(f"Uploaded file {filename} has an unknown type for specific sending, will be sent as generic document or text only.")
-                # If file_type is crucial, you might want to return an error or default to 'document'
+            if media_file:
+                # Reset stream position for each send
+                media_file.seek(0)
+                file_content = io.BytesIO(media_file.read())
+                file_content.name = media_file.filename # Important for aiogram to determine type
+                
+                input_file = InputFile(file_content, filename=media_file.filename)
+                
+                content_type = media_file.content_type
+                logger.info(f"Attempting to send media with content type: {content_type} to {user_id}")
+
+                coro = None
+                if 'image' in content_type:
+                    coro = bot.send_photo(user_id, input_file, caption=message_text if message_text else None, parse_mode=ParseMode.HTML)
+                elif 'video' in content_type:
+                    coro = bot.send_video(user_id, input_file, caption=message_text if message_text else None, parse_mode=ParseMode.HTML)
+                elif 'audio' in content_type: # Added audio support
+                    coro = bot.send_audio(user_id, input_file, caption=message_text if message_text else None, parse_mode=ParseMode.HTML)
+                else: # Default to document
+                    coro = bot.send_document(user_id, input_file, caption=message_text if message_text else None, parse_mode=ParseMode.HTML)
+                
+                if coro:
+                    # Run the coroutine in the bot's event loop
+                    future = asyncio.run_coroutine_threadsafe(coro, loop)
+                    future.result(timeout=30) # Wait for completion with timeout
+                else: # If only text was provided with media, but media type was not sendable this way
+                    if message_text:
+                         coro_text = bot.send_message(user_id, message_text, parse_mode=ParseMode.HTML)
+                         future = asyncio.run_coroutine_threadsafe(coro_text, loop)
+                         future.result(timeout=10)
+
+            elif message_text: # Only text
+                coro = bot.send_message(user_id, message_text, parse_mode=ParseMode.HTML)
+                future = asyncio.run_coroutine_threadsafe(coro, loop)
+                future.result(timeout=10) # Wait for completion with timeout
+            
+            sent_count += 1
+            logger.info(f"Notification sent to {user_id}")
+        
         except Exception as e:
-            logger.error(f"Error saving uploaded file {filename}: {e}")
-            return {"error": f"Ошибка сохранения файла: {e}"}, 500
+            error_count += 1
+            logger.error(f"Failed to send notification to {user_id}: {e}")
+            # Common errors: bot blocked by user, chat not found, timeout
+            if "bot was blocked by the user" in str(e).lower():
+                logger.warning(f"User {user_id} blocked the bot. Consider removing them.")
+            # You might want to remove users who have blocked the bot from the DB here
     
-    notification_item = {
-        "text": text_content,
-        "file_path": file_path,
-        "file_type": file_type
-    }
+    if media_file: # Close the original file stream if it was opened
+        media_file.close()
 
-    try:
-        # Put the item into the asyncio queue from this synchronous thread
-        future = asyncio.run_coroutine_threadsafe(message_queue.put(notification_item), bot_loop)
-        future.result(timeout=5) # Wait for the put operation to complete, with a timeout
-        logger.info(f"Notification enqueued: Text='{text_content[:30]}...', File='{file_path}'")
-        return {"message": "Уведомление добавлено в очередь на отправку."}, 200
-    except asyncio.TimeoutError:
-        logger.error("Timeout putting notification onto the queue.")
-        if file_path and os.path.exists(file_path): # Cleanup if queueing failed
-            os.remove(file_path)
-        return {"error": "Не удалось добавить уведомление в очередь (тайм-аут)."}, 500
-    except Exception as e:
-        logger.error(f"Error putting notification onto the queue: {e}")
-        if file_path and os.path.exists(file_path): # Cleanup if queueing failed
-            os.remove(file_path)
-        return {"error": f"Ошибка добавления в очередь: {e}"}, 500
+    flash(f"Уведомление отправлено {sent_count} пользователям. Ошибок: {error_count}.", "success" if error_count == 0 else "error")
+    return redirect(url_for('admin_panel_route'))
 
-# --- Main Execution ---
-async def main_async():
-    global bot_instance, dp, message_queue, bot_loop
-
-    bot_instance = Bot(token=BOT_TOKEN)
-    # dp is already initialized globally if you stick to that pattern,
-    # otherwise initialize here: dp = Dispatcher()
-    message_queue = asyncio.Queue()
-    bot_loop = asyncio.get_running_loop() # Get the current event loop
-
-    load_subscribed_users() # Load users before starting any tasks
-
-    # Start the background task for processing notifications
-    asyncio.create_task(process_notifications_from_queue())
-    
-    logger.info("Starting Telegram bot polling...")
-    try:
-        await dp.start_polling(bot_instance, allowed_updates=dp.resolve_used_update_types())
-    except Exception as e:
-        logger.critical(f"Fatal error in bot polling: {e}")
-    finally:
-        await bot_instance.session.close()
-        logger.info("Bot polling stopped and session closed.")
 
+# --- Functions to run Flask and Aiogram ---
 def run_flask():
-    logger.info(f"Starting Flask server on {FLASK_HOST}:{FLASK_PORT}")
-    # Use a production-ready WSGI server like gunicorn or waitress in a real setup
-    # For simplicity, Flask's built-in server is used here.
-    # Setting debug=False is generally recommended for anything beyond local dev.
+    # Use '0.0.0.0' to make it accessible externally, False for debug in "production"
     flask_app.run(host=FLASK_HOST, port=FLASK_PORT, debug=False, use_reloader=False)
 
-if __name__ == '__main__':
-    # Initialize Dispatcher here if not done globally already
-    # This pattern is common when dp needs to be accessible globally for route decorators
-    dp = Dispatcher() 
-    # Register handlers after dp is initialized
-    dp.message.register(handle_start, CommandStart())
+async def main_bot_loop():
+    # Start polling
+    logger.info("Starting bot polling...")
+    # No need to pass bot, dp will use the one it was initialized with
+    await dp.start_polling()
+
 
+if __name__ == '__main__':
+    init_db() # Initialize database on startup
 
-    # Start Flask in a separate thread
+    # Run Flask in a separate thread
+    # daemon=True ensures the thread exits when the main program exits
     flask_thread = threading.Thread(target=run_flask, daemon=True)
     flask_thread.start()
+    logger.info(f"Flask admin panel running on http://{FLASK_HOST}:{FLASK_PORT}")
 
-    # Start Aiogram bot
+    # Run Aiogram in the main thread's asyncio loop
+    # executor.start_polling(dp, skip_updates=True) # This is a blocking call
+    # For more control or if mixing with other asyncio tasks:
+    loop = asyncio.get_event_loop()
     try:
-        asyncio.run(main_async())
+        loop.run_until_complete(main_bot_loop())
     except KeyboardInterrupt:
-        logger.info("Application shutting down (KeyboardInterrupt)...")
-    except Exception as e:
-        logger.critical(f"Application crashed: {e}", exc_info=True)
+        logger.info("Bot polling stopped by user.")
     finally:
-        logger.info("Application shutdown complete.")
+        logger.info("Shutting down...")
+        # You might want to close bot session here if needed, though start_polling handles it
+        # await bot.session.close() # if you are managing session explicitly
+        loop.close()