bot.py

import os
import sqlite3
import discord
from discord.ext import commands
from dotenv import load_dotenv
from datetime import datetime, timedelta
import json
import configparser
import asyncio
from pathlib import Path
import speech_recognition as sr
from gtts import gTTS
from pydub import AudioSegment
import tempfile
import struct
import io
import wave
import threading
import queue

# Настройка пути к FFmpeg (для Windows с WinGet)
FFMPEG_PATHS = [
    r"C:\Users\utuba\AppData\Local\Microsoft\WinGet\Packages\Gyan.FFmpeg_Microsoft.Winget.Source_8wekyb3d8bbwe\ffmpeg-8.0.1-full_build\bin",
    r"C:\ffmpeg\bin",
    r"C:\Program Files\ffmpeg\bin",
]
for ffmpeg_path in FFMPEG_PATHS:
    if os.path.exists(ffmpeg_path):
        os.environ["PATH"] = ffmpeg_path + os.pathsep + os.environ.get("PATH", "")
        AudioSegment.converter = os.path.join(ffmpeg_path, "ffmpeg.exe")
        AudioSegment.ffprobe = os.path.join(ffmpeg_path, "ffprobe.exe")
        print(f"[INFO] FFmpeg найден: {ffmpeg_path}")
        break

# Опциональные импорты для улучшенного распознавания
try:
    import whisper
    WHISPER_AVAILABLE = True
    whisper_model = None  # Ленивая загрузка
except ImportError:
    WHISPER_AVAILABLE = False
    whisper_model = None
    print("[INFO] Whisper не установлен. Используется Google Speech Recognition.")

try:
    import numpy as np
    NUMPY_AVAILABLE = True
except ImportError:
    NUMPY_AVAILABLE = False

# Локальная нейросеть для генерации текста
try:
    from neural_chat import get_neural_model, neural_generate, neural_train, TORCH_AVAILABLE
    NEURAL_AVAILABLE = TORCH_AVAILABLE
    if NEURAL_AVAILABLE:
        print("[INFO] Локальная нейросеть доступна (PyTorch)")
    else:
        print("[INFO] PyTorch не установлен. Локальная нейросеть недоступна.")
except ImportError as e:
    NEURAL_AVAILABLE = False
    print(f"[INFO] Модуль neural_chat не загружен: {e}")

dotenv_loaded = load_dotenv(dotenv_path=Path(__file__).parent / ".env")
# Проверка наличия ключей для внешнего ИИ
def _warn_env():
    gemini = os.getenv('EXTERNAL_AI_GEMINI_KEY')
    openai = os.getenv('EXTERNAL_AI_OPENAI_KEY')
    api = os.getenv('EXTERNAL_AI_API_KEY')
    provider = os.getenv('EXTERNAL_AI_PROVIDER')
    if not (gemini or openai or api):
        print("[УВАГА] Не знайдено жодного ключа EXTERNAL_AI_GEMINI_KEY, EXTERNAL_AI_OPENAI_KEY або EXTERNAL_AI_API_KEY. Зовнішній ІІ не працюватиме!")
    else:
        print(f"[INFO] Ключі ІІ: GEMINI={'є' if gemini else 'немає'}, OPENAI={'є' if openai else 'немає'}, API={'є' if api else 'немає'}, PROVIDER={provider}")
    if not dotenv_loaded:
        print("[УВАГА] .env не знайдено або не завантажено!")
_warn_env()
load_dotenv()

config = configparser.ConfigParser()
config.read('config.ini')

def _int_cfg(section, key, default):
    try:
        return int(config.get(section, key))
    except Exception:
        return default

MAX_POINTS = {
    "text": _int_cfg('POINTS', 'text_max', 15),
    "voice": _int_cfg('POINTS', 'voice_max', 10),
    "events": _int_cfg('POINTS', 'events_max', 5),
    "other": _int_cfg('POINTS', 'other_max', 5)
}
TOTAL_MAX = sum(MAX_POINTS.values())
DEFAULT_THRESHOLD = _int_cfg('DEFAULTS', 'threshold', 65)  # процентов

DB_PATH = "activity.db"
THOUGHTS_DIR = "thoughts"

intents = discord.Intents.default()
intents.message_content = True
intents.members = True

bot = commands.Bot(command_prefix=["!", "! "], intents=intents)

# Разрешить выполнение всех команд без проверок модератора/админа
def _noop_check(**perms):
    def decorator(func):
        return func
    return decorator

# Перезаписываем проверки из discord.ext.commands на no-op
commands.has_guild_permissions = _noop_check
commands.has_permissions = _noop_check

# --- Голосовые функции ---
voice_clients = {}
voice_activity_tracking = {}  # Для отслеживания времени в голосовых каналах

async def join_voice_channel(ctx):
    """Подключение к голосовому каналу с улучшенной обработкой ошибок"""
    if not ctx.author.voice:
        await ctx.send("❌ Ти не в голосовому каналі!")
        return None
    
    channel = ctx.author.voice.channel
    
    # ВАЖЛИВО: Спочатку повністю очистити будь-яке існуюче підключення
    # Це вирішує помилку 4006 "Session no longer valid"
    if ctx.guild.voice_client:
        try:
            await ctx.guild.voice_client.disconnect(force=True)
            await asyncio.sleep(1)  # Дати Discord час очистити сесію
        except:
            pass
        voice_clients.pop(ctx.guild.id, None)
    
    # Також очистити з нашого словника
    if ctx.guild.id in voice_clients:
        try:
            vc = voice_clients[ctx.guild.id]
            if vc:
                await vc.disconnect(force=True)
        except:
            pass
        voice_clients.pop(ctx.guild.id, None)
        await asyncio.sleep(0.5)
    
    try:
        # Підключємося БЕЗ self_deaf щоб бот міг слухати користувачів
        vc = await channel.connect(timeout=15.0, reconnect=False, self_deaf=False)
        voice_clients[ctx.guild.id] = vc
        await ctx.send(f"🎤 Підключився до голосового каналу: {channel.name}")
        return vc
    except asyncio.TimeoutError:
        await ctx.send("❌ Таймаут підключення до голосового каналу. Спробуйте пізніше.")
        # Очищаємо зіпсоване підключення
        voice_clients.pop(ctx.guild.id, None)
        return None
    except discord.ClientException as e:
        await ctx.send(f"❌ Помилка підключення: {e}")
        # Очищаємо зіпсоване підключення
        if ctx.guild.voice_client:
            try:
                await ctx.guild.voice_client.disconnect(force=True)
            except:
                pass
        voice_clients.pop(ctx.guild.id, None)
        return None
    except Exception as e:
        await ctx.send(f"❌ Неочікувана помилка: {e}")
        voice_clients.pop(ctx.guild.id, None)
        return None

async def leave_voice_channel(ctx):
    """Отключение от голосового канала"""
    vc = voice_clients.get(ctx.guild.id) or ctx.guild.voice_client
    if vc:
        try:
            await vc.disconnect(force=True)
            await ctx.send("👋 Відключився від голосового каналу.")
        except:
            await ctx.send("👋 Відключився від голосового каналу.")
        voice_clients.pop(ctx.guild.id, None)
    else:
        await ctx.send("❌ Я не в голосовому каналі!")

# Авто-підключення до голосових каналів (по серверах)
# {guild_id: True/False}
auto_voice_join = {}

# --- Отслеживание голосовой активности ---
@bot.event
async def on_voice_state_update(member, before, after):
    """Отслеживание голосовой активности"""
    guild = member.guild
    
    # Начисляем очки за голосовую активность
    if before.channel is None and after.channel is not None:
        # Пользователь зашел в голосовой канал
        voice_activity_tracking[(guild.id, member.id)] = datetime.utcnow()
    elif before.channel is not None and after.channel is None:
        # Пользователь вышел из голосового канала
        start_time = voice_activity_tracking.pop((guild.id, member.id), None)
        if start_time and not member.bot:
            duration = (datetime.utcnow() - start_time).total_seconds()
            # 1 очко за каждые 5 минут в голосовом канале
            points = int(duration / 300)
            if points > 0:
                upsert_user(guild.id, member.id)
                add_field(guild.id, member.id, "voice", points)
    
    # Перевіряємо чи увімкнено авто-підключення для цього сервера
    if not auto_voice_join.get(guild.id, False):
        return
        
    # Авто-підключення (якщо увімкнено)
    if after.channel and len(after.channel.members) >= 2:
        if guild.id not in voice_clients or not (voice_clients.get(guild.id) and voice_clients[guild.id].is_connected()):
            # Проверяем, не подключен ли бот уже
            if guild.voice_client and guild.voice_client.is_connected():
                return
            try:
                # Вимикаємо reconnect щоб уникнути нескінченних спроб
                vc = await after.channel.connect(timeout=10.0, reconnect=False)
                voice_clients[guild.id] = vc
                text_channel = discord.utils.get(guild.text_channels, name="general") or \
                              discord.utils.get(guild.text_channels, name="общий") or \
                              guild.text_channels[0] if guild.text_channels else None
                if text_channel:
                    await text_channel.send(f"🎤 Автоматично підключився до: {after.channel.name}")
            except Exception as e:
                print(f"[VOICE] Помилка авто-підключення: {e}")

# ============================================================
# ГОЛОСОВОЕ ОБЩЕНИЕ С ИИ - Распознавание речи и синтез ответов
# ============================================================

# Настройки голосового режима
voice_listen_mode = {}  # {guild_id: True/False} - режим прослушивания
voice_audio_buffers = {}  # {guild_id: {user_id: AudioBuffer}}
voice_text_channels = {}  # {guild_id: text_channel} - куда отправлять логи
voice_wake_words = ["бот", "ботик", "компотик", "кампотик", "эй бот", "hey bot", "привет бот"]

class AudioBuffer:
    """Буфер для накопления аудио от пользователя"""
    def __init__(self, user_id):
        self.user_id = user_id
        self.frames = []
        self.last_audio_time = datetime.utcnow()
        self.is_speaking = False
        self.silence_threshold = 1.5  # секунд тишины для завершения фразы
        
    def add_frame(self, pcm_data):
        self.frames.append(pcm_data)
        self.last_audio_time = datetime.utcnow()
        self.is_speaking = True
        
    def get_audio_data(self):
        if not self.frames:
            return None
        return b''.join(self.frames)
    
    def clear(self):
        self.frames = []
        self.is_speaking = False
        
    def is_silent(self):
        return (datetime.utcnow() - self.last_audio_time).total_seconds() > self.silence_threshold

# VoiceSink доступен только в py-cord, проверяем наличие
VOICE_RECEIVE_AVAILABLE = hasattr(discord, 'sinks')

if VOICE_RECEIVE_AVAILABLE:
    class VoiceSink(discord.sinks.Sink):
        """Кастомный sink для записи аудио из Discord"""
        def __init__(self, guild_id, callback):
            super().__init__()
            self.guild_id = guild_id
            self.callback = callback
            self.audio_data = {}
            
        def write(self, data, user):
            if user not in self.audio_data:
                self.audio_data[user] = []
            self.audio_data[user].append(data)
            
        def cleanup(self):
            self.audio_data.clear()
else:
    VoiceSink = None  # Заглушка для discord.py

def get_whisper_model():
    """Ленивая загрузка модели Whisper"""
    global whisper_model
    if WHISPER_AVAILABLE and whisper_model is None:
        try:
            print("[VOICE] Загрузка модели Whisper (base)...")
            whisper_model = whisper.load_model("base")
            print("[VOICE] Модель Whisper загружена успешно!")
        except Exception as e:
            print(f"[VOICE] Ошибка загрузки Whisper: {e}")
    return whisper_model

def recognize_speech_whisper(audio_path):
    """Распознавание речи через Whisper (офлайн, высокое качество)"""
    model = get_whisper_model()
    if model is None:
        return None, "Whisper не доступен"
    try:
        result = model.transcribe(audio_path, language="ru")
        text = result.get("text", "").strip()
        return text if text else None, None
    except Exception as e:
        return None, str(e)

def recognize_speech_google(audio_path):
    """Распознавание речи через Google Speech Recognition (онлайн)"""
    recognizer = sr.Recognizer()
    try:
        with sr.AudioFile(audio_path) as source:
            audio = recognizer.record(source)
        # Пробуем русский, потом украинский, потом английский
        for lang in ["ru-RU", "uk-UA", "en-US"]:
            try:
                text = recognizer.recognize_google(audio, language=lang)
                if text:
                    return text, None
            except sr.UnknownValueError:
                continue
            except sr.RequestError as e:
                return None, f"Ошибка сервиса: {e}"
        return None, "Не удалось распознать речь"
    except Exception as e:
        return None, str(e)

async def recognize_speech(audio_path, prefer_whisper=True):
    """Универсальная функция распознавания речи"""
    loop = asyncio.get_event_loop()
    
    if prefer_whisper and WHISPER_AVAILABLE:
        text, error = await loop.run_in_executor(None, recognize_speech_whisper, audio_path)
        if text:
            return text, "whisper"
        # Fallback на Google
        text, error = await loop.run_in_executor(None, recognize_speech_google, audio_path)
        if text:
            return text, "google"
        return None, error
    else:
        text, error = await loop.run_in_executor(None, recognize_speech_google, audio_path)
        if text:
            return text, "google"
        return None, error

def pcm_to_wav(pcm_data, sample_rate=48000, channels=2, sample_width=2):
    """Конвертация PCM данных в WAV файл"""
    with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as f:
        with wave.open(f.name, 'wb') as wav:
            wav.setnchannels(channels)
            wav.setsampwidth(sample_width)
            wav.setframerate(sample_rate)
            wav.writeframes(pcm_data)
        return f.name

async def generate_voice_response(user_text, user_name, guild_id):
    """Генерация ответа через ИИ для голосового общения"""
    # Получаем контекст из мыслей
    thoughts = get_thoughts(guild_id, limit=10)
    memory = ""
    if thoughts:
        memory = "\n".join([t[3] if isinstance(t, tuple) else t.get('content', '') for t in thoughts[:5]])
    
    prompt = f"""Ти голосовий помічник у Discord. Відповідай коротко (1-2 речення), дружньо, можна з гумором.
Не використовуй емодзі та спеціальні символи - твоя відповідь буде озвучена.

Контекст сервера:
{memory}

Користувач {user_name} сказав голосом: "{user_text}"

Відповідай українською, коротко і по справі:"""

    ok, response = call_external_model(prompt, timeout=10)
    
    if ok and response:
        # Очищаем от эмодзи и спецсимволов для TTS
        import re
        clean = re.sub(r'[^\w\s\.\,\!\?\-\:\;\'\"\(\)]', '', response)
        clean = clean.strip()
        if len(clean) > 200:
            # Обрезаем до последнего предложения
            sentences = re.split(r'[.!?]', clean[:200])
            if len(sentences) > 1:
                clean = '.'.join(sentences[:-1]) + '.'
            else:
                clean = clean[:200]
        return clean
    else:
        return "Вибач, я не зміг обробити запит."

# --- Улучшенный синтез речи и воспроизведение ---
# РЕЖИМ: Відповіді тільки текстом (голос вимкнено за замовчуванням)
# Для кожного сервера окремо
voice_response_mode = {}  # {guild_id: True/False} - чи говорити голосом

async def speak_text(vc, text, lang='uk'):
    """Синтез речи и воспроизведение в голосовому каналі"""
    # Якщо голосові відповіді вимкнено для цього сервера - нічого не робимо
    guild_id = vc.guild.id if vc and hasattr(vc, 'guild') else None
    if guild_id and not voice_response_mode.get(guild_id, False):
        return True
        
    if not vc or not vc.is_connected():
        return False
        
    # Ждем, поки закончится предыдущее воспроизведение
    while vc.is_playing():
        await asyncio.sleep(0.5)
    
    try:
        # Создаём TTS
        tts = gTTS(text, lang=lang)
        
        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as fp:
            mp3_path = fp.name
            tts.save(mp3_path)
        
        # Конвертируем в WAV для лучшого якості
        audio = AudioSegment.from_mp3(mp3_path)
        wav_path = mp3_path.replace('.mp3', '.wav')
        audio.export(wav_path, format='wav')
        
        # Воспроизведение
        source = discord.FFmpegPCMAudio(wav_path)
        vc.play(source)
        
        while vc.is_playing():
            await asyncio.sleep(0.5)
        
        # Очистка временных файлов
        try:
            os.unlink(mp3_path)
            os.unlink(wav_path)
        except:
            pass
            
        return True
    except Exception as e:
        print(f"[VOICE TTS] Ошибка: {e}")
        return False

async def speak_text_async(vc, text, lang='uk'):
    """Асинхронный синтез речи без блокировки"""
    asyncio.create_task(speak_text(vc, text, lang))

async def speak_text_force(vc, text, lang='uk'):
    """Примусовий синтез речі (ігнорує режим voice_response_mode)"""
    if not vc or not vc.is_connected():
        return False
        
    # Ждем, поки закончится предыдущее воспроизведение
    while vc.is_playing():
        await asyncio.sleep(0.5)
    
    try:
        # Создаём TTS
        tts = gTTS(text, lang=lang)
        
        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as fp:
            mp3_path = fp.name
            tts.save(mp3_path)
        
        # Конвертируем в WAV для лучшого якості
        audio = AudioSegment.from_mp3(mp3_path)
        wav_path = mp3_path.replace('.mp3', '.wav')
        audio.export(wav_path, format='wav')
        
        # Воспроизведение
        source = discord.FFmpegPCMAudio(wav_path)
        vc.play(source)
        
        while vc.is_playing():
            await asyncio.sleep(0.5)
        
        # Очистка временных файлов
        try:
            os.unlink(mp3_path)
            os.unlink(wav_path)
        except:
            pass
            
        return True
    except Exception as e:
        print(f"[VOICE TTS FORCE] Ошибка: {e}")
        return False

# --- Обработка голосовых команд ---
async def process_voice_command(text, user, guild, vc, text_channel):
    """Обработка распознанного голосового текста"""
    if not text:
        return
        
    text_lower = text.lower().strip()
    user_name = user.display_name if hasattr(user, 'display_name') else str(user)
    
    # Логируем в текстовый канал
    if text_channel:
        await text_channel.send(f"🎤 **{user_name}:** {text}")
    
    # Проверяем на wake word
    has_wake_word = any(wake in text_lower for wake in voice_wake_words)
    
    # Голосовые команды
    if "выйди" in text_lower or "отключись" in text_lower or "уйди" in text_lower:
        await speak_text(vc, "Хорошо, ухожу. Пока!")
        if text_channel:
            await text_channel.send("👋 Виходжу з голосового каналу.")
        await vc.disconnect()
        voice_listen_mode.pop(guild.id, None)
        return
        
    elif "замолчи" in text_lower or "тихо" in text_lower or "молчи" in text_lower:
        voice_listen_mode[guild.id] = False
        await speak_text(vc, "Хорошо, молчу.")
        if text_channel:
            await text_channel.send("🔇 Режим прослуховування вимкнено. Використовуйте `!listen` щоб увімкнути.")
        return
        
    elif "слушай" in text_lower or "активируйся" in text_lower:
        voice_listen_mode[guild.id] = True
        await speak_text(vc, "Слушаю вас.")
        if text_channel:
            await text_channel.send("🔊 Режим прослуховування увімкнено.")
        return
    
    elif "который час" in text_lower or "сколько времени" in text_lower or "время" in text_lower:
        now = datetime.now().strftime("%H:%M")
        await speak_text(vc, f"Сейчас {now}")
        return
        
    elif "как дела" in text_lower or "как ты" in text_lower:
        responses = ["Отлично, спасибо что спросил!", "Всё хорошо, готов помочь!", "Супер, давай обічся!"]
        import random
        await speak_text(vc, random.choice(responses))
        return
    
    # Если есть wake word или режим прослушивания активен - генерируем ИИ ответ
    if has_wake_word or voice_listen_mode.get(guild.id, False):
        # Убираем wake word из текста
        query = text_lower
        for wake in voice_wake_words:
            query = query.replace(wake, "").strip()
        
        if query:
            if text_channel:
                await text_channel.send("🤔 Думаю над відповіддю...")
            
            response = await generate_voice_response(query, user_name, guild.id)
            
            if response:
                await speak_text(vc, response)
                if text_channel:
                    await text_channel.send(f"!tts uk {response}")
                    
                # Сохраняем в мысли
                add_thought(guild.id, user.id if hasattr(user, 'id') else 0, 
                           f"Голосовий диалог - {user_name}: {text} → Бот: {response}")

# --- Запись голоса из Discord (используя discord.py Sinks) ---
class VoiceRecorder:
    """Класс для записи и обработки голоса из Discord"""
    
    def __init__(self, guild_id, text_channel, vc):
        self.guild_id = guild_id
        self.text_channel = text_channel
        self.vc = vc
        self.is_recording = False
        self.audio_queue = asyncio.Queue()
        
    async def start_recording(self):
        """Начать запись голоса"""
        if not hasattr(self.vc, 'start_recording'):
            # discord.py не поддерживает запись напрямую
            # Используем альтернативный подход через receive
            await self.text_channel.send(
                "⚠️ **Увага:** Для повноцінного розпізнавання голосу потрібен py-cord замість discord.py.\n"
                "Зараз використовується спрощений режим: скажіть команду після звукового сигналу."
            )
            return False
        
        self.is_recording = True
        # Для py-cord можно использовать vc.start_recording()
        return True
        
    async def stop_recording(self):
        """Остановить запись"""
        self.is_recording = False

# Глобальный словарь рекордеров
voice_recorders = {}

async def start_voice_listening(ctx):
    """Запуск режима голосового прослушивания"""
    guild_id = ctx.guild.id
    vc = voice_clients.get(guild_id) or ctx.guild.voice_client
    
    if not vc or not vc.is_connected():
        vc = await join_voice_channel(ctx)
        if not vc:
            return False
    
    voice_listen_mode[guild_id] = True
    voice_text_channels[guild_id] = ctx.channel
    
    await ctx.send(
        "🎤 **Голосовий режим активовано!**\n\n"
        "Як користуватися:\n"
        "• Скажіть «Ботик» або «Компотик» + ваше питання\n"
        "• Команди: «Виключись», «Замовкни», «Котра година»\n"
        "• Бот відповість голосом\n\n"
        "Для запису голосу використовуйте `!record`"
    )
    
    await speak_text(vc, "Привет! Голосовий режим активирован. Обращайся ко мне по имени.")
    return True

# --- Записи и распознавание речи (SpeechRecognition + pydub) ---
async def record_and_recognize(vc, ctx, duration=5):
    """Запись голоса и распознавание (симуляция через микрофон)"""
    await ctx.send(f"🎙️ Записую {duration} секунд... Говоріть зараз!")
    
    # Создаём временный файл
    with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp:
        tmp_path = tmp.name
    
    try:
        # Используем speech_recognition для записи с микрофона сервера
        # (Это работает только если бот запущен на машине с микрофоном)
        recognizer = sr.Recognizer()
        
        # Альтернативный метод: просим пользователя отправить голосовое сообщение
        await ctx.send(
            "⚠️ **Альтернативний спосіб:**\n"
            "Відправте голосове повідомлення в цей канал, і я його розпізнаю!\n"
            "Або використовуйте `!say <текст>` для синтезу мовлення."
        )
        
        return None
        
    except Exception as e:
        await ctx.send(f"❌ Помилка запису: {e}")
        return None

