// Discord Bot Development
const { Client, GatewayIntentBits, SlashCommandBuilder, REST, Routes } = require('discord.js');

class DiscordBot {
    constructor(token, clientId, guildId) {
        this.token = token;
        this.clientId = clientId;
        this.guildId = guildId;
        
        this.client = new Client({
            intents: [
                GatewayIntentBits.Guilds,
                GatewayIntentBits.GuildMessages,
                GatewayIntentBits.MessageContent,
                GatewayIntentBits.GuildVoiceStates
            ]
        });
        
        this.setupEventHandlers();
    }
    
    setupEventHandlers() {
        this.client.once('ready', () => {
            console.log(`Bot logged in as ${this.client.user.tag}`);
        });
        
        this.client.on('interactionCreate', async (interaction) => {
            if (!interaction.isChatInputCommand()) return;
            
            switch (interaction.commandName) {
                case 'ping':
                    await this.handlePing(interaction);
                    break;
                    
                case 'createevent':
                    await this.handleCreateEvent(interaction);
                    break;
                    
                case 'moderation':
                    await this.handleModeration(interaction);
                    break;
                    
                case 'music':
                    await this.handleMusic(interaction);
                    break;
            }
        });
        
        this.client.on('guildMemberAdd', async (member) => {
            await this.welcomeNewMember(member);
        });
    }
    
    async registerCommands() {
        const commands = [
            new SlashCommandBuilder()
                .setName('ping')
                .setDescription('Check bot latency'),
                
            new SlashCommandBuilder()
                .setName('createevent')
                .setDescription('Create a server event')
                .addStringOption(option =>
                    option.setName('title')
                        .setDescription('Event title')
                        .setRequired(true))
                .addStringOption(option =>
                    option.setName('description')
                        .setDescription('Event description'))
                .addStringOption(option =>
                    option.setName('date')
                        .setDescription('Event date (YYYY-MM-DD)')),
                        
            new SlashCommandBuilder()
                .setName('moderation')
                .setDescription('Moderation commands')
                .addSubcommand(subcommand =>
                    subcommand
                        .setName('warn')
                        .setDescription('Warn a user')
                        .addUserOption(option =>
                            option.setName('user')
                                .setDescription('User to warn')
                                .setRequired(true))
                        .addStringOption(option =>
                            option.setName('reason')
                                .setDescription('Warning reason')))
                .addSubcommand(subcommand =>
                    subcommand
                        .setName('mute')
                        .setDescription('Mute a user')
                        .addUserOption(option =>
                            option.setName('user')
                                .setDescription('User to mute')
                                .setRequired(true))
                        .addIntegerOption(option =>
                            option.setName('duration')
                                .setDescription('Mute duration in minutes')))
        ];
        
        const rest = new REST({ version: '10' }).setToken(this.token);
        
        try {
            await rest.put(
                Routes.applicationGuildCommands(this.clientId, this.guildId),
                { body: commands }
            );
            console.log('Commands registered successfully');
        } catch (error) {
            console.error('Error registering commands:', error);
        }
    }
    
    async handlePing(interaction) {
        const ping = this.client.ws.ping;
        await interaction.reply(`🏓 Pong! Latency: ${ping}ms`);
    }
    
    async handleCreateEvent(interaction) {
        const title = interaction.options.getString('title');
        const description = interaction.options.getString('description') || 'No description provided';
        const date = interaction.options.getString('date');
        
        const guild = interaction.guild;
        
        try {
            const event = await guild.scheduledEvents.create({
                name: title,
                description: description,
                scheduledStartTime: date ? new Date(date) : new Date(Date.now() + 24 * 60 * 60 * 1000),
                privacyLevel: 2, // Guild only
                entityType: 3    // External
            });
            
            await interaction.reply(`✅ Event "${title}" created successfully!`);
        } catch (error) {
            await interaction.reply('❌ Failed to create event. Please check the date format.');
        }
    }
    
