bot/adapters/discord/src/discord.controller.ts

import EventEmitter from "node:events";
import {
	type WaterMeController,
	waterMeController,
} from "features/water-me/water-me.controller";
import client from "lib/client";

export default class DiscordController extends EventEmitter {
	private waterMeController: WaterMeController = waterMeController;

	constructor() {
		super();
		let channelListeners = new Map();

		process.on("exit", async () => {
			const channels = client.channels;
			const logChannel = channels.cache.get(config.discord.channelIdLog);
			await this.handleShutdown(logChannel);
			process.exit(0);
		});

		process.on("SIGINT", async () => {
			const channels = client.channels;
			const logChannel = channels.cache.get(config.discord.channelIdLog);
			await this.handleShutdown(logChannel);
			process.exit(0);
		});

		process.on("SIGTERM", async () => {
			const channels = client.channels;
			const logChannel = channels.cache.get(config.discord.channelIdLog);
			await this.handleShutdown(logChannel);
			process.exit(0);
		});

		// listen for interactions
		client.on("interactionCreate", this.handleInteraction.bind(this));

		client.on("messageCreate", async (message) => {
			console.log(message.id);
			if (message.channel.type === ChannelType.DM) {
				console.log("got msg");
				await this.dmService.forward(message);
			}
		});

		client.on("guildMemberAdd", async (member) => {
			await this.greetingService.welcome(member);
		});

		client.on(
			Events.VoiceStateUpdate,
			async (oldState: VoiceState, newState: VoiceState) => {
				// check if user joined a vc
				if (
					(!oldState.channelId && newState.channelId) ||
					oldState.channelId !== newState.channelId
				) {
					// check if right vc
					if (
						newState.channelId === config.discord.vchannelIdForTwo ||
						newState.channelId === config.discord.vchannelIdForThree ||
						newState.channelId === config.discord.vchannelIdForFour ||
						newState.channelId === config.discord.vchannelIdForGroup
					) {
						const channel = newState.channel;
						if (!channel) {
							console.error("channel not found");
							return;
						}
						try {
							const newChannel =
								await this.dynamicVChannelService.createVChannel(
									newState,
									channel,
								);
							// move user in new channel
							await newState.setChannel(newChannel);
							// create specific listener for channel
							const channelListener = async (
								oldState: VoiceState,
								newState: VoiceState,
							) => {
								channelListeners =
									await this.dynamicVChannelService.deleteVChannel(
										oldState,
										newState,
										newChannel,
										channelListeners,
										channelListener,
									);
							};
							// save listener in map
							channelListeners.set(newChannel.id, channelListener);
							// add listener
							client.on(Events.VoiceStateUpdate, channelListener);
						} catch (error) {
							console.error("error while duplicating channel", error);
						}
					}
				}
			},
		);
		console.log(
			`----------------\nversion ${config.discord.version}\n----------------`,
		);
	}

	async setActivity(state: number) {
		switch (state) {
			case 0:
				client.user?.setActivity(" ", { type: 0 });
				console.log("set activity");
				client.user?.setPresence({
					status: "invisible",
				});
				break;
			default:
				client.user?.setActivity("spielt sudoku", { type: 0 });
				console.log("set activity");
				client.user?.setPresence({
					status: "online",
				});
				break;
		}
	}

	async handleInteraction(interaction: Interaction<CacheType>) {
		if (interaction.isModalSubmit()) {
			await this.handleModalSubmit(interaction);
			return;
		}

		if (interaction.isChatInputCommand()) {
			await this.handleChatInputCommand(interaction);
			return;
		}
		if (interaction.isButton()) {
			await this.handleButton(interaction);
			return;
		}
	}

	async handleButton(interaction: ButtonInteraction<CacheType>) {
		const { customId } = interaction;
		console.log(interaction.customId);

		if (customId.toLowerCase().includes("moreWater")) {
			await this.waterMeService.handleInteraction(interaction);
		}
		if (customId.toLowerCase().includes("medication")) {
			await this.medicationService.handleInteraction(interaction);
		}
	}

	async handleChatInputCommand(
		interaction: ChatInputCommandInteraction<CacheType>,
	) {
		const commandName = interaction.commandName as CommandsType;

		// add commands
		switch (commandName) {
			case Commands.Enum.giessen:
				await this.waterMeService.handleInteraction(interaction); // zu chatinputcommand wechseln
				return;
			case Commands.Enum.medikamente:
				await this.medicationService.handleChatInputCommand(interaction);
				return;
			case Commands.Enum.hilfe:
				await this.helpService.handleInteraction(interaction); // zu chatinputcommand wechseln
				return;
			case Commands.Enum.support:
			case Commands.Enum.kofi:
			case Commands.Enum.disboard:
			case Commands.Enum.discadia:
				await this.supportService.handleInteraction(interaction);
				return;
			case Commands.Enum.accept:
				await this.greetingService.handleChatInputCommand(interaction);
				return;
			case Commands.Enum.welcome:
				await this.greetingService.handleChatInputCommand(interaction);
				return;
			case Commands.Enum.embed:
			case Commands.Enum.message:
				await this.customMessageService.handleChatInputCommand(interaction);
				return;
			case Commands.Enum.reminder:
				await this.greetingService.handleChatInputCommand(interaction);
				return;
			case Commands.Enum.version:
				await this.debugService.handleChatInputCommand(interaction);
				return;
			default:
				break;
		}
	}

	// wenn neues fenster durch buttonclick or so
	async handleModalSubmit(interaction: ModalSubmitInteraction<CacheType>) {
		const { customId } = interaction;

		switch (customId) {
			default:
				break;
		}
	}
}