const {
	Events,
	ButtonInteraction,
	ModalBuilder,
	TextInputBuilder,
	TextInputStyle,
	ActionRowBuilder,
	EmbedBuilder,
	Client,
	PermissionFlagsBits,
	ChannelType,
} = require('discord.js');

const {
	No_Co_Owner_Without_Badge,
} = require('../../Functions/Channel-Create/Progression-Category/No-Co-Owner-Without-Badge');
const {
	No_Co_Owner_With_Badge,
} = require('../../Functions/Channel-Create/Progression-Category/No-Co-Owner-With-Badge');

const {
	Co_Owner_Without_Badge,
} = require('../../Functions/Channel-Create/Progression-Category/Co-Owner-Without-Badge');
const {
	Co_Owner_With_Badge,
} = require('../../Functions/Channel-Create/Progression-Category/Co-Owner-With-Badge');

//Day Category Functions.
const {
	Co_Owner_With_Badge_Day,
} = require('../../Functions/Channel-Create/Day-Category/Co-Owner-With-Badge-Day');
const {
	Co_Owner_Without_Badge_Day,
} = require('../../Functions/Channel-Create/Day-Category/Co-Owner-Without-Badge-Day');
const {
	No_Co_Owner_With_Badge_Day,
} = require('../../Functions/Channel-Create/Day-Category/No-Co-Owner-With-Badge-Day');
const {
	No_Co_Owner_Without_Badge_Day,
} = require('../../Functions/Channel-Create/Day-Category/No-Co-Owner-Without-Badge-Day');
module.exports = {
	name: Events.InteractionCreate,
	/**
	 *
	 * @param {ButtonInteraction} interaction
	 * @param {Client} client
	 * @returns
	 */
	async execute(interaction, client) {
		if (!interaction.isButton()) return;

		if (
			!['ch-verification-confirm', 'ch-verification-decline'].includes(
				interaction.customId
			)
		)
			return;

		const Embed = interaction.message.embeds[0];
		const Fields = Embed.fields;
		const State = Fields.find((Field) => Field.name === 'Confirmed');

		//Create Channel Data
		const coOwnerData = Fields.find((Field) => Field.name === 'Co Owner');
		const dayCategory = Fields.find((Field) => Field.name === 'Day Category');
		const dayCategoryName = dayCategory.value.split('/')[0];
		const dayCategoryID = dayCategory.value.split('/')[1];
		const shortDay = Fields.find((Field) => Field.name === 'Short Day').value;
		const raidType = Fields.find((Field) => Field.name === 'Raid Type').value;
		const Time = Fields.find((Field) => Field.name === 'Time').value;
		const Period = Fields.find((Field) => Field.name === 'Period').value;

		const dayRole = Fields.find((Field) => Field.name === 'Day Role').value;
		const dayRoleId = dayRole.substring(2, dayRole.length - 1);
		let raidDay;

		const Days = [
			'Tuesday',
			'Wednesday',
			'Thursday',
			'Friday',
			'Saturday',
			'Sunday',
			'Monday',
		];
		for (let i = 0; i < Days.length; i++) {
			if (Days[i].startsWith(`${shortDay}`)) {
				raidDay = Days[i];
			}
		}

		const progRole = interaction.guild.roles.cache.find(
			(role) => role.name === `Progression ` + raidDay
		);
		const raids = Fields.find((Field) => Field.name === 'Raid').value;
		const User = Fields.find((Field) => Field.name === 'User');
		const UserID = User.value.substring(2, User.value.length - 1);
		const Memb = interaction.guild.members.cache.find(
			(Mem) => Mem.id === `${UserID}`
		);
		let Emoji;
		const emojiRegex = /\p{Emoji}/u;
		if (emojiRegex.test(Memb.nickname.split(/.*?/u)[0]) === true) {
			const OrganizerEmoji = Memb.nickname.split(/.*?/u)[0];
			Emoji = interaction.guild.roles.cache.find(
				(role) =>
					role.name.includes('Badge') && role.name.includes(`${OrganizerEmoji}`)
			);
		}

		const errorEmbed = new EmbedBuilder()
			.setTitle('❌An Error Occurred')
			.setColor('Red');
		const successfulEmbed = new EmbedBuilder()
			.setTitle('✅Successfully Done')
			.setColor('Green');
		//Create Channel Data Finish
		const embedReply = new EmbedBuilder();
		console.log(interaction.customId);
		if (interaction.customId === 'ch-verification-decline') {
			if (State.value === '✅') {
				if (interaction.isRepliable()) {
					embedReply.setColor('DarkGreen');
					embedReply.setDescription(
						"-- This Channel Has Already Been Confirmed , You Can't Decline It Now"
					);
					if (!interaction.replied && !interaction.deferred) {
						return interaction.reply({ embeds: [embedReply], ephemeral: true });
					}

					if (interaction.deferred) {
						return interaction.editReply({ embeds: [embedReply] });
					}

					// replied && !deferred
					return interaction.followUp({
						embeds: [embedReply],
						ephemeral: true,
					});
				}
			} else if (State.value === '❌') {
				if (interaction.isRepliable()) {
					const embedReply = new EmbedBuilder();
					embedReply.setColor('DarkRed');
					embedReply.setDescription(
						"-- This Channel Has Already Been Declined , You Can't Decline It Again"
					);
					if (!interaction.replied && !interaction.deferred) {
						return interaction.reply({ embeds: [embedReply], ephemeral: true });
					}

					if (interaction.deferred) {
						return interaction.editReply({ embeds: [embedReply] });
					}

					// replied && !deferred
					return interaction.followUp({
						embeds: [embedReply],
						ephemeral: true,
					});
				}
			} else {
				const modal = new ModalBuilder()
					.setCustomId('decline')
					.setTitle('❌Decline Form');

				const declineReason = new TextInputBuilder()
					.setCustomId('decline-reason')
					.setLabel('Decline Reason')
					.setPlaceholder(
						'Provide The Reason Why You Declining The Request ( Org Will Be Notified ).'
					)
					.setRequired(true)
					.setStyle(TextInputStyle.Paragraph)
					.setMinLength(1);

				const First = new ActionRowBuilder().addComponents(declineReason);

				modal.addComponents(First);
				await interaction.showModal(modal);
			}
		} else if (interaction.customId === 'ch-verification-confirm') {
			if (State.value === '✅') {
				if (interaction.isRepliable()) {
					embedReply.setColor('DarkGreen');
					embedReply.setDescription(
						"-- This Channel Has Already Been Confirmed , You Can't Confirm It Again"
					);
					if (!interaction.replied && !interaction.deferred) {
						return interaction.reply({ embeds: [embedReply], ephemeral: true });
					}

					if (interaction.deferred) {
						return interaction.editReply({ embeds: [embedReply] });
					}

					// replied && !deferred
					return interaction.followUp({
						embeds: [embedReply],
						ephemeral: true,
					});
				}
			} else if (State.value === '❌') {
				if (interaction.isRepliable()) {
					const embedReply = new EmbedBuilder();
					embedReply.setColor('DarkRed');
					embedReply.setDescription(
						"-- This Channel Has Already Been Confirmed , You Can't Decline It Now"
					);
					if (!interaction.replied && !interaction.deferred) {
						return interaction.reply({ embeds: [embedReply], ephemeral: true });
					}

					if (interaction.deferred) {
						return interaction.editReply({ embeds: [embedReply] });
					}

					// replied && !deferred
					return interaction.followUp({
						embeds: [embedReply],
						ephemeral: true,
					});
				}
			} else {
				switch (dayCategoryID) {
					case '1020379323343065189':
						{
							switch (coOwnerData.value) {
								case undefined:
									{
										switch (Emoji) {
											case undefined:
												{
													No_Co_Owner_Without_Badge(
														EmbedBuilder,
														Embed,
														interaction,
														shortDay,
														dayCategoryID,
														raidType,
														Time,
														Period,
														Memb,
														dayRoleId,
														progRole,
														PermissionFlagsBits,
														successfulEmbed,
														errorEmbed,
														ChannelType,
														raids
													);
												}
												break;
											default: {
												No_Co_Owner_With_Badge(
													EmbedBuilder,
													Embed,
													interaction,
													shortDay,
													dayCategoryID,
													raidType,
													Time,
													Period,
													Memb,
													dayRoleId,
													progRole,
													PermissionFlagsBits,
													successfulEmbed,
													errorEmbed,
													ChannelType,
													Emoji,
													raids
												);
											}
										}
									}
									break;
								default: {
									const coOwner = coOwnerData.value.substring(
										2,
										coOwnerData.length - 1
									);
									const CoownerReal = await interaction.guild.members.fetch(
										coOwner
									);
									switch (Emoji) {
										case undefined:
											{
												Co_Owner_Without_Badge(
													EmbedBuilder,
													Embed,
													interaction,
													shortDay,
													dayCategoryID,
													raidType,
													Time,
													Period,
													Memb,
													dayRoleId,
													progRole,
													PermissionFlagsBits,
													successfulEmbed,
													errorEmbed,
													ChannelType,
													CoownerReal,
													raids
												);
											}
											break;
										default: {
											Co_Owner_With_Badge(
												EmbedBuilder,
												Embed,
												interaction,
												shortDay,
												dayCategoryID,
												raidType,
												Time,
												Period,
												Memb,
												dayRoleId,
												progRole,
												PermissionFlagsBits,
												successfulEmbed,
												errorEmbed,
												ChannelType,
												CoownerReal,
												Emoji,
												raids
											);
										}
									}
								}
							}
						}
						break;
					case '1020379206825295873':
						{
							switch (coOwnerData.value) {
								case undefined:
									{
										switch (Emoji) {
											case undefined:
												{
													No_Co_Owner_Without_Badge(
														EmbedBuilder,
														Embed,
														interaction,
														shortDay,
														dayCategoryID,
														raidType,
														Time,
														Period,
														Memb,
														dayRoleId,
														progRole,
														PermissionFlagsBits,
														successfulEmbed,
														errorEmbed,
														ChannelType,
														raids
													);
												}
												break;
											default: {
												No_Co_Owner_With_Badge(
													EmbedBuilder,
													Embed,
													interaction,
													shortDay,
													dayCategoryID,
													raidType,
													Time,
													Period,
													Memb,
													dayRoleId,
													progRole,
													PermissionFlagsBits,
													successfulEmbed,
													errorEmbed,
													ChannelType,
													Emoji,
													raids
												);
											}
										}
									}
									break;
								default: {
									const coOwner = coOwnerData.value.substring(
										2,
										coOwnerData.length - 1
									);
									const CoownerReal = await interaction.guild.members.fetch(
										coOwner
									);
									switch (Emoji) {
										case undefined:
											{
												Co_Owner_Without_Badge(
													EmbedBuilder,
													Embed,
													interaction,
													shortDay,
													dayCategoryID,
													raidType,
													Time,
													Period,
													Memb,
													dayRoleId,
													progRole,
													PermissionFlagsBits,
													successfulEmbed,
													errorEmbed,
													ChannelType,
													CoownerReal,
													raids
												);
											}
											break;
										default: {
											Co_Owner_With_Badge(
												EmbedBuilder,
												Embed,
												interaction,
												shortDay,
												dayCategoryID,
												raidType,
												Time,
												Period,
												Memb,
												dayRoleId,
												progRole,
												PermissionFlagsBits,
												successfulEmbed,
												errorEmbed,
												ChannelType,
												CoownerReal,
												Emoji,
												raids
											);
										}
									}
								}
							}
						}
						break;
					default: {
					}
				}
			}
		}
	},
};