async def process_voice_message(message, attachment):
    """Обработка голосового сообщения: распознавание и ответ через ИИ"""
    guild = message.guild
    channel = message.channel
    author = message.author
    
    try:
        # Скачиваем аудио файл
        with tempfile.NamedTemporaryFile(delete=False, suffix='.ogg') as tmp:
            await attachment.save(tmp.name)
            ogg_path = tmp.name
        
        # Конвертируем в WAV
        try:
            audio = AudioSegment.from_file(ogg_path)
            wav_path = ogg_path.replace('.ogg', '.wav')
            audio.export(wav_path, format='wav')
        except Exception as e:
            await channel.send(f"⚠️ Помилка конвертації: {e}")
            return
        
        # Распознаваем речь
        await channel.send("🎙️ Розпізнаю мовлення...")
        text, engine = await recognize_speech(wav_path)
        
        # Очистка временных файлов
        try:
            os.unlink(ogg_path)
            os.unlink(wav_path)
        except:
            pass
        
        if not text:
            await channel.send("❌ Не вдалося розпізнати мовлення.")
            return
        
        # Показываем распознанний текст
        await channel.send(f"📝 **{author.display_name} сказав:** {text}")
        
        # Проверяем, єсть підключення до голосового каналу
        vc = voice_clients.get(guild.id) or guild.voice_client
        
        # Обрабатываем как голосовую команду
        if vc and vc.is_connected():
            await process_voice_command(text, author, guild, vc, channel)
        else:
            # Генерируем текстовый ответ через ИИ
            response = await generate_voice_response(text, author.display_name, guild.id)
            if response:
                await channel.send(f"!tts uk {response}")
                # Сохраняем диалог
                add_thought(guild.id, author.id, 
                           f"Голосове повідомлення - {author.display_name}: {text} → Бот: {response}")
                
    except Exception as e:
        await channel.send(f"❌ Помилка обробки голосового повідомлення: {e}")
        print(f"[VOICE MSG ERROR] {e}")

# --- Команды ---
@bot.command(name="join")
async def join(ctx):
    await join_voice_channel(ctx)

@bot.command(name="leave")
async def leave(ctx):
    # Отключаем режим прослушивания
    voice_listen_mode.pop(ctx.guild.id, None)
    voice_text_channels.pop(ctx.guild.id, None)
    await leave_voice_channel(ctx)

@bot.command(name="say")
async def say(ctx, *, text: str):
    """!say <текст> — озвучить текст в голосовому каналі"""
    vc = voice_clients.get(ctx.guild.id) or ctx.guild.voice_client
    if not vc or not vc.is_connected():
        vc = await join_voice_channel(ctx)
    if vc:
        await ctx.send(f"🔊 Озвучую: {text[:100]}...")
        await speak_text_force(vc, text)

@bot.command(name="listen")
async def listen(ctx):
    """!listen — включить режим голосового прослушивания"""
    result = await start_voice_listening(ctx)
    if not result:
        await ctx.send("❌ Не вдалося активувати голосовий режим.")

@bot.command(name="stoplisten")
async def stoplisten(ctx):
    """!stoplisten — вимкнути режим прослуховування"""
    voice_listen_mode[ctx.guild.id] = False
    await ctx.send("🔇 Режим прослуховування вимкнено.")

@bot.command(name="autoconnect")
async def autoconnect(ctx, mode: str = None):
    """!autoconnect [on/off] — увімкнути/вимкнути авто-підключення до голосових каналів"""
    guild_id = ctx.guild.id
    
    if mode is None:
        # Показати поточний статус
        current = auto_voice_join.get(guild_id, False)
        status = "✅ увімкнено" if current else "❌ вимкнено"
        await ctx.send(f"🔊 Авто-підключення: {status}\n"
                       f"Використання: `!autoconnect on` або `!autoconnect off`")
        return
    
    mode = mode.lower()
    if mode in ["on", "1", "true", "yes", "так", "увімкнути"]:
        auto_voice_join[guild_id] = True
        await ctx.send("✅ Авто-підключення увімкнено!\n"
                       "Бот буде автоматично заходити в голосовий канал, коли там є 2+ людини.")
    elif mode in ["off", "0", "false", "no", "ні", "вимкнути"]:
        auto_voice_join[guild_id] = False
        await ctx.send("❌ Авто-підключення вимкнено!\n"
                       "Використовуйте `!join` для ручного підключення.")
    else:
        await ctx.send("❓ Невідомий режим. Використовуйте: `!autoconnect on` або `!autoconnect off`")

@bot.command(name="voicechat")
async def voicechat(ctx, *, text: str = None):
    """!voicechat <текст> — поговорить з ботом голосом (он ответит в голосовому каналі)"""
    vc = voice_clients.get(ctx.guild.id) or ctx.guild.voice_client
    if not vc or not vc.is_connected():
        vc = await join_voice_channel(ctx)
    
    if not vc:
        await ctx.send("❌ Не можу підключитися до голосового каналу.")
        return
    
    if not text:
        await ctx.send("❓ Вкажіть текст для спілкування: `!voicechat привіт, як справи?`")
        return
    
    await ctx.send("🤔 Думаю...")
    
    # Генерируем ответ через ИИ
    response = await generate_voice_response(text, ctx.author.display_name, ctx.guild.id)
    
    if response:
        await ctx.send(f"!tts uk {response}")
        await speak_text(vc, response)
        # Сохраняем диалог
        add_thought(ctx.guild.id, ctx.author.id, 
                   f"Голосовий чат - {ctx.author.display_name}: {text} → Бот: {response}")

@bot.command(name="recognize")
async def recognize_cmd(ctx):
    """!recognize — распознать голосовое сообщение (ответьте на голосовое сообщение)"""
    if not ctx.message.reference:
        await ctx.send("❓ Відповідайте цією командою на голосове повідомлення!")
        return
    
    try:
        ref_msg = await ctx.channel.fetch_message(ctx.message.reference.message_id)
        
        # Проверяем, єсть вкладень
        if not ref_msg.attachments:
            await ctx.send("❌ В повідомленні немає вкладень.")
            return
        
        # Іщем аудіо файл
        audio_attachment = None
        for att in ref_msg.attachments:
            if att.content_type and 'audio' in att.content_type:
                audio_attachment = att
                break
            if att.filename.endswith(('.ogg', '.mp3', '.wav', '.m4a', '.webm')):
                audio_attachment = att
                break
        
        if not audio_attachment:
            await ctx.send("❌ Не знайдено аудіо файл у повідомленні.")
            return
        
        await ctx.send("🎙️ Завантую та розпізнаю...")
        
        # Скачиваем файл
        with tempfile.NamedTemporaryFile(delete=False, suffix='.ogg') as tmp:
            await audio_attachment.save(tmp.name)
            ogg_path = tmp.name
        
        # Конвертируем в WAV
        try:
            audio = AudioSegment.from_file(ogg_path)
            wav_path = ogg_path.replace('.ogg', '.wav')
            audio.export(wav_path, format='wav')
        except Exception as e:
            await ctx.send(f"❌ Помилка конвертації аудіо: {e}")
            return
        
        # Распознаваем
        text, engine = await recognize_speech(wav_path)
        
        # Очистка
        try:
            os.unlink(ogg_path)
            os.unlink(wav_path)
        except:
            pass
        
        if text:
            await ctx.send(f"📝 **Розпізнаю ({engine}):**\n{text}")
            
            # Спрашиваем, нужен ли ответ
            vc = voice_clients.get(ctx.guild.id) or ctx.guild.voice_client
            if vc and vc.is_connected():
                await ctx.send("🤔 Генерируем відповідь...")
                response = await generate_voice_response(text, ref_msg.author.display_name, ctx.guild.id)
                if response:
                    await ctx.send(f"!tts uk {response}")
                    await speak_text(vc, response)
        else:
            await ctx.send("❌ Не вдалося розпізнати мовлення.")
            
    except Exception as e:
        await ctx.send(f"❌ Помилка: {e}")

@bot.command(name="tts")
async def tts_cmd(ctx, lang: str = "ru", *, text: str = None):
    """!tts [мова] <текст> — синтез речі (мови: ru, uk, en)"""
    if text is None:
        # Может быть язык не указан
        if lang and lang not in ["ru", "uk", "en", "de", "fr", "es"]:
            text = lang
            lang = "ru"
        else:
            await ctx.send("❓ Вкажіть текст: `!tts привіт` або `!tts uk привіт`")
            return
    
    vc = voice_clients.get(ctx.guild.id) or ctx.guild.voice_client
    if not vc or not vc.is_connected():
        vc = await join_voice_channel(ctx)
    
    if vc:
        await ctx.send(f"🔊 Озвучую ({lang}): {text[:50]}...")
        await speak_text_force(vc, text, lang=lang)

@bot.command(name="voicehelp")
async def voicehelp(ctx):
    """!voicehelp — справка по голосовым командам"""
    voice_on = voice_response_mode.get(ctx.guild.id, False)
    help_text = f"""🎤 **Голосові команди:**

**Підключення:**
• `!join` — підключитися до голосового каналу
• `!leave` — вийти з голосового каналу

**Режим відповідей:**
• `!voiceon` — бот відповідає голосом 🔊
• `!voiceoff` — бот відповідає тільки текстом 📝
• **Поточний режим:** {'🔊 Голос' if voice_on else '📝 Текст'}

**Синтез мовлення:**
• `!say <текст>` — озвучити текст
• `!tts [мова] <текст>` — озвучити з вибором мови (ru/uk/en)

**ІІ спілкування:**
• `!voicechat <текст>` — поговорити з ботом (відповідь голосом)
• `!ask <питання>` — питання до ІІ (відповідь текстом)

**Розпізнавання:**
• `!recognize` — відповісти на голосове повідомлення для розпізнавання
• `!listen` — увімкнути режим прослуховування
• `!stoplisten` — вимкнути режим

**Як працюється голосовий режим:**
1. Увійдіть в голосовий канал
2. Напишіть `!listen` для активації
3. Відправляйте голосові повідомлення
4. Бот розпізнає та відповість голосом

**Whisper:** {'✅ Встановлено' if WHISPER_AVAILABLE else '❌ Не встановлено (pip install openai-whisper)'}
"""
    await ctx.send(help_text)

@bot.command(name="voiceon")
async def voiceon_cmd(ctx):
    """!voiceon — увімкнути голосові відповіді"""
    voice_response_mode[ctx.guild.id] = True
    await ctx.send("🔊 **Голосові відповіді увімкнено!** Бот буде відповідати голосом.")

@bot.command(name="voiceoff")
async def voiceoff_cmd(ctx):
    """!voiceoff — вимкнути голосові відповіді (тільки текстом)"""
    voice_response_mode[ctx.guild.id] = False
    await ctx.send("📝 **Голосові відповіді вимкнено!** Бот буде відповідати тільки текстом.")

# --- Автоматичний голосовий цикл ---
async def voice_auto_loop(guild_id, ctx):
    vc = voice_clients.get(guild_id)
    if not vc or not vc.is_connected():
        return
    await ctx.send("🎤 **Автоматичний режим активовано!**\nВідправляйте голосові повідомлення для спілкування.")
    
    voice_listen_mode[guild_id] = True
    voice_text_channels[guild_id] = ctx.channel
    
    while vc.is_connected() and voice_listen_mode.get(guild_id, False):
        await asyncio.sleep(2)
    
    await ctx.send("🔇 Автоматичний режим завершено.")

@bot.command(name="autovoice")
async def autovoice(ctx):
    """!autovoice — включить автоматичний голосовий режим"""
    vc = voice_clients.get(ctx.guild.id) or ctx.guild.voice_client
    if not vc or not vc.is_connected():
        vc = await join_voice_channel(ctx)
    if vc:
        bot.loop.create_task(voice_auto_loop(ctx.guild.id, ctx))
        await speak_text(vc, "Автоматичний режим включено. Отправляйте голосові повідомлення.")

@bot.command(name="ping")
async def ping(ctx):
    """Диагностическая команда: отримається pong"""
    latency = round(bot.latency * 1000)
    await ctx.send(f"🏓! Затримка: {latency}ms")

# В деяких случаях команди могли бути зареєстровані на іншем бот
# Перерегистрируем ключові голосові команди на поточному екземплярі
# Голосові команди вже зареєстровані через декоратори
def init_db():
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        f"""
        CREATE TABLE IF NOT EXISTS users (
            guild_id INTEGER,
            user_id INTEGER,
            text INTEGER DEFAULT 0,
            voice INTEGER DEFAULT 0,
            events INTEGER DEFAULT 0,
            other INTEGER DEFAULT 0,
            threshold INTEGER DEFAULT {DEFAULT_THRESHOLD}
            , PRIMARY KEY (guild_id, user_id)
        )
        """
    )
    # Таблиця для отслеживания входов/вих
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS member_events (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            guild_id INTEGER,
            user_id INTEGER,
            username TEXT,
            event_type TEXT,
            timestamp TEXT
        )
        """
    )

    # Настройки сервера для мыслей (вкл/вимкнено)
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS guild_settings (
            guild_id INTEGER PRIMARY KEY,
            thoughts_enabled INTEGER DEFAULT 0,
            thought_interval INTEGER DEFAULT 60
        )
        """
    )

    # Журнал мыслей
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS thoughts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            guild_id INTEGER,
            created_by INTEGER,
            timestamp TEXT,
            content TEXT
        )
        """
    )

    # Таблиця пользовательських согласий на анализ
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS ai_consent (
            guild_id INTEGER,
            user_id INTEGER,
            consent INTEGER DEFAULT 0,
            allow_external INTEGER DEFAULT 0,
            PRIMARY KEY (guild_id, user_id)
        )
        """
    )

    # ========== СИСТЕМА ОБУЧЕНИЯ НА СООБЩЕНИЯ ПОЛЬЗОВАТЕЛЯ ==========
    # Таблиця для хранення прикладних сообщений для навчення
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS chat_learning (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            guild_id INTEGER,
            user_id INTEGER,
            username TEXT,
            message TEXT,
            timestamp TEXT,
            message_type TEXT DEFAULT 'regular'
        )
        """
    )
    
    # Таблиця для хранення аналізу стилю пользователей
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS user_style_profile (
            guild_id INTEGER,
            user_id INTEGER,
            username TEXT,
            vocabulary_sample TEXT,
            common_phrases TEXT,
            avg_message_length INTEGER DEFAULT 0,
            topics TEXT,
            humor_style TEXT,
            last_updated TEXT,
            PRIMARY KEY (guild_id, user_id)
        )
        """
    )
    
    # Настройки навчення для сервера
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS learning_settings (
            guild_id INTEGER PRIMARY KEY,
            learning_enabled INTEGER DEFAULT 0,
            min_messages_for_profile INTEGER DEFAULT 20,
            max_stored_messages INTEGER DEFAULT 500
        )
        """
    )
    
    # Таблиця предпочтительних імен пользователей
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS user_nicknames (
            guild_id INTEGER,
            user_id INTEGER,
            preferred_name TEXT,
            set_at TEXT,
            PRIMARY KEY (guild_id, user_id)
        )
        """
    )

    # Таблиця для принудительной привязки персоны к пользователю (персоны по user_id)
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS persona_overrides (
            guild_id INTEGER,
            user_id INTEGER,
            note TEXT,
            PRIMARY KEY (guild_id, user_id)
        )
        """
    )

    # Таблица для хранения сообщений, которые отправил бот (память бота)
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS bot_memory (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            guild_id INTEGER,
            channel_id INTEGER,
            message_id INTEGER,
            content TEXT,
            timestamp TEXT
        )
        """
    )

    conn.commit()
    conn.close()

def upsert_user(guild_id, user_id):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("INSERT OR IGNORE INTO users (guild_id, user_id) VALUES (?, ?)", (guild_id, user_id))
    conn.commit()
    conn.close()

def set_field(guild_id, user_id, field, value):
    if field not in MAX_POINTS:
        return False
    value = max(0, min(MAX_POINTS[field], int(value)))
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(f"UPDATE users SET {field} = ? WHERE guild_id = ? AND user_id = ?", (value, guild_id, user_id))
    conn.commit()
    conn.close()
    return True


def save_bot_message(guild_id, channel_id, message_id, content, timestamp=None):
    """Сохранить сообщение, отправленное ботом, в таблицу bot_memory."""
    try:
        conn = sqlite3.connect(DB_PATH)
        cur = conn.cursor()
        ts = timestamp or datetime.utcnow().isoformat()
        cur.execute(
            "INSERT INTO bot_memory (guild_id, channel_id, message_id, content, timestamp) VALUES (?, ?, ?, ?, ?)",
            (guild_id, channel_id, message_id, content, ts)
        )
        conn.commit()
    except Exception:
        pass
    finally:
        try:
            conn.close()
        except Exception:
            pass


def get_bot_messages(guild_id, limit=10):
    """Получить последние сообщения бота для сервера."""
    try:
        conn = sqlite3.connect(DB_PATH)
        cur = conn.cursor()
        cur.execute(
            "SELECT message_id, channel_id, content, timestamp FROM bot_memory WHERE guild_id = ? ORDER BY id DESC LIMIT ?",
            (guild_id, limit)
        )
        rows = cur.fetchall()
        return rows
    except Exception:
        return []
    finally:
        try:
            conn.close()
        except Exception:
            pass


def set_persona_override(guild_id, user_id, note=None):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("INSERT OR REPLACE INTO persona_overrides (guild_id, user_id, note) VALUES (?, ?, ?)", (guild_id, user_id, note))
    conn.commit()
    conn.close()


