Update app.py

app.py

@@ -1,426 +1,339 @@
+#!/usr/bin/env python3
 import os
 import asyncio
-import time
-import re
-import urllib.parse
-import io
 import logging
-import random
-import json
+from datetime import datetime, timedelta
+from collections import deque
+from typing import Dict, List, Optional
+
+from telegram import Update
+from telegram.ext import Application, CommandHandler, MessageHandler, ContextTypes, filters
+import google.generativeai as genai
+import firebase_admin
+from firebase_admin import credentials, firestore
 import aiohttp
-from typing import Optional, Dict
+from duckduckgo_search import DDGS
 
-from aiohttp import web
-from telegram import (
-    Update,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-)
-from telegram.ext import (
-    Application,
-    CommandHandler,
-    MessageHandler,
-    CallbackQueryHandler,
-    ContextTypes,
-    filters,
-)
-from telegram.constants import ParseMode, ChatAction
-
-# ============================================================
-# НАСТРОЙКА ЛОГИРОВАНИЯ
-# ============================================================
-logging.basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    level=logging.INFO,
-)
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# ============================================================
-# КОНФИГУРАЦИЯ БОТА И КЛЮЧЕЙ
-# ============================================================
-BOT_TOKEN = os.environ.get("BOT_TOKEN", "8605889873:AAE2gV2t0psXKlj-8h9ksyyoCrWa8Q-TdkA")
-CF_WORKER_URL = os.environ.get("CF_WORKER_URL", "https://tg-proxy.artyomanisimov37.workers.dev")
-WEBHOOK_URL = os.environ.get("WEBHOOK_URL", "https://rid3-aibottbh.hf.space")
-PORT = int(os.environ.get("PORT", 7860))
-
-# Ключи для ежечасных объявлений
-ANNOUNCE_KEYS = [
+# ============= КОНФИГУРАЦИЯ =============
+TG_BOT_TOKEN = "8531345451:AAE8qJlFEwIcuQdUiIFk2viZS9xLLMk2c_o"
+GOOGLE_API_KEYS = [
     "AIzaSyC59FksQAoeVeBKzVpxpL8zByEg3DAkKgE",
     "AIzaSyDCL7CImQjZ3DlInbjmWDWw7UeQ5bQDUbU"
 ]
+CF_WORKER_URL = "https://tg-proxy.artyomanisimov37.workers.dev"
+ADMIN_ID = 1234567890  # Замени на реальный ID админа
+BOT_CHAT_ID = -1001234567890  # Замени на реальный ID чата
+ACTIVITY_CHECK_INTERVAL = 1800  # 30 минут
+
+# Firebase инициализация
+try:
+    firebase_admin.initialize_app(credentials.Certificate("firebase_admin.json"))
+    db = firestore.client()
+    logger.info("✅ Firebase подключен")
+except Exception as e:
+    logger.error(f"❌ Firebase ошибка: {e}")
+    db = None
+
+# Google Generative AI
+genai.configure(api_key=GOOGLE_API_KEYS[0])
+
+# ============= СОСТОЯНИЕ БОТА =============
+class BotState:
+    def __init__(self):
+        self.request_queue: Dict[int, deque] = {}  # chat_id -> очередь запросов
+        self.processing: Dict[int, bool] = {}  # chat_id -> обрабатывается ли
+        self.last_activity = datetime.now()
+        self.is_sleeping = False
+        self.whitelist: set = set()
+        self.current_api_key_index = 0
+        self.load_whitelist()
+    
+    def load_whitelist(self):
+        """Загрузить белый список из Firebase"""
+        if db:
+            try:
+                doc = db.collection("bot_config").document("whitelist").get()
+                if doc.exists:
+                    self.whitelist = set(doc.get("users", []))
+                else:
+                    self.whitelist = {ADMIN_ID}
+                    self.save_whitelist()
+                logger.info(f"📋 Белый список: {len(self.whitelist)} пользователей")
+            except Exception as e:
+                logger.error(f"Ошибка загрузки списка: {e}")
+                self.whitelist = {ADMIN_ID}
+    
+    def save_whitelist(self):
+        """Сохранить белый список в Firebase"""
+        if db:
+            try:
+                db.collection("bot_config").document("whitelist").set({
+                    "users": list(self.whitelist),
+                    "updated_at": datetime.now()
+                })
+            except Exception as e:
+                logger.error(f"Ошибка сохранения: {e}")
+    
+    def is_whitelisted(self, user_id: int) -> bool:
+        return user_id in self.whitelist or user_id == ADMIN_ID
+    
+    def add_whitelist(self, user_id: int):
+        if user_id not in self.whitelist:
+            self.whitelist.add(user_id)
+            self.save_whitelist()
+    
+    def remove_whitelist(self, user_id: int):
+        if user_id != ADMIN_ID and user_id in self.whitelist:
+            self.whitelist.remove(user_id)
+            self.save_whitelist()
 
-# Ключи для общения с вайтлистом
-CHAT_KEYS = [
-    "AIzaSyCuJfvES31KE86l0NM-rXUnbTIoooh8kis",
-    "AIzaSyA2vr6mbAEcBMNL1LM36-PjA2_ZVfpHia0",
-    "AIzaSyCXkFnlqbv_J3g2JIu3agxRM3Rh-g-Y_Tc",
-    "AIzaSyBp47tYRwstD2givN1ptPAmwytZMTDp7-4",
-    "AIzaSyDDbqYYtHXPmVq7l0htd9RXavuV0puqr5o",
-    "AIzaSyC_Rq4JfCD30sUb_Df09LVR6CtfirGu9P4"
-]
-
-ADMIN_PASSWORD = "artyom2010Q"
-
-# Лимит запросов на один ключ до того, как он "устанет" (напр. 20 запросов)
-KEY_MAX_USES = 20
-KEY_COOLDOWN_SECONDS = 3600 # Час отдыха
-
-# ============================================================
-# БАЗА ДАННЫХ (Бот запоминает админов, вайтлист и чаты)
-# ============================================================
-DB_FILE = "bot_db.json"
-
-def load_db() -> dict:
-    if os.path.exists(DB_FILE):
-        try:
-            with open(DB_FILE, "r", encoding="utf-8") as f:
-                return json.load(f)
-        except Exception as e:
-            logger.error(f"Ошибка чтения БД: {e}")
-    # Дефолтная структура
-    return {
-        "admins": [],
-        "whitelist": [],
-        "known_chats": [],
-        "key_usage": {}
-    }
-
-def save_db(data: dict):
-    with open(DB_FILE, "w", encoding="utf-8") as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-
-db = load_db()
-
-def track_chat(chat_id: int):
-    if chat_id not in db["known_chats"]:
-        db["known_chats"].append(chat_id)
-        save_db(db)
-
-# ============================================================
-# МЕНЕДЖЕР КЛЮЧЕЙ GEMINI (Усталость и восстановление)
-# ============================================================
-def get_available_key(is_announce=False) -> Optional[str]:
-    keys_pool = ANNOUNCE_KEYS if is_announce else CHAT_KEYS
-    current_time = time.time()
-    
-    available_keys = []
-    for key in keys_pool:
-        usage_info = db["key_usage"].get(key, {"uses": 0, "cooldown_until": 0})
-        
-        # Если время кулдауна прошло, сбрасываем усталость
-        if current_time > usage_info["cooldown_until"]:
-            if usage_info["uses"] >= KEY_MAX_USES:
-                usage_info["uses"] = 0 # Восстановил силы
-                db["key_usage"][key] = usage_info
-                save_db(db)
-            
-            if usage_info["uses"] < KEY_MAX_USES:
-                available_keys.append(key)
-                
-    if not available_keys:
-        return None
-        
-    return random.choice(available_keys)
+bot_state = BotState()
 
-def increment_key_usage(key: str):
-    usage_info = db["key_usage"].get(key, {"uses": 0, "cooldown_until": 0})
-    usage_info["uses"] += 1
-    
-    if usage_info["uses"] >= KEY_MAX_USES:
-        usage_info["cooldown_until"] = time.time() + KEY_COOLDOWN_SECONDS
+# ============= AI ГЕНЕРАТОР =============
+async def generate_text(prompt: str, user_id: int) -> str:
+    """Генерировать текст через Google Generative AI"""
+    try:
+        model = genai.GenerativeModel("gemini-pro")
+        response = model.generate_content(prompt)
+        result = response.text
         
-    db["key_usage"][key] = usage_info
-    save_db(db)
-
-async def ask_gemini(prompt: str, is_announce=False) -> str:
-    key = get_available_key(is_announce)
-    if not key:
-        return "😔 Мои нейроны устали. Мне нужно время, чтобы восстановить силы. Я пока не могу отвечать."
+        # Сохранить в Firebase
+        if db:
+            db.collection("users").document(str(user_id)).collection("history").add({
+                "prompt": prompt,
+                "response": result,
+                "timestamp": datetime.now(),
+                "model": "gemini-pro"
+            })
         
-    url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key={key}"
-    payload = {"contents": [{"parts": [{"text": prompt}]}]}
+        return result
+    except Exception as e:
+        logger.error(f"❌ Ошибка генерации: {e}")
+        return f"❌ Ошибка: {str(e)}"
+
+# ============= CLOUDFLARE ПРОКСИ =============
+async def send_via_cloudflare(method: str, chat_id: int, text: str, **kwargs):
+    """Отправить сообщение через Cloudflare worker"""
+    payload = {
+        "method": method,
+        "chat_id": chat_id,
+        "text": text,
+        **kwargs
+    }
     
     try:
         async with aiohttp.ClientSession() as session:
-            async with session.post(url, json=payload) as resp:
+            async with session.post(CF_WORKER_URL, json=payload) as resp:
                 if resp.status == 200:
-                    increment_key_usage(key)
-                    data = await resp.json()
-                    return data['candidates'][0]['content']['parts'][0]['text']
-                else:
-                    logger.error(f"Ошибка Gemini: {await resp.text()}")
-                    return "❌ Ошибка при обращении к мозгу Google."
+                    return await resp.json()
     except Exception as e:
-        logger.error(f"Сбой сети Gemini: {e}")
-        return "❌ Произошла ошибка связи."
-
-# ============================================================
-# ГЕНЕРАЦИЯ ИЗОБРАЖЕНИЙ (Pollinations AI)
-# ============================================================
-async def generate_image(prompt: str) -> Optional[bytes]:
-    encoded_prompt = urllib.parse.quote(prompt)
-    url = f"https://image.pollinations.ai/prompt/{encoded_prompt}?nologo=true&seed={random.randint(1,99999)}&width=1024&height=1024&enhance=true"
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url, timeout=120) as res:
-                if res.status == 200:
-                    return await res.read()
-    except Exception as e:
-        logger.error(f"Ошибка генерации картинки: {e}")
+        logger.error(f"Cloudflare ошибка: {e}")
+    
     return None
 
