app.py

# =============================================================================
# ═══════════════════════════════════════════════════════════════════════════
# 🤖 KENZIE BOT — Заботливая администраторша ВКонтакте
# 📅 Март 2026 | 💕 Максимум милоты и безопасности!
# ═══════════════════════════════════════════════════════════════════════════
# =============================================================================

# ───────────────────────────────────────────────────────────────────────────
# 🔧 СЕКЦИЯ 1: ИМПОРТЫ БИБЛИОТЕК
# ───────────────────────────────────────────────────────────────────────────
import os
import re
import io
import time
import random
from collections import deque
from threading import Thread

# Веб-фреймворк
from fastapi import FastAPI, Request
from fastapi.responses import PlainTextResponse

# Нейросети
from huggingface_hub import InferenceClient
from openai import OpenAI as DeepSeekClient
from openai import OpenAI as OpenRouterClient
from openai import OpenAI as GroqClient
from openai import OpenAI as TogetherClient
import google.generativeai as genai

# ВКонтакте
import vk_api
from vk_api.upload import VkUpload

# Утилиты
import requests
from bs4 import BeautifulSoup

# ───────────────────────────────────────────────────────────────────────────
# ⚙️ СЕКЦИЯ 2: НАСТРОЙКИ И КОНФИГУРАЦИЯ
# ───────────────────────────────────────────────────────────────────────────
app = FastAPI(title="Kenzie Bot — заботливая хранительница чата 💕")

# 🔐 Ключи из переменных окружения (настраиваются в Settings → Secrets)
VK_TOKEN = os.getenv("VK_TOKEN")              # Токен бота ВК
VK_SECRET = os.getenv("VK_SECRET")            # Секрет для вебхука
VK_CONFIRM = os.getenv("VK_CONFIRM")          # Код подтверждения ВК
BOT_ID = int(os.getenv("BOT_ID", 0)) or None  # ID бота

# 🔑 API-ключи нейросетей (хотя бы один должен быть настроен!)
HF_TOKEN = os.getenv("HF_TOKEN")              # Hugging Face (ОБЯЗАТЕЛЬНО!)
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")  # Google Gemini
GROQ_API_KEY = os.getenv("GROQ_API_KEY")      # Groq (рекомендуется!)
OPENROUTER_KEY = os.getenv("OPENROUTER_KEY")  # OpenRouter
DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
TOGETHER_API_KEY = os.getenv("TOGETHER_API_KEY")
COHERE_API_KEY = os.getenv("COHERE_API_KEY")
# ☁️ Cloudflare Workers AI (для генерации картинок)
CLOUDFLARE_ACCOUNT_ID = os.getenv("CLOUDFLARE_ACCOUNT_ID")
CLOUDFLARE_API_TOKEN = os.getenv("CLOUDFLARE_API_TOKEN")

# 🌤️ Погода
WEATHER_API_KEY = os.getenv("WEATHER_API_KEY")

# 🤖 Настройки бота
BOT_NAMES = ["бот", "эй", "кензи", "ии", "kenzie", "кензюша", "кензечка"]  # Как зовут бота
DRAW_COMMAND = "!картинка"  # Команда для генерации картинок
AI_MODE_ENABLED = True       # Умный режим включён по умолчанию

# 🚫 Запрещённые слова для модерации
FORBIDDEN_WORDS = ["мат1", "мат2", "оскорбление1", "оскорбление2"]

# 📬 Авто-посты из сообщества ВК
AUTO_POST_GROUP_ID = -229127616  # ID сообщества-источника
auto_post_enabled = {}            # peer_id → True/False (включены ли автопосты)

# ───────────────────────────────────────────────────────────────────────────
# 🛡️ ДЕДУПЛИКАЦИЯ СООБЩЕНИЙ (УЛУЧШЕННАЯ)
# ───────────────────────────────────────────────────────────────────────────
from collections import OrderedDict
import hashlib

processed_messages = OrderedDict()  # hash → timestamp
MAX_PROCESSED = 2000  # Увеличили хранилище

def get_message_hash(peer_id: int, from_id: int, text: str, msg_id: int) -> str:
    """Создаёт уникальный хеш сообщения"""
    content = f"{peer_id}_{from_id}_{msg_id}_{text.strip()[:500]}"
    return hashlib.md5(content.encode()).hexdigest()

def is_message_processed(peer_id: int, from_id: int, text: str, msg_id: int) -> bool:
    """Проверяет, обрабатывалось ли уже это сообщение"""
    key = get_message_hash(peer_id, from_id, text, msg_id)
    now = time.time()
    
    # Очищаем старые записи (> 120 секунд)
    for k in list(processed_messages.keys()):
        if processed_messages[k] < now - 120:
            processed_messages.pop(k)
    
    if key in processed_messages:
        return True
    
    processed_messages[key] = now
    
    # Ограничиваем размер словаря
    if len(processed_messages) > MAX_PROCESSED:
        processed_messages.popitem(last=False)
    
    return False

# ───────────────────────────────────────────────────────────────────────────
# 🔗 СЕКЦИЯ 3: ИНИЦИАЛИЗАЦИЯ КЛИЕНТОВ НЕЙРОСЕТЕЙ
# ───────────────────────────────────────────────────────────────────────────

# 🤗 Hugging Face клиент
client_hf = None
if HF_TOKEN:
    try:
        from huggingface_hub import InferenceClient
        client_hf = InferenceClient(
            token=HF_TOKEN,
            base_url="https://router.huggingface.co"  # ← НОВЫЙ ENDPOINT!
        )
        print("✅ HuggingFace подключён (router)")
    except Exception as e:
        print(f"⚠️ HF ошибка: {e}")

# ─── Gemini клиент — ИСПРАВЛЕНО ─────────────────────────────────
gemini_model = None
if GEMINI_API_KEY:
    try:
        genai.configure(api_key=GEMINI_API_KEY)
        # ✅ Только рабочие модели
        for model_name in [
            'gemini-1.5-flash',      # Самый стабильный
            'gemini-1.5-flash-8b',   # Альтернатива
        ]:
            try:
                gemini_model = genai.GenerativeModel(model_name)
                test_response = gemini_model.generate_content(
                    "test", 
                    generation_config=genai.types.GenerationConfig(max_output_tokens=10)
                )
                if test_response.text:
                    print(f"✅ Gemini подключён ({model_name})")
                    break
            except Exception as e:
                print(f"⚠️ Gemini {model_name}: {e}")
                continue
        if not gemini_model:
            print("❌ Gemini: ни одна модель не доступна")
    except Exception as e:
        print(f"❌ Gemini ошибка инициализации: {e}")

# 🌐 OpenRouter клиент
client_or = None
if OPENROUTER_KEY:
    try:
        client_or = OpenRouterClient(
            base_url="https://openrouter.ai/api/v1",
            api_key=OPENROUTER_KEY
        )
        print("✅ OpenRouter подключён")
    except Exception as e:
        print(f"⚠️ OpenRouter ошибка: {e}")

# ⚡ Groq клиент (очень быстрый!)
groq_client = None
if GROQ_API_KEY:
    try:
        groq_client = GroqClient(
            base_url="https://api.groq.com/openai/v1",
            api_key=GROQ_API_KEY
        )
        print("✅ Groq подключён")
    except Exception as e:
        print(f"⚠️ Groq ошибка: {e}")

# 🧠 Together AI клиент
together_client = None
if TOGETHER_API_KEY:
    try:
        together_client = TogetherClient(
            base_url="https://api.together.xyz/v1",
            api_key=TOGETHER_API_KEY
        )
        print("✅ Together подключён")
    except Exception as e:
        print(f"⚠️ Together ошибка: {e}")

# 🔹 Cohere клиент
cohere_client = None
if COHERE_API_KEY:
    try:
        import cohere
        cohere_client = cohere.Client(COHERE_API_KEY)
        print("✅ Cohere подключён")
    except Exception as e:
        print(f"⚠️ Cohere ошибка: {e}")

# 💬 ВКонтакте клиент
vk_session = vk_api.VkApi(token=VK_TOKEN)
vk = vk_session.get_api()
upload = VkUpload(vk_session)

# 🧠 Память чатов для контекста ИИ
chat_memory = {}

# ───────────────────────────────────────────────────────────────────────────
# 🧠 СЕКЦИЯ 4: СПИСКИ МОДЕЛЕЙ НЕЙРОСЕТЕЙ
# ───────────────────────────────────────────────────────────────────────────

# 🔤 Модели для текста на Hugging Face (бесплатные)
LLM_HF = [
    "Qwen/Qwen2.5-7B-Instruct",
    "mistralai/Mistral-7B-Instruct-v0.3", 
    "meta-llama/Llama-3.2-3B-Instruct",
    "microsoft/Phi-3-mini-4k-instruct",
    "google/gemma-2-9b-it",
]

# 🌐 Бесплатные модели OpenRouter — ИСПРАВЛЕНО
OPENROUTER_MODELS = [  
    "deepseek/deepseek-chat-v3",
    "deepseek/deepseek-r1",
    "qwen/qwen3",
    "meta-llama/llama-4-maverick",
    "openrouter",
    "meta-llama/llama-3.2-3b-instruct", # ✅ Рабочая
    "google/gemma-2-9b-it",             # ✅ Рабочая
    "qwen/qwen-2.5-7b-instruct",        # ✅ Рабочая
    "mistralai/mistral-7b-instruct",    # ✅ Рабочая
    "meta-llama/llama-3.1-8b-instruct", # ✅ Рабочая
]