def clear_persona_override(guild_id, user_id):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("DELETE FROM persona_overrides WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    conn.commit()
    conn.close()


def is_persona_override(guild_id, user_id):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT 1 FROM persona_overrides WHERE guild_id = ? AND user_id = ? LIMIT 1", (guild_id, user_id))
    row = cur.fetchone()
    conn.close()
    return bool(row)

def add_field(guild_id, user_id, field, delta):
    if field not in MAX_POINTS:
        return False
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(f"SELECT {field} FROM users WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    row = cur.fetchone()
    if row is None:
        upsert_user(guild_id, user_id)
        cur.execute(f"SELECT {field} FROM users WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
        row = cur.fetchone()
    current = row[0] or 0
    new = max(0, min(MAX_POINTS[field], current + int(delta)))
    cur.execute(f"UPDATE users SET {field} = ? WHERE guild_id = ? AND user_id = ?", (new, guild_id, user_id))
    conn.commit()
    conn.close()
    return True

def get_user(guild_id, user_id):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT text, voice, events, other, threshold FROM users WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    row = cur.fetchone()
    conn.close()
    if row:
        return {"text": row[0], "voice": row[1], "events": row[2], "other": row[3], "threshold": row[4]}
    return None

def reset_user(guild_id, user_id):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("UPDATE users SET text=0, voice=0, events=0, other=0 WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    conn.commit()
    conn.close()

def set_threshold_for_guild(guild_id, value):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("UPDATE users SET threshold = ? WHERE guild_id = ?", (int(value), guild_id))
    # Also insert a dummy row for guild owner later if needed; simpler: update existing rows only.
    conn.commit()
    conn.close()

# ---------- Мысли (internal monologue) ----------
def set_guild_thoughts_enabled(guild_id, enabled):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("INSERT OR REPLACE INTO guild_settings (guild_id, thoughts_enabled) VALUES (?, ?)", (guild_id, 1 if enabled else 0))
    conn.commit()
    conn.close()

# ---------- AI consent and analysis ----------
def set_user_consent(guild_id, user_id, consent=True, allow_external=False):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        "INSERT OR REPLACE INTO ai_consent (guild_id, user_id, consent, allow_external) VALUES (?, ?, ?, ?)",
        (guild_id, user_id, 1 if consent else 0, 1 if allow_external else 0)
    )
    conn.commit()
    conn.close()

def get_user_consent(guild_id, user_id):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT consent, allow_external FROM ai_consent WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    row = cur.fetchone()
    conn.close()
    if not row:
        return False, False
    return bool(row[0]), bool(row[1])

# Проста локальна аналитика (sentiment/keywords/intent)
_stopwords = set(["the","and","is","in","it","of","to","a","an","i","you","we","they","on","for","with","this","that"])  # простой набор
_positive = set(["good","great","awesome","nice","thanks","thank","love","like","win","yay","yay!"])
_negative = set(["bad","sad","terrible","hate","angry","no","fail","problem","issue"])

def analyze_text_local(text):
    words = [w.strip(".,!?;:\"'()[]") for w in text.lower().split()]
    words = [w for w in words if w and w not in _stopwords]
    # sentiment
    score = 0
    for w in words:
        if w in _positive:
            score += 1
        if w in _negative:
            score -= 1
    sentiment = "neutral"
    if score > 0:
        sentiment = "positive"
    elif score < 0:
        sentiment = "negative"
    # keywords
    freq = {}
    for w in words:
        freq[w] = freq.get(w, 0) + 1
    keywords = sorted(freq.items(), key=lambda x: -x[1])[:5]
    keywords = [k for k, _ in keywords]
    # intent: question?
    is_question = text.strip().endswith('?')
    summary = text if len(text) < 200 else text[:200] + '...'
    return {
        'sentiment': sentiment,
        'score': score,
        'keywords': keywords,
        'is_question': is_question,
        'summary': summary
    }

import requests

def call_external_model(prompt, provider=None, timeout=10):
    """Выполнить вызов внешней модели.
    Провайдер определяется по EXTERNAL_AI_PROVIDER в .env (например: openai, gemini).
    Поддерживает fallback: если provider='gemini' и вызов неуспешен, попытается OpenAI, если доступен.
    Возвращает (True, text) или (False, error_message).
    """
    # Поддержка отдельных ключей для провайдеров и общего ключа
    gemini_key = os.getenv('EXTERNAL_AI_GEMINI_KEY') or os.getenv('EXTERNAL_AI_API_KEY')
    openai_key = os.getenv('EXTERNAL_AI_OPENAI_KEY') or os.getenv('EXTERNAL_AI_API_KEY')
    env_provider = os.getenv('EXTERNAL_AI_PROVIDER')
    provider = (provider or env_provider or 'auto').lower()

    # Логируем промпт для отладки (файл ai_debug.log)
    try:
        with open('ai_debug.log', 'a', encoding='utf-8') as _lf:
            _lf.write(f'[{datetime.utcnow().isoformat()}] PROVIDER={provider}\nPROMPT:\n{prompt}\n---\n')
    except Exception:
        pass

    def try_openai(key_to_use):
        if not key_to_use:
            return False, 'OpenAI key not configured.'
        try:
            # Используем OpenRouter endpoint вместо OpenAI
            url = 'https://openrouter.ai/api/v1/chat/completions'
            headers = {
                'Authorization': f'Bearer {key_to_use}',
                'Content-Type': 'application/json',
                'HTTP-Referer': 'https://github.com/utuba/discord_activity_bot',
                'User-Agent': 'discord-activity-bot/1.0 (https://github.com/utuba/discord_activity_bot)'
            }
            payload = {
                'model': os.getenv('EXTERNAL_AI_OPENAI_MODEL', 'openai/gpt-3.5-turbo'),
                'messages': [{'role': 'user', 'content': prompt}],
                'max_tokens': 200
            }
            r = requests.post(url, headers=headers, json=payload, timeout=timeout)
            if r.ok:
                data = r.json()
                text = None
                # try common places
                choices = data.get('choices') or []
                if choices:
                    first = choices[0]
                    if isinstance(first, dict):
                        text = first.get('message', {}).get('content') or first.get('text')
                if not text:
                    text = data.get('text') or data.get('output')
                # Удаляем маркеры <s> и ы если есть
                if text:
                    text = text.replace('<s>', '').replace('ы', '').strip()
                return True, text or 'No text in response.'
            return False, f'HTTP {r.status_code}: {r.text[:200]}'
        except Exception as e:
            return False, str(e)

    def try_gemini(key_to_use):
        if not key_to_use:
            return False, 'Gemini key not configured.'
        try:
            model = os.getenv('EXTERNAL_AI_GEMINI_MODEL', 'models/gemini-pro')
            # Новый endpoint Gemini v1
            url = f'https://generativelanguage.googleapis.com/v1/{model}:generateContent'
            headers = {'Content-Type': 'application/json'}
            params = {'key': key_to_use}
            payload = {
                'contents': [{ 'parts': [{ 'text': prompt }] }],
                'generationConfig': {
                    'temperature': 0.7,
                    'maxOutputTokens': 200
                }
            }
            r = requests.post(url, headers=headers, params=params, json=payload, timeout=timeout)
            if r.ok:
                data = r.json()
                candidates = data.get('candidates') or []
                if candidates:
                    cand = candidates[0]
                    text = cand.get('content') or cand.get('output') or ''
                    # Gemini v1: ответ теперь в cand['content']['parts'][0]['text']
                    if isinstance(text, dict):
                        parts = text.get('parts')
                        if parts and isinstance(parts, list) and 'text' in parts[0]:
                            text = parts[0]['text']
                        else:
                            text = str(text)
                    elif isinstance(text, list):
                        text = ''.join([t.get('text', '') if isinstance(t, dict) else str(t) for t in text])
                    return True, text or 'No text in response.'
                return False, 'No candidates in response.'
            return False, f'HTTP {r.status_code}: {r.text[:200]}'
        except Exception as e:
            return False, str(e)

    # Provider selection and fallback
    if provider == 'openai':
        return try_openai(openai_key)
    elif provider == 'gemini':
        ok, res = try_gemini(gemini_key)
        if ok:
            return ok, res
        # fallback to openai if available
        ok2, res2 = try_openai(openai_key)
        if ok2:
            return ok2, res2
        return False, f'Gemini failed: {res}; OpenAI fallback: {res2}'
    elif provider == 'auto':
        # try gemini first, then openai
        ok, res = try_gemini(gemini_key)
        if ok:
            return ok, res
        ok2, res2 = try_openai(openai_key)
        if ok2:
            return ok2, res2
        return False, f'Gemini failed: {res}; OpenAI failed: {res2}'
    else:
        return False, f'Unknown provider: {provider}'


def call_external_model_with_image(prompt, image_data, mime_type="image/jpeg", provider=None, timeout=30):
    """Выполнить вызов внешней модели с изображением.
    image_data: bytes или base64 строка изображения
    mime_type: тип изображения (image/jpeg, image/png, image/gif, image/webp)
    Возвращает (True, text) или (False, error_message).
    """
    import base64
    
    # Конвертируем bytes в base64 если нужно
    if isinstance(image_data, bytes):
        image_base64 = base64.b64encode(image_data).decode('utf-8')
    else:
        image_base64 = image_data
    
    gemini_key = os.getenv('EXTERNAL_AI_GEMINI_KEY') or os.getenv('EXTERNAL_AI_API_KEY')
    openai_key = os.getenv('EXTERNAL_AI_OPENAI_KEY') or os.getenv('EXTERNAL_AI_API_KEY')
    env_provider = os.getenv('EXTERNAL_AI_PROVIDER')
    provider = (provider or env_provider or 'auto').lower()

    # Логируем для отладки
    try:
        with open('ai_debug.log', 'a', encoding='utf-8') as _lf:
            _lf.write(f'[{datetime.utcnow().isoformat()}] IMAGE_ANALYSIS PROVIDER={provider}\nPROMPT:\n{prompt}\n---\n')
    except Exception:
        pass

    def try_openai_vision(key_to_use):
        if not key_to_use:
            return False, 'OpenAI key not configured.'
        try:
            url = 'https://openrouter.ai/api/v1/chat/completions'
            headers = {
                'Authorization': f'Bearer {key_to_use}',
                'Content-Type': 'application/json',
                'HTTP-Referer': 'https://github.com/utuba/discord_activity_bot',
                'User-Agent': 'discord-activity-bot/1.0'
            }
            # Используем модель с поддержкой vision
            vision_model = os.getenv('EXTERNAL_AI_VISION_MODEL', 'openai/gpt-4o-mini')
            payload = {
                'model': vision_model,
                'messages': [{
                    'role': 'user',
                    'content': [
                        {'type': 'text', 'text': prompt},
                        {'type': 'image_url', 'image_url': {'url': f'data:{mime_type};base64,{image_base64}'}}
                    ]
                }],
                'max_tokens': 500
            }
            r = requests.post(url, headers=headers, json=payload, timeout=timeout)
            if r.ok:
                data = r.json()
                choices = data.get('choices') or []
                if choices:
                    text = choices[0].get('message', {}).get('content')
                    if text:
                        return True, text.strip()
                return False, 'No text in response.'
            return False, f'HTTP {r.status_code}: {r.text[:200]}'
        except Exception as e:
            return False, str(e)

    def try_gemini_vision(key_to_use):
        if not key_to_use:
            return False, 'Gemini key not configured.'
        try:
            # Используем Gemini 1.5 Flash для vision (или gemini-pro-vision)
            vision_model = os.getenv('EXTERNAL_AI_GEMINI_VISION_MODEL', 'models/gemini-1.5-flash')
            url = f'https://generativelanguage.googleapis.com/v1/{vision_model}:generateContent'
            headers = {'Content-Type': 'application/json'}
            params = {'key': key_to_use}
            payload = {
                'contents': [{
                    'parts': [
                        {'text': prompt},
                        {'inline_data': {'mime_type': mime_type, 'data': image_base64}}
                    ]
                }],
                'generationConfig': {
                    'temperature': 0.7,
                    'maxOutputTokens': 500
                }
            }
            r = requests.post(url, headers=headers, params=params, json=payload, timeout=timeout)
            if r.ok:
                data = r.json()
                candidates = data.get('candidates') or []
                if candidates:
                    cand = candidates[0]
                    content = cand.get('content', {})
                    parts = content.get('parts', [])
                    if parts and 'text' in parts[0]:
                        return True, parts[0]['text'].strip()
                return False, 'No text in response.'
            return False, f'HTTP {r.status_code}: {r.text[:200]}'
        except Exception as e:
            return False, str(e)

    # Provider selection and fallback
    if provider == 'openai':
        return try_openai_vision(openai_key)
    elif provider == 'gemini':
        ok, res = try_gemini_vision(gemini_key)
        if ok:
            return ok, res
        ok2, res2 = try_openai_vision(openai_key)
        if ok2:
            return ok2, res2
        return False, f'Gemini vision failed: {res}; OpenAI fallback: {res2}'
    elif provider == 'auto':
        ok, res = try_gemini_vision(gemini_key)
        if ok:
            return ok, res
        ok2, res2 = try_openai_vision(openai_key)
        if ok2:
            return ok2, res2
        return False, f'Gemini vision failed: {res}; OpenAI vision failed: {res2}'
    else:
        return False, f'Unknown provider: {provider}'


async def analyze_image_from_attachment(attachment, prompt=None):
    """Скачать изображение из Discord attachment и проанализировать."""
    # Поддерживаемые форматы
    supported_types = ['image/jpeg', 'image/png', 'image/gif', 'image/webp']
    
    # Определяем MIME тип
    content_type = attachment.content_type
    if not content_type:
        # Определяем по расширению
        ext = attachment.filename.lower().split('.')[-1]
        type_map = {'jpg': 'image/jpeg', 'jpeg': 'image/jpeg', 'png': 'image/png', 'gif': 'image/gif', 'webp': 'image/webp'}
        content_type = type_map.get(ext)
    
    if not content_type or content_type not in supported_types:
        return False, f'Непідтримуваний формат. Підтримуються: JPEG, PNG, GIF, WEBP'
    
    # Скачиваем изображение
    try:
        image_data = await attachment.read()
    except Exception as e:
        return False, f'Помилка завантаження зображення: {e}'
    
    # Проверяем размер (макс 20MB)
    if len(image_data) > 20 * 1024 * 1024:
        return False, 'Зображення занадто велике (макс 20MB)'
    
    # Формируем промпт
    if not prompt:
        prompt = "Опиши це зображення детально. Що на ньому зображено? Які емоції воно викликає?"
    
    return call_external_model_with_image(prompt, image_data, content_type)


async def perform_analysis_and_reply(ctx, text, use_external=False):
    # always do local analysis
    local = analyze_text_local(text)
    reply = f"Аналіз (локально):\nСентимент: {local['sentiment']} (оцінка {local['score']})\nКлючові слова: {', '.join(local['keywords'])}\n"
    if local['is_question']:
        reply += "Запит виглядає як питання.\n"

    if use_external:
        # Проверяем согласие
        consent, allow_ext = get_user_consent(ctx.guild.id, ctx.author.id)
        if not consent or not allow_ext:
            reply += "\n❗ Зовнішній аналіз не дозволено. Попросіть користувача увімкнути: !ai_consent external"
            await ctx.send(reply)
            return
        # формируем промпт из агрегированной summary
        prompt = f"Коротко дай відповідь/інсайт за наступною зведенням:\n{local['summary']}"
        ok, out = call_external_model(prompt)
        if ok:
            reply += f"\nЗовнішня відповідь: {out}"
        else:
            reply += f"\nПомилка зовнішньої моделі: {out}"

    await ctx.send(reply)

def get_guild_thoughts_enabled(guild_id):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT thoughts_enabled FROM guild_settings WHERE guild_id = ?", (guild_id,))
    row = cur.fetchone()
    conn.close()
    return bool(row[0]) if row else False

def add_thought(guild_id, created_by, content):
    # Если content пустой — генерируем мысль через нейросеть
    if not content or not content.strip():
        prompt = "Згенеруй коротку цікаву думку для Discord-сервера."
        ok, out = call_external_model(prompt)
        content = out.strip() if ok and out else "Сьогодні гарний день!"
    # Вставляем в БД и одновременно дописываем в файл (jsonl) для каждого сервера
    ts = datetime.utcnow().isoformat()
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO thoughts (guild_id, created_by, timestamp, content) VALUES (?, ?, ?, ?)",
        (guild_id, created_by or 0, ts, content)
    )
    last_id = cur.lastrowid
    conn.commit()
    conn.close()

    # Пишем в файл в формате JSONL
    try:
        os.makedirs(THOUGHTS_DIR, exist_ok=True)
        file_path = os.path.join(THOUGHTS_DIR, f"thoughts_{guild_id}.jsonl")
        record = {"id": last_id, "created_by": created_by or 0, "timestamp": ts, "content": content}
        with open(file_path, "a", encoding="utf-8") as f:
            f.write(json.dumps(record, ensure_ascii=False) + "\n")
    except Exception as e:
        # Не фатальная ошибка — логируем в консоль
        print(f"Помилка запису файлу думок: {e}")

    return last_id

def get_thoughts(guild_id, limit=10):
    # Спочатку читаем из файла (если есть), іншій — з БД
    file_path = os.path.join(THOUGHTS_DIR, f"thoughts_{guild_id}.jsonl")
    if os.path.exists(file_path):
        try:
            with open(file_path, "r", encoding="utf-8") as f:
                lines = f.readlines()
            # берём последние N записей (файл в хронологическом порядке)
            recent = [json.loads(l) for l in lines if l.strip()][-limit:]
            # возвращаем в порядке от новых к старым, совместимо с интерфейсом (id, created_by, timestamp, content)
            rows = [(r.get("id"), r.get("created_by"), r.get("timestamp"), r.get("content")) for r in reversed(recent)]
            return rows
        except Exception as e:
            print(f"Помилка читання файлу думок: {e}")
            # fallthrough to DB
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT id, created_by, timestamp, content FROM thoughts WHERE guild_id = ? ORDER BY id DESC LIMIT ?", (guild_id, limit))
    rows = cur.fetchall()
    conn.close()
    return rows


def set_guild_thought_interval(guild_id, seconds):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        "INSERT OR REPLACE INTO guild_settings (guild_id, thoughts_enabled, thought_interval) VALUES (?, COALESCE((SELECT thoughts_enabled FROM guild_settings WHERE guild_id = ?), ?)",
        (guild_id, guild_id, int(seconds))
    )
    conn.commit()
    conn.close()


def get_guild_thought_interval(guild_id):
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT thought_interval FROM guild_settings WHERE guild_id = ?", (guild_id,))
    row = cur.fetchone()
    conn.close()
    return int(row[0]) if row and row[0] else 60


def generate_thought_text(guild_id):
    """Генерирует кратку "мысль" на основі агрегированих даних (без чтения сырых сообщений)."""
    try:
        conn = sqlite3.connect(DB_PATH)
        cur = conn.cursor()
        # Количество пользователей и средний балл
        cur.execute("SELECT COUNT(*), AVG(text + voice + events + other) FROM users WHERE guild_id = ?", (guild_id,))
        r = cur.fetchone()
        user_count = r[0] or 0
        avg_score = (r[1] or 0)

        # Топ-3 пользователей
        cur.execute("SELECT user_id, (text + voice + events + other) as total FROM users WHERE guild_id = ? ORDER BY total DESC LIMIT 3", (guild_id,))
        top = cur.fetchall()

        # Изменения за 24 часа
        cutoff = (datetime.utcnow() - timedelta(hours=24)).isoformat()
        cur.execute("SELECT SUM(CASE WHEN event_type = 'join' THEN 1 ELSE 0 END), SUM(CASE WHEN event_type = 'leave' THEN 1 ELSE 0 END) FROM member_events WHERE guild_id = ? AND timestamp >= ?", (guild_id, cutoff))
        ev = cur.fetchone() or (0, 0)
        joins = ev[0] or 0
        leaves = ev[1] or 0

        conn.close()

        parts = []
        parts.append(f"За останні 24 год: +{joins}/-{leaves} учасників.")
        parts.append(f"Користувачів у БД: {user_count}; середній бал: {avg_score:.1f}/{TOTAL_MAX}.")
        if top:
            tops = ", ".join([f"ID {t[0]}:{t[1]}" for t in top])
            parts.append(f"Топ-3 за балами: {tops}.")
        else:
            parts.append("Поки немає активних користувачів.")

        # Невелика рекомендація
        if avg_score < (DEFAULT_THRESHOLD / 100.0) * TOTAL_MAX:
            parts.append("Рекомендація: стимулювати активність (івенти, привітання, завдання).")
        else:
            parts.append("В цілому активність на рівні або вище порогу.")

        return "\n".join(parts)
    except Exception as e:
        return f"Ошибка генерации мысли: {str(e)}"

# ============================================================
# СИСТЕМА ОБУЧЕНИЯ НА СООБЩЕНИЯ ПОЛЬЗОВАТЕЛЯ (Chat Learning)
# ============================================================

LEARNING_DIR = "learning_data"
# Режим длинных ответов по серверам (in-memory)
long_response_mode = {}

# ---------- Функции для имён пользователей ----------

def set_user_nickname(guild_id, user_id, name):
    """Запомнить предпочтительное имя пользователя"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        "INSERT OR REPLACE INTO user_nicknames (guild_id, user_id, preferred_name, set_at) VALUES (?, ?, ?, ?)",
        (guild_id, user_id, name, datetime.utcnow().isoformat())
    )
    conn.commit()
    conn.close()

def get_user_nickname(guild_id, user_id):
    """Получить предпочтительное имя пользователя"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT preferred_name FROM user_nicknames WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    row = cur.fetchone()
    conn.close()
    return row[0] if row else None

def get_all_nicknames(guild_id):
    """Получить все имена для промпта"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT user_id, preferred_name FROM user_nicknames WHERE guild_id = ?", (guild_id,))
    rows = cur.fetchall()
    conn.close()
    return {str(row[0]): row[1] for row in rows}

# ---------- Функции обучения ----------

def get_learning_settings(guild_id):
    """Получить настройки обучения для сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT learning_enabled, min_messages_for_profile, max_stored_messages FROM learning_settings WHERE guild_id = ?", (guild_id,))
    row = cur.fetchone()
    conn.close()
    if row:
        return {
            "learning_enabled": bool(row[0]),
            "min_messages": row[1],
            "max_messages": row[2]
        }
    return {"learning_enabled": False, "min_messages": 20, "max_messages": 500}

def set_learning_enabled(guild_id, enabled):
    """Включить/выключить обучение для сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        "INSERT OR REPLACE INTO learning_settings (guild_id, learning_enabled, min_messages_for_profile, max_stored_messages) VALUES (?, ?, COALESCE((SELECT min_messages_for_profile FROM learning_settings WHERE guild_id = ?), 20), COALESCE((SELECT max_stored_messages FROM learning_settings WHERE guild_id = ?), 500))",
        (guild_id, 1 if enabled else 0, guild_id, guild_id)
    )
    conn.commit()
    conn.close()

def save_message_for_learning(guild_id, user_id, username, message, message_type='regular'):
    """Сохранить сообщение для обучения"""
    settings = get_learning_settings(guild_id)
    if not settings['learning_enabled']:
        return False
    
    # Не сохраняем слишком короткие сообщения или команды
    if len(message.strip()) < 3 or message.strip().startswith('!'):
        return False
    
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    
    # Проверяем лимит сообщений
    cur.execute("SELECT COUNT(*) FROM chat_learning WHERE guild_id = ?", (guild_id,))
    count = cur.fetchone()[0]
    
    if count >= settings['max_messages']:
        # Удаляем старые сообщения
        cur.execute("DELETE FROM chat_learning WHERE guild_id = ? AND id IN (SELECT id FROM chat_learning WHERE guild_id = ? ORDER BY id ASC LIMIT 50)", (guild_id, guild_id))
    
    ts = datetime.utcnow().isoformat()
    cur.execute(
        "INSERT INTO chat_learning (guild_id, user_id, username, message, timestamp, message_type) VALUES (?, ?, ?, ?, ?, ?)",
        (guild_id, user_id, username, message, ts, message_type)
    )
    conn.commit()
    conn.close()
    
    # Также сохраняем в файл для бэкапа
    try:
        os.makedirs(LEARNING_DIR, exist_ok=True)
        file_path = os.path.join(LEARNING_DIR, f"chat_{guild_id}.jsonl")
        record = {"user_id": user_id, "username": username, "message": message, "timestamp": ts, "type": message_type}
        with open(file_path, "a", encoding="utf-8") as f:
            f.write(json.dumps(record, ensure_ascii=False) + "\n")
    except Exception as e:
        print(f"[LEARNING] Ошибка записи файла: {e}")
    
    return True

def get_user_messages(guild_id, user_id, limit=50):
    """Получить последние сообщения пользователя для анализа"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT message, timestamp FROM chat_learning WHERE guild_id = ? AND user_id = ? ORDER BY id DESC LIMIT ?", (guild_id, user_id, limit))
    rows = cur.fetchall()
    conn.close()
    return rows

def get_server_messages(guild_id, limit=100):
    """Получить последние сообщения сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT username, message FROM chat_learning WHERE guild_id = ? ORDER BY id DESC LIMIT ?", (guild_id, limit))
    rows = cur.fetchall()
    conn.close()
    return rows

def analyze_user_style(guild_id, user_id, username):
    """Анализирует стиль общения пользователя"""
    messages = get_user_messages(guild_id, user_id, limit=100)
    settings = get_learning_settings(guild_id)
    
    if len(messages) < settings['min_messages']:
        return None
    
    texts = [m[0] for m in messages]
    
    # Базовая статистика
    total_length = sum(len(t) for t in texts)
    avg_length = total_length // len(texts) if texts else 0
    
    # Собираем часто используемые слова
    stop_words = {'я', 'ти', 'він', 'вона', 'ми', 'ви', 'вони', 'і', 'а', 'але', 'що', 'як', 'де', 'на', 'в', 'у', 'з', 'до', 'для', 'це', 'та', 'не', 'так'}
    words = []
    for t in texts:
        words.extend([w.lower().strip('.,!?;:()[]{}"\'-') for w in t.split() if len(w) > 2])
    
    word_freq = {}
    for w in words:
        if w and w not in stop_words:
            word_freq[w] = word_freq.get(w, 0) + 1
    
    top_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:15]
    vocabulary = ', '.join([w for w, _ in top_words])
    
    # Определяем темы
    topic_keywords = {
        'игры': ['гра', 'грати', 'геймер', 'ігри', 'game', 'play'],
        'аниме': ['аніме', 'манга', 'anime'],
        'музыка': ['музика', 'пісня', 'слухати'],
        'мемы': ['мем', 'кек', 'лол', 'рофл']
    }
    
    all_text = ' '.join(texts).lower()
    user_topics = []
    for topic, keywords in topic_keywords.items():
        if any(kw in all_text for kw in keywords):
            user_topics.append(topic)
    
    topics = ', '.join(user_topics) if user_topics else 'різне'
    
    # Определяем стиль юмора
    humor_markers = {'сарказм': ['сарказм', 'іронія'], 'мемний': ['кек', 'лол', 'рофл', 'база']}
    humor_styles = []
    for style, markers in humor_markers.items():
        if any(m in all_text for m in markers):
            humor_styles.append(style)
    humor = ', '.join(humor_styles) if humor_styles else 'нейтральний'
    
    # Сохраняем профиль
    ts = datetime.utcnow().isoformat()
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        """INSERT OR REPLACE INTO user_style_profile 
           (guild_id, user_id, username, vocabulary_sample, common_phrases, avg_message_length, topics, humor_style, last_updated)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
        (guild_id, user_id, username, vocabulary, '', avg_length, topics, humor, ts)
    )
    conn.commit()
    conn.close()
    
    return {"vocabulary": vocabulary, "avg_length": avg_length, "topics": topics, "humor": humor}

def get_user_style_profile(guild_id, user_id):
    """Получить профиль стиля пользователя"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT username, vocabulary_sample, avg_message_length, topics, humor_style, last_updated FROM user_style_profile WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    row = cur.fetchone()
    conn.close()
    if row:
        return {
            "username": row[0], "vocabulary": row[1], "avg_length": row[2],
            "topics": row[3], "humor": row[4], "last_updated": row[5]
        }
    return None

def get_server_style_summary(guild_id, limit=5):
    """Получить кратку сводку о стилі общения на сервері"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT username, vocabulary_sample, humor_style FROM user_style_profile WHERE guild_id = ? ORDER BY last_updated DESC LIMIT ?", (guild_id, limit))
    profiles = cur.fetchall()
    cur.execute("SELECT username, message FROM chat_learning WHERE guild_id = ? ORDER BY id DESC LIMIT 15", (guild_id,))
    recent = cur.fetchall()
    conn.close()
    
    if not profiles and not recent:
        return None
    
    parts = []
    if profiles:
        parts.append("Стилі учасників:")
        for p in profiles[:3]:
            if p[1]:
                parts.append(f"• {p[0]}: {p[1][:40]}")
    if recent:
        parts.append("Приклади повідомлень:")
        for msg in recent[:5]:
            if len(msg[1]) > 5:
                parts.append(f"• {msg[0]}: \"{msg[1][:50]}\"")
    
    return "\n".join(parts)