-# ============================================================
-# ОБРАБОТЧИКИ TELEGRAM: АДМИН И ПАНЕЛЬ
-# ============================================================
-async def admin_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+# ============= КОМАНДЫ =============
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
     user_id = update.effective_user.id
-    args = context.args
-    
-    if args and args[0] == ADMIN_PASSWORD:
-        if user_id not in db["admins"]:
-            db["admins"].append(user_id)
-            if user_id not in db["whitelist"]:
-                db["whitelist"].append(user_id) # Админ автоматически в вайтлисте
-            save_db(db)
-            await update.message.reply_text("✅ Пароль принят. Ты добавлен в список администраторов навсегда.")
-        else:
-            await update.message.reply_text("Ты и так уже админ!")
-    else:
-        await update.message.reply_text("❌ Неверный пароль.")
+    
+    if not bot_state.is_whitelisted(user_id):
+        await update.message.reply_text("❌ Вы не авторизованы")
+        return
+    
+    text = """🤖 Добро пожаловать в AI Bot!
 
-def get_panel_keyboard():
-    return InlineKeyboardMarkup([
-        [InlineKeyboardButton("➕ Добавить в WhiteList", callback_data="panel_add")],
-        [InlineKeyboardButton("➖ Удалить из WhiteList", callback_data="panel_remove")],
-        [InlineKeyboardButton("📋 Показать WhiteList", callback_data="panel_show")]
-    ])
+/ask [вопрос] - Спросить ИИ
+/premium - О премиум подписке
+/w - Управлять списком (админ)
+/help - Справка
 
-async def panel_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+Просто напишите "ии [текст)" и я отвечу!"""
+    
+    await update.message.reply_text(text)
+
+async def ask(update: Update, context: ContextTypes.DEFAULT_TYPE):
     user_id = update.effective_user.id
