const { SlashCommandBuilder, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
const ShopItem = require('../models/ShopItems');
const User = require('../models/User');

module.exports = {
    data: new SlashCommandBuilder()
        .setName('shop')
        .setDescription('Acheter des items dans la boutique'),
    async execute(interaction) {
        await interaction.deferReply({ ephemeral: true });

        const shopItems = await ShopItem.find();
        const user = await User.findOne({ discordId: interaction.user.id }).populate({
            path: 'activeCharacter',
        });

        if (!user || !user.activeCharacter) {
            return interaction.editReply({ content: 'Vous n\'avez pas de personnage actif !', ephemeral: true });
        }

        const character = user.activeCharacter;
        const { gallions, mornilles } = character.getCurrency();

        const itemsPerPage = 6;
        const pages = [];
        const allButtons = [];

        for (let i = 0; i < shopItems.length; i += itemsPerPage) {
            const currentPageItems = shopItems.slice(i, i + itemsPerPage);

            const shopEmbed = new EmbedBuilder()
                .setTitle('Items de la Boutique')
                .setDescription('Sélectionnez un item à acheter')
                .setColor(0x00FF00)
                .setFooter({ text: `Vous possédez actuellement : ${gallions} Gallions et ${mornilles} Mornilles` });

            currentPageItems.forEach(item => {
                const priceText = `${item.price.gallions} Gallions et ${item.price.mornilles} Mornilles`;
                shopEmbed.addFields({ name: `${item.emoji} ${item.name}`, value: `Prix: ${priceText}`, inline: true });

                const button = new ButtonBuilder()
                    .setCustomId(`buy_${item.name}`)
                    .setLabel(`Acheter ${item.name}`)
                    .setStyle(ButtonStyle.Primary);
                allButtons.push(button);
            });

            pages.push(shopEmbed);
        }

        let currentPage = 0;

        const createNavigationRow = (currentPage) => {
            const prevButton = new ButtonBuilder()
                .setCustomId('prev')
                .setLabel('Précédent')
                .setStyle(ButtonStyle.Primary)
                .setEmoji('⬅️')
                .setDisabled(currentPage === 0);

            const nextButton = new ButtonBuilder()
                .setCustomId('next')
                .setLabel('Suivant')
                .setStyle(ButtonStyle.Primary)
                .setEmoji('➡️')
                .setDisabled(currentPage === pages.length - 1);

            return new ActionRowBuilder().addComponents(prevButton, nextButton);
        };

        const createPageComponents = (currentPage) => {
            const start = currentPage * itemsPerPage;
            const end = start + itemsPerPage;
            const buttons = allButtons.slice(start, end);

            const rows = [];
            for (let j = 0; j < buttons.length; j += 3) {
                rows.push(new ActionRowBuilder().addComponents(buttons.slice(j, j + 3)));
            }
            rows.push(createNavigationRow(currentPage));
            return rows;
        };

        const updatePage = async (pageIndex) => {
            currentPage = pageIndex;
            const embed = pages[currentPage];
            const components = createPageComponents(currentPage);
            await interaction.editReply({ embeds: [embed], components, ephemeral: true });
        };

        await updatePage(currentPage);

        const filter = i => ['prev', 'next'].includes(i.customId) && i.user.id === interaction.user.id;
        const collector = interaction.channel.createMessageComponentCollector({ filter, time: 60000 });

        collector.on('collect', async i => {
            if (i.customId === 'next') {
                currentPage++;
            } else if (i.customId === 'prev') {
                currentPage--;
            }

            await updatePage(currentPage);
        });

        collector.on('end', () => {
            interaction.editReply({ components: [], ephemeral: true });
        });

        const buttonFilter = i => i.customId.startsWith('buy_') && i.user.id === interaction.user.id;
        const buttonCollector = interaction.channel.createMessageComponentCollector({ filter: buttonFilter, time: 60000 });

        buttonCollector.on('collect', async i => {
            const itemName = i.customId.split('_')[1];
            const item = shopItems.find(item => item.name === itemName);

            if (!item) return;

            const user = await User.findOne({ discordId: i.user.id }).populate({
                path: 'activeCharacter'
            });

            const character = user.activeCharacter;
            const { gallions, mornilles } = character.getCurrency();
            const totalMornilles = (gallions * 50) + mornilles;
            const itemCostInMornilles = (item.price.gallions * 50) + item.price.mornilles;

            if (totalMornilles < itemCostInMornilles) {
                await i.reply({ content: `Vous n'avez pas assez de Gallions et de Mornilles pour acheter ${itemName}.`, ephemeral: true });
                return;
            }

            await character.removeCurrency(item.price.gallions, item.price.mornilles);
            await character.addItem(item.name, 1);

            await i.reply({ content: `Vous avez acheté un(e) ${itemName} !`, ephemeral: true });

            const logChannelId = '1138125400661303387';
            const logChannel = await interaction.client.channels.fetch(logChannelId);
            await logChannel.send(`${interaction.user.username} a acheté un(e) ${itemName}.`);
        });

        buttonCollector.on('end', collected => {
            if (collected.size === 0) {
                interaction.editReply({ content: 'La boutique est fermée en raison de l\'inactivité.', components: [], ephemeral: true });
            }
        });
    },
};