def get_learning_stats(guild_id):
    """Получить статистику обучения"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT COUNT(*) FROM chat_learning WHERE guild_id = ?", (guild_id,))
    total = cur.fetchone()[0]
    cur.execute("SELECT COUNT(DISTINCT user_id) FROM chat_learning WHERE guild_id = ?", (guild_id,))
    users = cur.fetchone()[0]
    cur.execute("SELECT COUNT(*) FROM user_style_profile WHERE guild_id = ?", (guild_id,))
    profiles = cur.fetchone()[0]
    conn.close()
    return {"total_messages": total, "unique_users": users, "profiles_count": profiles}

def clear_learning_data(guild_id, user_id=None):
    """Очистить данні обучения"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    if user_id:
        cur.execute("DELETE FROM chat_learning WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
        cur.execute("DELETE FROM user_style_profile WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    else:
        cur.execute("DELETE FROM chat_learning WHERE guild_id = ?", (guild_id,))
        cur.execute("DELETE FROM user_style_profile WHERE guild_id = ?", (guild_id,))
    conn.commit()
    conn.close()

# ============================================================

# ---------- Commands ----------
@bot.event
async def on_ready():
    print(f"Logged in as {bot.user} (id: {bot.user.id})")
    # Диагностика: покажем зарегистрировані команди
    try:
        cmd_list = ', '.join(sorted([c.name for c in bot.commands]))
        print(f"[DEBUG] Зарегистровані команди: {cmd_list}")
        # Доп. диагностика
        print(f"[DEBUG] all_commands keys: {sorted(list(bot.all_commands.keys()))}")
        print(f"[DEBUG] get_command('join'): {bot.get_command('join')}")
    except Exception as e:
        print(f"[DEBUG] Ошибка получения списка команд: {e}")
    init_db()
    
    # Регистрируем persistent views для онбординга
    try:
        for guild in bot.guilds:
            init_onboarding_db()
            enabled, quarantine_role_id, _, _ = get_onboarding_settings(guild.id)
            if enabled:
                view = create_onboarding_view(guild, quarantine_role_id)
                bot.add_view(view)
        print("[DEBUG] Persistent views зарегистрированы")
    except Exception as e:
        print(f"[DEBUG] Ошибка регистрации persistent views: {e}")
    
    # Запускаем фонову задачу, яка генеруємо мысли для серверів, де включено
    try:
        asyncio.create_task(thoughts_background_task())
    except Exception:
        pass
    # Запускаем задачу анализа стилей
    try:
        asyncio.create_task(learning_background_task())
    except Exception:
        pass


async def learning_background_task():
    """Фонову задача для периодического анализа стилей пользователей."""
    await asyncio.sleep(60)  # Даём боту время на сбор сообщений
    while True:
        try:
            conn = sqlite3.connect(DB_PATH)
            cur = conn.cursor()
            # Получаем сервери с включённим обучением
            cur.execute("SELECT guild_id FROM learning_settings WHERE learning_enabled = 1")
            guilds = cur.fetchall()
            
            for (gid,) in guilds:
                # Получаем пользователей с >= 20 сообщений без свежего профиля
                cur.execute("""
                    SELECT user_id, COUNT(*) as cnt FROM chat_learning 
                    WHERE guild_id = ? 
                    GROUP BY user_id 
                    HAVING cnt >= 20
                """, (gid,))
                users = cur.fetchall()
                
                for user_id, msg_count in users:
                    # Проверяем, анализировали ли недавно
                    cur.execute("""
                        SELECT last_updated FROM user_style_profile 
                        WHERE user_id = ? AND guild_id = ?
                    """, (user_id, gid))
                    profile = cur.fetchone()

                    if profile:
                        last_update = datetime.fromisoformat(profile[0])
                        if datetime.utcnow() - last_update < timedelta(hours=6):
                            continue  # Анализировали недавно

                    # Анализируем стиль
                    messages = get_user_messages(user_id, gid, 50)
                    if messages:
                        analyze_user_style(user_id, gid, messages)

            conn.close()
        except Exception as e:
            print(f"Ошибка в learning_background_task: {e}")
        
        await asyncio.sleep(300)  # Проверяем каждые 5 минут


async def thoughts_background_task():
    """Фонову задача, яка периодически генеруємо мысли для включених серверів.
    Для кожного сервера використається інтервал (в хви), заданий в guild_settings.thought_interval.
    """
    await asyncio.sleep(10)  # Даём боту время на ініцизацію
    while True:
        try:
            conn = sqlite3.connect(DB_PATH)
            cur = conn.cursor()
            cur.execute("SELECT guild_id, thought_interval FROM guild_settings WHERE thoughts_enabled = 1")
            rows = cur.fetchall()

            now = datetime.utcnow()
            for gid, interval in rows:
                try:
                    # Получаем время последней мысли
                    cur.execute("SELECT timestamp FROM thoughts WHERE guild_id = ? ORDER BY id DESC LIMIT 1", (gid,))
                    last = cur.fetchone()
                    last_ts = datetime.fromisoformat(last[0]) if last and last[0] else None
                    seconds = int(interval) if interval else 60
                    if last_ts is None or (now - last_ts) >= timedelta(seconds=seconds):
                        content = generate_thought_text(gid)
                        add_thought(gid, 0, content)
                except Exception as e:
                    print(f"Ошибка при генерации мысли для {gid}: {e}")

            conn.close()
        except Exception as e:
            print(f"Ошибка в thoughts_background_task: {e}")
        # Ждем 30 секунд перед наступного перевіку
        await asyncio.sleep(30)

def parse_member(maybe_member, ctx):
    # try converting mention/id to Member
    if isinstance(maybe_member, discord.Member):
        return maybe_member
    if maybe_member is None:
        return ctx.author
    try:
        mid = int(maybe_member.strip("<@!>"))
        return ctx.guild.get_member(mid) or ctx.author
    except:
        return ctx.author

@bot.command(name="add")
async def cmd_add(ctx, member: discord.Member, category: str, amount: int):
    """!add @user text 3  — добавить 3 очка в категорию (text/voice/events/other)"""
    category = category.lower()
    upsert_user(ctx.guild.id, member.id)
    if category not in MAX_POINTS:
        await ctx.send("Неправильна категорія. Використовуйте: text, voice, events, other")
        return
    add_field(ctx.guild.id, member.id, category, amount)
    data = get_user(ctx.guild.id, member.id)
    await ctx.send(f"Додано {amount} у {category} для {member.display_name}. Поточне значення: {data[category]}/{MAX_POINTS[category]}")

@bot.command(name="set")
async def cmd_set(ctx, member: discord.Member, *, kv_pairs: str):
    """
    !set @user text 12 voice 8 events 5 other 4
    Можно указывать любое подмножество полей.
    """
    upsert_user(ctx.guild.id, member.id)
    parts = kv_pairs.split()
    if len(parts) % 2 != 0:
        await ctx.send("Неправильний формат. Приклад: !set @user text 12 voice 8")
        return
    changed = []
    for i in range(0, len(parts), 2):
        field = parts[i].lower()
        try:
            val = int(parts[i+1])
        except:
            await ctx.send(f"Невірне значення для {field}")
            return
        if field in MAX_POINTS:
            set_field(ctx.guild.id, member.id, field, val)
            changed.append(f"{field}={val}")
        else:
            await ctx.send(f"Невідомий поле: {field}")
            return
    await ctx.send(f"Встановлено для {member.display_name}: " + ", ".join(changed))

@bot.command(name="score")
async def cmd_score(ctx, member: discord.Member = None):
    """!score @user — показать результат"""
    if member is None:
        member = ctx.author
    upsert_user(ctx.guild.id, member.id)
    data = get_user(ctx.guild.id, member.id)
    if not data:
        await ctx.send("Немає даних для користувача.")
        return
    total = (data["text"] or 0) + (data["voice"] or 0) + (data["events"] or 0) + (data["other"] or 0)
    percent = total / TOTAL_MAX * 100
    threshold = data["threshold"] or DEFAULT_THRESHOLD
    status = "ПРОЙДЕ ✅" if percent >= threshold else "НЕ ПРОЙДЕ ❌"
    text = (
        f"Статистика для {member.display_name}:\n"
        f"Текст: {data['text']}/{MAX_POINTS['text']}\n"
        f"Голос: {data['voice']}/{MAX_POINTS['voice']}\n"
        f"Івенти: {data['events']}/{MAX_POINTS['events']}\n"
        f"Інше: {data['other']}/{MAX_POINTS['other']}\n\n"
        f"Всього: {total}/{TOTAL_MAX}  — {percent:.2f}%\n"
        f"Проходний бал: {threshold}%\n"
        f"Статус: {status}"
    )
    await ctx.send(text)

@bot.command(name="reset")
async def cmd_reset(ctx, member: discord.Member = None):
    """!reset @user — скинути очки"""
    if member is None:
        member = ctx.author
    reset_user(ctx.guild.id, member.id)
    await ctx.send(f"Бали для {member.display_name} скинуто.")

@bot.command(name="setthreshold")
@commands.has_guild_permissions(administrator=True)
async def cmd_setthreshold(ctx, value: int):
    """!setthreshold 65 — установить проходний процент для сервера (тільки адмін)"""
    set_threshold_for_guild(ctx.guild.id, value)
    await ctx.send(f"Проходний відсоток встановлено на {value}% (оновлені існуючі записи).")

@bot.command(name="helpactivity")
async def cmd_helpactivity(ctx):
    # Разбиваем на кількаєнні embed для кращого відображення
    
    embed1 = discord.Embed(
        title="📚 Довідка по командах бота",
        description="Усі доступні команди",
        color=discord.Color.blue()
    )
    
    embed1.add_field(
        name="🎯 Основні",
        value=(
            "`!ping` — перевірка зв'язку\n"
            "`!status` — статус бота\n"
            "`!helpactivity` — ця довідка"
        ),
        inline=False
    )
    
    embed1.add_field(
        name="📊 Статистика та активність",
        value=(
            "`!mystats` — твоя статистика\n"
            "`!score @user` — бали користувача\n"
            "`!leaderboard [N]` — топ учасників\n"
            "`!serverstats` — статистика сервера\n"
            "`!analyze` — аналіз (reply)\n"
            "`!memberchanges [днів]` — зміни учасників\n"
            "`!checkgone` — хто пішов з серверу"
        ),
        inline=False
    )
    
    embed1.add_field(
        name="🚀 Онбординг нових учасників",
        value=(
            "`!setuponboarding` — **повне авто-налаштування**\n"
            "`!onboarding` — статус/налаштування\n"
            "`!onboarding on/off` — увімкнути/вимкнути\n"
            "`!onboarding channel #канал` — канал\n"
            "`!onboarding quarantine @роль` — карантинна роль\n"
            "`!onboarding required on/off` — обов'язково\n"
            "`!onboarding test` — тест меню\n"
            "`!createroles all/2d/3d/prof` — створити ролі\n"
            "`!deleteroles all/2d/3d/prof` — видалити ролі"
        ),
        inline=False
    )
    
    await ctx.send(embed=embed1)
    
    embed2 = discord.Embed(color=discord.Color.green())
    
    embed2.add_field(
        name="🏷️ Керування ролями",
        value=(
            "`!roles` — меню вибору ролей\n"
            "`!rolemenu [#канал]` — постійне меню\n"
            "`!giverole @user @role` — видати роль\n"
            "`!removerole @user @role` — забрати роль\n"
            "`!massrole add/remove @role` — масово\n"
            "`!listroles [@user]` — список ролей\n"
            "`!roleinfo @role` — інфо про роль\n"
            "`!autorole @role` — авто-роль\n"
            "`!autorole_off` — вимкнути авто-роль"
        ),
        inline=False
    )
    
    embed2.add_field(
        name="🎭 Self-roles (вибір ролей)",
        value=(
            "`!selfrole_add @role 🎮 опис` — додати\n"
            "`!selfrole_remove @role` — видалити\n"
            "`!selfrole_list` — список\n"
            "`!selfrole_welcome on/off` — привітання"
        ),
        inline=False
    )
    
    embed2.add_field(
        name="💬 Повідомлення та ЛС",
        value=(
            "`!dm @user текст` — написати в ЛС\n"
            "`!broadcast @role текст` — всім з роллю\n"
            "`!digest [год] [#канал]` — AI дайджест\n"
            "`!chatlog [год] [#канал]` — лог чату\n"
            "`!say текст` — бот скаже"
        ),
        inline=False
    )
    
    await ctx.send(embed=embed2)
    
    embed3 = discord.Embed(color=discord.Color.purple())
    
    embed3.add_field(
        name="� Думки та пам'ять",
        value=(
            "`!think [текст]` — згенерувати думку\n"
            "`!thoughts [N]` — показати думки\n"
            "`!enable_thoughts` — увімкнути авто-думки\n"
            "`!disable_thoughts` — вимкнути\n"
            "`!set_thought_interval хв` — інтервал\n"
            "`!clearthoughts` — очистити думки"
        ),
        inline=False
    )
    
    embed3.add_field(
        name="🎤 Голосові команди",
        value=(
            "`!voicehelp` — повна довідка\n"
            "`!join` — зайти в голосовий\n"
            "`!leave` — вийти з голосового\n"
            "`!tts текст` — озвучити текст\n"
            "`!listen` — слухати голос\n"
            "`!stoplisten` — зупинити\n"
            "`!recognize` — розпізнаю (reply)\n"
            "`!voicechat текст` — голосовий чат\n"
            "`!autovoice on/off` — авто-голос"
        ),
        inline=False
    )
    
    embed3.add_field(
        name="⚙️ Адміністрування",
        value=(
            "`!set @user text 10 voice 5` — встановити\n"
            "`!add @user category amount` — додати бали\n"
            "`!reset @user` — скинути статистику\n"
            "`!setthreshold %` — поріг активності\n"
            "`!remind хв текст` — нагадування\n"
            "`!exportdata` — експорт даних"
        ),
        inline=False
    )
    
    embed3.set_footer(text="💡 Бот для відстеження активності аніматорів 🎨")
    
    await ctx.send(embed=embed3)

@bot.command(name="enable_thoughts")
@commands.has_guild_permissions(administrator=True)
async def cmd_enable_thoughts(ctx):
    set_guild_thoughts_enabled(ctx.guild.id, True)
    await ctx.send("✅ Автодум увімкнено для цього сервера.")

@bot.command(name="disable_thoughts")
@commands.has_guild_permissions(administrator=True)
async def cmd_disable_thoughts(ctx):
    set_guild_thoughts_enabled(ctx.guild.id, False)
    await ctx.send("✅ Автодум вимкнено для цього сервера.")

@bot.command(name="ai_consent")
async def cmd_ai_consent(ctx, mode: str = None):
    """!ai_consent [external] — дать согласие на анализ. Якщо указати 'external', разрешается внешний анализ."""
    allow_ext = (mode == 'external')
    set_user_consent(ctx.guild.id, ctx.author.id, True, allow_ext)
    await ctx.send(f"✅ Згоду збережено. External={allow_ext}")

@bot.command(name="ai_revoke")
async def cmd_ai_revoke(ctx):
    set_user_consent(ctx.guild.id, ctx.author.id, False, False)
    await ctx.send("✅ Згоду відкликано.")

@bot.command(name="analyze")
async def cmd_analyze(ctx, *, args: str = ""):
    """Використовуй як reply: !analyze [--external] — проаналізувати конкретне повідомлення (якщо reply) або текст."""
    use_external = False
    if '--external' in args:
        use_external = True
        args = args.replace('--external', '').strip()

    # Якщо це reply — берем сообщение
    if ctx.message.reference:
        try:
            ref = ctx.message.reference
            channel = ctx.channel
            msg = await channel.fetch_message(ref.message_id)
            # Проверяем, єсть consent у автора сообщения, якщо мы собираемся отправлять внешний вызов
            if use_external:
                consent, allow_ext = get_user_consent(ctx.guild.id, msg.author.id)
                if not consent or not allow_ext:
                    await ctx.send('❌ Не можна виконати зовнішній аналіз без згоди автора. Нехай автор виконає `!ai_consent external`.')
                    return
            await perform_analysis_and_reply(ctx, msg.content, use_external=use_external)
            return
        except Exception as e:
            await ctx.send(f"Помилка при отриманні replied-повідомлення: {e}")
            return

    # Іначе аналізуємо передане текст
    text = args.strip()
    if not text:
        await ctx.send("Вкажіть текст або відповідь на повідомлення, яке потрібно проаналізувати.")
        return
    # Проверяем consent автора команди, якщо external
    if use_external:
        consent, allow_ext = get_user_consent(ctx.guild.id, ctx.author.id)
        if not consent or not allow_ext:
            await ctx.send('❌ Не можна виконати зовнішній аналіз без згоди. Використовуй `!ai_consent external`.')
            return
    await perform_analysis_and_reply(ctx, text, use_external=use_external)


@bot.command(name="analyze_image", aliases=["img", "vision", "describe"])
async def cmd_analyze_image(ctx, *, prompt: str = None):
    """!analyze_image [опис] — проаналізувати зображення з повідомлення.
    Прикріпи зображення до команди або відповідь на повідомлення з зображенням.
    Можна додати опціональний опис/питання для більш точного аналізу.
    Приклади:
        !analyze_image - опис зображення
        !img що це за порода собаки?
        !vision скільки людей на фото?
    """
    # Проверяем согласие на внешний анализ (изображения всегда идут через внешний API)
    consent, allow_ext = get_user_consent(ctx.guild.id, ctx.author.id)
    if not consent or not allow_ext:
        await ctx.send('❌ Для аналізу зображень потрібна згода на зовнішній аналіз.\n'
                      'Використай `!ai_consent external` щоб дозволити.')
        return

    attachment = None
    
    # Ищем изображение в текущем сообщении
    if ctx.message.attachments:
        for att in ctx.message.attachments:
            if att.content_type and 'image' in att.content_type:
                attachment = att
                break
            elif att.filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.webp')):
                attachment = att
                break
    
    # Если нет в текущем — проверяем reply
    if not attachment and ctx.message.reference:
        try:
            ref_msg = await ctx.channel.fetch_message(ctx.message.reference.message_id)
            if ref_msg.attachments:
                for att in ref_msg.attachments:
                    if att.content_type and 'image' in att.content_type:
                        attachment = att
                        break
                    elif att.filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.webp')):
                        attachment = att
                        break
        except Exception:
            pass
    
    if not attachment:
        await ctx.send('❌ Прикріпи зображення або відповідь на повідомлення з зображенням.')
        return

    # Показываем что бот думает
    async with ctx.typing():
        ok, result = await analyze_image_from_attachment(attachment, prompt)
    
    if ok:
        # Ограничиваем длину ответа
        if len(result) > 1900:
            result = result[:1900] + "..."
        
        embed = discord.Embed(
            title="🖼️ Аналіз зображення",
            description=result,
            color=discord.Color.blue()
        )
        embed.set_thumbnail(url=attachment.url)
        if prompt:
            embed.set_footer(text=f"Запит: {prompt[:100]}")
        await ctx.send(embed=embed)
    else:
        await ctx.send(f'❌ Помилка аналізу: {result}')


@bot.command(name="think")
@commands.has_guild_permissions(administrator=True)
async def cmd_think(ctx, *, prompt: str = None):
    """!think — добавить мысль вручную или сгенерировать её автоматически"""
    if prompt:
        content = f"Ручна думка від {ctx.author.display_name}: {prompt}"
    else:
        content = generate_thought_text(ctx.guild.id)
    add_thought(ctx.guild.id, ctx.author.id, content)
    await ctx.send("✅ Думку додано до журналу.")
    await ctx.send(content)

@bot.command(name="thoughts")
@commands.has_guild_permissions(administrator=True)
async def cmd_thoughts(ctx, limit: int = 5):
    rows = get_thoughts(ctx.guild.id, limit)
    if not rows:
        await ctx.send("Немає думок для цього сервера.")
        return
    for _id, created_by, timestamp, content in rows:
        header = f"ID:{_id} | by: {created_by} | {timestamp}"
        await ctx.send(header + "\n" + content + "\n---")

# ---------- Нові команди ----------

@bot.command(name="leaderboard")
async def cmd_leaderboard(ctx, limit: int = 10):
    """!leaderboard [N] — показати топ-N участників по активності"""
    if limit < 1:
        limit = 10
    if limit > 50:
        limit = 50
    
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        """
        SELECT user_id, text, voice, events, other, 
               (text + voice + events + other) as total 
        FROM users 
        WHERE guild_id = ? 
        ORDER BY total DESC 
        LIMIT ?
        """,
        (ctx.guild.id, limit)
    )
    rows = cur.fetchall()
    conn.close()
    
    if not rows:
        await ctx.send("📊 Поки що немає даних про активність.")
        return
    
    # Формируем лидерборд
    leaderboard = f"🏆 **Топ-{len(rows)} учасників за активністю:**\n\n"
    medals = ["🥇", "🥈", "🥉"]
    
    for i, (user_id, text, voice, events, other, total) in enumerate(rows):
        member = ctx.guild.get_member(user_id)
        name = member.display_name if member else f"ID:{user_id}"
        percent = (total / TOTAL_MAX) * 100
        
        medal = medals[i] if i < 3 else f"{i+1}."
        bar_filled = int(percent / 10)
        bar = "█" * bar_filled + "░" * (10 - bar_filled)
        
        leaderboard += f"{medal} **{name}** — {total}/{TOTAL_MAX} ({percent:.1f}%)\n"
        leaderboard += f"    {bar} | 📝{text} 🎤{voice} 🎉{events} ⭐{other}\n"
    
    # Разбиваем якщо слишком длинный
    if len(leaderboard) > 2000:
        chunks = [leaderboard[i:i+1900] for i in range(0, len(leaderboard), 1900)]
        for chunk in chunks:
            await ctx.send(chunk)
    else:
        await ctx.send(leaderboard)

@bot.command(name="mystats")
async def cmd_mystats(ctx):
    """!mystats — показать свою статистику з візуалізацією"""
    upsert_user(ctx.guild.id, ctx.author.id)
    data = get_user(ctx.guild.id, ctx.author.id)
    
    if not data:
        await ctx.send("Немає даних.")
        return
    
    text = data["text"] or 0
    voice = data["voice"] or 0
    events = data["events"] or 0
    other = data["other"] or 0
    total = text + voice + events + other
    percent = (total / TOTAL_MAX) * 100
    threshold = data["threshold"] or DEFAULT_THRESHOLD
    
    # Візуаліні бары
    def make_bar(value, max_val):
        filled = int((value / max_val) * 10) if max_val > 0 else 0
        return "█" * filled + "░" * (10 - filled)
    
    status_emoji = "✅" if percent >= threshold else "⚠️" if percent >= threshold * 0.7 else "❌"
    
    stats = f"""📊 **Статистика {ctx.author.display_name}**

📝 **Текст:** {text}/{MAX_POINTS['text']} {make_bar(text, MAX_POINTS['text'])}
🎤 **Голос:** {voice}/{MAX_POINTS['voice']} {make_bar(voice, MAX_POINTS['voice'])}
🎉 **Івенти:** {events}/{MAX_POINTS['events']} {make_bar(events, MAX_POINTS['events'])}
⭐ **Інше:** {other}/{MAX_POINTS['other']} {make_bar(other, MAX_POINTS['other'])}

**Загалом:** {total}/{TOTAL_MAX} ({percent:.1f}%)
**Проходний бал:** {threshold}%
**Статус:** {status_emoji} {"ПРОЙДЕ" if percent >= threshold else "НЕ ПРОЙДЕ"}
"""
    await ctx.send(stats)

@bot.command(name="serverstats")
async def cmd_serverstats(ctx):
    """!serverstats — общая статистика сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    
    # Общая статистика
    cur.execute("""
        SELECT 
            COUNT(*) as total_users,
            AVG(text + voice + events + other) as avg_score,
            MAX(text + voice + events + other) as max_score,
            SUM(text) as total_text,
            SUM(voice) as total_voice,
            SUM(events) as total_events,
            SUM(other) as total_other
        FROM users WHERE guild_id = ?
    """, (ctx.guild.id,))
    row = cur.fetchone()
    
    # Изменения за 24 часа
    cutoff = (datetime.utcnow() - timedelta(hours=24)).isoformat()
    cur.execute("""
        SELECT 
            SUM(CASE WHEN event_type = 'join' THEN 1 ELSE 0 END) as joins,
            SUM(CASE WHEN event_type = 'leave' THEN 1 ELSE 0 END) as leaves
        FROM member_events 
        WHERE guild_id = ? AND timestamp >= ?
    """, (ctx.guild.id, cutoff))
    events_row = cur.fetchone()
    
    # Скільки пройдуть поріг
    cur.execute("""
        SELECT COUNT(*) FROM users 
        WHERE guild_id = ? 
        AND ((text + voice + events + other) * 100.0 / ?) >= threshold
    """, (ctx.guild.id, TOTAL_MAX))
    passed = cur.fetchone()[0] or 0
    
    conn.close()
    
    total_users = row[0] or 0
    avg_score = row[1] or 0
    max_score = row[2] or 0
    total_text = row[3] or 0
    total_voice = row[4] or 0
    total_events = row[5] or 0
    total_other = row[6] or 0
    
    joins = events_row[0] or 0 if events_row else 0
    leaves = events_row[1] or 0 if events_row else 0
    
    avg_percent = (avg_score / TOTAL_MAX) * 100 if TOTAL_MAX > 0 else 0
    
    stats = f"""📈 **Статистика сервера {ctx.guild.name}**

👥 **Учасників у базі:** {total_users}
👤 **На сервері:** {ctx.guild.member_count}

📊 **Середній бал:** {avg_score:.1f}/{TOTAL_MAX} ({avg_percent:.1f}%)
🏆 **Максимальний бал:** {max_score}/{TOTAL_MAX}
✅ **Пройдуть поріг:** {passed}/{total_users}

**Сума балів по категоріях:**
📝 Текст: {total_text} | 🎤 Голос: {total_voice}
🎉 Івенти: {total_events} | ⭐ Інше: {total_other}

**За останні 24 години:**
➕ Приєдналось: {joins}
➖ Вийшло: {leaves}
"""
    await ctx.send(stats)

# Хранилище напоминаний
pending_reminders = {}

@bot.command(name="remind")
async def cmd_remind(ctx, minutes: int, *, text: str):
    """!remind <минуты> <текст> — напоминание через N минут"""
    if minutes < 1:
        await ctx.send("❌ Мінімум 1 хвилина.")
        return
    if minutes > 1440:  # 24 часа
        await ctx.send("❌ Максимум 1440 хвилин (24 години).")
        return
    
    remind_time = datetime.utcnow() + timedelta(minutes=minutes)
    await ctx.send(f"⏰ Нагадаю через {minutes} хв: {text}")
    
    async def remind_task():
        await asyncio.sleep(minutes * 60)
        await ctx.send(f"⏰ **Нагадування для {ctx.author.mention}:**\n{text}")
    
    asyncio.create_task(remind_task())

@bot.command(name="ask")
async def cmd_ask(ctx, *, question: str):
    """!ask <вопрос> — задать вопрос ИИ"""
    if not question.strip():
        await ctx.send("❓ Вкажіть питання.")
        return
    
    # Проверяем согласие
    consent, allow_ext = get_user_consent(ctx.guild.id, ctx.author.id)
    if not consent:
        await ctx.send("⚠️ Спочатку дайте згоду: `!ai_consent` або `!ai_consent external`")
        return
    
    await ctx.send("🤔 Думаю...")
    
    prompt = f"Відповідай коротко українською або російською (як питання). Питання від користувача {ctx.author.display_name}: {question}"
    
    ok, response = call_external_model(prompt, timeout=15)
    
    if ok and response:
        # Обрезаем слишком длинные ответы
        if len(response) > 1800:
            response = response[:1800] + "..."
        await ctx.send(f"!tts uk {response}")
    else:
        await ctx.send(f"❌ Не вдалося отримати відповідь: {response}")

@bot.command(name="set_thought_interval")
@commands.has_guild_permissions(administrator=True)
async def cmd_set_thought_interval(ctx, seconds: int = 60):
    """!set_thought_interval <секунд> — установить інтервал генерации мыслей для сервера (15-1800)"""
    if seconds < 15 or seconds > 1800:
        await ctx.send("Вкажіть інтервал у секундах від 15 до 1800.")
        return
    set_guild_thought_interval(ctx.guild.id, seconds)
    await ctx.send(f"🕒 Інтервал генерації думок встановлено: {seconds} секунд.")

@bot.command(name="exportdata")
async def cmd_exportdata(ctx):
    """Экспорт даних сервера і пользователей в JSON"""
    try:
        # Собираем інформацію про сервер
        guild_info = {
            "id": ctx.guild.id,
            "name": ctx.guild.name,
            "member_count": ctx.guild.member_count
        }
        
        # Собираем інформацію про всіх учасників
        members_info = {}
        for member in ctx.guild.members:
            members_info[str(member.id)] = {
                "name": member.name,
                "display_name": member.display_name,
                "discriminator": member.discriminator,
                "bot": member.bot
            }
        
        # Получаем данні з бази
        conn = sqlite3.connect(DB_PATH)
        cur = conn.cursor()
        cur.execute("SELECT user_id, text, voice, events, other, threshold FROM users WHERE guild_id = ?", (ctx.guild.id,))
        rows = cur.fetchall()
        
        users_data = []
        for user_id, text, voice, events, other, threshold in rows:
            user_info = members_info.get(str(user_id), {
                "name": "Unknown",
                "display_name": "Unknown User",
                "discriminator": "0000",
                "bot": False
            })
            users_data.append({
                "user_id": user_id,
                "name": user_info["name"],
                "display_name": user_info["display_name"],
                "text": text,
                "voice": voice,
                "events": events,
                "other": other,
                "threshold": threshold,
                "total": text + voice + events + other
            })
        
        conn.close()
        
        # Сохраняем в JSON
        export_data = {
            "guild": guild_info,
            "users": users_data,
            "timestamp": datetime.utcnow().isoformat()
        }
        
        with open(f"export_{ctx.guild.id}.json", "w", encoding="utf-8") as f:
            json.dump(export_data, f, ensure_ascii=False, indent=2)
        
        await ctx.send(f"✅ Данные экспортированы в `export_{ctx.guild.id}.json`")
    except Exception as e:
        await ctx.send(f"❌ Ошибка экспорта: {str(e)}")

@bot.command(name="checkgone")
async def cmd_checkgone(ctx):
    """Проверить, які пользователі вишли з сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    # Получаем всіх пользователей цього сервера з бази
    cur.execute("SELECT user_id FROM users WHERE guild_id = ?", (ctx.guild.id,))
    rows = cur.fetchall()
    conn.close()
    
    if not rows:
        await ctx.send("В базі немає пользователів з цього сервера.")
        return
    
    # Получаем поточних учасників сервера
    current_member_ids = {member.id for member in ctx.guild.members}
    
    # Находим тех, хто єсть в базі, але на сервері
    gone_users = []
    for (user_id,) in rows:
        if user_id not in current_member_ids:
            gone_users.append(user_id)
    
    if not gone_users:
        await ctx.send("✅ Все пользователі из бази остаются на сервері.")
    else:
        gone_list = "\n".join([f"<@{uid}> (ID: {uid})" for uid in gone_users])
        await ctx.send(f"❌ Следующі пользователі вишли з сервера ({len(gone_users)}):\n{gone_list}")

@bot.command(name="memberchanges")
async def cmd_memberchanges(ctx, days: int = 3):
    """Показати зміни учасників за останні N днів"""
    if days < 1 or days > 30:
        await ctx.send("Укажіть кількість днів від 1 до 30.")
        return
    
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    
    # Вычисляем дату отсечки
    cutoff = (datetime.utcnow() - timedelta(days=days))
    cutoff_str = cutoff.isoformat()
    
    # Получаем события за период
    cur.execute(
        """
        SELECT user_id, username, event_type, timestamp 
        FROM member_events 
        WHERE guild_id = ? AND timestamp >= ?
        ORDER BY timestamp DESC
        """,
        (ctx.guild.id, cutoff_str)
    )
    events = cur.fetchall()
    conn.close()
    
    if not events:
        await ctx.send(f"📊 За останні {days} днів зміни учасників.")
        return
    
    # Подсчитываем статистику
    joins = []
    leaves = []
    
    for user_id, username, event_type, timestamp in events:
        ts = datetime.fromisoformat(timestamp)
        time_str = ts.strftime("%d.%m.%Y %H:%M")
        
        if event_type == "join":
            joins.append(f"➕ {username} ({time_str})")
        elif event_type == "leave":
            leaves.append(f"➖ {username} ({time_str})")
    
    # Формируем отчёт
    report = f"📊 **Измені учасників за останні {days} днів:**\n\n"
    
    
    # Текущий состав
    current_count = len(ctx.guild.members)
    report += f"**Сейчас на сервері:** {current_count} учасників"
    
    # Разбиваем на часті, якщо слишком длинный
    if len(report) > 2000:
        chunks = [report[i:i+1900] for i in range(0, len(report), 1900)]
        for chunk in chunks:
            await ctx.send(chunk)
    else:
        await ctx.send(report)

# ---------- Команди системы обучения ----------

@bot.command(name="learn_on")
@commands.has_permissions(administrator=True)
async def learn_on(ctx):
    """Включити обучение на сообщения сервера (тільки адмін)"""
    set_learning_enabled(ctx.guild.id, True)
    await ctx.send("✅ Обучение включено! Бот буде учиться обічні.")

@bot.command(name="learn_off")
@commands.has_permissions(administrator=True)
async def learn_off(ctx):
    """Виключити обучение (тільки адмін)"""
    set_learning_enabled(ctx.guild.id, False)
    await ctx.send("❌ Обучение виключено.")

@bot.command(name="learn_status")
async def learn_status(ctx):
    """Показати статус системи обучения"""
    settings = get_learning_settings(ctx.guild.id)
    stats = get_learning_stats(ctx.guild.id)
    
    status = "✅ Включено" if settings['learning_enabled'] else "❌ Виключено"
    embed = discord.Embed(title="📊 Система обучения", color=0x00ff00 if settings['learning_enabled'] else 0xff0000)
    embed.add_field(name="Статус", value=status, inline=False)
    embed.add_field(name="Сообщений собрано", value=str(stats.get('total_messages', 0)), inline=True)
    embed.add_field(name="Пользователі", value=str(stats.get('unique_users', 0)), inline=True)
    embed.add_field(name="Проанализировано", value=str(stats.get('analyzed_users', 0)), inline=True)
    await ctx.send(embed=embed)

@bot.command(name="my_style")
async def my_style(ctx):
    """Показати свой стиль общения"""
    profile = get_user_style_profile(ctx.author.id, ctx.guild.id)
    if not profile:
        await ctx.send("❓ Поки немає даних. Напише ще.")
        return
    
    embed = discord.Embed(title=f"🎨 Стиль {ctx.author.display_name}", color=0x9b59b6)
    embed.add_field(name="Средній длина", value=f"{profile['avg_length']:.0f} символів", inline=True)
    embed.add_field(name="Эмодзи", value=f"{profile['emoji_rate']*100:.1f}%", inline=True)
    embed.add_field(name="Капс", value=f"{profile['caps_rate']*100:.1f}%", inline=True)
    if profile.get('common_phrases'):
        embed.add_field(name="Фрази", value=profile['common_phrases'][:200], inline=False)
    await ctx.send(embed=embed)

@bot.command(name="server_style")
async def server_style(ctx):
    """Показати общий стиль сервера"""
    summary = get_server_style_summary(ctx.guild.id)
    if not summary:
        await ctx.send("❓ Недостато даних для аналізу.")
        return
    
    embed = discord.Embed(title="🌐 Стиль общения сервера", color=0x3498db)
    embed.description = summary[:1000]
    await ctx.send(embed=embed)

@bot.command(name="analyze_style")
async def analyze_style_cmd(ctx, user: discord.Member = None):
    """Анализировать стиль пользователя"""
    target = user or ctx.author
    messages = get_user_messages(target.id, ctx.guild.id, 50)
    
    if len(messages) < 5:
        await ctx.send(f"❓ Недостато даних. Нужно мінмім 5.")
        return
    
    analyze_user_style(target.id, ctx.guild.id, messages)
    await ctx.send(f"✅ Стиль {target.display_name} проанализирован!")

@bot.command(name="clear_my_data")
async def clear_my_data(ctx):
    """Удалити свої данні з системи обучения"""
    clear_learning_data(user_id=ctx.author.id, server_id=ctx.guild.id)
    await ctx.send("🗑️ Твої данні удалено з системи обучения.")

@bot.command(name="learn_help")
async def learn_help(ctx):
    """Справка по системи обучения"""
    embed = discord.Embed(title="📚 Система обучения", color=0x2ecc71)
    embed.description = "Бот учится стиля общения сервера для більшніх відповідей."
    embed.add_field(name="!learn_on / !learn_off", value="Вкл/вимкнути обучение (адмін)", inline=False)
    embed.add_field(name="!learn_status", value="Статус системи", inline=False)
    embed.add_field(name="!my_style", value="Показати свой стиль", inline=False)
    embed.add_field(name="!server_style", value="Стиль сервера", inline=False)
    embed.add_field(name="!analyze_style [@user]", value="Анализировать стиль", inline=False)
    embed.add_field(name="!clear_my_data", value="Удалити свої данні", inline=False)
    embed.add_field(name="!callme <ім'я>", value="Як мене називати", inline=False)
    await ctx.send(embed=embed)


@bot.command(name="image_help", aliases=["imghelp", "vision_help"])
async def image_help(ctx):
    """Справка по аналізу зображень"""
    embed = discord.Embed(title="🖼️ Аналіз зображень", color=0x3498db)
    embed.description = (
        "Бот може аналізувати зображення за допомогою ІІ (Gemini/OpenAI Vision).\n\n"
        "**Важливо:** Для використання потрібна згода на зовнішній аналіз!"
    )
    embed.add_field(
        name="!ai_consent external", 
        value="Дозволити зовнішній аналіз (обов'язково)", 
        inline=False
    )
    embed.add_field(
        name="!analyze_image [питання]", 
        value="Аналізувати прикріплене зображення", 
        inline=False
    )
    embed.add_field(
        name="!img [питання]", 
        value="Коротка версія команди", 
        inline=False
    )
    embed.add_field(
        name="!vision [питання]", 
        value="Ще одна коротка версія", 
        inline=False
    )
    embed.add_field(
        name="Як використовувати",
        value=(
            "1️⃣ Прикріпи зображення + напиши `!img`\n"
            "2️⃣ Або: Відповідь на повідомлення з картинкою + `!img`\n"
            "3️⃣ Додай питання: `!img що це за порода?`"
        ),
        inline=False
    )
    embed.add_field(
        name="Підтримувані формати",
        value="JPEG, PNG, GIF, WebP (до 20MB)",
        inline=False
    )
    embed.set_footer(text="Налаштуй EXTERNAL_AI_GEMINI_KEY або EXTERNAL_AI_OPENAI_KEY в .env")
    await ctx.send(embed=embed)


# ============== НЕЙРОСЕТЬ ==============

@bot.command(name="neural_train", aliases=["ntrain", "train_ai"])
@commands.has_permissions(administrator=True)
async def cmd_neural_train(ctx, epochs: int = 5):
    """!neural_train [эпохи] — обучить локальную нейросеть на сообщениях сервера.
    Требует PyTorch и минимум 20 сообщений в системе обучения.
    """
    if not NEURAL_AVAILABLE:
        await ctx.send("❌ PyTorch не установлен. Установи: `pip install torch`")
        return
    
    # Проверяем что обучение включено
    settings = get_learning_settings(ctx.guild.id)
    if not settings['learning_enabled']:
        await ctx.send("❌ Сначала включи сбор сообщений: `!learn_on`")
        return
    
    # Ограничиваем эпохи
    epochs = max(1, min(epochs, 50))
    
    msg = await ctx.send(f"🧠 Начинаю обучение нейросети ({epochs} эпох)...")
    
    try:
        model = get_neural_model(ctx.guild.id)
        
        def progress_callback(epoch, total, loss):
            # Обновляем сообщение каждые 2 эпохи
            if epoch % 2 == 0 or epoch == total:
                asyncio.create_task(
                    msg.edit(content=f"🧠 Обучение: {epoch}/{total} эпох, Loss: {loss:.4f}")
                )
        
        success, result = model.train(epochs=epochs, callback=progress_callback)
        
        if success:
            status = model.get_status()
            embed = discord.Embed(title="✅ Обучение завершено!", color=discord.Color.green())
            embed.add_field(name="Результат", value=result, inline=False)
            embed.add_field(name="Всего эпох", value=str(status['trained_epochs']), inline=True)
            embed.add_field(name="Сообщений", value=str(status['total_messages']), inline=True)
            embed.add_field(name="Устройство", value=status['device'], inline=True)
            await msg.edit(content=None, embed=embed)
        else:
            await msg.edit(content=f"❌ Ошибка обучения: {result}")
    
    except Exception as e:
        await msg.edit(content=f"❌ Ошибка: {e}")


@bot.command(name="neural_generate", aliases=["ngen", "ai_say"])
async def cmd_neural_generate(ctx, *, prompt: str = ""):
    """!neural_generate [начало] — сгенерировать текст с помощью локальной нейросети.
    Если указать начало — продолжит с него.
    """
    if not NEURAL_AVAILABLE:
        await ctx.send("❌ PyTorch не установлен.")
        return
    
    model = get_neural_model(ctx.guild.id)
    if not model:
        await ctx.send("❌ Ошибка получения модели.")
        return
    
    status = model.get_status()
    if not status['exists']:
        await ctx.send("❌ Модель ещё не обучена. Админ может запустить `!neural_train`")
        return
    
    async with ctx.typing():
        text, error = model.generate(prompt=prompt, max_len=150, temperature=0.8)
    
    if error:
        await ctx.send(f"❌ {error}")
        return
    
    if not text or len(text.strip()) < 2:
        await ctx.send("🤔 Не вдалося згенерувати текст. Спробуй ще раз.")
        return
    
    # Ограничиваем длину
    if len(text) > 500:
        text = text[:500] + "..."
    
    embed = discord.Embed(
        title="🧠 Нейросеть каже:",
        description=text,
        color=discord.Color.purple()
    )
    if prompt:
        embed.set_footer(text=f"Промпт: {prompt[:50]}")
    await ctx.send(embed=embed)


@bot.command(name="neural_status", aliases=["nstatus", "ai_status"])
async def cmd_neural_status(ctx):
    """!neural_status — показать статус локальной нейросети"""
    if not NEURAL_AVAILABLE:
        await ctx.send("❌ PyTorch не установлен. Локальная нейросеть недоступна.")
        return
    
    model = get_neural_model(ctx.guild.id)
    status = model.get_status()
    
    embed = discord.Embed(title="🧠 Статус нейросети", color=discord.Color.blue())
    
    if status['exists']:
        embed.add_field(name="Статус", value="✅ Обучена", inline=True)
        embed.add_field(name="Эпох обучения", value=str(status['trained_epochs']), inline=True)
        embed.add_field(name="Сообщений", value=str(status['total_messages']), inline=True)
        if status['vocab_size']:
            embed.add_field(name="Словарь", value=f"{status['vocab_size']} символов", inline=True)
        embed.add_field(name="Устройство", value=status['device'], inline=True)
        if status['last_trained']:
            embed.add_field(name="Последнее обучение", value=status['last_trained'][:10], inline=True)
    else:
        embed.add_field(name="Статус", value="❌ Не обучена", inline=False)
        embed.add_field(name="Как обучить", value="`!learn_on` → подождать сообщений → `!neural_train`", inline=False)
    
    await ctx.send(embed=embed)


@bot.command(name="neural_help", aliases=["nhelp"])
async def cmd_neural_help(ctx):
    """Справка по локальной нейросети"""
    embed = discord.Embed(title="🧠 Локальная нейросеть", color=discord.Color.purple())
    embed.description = (
        "Собственная LSTM-нейросеть, которая учится на сообщениях сервера!\n\n"
        "**Как это работает:**\n"
        "1. Включи сбор сообщений: `!learn_on`\n"
        "2. Подожди пока накопится 20+ сообщений\n"
        "3. Обучи модель: `!neural_train`\n"
        "4. Генерируй текст: `!neural_generate`"
    )
    embed.add_field(name="!neural_train [эпохи]", value="Обучить нейросеть (админ)", inline=False)
    embed.add_field(name="!neural_generate [текст]", value="Сгенерировать текст", inline=False)
    embed.add_field(name="!neural_status", value="Статус модели", inline=False)
    embed.add_field(name="!ngen", value="Короткая версия генерации", inline=True)
    embed.add_field(name="!ntrain", value="Короткая версия обучения", inline=True)
    embed.set_footer(text="Требует PyTorch: pip install torch")
    await ctx.send(embed=embed)


@bot.command(name="long_on")
@commands.has_permissions(administrator=True)
async def long_on(ctx):
    """Включить длинные ответы на сервере (админ)"""
    long_response_mode[ctx.guild.id] = True
    await ctx.send("✅ Длинные ответы включены для этого сервера.")


@bot.command(name="long_off")
@commands.has_permissions(administrator=True)
async def long_off(ctx):
    """Отключить длинные ответы на сервере (админ)"""
    long_response_mode[ctx.guild.id] = False
    await ctx.send("❌ Длинные ответы выключены для этого сервера.")


@bot.command(name="long_status")
async def long_status(ctx):
    """Показать статус длинных ответов"""
    enabled = long_response_mode.get(ctx.guild.id, False)
    await ctx.send("✅ Включены" if enabled else "❌ Выключены")

@bot.command(name="callme")
async def callme(ctx, *, name: str = None):
    """Встановити як бот буде називати користувача"""
    if not name:
        current = get_user_nickname(ctx.guild.id, ctx.author.id)
        if current:
            await ctx.send(f"🏷️ Я називаю тебе: **{current}**")
        else:
            await ctx.send(f"🏷️ Поки не знаюи як тебе називати. Напише `!callme <ім'я>`")
        return
    
    set_user_nickname(ctx.guild.id, ctx.author.id, name)
    await ctx.send(f"✅ Тепер я буду називати **{name}**!")

@bot.command(name="whois")
async def whois(ctx, user: discord.Member = None):
    """Показати як бот знає користувача"""
    target = user or ctx.author
    nickname = get_user_nickname(ctx.guild.id, target.id)
    if nickname:
        await ctx.send(f"🏷️ {target.display_name} = **{nickname}**")
    else:
        await ctx.send(f"❓ Не знаюи як називати {target.display_name}")

# ---------- Автозачет за сообщения і обробка голосових ----------
@bot.event
async def on_message(message: discord.Message):
    """Начисляем 1 очко за кожне пользовательське сообщення в текстових каналах.
    Також обробка голосових сообщення для распознавання.
    """
    # Ігніруем ботов і ліснійні сообщення
    if message.author.bot or message.guild is None:
        return
    
    # ========== ОБРАБОТ ГОЛОСОВИХ СООБЩЕНИЙ ==========
    # Проверяем, єсть голосового вкладення і активенний режим прослуховування
    if message.attachments and voice_listen_mode.get(message.guild.id, False):
        for attachment in message.attachments:
            is_voice = False
            if attachment.content_type and 'audio' in attachment.content_type:
                is_voice = True
            elif attachment.filename.endswith(('.ogg', '.mp3', '.wav', '.m4a', '.webm')):
                is_voice = True
            
            if is_voice:
                # Обрабатываем голосове сообщення
                asyncio.create_task(process_voice_message(message, attachment))
                break

    # Начисляем очки за текстові сообщення
    try:
        upsert_user(message.guild.id, message.author.id)
        add_field(message.guild.id, message.author.id, "text", 1)
        
        # ========== СБОР СООБЩЕНИЙ ДЛЯННІ ==========
        save_message_for_learning(
            message.guild.id, 
            message.author.id, 
            str(message.author.display_name), 
            message.content
        )
    finally:
        await bot.process_commands(message)

@bot.event
async def on_member_join(member: discord.Member):
    """Отслеживаем вход участника на сервер і запускаем онбординг"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO member_events (guild_id, user_id, username, event_type, timestamp) VALUES (?, ?, ?, ?, ?)",
        (member.guild.id, member.id, str(member), "join", datetime.utcnow().isoformat())
    )
    conn.commit()
    conn.close()
    
    # Автоматично створюємо запис для нового учасника
    upsert_user(member.guild.id, member.id)
    
    # Проверяем настройки онбордингу
    try:
        init_onboarding_db()
        onboard_enabled, quarantine_role_id, onboard_channel_id, require_roles = get_onboarding_settings(member.guild.id)

        if onboard_enabled:
            # Видати карантинну роль
            if quarantine_role_id:
                quarantine_role = member.guild.get_role(quarantine_role_id)
                if quarantine_role and quarantine_role < member.guild.me.top_role:
                    try:
                        await member.add_roles(quarantine_role, reason="Онбординг: карантинна роль")
                    except:
                        pass
            
            # Створюємо меню онбордингу з категоріями
            view = create_onboarding_view(member.guild, quarantine_role_id)
            
            embed = discord.Embed(
                title=f"👋 Ласкаво просимо на {member.guild.name}!",
                description=(
                    f"Привіт, {member.mention}!\n\n"
                    "Перед тим як увійти на сервер, розкажи нам про себе:\n\n"
                    "🎨 **Який софт ти використовуєш?**\n"
                    "Обери з випадаючих меню нижче.\n\n"
                    "💼 **Ким ти є?**\n"
                    "Обери свою професію.\n\n"
                    "Після вибору натисни **Готово!** щоб увійти на сервер."
                ),
                color=discord.Color.blue()
            )
            if member.guild.icon:
                embed.set_thumbnail(url=member.guild.icon.url)
            embed.set_footer(text="Ці ролі допоможуть іншим знайти тебе та спілкуватись на схожі теми")
            
            # Отправляем в указанный канал или в ЛС
            if onboard_channel_id:
                channel = member.guild.get_channel(onboard_channel_id)
                if channel:
                    await channel.send(f"{member.mention}", embed=embed, view=view)
            else:
                try:
                    await member.send(embed=embed, view=view)
                except discord.Forbidden:
                    # Якщо ЛС закриті, іщем канал для отправки
                    welcome_ch = discord.utils.get(member.guild.text_channels, name="welcome") or \
                                discord.utils.get(member.guild.text_channels, name="onboarding")
                    if welcome_ch:
                        await welcome_ch.send(f"{member.mention}", embed=embed, view=view)
            
            return  # Онбординг активен — не виконуємо обычне приветствие
    except Exception as e:
        print(f"[ONBOARDING ERROR] {e}")
    
    # Якщо онбординг виключено — обична логіка
    # Видати авто-роль якщо настроена
    try:
        init_autorole_db()
        autorole_id = get_autorole(member.guild.id)
        if autorole_id:
            role = member.guild.get_role(autorole_id)
            if role and role < member.guild.me.top_role:
                await member.add_roles(role, reason="Авто-роль для нового учасника")
    except Exception as e:
        print(f"[AUTOROLE ERROR] {e}")
    
    # Проверяем, єсть self-roles і потрібно відправляти меню
    try:
        init_selfroles_db()
        channel_id, welcome_enabled = get_selfrole_settings(member.guild.id)
        
        if welcome_enabled:
            roles_data = get_selfroles(member.guild.id)
            if roles_data:
                # Створюємо меню выбора ролей
                view = create_selfrole_view(member.guild, use_buttons=True)
                
                if view and view.children:
                    embed = discord.Embed(
                        title=f"👋 Ласкаво просимо на {member.guild.name}!",
                        description=(
                            f"Привіт, {member.mention}!\n\n"
                            "🏷️ **Оберіть собі ролі:**\n"
                            "Натисніть на кнопки нижче щоб отримати ролі.\n"
                            "Натисніть ще раз щоб зняти роль."
                        ),
                        color=discord.Color.green()
                    )
                    embed.set_thumbnail(url=member.guild.icon.url if member.guild.icon else None)
                    
                    # Отправляем в указанный канал или в ЛС
                    if channel_id:
                        channel = member.guild.get_channel(channel_id)
                        if channel:
                            await channel.send(f"{member.mention}", embed=embed, view=view)
                    else:
                        # Отправляем в ЛС
                        try:
                            await member.send(embed=embed, view=view)
                        except discord.Forbidden:
                            pass  # Пользователь закрив ЛС
    except Exception as e:
        print(f"[SELFROLE WELCOME ERROR] {e}")
    
    # Отправляем приветствие (если есть канал)
    welcome_channel = discord.utils.get(member.guild.text_channels, name="welcome") or \
                     discord.utils.get(member.guild.text_channels, name="general") or \
                     discord.utils.get(member.guild.text_channels, name="загальний")
    if welcome_channel:
        try:
            await welcome_channel.send(f"👋 Вітаємо {member.mention} на сервері!")
        except Exception:
            pass

@bot.event
async def on_member_remove(member: discord.Member):
    """Отслеживаем выход участника с сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO member_events (guild_id, user_id, username, event_type, timestamp) VALUES (?, ?, ?, ?, ?)",
        (member.guild.id, member.id, str(member), "leave", datetime.utcnow().isoformat())
    )
    conn.commit()
    conn.close()