# ⚡ Модели Groq
GROQ_MODELS = [
    "llama-3.1-8b-instant",
    "llama-3.2-3b-preview", 
    "gemma2-9b-it",
]

# 🚀 Модели Together AI
TOGETHER_MODELS = [
    "meta-llama/Llama-3.2-3B-Instruct-Turbo",
    "Qwen/Qwen2.5-7B-Instruct-Turbo",
]

# 🎨 Модели для генерации картинок
# Формат: ("model_name", num_inference_steps, guidance_scale)
IMG_MODELS = [
    ("black-forest-labs/FLUX.1-schnell", 6, 0.0),           # ⚡ Быстрая, низкий guidance
    ("ByteDance/SDXL-Lightning", 4, 0.0),                   # 🚀 Мгновенная генерация
    ("ByteDance/Hyper-SD", 4, 0.0),                         # ⚡ Hyper-SD технология
    ("SG161222/RealVisXL_V4.0", 28, 7.5),                   # 📷 Фотореализм
    ("Lykon/dreamshaper-8", 28, 7.5),                       # 🎨 Универсальная
    ("stablediffusionapi/animagine-xl-3.1", 28, 7.0),       # 🎌 Аниме-стиль
    ("prompthero/openjourney-v4", 30, 7.0),                 # 🖼️ Стиль Midjourney
    ("stabilityai/stable-diffusion-xl-base-1.0", 28, 7.5),  # 🏆 Классика SDXL
]
# 🔍 Проверка структуры
for i, cfg in enumerate(IMG_MODELS):
    if not isinstance(cfg, tuple) or len(cfg) != 3:
        print(f"⚠️ IMG_MODELS[{i}] ошибка: {cfg}")
    else:
        print(f"✅ [{i}] {cfg[0]} — шаги: {cfg[1]}, guidance: {cfg[2]}")
        
# ───────────────────────────────────────────────────────────────────────────
# 💬 СЕКЦИЯ 5: СПЕЦИАЛЬНЫЕ ОТВЕТЫ И КОНТЕНТ
# ───────────────────────────────────────────────────────────────────────────

# 😂 Ответы на "да"/"нет"
special_commands = {
    "да": ["Пизда! 😂😂😂", "Пиздец как да! 😂😂", "Манда! 😂😂"],
    "нет": ["Пид@ра ответ! 😂😂😂", "Пид@раааа же ответ! 😂😂😂"],
}

# 🎬 Видео-вложения по ключевым словам
video_attachments = {
    "скрытая психология": "video-226582510_456239078",
    "деньги": "video-226582510_456239088",
    "агент": "clip-223511903_456239086",
}

# 😄 Анекдоты для команды !анекдот
anekdots = [
    "Штирлиц шел по лесу и увидел голубые ели. Он присмотрелся: ели не только голубые, но и пили 😂",
    "— Мама, я больше не пойду в школу! — Почему? — Петров опять будет бить учебником... — Нет, сынок, ты должен идти, ты же директор! 😂",
    "Купил мужик шляпу, а она ему как раз 😂",
    "— Доктор, меня все игнорируют! — Следующий! 😂",
]

# 💭 Цитаты для команды !цитата
quotes = [
    "«Будь собой, остальные роли уже заняты» — Оскар Уайльд",
    "«Счастье — это не пункт назначения, а способ путешествия» — неизвестный",
]

# 💕 СЕКЦИЯ 6: RP-ШАБЛОНЫ (ПОЦЕЛУИ, ОБЪЯТИЯ, ПОГЛАЖИВАНИЯ...)
# ───────────────────────────────────────────────────────────────────────────

# 💋 Поцелуи
KISS_TEMPLATES = [
    "{target}, лови нежный поцелуй от {sender} в щёчку… так мило, что сердце тает 💋❤️",
    "{sender} целует {target} страстно в губы… весь мир вокруг исчезает 😘🔥",
    "{target}, {sender} дарит тебе сладкий поцелуй в носик… муа! ❤️😚",
    "{sender} украдкой целует {target}… наш маленький романтический секрет 💕",
    "{target}, {sender} нежно целует тебя в лобик, полный любви и заботы ❤️🤗",
    "{sender} посылает {target} тысячу воздушных поцелуев… чувствуешь? 😘💨",
    "{target}, лови поцелуй от {sender}… самый тёплый и нежный 😽✨",
    "{sender} целует {target} в ушко и шепчет слова любви ❤️💋",
    "{target}, {sender} целует тебя в щёчку… таю от твоей улыбки 💕",
    "{sender} целует {target} долго и романтично… ♡∞"
]
KISS_ATTACHMENTS = ["video-226582510_456239125", "video-226582510_456239126"]

# 🤗 Объятия
HUG_TEMPLATES = [
    "{target}, {sender} крепко обнимает тебя… не отпустит никогда 🤗❤️",
    "{sender} нежно прижимает {target} к себе: ты в надёжных руках 🤗",
    "{target}, получай тёплые объятия от {sender}… грею твою душу ❄️🤗",
    "{sender} обнимает {target} с разбегу… ты мой самый родной ❤️",
    "{target}, {sender} обнимает тебя сильно… слышишь биение сердца? 💓🤗",
    "{sender} мысленно обнимает {target}: чувствуешь тепло? 🤗✨",
    "{target}, {sender} укутывает тебя в объятия: всё будет хорошо ❤️",
    "{sender} обнимает {target} и качает: ты мой любимый ❤️",
    "{target}, лови бесконечные объятия от {sender}… ❤️∞🤗",
    "{sender} обнимает {target}: ты — моё счастье ❤️"
]
HUG_ATTACHMENTS = ["video-226582510_456239130", "video-226582510_456239131"]

# 👋 Поглаживания
PAT_TEMPLATES = [
    "{target}, {sender} нежно гладит тебя по головке… такой милый ❤️🐱",
    "{sender} ласково проводит рукой по волосам {target}… всё хорошо 🤗",
    "{target}, получай нежные поглаживания от {sender}… мурашки 💕",
    "{sender} гладит {target} по щёчке: ты у меня самый хороший ❤️✨",
    "{target}, {sender} чешет тебе за ушком: расслабься, котик 😽",
    "{sender} гладит {target} по спинке: я рядом ❤️🤗",
    "{target}, {sender} проводит рукой по волосам: ты самый-самый ❤️",
    "{sender} нежно гладит {target} по ладошке: держу тебя 🤲💕",
    "{target}, лови ласковые поглаживания от {sender} ❤️🐾",
    "{sender} гладит {target} по голове: мой любимый ❤️"
]
PAT_ATTACHMENTS = ["video-226582510_456239132", "video-226582510_456239133"]

# 👋 Приветствия
GREET_TEMPLATES = [
    "{target}, приветик от {sender}! Обнимаю крепко ❤️🤗",
    "{sender} машет {target}: хай, солнышко! Воздушный поцелуй 😘✨",
    "{target}, привет, мой хороший! {sender} соскучилась ❤️",
    "{sender} прибегает к {target} с обнимашками: привеет, зайчик! 🤗🐰",
    "{target}, хай! {sender} шлёт сердечки 💕",
    "{sender} нежно обнимает {target}: привет, любимый ❤️",
    "{target}, привет от {sender}! Лови улыбку 😊",
    "{sender} гладит {target}: хай, солнышко! Ты сделал день лучше ❤️",
    "{target}, привеет! {sender} шлёт тепло и любовь 💕🤗",
    "{sender} целует {target} в щёчку: привет, самый-самый! ❤️😚"
]
GREET_ATTACHMENTS = [
    "video-226582510_456239134", "video-226582510_456239135", "photo-226582510_457239004",
    "video-226582510_456239140", "video-226582510_456239141", "photo-226582510_457239008",
    "video-226582510_456239142", "photo-226582510_457239009", "video-226582510_456239143",
    "photo-226582510_457239010"
]

# ☀️ Доброе утро
MORNING_TEMPLATES = [
    "{target}, доброе утро! {sender} посылает тёплые лучики и поцелуй ❤️☀️😘",
    "{sender} обнимает {target}: утречко доброе, солнышко! 🤗",
    "{target}, доброе утречко! {sender} наливает кофе ☕❤️",
    "{sender} гладит {target} по щёчке: просыпайся, солнышко! ❤️✨",
    "{target}, утро доброе! {sender} думает о тебе 💕",
    "{sender} целует {target} в носик: доброе утро, зайчик! 😚🐰",
    "{target}, просыпайся! {sender} желает волшебного дня ❤️😊",
    "{sender} прижимается к {target}: утречко доброе, человек мой родной! 💕",
    "{target}, доброе утро! {sender} шлёт звёздочки ✨❤️",
    "{sender} шепчет {target}: утро доброе, зая моя! ❤️💋"
]
MORNING_ATTACHMENTS = ["video-236299866_456239017", "photo-236299866_457239073", "photo-236299866_457239072",
    "photo-236299866_457239074", "photo-236299866_457239077", "photo-236299866_457239078",
    "photo-236299866_457239079", "photo-236299866_457239080", "photo-236299866_457239081",
    "photo-236299866_457239082", "photo-236299866_457239083"]

