index.js

"use strict";

const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
const automodCommand = require("./commands/automod");
const ruleSchema = require("./models/rule");
const whitelistSchema = require("./models/whitelist");
const { parseDuration } = require("./lib/parseDuration");

// In-memory spam history tracker
// Key: `${guildId}-${userId}` -> { timestamps: Array, lastContent: String, contentCount: Number }
const spamHistory = new Map();

async function load(ctx) {
	// --- Register Models ----------------------------------------------------
	const AutoModRule = ctx.defineModel("AutoModRule", ruleSchema);
	const Whitelist = ctx.defineModel("Whitelist", whitelistSchema);
	ctx.models = { AutoModRule, Whitelist };

	// --- Register Commands --------------------------------------------------
	ctx.registerCommand({
		data: automodCommand.data,
		execute: (interaction) => automodCommand.execute(interaction, ctx),
	});

	// --- Register Events ----------------------------------------------------
	ctx.registerEvent("messageCreate", async (message, client) => {
		try {
			// Skip bot messages
			if (message.author.bot) return;
			// Skip DMs
			if (!message.guild) return;
			// Skip empty messages
			if (!message.content) return;

			// Bypass administrators and manage guild permission holders
			if (message.member) {
				const isBypass = message.member.permissions.has(PermissionFlagsBits.Administrator) ||
					message.member.permissions.has(PermissionFlagsBits.ManageGuild);
				if (isBypass) return;
			}

			// Respect the dashboard on/off toggle (settings.enabled). Defaults to
			// on when unset so existing rule-based setups keep working.
			const settings = (await ctx.db.getPluginConfig(message.guild.id, "adb-plugin-automod"))?.data || {};
			if (settings.enabled === false) return;

			// Retrieve active rules for this guild
			const rules = await AutoModRule.find({ guildId: message.guild.id, enabled: true });
			if (rules.length === 0) return;

			// Priority order for checks: invite -> link -> caps -> mention -> emoji -> word -> spam
			const typePriority = ["invite", "link", "caps", "mention", "emoji", "word", "spam"];
			const activeRules = rules.sort((a, b) => typePriority.indexOf(a.type) - typePriority.indexOf(b.type));

			for (const rule of activeRules) {
				const ruleType = rule.type;

				// Check if this channel or the user's roles are whitelisted for this rule type
				const isExcluded = await isWhitelisted(message, ruleType, Whitelist);
				if (isExcluded) continue;

				let triggered = false;
				let details = "";

				if (ruleType === "invite") {
					triggered = checkInvite(message);
					if (triggered) details = "Message contained a Discord invite link";
				} else if (ruleType === "link") {
					triggered = checkLink(message, rule);
					if (triggered) details = "Message contained a blocked link";
				} else if (ruleType === "caps") {
					triggered = checkCaps(message, rule);
					if (triggered) details = `Caps percentage exceeded threshold (${rule.config?.threshold || 70}%)`;
				} else if (ruleType === "mention") {
					triggered = checkMention(message, rule);
					if (triggered) details = `Mention count exceeded threshold (${rule.config?.threshold || 5})`;
				} else if (ruleType === "emoji") {
					triggered = checkEmoji(message, rule);
					if (triggered) details = `Emoji count exceeded threshold (${rule.config?.threshold || 5})`;
				} else if (ruleType === "word") {
					triggered = checkWord(message, rule);
					if (triggered) details = "Message contained a blocked word";
				} else if (ruleType === "spam") {
					triggered = checkSpam(message, rule);
					if (triggered) details = "Spam detected (rapid/repeated messages or consecutive duplicate characters)";
				}

				if (triggered) {
					await handleAction(ctx, message, rule, details);
					break; // Stop running other filters after the first match
				}
			}
		} catch (err) {
			ctx.logger.error("Error in AutoMod messageCreate handler:", err);
		}
	});

	ctx.logger.info("AutoMod plugin loaded successfully");
}