# ---------- Глобальна обробка помилок ----------
@bot.event
async def on_command_error(ctx, error):
    """Глобальний обробник помилок команд"""
    if isinstance(error, commands.MissingPermissions):
        await ctx.send("❌ Недостатньо прав для виконання цієї команди.")
    elif isinstance(error, commands.MissingRequiredArgument):
        await ctx.send(f"❌ Відсутній аргумент: `{error.param.name}`. Використовуйте `!helpactivity` для допомоги.")
    elif isinstance(error, commands.BadArgument):
        await ctx.send(f"❌ Невірний аргумент. Перевірте формат команди.")
    elif isinstance(error, commands.CommandNotFound):
        pass  # Игнорируем несуществующие команды
    elif isinstance(error, commands.CommandOnCooldown):
        await ctx.send(f"⏳ Команда на кулдауні. Спробуйте через {error.retry_after:.1f} сек.")
    else:
        print(f"[ERROR] Команда {ctx.command}: {error}")
        await ctx.send(f"❌ Помилка: {str(error)[:200]}")

@cmd_setthreshold.error
async def setthreshold_error(ctx, error):
    if isinstance(error, commands.MissingPermissions):
        await ctx.send("❌ Тільки адміністратор може змінювати поріг.")
    else:
        await ctx.send(f"❌ Помилка: {str(error)}")