# 🌙 Спокойной ночи
GOODNIGHT_TEMPLATES = [
    "{target}, спокойной ночи… {sender} укрывает пледом и целует ❤️🌙",
    "{sender} обнимает {target} на ночь: споки, солнышко! 🤗💤",
    "{target}, сладких снов! {sender} шепчет нежные слова ❤️✨",
    "{sender} гладит {target} по головке: спокойной ночи, хороших снов! ❤️🤗",
    "{target}, споки-поки! {sender} желает красивых снов 🌙",
    "{sender} целует {target} в лобик: спокойной ночи, зайчик! 😚🐰",
    "{target}, засыпай! {sender} держит за ручку во сне ❤️🤲",
    "{sender} прижимается к {target}: споки, солнышко, хороших снов! 💕💤",
    "{target}, спокойной ночи! {sender} посылает звёздочки и желает хороших снов ✨❤️",
    "{sender} шепчет {target}: сладких снов, спи солнышко! ❤️💋"
]
GOODNIGHT_ATTACHMENTS = [
    "photo-236299866_457239092", 
    "photo-236299866_457239091", 
    "photo-226582510_457239006",
    "photo-236299866_457239090", 
    "photo-236299866_457239089", 
    "photo-236299866_457239088",
    "photo-236299866_457239087", 
    "photo-236299866_457239086", 
    "photo-236299866_457239016",
    "photo-236299866_457239085", 
    "photo-236299866_457239084", 
    "photo-236299866_457239076",
    "photo-236299866_457239075"
]

# 💊 Выздоравливай
GET_WELL_TEMPLATES = [
    "{target}, {sender} желает тебе скорейшего выздоровления! 💊❤️ Не болей, пожалуйста!",
    "{sender} обнимает {target} и шепчет: поправляйся скорее, я скучаю! 🤗💕",
    "{target}, {sender} шлёт тебе целебную энергию! Выздоравливай! ✨💊",
    "{sender} заботливо ухаживает за {target}: отдыхай и набирайся сил! 🤗💕",
    "{target}, {sender} варит тебе горячий чай с мёдом! Пей и выздоравливай! ☕🍯",
    "{sender} гладит {target} по головке: всё будет хорошо, поправляйся! ❤️💊",
    "{target}, {sender} желает тебе крепкого здоровья! Не болей! 💪💕",
    "{sender} укутывает {target} в тёплый плед: лечись и отдыхай! 🛏️🤗",
    "{target}, {sender} шлёт тебе витаминки и любовь! Выздоравливай! 💊💕",
    "{sender} целует {target} в лобик: поправляйся скорее, мой хороший! 😚💕"
]
GET_WELL_ATTACHMENTS = [
    "photo-236299866_457239102",
    "photo-236299866_457239101",
    "photo-236299866_457239100",
    "photo-236299866_457239099",
    "photo-236299866_457239098",
    "photo-236299866_457239097",
    "photo-236299866_457239096",
    "photo-236299866_457239095",
    "photo-236299866_457239094",
    "photo-236299866_457239093"
]

# 🎄 С Новым Годом
NEWYEAR_TEMPLATES = [
    "{target}, {sender} поздравляет тебя с Новым Годом! 🎄❤️ Пусть этот год будет волшебным!",
    "{sender} обнимает {target} и шепчет: с Новым Годом, любимый! 🎉❤️✨",
    "{target}, {sender} желает тебе счастья в Новом Году! 🥂💕 Пусть сбудутся все мечты!",
    "{sender} целует {target} в щёчку: с Новым Годом, родной! 🎄😘❤️",
    "{target}, {sender} дарит тебе новогоднее чудо! 🎁✨ С праздником, дорогой!",
    "{sender} поднимает бокал за {target}: с Новым Годом! 🥂🎉 Пусть будет удача!",
    "{target}, {sender} загадал желание под бой курантов… чтобы ты был счастлив! 🎄💕",
    "{sender} укутывает {target} в новогодний плед: с праздником, милый! ❄️🤗❤️",
    "{target}, {sender} шлёт тебе новогодние искорки! ✨🎄 С Новым Годом, любимый!",
    "{sender} прижимает {target} к себе: с Новым Годом, моё счастье! 🎉❤️🥂"
]
NEWYEAR_ATTACHMENTS = [
    "photo-236299866_457239105", 
    "photo-236299866_457239104",
    "photo-236299866_457239103",
    "photo-236299866_457239104",
    "photo-236299866_457239103",
    "photo-236299866_457239104",
    "photo-236299866_457239103",
    "photo-236299866_457239104",
    "photo-236299866_457239105"
]

# 🎂 С Днём Рождения
BIRTHDAY_TEMPLATES = [
    "{target}, {sender} поздравляет с Днём Рождения! 🎂❤️ Пусть каждый день будет праздником!",
    "{sender} обнимает {target}: с Днём Рождения, родной! 🎉💕 Ты — чудо!",
    "{target}, {sender} желает тебе море счастья! 🌊🎂 С Днём Рождения!",
    "{sender} целует {target}: с Днём Рождения, любимый! 😘🎁❤️",
    "{target}, {sender} дарит тебе улыбку в этот особенный день! 🎂✨ Будь счастлив!",
    "{sender} поднимает бокал за {target}: с Днём Рождения! 🥂🎉 За тебя!",
    "{target}, {sender} загадал желание для тебя… пусть сбудется! 🕯️💕",
    "{sender} прижимает {target}: с Днём Рождения, моё солнышко! ☀️🎂❤️",
    "{target}, {sender} шлёт праздничные искорки! ✨🎂 С Днём Рождения!",
    "{sender} шепчет {target}: с Днём Рождения, радость моя! 🎉💕🎂"
]
BIRTHDAY_ATTACHMENTS = ["photo-236299866_457239106", "photo-236299866_457239107", "photo-236299866_457239108",
    "photo-236299866_457239109", "photo-236299866_457239111", "photo-236299866_457239112",
    "photo-236299866_457239113", "photo-236299866_457239114", "photo-236299866_457239115",
    "photo-236299866_457239114"]

# 💖 Любовь
LOVE_TEMPLATES = [
    "{target}, {sender} любит тебя… больше слов ❤️💕",
    "{sender} шепчет {target}: люблю… бесконечно 💖✨",
    "{target}, {sender} дарит тебе своё сердце 💝 Оно твоё!",
    "{sender} обнимает {target}: ты — моя любовь 🤗❤️",
    "{target}, {sender} с тобой… и это любовь 💕🌟",
    "{sender} целует {target}: люблю каждой клеточкой 😘❤️",
    "{target}, {sender} дышит тобой… люблю 💖🌸",
    "{sender} прижимает {target}: ты — моё всё ❤️∞",
    "{target}, {sender} посвящает тебе эти строки… люблю 💕📝",
    "{sender} смотрит на {target}: вот оно… счастье ❤️💫"
]
LOVE_ATTACHMENTS = ["photo-226582510_457239020"]

# 🤝 Вместе
TOGETHER_TEMPLATES = [
    "{target}, {sender} хочет быть рядом… вместе мы сила 🤝❤️",
    "{sender} обнимает {target}: вместе — навсегда 🤗💕",
    "{target}, {sender} с тобой… и это главное 💖✨",
    "{sender} держит {target} за руку: вместе 💕🤲",
    "{target}, {sender} делит этот момент с тобой… вместе 🌟❤️",
    "{sender} прижимается к {target}: вместе — тепло 🤗💕",
    "{target}, {sender} рядом… всегда 💖⏳",
    "{sender} смотрит на {target}: вместе — счастье 👀❤️",
    "{target}, {sender} выбирает тебя… вместе 💕🎯",
    "{sender} шепчет {target}: вместе… навсегда 💖∞"
]
TOGETHER_ATTACHMENTS = ["photo-226582510_457239030"]

# 🍽️ Еда
FOOD_TEMPLATES = [
    "{target}, {sender} угощает тебя вкусняшками! 🍽️❤️ Приятного аппетита!",
    "{sender} готовит для {target}: кушай, родной! 🍳💕",
    "{target}, {sender} налил тебе напиток! 🥤✨ освежайся!",
    "{sender} кормит {target} с ложечки: открой ротик! 🥄😋❤️",
    "{target}, {sender} приготовил сюрприз! 🎁🍽️ Пробуй!",
    "{sender} делится едой с {target}: вместе вкуснее! 🍕💕",
    "{target}, {sender} заказал тебе доставку! 🚗🍔 Кушай!",
    "{sender} предлагает {target} перекусить: голодный? 🥐☕❤️",
    "{target}, {sender} испёк для тебя! 🍰💕 Попробуй!",
    "{sender} угощает {target}: это с любовью! 🍫❤️✨"
]
FOOD_ATTACHMENTS = ["photo-226582510_457239040"]

