const { Client, GatewayIntentBits, EmbedBuilder } = require('discord.js');
const { AutoModerationRuleTriggerType, AutoModerationRuleActionType } = require('discord.js');

class ModerationBot {
    constructor() {
        this.client = new Client({
            intents: [
                GatewayIntentBits.Guilds,
                GatewayIntentBits.GuildMessages,
                GatewayIntentBits.MessageContent,
                GatewayIntentBits.GuildMembers
            ]
        });
        
        this.setupEventHandlers();
    }
    
    setupEventHandlers() {
        this.client.on('messageCreate', async (message) => {
            if (message.author.bot) return;
            
            // Проверка на спам
            if (this.isSpam(message)) {
                await this.handleSpam(message);
            }
            
            // Проверка на токсичность
            if (this.isToxic(message)) {
                await this.handleToxicMessage(message);
            }
            
            // Проверка на рекламу
            if (this.isAdvertisement(message)) {
                await this.handleAdvertisement(message);
            }
        });
        
        this.client.on('guildMemberAdd', async (member) => {
            await this.handleNewMember(member);
        });
    }
    
    async handleSpam(message) {
        // Удаление сообщения
        await message.delete();
        
        // Предупреждение пользователю
        const embed = new EmbedBuilder()
            .setColor('#ff0000')
            .setTitle('⚠️ Предупреждение')
            .setDescription('Ваше сообщение было удалено за спам.')
            .setTimestamp();
        
        await message.author.send({ embeds: [embed] });
        
        // Логирование
        await this.logModerationAction(message, 'spam_detection');
    }
    
    async handleToxicMessage(message) {
        // Удаление сообщения
        await message.delete();
        
        // Временная блокировка
        const timeoutDuration = 10  60  1000; // 10 минут
        await message.member.timeout(timeoutDuration, 'Токсичное сообщение');
        
        // Уведомление модераторам
        await this.notifyModerators(message, 'toxic_message');
    }
    
    async handleNewMember(member) {
        // Проверка аккаунта
        const accountAge = Date.now() - member.user.createdTimestamp;
        const isNewAccount = accountAge < 7  24  60  60  1000; // 7 дней
        
        if (isNewAccount) {
            // Ограниченные права для новых аккаунтов
            const role = member.guild.roles.cache.find(r => r.name === 'Новый участник');
            if (role) {
                await member.roles.add(role);
            }
        }
        
        // Приветственное сообщение
        const welcomeEmbed = new EmbedBuilder()
            .setColor('#00ff00')
            .setTitle(Добро пожаловать, ${member.user.username}!)
            .setDescription('Добро пожаловать на наш сервер!')
            .addFields(
                { name: 'Правила', value: 'Прочитайте правила в канале #правила' },
                { name: 'Роли', value: 'Выберите роли в канале #роли' }
            )
            .setThumbnail(member.user.displayAvatarURL())
            .setTimestamp();
        
        const welcomeChannel = member.guild.channels.cache.find(ch => ch.name === 'добро-пожаловать');
        if (welcomeChannel) {
            await welcomeChannel.send({ embeds: [welcomeEmbed] });
        }
    }
}

class GamingBot {
    constructor() {
        this.games = new Map();
        this.playerStats = new Map();
    }
    
    async startGame(message, gameType) {
        const channel = message.channel;
        const gameId = ${channel.id}_${Date.now()};
        
        switch (gameType) {
            case 'trivia':
                await this.startTriviaGame(gameId, channel);
                break;
            case 'wordle':
                await this.startWordleGame(gameId, channel);
                break;
            case 'poker':
                await this.startPokerGame(gameId, channel);
                break;
        }
    }
    
    async startTriviaGame(gameId, channel) {
        const questions = [
            {
                question: "Какая столица России?",
                options: ["Москва", "Санкт-Петербург", "Казань", "Новосибирск"],
                correct: 0,
                points: 10
            },
            {
                question: "Сколько планет в Солнечной системе?",
                options: ["8", "9", "10", "7"],
                correct: 0,
                points: 15
            }
        ];
        
        const game = {
            id: gameId,
            channel: channel,
            questions: questions,
            currentQuestion: 0,
            players: new Map(),
            startTime: Date.now()
        };
        
        this.games.set(gameId, game);
        
        // Отправка первого вопроса
        await this.sendQuestion(game);
        
        // Таймер для вопроса
        setTimeout(() => {
            this.endQuestion(game);
        }, 30000); // 30 секунд на ответ
    }
    