# ---------- Дополнительные утилиты ----------
@bot.command(name="status")
async def cmd_status(ctx):
    """!status — показать статус бота"""
    uptime = datetime.utcnow() - bot.user.created_at if bot.user else timedelta(0)
    
    # Статистика
    total_guilds = len(bot.guilds)
    total_members = sum(g.member_count for g in bot.guilds)
    voice_connections = len([vc for vc in bot.voice_clients if vc.is_connected()])
    
    status_text = f"""🤖 **Статус бота**

📊 **Серверів:** {total_guilds}
👥 **Учасників:** {total_members}
🎤 **Голосових підключень:** {voice_connections}
⏱️ **Пінг:** {round(bot.latency * 1000)}ms
🌐 **API:** {'✅ Онлайн' if bot.is_ready() else '❌ Офлайн'}
"""
    await ctx.send(status_text)

@bot.command(name="clearthoughts")
@commands.has_guild_permissions(administrator=True)
async def cmd_clearthoughts(ctx):
    """!clearthoughts — очистить все мысли сервера (только админ)"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("DELETE FROM thoughts WHERE guild_id = ?", (ctx.guild.id,))
    deleted = cur.rowcount
    conn.commit()
    conn.close()
    
    # Удаляем файл мыслей
    file_path = os.path.join(THOUGHTS_DIR, f"thoughts_{ctx.guild.id}.jsonl")
    if os.path.exists(file_path):
        try:
            os.remove(file_path)
        except Exception:
            pass
    
    await ctx.send(f"🗑️ Видалено {deleted} думок.")


@bot.command(name="digest")
async def cmd_digest(ctx, hours: int = 24, channel: discord.TextChannel = None):
    """!digest [часы] [#канал] — получить сводку событий в чате в ЛС
    
    Примеры:
    !digest — сводка за 24 часа по текущему каналу
    !digest 12 — сводка за 12 часов
    !digest 6 #general — сводка за 6 часов по каналу #general
    """
    if hours < 1:
        hours = 1
    if hours > 168:  # максимум неделя
        hours = 168
    
    target_channel = channel or ctx.channel
    
    # Проверяем права на чтение канала
    if not target_channel.permissions_for(ctx.author).read_messages:
        await ctx.send("❌ У вас немає доступу до цього каналу.")
        return
    
    await ctx.send(f"📨 Збираю дайджест за {hours} год. з {target_channel.mention}... Відправлю в ЛС.")
    
    try:
        cutoff_time = datetime.utcnow() - timedelta(hours=hours)
        messages_data = []
        message_count = 0
        unique_authors = set()
        reactions_count = 0
        attachments_count = 0
        links_count = 0
        
        # Собираем сообщения
        async for msg in target_channel.history(limit=500, after=cutoff_time):
            if msg.author.bot:
                continue
            message_count += 1
            unique_authors.add(msg.author.id)
            reactions_count += sum(r.count for r in msg.reactions)
            attachments_count += len(msg.attachments)
            if "http" in msg.content:
                links_count += 1
            
            # Сохраняем краткую информацию о сообщении
            if len(messages_data) < 50:  # ограничиваем для AI
                content_short = msg.content[:200] + "..." if len(msg.content) > 200 else msg.content
                messages_data.append({
                    "author": msg.author.display_name,
                    "content": content_short,
                    "time": msg.created_at.strftime("%H:%M"),
                    "reactions": sum(r.count for r in msg.reactions)
                })
        
        # Формируем базовую статистику
        digest = f"""📊 **Дайджест каналу #{target_channel.name}**
📅 Період: останні {hours} год.
🏠 Сервер: {ctx.guild.name}

📈 **Статистика:**
💬 Повідомлень: {message_count}
👥 Унікальних авторів: {len(unique_authors)}
❤️ Реакцій: {reactions_count}
📎 Вкладень: {attachments_count}
🔗 Посилань: {links_count}

"""
        
        # Топ авторы
        if message_count > 0:
            author_counts = {}
            async for msg in target_channel.history(limit=500, after=cutoff_time):
                if not msg.author.bot:
                    author_counts[msg.author.display_name] = author_counts.get(msg.author.display_name, 0) + 1
            
            top_authors = sorted(author_counts.items(), key=lambda x: -x[1])[:5]
            if top_authors:
                digest += "👑 **Топ авторів:**\n"
                for i, (name, count) in enumerate(top_authors):
                    digest += f"{i+1}. {name}: {count} повідомлень\n"
                digest += "\n"
        
        # Попробуем сделать AI-сводку если есть сообщения
        if messages_data and message_count > 0:
            consent, allow_ext = get_user_consent(ctx.guild.id, ctx.author.id)
            if consent and allow_ext:
                # Формируем промпт для AI
                messages_text = "\n".join([
                    f"[{m['time']}] {m['author']}: {m['content']}" 
                    for m in messages_data[:30]
                ])
                
                prompt = f"""Проаналізуй ці повідомлення з Discord-чату і зроби коротку сводку (3-5 речень) українською:
- Про що говорили?
- Які основні теми?
- Хто був найактивніший?
- Який загальний настрій?

Повідомлення:
{messages_text}

Сводка:"""
                
                ok, ai_summary = call_external_model(prompt, timeout=20)
                if ok and ai_summary:
                    digest += f"🤖 **AI-аналіз:**\n{ai_summary}\n\n"
            else:
                digest += "💡 *Для AI-аналізу використайте `!ai_consent external`*\n\n"
        
        # Последние важные сообщения (с реакциями)
        popular = [m for m in messages_data if m['reactions'] >= 2][:5]
        if popular:
            digest += "🔥 **Популярні повідомлення:**\n"
            for m in popular:
                digest += f"• [{m['time']}] **{m['author']}**: {m['content'][:100]}... ({m['reactions']} реакцій)\n"
        
        # Отправляем в ЛС
        try:
            await ctx.author.send(digest[:2000])
            if len(digest) > 2000:
                # Разбиваем на части
                for i in range(2000, len(digest), 1900):
                    await ctx.author.send(digest[i:i+1900])
            await ctx.send(f"✅ Дайджест відправлено в ЛС!")
        except discord.Forbidden:
            await ctx.send("❌ Не можу відправити ЛС. Перевірте налаштування приватності.")
            
    except Exception as e:
        await ctx.send(f"❌ Помилка: {str(e)[:200]}")


@bot.command(name="dm")
@commands.has_guild_permissions(administrator=True)
async def cmd_dm(ctx, member: discord.Member, *, message: str):
    """!dm @user <сообщение> — отправить личное сообщение пользователю (только админ)
    
    Пример: !dm @Username Привет! Это важное сообщение от администрации.
    """
    if not message.strip():
        await ctx.send("❌ Вкажіть текст повідомлення.")
        return
    
    try:
        dm_content = f"""📬 **Повідомлення від адміністрації сервера {ctx.guild.name}**

{message}

---
*Відправлено адміністратором {ctx.author.display_name}*
*Щоб відповісти, напишіть у відповідний канал на сервері.*
"""
        await member.send(dm_content)
        await ctx.send(f"✅ Повідомлення відправлено {member.mention} в ЛС.")
    except discord.Forbidden:
        await ctx.send(f"❌ Не можу відправити ЛС користувачу {member.mention}. Можливо, він закрив ЛС.")
    except Exception as e:
        await ctx.send(f"❌ Помилка: {str(e)[:200]}")


@bot.command(name="broadcast")
@commands.has_guild_permissions(administrator=True)
async def cmd_broadcast(ctx, role: discord.Role, *, message: str):
    """!broadcast @role <сообщение> — отправить ЛС всем с указанной ролью (только админ)
    
    Пример: !broadcast @Members Важное объявление для всех!
    """
    if not message.strip():
        await ctx.send("❌ Вкажіть текст повідомлення.")
        return
    
    members_with_role = [m for m in role.members if not m.bot]
    if not members_with_role:
        await ctx.send(f"❌ Немає учасників з роллю {role.mention}.")
        return
    
    await ctx.send(f"📤 Відправляю повідомлення {len(members_with_role)} учасникам з роллю {role.mention}...")
    
    success = 0
    failed = 0
    
    dm_content = f"""📢 **Масове повідомлення від сервера {ctx.guild.name}**

{message}

---
*Відправлено адміністратором {ctx.author.display_name}*
"""
    
    for member in members_with_role:
        try:
            await member.send(dm_content)
            success += 1
            await asyncio.sleep(0.5)  # Чтобы не получить rate limit
        except discord.Forbidden:
            failed += 1
        except Exception:
            failed += 1
    
    await ctx.send(f"✅ Відправлено: {success} | ❌ Не вдалось: {failed}")


@bot.command(name="chatlog")
async def cmd_chatlog(ctx, hours: int = 1, channel: discord.TextChannel = None):
    """!chatlog [часы] [#канал] — получить лог сообщений в ЛС (без AI-обработки)
    
    Примеры:
    !chatlog — лог за последний час
    !chatlog 2 #general — лог за 2 часа с канала #general
    """
    if hours < 1:
        hours = 1
    if hours > 24:
        hours = 24
    
    target_channel = channel or ctx.channel
    
    if not target_channel.permissions_for(ctx.author).read_messages:
        await ctx.send("❌ У вас немає доступу до цього каналу.")
        return
    
    await ctx.send(f"📋 Збираю лог за {hours} год. з {target_channel.mention}... Відправлю в ЛС.")
    
    try:
        cutoff_time = datetime.utcnow() - timedelta(hours=hours)
        log_parts = [f"📋 **Лог каналу #{target_channel.name}** (останні {hours} год.)\n"]
        current_part = ""
        
        messages_list = []
        async for msg in target_channel.history(limit=200, after=cutoff_time):
            if not msg.author.bot:
                messages_list.append(msg)
        
        messages_list.reverse()  # Хронологический порядок
        
        for msg in messages_list:
            time_str = msg.created_at.strftime("%H:%M")
            content = msg.content[:300] + "..." if len(msg.content) > 300 else msg.content
            attachments = f" [📎 {len(msg.attachments)} вкладень]" if msg.attachments else ""
            line = f"`{time_str}` **{msg.author.display_name}**:{attachments} {content}\n"
            
            if len(current_part) + len(line) > 1800:
                log_parts.append(current_part)
                current_part = line
            else:
                current_part += line
        
        if current_part:
            log_parts.append(current_part)
        
        # Отправляем в ЛС
        try:
            for part in log_parts:
                if part.strip():
                    await ctx.author.send(part)
                    await asyncio.sleep(0.3)
            await ctx.send(f"✅ Лог ({len(messages_list)} повідомлень) відправлено в ЛС!")
        except discord.Forbidden:
            await ctx.send("❌ Не можу відправити ЛС. Перевірте налаштування приватності.")
            
    except Exception as e:
        await ctx.send(f"❌ Помилка: {str(e)[:200]}")


# ---------- Управление ролями ----------

# Хранилище авто-ролей (guild_id -> role_id)
auto_roles = {}

def init_autorole_db():
    """Инициализация таблицы авто-ролей"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("""
        CREATE TABLE IF NOT EXISTS autoroles (
            guild_id INTEGER PRIMARY KEY,
            role_id INTEGER
        )
    """)
    conn.commit()
    conn.close()

def get_autorole(guild_id):
    """Получить авто-роль для сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT role_id FROM autoroles WHERE guild_id = ?", (guild_id,))
    row = cur.fetchone()
    conn.close()
    return row[0] if row else None

def set_autorole(guild_id, role_id):
    """Установить авто-роль для сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    if role_id is None:
        cur.execute("DELETE FROM autoroles WHERE guild_id = ?", (guild_id,))
    else:
        cur.execute("INSERT OR REPLACE INTO autoroles (guild_id, role_id) VALUES (?, ?)", (guild_id, role_id))
    conn.commit()
    conn.close()


# ---------- Self-roles система (роли по выбору) ----------

def init_selfroles_db():
    """Инициализация таблицы self-roles"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("""
        CREATE TABLE IF NOT EXISTS selfroles (
            guild_id INTEGER,
            role_id INTEGER,
            description TEXT,
            emoji TEXT,
            PRIMARY KEY (guild_id, role_id)
        )
    """)
    cur.execute("""
        CREATE TABLE IF NOT EXISTS selfrole_settings (
            guild_id INTEGER PRIMARY KEY,
            welcome_channel_id INTEGER,
            welcome_enabled INTEGER DEFAULT 1
        )
    """)
    conn.commit()
    conn.close()

def get_selfroles(guild_id):
    """Получить список self-roles для сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT role_id, description, emoji FROM selfroles WHERE guild_id = ?", (guild_id,))
    rows = cur.fetchall()
    conn.close()
    return rows

def add_selfrole(guild_id, role_id, description="", emoji="🏷️"):
    """Добавить роль в список self-roles"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("INSERT OR REPLACE INTO selfroles (guild_id, role_id, description, emoji) VALUES (?, ?, ?, ?)",
                (guild_id, role_id, description, emoji))
    conn.commit()
    conn.close()

def remove_selfrole(guild_id, role_id):
    """Удалить роль из списка self-roles"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("DELETE FROM selfroles WHERE guild_id = ? AND role_id = ?", (guild_id, role_id))
    conn.commit()
    conn.close()

def get_selfrole_settings(guild_id):
    """Получить настройки self-roles для сервера"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT welcome_channel_id, welcome_enabled FROM selfrole_settings WHERE guild_id = ?", (guild_id,))
    row = cur.fetchone()
    conn.close()
    return row if row else (None, 1)

def set_selfrole_settings(guild_id, channel_id=None, enabled=True):
    """Установить настройки self-roles"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("INSERT OR REPLACE INTO selfrole_settings (guild_id, welcome_channel_id, welcome_enabled) VALUES (?, ?, ?)",
                (guild_id, channel_id, 1 if enabled else 0))
    conn.commit()
    conn.close()


# ============== ONBOARDING SYSTEM ==============
def init_onboarding_db():
    """Инициализация таблицы онбординга"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute('''CREATE TABLE IF NOT EXISTS onboarding_settings (
        guild_id INTEGER PRIMARY KEY,
        enabled INTEGER DEFAULT 0,
        quarantine_role_id INTEGER,
        onboarding_channel_id INTEGER,
        require_roles INTEGER DEFAULT 1
    )''')
    cur.execute('''CREATE TABLE IF NOT EXISTS onboarding_completed (
        guild_id INTEGER,
        user_id INTEGER,
        completed_at TEXT,
        PRIMARY KEY (guild_id, user_id)
    )''')
    conn.commit()
    conn.close()


def get_onboarding_settings(guild_id):
    """Получить настройки онбординга"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT enabled, quarantine_role_id, onboarding_channel_id, require_roles FROM onboarding_settings WHERE guild_id = ?", (guild_id,))
    row = cur.fetchone()
    conn.close()
    return row if row else (0, None, None, 1)