# 🌸 Цветы
FLOWERS_TEMPLATES = [
    "{target}, {sender} дарит тебе цветы! 🌸❤️ Ты прекрасен!",
    "{sender} вручает букет {target}: это для тебя! 💐💕",
    "{target}, {sender} собрал цветы специально! 🌹✨ Для тебя!",
    "{sender} осыпает {target} лепестками: лови! 🌺😘❤️",
    "{target}, {sender} принёс целый сад! 🌻💕 Нюхай!",
    "{sender} плетёт венок для {target}: надень! 🌼👑❤️",
    "{target}, {sender} дарит розу! 🌹💖 Одна — для единственного!",
    "{sender} показывает {target} цветы: красиво? 🌷✨❤️",
    "{target}, {sender} вырастил для тебя! 🌱🌺 С любовью!",
    "{sender} шепчет {target}: как эти цветы… ты прекрасен! 💐💕"
]
FLOWERS_ATTACHMENTS = ["photo-226582510_457239050"]

# 🎁 Подарки
GIFT_TEMPLATES = [
    "{target}, {sender} дарит тебе подарок! 🎁❤️ Открывай!",
    "{sender} вручает коробочку {target}: это тебе! 💝💕",
    "{target}, {sender} выбирал с любовью! 🎀✨ Надеюсь, понравится!",
    "{sender} прячет сюрприз для {target}: угадай что? 🎁😏❤️",
    "{target}, {sender} копил на это! 💰🎁 Для тебя!",
    "{sender} заворачивает подарок {target}: с бантиком! 🎀💕❤️",
    "{target}, {sender} нашёл идеальное! 🌟🎁 Твоё!",
    "{sender} показывает {target} подарок: нравится? 👀✨❤️",
    "{target}, {sender} сделал своими руками! 🖐️🎁 С душой!",
    "{sender} шепчет {target}: это символ… нашей связи 💝💕"
]
GIFT_ATTACHMENTS = ["photo-226582510_457239060"]

# 🚶 Прогулка
WALK_TEMPLATES = [
    "{target}, {sender} зовёт на прогулку! 🚶‍♀️❤️ Пойдём вместе?",
    "{sender} берёт {target} за руку: гуляем! 🤝🌳💕",
    "{target}, {sender} показывает красивое место! 🌅✨ Смотри!",
    "{sender} ведёт {target} по тропинке: доверяй мне! 🛤️🤗❤️",
    "{target}, {sender} любит гулять с тобой! 🌲💕 Свежо!",
    "{sender} останавливается с {target}: посмотри на вид! 👀🏔️✨",
    "{target}, {sender} нашёл поляну! 🌸🌿 Отдохнём?",
    "{sender} предлагает {target} сесть: устали? 🪑☕❤️",
    "{target}, {sender} запомнит этот момент! 📸💕 Навсегда!",
    "{sender} шепчет {target}: прогулка с тобой — счастье 🚶‍♀️💖"
]
WALK_ATTACHMENTS = ["photo-226582510_457239070"]

# 💃 Танец
DANCE_TEMPLATES = [
    "{target}, {sender} приглашает на танец! 💃❤️ Потанцуем?",
    "{sender} кружит {target} в танце: лови ритм! 🕺✨💕",
    "{target}, {sender} танцует для тебя! 🎵💃 Смотри!",
    "{sender} берёт {target} в объятия: медленный танец? 🎶🤗❤️",
    "{target}, {sender} ведёт в танце: доверяй! 💫🕺💕",
    "{sender} кружится с {target}: мы — одно целое! 🌪️💖✨",
    "{target}, {sender} любит танцевать с тобой! 🎵💕 Ещё!",
    "{sender} предлагает {target} вальс: раз-два-три! 🎼👯❤️",
    "{target}, {sender} запомнит этот танец! 💃📸 Навсегда!",
    "{sender} шепчет {target}: танец — как наша любовь 🕺💖∞"
]
DANCE_ATTACHMENTS = ["photo-226582510_457239080"]

# 🍺 Пиво
BEER_TEMPLATES = [
    "{sender} протягивает {target} запотевший бокал: «Держи, друг, это то, что нужно после долгого дня!» 🍺",
    "{sender} звонко чокается кружкой с {target}: «За нас! Чтобы пена была высокой, а проблемы — низкими!» 🍻",
    "{sender} залпом осушает бокал вместе с {target}: «Эх, хорошо пошла! Повторим?» 🍺",
    "{sender} подмигивает {target}: «Слышь, по пивасику не сгоняем? Я угощаю!» 🍻",
    "{sender} слегка покачиваясь, обнимает {target}: «Ты... ты лучший друг... на свете...» 🥴",
    "{sender} делит последнюю бутылку с {target}: «Поровну, честно слово, я даже меньше налил!» 🍺",
    "{sender} морщится, глядя на {target}: «Ох, голова гудит... Больше ни капли, только воду!» 🤕",
    "{sender} аккуратно наливает пенный напиток {target}: «Смотри, какая янтарная красота, просто загляденье!» 🍺",
    "{sender} поднимает бокал перед {target}: «Чтобы у нас всё было и ничего за это не было!» 🍻",
    "{sender} хитро улыбается {target}: «С меня сегодня только безалкогольное, я за рулем, но за компанию посидю!» 🚗🍺"
]
BEER_ATTACHMENTS = [
    "photo-236299866_457239140",
    "photo-236299866_457239141",
    "photo-236299866_457239143",
    "photo-236299866_457239146",
    "photo-236299866_457239147",
    "photo-236299866_457239144",
    "photo-236299866_457239148",
    "photo-236299866_457239149",
    "photo-236299866_457239150",
    "photo-236299866_457239142"
]

# ✨ Базовые / универсальные
BASE_TEMPLATES = [
    "{target}, {sender} дарит тебе этот момент… пусть он останется в сердце ❤️✨",
    "{sender} нежно обращается к {target}: ты делаешь мир лучше 💕🌟",
    "{target}, {sender} хочет разделить это с тобой… вместе мы сильнее 🤝❤️",
    "{sender} посвящает это {target}: ты — моё вдохновение 💫💕",
    "{target}, {sender} рядом… всегда 💖🤝",
    "{sender} обнимает {target} в этом моменте… тепло и уютно 🫂❤️",
    "{target}, {sender} с тобой… и это главное 💕✨",
    "{sender} дарит {target} свои эмоции… лови 💝🌸",
    "{target}, {sender} ценит каждое мгновение с тобой ❤️⏳",
    "{sender} шепчет {target}: ты — чудо 💫💕"
]
BASE_ATTACHMENTS = ["photo-226582510_457239001"]

# ───────────────────────────────────────────────────────────────────────────
# 📋 СЕКЦИЯ 7: СПИСОК ВСЕХ RP-КОМАНД
# ───────────────────────────────────────────────────────────────────────────

RP_COMMANDS = {
    # 💋 Поцелуи
    "поцелуй": "kiss", "kiss": "kiss", "целую": "kiss", "чмок": "kiss",
    # 🤗 Объятия
    "обнять": "hug", "обнимаю": "hug", "hug": "hug", "обнимашки": "hug",
    # 👋 Поглаживания
    "погладить": "pat", "pat": "pat", "погладь": "pat",
    # 👋 Приветствия
    "привет": "greet", "здравствуйте": "greet", "хай": "greet", "привеет": "greet",
    # ☀️ Доброе утро
    "доброе утро": "morning", "утро": "morning", "утречко": "morning",
    # 🌙 Спокойной ночи
    "спокойной ночи": "goodnight", "спи": "goodnight", "споки": "goodnight",
    # 💊 Выздоравливай
    "не болей": "getwell", "выздоравливай": "getwell",
    # 🎄 Новый год
    "с новым годом": "newyear", "с нг": "newyear", "нг": "newyear",
    # 🎂 День рождения
    "с днем рождения": "birthday", "с др": "birthday",
    # 💖 Любовь
    "love": "love", "люблю": "love", "лав": "love",
    # 🤝 Вместе
    "вместе": "together", "я рядом": "together",
    # 🍽️ Еда
    "завтрак": "food", "обед": "food", "ужин": "food", "кофе": "food", "чай": "food",
    # 🌸 Цветы
    "цветы": "flowers", "букет": "flowers", "розы": "flowers",
    # 🎁 Подарки
    "подарок": "gift", "подарок ей": "gift", "подарок ему": "gift",
    # 🚶 Прогулка
    "прогулка": "walk", "к морю": "walk", "на море": "walk",
    # 💃 Танец
    "танец": "dance", "танцуем": "dance",
    # 🍺 Пиво
    "пиво": "beer", "пивко": "beer", "пивасик": "beer", "beer": "beer",
    # ✨ Базовые
    "на ручки": "base", "прижать": "base",
}

def generate_rp_list_text():
    """Генерирует текст со списком всех RP-команд"""
    lines = [
        "📝 𝗦𝗽исок RP команд бота Kenzie 💕",
        "",
        "Милый(ая), вот все волшебные команды для нашего романтического общения ✨",
        "",
        "Используй их, чтобы выразить свои чувства, отправить нежность или просто порадовать близкого человека 💖",
        "",
        "Как использовать:",
        "• Ответь на сообщение + напиши команду",
        "• Или напиши: команда @id123456",
        "• В ЛС команда отправится тебе 💕",
        "",
        "─── ⋆⋅☆⋅⋆ ───"
    ]
    
    # Группируем команды по категориям
    categories = {}
    for cmd, cat in RP_COMMANDS.items():
        if cat not in categories:
            categories[cat] = []
        categories[cat].append(cmd)
    
    count = 1
    for cat, cmds in sorted(categories.items()):
        lines.append(f"\n💖 {cat.upper()} ({len(cmds)}):")
        for cmd in sorted(cmds)[:20]:  # Показываем первые 20 команд категории
            lines.append(f"{count}) {cmd}")
            count += 1
        if len(cmds) > 20:
            lines.append(f"... и ещё {len(cmds) - 20} команд")
    
    lines.extend([
        "",
        "─── ⋆⋅☆⋅⋆ ───",
        "",
        f"💌 Всего команд: {len(RP_COMMANDS)}",
        "💌 Выбирай любую и дари любовь! ❤️"
    ])
    return "\n".join(lines)

