Fix duplicate streamWatching, locale guild et console log/error

src/utils/twitch.ts

@@ -2,7 +2,7 @@
 const clientId = process.env.TWITCH_APP_ID
 const clientSecret = process.env.TWITCH_APP_SECRET
 if (!clientId || !clientSecret) {
-	console.warn(chalk.red("[Twitch] Missing TWITCH_APP_ID or TWITCH_APP_SECRET in environment variables!"))
+	logConsole('twitch', 'missing_credentials')
 	process.exit(1)
 }
 
@@ -14,12 +14,11 @@ import { NgrokAdapter } from "@twurple/eventsub-ngrok"
 import type { EventSubStreamOnlineEvent, EventSubStreamOfflineEvent } from "@twurple/eventsub-base"
 import { EmbedBuilder, ChannelType, ComponentType, ButtonBuilder, ButtonStyle, Locale } from "discord.js"
 import type { Client, Guild } from "discord.js"
-import chalk from "chalk"
 import discordClient from "@/index"
 import type { GuildTwitch } from "@/types/schemas"
 import dbGuild from "@/schemas/guild"
-import { t } from "@/utils/i18n"
-import { logConsole } from "@/utils/console"
+import { t, getGuildLocale } from "@/utils/i18n"
+import { logConsole, logConsoleError } from "@/utils/console"
 
 // Twurple API client setup
 const authProvider = new AppTokenAuthProvider(clientId, clientSecret)
@@ -35,7 +34,7 @@ if (process.env.NODE_ENV === "development") {
 	const hostName = process.env.TWURPLE_HOSTNAME ?? "localhost"
 	const port = process.env.TWURPLE_PORT ?? "3000"
 
-	console.log(chalk.magenta(`[Twitch] Starting listener with port ${port}...`))
+	logConsole('twitch', 'starting_listener_port', { port })
 	adapter = new ReverseProxyAdapter({ hostName, port: parseInt(port) })
 }
 
@@ -45,26 +44,30 @@ listener.start()
 
 // Twurple subscriptions callback functions
 export const onlineSub = async (event: EventSubStreamOnlineEvent) => {
-	console.log(chalk.magenta(`[Twitch] Stream from ${event.broadcasterName} (ID ${event.broadcasterId}) is now online, sending Discord messages...`))
+	logConsole('twitch', 'stream_online', { streamer: event.broadcasterName, id: event.broadcasterId })
 
 	const results = await Promise.allSettled(discordClient.guilds.cache.map(async guild => {
+		const processingKey = `${guild.id}-${event.broadcasterId}`
 		try {
-			console.log(chalk.magenta(`[Twitch] Processing guild: ${guild.name} (ID: ${guild.id}) for streamer ${event.broadcasterName}`))
+			if (processingStreamers.has(processingKey)) { logConsole('twitch', 'streamer_already_processing', { guildName: guild.name, broadcasterName: event.broadcasterName }); return }
+			processingStreamers.add(processingKey)
+
+			logConsole('twitch', 'processing_guild', { name: guild.name, id: guild.id, streamer: event.broadcasterName })
 
 			const notification = await generateNotification(guild, event.broadcasterId, event.broadcasterName)
-			if (notification.status !== "ok") { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Notification generation failed with status: ${notification.status}`)); return }
+			if (notification.status !== "ok") { logConsole('twitch', 'notification_failed', { guild: guild.name, status: notification.status }); return }
 
 			const { guildProfile, dbData, channel, content, embed } = notification
-			if (!dbData) { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} No dbData found`)); return }
+			if (!dbData) { logConsole('twitch', 'no_db_data', { guild: guild.name }); return }
 
 			const streamerIndex = dbData.streamers.findIndex(s => s.twitchUserId === event.broadcasterId)
-			if (streamerIndex === -1) { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Streamer ${event.broadcasterName} not found in this guild`)); return }
+			if (streamerIndex === -1) { logConsole('twitch', 'streamer_not_found', { guild: guild.name, streamer: event.broadcasterName }); return }
 
-			if (dbData.streamers[streamerIndex].messageId) { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Message already exists for ${event.broadcasterName}, skipping`)); return }
+			if (dbData.streamers[streamerIndex].messageId) { logConsole('twitch', 'message_exists', { guild: guild.name, streamer: event.broadcasterName }); return }
 
-			console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Sending notification for ${event.broadcasterName}`))
+			logConsole('twitch', 'sending_notification', { guild: guild.name, streamer: event.broadcasterName })
 			const message = await channel.send({ content, embeds: [embed] })
-			console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Message sent with ID: ${message.id}`))
+			logConsole('twitch', 'message_sent', { guild: guild.name, id: message.id })
 
 			dbData.streamers[streamerIndex].messageId = message.id
 
