DiscordBotExample

const { Client, GatewayIntentBits, REST, Routes, EmbedBuilder } = require('discord.js');
const fs = require('fs');
require('dotenv').config();

// My Client Instance
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages] });

// Defining slash commands :)
const commands = [
    {
        name: 'ping',
        description: 'Replies with bot and API latency!',
    },
    {
        name: 'kick',
        description: 'Kicks a user from the server.',
        options: [
            {
                name: 'user',
                type: 6, // USER type
                description: 'The user to kick.',
                required: true,
            },
        ],
    },
    {
        name: 'ban',
        description: 'Bans a user from the server.',
        options: [
            {
                name: 'user',
                type: 6, // USER type
                description: 'The user to ban.',
                required: true,
            },
        ],
    },
    {
        name: 'timeout',
        description: 'Timeout (mute) a user for a specified duration.',
        options: [
            {
                name: 'user',
                type: 6, // USER type
                description: 'The user to timeout.',
                required: true,
            },
            {
                name: 'duration',
                type: 4, // INTEGER type
                description: 'The duration in seconds.',
                required: true,
            },
        ],
    },
    {
        name: 'clear',
        description: 'Deletes a number of messages from a channel.',
        options: [
            {
                name: 'amount',
                type: 4, // INTEGER type
                description: 'Number of messages to delete (1-100).',
                required: true,
            },
        ],
    },
    {
        name: 'level',
        description: 'Check your level and XP.',
    },
    {
        name: 'leaderboard',
        description: 'Shows the top 10 users by XP.',
    }
];

// Slash Commands Registration
const rest = new REST({ version: '10' }).setToken(process.env.TOKEN);

(async () => {
    try {
        console.log('Started refreshing application (/) commands.');
        await rest.put(
            Routes.applicationGuildCommands(process.env.CLIENT_ID, '1266754889661550652'),
            { body: commands }
        );

        console.log('Successfully reloaded application (/) commands.');
    } catch (error) {
        console.error(error);
    }
})();

// Leveling system roles
const roles = [
  { level: 1, role: 'Bronze I' },
  { level: 5, role: 'Bronze II' },
  { level: 10, role: 'Bronze III' },
  { level: 15, role: 'Silver I', additionalRole: 'Cub' },
  { level: 20, role: 'Silver II' },
  { level: 25, role: 'Silver III' },
  { level: 30, role: 'Gold I', additionalRole: 'Young Cub' },
  { level: 35, role: 'Gold II' },
  { level: 40, role: 'Gold III' },
  { level: 45, role: 'Platinum I', additionalRole: 'Young Adult' },
  { level: 50, role: 'Platinum II' },
  { level: 55, role: 'Platinum III' },
  { level: 60, role: 'Diamond I', additionalRole: 'Adult' },
  { level: 65, role: 'Diamond II' },
  { level: 70, role: 'Diamond III' },
  { level: 100, role: 'Tiger Champion', additionalRole: 'Full Grown Adult' }
];

// File to store user data (XP and Level)
const userDataFile = './userData.json';

// Check if the user data file exists, or just create one duh
if (!fs.existsSync(userDataFile)) {
    fs.writeFileSync(userDataFile, JSON.stringify({ users: {} }, null, 4));
}

// Load user data
function loadUserData() {
    return JSON.parse(fs.readFileSync(userDataFile, 'utf8'));
}

// Save user data
function saveUserData(data) {
    fs.writeFileSync(userDataFile, JSON.stringify(data, null, 4));
}

// When the bot is ready
client.once('ready', () => {
    console.log(`Logged in as ${client.user.tag}!`);
});