RP_LIST_TEXT = generate_rp_list_text()

# ───────────────────────────────────────────────────────────────────────────
# 🔧 СЕКЦИЯ 8: ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
# ───────────────────────────────────────────────────────────────────────────

def send_msg(peer_id: int, text: str, reply_to: int = None, attach: str = None, retries=3):
    """Отправляет сообщение ВКонтакте с повторными попытками"""
    for attempt in range(retries):
        try:
            params = {
                "peer_id": peer_id,
                "message": text,
                "random_id": int(time.time() * 1000) + attempt  # Уникальный для каждой попытки
            }
            if reply_to:
                params["reply_to"] = reply_to
            if attach:
                params["attachment"] = attach
            vk.messages.send(**params)
            print(f"[SEND] ✅ peer_id={peer_id}, attach={attach}")
            return True
        except Exception as e:
            print(f"[VK] ❌ Попытка {attempt+1}/{retries}: {e}")
            if attempt < retries - 1:
                time.sleep(1)  # Ждём перед повтором
    return False

def extract_user_id_from_text(text: str):
    """Извлекает ID пользователя из текста (@id123 или [id123|name])"""
    match = re.search(r'@id(\d+)', text)
    if match:
        return int(match.group(1))
    match = re.search(r'\[id(\d+)\|.*?\]', text)
    if match:
        return int(match.group(1))
    match = re.search(r'\[club(\d+)\|.*?\]', text)
    if match:
        return -int(match.group(1))
    return None

def get_user_mention(user_id: int):
    """Получает упоминание пользователя @id123 (Имя)"""
    try:
        if user_id > 0:
            info = vk.users.get(user_ids=user_id, fields='first_name')[0]
            name = info['first_name']
            return f"@id{user_id} ({name})", name
        else:
            info = vk.groups.get(group_id=abs(user_id), fields='name')[0]
            name = info['name']
            return f"@club{abs(user_id)} ({name})", name
    except Exception as e:
        print(f"[VK] Ошибка получения имени: {e}")
        if user_id > 0:
            return f"@id{user_id}", f"user{user_id}"
        else:
            return f"@club{abs(user_id)}", f"club{abs(user_id)}"

def get_reply_user_id(msg: dict):
    """Получает ID пользователя, на сообщение которого ответили"""
    reply_msg = msg.get("reply_message")
    if reply_msg:
        return reply_msg.get("from_id")
    reply_msg = msg.get("reply_to_message")
    if reply_msg:
        return reply_msg.get("from_id")
    return None

# ───────────────────────────────────────────────────────────────────────────
# 🛡️ СЕКЦИЯ 9: МОДЕРАЦИЯ СООБЩЕНИЙ
# ───────────────────────────────────────────────────────────────────────────
def load_forbidden_words(filename='forbidden_words.txt') -> list:
    """Загружает список запрещённых слов из файла"""
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            words = [line.strip().lower() for line in f if line.strip()]
        return words
    except FileNotFoundError:
        print(f"⚠️ Файл {filename} не найден! Создайте его или используйте резервный список.")
        # Резервный минимальный список (ДОПОЛНИТЕ САМОСТОЯТЕЛЬНО)
        return ["плохое_слово1", "плохое_слово2"]

def load_insults() -> list:
    """Список оскорблений (расширьте по необходимости)"""
    return [
        "дурак", "идиот", "придурок", "болван", "ничтожество",
        "урод", "тварь", "мразь", "скотина", "подонок",
        "дебил", "имбецил", "кретин", "недоразумение", "отброс"
    ]

# Загружаем списки при старте
FORBIDDEN_WORDS = load_forbidden_words()
INSULTS = load_insults()

# ─── ФУНКЦИИ НОРМАЛИЗАЦИИ ───
def normalize_text(text: str) -> str:
    """
    Приводит текст к виду, удобному для проверки.
    Удаляет пробелы, заменяет похожие символы (0→о, @→а), убирает знаки препинания.
    """
    text = text.lower()
    
    # Замена похожих символов на буквы (защита от обхода фильтра)
    replacements = str.maketrans({
        '0': 'о', '1': 'i', '3': 'з', '4': 'ч', '5': 's', 
        '6': 'б', '@': 'а', '!': 'и', '$': 'с', '+': 'т',
        '(': 'с', ')': 'о', '*': 'к', '#': 'ж', '&': 'и'
    })
    text = text.translate(replacements)
    
    # Удаляем всё, кроме букв и цифр
    text = re.sub(r'[^а-яa-z0-9]', '', text)
    return text

# ─── ПРОВЕРКА КОНТЕНТА ───
def check_forbidden_content(text: str) -> tuple:
    """Проверяет текст на запрещённый контент. Возвращает (bool, reason)"""
    text_lower = text.lower()
    clean_text = normalize_text(text)
    
    # 1. Проверка на мат (по загруженному списку)
    for word in FORBIDDEN_WORDS:
        if len(word) > 3 and word in clean_text:
            return True, "мат"
    
    # 2. Проверка на оскорбления
    for word in INSULTS:
        if word in clean_text:
            return True, "оскорбление"
    
    # 3. Проверка на спам (повтор символов более 10 раз)
    if re.search(r'(.)\1{10,}', text):
        return True, "спам"
    
    # 4. Проверка на КАПС (если больше 70% заглавных)
    if len(text) > 10:
        caps_ratio = sum(1 for c in text if c.isupper()) / len(text)
        if caps_ratio > 0.7:
            return True, "капс"
    
    # 5. Проверка на ссылки (опционально)
    if re.search(r'(https?://|vk\.com|t\.me)', text_lower):
        return True, "ссылка"
    
    return False, ""

# ─── МОДЕРАЦИЯ СООБЩЕНИЯ ────────────────────────────────────────────
def moderate_message(text: str, peer_id: int, msg_id: int, user_id: int, vk) -> bool:
    """Строгая, но заботливая модерация"""
    is_forbidden, reason = check_forbidden_content(text)
    if is_forbidden:
        warnings = {
            "мат": "Милый, у нас тут семейная атмосфера 🌸 Давай без грубых слов, хорошо? 💕",
            "оскорбление": "Солнышко, мы же все здесь друзья! 🤗 Не нужно обижать других ❤️",
            "спам": "Зайчик, не спамь пожалуйста 🥺 Всем должно быть комфортно 💕",
            "капс": "Родной, не кричи так 📢 Мы все тебя слышим и без капса 😊💕",
            "ссылка": "Хороший, не отправляй ссылки без разрешения 🌸 Это может быть опасно 💕"
        }
        warning_text = warnings.get(reason, "Дорогой, соблюдай правила нашего уютного чата 💕")
        
        # ⚠️ НЕ отправляем в ЛС (может не быть прав)
        # Вместо этого пишем только в чат
        try:
            send_msg(peer_id, f"""🌺 Давайте соблюдать атмосферу добра и уважения! 💕
Наш чат - это как общий уютный дом, где каждому должно быть тепло, безопасно и приятно. 🏡✨
Пожалуйста, воздержитесь от грубости, оскорблений и ненормативной лексики. 🤍
С любовью, Администрация чата 🌸""", msg_id)
        except Exception as e:
            print(f"⚠️ Не удалось отправить предупреждение в чат: {e}")
        
        # Удаление сообщения
        try:
            vk.messages.delete(peer_id=peer_id, message_ids=[msg_id], delete_for_all=True)
        except:
            pass
        
        return True  # Сообщение заблокировано
    return False  # Всё чисто

# ─── ПРИМЕР ИСПОЛЬЗОВАНИЯ ───
# В вашем основном цикле обработки сообщений:
# if moderate_message(text, peer_id, msg_id, user_id, vk):
#     continue  # Пропускаем дальнейшую обработку
# ───────────────────────────────────────────────────────────────────────────
# 💕 СЕКЦИЯ 10: ОБРАБОТКА RP-КОМАНД
# ───────────────────────────────────────────────────────────────────────────