    async sendQuestion(game) {
        const question = game.questions[game.currentQuestion];
        
        const embed = new EmbedBuilder()
            .setColor('#0099ff')
            .setTitle(Вопрос ${game.currentQuestion + 1}/${game.questions.length})
            .setDescription(question.question)
            .addFields(
                { name: 'A', value: question.options[0], inline: true },
                { name: 'B', value: question.options[1], inline: true },
                { name: 'C', value: question.options[2], inline: true },
                { name: 'D', value: question.options[3], inline: true }
            )
            .setFooter({ text: 'Ответьте реакцией A, B, C или D' });
        
        const message = await game.channel.send({ embeds: [embed] });
        
        // Добавляем реакции
        await message.react('🇦');
        await message.react('🇧');
        await message.react('🇨');
        await message.react('🇩');
        
        game.questionMessage = message;
    }
    
    async handleAnswer(reaction, user) {
        if (user.bot) return;
        
        const gameId = this.findGameByChannel(reaction.message.channel);
        if (!gameId) return;
        
        const game = this.games.get(gameId);
        if (!game || !game.questionMessage) return;
        
        if (reaction.message.id !== game.questionMessage.id) return;
        
        const answerMap = { '🇦': 0, '🇧': 1, '🇨': 2, '🇩': 3 };
        const userAnswer = answerMap[reaction.emoji.name];
        
        if (userAnswer === undefined) return;
        
        const question = game.questions[game.currentQuestion];
        const isCorrect = userAnswer === question.correct;
        
        // Обновление статистики игрока
        if (!game.players.has(user.id)) {
            game.players.set(user.id, { score: 0, correct: 0, total: 0 });
        }
        
        const player = game.players.get(user.id);
        player.total++;
        
        if (isCorrect) {
            player.score += question.points;
            player.correct++;
            
            await reaction.message.reply(✅ ${user.username} ответил правильно! (+${question.points} очков));
        } else {
            await reaction.message.reply(❌ ${user.username} ответил неправильно. Правильный ответ: ${question.options[question.correct]});
        }
    }
}

class AnalyticsBot {
    constructor() {
        this.serverStats = new Map();
        this.userActivity = new Map();
        this.channelStats = new Map();
    }
    
    async trackMessage(message) {
        if (message.author.bot) return;
        
        const userId = message.author.id;
        const channelId = message.channel.id;
        const guildId = message.guild.id;
        
        // Обновление статистики пользователя
        if (!this.userActivity.has(userId)) {
            this.userActivity.set(userId, {
                messages: 0,
                channels: new Set(),
                lastActivity: Date.now(),
                joinDate: message.member.joinedTimestamp
            });
        }
        
        const userStats = this.userActivity.get(userId);
        userStats.messages++;
        userStats.channels.add(channelId);
        userStats.lastActivity = Date.now();
        
        // Обновление статистики канала
        if (!this.channelStats.has(channelId)) {
            this.channelStats.set(channelId, {
                messages: 0,
                users: new Set(),
                lastActivity: Date.now()
            });
        }
        
        const channelStats = this.channelStats.get(channelId);
        channelStats.messages++;
        channelStats.users.add(userId);
        channelStats.lastActivity = Date.now();
    }
    
    async generateServerReport(guild) {
        const totalMembers = guild.memberCount;
        const onlineMembers = guild.members.cache.filter(member => member.presence?.status !== 'offline').size;
        const channels = guild.channels.cache.size;
        const roles = guild.roles.cache.size;
        
        // Топ активных пользователей
        const topUsers = Array.from(this.userActivity.entries())
            .sort((a, b) => b[1].messages - a[1].messages)
            .slice(0, 10);
        
        // Топ активных каналов
        const topChannels = Array.from(this.channelStats.entries())
            .sort((a, b) => b[1].messages - a[1].messages)
            .slice(0, 5);
        
        const embed = new EmbedBuilder()
            .setColor('#00ff00')
            .setTitle(📊 Отчет по серверу ${guild.name})
            .setThumbnail(guild.iconURL())
            .addFields(
                { name: '👥 Участники', value: ${onlineMembers}/${totalMembers} онлайн, inline: true },
                { name: '📺 Каналы', value: channels.toString(), inline: true },
                { name: '🎭 Роли', value: roles.toString(), inline: true },
                { name: '🔥 Топ пользователей', value: this.formatTopUsers(topUsers), inline: false },
                { name: '📈 Топ каналов', value: this.formatTopChannels(topChannels), inline: false }
            )
            .setTimestamp();
        
        return embed;
    }
    