-    if user_id not in db["admins"]:
-        await update.message.reply_text("⛔️ У тебя нет прав администратора.")
+    chat_id = update.effective_chat.id
+    
+    if not bot_state.is_whitelisted(user_id):
         return
-        
-    await update.message.reply_text(
-        "🛠 **Админ Панель**\nЗдесь ты можешь управлять доступом к ИИ и генерации картинок.", 
-        reply_markup=get_panel_keyboard(),
-        parse_mode=ParseMode.MARKDOWN
-    )
+    
+    if not context.args:
+        await update.message.reply_text("Использование: /ask [вопрос]")
+        return
+    
+    prompt = " ".join(context.args)
+    
+    # Добавить в очередь
+    if chat_id not in bot_state.request_queue:
+        bot_state.request_queue[chat_id] = deque()
+    
+    bot_state.request_queue[chat_id].append({"user_id": user_id, "prompt": prompt})
+    
+    # Показать индикатор печатания
+    await update.message.chat.send_action("typing")
+    
+    # Генерировать ответ
+    response = await generate_text(prompt, user_id)
+    
+    # Отправить ответ
+    if len(response) > 4096:
+        for i in range(0, len(response), 4096):
+            await update.message.reply_text(response[i:i+4096])
+    else:
+        await update.message.reply_text(response)
+    
+    bot_state.last_activity = datetime.now()
 