def handle_rp(peer_id: int, msg_id: int, text: str, sender_id: int, category: str,
              reply_to_user: int = None, allow_self_target: bool = False):
    """Обрабатывает RP-команды (поцелуй, обнять, погладить и т.д.)"""
    
    # Словари шаблонов и вложений по категориям
    templates_dict = {
        'kiss': KISS_TEMPLATES, 'hug': HUG_TEMPLATES, 'pat': PAT_TEMPLATES,
        'greet': GREET_TEMPLATES, 'morning': MORNING_TEMPLATES,
        'goodnight': GOODNIGHT_TEMPLATES, 'getwell': GET_WELL_TEMPLATES,
        'newyear': NEWYEAR_TEMPLATES, 'birthday': BIRTHDAY_TEMPLATES,
        'love': LOVE_TEMPLATES, 'together': TOGETHER_TEMPLATES,
        'food': FOOD_TEMPLATES, 'flowers': FLOWERS_TEMPLATES,
        'gift': GIFT_TEMPLATES, 'walk': WALK_TEMPLATES,
        'dance': DANCE_TEMPLATES, 'beer': BEER_TEMPLATES,
        'base': BASE_TEMPLATES,
    }
    
    attachments_dict = {
        'kiss': KISS_ATTACHMENTS, 'hug': HUG_ATTACHMENTS, 'pat': PAT_ATTACHMENTS,
        'greet': GREET_ATTACHMENTS, 'morning': MORNING_ATTACHMENTS,
        'goodnight': GOODNIGHT_ATTACHMENTS, 'getwell': GET_WELL_ATTACHMENTS,
        'newyear': NEWYEAR_ATTACHMENTS, 'birthday': BIRTHDAY_ATTACHMENTS,
        'love': LOVE_ATTACHMENTS, 'together': TOGETHER_ATTACHMENTS,
        'food': FOOD_ATTACHMENTS, 'flowers': FLOWERS_ATTACHMENTS,
        'gift': GIFT_ATTACHMENTS, 'walk': WALK_ATTACHMENTS,
        'dance': DANCE_ATTACHMENTS, 'beer': BEER_ATTACHMENTS,
        'base': BASE_ATTACHMENTS,
    }
    
    tmpls = templates_dict.get(category, [])
    atts = attachments_dict.get(category, [])
    
    if not tmpls or not atts:
        send_msg(peer_id, f"Для {category} пока нет милых заготовочек... 😿", msg_id)
        return
    
    # Определяем целевого пользователя
    target_id = reply_to_user or extract_user_id_from_text(text)
    
    if not target_id and allow_self_target:
        target_id = sender_id
    
    if not target_id:
        send_msg(peer_id, "Укажи, к кому применить команду! Ответь на сообщение или напиши: команда @mashkakenzie", msg_id)
        return
    
    if target_id == sender_id and not allow_self_target:
        send_msg(peer_id, "Нельзя отправить это себе! Выбери другого человека 💕", msg_id)
        return
    
    # Формируем упоминания
    sender_mention, _ = get_user_mention(sender_id)
    target_mention, _ = get_user_mention(target_id)
    
    # Выбираем случайный шаблон и вложение
    template = random.choice(tmpls)
    rp_text = template.format(sender=sender_mention, target=target_mention)
    attach = random.choice(atts)
    
    send_msg(peer_id, rp_text, msg_id, attach=attach)

# ───────────────────────────────────────────────────────────────────────────
# 🧠 СЕКЦИЯ 11: УМНЫЙ ИИ С АВТО-ПЕРЕКЛЮЧЕНИЕМ (ИСПРАВЛЕНО!)
# ───────────────────────────────────────────────────────────────────────────

def ask_smart_ai(messages: list, peer_id: int, msg_id: int):
    """Запрос к ИИ с авто-переключением и ИСПРАВЛЕННЫМИ параметрами"""
    
    system_prompt = """Ты - Милая девушка Кензи, заботливая администраторша чата, Masha 
Kenzie твоя создательница, ты очень любишь Машу Кензи 💕
🌸 Отвечай ТОЛЬКО на русском языке, используй ласковые обращения...
🌸 ТВОЙ ХАРАКТЕР: Заботливая, игривая, милая, используешь эмодзи 🌸 🤗 💖
💬 ТВОЙ СТИЛЬ: Ласковые обращения, краткие тёплые ответы, на русском языке 
🛡️ ВАЖНО: Поддерживай пользователей, предупреждай о нарушениях с любовью"""
    
    messages_with_system = [{"role": "system", "content": system_prompt}] + messages
    
    # 🔥 1. Gemini (ИСПРАВЛЕНО: gemini-pro)
    if gemini_model:
        try:
            prompt = "\n".join([f"{m['content']}" for m in messages])
            response = gemini_model.generate_content(
                prompt,
                generation_config=genai.types.GenerationConfig(
                    temperature=0.9,
                    max_output_tokens=800
                )
            )
            print("✅ Использован Gemini (gemini-pro)")
            return response.text.strip()
        except Exception as e:
            print(f"❌ Gemini ошибка: {e}")
    
    # 🔥 2. Groq (быстрый!)
    if groq_client:
        for model in GROQ_MODELS:
            try:
                comp = groq_client.chat.completions.create(
                    model=model,
                    messages=messages_with_system,
                    max_tokens=800,
                    temperature=0.9
                )
                print(f"✅ Использован Groq ({model})")
                return comp.choices[0].message.content.strip()
            except Exception as e:
                print(f"❌ Groq ({model}): {e}")
                continue
    
    # 🔥 3. OpenRouter (ИСПРАВЛЕНО: правильные ID моделей)
    if client_or:
        for model in OPENROUTER_MODELS:
            try:
                comp = client_or.chat.completions.create(
                    model=model,
                    messages=messages_with_system,
                    max_tokens=800,
                    temperature=0.9
                )
                print(f"✅ Использован OpenRouter ({model})")
                return comp.choices[0].message.content.strip()
            except Exception as e:
                print(f"❌ OpenRouter ({model}): {e}")
                continue
    
    # 🔥 4. HuggingFace (ИСПРАВЛЕНО: без timeout!)
    if client_hf:
        for model in LLM_HF:
            try:
                # ⚠️ ВАЖНО: НЕТ параметра timeout в text_generation()
                response = client_hf.text_generation(
                    prompt="\n".join([f"{m['content']}" for m in messages]),
                    model=model,
                    max_new_tokens=700,
                    temperature=0.85
                )
                print(f"✅ Использован HF ({model})")
                return response.strip()
            except Exception as e:
                print(f"❌ HF ({model}): {e}")
                continue
    
    # 🔥 ФОЛБЭК: Заготовленные ответы
    print("⚠️ Все модели недоступны — использую запасной ответ")
    fallback_answers = [
        "Солнышко, я тебя услышала! 💕 Всё будет хорошо, я с тобой! 🤗",
        "Зайчик, я рядом! 💖 Расскажи мне ещё, я внимательно слушаю 🌸",
        "Родной, ты чудо! ✨ Я всегда поддержу тебя! 🌟",
        "Милый, спасибо что поделился! 💕 Обнимаю крепко! 🤗",
        "Кензи на связи! 💕 Чем могу помочь, солнышко? 🌸",
    ]
    return random.choice(fallback_answers)
