import { type BaseInteraction, type Client, Events } from "discord.js";
import { commands } from "../handlers/interactions";

import { parseComponentId } from "@/utils/discord/components";
import { loggers } from "@/utils/logging";
const logger = loggers.interactions;

export default {
	event: Events.InteractionCreate,
	async execute(client: Client, interaction: BaseInteraction) {
		if (interaction.isCommand()) {
			const command = commands.get(interaction.commandName);
			const sub = interaction.isChatInputCommand() ? interaction.options.getSubcommand() : null;
			const commandString = sub ? `${interaction.commandName}/${sub}` : interaction.commandName;

			logger.info(
				{
					command: commandString,
					user: {
						id: interaction.user.id,
						discriminator: interaction.user.tag,
					},
				},
				`received chat input interaction`,
			);

			if (!command || !command.execute) return;
			try {
				await command.execute(client, interaction);
			} catch (error) {
				logger.error(error, `there was an error while executing ${interaction.commandName}`);

				if (interaction.deferred || interaction.replied) {
					await interaction.followUp({
						content: "there was an error while executing this command!",
						flags: ["Ephemeral"],
					});
				} else {
					await interaction.reply({
						content: "there was an error while executing this command!",
						flags: ["Ephemeral"],
					});
				}
			}
		} else if (interaction.isButton()) {
			const { commandName } = parseComponentId(interaction.customId);
			const command = commands.get(commandName);

			logger.info(
				{
					button: commandName,
					id: interaction.customId,
					user: {
						id: interaction.user.id,
						discriminator: interaction.user.tag,
					},
				},
				"received button interaction",
			);

			if (!command || !command.buttonExecute) {
				return interaction.reply({
					content: `couldn't find the associated command (${commandName})`,
					flags: ["Ephemeral"],
				});
			}
			try {
				await command.buttonExecute(client, interaction);
			} catch (error) {
				logger.error(
					error,
					`there was an error while executing button with customId ${interaction.customId}`,
				);

				if (interaction.deferred || interaction.replied) {
					await interaction.followUp({
						content: "there was an error while executing this button command!",
						flags: ["Ephemeral"],
					});
				} else {
					await interaction.reply({
						content: "there was an error while executing this button command!",
						flags: ["Ephemeral"],
					});
				}
			}
		} else if (interaction.isModalSubmit()) {
			const { commandName } = parseComponentId(interaction.customId);
			const command = commands.get(commandName);

			logger.info(
				{
					modal: commandName,
					id: interaction.customId,
					user: {
						id: interaction.user.id,
						discriminator: interaction.user.tag,
					},
				},
				"received modal interaction",
			);

			if (!command || !command.modalExecute) return;
			try {
				await command.modalExecute(client, interaction);
			} catch (error) {
				logger.error(
					error,
					`there was an error while executing modal with customId ${interaction.customId}`,
				);

				if (interaction.deferred || interaction.replied) {
					await interaction.followUp({
						content: "there was an error while executing this modal!",
						flags: ["Ephemeral"],
					});
				} else {
					await interaction.reply({
						content: "there was an error while executing this modal!",
						flags: ["Ephemeral"],
					});
				}
			}
		} else if (interaction.isAutocomplete()) {
			const command = commands.get(interaction.commandName);

			logger.info(
				{
					command: command?.data?.name,
					user: {
						id: interaction.user.id,
						discriminator: interaction.user.tag,
					},
				},
				"received autocomplete interaction",
			);

			if (!command || !command.autocomplete) return;
			try {
				await command.autocomplete(interaction);
			} catch (error) {
				logger.error(
					error,
					`there was an error while executing autocomplete command for ${interaction.commandName}`,
				);
			}
		} else if (interaction.isStringSelectMenu()) {
			const { commandName } = parseComponentId(interaction.customId);
			const command = commands.get(commandName);

			logger.info(
				{
					menu: commandName,
					id: interaction.customId,
					user: {
						id: interaction.user.id,
						discriminator: interaction.user.tag,
					},
				},
				"received select menu interaction",
			);

			if (!command || !command.selectMenuExecute)
				return interaction.reply({
					content: "couldn't find the associated command!",
					flags: ["Ephemeral"],
				});
			try {
				await command.selectMenuExecute(client, interaction);
			} catch (error) {
				logger.error(
					error,
					`there was an error while executing select menu with customId ${interaction.customId}`,
				);

				if (interaction.deferred || interaction.replied) {
					await interaction.followUp({
						content: "there was an error while executing this select menu!",
						flags: ["Ephemeral"],
					});
				} else {
					await interaction.reply({
						content: "there was an error while executing this select menu!",
						flags: ["Ephemeral"],
					});
				}
			}
		}
	},
};