// --- Whitelist Checker -------------------------------------------------------
async function isWhitelisted(message, filterType, WhitelistModel) {
	// Check channel whitelist
	const channelWl = await WhitelistModel.findOne({
		guildId: message.guild.id,
		targetId: message.channel.id,
		targetType: "channel",
		filterType: { $in: [filterType, "all"] },
	});
	if (channelWl) return true;

	// Check role whitelist
	if (message.member && message.member.roles) {
		const roleIds = Array.from(message.member.roles.cache.keys());
		if (roleIds.length > 0) {
			const roleWl = await WhitelistModel.findOne({
				guildId: message.guild.id,
				targetId: { $in: roleIds },
				targetType: "role",
				filterType: { $in: [filterType, "all"] },
			});
			if (roleWl) return true;
		}
	}

	return false;
}

// --- Filter Functions --------------------------------------------------------

function checkInvite(message) {
	const inviteRegex = /(discord\.(gg|io|me|li)\b)|(discord(?:app)?\.com\/invite\b)/i;
	return inviteRegex.test(message.content);
}

function checkLink(message, rule) {
	const content = message.content;
	const urlRegex = /https?:\/\/(?:www\.)?([a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+)/gi;
	let match;
	const links = [];
	while ((match = urlRegex.exec(content)) !== null) {
		links.push(match[1].toLowerCase());
	}
	if (links.length === 0) return false;

	// Exclude Discord invites from link check (let invite filter handle them)
	const inviteRegex = /(discord\.(gg|io|me|li)\b)|(discord(?:app)?\.com\/invite\b)/i;
	const nonInviteLinks = links.filter((link) => {
		return !inviteRegex.test("https://" + link);
	});

	if (nonInviteLinks.length === 0) return false;

	const allowedDomains = rule.config?.words || [];
	const hasBlockedLink = nonInviteLinks.some((domain) => {
		return !allowedDomains.some((allowed) => {
			const lowerAllowed = allowed.toLowerCase();
			return domain === lowerAllowed || domain.endsWith("." + lowerAllowed);
		});
	});

	return hasBlockedLink;
}

function checkCaps(message, rule) {
	const content = message.content;
	if (content.length < 10) return false;
	const letters = content.replace(/[^a-zA-Z]/g, "");
	if (letters.length < 5) return false;
	const uppers = letters.replace(/[^A-Z]/g, "");
	const ratio = (uppers.length / letters.length) * 100;
	const threshold = rule.config?.threshold || 70;
	return ratio > threshold;
}

function checkMention(message, rule) {
	const threshold = rule.config?.threshold || 5;
	return message.mentions.users.size > threshold;
}

function checkEmoji(message, rule) {
	const threshold = rule.config?.threshold || 5;
	const customEmojis = message.content.match(/<a?:\w+:\d+>/g) || [];
	const unicodeEmojis = message.content.match(/\p{Emoji_Presentation}/gu) || [];
	const total = customEmojis.length + unicodeEmojis.length;
	return total > threshold;
}

function checkWord(message, rule) {
	const words = rule.config?.words || [];
	if (words.length === 0) return false;

	const content = message.content.toLowerCase();
	return words.some((word) => {
		const lowerWord = word.toLowerCase();
		const startsWithWildcard = lowerWord.startsWith("*");
		const endsWithWildcard = lowerWord.endsWith("*");

		let cleanWord = lowerWord;
		if (startsWithWildcard) cleanWord = cleanWord.slice(1);
		if (endsWithWildcard) cleanWord = cleanWord.slice(0, -1);

		let escaped = cleanWord.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
		escaped = escaped.replace(/\\\*/g, ".*");

		let pattern = "";
		if (!startsWithWildcard) {
			pattern += "\\b";
		}
		pattern += escaped;
		if (!endsWithWildcard) {
			pattern += "\\b";
		}

		const regex = new RegExp(pattern, "i");
		return regex.test(content);
	});
}

function checkSpam(message, rule) {
	const guildId = message.guild.id;
	const userId = message.author.id;
	const now = Date.now();
	const config = rule.config || {};
	const limit = config.threshold || 5;
	const windowMs = (config.seconds || 5) * 1000;

	const key = `${guildId}-${userId}`;
	if (!spamHistory.has(key)) {
		spamHistory.set(key, { timestamps: [], lastContent: "", contentCount: 0 });
	}
	const record = spamHistory.get(key);

	// 1. Rapid messages check
	record.timestamps.push(now);
	record.timestamps = record.timestamps.filter((t) => now - t < windowMs);
	if (record.timestamps.length > limit) {
		return true;
	}

	// 2. Duplicate consecutive messages check
	if (message.content === record.lastContent) {
		record.contentCount++;
		if (record.contentCount >= 3) {
			return true;
		}
	} else {
		record.lastContent = message.content;
		record.contentCount = 1;
	}

	// 3. Repeated consecutive characters check
	if (/(.)\1{14,}/.test(message.content)) {
		return true;
	}

	return false;
}

// --- Action Handlers ---------------------------------------------------------

async function getLogChannel(guild, ctx) {
	const automodConfig = (await ctx.db.getPluginConfig(guild.id, "adb-plugin-automod"))?.data || {};
	if (automodConfig.logChannelId) {
		const channel = await guild.channels.fetch(automodConfig.logChannelId).catch(() => null);
		if (channel) return channel;
	}

	const modConfig = (await ctx.db.getPluginConfig(guild.id, "adb-plugin-moderation"))?.data || {};
	if (modConfig.log_channel_id) {
		const channel = await guild.channels.fetch(modConfig.log_channel_id).catch(() => null);
		if (channel) return channel;
	}

	// Fallback lookup by name
	if (guild.channels.cache) {
		const channel = guild.channels.cache.find(
			(c) => c.name === "mod-logs" || c.name === "automod-logs" || c.name === "logs",
		);
		if (channel) return channel;
	}
	return null;
}

async function logIncident(ctx, message, ruleType, action, details) {
	const logChannel = await getLogChannel(message.guild, ctx);
	if (!logChannel) return;

	const embed = new EmbedBuilder()
		.setColor(0xe74c3c)
		.setTitle("AutoMod Violation")
		.addFields(
			{ name: "User", value: `${message.author.tag} (${message.author.id})`, inline: true },
			{ name: "Channel", value: `<#${message.channel.id}>`, inline: true },
			{ name: "Filter", value: `\`${ruleType}\``, inline: true },
			{ name: "Action Taken", value: `\`${action}\``, inline: true },
		)
		.setTimestamp();

	if (message.content) {
		embed.addFields({ name: "Content", value: message.content.slice(0, 1024) });
	}
	if (details) {
		embed.addFields({ name: "Details", value: details });
	}

	await logChannel.send({ embeds: [embed] }).catch(() => {});
}

async function handleAction(ctx, message, rule, details) {
	const action = rule.action;
	const ruleType = rule.type;
	const guild = message.guild;

	// Always delete the offending message
	await message.delete().catch(() => {});

	if (action === "warn") {
		const profile = await ctx.db.getUserProfile(message.author.id, guild.id);
		const newWarnings = (profile.warnings || 0) + 1;
		await ctx.db.updateUserProfile(message.author.id, guild.id, { warnings: newWarnings });

		const dmEmbed = new EmbedBuilder()
			.setColor(0xf1c40f)
			.setTitle("AutoMod Warning")
			.setDescription(`You have been warned in **${guild.name}** for triggering the **${ruleType}** filter.`)
			.addFields({ name: "Reason", value: details })
			.setTimestamp();
		await message.author.send({ embeds: [dmEmbed] }).catch(() => {});

		await logIncident(ctx, message, ruleType, action, `Total Warnings: ${newWarnings} | ${details}`);
	} else if (action === "mute" || action === "timeout") {
		const member = message.member || await guild.members.fetch(message.author.id).catch(() => null);
		if (member && member.moderatable) {
			const durationStr = rule.config?.duration || (action === "mute" ? "10m" : "1h");
			const durationMs = parseDuration(durationStr) || (10 * 60 * 1000);

			await member.timeout(durationMs, `[AutoMod] Triggered ${ruleType} filter`).catch(() => {});

			const dmEmbed = new EmbedBuilder()
				.setColor(0xe74c3c)
				.setTitle("AutoMod Timeout")
				.setDescription(`You have been timed out in **${guild.name}** for **${durationStr}** for triggering the **${ruleType}** filter.`)
				.addFields({ name: "Reason", value: details })
				.setTimestamp();
			await message.author.send({ embeds: [dmEmbed] }).catch(() => {});

			await logIncident(ctx, message, ruleType, `${action} (${durationStr})`, details);
		} else {
			await logIncident(ctx, message, ruleType, `${action} (failed - not moderatable)`, `Could not timeout user: ${details}`);
		}
	} else {
		// Log action (or delete)
		await logIncident(ctx, message, ruleType, action, details);
	}
}

module.exports = { load };