bot.js

const { Client, GatewayIntentBits, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, PermissionFlagsBits } = require('discord.js');
require('dotenv').config();

const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.GuildMessageReactions,
        GatewayIntentBits.DirectMessages,
        GatewayIntentBits.MessageContent
    ]
});

// Store active Secret Santa sessions
// Structure: { channelId: { organizer: userId, participants: Set, assignments: Map, messageId: string, receivedGifts: Set } }
const secretSantaSessions = new Map();

client.once('ready', () => {
    console.log(`✅ Logged in as ${client.user.tag}`);
    console.log(`Bot is ready and listening for commands!`);
});

// Helper function to shuffle array
function shuffleArray(array) {
    const shuffled = [...array];
    for (let i = shuffled.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
    }
    return shuffled;
}

// Helper function to create assignments (circular)
function createAssignments(participants) {
    const shuffled = shuffleArray(participants);
    const assignments = new Map();
    
    for (let i = 0; i < shuffled.length; i++) {
        const giver = shuffled[i];
        const receiver = shuffled[(i + 1) % shuffled.length];
        assignments.set(giver, receiver);
    }
    
    return assignments;
}

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

    // /secretsanta command
    if (message.content.toLowerCase() === '/secretsanta') {
        const channelId = message.channel.id;
        
        // Check if there's already an active session
        if (secretSantaSessions.has(channelId)) {
            return message.reply('⚠️ There is already an active Secret Santa in this channel! Use `/assign` to close signups or wait for it to complete.');
        }

        // Create embed message
        const embed = new EmbedBuilder()
            .setColor('#FF0000')
            .setTitle('🎅 Secret Santa Sign-Up! 🎄')
            .setDescription('React with 🎁 to join the Secret Santa!\n\n**How it works:**\n• React to this message to participate\n• The organizer will use `/assign` to close signups and assign Secret Santas\n• You\'ll receive a DM with your assignment\n• Use `/ordered` when you order your gift\n• Use `/delivered` when your gift is delivered')
            .addFields(
                { name: 'Organizer', value: `<@${message.author.id}>`, inline: true },
                { name: 'Participants', value: '0', inline: true }
            )
            .setFooter({ text: 'React with 🎁 to join!' })
            .setTimestamp();

        const sentMessage = await message.channel.send({ embeds: [embed] });
        await sentMessage.react('🎁');

        // Initialize session
        secretSantaSessions.set(channelId, {
            organizer: message.author.id,
            participants: new Set(),
            assignments: new Map(),
            receivedGifts: new Set(),
            messageId: sentMessage.id,
            guildId: message.guild.id
        });

        console.log(`Secret Santa started in channel ${channelId} by ${message.author.tag}`);
    }

    // /assign command
    if (message.content.toLowerCase() === '/assign') {
        const channelId = message.channel.id;
        const session = secretSantaSessions.get(channelId);

        if (!session) {
            return message.reply('⚠️ There is no active Secret Santa in this channel. Start one with `/secretsanta`');
        }

        if (session.organizer !== message.author.id) {
            return message.reply('⚠️ Only the organizer can assign Secret Santas!');
        }

        if (session.participants.size < 2) {
            return message.reply('⚠️ Need at least 2 participants to assign Secret Santas!');
        }

        // Create assignments
        const participantArray = Array.from(session.participants);
        session.assignments = createAssignments(participantArray);

        // Send announcement in channel
        const participantMentions = participantArray.map(id => `<@${id}>`).join(', ');
        const announceEmbed = new EmbedBuilder()
            .setColor('#00FF00')
            .setTitle('🎁 Secret Santa Assignments Complete!')
            .setDescription(`**Participants:** ${participantMentions}\n\nCheck your DMs for your Secret Santa assignment! 🎅`)
            .setTimestamp();

        await message.channel.send({ embeds: [announceEmbed] });

        // Send DMs to each participant
        let successCount = 0;
        let failCount = 0;
        const failedUsers = [];

        for (const [giverId, receiverId] of session.assignments.entries()) {
            try {
                const giver = await client.users.fetch(giverId);
                const receiver = await client.users.fetch(receiverId);
                const channel = await client.channels.fetch(channelId);
                const guild = await client.guilds.fetch(session.guildId);

                const dmEmbed = new EmbedBuilder()
                    .setColor('#FF0000')
                    .setTitle('🎅 Your Secret Santa Assignment!')
                    .setDescription(`**Server:** ${guild.name}\n**Channel:** #${channel.name}\n\nYou are the Secret Santa for: **${receiver.username}**`)
                    .addFields(
                        { name: '📝 What to do:', value: '• Get them a gift!\n• Use `/ordered` when you order the gift (in channel or DM me)\n• Use `/delivered` when the gift is delivered (in channel or DM me)\n• They can use `/received` to confirm receipt!' }
                    )
                    .setFooter({ text: 'Keep it secret! 🤫' })
                    .setTimestamp();

                await giver.send({ embeds: [dmEmbed] });
                successCount++;
                console.log(`✅ Sent assignment to ${giver.tag}: ${receiver.tag}`);
            } catch (error) {
                console.error(`❌ Failed to DM user ${giverId}:`, error.message);
                failCount++;
                failedUsers.push(giverId);
            }
        }

        // Report results
        let resultMessage = `✅ Sent ${successCount} assignment(s)!`;
        
        if (failCount > 0) {
            const failedMentions = failedUsers.map(id => `<@${id}>`).join(', ');
            resultMessage += `\n\n⚠️ **${failCount} user(s) failed to receive DMs:**\n${failedMentions}\n\n**Please enable DMs from server members in your Privacy Settings!**`;
        }

        await message.channel.send(resultMessage);
        console.log(`Assignments completed for channel ${channelId}`);
    }

    // /finish command
    if (message.content.toLowerCase() === '/finish') {
        const channelId = message.channel.id;
        const session = secretSantaSessions.get(channelId);

        if (!session) {
            return message.reply('⚠️ There is no active Secret Santa in this channel.');
        }

        if (session.organizer !== message.author.id) {
            return message.reply('⚠️ Only the organizer can finish the Secret Santa!');
        }

        // Remove the session
        secretSantaSessions.delete(channelId);

        const finishEmbed = new EmbedBuilder()
            .setColor('#00FF00')
            .setTitle('🎄 Secret Santa Finished!')
            .setDescription('The Secret Santa has been closed. Happy holidays! 🎅')
            .setFooter({ text: 'Start a new one anytime with /secretsanta' })
            .setTimestamp();

        await message.channel.send({ embeds: [finishEmbed] });
        console.log(`Secret Santa finished in channel ${channelId} by ${message.author.tag}`);
    }

    // /santastatus command
    if (message.content.toLowerCase() === '/santastatus') {
        const channelId = message.channel.id;
        const session = secretSantaSessions.get(channelId);

        if (!session) {
            return message.reply('⚠️ There is no active Secret Santa in this channel.');
        }

        const totalParticipants = session.assignments.size; // Use assignments size, not participants
        const assignmentsComplete = session.assignments.size > 0;
        const receivedCount = session.receivedGifts.size;
        const progressPercent = totalParticipants > 0 ? Math.round((receivedCount / totalParticipants) * 100) : 0;

        // Create progress bar
        const barLength = 10;
        const filledBars = Math.round((receivedCount / totalParticipants) * barLength);
        const progressBar = '🟩'.repeat(filledBars) + '⬜'.repeat(barLength - filledBars);

        const statusEmbed = new EmbedBuilder()
            .setColor('#3498DB')
            .setTitle('📊 Secret Santa Status')
            .addFields(
                { name: '👥 Total Participants', value: `${totalParticipants}`, inline: true },
                { name: '✅ Assignments Sent', value: assignmentsComplete ? 'Yes' : 'No', inline: true },
                { name: '🎁 Gifts Received', value: `${receivedCount}/${totalParticipants}`, inline: true },
                { name: '📈 Progress', value: `${progressBar}\n${progressPercent}% complete` }
            )
            .setFooter({ text: `Organizer: ${message.guild.members.cache.get(session.organizer)?.user.username || 'Unknown'}` })
            .setTimestamp();

        await message.channel.send({ embeds: [statusEmbed] });
    }

    // /participants command
    if (message.content.toLowerCase() === '/participants') {
        const channelId = message.channel.id;
        const session = secretSantaSessions.get(channelId);

        if (!session) {
            return message.reply('⚠️ There is no active Secret Santa in this channel.');
        }

        // Get the list of participants
        let participantList;
        if (session.assignments.size > 0) {
            // If assignments have been made, use those participants (frozen list)
            const participantIds = Array.from(session.assignments.keys());
            const participants = await Promise.all(
                participantIds.map(async (id) => {
                    try {
                        const user = await client.users.fetch(id);
                        return user.username;
                    } catch (error) {
                        return `Unknown User (${id})`;
                    }
                })
            );
            participantList = participants.map((name, index) => `${index + 1}. ${name}`).join('\n');
        } else {
            // If no assignments yet, show current sign-ups
            const participantIds = Array.from(session.participants);
            if (participantIds.length === 0) {
                participantList = 'No participants yet';
            } else {
                const participants = await Promise.all(
                    participantIds.map(async (id) => {
                        try {
                            const user = await client.users.fetch(id);
                            return user.username;
                        } catch (error) {
                            return `Unknown User (${id})`;
                        }
                    })
                );
                participantList = participants.map((name, index) => `${index + 1}. ${name}`).join('\n');
            }
        }

        const participantsEmbed = new EmbedBuilder()
            .setColor('#E74C3C')
            .setTitle('🎅 Secret Santa Participants')
            .setDescription(participantList)
            .addFields(
                { name: 'Status', value: session.assignments.size > 0 ? '✅ Assignments sent' : '⏳ Waiting for assignments' }
            )
            .setTimestamp();

        await message.channel.send({ embeds: [participantsEmbed] });
    }

    // /ordered command - can be used in DM or channel
    if (message.content.toLowerCase().startsWith('/ordered')) {
        const userId = message.author.id;
        
        // If in DM, find the user's Secret Santa session(s)
        if (message.channel.type === 1) { // DM channel
            const userSessions = [];
            
            // Find all sessions where this user is a participant with assignments
            for (const [channelId, session] of secretSantaSessions.entries()) {
                if (session.assignments.has(userId)) {
                    userSessions.push({ channelId, session });
                }
            }
            
            if (userSessions.length === 0) {
                return message.reply('⚠️ You are not participating in any active Secret Santa with assignments.');
            }
            
            if (userSessions.length === 1) {
                // Auto-infer the session
                const { session } = userSessions[0];
                await sendOrderedNotification(message, session, userId);
            } else {
                // Multiple sessions - ask user to specify
                const sessionList = await Promise.all(userSessions.map(async ({ channelId, session }, index) => {
                    try {
                        const channel = await client.channels.fetch(channelId);
                        const guild = await client.guilds.fetch(session.guildId);
                        return `${index + 1}. **${guild.name}** - #${channel.name}`;
                    } catch (error) {
                        return `${index + 1}. Channel ID: ${channelId}`;
                    }
                }));
                
                const listEmbed = new EmbedBuilder()
                    .setColor('#FFA500')
                    .setTitle('🎁 Multiple Secret Santas Found')
                    .setDescription('You are participating in multiple Secret Santas. Please specify which one:\n\n' + sessionList.join('\n') + '\n\nUse: `/ordered <number>`')
                    .setTimestamp();
                
                return message.reply({ embeds: [listEmbed] });
            }
        } else {
            // In channel - use that channel's session
            const channelId = message.channel.id;
            const session = secretSantaSessions.get(channelId);

            if (!session || session.assignments.size === 0) {
                return message.reply('⚠️ There is no active Secret Santa with assignments in this channel.');
            }

            if (!session.assignments.has(userId)) {
                return message.reply('⚠️ You are not participating in this Secret Santa!');
            }

            // Delete the command message for privacy
            try {
                await message.delete();
            } catch (error) {
                console.log('Could not delete message');
            }

            await sendOrderedNotification(message, session, userId);
        }
    }

    // /delivered command - can be used in DM or channel
    if (message.content.toLowerCase().startsWith('/delivered')) {
        const userId = message.author.id;
        
        // If in DM, find the user's Secret Santa session(s)
        if (message.channel.type === 1) { // DM channel
            const userSessions = [];
            
            // Find all sessions where this user is a participant with assignments
            for (const [channelId, session] of secretSantaSessions.entries()) {
                if (session.assignments.has(userId)) {
                    userSessions.push({ channelId, session });
                }
            }
            
            if (userSessions.length === 0) {
                return message.reply('⚠️ You are not participating in any active Secret Santa with assignments.');
            }
            
            if (userSessions.length === 1) {
                // Auto-infer the session
                const { session } = userSessions[0];
                await sendDeliveredNotification(message, session, userId);
            } else {
                // Multiple sessions - ask user to specify
                const sessionList = await Promise.all(userSessions.map(async ({ channelId, session }, index) => {
                    try {
                        const channel = await client.channels.fetch(channelId);
                        const guild = await client.guilds.fetch(session.guildId);
                        return `${index + 1}. **${guild.name}** - #${channel.name}`;
                    } catch (error) {
                        return `${index + 1}. Channel ID: ${channelId}`;
                    }
                }));
                
                const listEmbed = new EmbedBuilder()
                    .setColor('#00FF00')
                    .setTitle('🎁 Multiple Secret Santas Found')
                    .setDescription('You are participating in multiple Secret Santas. Please specify which one:\n\n' + sessionList.join('\n') + '\n\nUse: `/delivered <number>`')
                    .setTimestamp();
                
                return message.reply({ embeds: [listEmbed] });
            }
        } else {
            // In channel - use that channel's session
            const channelId = message.channel.id;
            const session = secretSantaSessions.get(channelId);

            if (!session || session.assignments.size === 0) {
                return message.reply('⚠️ There is no active Secret Santa with assignments in this channel.');
            }

            if (!session.assignments.has(userId)) {
                return message.reply('⚠️ You are not participating in this Secret Santa!');
            }

            // Delete the command message for privacy
            try {
                await message.delete();
            } catch (error) {
                console.log('Could not delete message');
            }

            await sendDeliveredNotification(message, session, userId);
        }
    }

    // /received command - can be used in DM or channel
    if (message.content.toLowerCase().startsWith('/received')) {
        const userId = message.author.id;
        
        // If in DM, find the user's Secret Santa session(s)
        if (message.channel.type === 1) { // DM channel
            const userSessions = [];
            
            // Find all sessions where this user is a participant (as a receiver in assignments)
            for (const [channelId, session] of secretSantaSessions.entries()) {
                // Check if user is either a giver or receiver in assignments
                const isParticipant = session.assignments.has(userId) || 
                                     Array.from(session.assignments.values()).includes(userId);
                if (isParticipant && session.assignments.size > 0) {
                    userSessions.push({ channelId, session });
                }
            }
            
            if (userSessions.length === 0) {
                return message.reply('⚠️ You are not participating in any active Secret Santa with assignments.');
            }
            
            if (userSessions.length === 1) {
                // Auto-infer the session
                const { session } = userSessions[0];
                await sendReceivedNotification(message, session, userId);
            } else {
                // Multiple sessions - ask user to specify
                const sessionList = await Promise.all(userSessions.map(async ({ channelId, session }, index) => {
                    try {
                        const channel = await client.channels.fetch(channelId);
                        const guild = await client.guilds.fetch(session.guildId);
                        return `${index + 1}. **${guild.name}** - #${channel.name}`;
                    } catch (error) {
                        return `${index + 1}. Channel ID: ${channelId}`;
                    }
                }));
                
                const listEmbed = new EmbedBuilder()
                    .setColor('#9B59B6')
                    .setTitle('🎁 Multiple Secret Santas Found')
                    .setDescription('You are participating in multiple Secret Santas. Please specify which one:\n\n' + sessionList.join('\n') + '\n\nUse: `/received <number>`')
                    .setTimestamp();
                
                return message.reply({ embeds: [listEmbed] });
            }
        } else {
            // In channel - use that channel's session
            const channelId = message.channel.id;
            const session = secretSantaSessions.get(channelId);

            if (!session || session.assignments.size === 0) {
                return message.reply('⚠️ There is no active Secret Santa with assignments in this channel.');
            }

            // Check if user is in the assignments (either as giver or receiver)
            const isParticipant = session.assignments.has(userId) || 
                                 Array.from(session.assignments.values()).includes(userId);
            
            if (!isParticipant) {
                return message.reply('⚠️ You are not participating in this Secret Santa!');
            }

            // Delete the command message for privacy
            try {
                await message.delete();
            } catch (error) {
                console.log('Could not delete message');
            }

            await sendReceivedNotification(message, session, userId);
        }
    }
});