-async def handle_panel_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    user_id = query.from_user.id
+async def whitelist_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user_id = update.effective_user.id
     
-    if user_id not in db["admins"]:
-        await query.answer("У тебя нет прав!", show_alert=True)
+    if user_id != ADMIN_ID:
+        await update.message.reply_text("❌ Только админ")
         return
-        
-    await query.answer()
-    action = query.data
     
-    if action == "panel_show":
-        wl = "\n".join([f"- `{uid}`" for uid in db["whitelist"]]) if db["whitelist"] else "Пусто"
-        await query.edit_message_text(f"📋 **WhiteList пользователей:**\n{wl}", reply_markup=get_panel_keyboard(), parse_mode=ParseMode.MARKDOWN)
-        
-    elif action == "panel_add":
-        context.user_data["awaiting_id_for"] = "add"
-        await query.message.reply_text("Отправь ID пользователя (число), чтобы добавить его в WhiteList:")
-        
-    elif action == "panel_remove":
-        context.user_data["awaiting_id_for"] = "remove"
-        await query.message.reply_text("Отправь ID пользователя (число), чтобы удалить его из WhiteList:")
+    if not context.args:
+        users = "\n".join(str(u) for u in sorted(bot_state.whitelist))
+        await update.message.reply_text(f"📋 Список:\n{users}")
+        return
+    
+    action = context.args[0]
+    
+    if action == "add" and len(context.args) > 1:
+        try:
+            uid = int(context.args[1])
+            bot_state.add_whitelist(uid)
+            await update.message.reply_text(f"✅ Пользователь {uid} добавлен")
+        except ValueError:
+            await update.message.reply_text("❌ Неверный ID")
+    
+    elif action == "remove" and len(context.args) > 1:
+        try:
+            uid = int(context.args[1])
+            bot_state.remove_whitelist(uid)
+            await update.message.reply_text(f"✅ Пользователь {uid} удален")
+        except ValueError:
+            await update.message.reply_text("❌ Неверный ID")
+    
+    else:
+        await update.message.reply_text(
+            "/w - показать список\n"
+            "/w add [ID] - добавить\n"
+            "/w remove [ID] - удалить"
+        )
 