// Handle slash commands
client.on('interactionCreate', async (interaction) => {
    if (!interaction.isCommand()) return;

    const { commandName, options } = interaction;

    if (commandName === 'ping') {
        const embed = new EmbedBuilder()
            .setColor(0x00ff00)
            .setTitle('🏓 Pong!')
            .addFields(
                { name: 'Bot Latency', value: `${Date.now() - interaction.createdTimestamp}ms`, inline: true },
                { name: 'API Latency', value: `${Math.round(client.ws.ping)}ms`, inline: true }
            )
            .setFooter({ text: 'Latency Checker', iconURL: client.user.displayAvatarURL() });

        await interaction.reply({ embeds: [embed] });
    } else if (commandName === 'kick') {
        const user = options.getUser('user');
        const member = interaction.guild.members.cache.get(user.id);

        if (!member) {
            return interaction.reply({ content: 'User not found!', ephemeral: true });
        }

        try {
            await member.kick();
            const embed = new EmbedBuilder()
                .setColor(0xff0000)
                .setTitle('✅ User Kicked')
                .setDescription(`Successfully kicked ${user.tag}.`)
                .setTimestamp();

            interaction.reply({ embeds: [embed] });
        } catch (error) {
            interaction.reply({ content: `❌ Failed to kick ${user.tag}.`, ephemeral: true });
        }
    } else if (commandName === 'ban') {
        const user = options.getUser('user');
        const member = interaction.guild.members.cache.get(user.id);

        if (!member) {
            return interaction.reply({ content: 'User not found!', ephemeral: true });
        }

        try {
            await member.ban();
            const embed = new EmbedBuilder()
                .setColor(0xff0000)
                .setTitle('✅ User Banned')
                .setDescription(`Successfully banned ${user.tag}.`)
                .setTimestamp();

            interaction.reply({ embeds: [embed] });
        } catch (error) {
            interaction.reply({ content: `❌ Failed to ban ${user.tag}.`, ephemeral: true });
        }
    } else if (commandName === 'timeout') {
        const user = options.getUser('user');
        const duration = options.getInteger('duration');
        const member = interaction.guild.members.cache.get(user.id);

        if (!member) {
            return interaction.reply({ content: 'User not found!', ephemeral: true });
        }

        try {
            await member.timeout(duration * 1000);
            const embed = new EmbedBuilder()
                .setColor(0xffa500)
                .setTitle('✅ User Timed Out')
                .setDescription(`${user.tag} has been timed out for ${duration} seconds.`)
                .setTimestamp();

            interaction.reply({ embeds: [embed] });
        } catch (error) {
            interaction.reply({ content: `❌ Failed to timeout ${user.tag}.`, ephemeral: true });
        }
    } else if (commandName === 'clear') {
        const amount = options.getInteger('amount');

        if (amount < 1 || amount > 100) {
            return interaction.reply({ content: '❌ You can only delete between 1 and 100 messages.', ephemeral: true });
        }

        try {
            const messages = await interaction.channel.bulkDelete(amount, true);
            const embed = new EmbedBuilder()
                .setColor(0x00ff00)
                .setTitle('✅ Messages Cleared')
                .setDescription(`Successfully deleted ${messages.size} messages.`)
                .setTimestamp();

            interaction.reply({ embeds: [embed] });
        } catch (error) {
            interaction.reply({ content: `❌ Failed to delete messages.`, ephemeral: true });
        }
    } else if (commandName === 'level') {
        // Get user data
        const data = loadUserData();
        const userID = interaction.user.id;
        const user = data.users[userID];

        if (!user) {
            return interaction.reply({ content: 'You have not gained any XP yet!', ephemeral: true });
        }

        const embed = new EmbedBuilder()
            .setColor(0x00ff00)
            .setTitle(`${interaction.user.tag}'s Level`)
            .addFields(
                { name: 'Level', value: `${user.level}`, inline: true },
                { name: 'XP', value: `${user.xp}`, inline: true }
            )
            .setTimestamp();

        interaction.reply({ embeds: [embed] });
    } else if (commandName === 'leaderboard') {
        // Get all users and sort by XP
        const data = loadUserData();
        const users = Object.entries(data.users)
            .map(([id, { xp, level }]) => ({ id, xp, level }))
            .sort((a, b) => b.xp - a.xp); // Sort by XP in descending order

        const leaderboard = users.slice(0, 10); // Get top 10 users

        // Create leaderboard embed
        const embed = new EmbedBuilder()
            .setColor(0x00ff00)
            .setTitle('Top 10 Users by XP')
            .setTimestamp();

        leaderboard.forEach((user, index) => {
            const member = interaction.guild.members.cache.get(user.id);
            embed.addFields({
                name: `#${index + 1} ${member ? member.user.tag : 'Unknown'}`,
                value: `Level: ${user.level} | XP: ${user.xp}`,
                inline: false,
            });
        });

        interaction.reply({ embeds: [embed] });
    }
});

// Handle messages and XP
client.on('messageCreate', async (message) => {
    if (message.author.bot) return;

    // Load user data
    let data = loadUserData();
    const userID = message.author.id;
    let user = data.users[userID];

    // Initialize user if they don't exist in the data
    if (!user) {
        data.users[userID] = { xp: 0, level: 1 };
        user = data.users[userID];
    }

    // Calculate XP based on message length
    let xpGained = Math.floor(message.content.split(' ').length / 5) * 10; // 10 XP per 5 words

    user.xp += xpGained;

    // Check for level-up
    const levelRoles = roles.filter(role => role.level <= user.level);
    if (levelRoles.length > 0) {
        const latestRole = levelRoles[levelRoles.length - 1];

        // Assign role if not already assigned
        const member = message.guild.members.cache.get(userID);
        if (member && !member.roles.cache.some(role => role.name === latestRole.role)) {
            await member.roles.add(latestRole.role);
            // Check for additional role
            if (latestRole.additionalRole) {
                await member.roles.add(latestRole.additionalRole);
                message.reply(`🎊 Congratulations! You've reached level ${user.level}. An additional role ${latestRole.additionalRole} has been added to you.`);
            } else {
                message.reply(`🎊 Congratulations! You've reached level ${user.level} and gained the ${latestRole.role} role.`);
            }
        }
    }

    // Check if user has leveled up
    const nextLevel = Math.floor(user.xp / 100) + 1;
    if (user.level < nextLevel) {
        user.level = nextLevel;
    }

    // Save updated data Yippe!
    saveUserData(data);
});

client.login(process.env.TOKEN);