// Helper function to send ordered notification
async function sendOrderedNotification(message, session, userId) {
    const receiverId = session.assignments.get(userId);

    if (!receiverId) {
        return message.reply('⚠️ Could not find your assignment. Please contact the organizer.');
    }

    try {
        const receiver = await client.users.fetch(receiverId);

        // Send anonymous notification to receiver
        const notifyEmbed = new EmbedBuilder()
            .setColor('#FFA500')
            .setTitle('🎁 Gift Update!')
            .setDescription('Good news! Your Secret Santa has ordered your gift! 🛍️')
            .setFooter({ text: 'Stay tuned for delivery!' })
            .setTimestamp();

        await receiver.send({ embeds: [notifyEmbed] });

        // Confirm to sender
        const confirmEmbed = new EmbedBuilder()
            .setColor('#00FF00')
            .setTitle('✅ Notification Sent!')
            .setDescription(`Your recipient has been notified that their gift has been ordered!`)
            .setTimestamp();

        await message.reply({ embeds: [confirmEmbed] });

        console.log(`${message.author.tag} marked gift as ordered for ${receiver.tag}`);
    } catch (error) {
        console.error('Error sending ordered notification:', error);
        await message.reply('⚠️ Could not send notification. Please try again.');
    }
}

// Helper function to send delivered notification
async function sendDeliveredNotification(message, session, userId) {
    const receiverId = session.assignments.get(userId);

    if (!receiverId) {
        return message.reply('⚠️ Could not find your assignment. Please contact the organizer.');
    }

    try {
        const receiver = await client.users.fetch(receiverId);

        // Send anonymous notification to receiver
        const notifyEmbed = new EmbedBuilder()
            .setColor('#00FF00')
            .setTitle('🎁 Gift Delivered!')
            .setDescription('Your Secret Santa gift has been delivered! 🎉\n\nCheck your mailbox or doorstep! 📦')
            .setFooter({ text: 'Happy Holidays!' })
            .setTimestamp();

        await receiver.send({ embeds: [notifyEmbed] });

        // Confirm to sender
        const confirmEmbed = new EmbedBuilder()
            .setColor('#00FF00')
            .setTitle('✅ Notification Sent!')
            .setDescription(`Your recipient has been notified that their gift has been delivered!`)
            .setTimestamp();

        await message.reply({ embeds: [confirmEmbed] });

        console.log(`${message.author.tag} marked gift as delivered for ${receiver.tag}`);
    } catch (error) {
        console.error('Error sending delivered notification:', error);
        await message.reply('⚠️ Could not send notification. Please try again.');
    }
}