-# ============================================================
-# ОБРАБОТКА ОБЫЧНЫХ СООБЩЕНИЙ
-# ============================================================
-IMAGE_KEYWORDS = ["нарисуй", "нарисуйте", "рисуй", "draw", "картинка", "картинку", "фото", "изображение"]
-AI_TRIGGER_KEYWORDS = ["inai", "инэй", "инаи", "ии", "ai", "бот", "bot"]
+async def premium(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    text = """💎 Премиум возможности:
+✅ Создание видео
+✅ Создание музыки
+✅ Приоритет в обработке
 
-async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    if not update.message or not update.message.text:
-        return
+Дайте буст группе @chat_crx и получите премиум!"""
+    await update.message.reply_text(text)
 
-    chat_id = update.effective_chat.id
+async def help_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    text = """📚 Справка:
+
+/ask [текст] - Спросить ИИ
+/imagine [описание] - Создать фото
+/music [описание] - Создать музыку
+/video [описание] - Создать видео
+/premium - О премиум
+
+Напишите "ии [текст] - я отвечу в чате"""
+    await update.message.reply_text(text)
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
     user_id = update.effective_user.id
-    user_text = update.message.text.strip()
+    chat_id = update.effective_chat.id
+    text = update.message.text
     
-    # Сохраняем чат для ежечасной рассылки
-    track_chat(chat_id)
-
-    # 1. Логика Админ-панели (добавление/удаление ID)
-    if context.user_data.get("awaiting_id_for"):
-        action = context.user_data.pop("awaiting_id_for")
-        if user_text.isdigit() or (user_text.startswith('-') and user_text[1:].isdigit()):
-            target_id = int(user_text)
-            if action == "add":
-                if target_id not in db["whitelist"]:
-                    db["whitelist"].append(target_id)
-                    save_db(db)
-                await update.message.reply_text(f"✅ ID {target_id} добавлен в WhiteList.")
-            elif action == "remove":
-                if target_id in db["whitelist"]:
-                    db["whitelist"].remove(target_id)
-                    save_db(db)
-                await update.message.reply_text(f"🗑 ID {target_id} удален из WhiteList.")
-        else:
-            await update.message.reply_text("❌ Это не числовой ID. Операция отменена.")
+    if not bot_state.is_whitelisted(user_id):
+        logger.warning(f"❌ Неавторизованный пользователь {user_id}")
         return
-
-    # 2. Проверка прав (WhiteList) для работы с ИИ
-    is_whitelisted = user_id in db["whitelist"]
-    
-    # 3. Генерация изображений (С ПРОЦЕНТАМИ)
-    is_image_request = any(kw in user_text.lower() for kw in IMAGE_KEYWORDS)
-    if is_image_request:
-        if not is_whitelisted:
-            await update.message.reply_text("⛔️ Извини, но ты не в белом списке для создания фотографий.")
+    
+    # Если сообщение начинается с "ии"
+    if text.lower().startswith("ии"):
+        prompt = text[2:].strip()
+        if not prompt:
             return
-            
-        status_msg = await update.message.reply_text("⏳ Подключаюсь к холсту... [0%]")
-        await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.UPLOAD_PHOTO)
-        
-        await asyncio.sleep(1.5)
-        await status_msg.edit_text("🎨 Рисую контуры... [35%]")
         
-        await asyncio.sleep(1.5)
-        await status_msg.edit_text("🖌 Добавляю цвета и детали... [75%]")
+        # Добавить в очередь
+        if chat_id not in bot_state.request_queue:
+            bot_state.request_queue[chat_id] = deque()
         
-        image_bytes = await generate_image(user_text)
+        bot_state.request_queue[chat_id].append({"user_id": user_id, "prompt": prompt})
         
-        await status_msg.edit_text("✨ Завершаю обработку... [99%]")
-        await asyncio.sleep(1)
+        # Обработать запрос
+        await update.message.chat.send_action("typing")
         