    formatTopUsers(users) {
        return users.map(([userId, stats], index) => {
            const user = this.client.users.cache.get(userId);
            return ${index + 1}. ${user?.username || 'Неизвестный'}: ${stats.messages} сообщений;
        }).join('\n');
    }
    
    formatTopChannels(channels) {
        return channels.map(([channelId, stats], index) => {
            const channel = this.client.channels.cache.get(channelId);
            return ${index + 1}. ${channel?.name || 'Неизвестный'}: ${stats.messages} сообщений;
        }).join('\n');
    }
}

class CommerceBot {
    constructor() {
        this.products = new Map();
        this.orders = new Map();
        this.userBalances = new Map();
    }
    
    async setupShop() {
        // Добавление товаров
        this.products.set('premium_role', {
            name: 'Премиум роль',
            price: 500,
            description: 'Доступ к эксклюзивным каналам',
            type: 'role'
        });
        
        this.products.set('custom_emoji', {
            name: 'Кастомный эмодзи',
            price: 1000,
            description: 'Персональный эмодзи на сервере',
            type: 'emoji'
        });
        
        this.products.set('server_boost', {
            name: 'Буст сервера',
            price: 2000,
            description: 'Улучшения для всего сервера',
            type: 'boost'
        });
    }
    
    async showShop(message) {
        const embed = new EmbedBuilder()
            .setColor('#ff9900')
            .setTitle('🛒 Магазин сервера')
            .setDescription('Выберите товар для покупки:');
        
        for (const [id, product] of this.products) {
            embed.addFields({
                name: ${product.name} - ${product.price} 💰,
                value: product.description,
                inline: false
            });
        }
        
        embed.setFooter({ text: 'Используйте /buy <товар> для покупки' });
        
        await message.reply({ embeds: [embed] });
    }
    
    async processPurchase(userId, productId) {
        const product = this.products.get(productId);
        if (!product) {
            return { success: false, message: 'Товар не найден' };
        }
        
        const userBalance = this.userBalances.get(userId) || 0;
        if (userBalance < product.price) {
            return { success: false, message: 'Недостаточно средств' };
        }
        
        // Списание средств
        this.userBalances.set(userId, userBalance - product.price);
        
        // Создание заказа
        const orderId = order_${Date.now()}_${userId};
        this.orders.set(orderId, {
            id: orderId,
            userId: userId,
            productId: productId,
            price: product.price,
            status: 'pending',
            createdAt: Date.now()
        });
        
        // Выполнение покупки
        await this.executePurchase(userId, product);
        
        return { success: true, message: 'Покупка успешно выполнена!' };
    }
    
    async executePurchase(userId, product) {
        const user = this.client.users.cache.get(userId);
        const guild = this.client.guilds.cache.first(); // Предполагаем один сервер
        
        switch (product.type) {
            case 'role':
                const role = guild.roles.cache.find(r => r.name === 'Premium');
                if (role) {
                    const member = guild.members.cache.get(userId);
                    if (member) {
                        await member.roles.add(role);
                    }
                }
                break;
                
            case 'emoji':
                // Логика создания кастомного эмодзи
                await this.createCustomEmoji(guild, userId);
                break;
                
            case 'boost':
                // Логика буста сервера
                await this.boostServer(guild, userId);
                break;
        }
    }
}

const { Pool } = require('pg');

class DatabaseIntegration {
    constructor() {
        this.pool = new Pool({
            user: process.env.DB_USER,
            host: process.env.DB_HOST,
            database: process.env.DB_NAME,
            password: process.env.DB_PASSWORD,
            port: process.env.DB_PORT,
        });
    }
    
    async saveUserData(userId, data) {
        const query = 
            INSERT INTO users (discord_id, username, data, created_at)
            VALUES ($1, $2, $3, NOW())
            ON CONFLICT (discord_id) 
            DO UPDATE SET username = $2, data = $3, updated_at = NOW()
        ;
        
        await this.pool.query(query, [userId, data.username, JSON.stringify(data)]);
    }
    