def set_onboarding_settings(guild_id, enabled, quarantine_role_id=None, channel_id=None, require_roles=1):
    """Установить настройки онбординга"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("""INSERT OR REPLACE INTO onboarding_settings 
                   (guild_id, enabled, quarantine_role_id, onboarding_channel_id, require_roles) 
                   VALUES (?, ?, ?, ?, ?)""",
                (guild_id, 1 if enabled else 0, quarantine_role_id, channel_id, 1 if require_roles else 0))
    conn.commit()
    conn.close()


def mark_onboarding_completed(guild_id, user_id):
    """Отметить что пользователь прошёл онбординг"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("INSERT OR REPLACE INTO onboarding_completed (guild_id, user_id, completed_at) VALUES (?, ?, ?)",
                (guild_id, user_id, datetime.utcnow().isoformat()))
    conn.commit()
    conn.close()


def is_onboarding_completed(guild_id, user_id):
    """Проверить, прошёл ли пользователь онбординг"""
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()
    cur.execute("SELECT 1 FROM onboarding_completed WHERE guild_id = ? AND user_id = ?", (guild_id, user_id))
    result = cur.fetchone()
    conn.close()
    return result is not None


class OnboardingCategorySelect(discord.ui.Select):
    """Выбор категории ролей для онбординга"""
    def __init__(self, category_key: str, category_data: dict, guild: discord.Guild):
        self.category_key = category_key
        self.guild = guild
        self.role_map = {}
        
        options = []
        for role_name, emoji, description in category_data["roles"]:
            role = discord.utils.get(guild.roles, name=role_name)
            if role:
                self.role_map[str(role.id)] = role
                options.append(discord.SelectOption(
                    label=role_name[:100],
                    value=str(role.id),
                    description=description[:100] if description else "Оберіть цю роль",
                    emoji=emoji
                ))
        
        if not options:
            options.append(discord.SelectOption(label="Ролі не створено", value="none"))
        
        super().__init__(
            placeholder=f"{category_data['name']} — оберіть що використовуєте",
            min_values=0,
            max_values=min(len(options), len(options)),
            options=options,
            custom_id=f"onboard_{category_key}"
        )
    
    async def callback(self, interaction: discord.Interaction):
        try:
            if "none" in self.values:
                await interaction.response.send_message("ℹ️ Ролі ще не створено на сервері.", ephemeral=True)
                return
            
            member = interaction.user
            guild = interaction.guild
            added = []
            
            # Переопределяем role_map из guild если он пустой (после перезапуска)
            if not self.role_map:
                for opt in self.options:
                    if opt.value != "none":
                        role = guild.get_role(int(opt.value))
                        if role:
                            self.role_map[opt.value] = role
            
            for role_id in self.values:
                role = self.role_map.get(role_id)
                if not role:
                    role = guild.get_role(int(role_id))
                if role and role not in member.roles:
                    try:
                        await member.add_roles(role, reason="Onboarding: вибір ролей")
                        added.append(f"{role.name}")
                    except:
                        pass
            
            if added:
                await interaction.response.send_message(
                    f"✅ Додано ролі: {', '.join(added)}\n\n"
                    "Продовжуйте обирати ролі з інших категорій, потім натисніть **Готово!**",
                    ephemeral=True
                )
            else:
                await interaction.response.send_message("ℹ️ Ви вже маєте ці ролі.", ephemeral=True)
        except Exception as e:
            try:
                await interaction.response.send_message(
                    "⚠️ Помилка при обробці. Спробуйте ще раз.",
                    ephemeral=True
                )
            except:
                pass


class OnboardingCompleteButton(discord.ui.Button):
    """Кнопка завершения онбординга"""
    def __init__(self, quarantine_role_id: int = None):
        super().__init__(
            style=discord.ButtonStyle.success,
            label="✅ Готово! Увійти на сервер",
            custom_id="onboard_complete",
            row=4
        )
        self.quarantine_role_id = quarantine_role_id
    
    async def callback(self, interaction: discord.Interaction):
        try:
            member = interaction.user
            guild = interaction.guild
            
            # Получаем quarantine_role_id из БД (на случай если бот перезапущен)
            init_onboarding_db()
            _, db_quarantine_role_id, _, require_roles = get_onboarding_settings(guild.id)
            quarantine_role_id = self.quarantine_role_id or db_quarantine_role_id
            
            # Проверяем, выбрал ли пользователь хоть одну роль
            user_roles = [r for r in member.roles if r.name != "@everyone"]
            preset_role_names = []
            for cat in PRESET_ROLES.values():
                for name, _, _ in cat["roles"]:
                    preset_role_names.append(name)
            
            has_preset_role = any(r.name in preset_role_names for r in user_roles)
            
            if require_roles and not has_preset_role:
                await interaction.response.send_message(
                    "⚠️ **Будь ласка, оберіть хоча б одну роль!**\n\n"
                    "Це допоможе іншим учасникам дізнатися про ваші інтереси та навички.",
                    ephemeral=True
                )
                return
            
            # Убираем карантинную роль
            if quarantine_role_id:
                quarantine_role = guild.get_role(quarantine_role_id)
                if quarantine_role and quarantine_role in member.roles:
                    try:
                        await member.remove_roles(quarantine_role, reason="Onboarding завершено")
                    except:
                        pass
            
            # Отмечаем онбординг как пройденный
            mark_onboarding_completed(guild.id, member.id)
            
            # Получаем выбранные роли
            selected = [r.name for r in user_roles if r.name in preset_role_names]
            
            await interaction.response.send_message(
                f"🎉 **Ласкаво просимо на сервер {guild.name}!**\n\n"
                f"Ваші ролі: {', '.join(selected) if selected else 'не обрано'}\n\n"
                "Тепер ви маєте доступ до всіх каналів. Приємного спілкування! 🚀",
                ephemeral=True
            )
        except Exception as e:
            try:
                await interaction.response.send_message(
                    f"⚠️ Помилка при обробці. Спробуйте ще раз або зверніться до адміністратора.",
                    ephemeral=True
                )
            except:
                pass


class OnboardingSkipButton(discord.ui.Button):
    """Кнопка пропуска выбора ролей"""
    def __init__(self, quarantine_role_id: int = None):
        super().__init__(
            style=discord.ButtonStyle.secondary,
            label="⏭️ Пропустити",
            custom_id="onboard_skip",
            row=4
        )
        self.quarantine_role_id = quarantine_role_id
    
    async def callback(self, interaction: discord.Interaction):
        try:
            member = interaction.user
            guild = interaction.guild
            
            init_onboarding_db()
            _, db_quarantine_role_id, _, require_roles = get_onboarding_settings(guild.id)
            
            if require_roles:
                await interaction.response.send_message(
                    "⚠️ На цьому сервері вибір ролей обов'язковий.\n"
                    "Будь ласка, оберіть хоча б одну роль.",
                    ephemeral=True
                )
                return
            
            # Получаем quarantine_role_id из БД (на случай если бот перезапущен)
            quarantine_role_id = self.quarantine_role_id or db_quarantine_role_id
            
            # Убираем карантинную роль
            if quarantine_role_id:
                quarantine_role = guild.get_role(quarantine_role_id)
                if quarantine_role and quarantine_role in member.roles:
                    try:
                        await member.remove_roles(quarantine_role, reason="Onboarding пропущено")
                    except:
                        pass
            
            mark_onboarding_completed(guild.id, member.id)
            
            await interaction.response.send_message(
                f"👋 Ласкаво просимо на {guild.name}!\n"
                "Ви можете обрати ролі пізніше командою `!roles`",
                ephemeral=True
            )
        except Exception as e:
            try:
                await interaction.response.send_message(
                    "⚠️ Помилка при обробці. Спробуйте ще раз.",
                    ephemeral=True
                )
            except:
                pass


def create_onboarding_view(guild: discord.Guild, quarantine_role_id: int = None):
    """Создать view для онбординга с категориями"""
    view = discord.ui.View(timeout=None)
    
    # Добавляем Select меню для каждой категории
    for cat_key, cat_data in PRESET_ROLES.items():
        select = OnboardingCategorySelect(cat_key, cat_data, guild)
        if select.options and select.options[0].value != "none":
            view.add_item(select)
    
    # Добавляем кнопки
    view.add_item(OnboardingCompleteButton(quarantine_role_id))
    view.add_item(OnboardingSkipButton(quarantine_role_id))
    
    return view


class SelfRoleView(discord.ui.View):
    """Меню с кнопками для выбора ролей"""
    def __init__(self, guild_id, timeout=300):
        super().__init__(timeout=timeout)
        self.guild_id = guild_id
        
    async def on_timeout(self):
        # Отключаем кнопки после таймаута
        for item in self.children:
            item.disabled = True


class SelfRoleButton(discord.ui.Button):
    """Кнопка для выбора роли"""
    def __init__(self, role: discord.Role, emoji: str = "🏷️", description: str = ""):
        super().__init__(
            style=discord.ButtonStyle.primary,
            label=role.name[:80],
            emoji=emoji,
            custom_id=f"selfrole_{role.id}"
        )
        self.role = role
        self.role_description = description
        
    async def callback(self, interaction: discord.Interaction):
        member = interaction.user
        
        if self.role in member.roles:
            # Убираем роль
            try:
                await member.remove_roles(self.role, reason="Self-role: користувач зняв роль")
                await interaction.response.send_message(
                    f"❌ Роль **{self.role.name}** знято!", 
                    ephemeral=True
                )
            except discord.Forbidden:
                await interaction.response.send_message(
                    f"⚠️ Не можу зняти роль {self.role.name}.", 
                    ephemeral=True
                )
        else:
            # Добавляем роль
            try:
                await member.add_roles(self.role, reason="Self-role: користувач обрав роль")
                await interaction.response.send_message(
                    f"✅ Роль **{self.role.name}** отримано!", 
                    ephemeral=True
                )
            except discord.Forbidden:
                await interaction.response.send_message(
                    f"⚠️ Не можу видати роль {self.role.name}.", 
                    ephemeral=True
                )


class SelfRoleSelect(discord.ui.Select):
    """Выпадающее меню для выбора ролей"""
    def __init__(self, roles_data: list, guild: discord.Guild):
        options = []
        self.role_map = {}
        
        for role_id, description, emoji in roles_data[:25]:  # Максимум 25 опций
            role = guild.get_role(role_id)
            if role:
                self.role_map[str(role_id)] = role
                options.append(discord.SelectOption(
                    label=role.name[:100],
                    value=str(role_id),
                    description=(description or "Натисніть для вибору")[:100],
                    emoji=emoji or "🏷️"
                ))
        
        if not options:
            options.append(discord.SelectOption(label="Немає доступних ролей", value="none"))
        
        super().__init__(
            placeholder="🏷️ Оберіть роль...",
            min_values=0,
            max_values=min(len(options), 5),
            options=options
        )
        
    async def callback(self, interaction: discord.Interaction):
        if "none" in self.values:
            await interaction.response.send_message("ℹ️ Немає доступних ролей.", ephemeral=True)
            return
            
        member = interaction.user
        added = []
        removed = []
        errors = []
        
        # Обрабатываем выбранные роли
        for role_id in self.values:
            role = self.role_map.get(role_id)
            if not role:
                continue
                
            if role in member.roles:
                # Роль уже есть - снимаем
                try:
                    await member.remove_roles(role, reason="Self-role: користувач зняв роль")
                    removed.append(role.name)
                except:
                    errors.append(role.name)
            else:
                # Роли нет - добавляем
                try:
                    await member.add_roles(role, reason="Self-role: користувач обрав роль")
                    added.append(role.name)
                except:
                    errors.append(role.name)
        
        response = []
        if added:
            response.append(f"✅ Отримано: {', '.join(added)}")
        if removed:
            response.append(f"❌ Знято: {', '.join(removed)}")
        if errors:
            response.append(f"⚠️ Помилка з: {', '.join(errors)}")
            
        await interaction.response.send_message(
            "\n".join(response) if response else "ℹ️ Нічого не змінено.",
            ephemeral=True
        )


def create_selfrole_view(guild: discord.Guild, use_buttons=True):
    """Создать view с self-roles для сервера"""
    init_selfroles_db()
    roles_data = get_selfroles(guild.id)
    
    if not roles_data:
        return None
    
    view = discord.ui.View(timeout=None)  # Постоянный view
    
    if use_buttons and len(roles_data) <= 5:
        # Используем кнопки для небольшого количества ролей
        for role_id, description, emoji in roles_data:
            role = guild.get_role(role_id)
            if role and role < guild.me.top_role:
                view.add_item(SelfRoleButton(role, emoji or "🏷️", description or ""))
    else:
        # Используем Select меню для большого количества
        view.add_item(SelfRoleSelect(roles_data, guild))
    
    return view


@bot.command(name="selfrole_add")
@commands.has_guild_permissions(administrator=True)
async def cmd_selfrole_add(ctx, role: discord.Role, emoji: str = "🏷️", *, description: str = ""):
    """!selfrole_add @role [emoji] [описание] — добавить роль в меню выбора
    
    Пример: !selfrole_add @Gamer 🎮 Для геймерів
    """
    init_selfroles_db()
    
    if role >= ctx.guild.me.top_role:
        await ctx.send(f"❌ Роль {role.mention} вище моєї — не зможу її видавати.")
        return
    
    add_selfrole(ctx.guild.id, role.id, description, emoji)
    await ctx.send(f"✅ Роль {role.mention} додано до меню вибору.\nEmoji: {emoji}\nОпис: {description or 'немає'}")


@bot.command(name="selfrole_remove")
@commands.has_guild_permissions(administrator=True)
async def cmd_selfrole_remove(ctx, role: discord.Role):
    """!selfrole_remove @role — убрать роль из меню выбора"""
    init_selfroles_db()
    remove_selfrole(ctx.guild.id, role.id)
    await ctx.send(f"✅ Роль {role.mention} видалено з меню вибору.")


@bot.command(name="selfrole_list")
async def cmd_selfrole_list(ctx):
    """!selfrole_list — показать доступные self-roles"""
    init_selfroles_db()
    roles_data = get_selfroles(ctx.guild.id)
    
    if not roles_data:
        await ctx.send("ℹ️ На цьому сервері немає налаштованих ролей для вибору.\nАдміни можуть додати: `!selfrole_add @роль`")
        return
    
    text = "🏷️ **Доступні ролі для вибору:**\n\n"
    for role_id, description, emoji in roles_data:
        role = ctx.guild.get_role(role_id)
        if role:
            text += f"{emoji or '🏷️'} {role.mention}"
            if description:
                text += f" — {description}"
            text += "\n"
    
    text += "\nВикористовуйте `!roles` для вибору ролі!"
    await ctx.send(text)


@bot.command(name="roles")
async def cmd_roles(ctx):
    """!roles — открыть меню выбора ролей"""
    init_selfroles_db()
    
    view = create_selfrole_view(ctx.guild)
    
    if not view or not view.children:
        await ctx.send("ℹ️ На цьому сервері немає налаштованих ролей для вибору.")
        return
    
    # Показываем текущие роли пользователя
    user_roles = [r.mention for r in ctx.author.roles if r.name != "@everyone"]
    current = f"Ваші поточні ролі: {', '.join(user_roles[:10])}" if user_roles else "У вас поки немає ролей"
    
    embed = discord.Embed(
        title="🏷️ Виберіть ролі",
        description=f"Натисніть на кнопку/виберіть зі списку щоб отримати або зняти роль.\n\n{current}",
        color=discord.Color.blue()
    )
    
    await ctx.send(embed=embed, view=view)


@bot.command(name="rolemenu")
@commands.has_guild_permissions(administrator=True)
async def cmd_rolemenu(ctx, channel: discord.TextChannel = None):
    """!rolemenu [#канал] — создать постоянное меню выбора ролей в канале
    
    Пример: !rolemenu #roles
    """
    init_selfroles_db()
    target = channel or ctx.channel
    
    view = create_selfrole_view(ctx.guild, use_buttons=True)
    
    if not view or not view.children:
        await ctx.send("❌ Спочатку додайте ролі: `!selfrole_add @роль`")
        return
    
    roles_data = get_selfroles(ctx.guild.id)
    description = "Натисніть на кнопку щоб отримати або зняти роль:\n\n"
    for role_id, desc, emoji in roles_data:
        role = ctx.guild.get_role(role_id)
        if role:
            description += f"{emoji or '🏷️'} **{role.name}**"
            if desc:
                description += f" — {desc}"
            description += "\n"
    
    embed = discord.Embed(
        title="🏷️ Виберіть свої ролі",
        description=description,
        color=discord.Color.green()
    )
    embed.set_footer(text="Натисніть ще раз щоб зняти роль")
    
    await target.send(embed=embed, view=view)
    if target != ctx.channel:
        await ctx.send(f"✅ Меню ролей створено в {target.mention}")


@bot.command(name="selfrole_welcome")
@commands.has_guild_permissions(administrator=True)
async def cmd_selfrole_welcome(ctx, enabled: str = "on", channel: discord.TextChannel = None):
    """!selfrole_welcome <on/off> [#канал] — включить/выключить приветствие с ролями
    
    Примеры:
    !selfrole_welcome on #welcome — включить и отправлять в #welcome
    !selfrole_welcome off — выключить
    """
    init_selfroles_db()
    
    if enabled.lower() in ["on", "yes", "1", "true", "так"]:
        channel_id = channel.id if channel else None
        set_selfrole_settings(ctx.guild.id, channel_id, True)
        if channel:
            await ctx.send(f"✅ Привітання з вибором ролей увімкнено. Канал: {channel.mention}")
        else:
            await ctx.send("✅ Привітання з вибором ролей увімкнено (буде в ЛС новим учасникам)")
    else:
        set_selfrole_settings(ctx.guild.id, None, False)
        await ctx.send("❌ Привітання з вибором ролей вимкнено.")


# Предустановленные роли для анимации и 3D
PRESET_ROLES = {
    "2d_software": {
        "name": "🎨 2D Софт",
        "roles": [
            ("Pencil2D", "✏️", "Безкоштовний 2D редактор"),
            ("TupiTube", "🎬", "Анімація для початківців"),
            ("Synfig Studio", "🌀", "Векторна 2D анімація"),
            ("Krita", "🖌️", "Малювання та анімація"),
            ("Adobe Animate", "🔶", "Професійна Flash анімація"),
            ("Toon Boom Harmony", "🎭", "Індустріальний стандарт"),
            ("TVPaint Animation", "📺", "Традиційна анімація"),
            ("Moho", "🎪", "Anime Studio"),
            ("OpenToonz", "🎞️", "Студійна 2D анімація"),
            ("Clip Studio Paint", "📝", "Манга та анімація"),
            ("FlipaClip", "📱", "Мобільна анімація"),
            ("Animation Desk", "🖼️", "Цифровий блокнот"),
            ("Alight Motion", "✨", "Моушн дизайн"),
            ("ibisPaint X", "🎨", "Малювання на телефоні"),
            ("Pixilart", "👾", "Піксель арт"),
        ]
    },
    "3d_software": {
        "name": "🎮 3D Софт",
        "roles": [
            ("Blender", "🧊", "Безкоштовний 3D комбайн"),
            ("Autodesk Maya", "🌟", "Індустріальний стандарт"),
            ("Autodesk 3ds Max", "🏗️", "3D моделювання"),
            ("Cinema 4D", "🎥", "Моушн графіка"),
            ("Houdini", "🔮", "Процедурна графіка"),
            ("ZBrush", "🗿", "Цифрова скульптура"),
            ("LightWave 3D", "💡", "3D анімація"),
            ("Modo", "⚙️", "Моделювання та рендер"),
            ("SketchUp", "📐", "3D архітектура"),
            ("Unreal Engine", "🎮", "Ігровий рушій"),
            ("Unity", "🕹️", "Ігровий рушій"),
        ]
    },
    "professions": {
        "name": "💼 Професії",
        "roles": [
            ("Аніматор", "🎬", "Створення анімацій"),
            ("3D Художник", "🎮", "3D моделювання та рендер"),
            ("Програміст", "💻", "Розробка та скриптинг"),
            ("Музикант", "🎤", "Створюю музику"),
        ]
    },
    "music": {
        "name": "🎵 Музика",
        "roles": [
            ("FL Studio", "🍊", "DAW для бітмейкінгу"),
            ("Ableton Live", "🎹", "Електронна музика"),
            ("Logic Pro", "🍎", "DAW для Mac"),
            ("Cubase", "🎼", "Професійна DAW"),
            ("Pro Tools", "🎚️", "Студійний стандарт"),
            ("Reaper", "🔪", "Легка та потужна DAW"),
            ("GarageBand", "🎸", "Безкоштовна DAW"),
            ("Audacity", "🎙️", "Аудіо редактор"),
            ("LMMS", "🎵", "Безкоштовна DAW"),
            ("Музикант", "🎤", "Створюю музику"),
            ("Саунд-дизайнер", "🔊", "Звуковий дизайн"),
            ("Бітмейкер", "🥁", "Створюю біти"),
        ]
    }
}


@bot.command(name="createroles")
@commands.has_guild_permissions(administrator=True)
async def cmd_createroles(ctx, category: str = None):
    """!createroles [категорія] — створити ролі на сервері
    
    Категорії: 2d, 3d, prof, music, all
    Приклад: !createroles all
    """
    if not category:
        await ctx.send(
            "🏷️ **Доступні категорії ролей:**\n\n"
            "`!createroles 2d` — 2D софт (15 ролей)\n"
            "`!createroles 3d` — 3D софт (11 ролей)\n"
            "`!createroles prof` — Професії (3 ролі)\n"
            "`!createroles music` — Музика (12 ролей)\n"
            "`!createroles all` — Всі ролі (41 роль)\n"
        )
        return
    
    category = category.lower()
    
    # Определяем какие категории создавать
    if category == "all":
        categories_to_create = ["2d_software", "3d_software", "professions", "music"]
    elif category == "2d":
        categories_to_create = ["2d_software"]
    elif category == "3d":
        categories_to_create = ["3d_software"]
    elif category in ["prof", "professions", "професії"]:
        categories_to_create = ["professions"]
    elif category in ["music", "музика", "муз"]:
        categories_to_create = ["music"]
    else:
        await ctx.send("❌ Невідома категорія. Використовуйте: 2d, 3d, prof, all")
        return
    
    await ctx.send(f"🔄 Створюю ролі... Це може зайняти деякий час.")
    
    init_selfroles_db()
    created = 0
    skipped = 0
    errors = 0
    
    for cat_key in categories_to_create:
        cat_data = PRESET_ROLES[cat_key]
        
        for role_name, emoji, description in cat_data["roles"]:
            # Проверяем существует ли роль
            existing_role = discord.utils.get(ctx.guild.roles, name=role_name)
            
            if existing_role:
                # Роль уже существует — добавляем в selfroles если её там нет
                add_selfrole(ctx.guild.id, existing_role.id, description, emoji)
                skipped += 1
            else:
                try:
                    # Создаем роль
                    new_role = await ctx.guild.create_role(
                        name=role_name,
                        reason=f"Створено через !createroles від {ctx.author}",
                        mentionable=False
                    )
                    # Добавляем в selfroles
                    add_selfrole(ctx.guild.id, new_role.id, description, emoji)
                    created += 1
                    await asyncio.sleep(0.5)  # Избегаем rate limit
                except discord.Forbidden:
                    errors += 1
                except Exception as e:
                    errors += 1
                    print(f"[CREATEROLES ERROR] {role_name}: {e}")
    
    await ctx.send(
        f"✅ **Готово!**\n\n"
        f"🆕 Створено: {created}\n"
        f"⏭️ Пропущено (вже існують): {skipped}\n"
        f"❌ Помилок: {errors}\n\n"
        f"Використовуйте `!roles` для вибору ролей або `!rolemenu #канал` для створення меню."
    )