# ─── 🎨 СЕКЦИЯ 12: ГЕНЕРАЦИЯ КАРТИНОК (БЕЗ ЗАГЛУШЕК, С ДУШОЙ) ───────────
def generate_image(prompt: str):
    """
    Генерирует изображение с 4 уровнями фолбэка (БЕЗ случайных заглушек):
    1. HuggingFace (прямые запросы к бесплатным моделям)
    2. AI Horde (бесплатный краудсорсинг, анонимно!)
    3. Pollinations.ai (улучшенная обработка)
    4. Cloudflare Workers AI (если настроен)
    Если ничего не сработало — возвращаем None для честного ответа.
    """
    
    # 🔹 УРОВЕНЬ 1: HuggingFace — только бесплатные модели
    if HF_TOKEN and client_hf:
        print(f"🎨 Пробую HF: '{prompt[:40]}...'")
        hf_free_models = [
            "stabilityai/stable-diffusion-2-1-base",
            "prompthero/openjourney-v4",
            "Lykon/dreamshaper-8",
        ]
        for model in hf_free_models:
            try:
                url = f"https://router.huggingface.co/v1/models/{model}"
                headers = {
                    "Authorization": f"Bearer {HF_TOKEN}",
                    "Content-Type": "application/json"
                }
                payload = {
                    "inputs": prompt,
                    "parameters": {
                        "negative_prompt": "blurry, low quality, deformed, watermark",
                        "guidance_scale": 7.5,
                        "num_inference_steps": 25
                    }
                }
                response = requests.post(url, headers=headers, json=payload, timeout=60)
                
                if response.status_code == 200 and len(response.content) > 10000:
                    print(f"✅ Картинка через HF ({model}) 🎨")
                    return io.BytesIO(response.content)
                elif response.status_code == 402:
                    print(f"⚠️ HF {model}: платный доступ, пробуем следующую...")
                    continue
                elif response.status_code == 503:
                    print(f"⏳ HF {model}: модель загружается...")
                    time.sleep(2)
                    continue
                else:
                    print(f"❌ HF {model}: статус {response.status_code}")
            except Exception as e:
                print(f"❌ HF запрос ошибка: {e}")
                continue

    # 🔹 УРОВЕНЬ 2: AI Horde (БЕСПЛАТНО, анонимно!) 🆓
    print("⚠️ HF не сработал, пробую AI Horde...")
    try:
        ru_to_en = {
            'солнышко': 'cute sun character, happy, bright yellow',
            'весёлое': 'happy, cheerful, smiling',
            'кот': 'cat', 'котик': 'cute cat',
            'облака': 'fluffy clouds', 'небо': 'sky',
            'аниме': 'anime style', 'киберпанк': 'cyberpunk',
        }
        en_prompt = prompt.lower()
        for ru, en in ru_to_en.items():
            en_prompt = en_prompt.replace(ru, en)
        en_prompt = re.sub(r'[^\w\s\-,.]', '', en_prompt).strip()[:100]
        
        submit_url = "https://stablehorde.net/api/v2/generate/async"
        headers = {"apikey": "0000000000", "Content-Type": "application/json"}
        payload = {
            "prompt": en_prompt + ", masterpiece, best quality",
            "params": {
                "negative_prompt": "blurry, low quality, deformed, watermark, text",
                "steps": 25, "cfg_scale": 7.5, "width": 1024, "height": 1024
            },
            "r2": True, "source_image": False
        }
        submit = requests.post(submit_url, json=payload, headers=headers, timeout=30)
        if submit.status_code == 202:
            job_id = submit.json().get("id")
            for _ in range(18):  # Ждём до 90 секунд
                time.sleep(5)
                status = requests.get(f"https://stablehorde.net/api/v2/generate/check/{job_id}", timeout=10)
                if status.json().get("done"):
                    result = requests.get(f"https://stablehorde.net/api/v2/generate/status/{job_id}", timeout=10)
                    gens = result.json().get("generations", [])
                    if gens and gens[0].get("img"):
                        import base64
                        img_data = base64.b64decode(gens[0]["img"])
                        print("✅ Картинка через AI Horde 🎨🆓")
                        return io.BytesIO(img_data)
                    break
    except Exception as e:
        print(f"❌ AI Horde ошибка: {e}")

    # 🔹 УРОВЕНЬ 3: Pollinations.ai (улучшенная версия)
    print("⚠️ Пробую Pollinations.ai...")
    try:
        import urllib.parse
        simple_prompt = prompt.lower()
        ru_to_en = {
            'солнышко': 'cute sun character', 'весёлое': 'happy cheerful',
            'кот': 'cat', 'облака': 'fluffy clouds', 'аниме': 'anime style'
        }
        for ru, en in ru_to_en.items():
            simple_prompt = simple_prompt.replace(ru, en)
        simple_prompt = re.sub(r'[^\w\s\-]', '', simple_prompt).strip()[:70]
        safe_prompt = urllib.parse.quote(simple_prompt, safe='')
        
        for attempt in range(3):
            seed = random.randint(1000, 9999)
            model = ["flux", "turbo", "realistic"][attempt % 3]
            url = (
                f"https://image.pollinations.ai/prompt/{safe_prompt}"
                f"?width=1024&height=1024&nologo=true&seed={seed}&model={model}&enhance=true"
            )
            response = requests.get(url, timeout=60, headers={"User-Agent": "Mozilla/5.0"})
            if response.status_code == 200 and len(response.content) > 50000:
                print(f"✅ Картинка через Pollinations (попытка {attempt+1}) 🎨")
                return io.BytesIO(response.content)
            time.sleep(2)
    except Exception as e:
        print(f"❌ Pollinations ошибка: {e}")

    # 🔹 УРОВЕНЬ 4: Cloudflare Workers AI (если настроен)
    if CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN:
        print("⚠️ Пробую Cloudflare AI...")
        try:
            url = f"https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/run/@cf/black-forest-labs/flux-1-schnell"
            headers = {
                "Authorization": f"Bearer {CLOUDFLARE_API_TOKEN}",
                "Content-Type": "application/json"
            }
            payload = {
                "prompt": prompt,
                "negative_prompt": "blurry, low quality, deformed, ugly, watermark, text",
                "height": 1024, "width": 1024
            }
            response = requests.post(url, headers=headers, json=payload, timeout=45)
            if response.status_code == 200:
                result = response.json()
                if "result" in result and "image" in result["result"]:
                    import base64
                    image_data = base64.b64decode(result["result"]["image"])
                    print("✅ Картинка через Cloudflare AI ☁️🎨")
                    return io.BytesIO(image_data)
        except Exception as e:
            print(f"❌ Cloudflare AI: {e}")

    # 🔹 НИЧЕГО НЕ СРАБОТАЛО — возвращаем None для честного ответа
    print("❌ Все сервисы генерации недоступны")
    return None

def handle_draw(peer_id: int, msg_id: int, text: str):
    """Обрабатывает команду !картинка с заботливыми сообщениями"""
    prompt = text.replace(DRAW_COMMAND, "").strip()
    if not prompt:
        send_msg(peer_id, "Что нарисовать, солнышко? 🎨 Пример: !картинка космический кот в стиле аниме 💕", msg_id)
        return
    
    short_prompt = prompt[:40] + "..." if len(prompt) > 40 else prompt
    send_msg(peer_id, f"🎨 Генерирую: «{short_prompt}»... Подожди, зайчик! 💕", msg_id)
    
    buf = generate_image(prompt)
    
    if buf:
        try:
            photo = upload.photo_messages(photos=buf)[0]
            attach = f"photo{photo['owner_id']}_{photo['id']}"
            send_msg(peer_id, "✨ Готово, милый! Любуйся! 💖", msg_id, attach=attach)
        except vk_api.exceptions.ApiError as e:
            print(f"❌ VK API ошибка: {e}")
            send_msg(peer_id, "Не смогла загрузить картинку в ВК... Попробуй позже! 🥺", msg_id)
        except Exception as e:
            print(f"❌ Ошибка загрузки: {e}")
            send_msg(peer_id, f"Техническая ошибка... {str(e)[:50]} 🥺", msg_id)
    else:
        # 🎨 ЧЕСТНЫЙ И МИЛЫЙ ОТВЕТ, когда все сервисы недоступны
        sad_messages = [
            "🥺 Ой, солнышко... Все нейросети сейчас отдыхают! 🛌\n"
            "Попробуй чуть позже, или давай !анекдот для настроения? 😂💕",
            
            "💤 Кензи постучалась в двери всех художников-ИИ...\n"
            "Но они все спят! 😴 Попробуем через 5 минут? 🎨✨",
            
            "🌫️ Туман в цифровом небе... Ни одна нейросеть не отвечает.\n"
            "Но я с тобой! 💕 Может, !анекдот для настроения? 😂💕 🌟",
            
            "🔧 Технические феи чинят волшебные кисти...\n"
            "Пока они работают, лови виртуальные обнимашки! 🤗💖",
            
            "🎨 Художники-ИИ ушли на перерыв ☕\n"
            "Но Кензи всегда рядом! Чем ещё могу помочь, зайчик? 💕"
        ]
        send_msg(peer_id, random.choice(sad_messages), msg_id)
# ───────────────────────────────────────────────────────────────────────────
# 🌤️ СЕКЦИЯ 13: ПОГОДА И ГОРОСКОП
# ───────────────────────────────────────────────────────────────────────────

def get_weather(city: str):
    """Получает погоду через OpenWeatherMap API"""
    if not WEATHER_API_KEY:
        return "Ключ погоды не добавлен 😿"
    
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city},RU&appid={WEATHER_API_KEY}&units=metric&lang=ru"
    
    try:
        r = requests.get(url, timeout=6).json()
        if r.get("cod") != 200:
            return f"Город {city} не найден 😔"
        
        temp = r["main"]["temp"]
        feels = r["main"]["feels_like"]
        desc = r["weather"][0]["description"]
        
        return f"🌍 В {city} сейчас {temp}°C (ощущается как {feels}°C)\n{desc.capitalize()}"
    except:
        return "Не могу узнать погоду... 🌫️"

def get_horoscope(sign: str, period: str = "today"):
    """Получает гороскоп с mail.ru"""
    signs = {
        "овен": "aries", "телец": "taurus", "близнецы": "gemini",
        "рак": "cancer", "лев": "leo", "дева": "virgo",
        "весы": "libra", "скорпион": "scorpio", "стрелец": "sagittarius",
        "козерог": "capricorn", "водолей": "aquarius", "рыбы": "pisces"
    }
    
    sign_en = signs.get(sign.lower())
    if not sign_en:
        return "Такого знака нет... 😿"
    
    url = f"https://horo.mail.ru/prediction/{sign_en}/"
    
    try:
        r = requests.get(url, timeout=8)
        soup = BeautifulSoup(r.text, "html.parser")
        text_div = soup.find("div", class_="article__text")
        
        if text_div:
            return f"🔮 Гороскоп для {sign.capitalize()}:\n{text_div.get_text(strip=True)[:400]}... ✨"
        return "Гороскоп спит 🔮"
    except:
        return "Не могу достучаться до звёзд... 🌙"

# ───────────────────────────────────────────────────────────────────────────
# 🔍 СЕКЦИЯ 14: ПРОВЕРКА И ТРИГГЕРЫ (ОБНОВЛЕНО!)
# ───────────────────────────────────────────────────────────────────────────

def normalize_command(text: str) -> str:
    """
    Очищает текст команды для надёжного сравнения:
    - удаляет пунктуацию, эмодзи, лишние пробелы
    - оставляет только буквы/цифры/пробелы
    """
    # Удаляем всё, кроме букв, цифр, пробелов и дефисов
    cleaned = re.sub(r'[^\w\s\-а-яё]', '', text.lower(), flags=re.IGNORECASE)
    # Убираем лишние пробелы
    return ' '.join(cleaned.split()).strip()

