const { Events, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, ActionRowBuilder, MessageFlags, ChannelType, EmbedBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
const generalSupportCategory = '1406811264646385674'
const generalSupportRole = '1405746354868715562'

const purchaseCategory = '1406811515767619595'
const purchaseRole = '1405746354868715562'

const pmAppCategory = '1406811460767715389'
const pmAppRole = '1405746354868715562'

module.exports = {
    name: Events.InteractionCreate,
    async execute (interaction, client) {
        const { guild } = interaction;
        if (interaction.isButton()) {
            const customId = interaction.customId;

            if (customId === 'button') {
                const menu = new StringSelectMenuBuilder()
                    .setCustomId('ticket-select')
                    .setPlaceholder('Choose your needed ticket type.')
                    .addOptions(
                        new StringSelectMenuOptionBuilder()
                            .setLabel('General Support')
                            .setDescription('Used for general support or inquiries.')
                            .setValue('general-support'),
                        new StringSelectMenuOptionBuilder()
                            .setLabel('Purchase')
                            .setDescription('Used to purchase a item.')
                            .setValue('purchase'),
                        new StringSelectMenuOptionBuilder()
                            .setLabel('PM Application')
                            .setDescription('The Partner Manager application.')
                            .setValue('pm-application'),
                )

                const row = new ActionRowBuilder().addComponents(menu)
                await interaction.reply({
                    components: [row],
                    flags: MessageFlags.Ephemeral
                })
            }
        }
        if (interaction.isStringSelectMenu()) {
            const customId = interaction.customId;

            if (customId === 'ticket-select') {
                const selectedValue = interaction.values[0];

                switch (selectedValue) {
                    case 'general-support':
                        const existingTicketGeneralSupport = interaction.guild.channels.cache.find(channel => channel.name === `general-support-${interaction.user.username}`);
                        if (existingTicketGeneralSupport) {
                            return interaction.reply({ content: `You already have a ticket open.`, flags: MessageFlags.Ephemeral })
                        }

                        const generalSupportChannel = await interaction.guild.channels.create({
                            name: `general-support-${interaction.user.username}`,
                            parent: generalSupportCategory,
                            type: ChannelType.GuildText,
                            permsissionOverwrites: [
                                {
                                    id: interaction.guild.id,
                                    deny: ['ViewChannel']
                                },
                                {
                                    id: interaction.user.id,
                                    allow: ['ViewChannel']
                                },
                                {
                                    id: generalSupportRole,
                                    allow: ['ViewChannel']
                                },
                            ]
                        });

                        const generalSupportEmbed = new EmbedBuilder()
                            .setTitle('General Support Ticket')
                            .setDescription('Please the describe your inquirie/issue in as much detail as possible.')
                            .setColor('Aqua')

                        const generalSupportButton = new ButtonBuilder()
                            .setCustomId('general-support-close')
                            .setLabel('Close')
                            .setStyle(ButtonStyle.Secondary)
                            .setEmoji('🔒')

                        const generalSupportRow = new ActionRowBuilder().addComponents(generalSupportButton)
                        
                        await interaction.reply({
                            content: `Ticket created: ${generalSupportChannel}`,
                            flags: MessageFlags.Ephemeral
                        })
                        await generalSupportChannel.send({
                            embeds: [generalSupportEmbed],
                            components: [generalSupportRow],
                            content: `<@${interaction.user.id}> <@&${generalSupportRole}>`
                        })


                        break;
                    case 'purchase':
                        const existingTicketPurchase = interaction.guild.channels.cache.find(channel => channel.name === `purchase-${interaction.user.username}`);
                        if (existingTicketPurchase) {
                            return interaction.reply({ content: `You already have a ticket open.`, flags: MessageFlags.Ephemeral })
                        }

                        const purchaseChannel = await interaction.guild.channels.create({
                            name: `purchase-${interaction.user.username}`,
                            parent: purchaseCategory,
                            type: ChannelType.GuildText,
                            permsissionOverwrites: [
                                {
                                    id: interaction.guild.id,
                                    deny: ['ViewChannel']
                                },
                                {
                                    id: interaction.user.id,
                                    allow: ['ViewChannel']
                                },
                                {
                                    id: purchaseRole,
                                    allow: ['ViewChannel']
                                },
                            ]
                        });

                        const purchaseEmbed = new EmbedBuilder()
                            .setTitle('Purchase Ticket')
                            .setDescription('What would you like to purchase and what payment method would you like to use to pay for it?')
                            .setColor('Aqua')

                        const purchaseButton = new ButtonBuilder()
                            .setCustomId('purchase-close')
                            .setLabel('Close')
                            .setStyle(ButtonStyle.Secondary)
                            .setEmoji('🔒')

                        const purchaseRow = new ActionRowBuilder().addComponents(purchaseButton)
                        
                        await interaction.reply({
                            content: `Ticket created: ${purchaseChannel}`,
                            flags: MessageFlags.Ephemeral
                        })
                        await purchaseChannel.send({
                            embeds: [purchaseEmbed],
                            components: [purchaseRow],
                            content: `<@${interaction.user.id}> <@&${purchaseRole}>`
                        })
                        break;
                    case 'pm-application':
                        const existingTicketPmApp = interaction.guild.channels.cache.find(channel => channel.name === `partner-application-${interaction.user.username}`);
                        if (existingTicketPmApp) {
                            return interaction.reply({ content: `You already have a ticket open.`, flags: MessageFlags.Ephemeral })
                        }

                        const pmAppChannel = await interaction.guild.channels.create({
                            name: `partner-manager-application-${interaction.user.username}`,
                            parent: pmAppCategory,
                            type: ChannelType.GuildText,
                            permsissionOverwrites: [
                                {
                                    id: interaction.guild.id,
                                    deny: ['ViewChannel']
                                },
                                {
                                    id: interaction.user.id,
                                    allow: ['ViewChannel']
                                },
                                {
                                    id: pmAppRole,
                                    allow: ['ViewChannel']
                                },
                            ]
                        });

                        const pmAppEmbed = new EmbedBuilder()
                            .setTitle('Partner Manager Application Ticket')
                            .setDescription('Please fill this form.\n```Hours Per Day:\nPartners Per Week:\nTimezone:```')
                            .setColor('Aqua')

                        const pmAppButton = new ButtonBuilder()
                            .setCustomId('pm-app-close')
                            .setLabel('Close')
                            .setStyle(ButtonStyle.Secondary)
                            .setEmoji('🔒')

                        const pmAppRow = new ActionRowBuilder().addComponents(pmAppButton)
                        
                        await interaction.reply({
                            content: `Ticket created: ${pmAppChannel}`,
                            flags: MessageFlags.Ephemeral
                        })
                        await pmAppChannel.send({
                            embeds: [pmAppEmbed],
                            components: [pmAppRow],
                            content: `<@${interaction.user.id}> <@&${pmAppRole}>`
                        })
                        break;
                    default: 
                        await interaction.reply({ content: 'Invalid selection, please try again.', flags: MessageFlags.Ephemeral })
                }
            }}
        if (interaction.isButton()) {
            const generalSupportChannel = interaction.generalSupportChannel;
            const customId = interaction.customId;
            
            if (customId === 'general-support-close') {
                console.log(interaction.customId)
                const generalSupportCloseEmbed = new EmbedBuilder()
                    .setTitle('Ticket Closing')
                    .setDescription('This ticket will close in 5 seconds.')
                    .setColor('Red')
                
                await generalSupportChannel.send({
                    embeds: [generalSupportCloseEmbed]
                })
                await interaction.reply({
                    content: 'Ticket closing started.', flags: MessageFlags.Ephemeral
                })
                setTimeout(() => {
                    generalSupportChannel.delete()
                }, 5000);
            }
        }
        if (interaction.isButton()) {
            const purchaseChannel = interaction.purchaseChannel;
            const customId = interaction.customId;

            if (customId === 'purchase-close') {
                const purchaseCloseEmbed = new EmbedBuilder()
                    .setTitle('Ticket Closing')
                    .setDescription('This ticket will close in 5 seconds.')
                    .setColor('Red')
                
                await purchaseChannel.send({
                    embeds: [purchaseCloseEmbed]
                })
                await interaction.reply({
                    content: 'Ticket closing started.', flags: MessageFlags.Ephemeral
                })
                setTimeout(() => {
                    purchaseChannel.delete()
                }, 5000);
            }    
        }
        if (interaction.isButton()) {
            const pmAppChannel = interaction.pmAppChannel;
            const customId = interaction.customId;
        
            if (customId === 'pm-app-close') {
                const pmAppCloseEmbed = new EmbedBuilder()
                    .setTitle('Ticket Closing')
                    .setDescription('This ticket will close in 5 seconds.')
                    .setColor('Red')
                
                await pmAppChannel.send({
                    embeds: [pmAppCloseEmbed]
                })
                await interaction.reply({
                    content: 'Ticket closing started.', flags: MessageFlags.Ephemeral
                })
                setTimeout(() => {
                    pmAppChannel.delete()
                }, 5000);
        }
    }
}}