    async getUserData(userId) {
        const query = 'SELECT * FROM users WHERE discord_id = $1';
        const result = await this.pool.query(query, [userId]);
        return result.rows[0];
    }
    
    async saveServerStats(guildId, stats) {
        const query = 
            INSERT INTO server_stats (guild_id, stats, date)
            VALUES ($1, $2, CURRENT_DATE)
            ON CONFLICT (guild_id, date)
            DO UPDATE SET stats = $2
        ;
        
        await this.pool.query(query, [guildId, JSON.stringify(stats)]);
    }
}

class ExternalAPIIntegration {
    constructor() {
        this.apis = {
            weather: 'https://api.openweathermap.org/data/2.5/weather',
            crypto: 'https://api.coingecko.com/api/v3/simple/price',
            news: 'https://newsapi.org/v2/top-headlines'
        };
    }
    
    async getWeather(city) {
        try {
            const response = await fetch(${this.apis.weather}?q=${city}&appid=${process.env.WEATHER_API_KEY}&units=metric&lang=ru);
            const data = await response.json();
            
            return {
                city: data.name,
                temperature: data.main.temp,
                description: data.weather[0].description,
                humidity: data.main.humidity,
                windSpeed: data.wind.speed
            };
        } catch (error) {
            console.error('Weather API error:', error);
            return null;
        }
    }
    
    async getCryptoPrice(coin) {
        try {
            const response = await fetch(${this.apis.crypto}?ids=${coin}&vs_currencies=usd,rub);
            const data = await response.json();
            
            return data[coin];
        } catch (error) {
            console.error('Crypto API error:', error);
            return null;
        }
    }
    
    async getNews(category = 'general') {
        try {
            const response = await fetch(${this.apis.news}?category=${category}&apiKey=${process.env.NEWS_API_KEY}&language=ru);
            const data = await response.json();
            
            return data.articles.slice(0, 5); // Топ 5 новостей
        } catch (error) {
            console.error('News API error:', error);
            return null;
        }
    }
}

# docker-compose.yml
version: '3.8'
services:
  discord-bot:
    build: .
    environment:
      - DISCORD_TOKEN=${DISCORD_TOKEN}
      - DB_HOST=${DB_HOST}
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_NAME=${DB_NAME}
      - WEATHER_API_KEY=${WEATHER_API_KEY}
      - NEWS_API_KEY=${NEWS_API_KEY}
    volumes:
      - ./logs:/app/logs
      - ./data:/app/data
    restart: unless-stopped
    
  postgres:
    image: postgres:15
    environment:
      - POSTGRES_DB=${DB_NAME}
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
      
  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    ports:
      - "6379:6379"

volumes:
  postgres_data:
  redis_data:

class BotMonitoring {
    constructor() {
        this.metrics = {
            uptime: Date.now(),
            messagesProcessed: 0,
            commandsExecuted: 0,
            errors: 0,
            memoryUsage: process.memoryUsage()
        };
    }
    
    async logCommand(command, user, success) {
        this.metrics.commandsExecuted++;
        
        const logEntry = {
            timestamp: new Date().toISOString(),
            command: command,
            user: user.id,
            username: user.username,
            success: success
        };
        
        console.log('Command executed:', logEntry);
        
        // Сохранение в базу данных
        await this.saveLogEntry(logEntry);
    }
    
    async logError(error, context) {
        this.metrics.errors++;
        
        const errorEntry = {
            timestamp: new Date().toISOString(),
            error: error.message,
            stack: error.stack,
            context: context
        };
        
        console.error('Bot error:', errorEntry);
        
        // Отправка уведомления администраторам
        await this.notifyAdmins(errorEntry);
    }
    
    getHealthStatus() {
        const uptime = Date.now() - this.metrics.uptime;
        const memoryUsage = process.memoryUsage();
        
        return {
            status: 'healthy',
            uptime: uptime,
            memoryUsage: memoryUsage,
            messagesProcessed: this.metrics.messagesProcessed,
            commandsExecuted: this.metrics.commandsExecuted,
            errorRate: this.metrics.errors / this.metrics.commandsExecuted
        };
    }
}