-        await status_msg.delete()
-        if image_bytes:
-            await update.message.reply_photo(photo=io.BytesIO(image_bytes))
-        else:
-            await update.message.reply_text("❌ Упс, карандаш сломался. Не удалось нарисовать.")
-        return
-
-    # 4. Общение с Google Gemini (Текст)
-    is_reply_to_bot = update.message.reply_to_message and update.message.reply_to_message.from_user.id == context.bot.id
-    has_trigger = any(kw in user_text.lower() for kw in AI_TRIGGER_KEYWORDS)
-    is_private = update.message.chat.type == "private"
-
-    if is_private or is_reply_to_bot or has_trigger:
-        if not is_whitelisted:
-            # Молчим или говорим, что нет доступа. Выберем молчание, чтобы не спамить.
-            return
+        # Если это первый запрос, ответить сразу
+        if len(bot_state.request_queue[chat_id]) == 1:
+            response = await generate_text(prompt, user_id)
             
-        await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
-        
-        # Системный промпт интегрируем в запрос
-        prompt = (
-            "Ты — умный и дружелюбный ИИ в Telegram. Отвечай кратко и интересно.\n"
-            f"Запрос пользователя: {user_text}"
-        )
-        
-        response_text = await ask_gemini(prompt, is_announce=False)
-        
-        try:
-            await update.message.reply_text(response_text[:4000], parse_mode=ParseMode.MARKDOWN)
-        except Exception:
-            await update.message.reply_text(response_text[:4000])
-
-# ============================================================
-# ЕЖЕЧАСНАЯ РАССЫЛКА ВО ВСЕ ЧАТЫ
-# ============================================================
-async def hourly_announce_routine(app: Application):
-    await asyncio.sleep(60) # Пауза перед первым запуском
-    while True:
-        chats = db["known_chats"].copy()
-        if chats:
-            prompt = (
-                "Напиши короткое, забавное и приветливое сообщение для чата. "
-                "Скажи всем, что ты ИИ от Гугла, присутствуешь здесь, готов пообщаться и "
-                "что тебе очень хотелось бы по запросу нарисовать для них какое-нибудь классное фото! "
-                "Не пиши длинно, 2-3 предложения."
-            )
+            if len(response) > 4096:
+                for i in range(0, len(response), 4096):
+                    await update.message.reply_text(response[i:i+4096])
+            else:
+                await update.message.reply_text(response)
             
-            # Генерируем текст используя ключи для анонсов
-            announcement = await ask_gemini(prompt, is_announce=True)
+            bot_state.request_queue[chat_id].popleft()
+        else:
+            # Для второго и последующих - подождать 5-10 секунд
+            await asyncio.sleep(7)
             
-            # Если ключи не устали
-            if "Мои нейроны устали" not in announcement:
-                for chat_id in chats:
-                    try:
-                        await app.bot.send_message(chat_id=chat_id, text=f"🔔 *Минутка внимания!*\n\n{announcement}", parse_mode=ParseMode.MARKDOWN)
-                    except Exception as e:
-                        logger.error(f"Не удалось отправить анонс в чат {chat_id}: {e}")
-                    await asyncio.sleep(1) # Защита от флуда в Telegram API
+            if bot_state.request_queue[chat_id]:
+                item = bot_state.request_queue[chat_id].popleft()
+                response = await generate_text(item["prompt"], item["user_id"])
+                
+                if len(response) > 4096:
+                    for i in range(0, len(response), 4096):
+                        await update.message.reply_text(response[i:i+4096])
+                else:
+                    await update.message.reply_text(response)
         