// Helper function to send received notification
async function sendReceivedNotification(message, session, userId) {
    // Check if already marked as received
    if (session.receivedGifts.has(userId)) {
        return message.reply('⚠️ You have already confirmed receipt of your gift!');
    }

    // Find who gave this user a gift (reverse lookup)
    let giverId = null;
    for (const [gId, rId] of session.assignments.entries()) {
        if (rId === userId) {
            giverId = gId;
            break;
        }
    }

    if (!giverId) {
        return message.reply('⚠️ Could not find your Secret Santa. Please contact the organizer.');
    }

    try {
        const giver = await client.users.fetch(giverId);

        // Mark as received
        session.receivedGifts.add(userId);

        // Calculate progress using frozen assignments count
        const totalParticipants = session.assignments.size;
        const receivedCount = session.receivedGifts.size;
        const progressPercent = Math.round((receivedCount / totalParticipants) * 100);

        // Send notification to giver
        const notifyEmbed = new EmbedBuilder()
            .setColor('#9B59B6')
            .setTitle('🎉 Gift Received!')
            .setDescription('Great news! Your Secret Santa recipient has confirmed they received their gift! 🎁\n\nThank you for participating! 🎅')
            .addFields(
                { name: '📊 Overall Progress', value: `${receivedCount}/${totalParticipants} participants received their gifts (${progressPercent}%)` }
            )
            .setFooter({ text: 'Mission accomplished!' })
            .setTimestamp();

        await giver.send({ embeds: [notifyEmbed] });

        // Confirm to receiver
        const confirmEmbed = new EmbedBuilder()
            .setColor('#00FF00')
            .setTitle('✅ Notification Sent!')
            .setDescription(`Your Secret Santa has been notified that you received your gift!\n\n**Progress:** ${receivedCount}/${totalParticipants} gifts received (${progressPercent}%)`)
            .setTimestamp();

        await message.reply({ embeds: [confirmEmbed] });

        console.log(`${message.author.tag} confirmed receipt, notified ${giver.tag} (Progress: ${receivedCount}/${totalParticipants})`);

        // If all gifts received, send celebration message
        if (receivedCount === totalParticipants) {
            // Find the channel
            for (const [channelId, sess] of secretSantaSessions.entries()) {
                if (sess === session) {
                    try {
                        const channel = await client.channels.fetch(channelId);
                        const celebrationEmbed = new EmbedBuilder()
                            .setColor('#FFD700')
                            .setTitle('🎄 Secret Santa Complete! 🎄')
                            .setDescription('🎉 **All participants have received their gifts!** 🎉\n\nThank you everyone for participating! Happy holidays! 🎅🎁')
                            .setFooter({ text: 'Use /finish to close this Secret Santa' })
                            .setTimestamp();
                        
                        await channel.send({ embeds: [celebrationEmbed] });
                    } catch (error) {
                        console.error('Could not send celebration message:', error);
                    }
                    break;
                }
            }
        }
    } catch (error) {
        console.error('Error sending received notification:', error);
        await message.reply('⚠️ Could not send notification. Please try again.');
    }
}