    async handleModeration(interaction) {
        const subcommand = interaction.options.getSubcommand();
        const targetUser = interaction.options.getUser('user');
        const member = interaction.guild.members.cache.get(targetUser.id);
        
        if (subcommand === 'warn') {
            const reason = interaction.options.getString('reason') || 'No reason provided';
            
            // Store warning in database
            await this.storeWarning(targetUser.id, interaction.user.id, reason);
            
            await interaction.reply(`⚠️ ${targetUser.tag} has been warned for: ${reason}`);
            
            // DM the user
            try {
                await targetUser.send(`You have been warned in ${interaction.guild.name} for: ${reason}`);
            } catch (error) {
                console.log('Could not DM user');
            }
            
        } else if (subcommand === 'mute') {
            const duration = interaction.options.getInteger('duration') || 60;
            
            try {
                await member.timeout(duration * 60 * 1000, 'Muted by moderator');
                await interaction.reply(`🔇 ${targetUser.tag} has been muted for ${duration} minutes`);
            } catch (error) {
                await interaction.reply('❌ Failed to mute user. Check permissions.');
            }
        }
    }
    
    async welcomeNewMember(member) {
        const welcomeChannel = member.guild.channels.cache.find(
            channel => channel.name === 'welcome' || channel.name === 'general'
        );
        
        if (welcomeChannel) {
            const welcomeEmbed = {
                color: 0x00FF00,
                title: 'Welcome to the server!',
                description: `Hello ${member.user.tag}! Welcome to **${member.guild.name}**`,
                thumbnail: { url: member.user.displayAvatarURL() },
                fields: [
                    { name: 'Member #', value: member.guild.memberCount.toString(), inline: true },
                    { name: 'Account Created', value: member.user.createdAt.toDateString(), inline: true }
                ],
                timestamp: new Date()
            };
            
            await welcomeChannel.send({ embeds: [welcomeEmbed] });
        }
        
        // Auto-assign role
        const memberRole = member.guild.roles.cache.find(role => role.name === 'Member');
        if (memberRole) {
            await member.roles.add(memberRole);
        }
    }
    
    async start() {
        await this.registerCommands();
        await this.client.login(this.token);
    }
}

// Discord Server Management Tools
class DiscordServerManager {
    constructor(client) {
        this.client = client;
    }
    
    async setupServerStructure(guildId, structure) {
        const guild = this.client.guilds.cache.get(guildId);
        
        // Create categories and channels
        for (const category of structure.categories) {
            const categoryChannel = await guild.channels.create({
                name: category.name,
                type: 4, // Category
                position: category.position
            });
            
            // Create text channels in category
            for (const textChannel of category.textChannels) {
                await guild.channels.create({
                    name: textChannel.name,
                    type: 0, // Text
                    parent: categoryChannel.id,
                    topic: textChannel.description
                });
            }
            
            // Create voice channels in category
            for (const voiceChannel of category.voiceChannels) {
                await guild.channels.create({
                    name: voiceChannel.name,
                    type: 2, // Voice
                    parent: categoryChannel.id,
                    userLimit: voiceChannel.userLimit || 0
                });
            }
        }
    }
    
    async createRoleSystem(guildId, roles) {
        const guild = this.client.guilds.cache.get(guildId);
        
        for (const role of roles) {
            await guild.roles.create({
                name: role.name,
                color: role.color,
                permissions: role.permissions,
                hoist: role.hoist || false,
                mentionable: role.mentionable || false
            });
        }
    }
    
    async setupAutoModeration(guildId, rules) {
        const guild = this.client.guilds.cache.get(guildId);
        
        // Create auto-moderation rules
        for (const rule of rules) {
            await guild.autoModerationRules.create({
                name: rule.name,
                eventType: rule.eventType,
                triggerType: rule.triggerType,
                triggerMetadata: rule.triggerMetadata,
                actions: rule.actions,
                enabled: true
            });
        }
    }
    
    async generateServerAnalytics(guildId) {
        const guild = this.client.guilds.cache.get(guildId);
        
        const analytics = {
            memberCount: guild.memberCount,
            onlineMembers: guild.members.cache.filter(m => m.presence?.status !== 'offline').size,
            channelCount: guild.channels.cache.size,
            roleCount: guild.roles.cache.size,
            boostLevel: guild.premiumTier,
            boostCount: guild.premiumSubscriptionCount,
            createdAt: guild.createdAt,
            features: guild.features
        };
        
        return analytics;
    }
}