@bot.command(name="deleteroles")
@commands.has_guild_permissions(administrator=True)
async def cmd_deleteroles(ctx, category: str = None):
    """!deleteroles [категорія] — видалити ролі з сервера
    
    Категорії: 2d, 3d, prof, all
    """
    if not category:
        await ctx.send("❓ Вкажіть категорію: 2d, 3d, prof, all")
        return
    
    category = category.lower()
    
    if category == "all":
        categories_to_delete = ["2d_software", "3d_software", "professions"]
    elif category == "2d":
        categories_to_delete = ["2d_software"]
    elif category == "3d":
        categories_to_delete = ["3d_software"]
    elif category in ["prof", "professions"]:
        categories_to_delete = ["professions"]
    else:
        await ctx.send("❌ Невідома категорія.")
        return
    
    await ctx.send(f"🗑️ Видаляю ролі...")
    
    deleted = 0
    errors = 0
    
    for cat_key in categories_to_delete:
        cat_data = PRESET_ROLES[cat_key]
        
        for role_name, emoji, description in cat_data["roles"]:
            existing_role = discord.utils.get(ctx.guild.roles, name=role_name)
            
            if existing_role:
                try:
                    # Удаляем из selfroles
                    remove_selfrole(ctx.guild.id, existing_role.id)
                    # Удаляем роль
                    await existing_role.delete(reason=f"Видалено через !deleteroles від {ctx.author}")
                    deleted += 1
                    await asyncio.sleep(0.3)
                except:
                    errors += 1
    
    await ctx.send(f"✅ Видалено: {deleted} ролей | Помилок: {errors}")


# ============== КОМАНДИ ОНБОРДИНГУ ==============

@bot.command(name="onboarding")
@commands.has_guild_permissions(administrator=True)
async def cmd_onboarding(ctx, action: str = None, value: str = None):
    """!onboarding — налаштувати онбординг нових учасників
    
    Команди:
    !onboarding — показати статус
    !onboarding on — увімкнути онбординг
    !onboarding off — вимкнути онбординг
    !onboarding channel #канал — канал для онбордингу
    !onboarding quarantine @роль — карантинна роль
    !onboarding required on/off — обов'язковий вибір ролей
    !onboarding test — протестувати онбординг
    """
    init_onboarding_db()
    enabled, quarantine_role_id, channel_id, require_roles = get_onboarding_settings(ctx.guild.id)
    
    if not action:
        # Показываем текущий статус
        status = "✅ Увімкнено" if enabled else "❌ Вимкнено"
        quarantine = ctx.guild.get_role(quarantine_role_id).mention if quarantine_role_id and ctx.guild.get_role(quarantine_role_id) else "не встановлено"
        channel = ctx.guild.get_channel(channel_id).mention if channel_id and ctx.guild.get_channel(channel_id) else "ЛС учасника"
        required = "✅ Так" if require_roles else "❌ Ні"
        
        # Проверяем наличие ролей
        roles_exist = False
        for cat in PRESET_ROLES.values():
            for role_name, _, _ in cat["roles"]:
                if discord.utils.get(ctx.guild.roles, name=role_name):
                    roles_exist = True
                    break
        
        embed = discord.Embed(
            title="🚀 Налаштування Онбордингу",
            description=(
                f"**Статус:** {status}\n"
                f"**Карантинна роль:** {quarantine}\n"
                f"**Канал:** {channel}\n"
                f"**Обов'язковий вибір ролей:** {required}\n\n"
                f"**Ролі створено:** {'✅ Так' if roles_exist else '❌ Ні (використай !createroles all)'}"
            ),
            color=discord.Color.blue()
        )
        embed.add_field(
            name="📝 Команди",
            value=(
                "`!onboarding on` — увімкнути\n"
                "`!onboarding off` — вимкнути\n"
                "`!onboarding channel #канал` — канал\n"
                "`!onboarding quarantine @роль` — карантин\n"
                "`!onboarding required on/off` — обов'язково\n"
                "`!onboarding test` — тест"
            ),
            inline=False
        )
        await ctx.send(embed=embed)
        return
    
    action = action.lower()
    
    if action == "on":
        set_onboarding_settings(ctx.guild.id, True, quarantine_role_id, channel_id, require_roles)
        await ctx.send("✅ **Онбординг увімкнено!**\n\nНові учасники тепер будуть бачити меню вибору ролей при вході.")
        
    elif action == "off":
        set_onboarding_settings(ctx.guild.id, False, quarantine_role_id, channel_id, require_roles)
        await ctx.send("❌ Онбординг вимкнено.")
        
    elif action == "channel":
        if not value:
            await ctx.send("❓ Вкажіть канал: `!onboarding channel #welcome`")
            return
        # Парсим канал из значения или из первого упоминания
        channel_mention = ctx.message.channel_mentions[0] if ctx.message.channel_mentions else None
        if channel_mention:
            set_onboarding_settings(ctx.guild.id, enabled, quarantine_role_id, channel_mention.id, require_roles)
            await ctx.send(f"✅ Канал онбордингу встановлено: {channel_mention.mention}")
        else:
            await ctx.send("❌ Вкажіть канал через згадку: `!onboarding channel #welcome`")
            
    elif action == "quarantine":
        if not value:
            await ctx.send("❓ Вкажіть роль: `!onboarding quarantine @Новачок`")
            return
        role_mention = ctx.message.role_mentions[0] if ctx.message.role_mentions else None
        if role_mention:
            set_onboarding_settings(ctx.guild.id, enabled, role_mention.id, channel_id, require_roles)
            await ctx.send(
                f"✅ Карантинну роль встановлено: {role_mention.mention}\n\n"
                "⚠️ **Важливо!** Налаштуйте права каналів так:\n"
                f"- {role_mention.mention} НЕ бачить основні канали\n"
                f"- {role_mention.mention} бачить тільки канал онбордингу\n"
                "Після проходження онбордингу роль буде знята."
            )
        else:
            await ctx.send("❌ Вкажіть роль через згадку: `!onboarding quarantine @Новачок`")
            
    elif action == "required":
        if value and value.lower() in ["on", "yes", "1", "true", "так"]:
            set_onboarding_settings(ctx.guild.id, enabled, quarantine_role_id, channel_id, True)
            await ctx.send("✅ Вибір ролей тепер **обов'язковий**. Учасники не зможуть пропустити вибір.")
        else:
            set_onboarding_settings(ctx.guild.id, enabled, quarantine_role_id, channel_id, False)
            await ctx.send("✅ Вибір ролей тепер **необов'язковий**. Учасники можуть пропустити.")
            
    elif action == "test":
        # Отправляем тестовое меню онбординга
        view = create_onboarding_view(ctx.guild, quarantine_role_id)
        
        embed = discord.Embed(
            title=f"👋 Ласкаво просимо на {ctx.guild.name}!",
            description=(
                f"Привіт, {ctx.author.mention}!\n\n"
                "Перед тим як увійти на сервер, розкажи нам про себе:\n\n"
                "🎨 **Який софт ти використовуєш?**\n"
                "Обери з випадаючих меню нижче.\n\n"
                "💼 **Ким ти є?**\n"
                "Обери свою професію.\n\n"
                "Після вибору натисни **Готово!** щоб увійти на сервер."
            ),
            color=discord.Color.blue()
        )
        if ctx.guild.icon:
            embed.set_thumbnail(url=ctx.guild.icon.url)
        embed.set_footer(text="🧪 Тестове повідомлення онбордингу")
        
        await ctx.send(embed=embed, view=view)
    else:
        await ctx.send("❓ Невідома дія. Використовуйте: on, off, channel, quarantine, required, test")


@bot.command(name="setuponboarding")
@commands.has_guild_permissions(administrator=True)
async def cmd_setuponboarding(ctx):
    """!setuponboarding — повне автоматичне налаштування онбордингу
    
    Створює карантинну роль, канал онбордингу, ролі та налаштовує права
    """
    await ctx.send("🔧 **Початок повного налаштування онбордингу...**\n⏳ Це займе кілька хвилин...")
    
    init_onboarding_db()
    
    # 1. Создаём карантинную роль
    quarantine_role = discord.utils.get(ctx.guild.roles, name="🆕 Новачок")
    if not quarantine_role:
        try:
            quarantine_role = await ctx.guild.create_role(
                name="🆕 Новачок",
                color=discord.Color.orange(),
                reason="Онбординг: карантинна роль",
                hoist=True  # Показывать отдельно в списке
            )
            await ctx.send(f"✅ Створено карантинну роль {quarantine_role.mention}")
        except Exception as e:
            await ctx.send(f"❌ Помилка створення карантинної ролі: {e}")
            return
    else:
        await ctx.send(f"✅ Роль {quarantine_role.mention} вже існує")
    
    # 2. Ищем или создаём канал онбординга
    onboarding_channel = discord.utils.get(ctx.guild.text_channels, name="👋привітання")
    if not onboarding_channel:
        # Пробуем найти другие подходящие каналы
        onboarding_channel = discord.utils.get(ctx.guild.text_channels, name="welcome") or \
                            discord.utils.get(ctx.guild.text_channels, name="привітання") or \
                            discord.utils.get(ctx.guild.text_channels, name="вітання")
    
    if not onboarding_channel:
        try:
            # Создаём канал с особыми правами
            overwrites = {
                ctx.guild.default_role: discord.PermissionOverwrite(
                    read_messages=False,
                    send_messages=False
                ),
                quarantine_role: discord.PermissionOverwrite(
                    read_messages=True,
                    send_messages=False,
                    read_message_history=True
                ),
                ctx.guild.me: discord.PermissionOverwrite(
                    read_messages=True,
                    send_messages=True,
                    embed_links=True
                )
            }
            onboarding_channel = await ctx.guild.create_text_channel(
                name="👋привітання",
                overwrites=overwrites,
                topic="Канал для вибору ролей новими учасниками",
                reason="Онбординг: канал привітання"
            )
            await ctx.send(f"✅ Створено канал {onboarding_channel.mention}")
        except Exception as e:
            await ctx.send(f"⚠️ Не вдалося створити канал: {e}")
            await ctx.send(f"📝 Створіть канал вручну і використайте `!onboarding channel #канал`")
            # Используем текущий канал
            onboarding_channel = ctx.channel
            await ctx.send(f"⏩ Тимчасово використовую {onboarding_channel.mention}")
    else:
        await ctx.send(f"✅ Канал {onboarding_channel.mention} вже існує")
    
    # Настраиваем права канала онбординга
    try:
        await onboarding_channel.set_permissions(
            quarantine_role,
            read_messages=True,
            send_messages=False,
            read_message_history=True,
            reason="Онбординг: дозвіл для новачків"
        )
    except:
        pass
    
    # 3. Запрещаем карантинной роли доступ ко всем каналам
    await ctx.send("🔒 Налаштовую права каналів... (новачки не бачитимуть інші канали)")
    
    channels_locked = 0
    for channel in ctx.guild.channels:
        if onboarding_channel and channel.id == onboarding_channel.id:
            continue  # Пропускаем канал онбординга
        
        try:
            # Запрещаем доступ карантинной роли
            await channel.set_permissions(
                quarantine_role,
                read_messages=False,
                connect=False,  # Для голосовых
                reason="Онбординг: обмеження для новачків"
            )
            channels_locked += 1
            await asyncio.sleep(0.2)  # Избегаем rate limit
        except:
            pass
    
    await ctx.send(f"✅ Заблоковано {channels_locked} каналів для новачків")
    
    # 4. Создаём роли из пресетов
    await ctx.send("🎨 Створюю ролі для вибору...")
    
    created = 0
    for cat_key, cat_data in PRESET_ROLES.items():
        for role_name, emoji, description in cat_data["roles"]:
            existing = discord.utils.get(ctx.guild.roles, name=role_name)
            if not existing:
                try:
                    new_role = await ctx.guild.create_role(
                        name=role_name,
                        reason=f"Онбординг: створення ролей"
                    )
                    init_selfroles_db()
                    add_selfrole(ctx.guild.id, new_role.id, description, emoji)
                    created += 1
                    await asyncio.sleep(0.3)
                except:
                    pass
            else:
                # Роль уже существует — добавляем в selfroles
                init_selfroles_db()
                add_selfrole(ctx.guild.id, existing.id, description, emoji)
    
    await ctx.send(f"✅ Створено {created} нових ролей")
    
    # 5. Включаем онбординг
    set_onboarding_settings(ctx.guild.id, True, quarantine_role.id, onboarding_channel.id, True)
    
    # 6. Отправляем приветственное сообщение в канал онбординга
    try:
        welcome_embed = discord.Embed(
            title=f"👋 Ласкаво просимо на {ctx.guild.name}!",
            description=(
                "**Перед тим як увійти на сервер, розкажи нам про себе!**\n\n"
                "🎨 **Який софт ти використовуєш?**\n"
                "Обери з меню нижче програми які знаєш.\n\n"
                "💼 **Ким ти є?**\n"
                "Обери свою професію.\n\n"
                "Після вибору натисни **✅ Готово!** щоб отримати доступ до серверу."
            ),
            color=discord.Color.blue()
        )
        if ctx.guild.icon:
            welcome_embed.set_thumbnail(url=ctx.guild.icon.url)
        welcome_embed.set_footer(text="Ці ролі допоможуть іншим знайти тебе")
        
        view = create_onboarding_view(ctx.guild, quarantine_role.id)
        await onboarding_channel.send(embed=welcome_embed, view=view)
        await ctx.send(f"✅ Меню вибору ролей відправлено в {onboarding_channel.mention}")
    except Exception as e:
        await ctx.send(f"⚠️ Не вдалося відправити меню: {e}")
    
    await ctx.send(
        f"\n🎉 **Онбординг повністю налаштовано!**\n\n"
        f"**Як це працює:**\n"
        f"1️⃣ Новий учасник заходить на сервер\n"
        f"2️⃣ Отримує роль {quarantine_role.mention}\n"
        f"3️⃣ Бачить ТІЛЬКИ канал {onboarding_channel.mention}\n"
        f"4️⃣ Обирає ролі з меню\n"
        f"5️⃣ Натискає 'Готово' → роль {quarantine_role.mention} знімається\n"
        f"6️⃣ Отримує доступ до всіх каналів! 🚀\n\n"
        f"**Протестуй:** `!onboarding test`"
    )


@bot.command(name="giverole")
@commands.has_guild_permissions(manage_roles=True)
async def cmd_giverole(ctx, member: discord.Member, role: discord.Role):
    """!giverole @user @role — выдать роль пользователю
    
    Пример: !giverole @Username @Verified
    """
    # Проверяем, может ли бот управлять этой ролью
    if role >= ctx.guild.me.top_role:
        await ctx.send(f"❌ Не можу видати роль {role.mention} — вона вище або рівна моїй найвищій ролі.")
        return
    
    if role in member.roles:
        await ctx.send(f"ℹ️ {member.mention} вже має роль {role.mention}.")
        return
    
    try:
        await member.add_roles(role, reason=f"Видано через команду від {ctx.author}")
        await ctx.send(f"✅ Роль {role.mention} видано користувачу {member.mention}.")
    except discord.Forbidden:
        await ctx.send(f"❌ Недостатньо прав для видачі ролі {role.mention}.")
    except Exception as e:
        await ctx.send(f"❌ Помилка: {str(e)[:200]}")


@bot.command(name="removerole")
@commands.has_guild_permissions(manage_roles=True)
async def cmd_removerole(ctx, member: discord.Member, role: discord.Role):
    """!removerole @user @role — забрать роль у пользователя
    
    Пример: !removerole @Username @Verified
    """
    if role >= ctx.guild.me.top_role:
        await ctx.send(f"❌ Не можу забрати роль {role.mention} — вона вище або рівна моїй найвищій ролі.")
        return
    
    if role not in member.roles:
        await ctx.send(f"ℹ️ {member.mention} не має ролі {role.mention}.")
        return
    
    try:
        await member.remove_roles(role, reason=f"Забрано через команду від {ctx.author}")
        await ctx.send(f"✅ Роль {role.mention} забрано у користувача {member.mention}.")
    except discord.Forbidden:
        await ctx.send(f"❌ Недостатньо прав для забирання ролі {role.mention}.")
    except Exception as e:
        await ctx.send(f"❌ Помилка: {str(e)[:200]}")


@bot.command(name="massrole")
@commands.has_guild_permissions(administrator=True)
async def cmd_massrole(ctx, action: str, role: discord.Role, target_role: discord.Role = None):
    """!massrole <add/remove> @role [@target_role] — массовая выдача/удаление роли
    
    Примеры:
    !massrole add @Verified — выдать роль всем участникам сервера
    !massrole add @Premium @Members — выдать @Premium всем, у кого есть @Members
    !massrole remove @OldRole — убрать роль у всех
    """
    if action not in ["add", "remove"]:
        await ctx.send("❌ Використовуйте `add` або `remove`.")
        return
    
    if role >= ctx.guild.me.top_role:
        await ctx.send(f"❌ Не можу керувати роллю {role.mention} — вона вище або рівна моїй найвищій ролі.")
        return
    
    # Определяем целевых участников
    if target_role:
        members = [m for m in ctx.guild.members if target_role in m.roles and not m.bot]
    else:
        members = [m for m in ctx.guild.members if not m.bot]
    
    if not members:
        await ctx.send("❌ Немає учасників для обробки.")
        return
    
    await ctx.send(f"⏳ Обробка {len(members)} учасників...")
    
    success = 0
    failed = 0
    
    for member in members:
        try:
            if action == "add":
                if role not in member.roles:
                    await member.add_roles(role, reason=f"Масова видача від {ctx.author}")
                    success += 1
            else:
                if role in member.roles:
                    await member.remove_roles(role, reason=f"Масове забирання від {ctx.author}")
                    success += 1
            await asyncio.sleep(0.3)  # Избегаем rate limit
        except Exception:
            failed += 1
    
    action_text = "видано" if action == "add" else "забрано"
    await ctx.send(f"✅ Роль {role.mention} {action_text} у {success} учасників. Помилок: {failed}.")


@bot.command(name="autorole")
@commands.has_guild_permissions(administrator=True)
async def cmd_autorole(ctx, role: discord.Role = None):
    """!autorole [@role] — установить/показать/убрать авто-роль для новых участников
    
    Примеры:
    !autorole @Member — установить авто-роль
    !autorole — показать текущую авто-роль
    !autorole off — отключить авто-роль
    """
    init_autorole_db()
    
    if role is None:
        # Показать текущую
        current = get_autorole(ctx.guild.id)
        if current:
            role_obj = ctx.guild.get_role(current)
            if role_obj:
                await ctx.send(f"🔄 Поточна авто-роль: {role_obj.mention}")
            else:
                await ctx.send("⚠️ Авто-роль встановлена, але роль більше не існує.")
        else:
            await ctx.send("ℹ️ Авто-роль не встановлена. Використовуйте `!autorole @роль` для налаштування.")
        return
    
    if role >= ctx.guild.me.top_role:
        await ctx.send(f"❌ Не можу видавати роль {role.mention} — вона вище або рівна моїй найвищій ролі.")
        return
    
    set_autorole(ctx.guild.id, role.id)
    await ctx.send(f"✅ Авто-роль встановлена: {role.mention}\nНові учасники будуть автоматично отримувати цю роль.")


@bot.command(name="autorole_off")
@commands.has_guild_permissions(administrator=True)
async def cmd_autorole_off(ctx):
    """!autorole_off — отключить авто-роль"""
    init_autorole_db()
    set_autorole(ctx.guild.id, None)
    await ctx.send("✅ Авто-роль вимкнена.")


@bot.command(name="listroles")
async def cmd_listroles(ctx, member: discord.Member = None):
    """!listroles [@user] — показать роли пользователя или все роли сервера
    
    Примеры:
    !listroles — все роли сервера
    !listroles @Username — роли конкретного пользователя
    """
    if member:
        roles = [r.mention for r in member.roles if r.name != "@everyone"]
        if roles:
            await ctx.send(f"🏷️ Ролі {member.mention}: {', '.join(roles)}")
        else:
            await ctx.send(f"ℹ️ {member.mention} не має ролей.")
    else:
        roles = [(r.name, len(r.members), r.mention) for r in ctx.guild.roles if r.name != "@everyone"]
        roles.sort(key=lambda x: -x[1])
        
        text = f"🏷️ **Ролі сервера {ctx.guild.name}:**\n\n"
        for name, count, mention in roles[:25]:
            text += f"{mention}: {count} учасників\n"
        
        if len(roles) > 25:
            text += f"\n... та ще {len(roles) - 25} ролей"
        
        await ctx.send(text)


@bot.command(name="roleinfo")
async def cmd_roleinfo(ctx, role: discord.Role):
    """!roleinfo @role — информация о роли"""
    perms = []
    if role.permissions.administrator:
        perms.append("👑 Адміністратор")
    if role.permissions.manage_guild:
        perms.append("⚙️ Керування сервером")
    if role.permissions.manage_roles:
        perms.append("🏷️ Керування ролями")
    if role.permissions.manage_channels:
        perms.append("📁 Керування каналами")
    if role.permissions.kick_members:
        perms.append("👢 Вигнання")
    if role.permissions.ban_members:
        perms.append("🔨 Бан")
    if role.permissions.manage_messages:
        perms.append("💬 Керування повідомленнями")
    
    info = f"""🏷️ **Інформація про роль {role.mention}**

📝 **Назва:** {role.name}
🆔 **ID:** {role.id}
🎨 **Колір:** {str(role.color)}
👥 **Учасників:** {len(role.members)}
📍 **Позиція:** {role.position}
🔔 **Згадується окремо:** {"Так" if role.hoist else "Ні"}
🤖 **Ботова роль:** {"Так" if role.is_bot_managed() else "Ні"}

"""
    
    if perms:
        info += "⚡ **Ключові права:**\n" + "\n".join(perms)
    else:
        info += "⚡ **Ключові права:** Немає особливих прав"
    
    await ctx.send(info)


# ---------- Запуск ----------
if __name__ == "__main__":
    # Загружаем переменные окружения из .env, если файл есть
    try:
        load_dotenv()
    except Exception:
        pass
    init_db()
    TOKEN = os.getenv("DISCORD_TOKEN")
    if not TOKEN:
        print("❌ Будь ласка, встановіть змінну оточення DISCORD_TOKEN з токеном бота.")
    else:
        print("🚀 Запуск бота...")
        try:
            bot.run(TOKEN)
        except discord.errors.PrivilegedIntentsRequired:
            print(
                "❌ Помилка: для цього бота потрібні привілейовані інтенти. "
                "Зайдіть до Discord Developer Portal → Bot і увімкніть 'MESSAGE CONTENT INTENT' "
                "та 'SERVER MEMBERS INTENT', потім збережіть зміни."
            )