@@ -74,18 +77,20 @@ export const onlineSub = async (event: EventSubStreamOnlineEvent) => {
 
 			startStreamWatching(guild.id, event.broadcasterId, event.broadcasterName, message.id)
 		} catch (error) {
-			console.log(chalk.magenta(`[Twitch] Error processing guild ${guild.name}`))
-			console.error(error)
+			processingStreamers.delete(processingKey)
+			logConsoleError('twitch', 'error_processing_guild', { name: guild.name }, error as Error)
+		} finally {
+			processingStreamers.delete(processingKey)
 		}
 	}))
 
 	results.forEach((result, index) => {
-		if (result.status === "rejected") console.log(chalk.magenta(`[Twitch] Guild ${index} failed:`), result.reason)
+		if (result.status === "rejected") logConsoleError('twitch', 'guild_failed', { index: index.toString() }, result.reason instanceof Error ? result.reason : new Error(String(result.reason)))
 	})
 }
 
 export const offlineSub = async (event: EventSubStreamOfflineEvent) => {
-	console.log(chalk.magenta(`[Twitch] Stream from ${event.broadcasterName} (ID ${event.broadcasterId}) is now offline, editing Discord messages...`))
+	logConsole('twitch', 'stream_offline', { streamer: event.broadcasterName, id: event.broadcasterId })
 
 	await Promise.all(discordClient.guilds.cache.map(async guild => {
 		await stopStreamWatching(guild.id, event.broadcasterId, event.broadcasterName)
@@ -95,8 +100,11 @@ export const offlineSub = async (event: EventSubStreamOfflineEvent) => {
 // Stream upadting intervals
 const streamIntervals = new Map<string, NodeJS.Timeout>()
 
+// Tracking des streamers en cours de traitement pour éviter les doublons
+const processingStreamers = new Set<string>()
+
 export function startStreamWatching(guildId: string, streamerId: string, streamerName: string, messageId: string) {
-	console.log(chalk.magenta(`[Twitch] StreamWatching - Démarrage du visionnage de ${streamerName} (ID ${streamerId}) sur ${guildId}`))
+	logConsole('twitch', 'start_watching', { streamer: streamerName, id: streamerId, guildId })
 
 	const key = `${guildId}-${streamerId}`
 	if (streamIntervals.has(key)) {
@@ -109,21 +117,19 @@ export function startStreamWatching(guildId: string, streamerId: string, streame
 		try {
 			const guild = await discordClient.guilds.fetch(guildId)
 			const notification = await generateNotification(guild, streamerId, streamerName)
-			if (notification.status !== "ok") { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Notification generation failed with status: ${notification.status}`)); return }
+			if (notification.status !== "ok") { logConsole('twitch', 'notification_failed', { guild: guild.name, status: notification.status }); return }
 
 			const { channel, content, embed } = notification
-			if (!embed) { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Embed is missing`)); return }
+			if (!embed) { logConsole('twitch', 'embed_missing', { guild: guild.name }); return }
 
 			try {
 				const message = await channel.messages.fetch(messageId)
 				await message.edit({ content, embeds: [embed] })
 			} catch (error) {
-				console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Error editing message for ${streamerName} (ID ${streamerId})`))
-				console.error(error)
+				logConsoleError('twitch', 'error_editing_message', { guild: guild.name, streamer: streamerName, id: streamerId }, error as Error)
 			}
 		} catch (error) {
-			console.log(chalk.magenta(`[Twitch] StreamWatching - Erreur lors du visionnage de ${streamerName} (ID ${streamerId}) sur ${guildId}`))
-			console.error(error)
+			logConsoleError('twitch', 'error_watching', { streamer: streamerName, id: streamerId, guildId }, error as Error)
 			await stopStreamWatching(guildId, streamerId, streamerName)
 		}
 	}, 60000)
@@ -132,7 +138,7 @@ export function startStreamWatching(guildId: string, streamerId: string, streame
 }
 
 export async function stopStreamWatching(guildId: string, streamerId: string, streamerName: string) {
-	console.log(chalk.magenta(`[Twitch] StreamWatching - Arrêt du visionnage de ${streamerName} (ID ${streamerId})`))
+	logConsole('twitch', 'stop_watching', { streamer: streamerName, id: streamerId })
 
 	const key = `${guildId}-${streamerId}`
 	if (streamIntervals.has(key)) {
@@ -140,116 +146,121 @@ export async function stopStreamWatching(guildId: string, streamerId: string, st
 		streamIntervals.delete(key)
 	}
 
-	const guild = await discordClient.guilds.fetch(guildId)
-	const guildProfile = await dbGuild.findOne({ guildId: guild.id })
-	if (!guildProfile) { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Database data does not exist !`)); return }
-
-	const dbData = guildProfile.get("guildTwitch") as GuildTwitch
-	if (!dbData.enabled || !dbData.channelId) { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Database data does not exist !`)); return }
-
-	const channel = await guild.channels.fetch(dbData.channelId)
-	if (!channel || (channel.type !== ChannelType.GuildText && channel.type !== ChannelType.GuildAnnouncement)) {
-		console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Channel with ID ${dbData.channelId} not found for Twitch notifications`))
-		return
-	}
-
-	const streamer = dbData.streamers.find(s => s.twitchUserId === streamerId)
-	if (!streamer) { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Streamer not found in guild for ${streamerName} (ID ${streamerId})`)); return }
-
-	const messageId = streamer.messageId
-	if (!messageId) { console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Message ID not found for ${streamerName} (ID ${streamerId})`)); return }
-
-	const user = await twitchClient.users.getUserById(streamerId)
-	if (!user) console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} User data not found for ${streamerName} (ID ${streamerId})`))
-
-	let duration_string = ""
-	const stream = await user?.getStream()
-	if (!stream) {
-		console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Stream data not found for ${streamerName} (ID ${streamerId})`))
-		duration_string = t(guild.preferredLocale, "twitch.notification.offline.duration_unknown")
-	} else {
-		const duration = new Date().getTime() - stream.startDate.getTime()
-		const seconds = Math.floor(duration / 1000)
-		const minutes = Math.floor(seconds / 60)
-		const hours = Math.floor(minutes / 60)
-		// eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-		duration_string = `${hours ? hours + "H " : ""}${minutes % 60 ? (minutes % 60) + "M " : ""}${seconds % 60 ? (seconds % 60) + "S" : ""}`
-	}
-
-	let content = ""
-	if (!streamer.discordUserId) content = t(guild.preferredLocale, "twitch.notification.offline.everyone", { streamer: streamerName })
-	else content = t(guild.preferredLocale, "twitch.notification.offline.everyone_with_mention", { discordId: streamer.discordUserId })
-
-	const embed = new EmbedBuilder()
-		.setColor("#6441a5")
-		.setAuthor({
-			name: t(guild.preferredLocale, "twitch.notification.offline.author", { duration: duration_string }),
-			iconURL: user?.profilePictureUrl ?? "https://static-cdn.jtvnw.net/emoticons/v2/58765/static/light/3.0"
-		})
-		.setTimestamp()
-
 	try {
-		const message = await channel.messages.fetch(messageId)
-		await message.edit({ content, embeds: [embed] })
+		const guild = await discordClient.guilds.fetch(guildId)
+		const guildProfile = await dbGuild.findOne({ guildId: guild.id })
+		if (!guildProfile) { logConsole('twitch', 'database_not_exist', { guild: guild.name }); return }
+
+		const dbData = guildProfile.get("guildTwitch") as GuildTwitch
+		if (!dbData.enabled || !dbData.channelId) { logConsole('twitch', 'database_not_exist', { guild: guild.name }); return }
+
+		const channel = await guild.channels.fetch(dbData.channelId)
+		if (!channel || (channel.type !== ChannelType.GuildText && channel.type !== ChannelType.GuildAnnouncement)) {
+			logConsole('twitch', 'channel_not_found', { guild: guild.name, channelId: dbData.channelId })
+			return
+		}
+
+		const streamer = dbData.streamers.find(s => s.twitchUserId === streamerId)
+		if (!streamer) { logConsole('twitch', 'streamer_not_found', { guild: guild.name, streamer: streamerName, id: streamerId }); return }
+
+		const messageId = streamer.messageId
+		if (!messageId) { logConsole('twitch', 'message_id_not_found', { guild: guild.name, streamer: streamerName, id: streamerId }); return }
+
+		const user = await twitchClient.users.getUserById(streamerId)
+		if (!user) logConsole('twitch', 'user_data_not_found', { guild: guild.name, streamer: streamerName, id: streamerId })
+
+		const guildLocale = await getGuildLocale(guild.id)
+		let duration_string = ""
+		const stream = await user?.getStream()
+		if (!stream) {
+			logConsole('twitch', 'stream_data_not_found', { guild: guild.name, streamer: streamerName, id: streamerId })
+			duration_string = t(guildLocale, "twitch.notification.offline.duration_unknown")
+		} else {
+			const duration = new Date().getTime() - stream.startDate.getTime()
+			const seconds = Math.floor(duration / 1000)
+			const minutes = Math.floor(seconds / 60)
+			const hours = Math.floor(minutes / 60)
+			// eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+			duration_string = `${hours ? hours + "H " : ""}${minutes % 60 ? (minutes % 60) + "M " : ""}${seconds % 60 ? (seconds % 60) + "S" : ""}`
+		}
+
+		let content = ""
+		if (!streamer.discordUserId) content = t(guildLocale, "twitch.notification.offline.everyone", { streamer: streamerName })
+		else content = t(guildLocale, "twitch.notification.offline.everyone_with_mention", { discordId: streamer.discordUserId })
+
+		const embed = new EmbedBuilder()
+			.setColor("#6441a5")
+			.setAuthor({
+				name: t(guildLocale, "twitch.notification.offline.author", { duration: duration_string }),
+				iconURL: user?.profilePictureUrl ?? "https://static-cdn.jtvnw.net/emoticons/v2/58765/static/light/3.0"
+			})
+			.setTimestamp()
+
+		try {
+			const message = await channel.messages.fetch(messageId)
+			await message.edit({ content, embeds: [embed] })
+		} catch (error) {
+			logConsoleError('twitch', 'error_editing_message', { guild: guild.name, streamer: streamerName, id: streamerId }, error as Error)
+		}
+
+		const streamerIndex = dbData.streamers.findIndex(s => s.twitchUserId === streamerId)
+		if (streamerIndex === -1) return
+
+		dbData.streamers[streamerIndex].messageId = ""
+
+		guildProfile.set("guildTwitch", dbData)
+		guildProfile.markModified("guildTwitch")
+		await guildProfile.save().catch(console.error)
 	} catch (error) {
-		console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Error editing message for ${streamerName} (ID ${streamerId})`))
-		console.error(error)
+		logConsoleError('twitch', 'stop_watching_error', { streamer: streamerName, id: streamerId, guildId }, error as Error)
 	}
-
-	const streamerIndex = dbData.streamers.findIndex(s => s.twitchUserId === streamerId)
-	if (streamerIndex === -1) return
-
-	dbData.streamers[streamerIndex].messageId = ""
-
-	guildProfile.set("guildTwitch", dbData)
-	guildProfile.markModified("guildTwitch")
-	await guildProfile.save().catch(console.error)
 }
 
 async function generateNotification(guild: Guild, streamerId: string, streamerName: string) {
 	const guildProfile = await dbGuild.findOne({ guildId: guild.id })
 	if (!guildProfile) {
-		console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Database data does not exist !`))
+		logConsole('twitch', 'database_not_exist', { guild: guild.name })
 		return { status: "noProfile" }
 	}
 
 	const dbData = guildProfile.get("guildTwitch") as GuildTwitch
 	if (!dbData.enabled || !dbData.channelId) {
-		console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Twitch module is not enabled or channel ID is missing`))
+		logConsole('twitch', 'module_disabled', { guild: guild.name })
 		return { status: "disabled" }
 	}
 
 	const channel = await guild.channels.fetch(dbData.channelId)
 	if ((channel?.type !== ChannelType.GuildText && channel?.type !== ChannelType.GuildAnnouncement)) {
-		console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Channel with ID ${dbData.channelId} not found for Twitch notifications`))
+		logConsole('twitch', 'channel_not_found', { guild: guild.name, channelId: dbData.channelId })
 		return { status: "noChannel" }
 	}
 
 	const streamer = dbData.streamers.find(s => s.twitchUserId === streamerId)
 	if (!streamer) {
-		console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Streamer not found in guild for ${streamerName} (ID ${streamerId})`))
+		logConsole('twitch', 'streamer_not_found', { guild: guild.name, streamer: streamerName, id: streamerId })
 		return { status: "noStreamer" }
 	}
 
 	const user = await twitchClient.users.getUserById(streamerId)
-	if (!user) console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} User data not found for ${streamerName} (ID ${streamerId})`))
+	if (!user) logConsole('twitch', 'user_data_not_found', { guild: guild.name, streamer: streamerName, id: streamerId })
 
 	const stream = await user?.getStream()