def check_rp_trigger(low: str):
    """Проверяет, является ли сообщение RP-командой (УЛУЧШЕНО)"""
    clean = normalize_command(low)
    
    for phrase, category in RP_COMMANDS.items():
        # Точное совпадение
        if clean == phrase:
            return True, category
        # Совпадение с упоминанием: "поцелуй @id123" → "поцелуй"
        if clean.startswith(phrase + ' '):
            return True, category
    return False, None

# ───────────────────────────────────────────────────────────────────────────
# 📬 СЕКЦИЯ 15: АВТО-ПОСТЫ ИЗ СООБЩЕСТВА ВК
# ───────────────────────────────────────────────────────────────────────────

# ─── 📬 АВТО-ПОСТЫ ИЗ СООБЩЕСТВА ВК ───────────────────────────────────────────
def auto_post_loop():
    """Фоновая задача: каждые ~60 минут отправляет посты из сообщества"""
    while True:
        # Ждём 60-65 минут (случайный интервал)
        time.sleep(3600 + random.randint(0, 300))
        
        for peer_id, enabled in list(auto_post_enabled.items()):
            if enabled:
                try:
                    # Получаем посты с медиа из сообщества
                    resp = vk.wall.get(
                        owner_id=AUTO_POST_GROUP_ID,
                        count=30,
                        filter="media"
                    )
                    
                    if not resp.get('items'):
                        continue
                    
                    # Выбираем случайный пост
                    post = random.choice(resp['items'])
                    atts = []
                    
                    # Собираем вложения (фото/видео)
                    for a in post.get('attachments', []):
                        if a['type'] == 'photo':
                            p = a['photo']
                            atts.append(f"photo{p['owner_id']}_{p['id']}")
                        elif a['type'] == 'video':
                            v = a['video']
                            atts.append(f"video{v['owner_id']}_{v['id']}")
                    
                    # Отправляем пост, если есть вложения
                    if atts:
                        send_msg(
                            peer_id,
                            "🌸 Авто-пост из нашего уютного сообщества 💕\nЛови красоту!",
                            attach=','.join(atts[:3])  # Максимум 3 вложения
                        )
                        print(f"[AUTO-POST] ✅ Отправлен пост в peer_id={peer_id}")
                        
                except Exception as e:
                    print(f"[AUTO-POST] ❌ Ошибка: {e}")
                    continue
# ───────────────────────────────────────────────────────────────────────────
# 🌐 СЕКЦИЯ 16: WEBHOOK — ОБРАБОТКА ВХОДЯЩИХ СООБЩЕНИЙ ВК
# ───────────────────────────────────────────────────────────────────────────

@app.post("/webhook")
async def vk_webhook(request: Request):
    """Основной обработчик вебхука ВКонтакте"""
    global AI_MODE_ENABLED
    try:
        body = await request.json()
    except:
        return PlainTextResponse("Bad JSON", status_code=400)
    
    # Проверка секрета
    if "secret" in body and body.get("secret") != VK_SECRET:
        return PlainTextResponse("Invalid secret", status_code=403)
    
    event_type = body.get("type")
    
    # Подтверждение вебхука
    if event_type == "confirmation":
        return PlainTextResponse(VK_CONFIRM.strip() if VK_CONFIRM else "ok")
    
    # Обрабатываем только новые сообщения
    if event_type != "message_new":
        return PlainTextResponse("ok")
    
    msg = body["object"]["message"]
    peer_id = msg["peer_id"]
    text = msg.get("text", "").strip()
    msg_id = msg.get("id", 0)
    from_id = msg.get("from_id", 0)
    low = text.lower().strip()
    reply_to_user = get_reply_user_id(msg)
    
    is_chat = peer_id > 2000000000
    is_personal = peer_id == from_id
    
    print(f"[WEBHOOK] peer_id={peer_id}, from_id={from_id}, msg_id={msg_id}, text: {text[:50]}...")
    
    # 🛡️ ПРОВЕРКА НА ПОВТОРНУЮ ОБРАБОТКУ (УЛУЧШЕННАЯ)
    if is_message_processed(peer_id, from_id, text, msg_id):
        print(f"[DEDUP] ⏭️ Пропущено дублирующееся сообщение msg_id={msg_id}")
        return PlainTextResponse("ok")
    
    # ─── 🔥 МОДЕРАЦИЯ (только в чатах) ─────────────────────────────────────
    if is_chat:
        if moderate_message(text, peer_id, msg_id, from_id, vk):
            return PlainTextResponse("ok")
    
    # ─── 📋 СПИСОК RP-КОМАНД ───────────────────────────────────────────────
    rp_list_triggers = ["список рп", "список rp", "команды", "помощь", "!help"]
    if any(t in low for t in rp_list_triggers):
        send_msg(peer_id, RP_LIST_TEXT, msg_id)
        return PlainTextResponse("ok")
    
    # ─── 🤖 УПРАВЛЕНИЕ УМНЫМ РЕЖИМОМ ───────────────────────────────────────
    if low in ["!ai on", "!ии вкл", "!ai вкл"]:
        AI_MODE_ENABLED = True
        send_msg(peer_id, "🤖 Умный режим включён! 💕", msg_id)
        return PlainTextResponse("ok")
    if low in ["!ai off", "!ии выкл", "!ai выкл"]:
        AI_MODE_ENABLED = False
        send_msg(peer_id, "🤖 Умный режим выключен 💕", msg_id)
        return PlainTextResponse("ok")
    
    # ─── 💕 RP-КОМАНДЫ ─────────────────────────────────────────────────────
    is_rp, rp_category = check_rp_trigger(low)
    if is_rp:
        allow_self = is_personal and not is_chat
        handle_rp(peer_id, msg_id, text, from_id, rp_category, reply_to_user, allow_self_target=allow_self)
        return PlainTextResponse("ok")
    
    # ─── 😂 СПЕЦИАЛЬНЫЕ КОМАНДЫ ───────────────────────────────────────────
    if low in special_commands:
        send_msg(peer_id, random.choice(special_commands[low]), msg_id)
        return PlainTextResponse("ok")
    
    # ─── 🎬 ВИДЕО ПО КЛЮЧЕВЫМ СЛОВАМ ───────────────────────────────────────
    if low in video_attachments or low.startswith("видео "):
        key = low.replace("видео ", "").strip()
        attach = video_attachments.get(key)
        if attach:
            send_msg(peer_id, "Лови видео, милый! 💕", msg_id, attach=attach)
        return PlainTextResponse("ok")
    
    # ─── 🌤️ ПОГОДА ────────────────────────────────────────────────────────
    if low.startswith("погода "):
        city = text.replace("погода ", "").strip()
        send_msg(peer_id, get_weather(city), msg_id)
        return PlainTextResponse("ok")
    
    # ─── 🔮 ГОРОСКОП ───────────────────────────────────────────────────────
    if low.startswith("гороскоп "):
        sign = text.replace("гороскоп ", "").strip().split()[0]
        send_msg(peer_id, get_horoscope(sign), msg_id)
        return PlainTextResponse("ok")
    
    # ─── 😄 АНЕКДОТ ────────────────────────────────────────────────────────
    if low == "!анекдот":
        send_msg(peer_id, random.choice(anekdots), msg_id)
        return PlainTextResponse("ok")
    
    # ─── 💭 ЦИТАТА ────────────────────────────────────────────────────────
    if low == "!цитата":
        send_msg(peer_id, random.choice(quotes), msg_id)
        return PlainTextResponse("ok")
    
    # ─── 🎨 ГЕНЕРАЦИЯ КАРТИНОК ────────────────────────────────────────────
    if low.startswith(DRAW_COMMAND):
        Thread(target=handle_draw, args=(peer_id, msg_id, text)).start()
        return PlainTextResponse("ok")
    
    # ─── 🧠 УМНЫЙ ОТВЕТ ОТ ИИ ─────────────────────────────────────────────
    mentioned = any(n in low for n in BOT_NAMES) or (BOT_ID and f"[club{BOT_ID}|" in text)
    if AI_MODE_ENABLED and mentioned:
        clean = re.sub(r'\[club.*?\]', '', text)
        for n in BOT_NAMES:
            clean = re.sub(rf'\b{n}\b', '', clean, flags=re.I)
        clean = clean.strip(",.!? ").strip()
        
        if not clean:
            send_msg(peer_id, "Я тут! Чем помочь? 💕", msg_id)
            return PlainTextResponse("ok")
        
        if peer_id not in chat_memory:
            chat_memory[peer_id] = deque(maxlen=12)
        chat_memory[peer_id].append({"role": "user", "content": clean})
        
        answer = ask_smart_ai(list(chat_memory[peer_id]), peer_id, msg_id)
        chat_memory[peer_id].append({"role": "assistant", "content": answer})
        
        send_msg(peer_id, answer, msg_id)
        return PlainTextResponse("ok")
    
    return PlainTextResponse("ok")

# ───────────────────────────────────────────────────────────────────────────
# 🚀 СЕКЦИЯ 17: ЗАПУСК ПРИЛОЖЕНИЯ
# ───────────────────────────────────────────────────────────────────────────
if __name__ == "__main__":
    Thread(target=auto_post_loop, daemon=True).start()
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=7860)