-        await asyncio.sleep(3600) # Ждем 1 час
-
-# ============================================================
-# СТАНДАРТНЫЕ ФУНКЦИИ ВЕБХУКА И ЗАПУСКА
-# ============================================================
-async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.message.reply_text("👋 Привет! Я ИИ. Если ты в белом списке, я могу рисовать для тебя и общаться!")
-    track_chat(update.effective_chat.id)
-
-telegram_app: Optional[Application] = None
-
-async def health_check(request: web.Request) -> web.Response:
-    return web.Response(text="✅ Bot is running!", content_type="text/plain")
-
-async def webhook_handler(request: web.Request) -> web.Response:
-    global telegram_app
-    try:
-        raw_data = await request.json()
-        update_obj = Update.de_json(raw_data, telegram_app.bot)
-        await telegram_app.process_update(update_obj)
-        return web.Response(text="OK", status=200)
-    except Exception as e:
-        return web.Response(text="Error", status=500)
-
-async def build_web_app() -> web.Application:
-    app = web.Application()
-    app.router.add_get("/", health_check)
-    app.router.add_post(f"/webhook/{BOT_TOKEN}", webhook_handler)
-    return app
-
-async def main_async():
-    global telegram_app
-    cf_base_url = f"{CF_WORKER_URL.rstrip('/')}/bot"
-    cf_base_file_url = f"{CF_WORKER_URL.rstrip('/')}/file/bot"
-
-    telegram_app = (
-        Application.builder()
-        .token(BOT_TOKEN)
-        .base_url(cf_base_url)
-        .base_file_url(cf_base_file_url)
-        .build()
-    )
+        bot_state.last_activity = datetime.now()
 
-    telegram_app.add_handler(CommandHandler("start", start_command))
-    telegram_app.add_handler(CommandHandler("admin", admin_command))
-    telegram_app.add_handler(CommandHandler("panel", panel_command))
-    telegram_app.add_handler(CallbackQueryHandler(handle_panel_callback, pattern="^panel_"))
-    telegram_app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
-
-    await telegram_app.initialize()
+async def activity_monitor(context: ContextTypes.DEFAULT_TYPE):
+    """Мониторить активность каждые 30 минут"""
+    logger.info("🔍 Проверка активности")
     
-    webhook_full_url = f"{WEBHOOK_URL.rstrip('/')}/webhook/{BOT_TOKEN}"
-    await telegram_app.bot.set_webhook(url=webhook_full_url)
-    await telegram_app.start()
-
-    # Запускаем фоновую задачу ежечасных уведомлений
-    asyncio.create_task(hourly_announce_routine(telegram_app))
+    if (datetime.now() - bot_state.last_activity).seconds > ACTIVITY_CHECK_INTERVAL:
+        bot_state.is_sleeping = True
+        logger.info("😴 Бот спит - нет активности")
+    else:
+        bot_state.is_sleeping = False
 
-    web_app = await build_web_app()
-    runner = web.AppRunner(web_app)
-    await runner.setup()
-    site = web.TCPSite(runner, host="0.0.0.0", port=PORT)
-    await site.start()
+async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    logger.error(f"Ошибка: {context.error}")
 
-    print(f"✅ Бот запущен! Webhook: {webhook_full_url}")
-    try:
-        await asyncio.Event().wait()
-    finally:
-        await telegram_app.bot.delete_webhook()
-        await telegram_app.stop()
-        await telegram_app.shutdown()
-        await runner.cleanup()
+# ============= ГЛАВНАЯ ФУНКЦИЯ =============
+def main():
+    logger.info("🚀 Запуск Telegram AI Bot...")
+    
+    app = Application.builder().token(TG_BOT_TOKEN).build()
+    
+    # Команды
+    app.add_handler(CommandHandler("start", start))
+    app.add_handler(CommandHandler("ask", ask))
+    app.add_handler(CommandHandler("w", whitelist_cmd))
+    app.add_handler(CommandHandler("premium", premium))
+    app.add_handler(CommandHandler("help", help_cmd))
+    
+    # Обычные сообщения
+    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
+    
+    # Обработчик ошибок
+    app.add_error_handler(error_handler)
+    
+    # Job очередь для мониторинга
+    job_queue = app.job_queue
+    job_queue.run_repeating(activity_monitor, interval=ACTIVITY_CHECK_INTERVAL, first=60)
+    
+    logger.info("✅ Бот запущен. Ctrl+C для остановки.")
+    app.run_polling()
 
 if __name__ == "__main__":
-    asyncio.run(main_async())
+    main()