-	if (!stream) console.log(chalk.magenta(`[Twitch] StreamWatching - {${guild.name}} Stream data not found for ${streamerName} (ID ${streamerId})`))
+	if (!stream) logConsole('twitch', 'stream_data_not_found', { guild: guild.name, streamer: streamerName, id: streamerId })
 
+	const guildLocale = await getGuildLocale(guild.id)
 	let content = ""
-	if (!streamer.discordUserId) content = t(guild.preferredLocale, "twitch.notification.online.everyone", { streamer: user?.displayName ?? streamerName })
-	else content = t(guild.preferredLocale, "twitch.notification.online.everyone_with_mention", { discordId: streamer.discordUserId })
+	if (!streamer.discordUserId) content = t(guildLocale, "twitch.notification.online.everyone", { streamer: user?.displayName ?? streamerName })
+	else content = t(guildLocale, "twitch.notification.online.everyone_with_mention", { discordId: streamer.discordUserId })
 
 	const embed = new EmbedBuilder()
 		.setColor("#6441a5")
-		.setTitle(stream?.title ?? t(guild.preferredLocale, "twitch.notification.online.title_unknown"))
+		.setTitle(stream?.title ?? t(guildLocale, "twitch.notification.online.title_unknown"))
 		.setURL(`https://twitch.tv/${streamerName}`)
 		.setAuthor({
-			name: t(guild.preferredLocale, "twitch.notification.online.author", { streamer: (user?.displayName ?? streamerName).toUpperCase() }),
+			name: t(guildLocale, "twitch.notification.online.author", { streamer: (user?.displayName ?? streamerName).toUpperCase() }),
 			iconURL: user?.profilePictureUrl ?? "https://static-cdn.jtvnw.net/emoticons/v2/58765/static/light/3.0"
 		})
-		.setDescription(t(guild.preferredLocale, "twitch.notification.online.description", { 
+		.setDescription(t(guildLocale, "twitch.notification.online.description", { 
 			game: stream?.gameName ?? "?", 
 			viewers: stream?.viewers.toString() ?? "?" 
 		}))