// Handle reactions for sign-up
client.on('messageReactionAdd', async (reaction, user) => {
    // Ignore bot reactions
    if (user.bot) return;

    // Handle partial reactions
    if (reaction.partial) {
        try {
            await reaction.fetch();
        } catch (error) {
            console.error('Error fetching reaction:', error);
            return;
        }
    }

    const channelId = reaction.message.channel.id;
    const session = secretSantaSessions.get(channelId);

    // Check if this is a Secret Santa sign-up message
    if (!session || session.messageId !== reaction.message.id) return;
    if (reaction.emoji.name !== '🎁') return;

    // Add participant
    session.participants.add(user.id);

    // Update the embed
    try {
        const message = await reaction.message.fetch();
        const embed = message.embeds[0];
        
        const updatedEmbed = EmbedBuilder.from(embed)
            .setFields(
                { name: 'Organizer', value: `<@${session.organizer}>`, inline: true },
                { name: 'Participants', value: `${session.participants.size}`, inline: true }
            );

        await message.edit({ embeds: [updatedEmbed] });
        console.log(`${user.tag} joined Secret Santa in channel ${channelId}`);
    } catch (error) {
        console.error('Error updating embed:', error);
    }
});

// Handle reaction removal
client.on('messageReactionRemove', async (reaction, user) => {
    if (user.bot) return;

    if (reaction.partial) {
        try {
            await reaction.fetch();
        } catch (error) {
            console.error('Error fetching reaction:', error);
            return;
        }
    }

    const channelId = reaction.message.channel.id;
    const session = secretSantaSessions.get(channelId);

    if (!session || session.messageId !== reaction.message.id) return;
    if (reaction.emoji.name !== '🎁') return;

    // Remove participant
    session.participants.delete(user.id);

    // Update the embed
    try {
        const message = await reaction.message.fetch();
        const embed = message.embeds[0];
        
        const updatedEmbed = EmbedBuilder.from(embed)
            .setFields(
                { name: 'Organizer', value: `<@${session.organizer}>`, inline: true },
                { name: 'Participants', value: `${session.participants.size}`, inline: true }
            );

        await message.edit({ embeds: [updatedEmbed] });
        console.log(`${user.tag} left Secret Santa in channel ${channelId}`);
    } catch (error) {
        console.error('Error updating embed:', error);
    }
});

// Login
client.login(process.env.DISCORD_BOT_TOKEN);