@kaikybrofc/omnizap-system 2.1.8

package/app/modules/rpgPokemonModule/rpgProfileCanvasRenderer.js

@@ -0,0 +1,354 @@
+import axios from 'axios';
+import { createCanvas, loadImage } from 'canvas';
+import logger from '../../utils/logger/loggerModule.js';
+
+const WIDTH = 1600;
+const HEIGHT = 1200;
+const PANEL_RADIUS = 26;
+const IMAGE_TIMEOUT_MS = Math.max(2_000, Number(process.env.RPG_PROFILE_CANVAS_TIMEOUT_MS) || 6_000);
+const IMAGE_CACHE_TTL_MS = Math.max(2 * 60 * 1000, Number(process.env.RPG_PROFILE_CANVAS_CACHE_TTL_MS) || 10 * 60 * 1000);
+const IMAGE_CACHE_LIMIT = Math.max(20, Number(process.env.RPG_PROFILE_CANVAS_CACHE_LIMIT) || 80);
+
+const imageCache = globalThis.__omnizapProfileCanvasImageCache instanceof Map ? globalThis.__omnizapProfileCanvasImageCache : new Map();
+globalThis.__omnizapProfileCanvasImageCache = imageCache;
+
+const TYPE_COLORS = new Map([
+  ['normal', '#a8a77a'],
+  ['fire', '#ee8130'],
+  ['water', '#6390f0'],
+  ['electric', '#f7d02c'],
+  ['grass', '#7ac74c'],
+  ['ice', '#96d9d6'],
+  ['fighting', '#c22e28'],
+  ['poison', '#a33ea1'],
+  ['ground', '#e2bf65'],
+  ['flying', '#a98ff3'],
+  ['psychic', '#f95587'],
+  ['bug', '#a6b91a'],
+  ['rock', '#b6a136'],
+  ['ghost', '#735797'],
+  ['dragon', '#6f35fc'],
+  ['dark', '#705746'],
+  ['steel', '#b7b7ce'],
+  ['fairy', '#d685ad'],
+]);
+
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
+const toInt = (value, fallback = 0) => {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? Math.trunc(numeric) : fallback;
+};
+
+const toText = (value, fallback = 'N/D') => {
+  if (value === null || value === undefined) return fallback;
+  const text = String(value).trim();
+  return text || fallback;
+};
+
+const trimText = (value, max = 120) => {
+  const text = String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!text) return '';
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(16, max - 1)).trimEnd()}…`;
+};
+
+const drawRoundRect = (ctx, x, y, width, height, radius, fillStyle) => {
+  ctx.beginPath();
+  ctx.moveTo(x + radius, y);
+  ctx.lineTo(x + width - radius, y);
+  ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
+  ctx.lineTo(x + width, y + height - radius);
+  ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+  ctx.lineTo(x + radius, y + height);
+  ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
+  ctx.lineTo(x, y + radius);
+  ctx.quadraticCurveTo(x, y, x + radius, y);
+  ctx.closePath();
+  if (fillStyle) {
+    ctx.fillStyle = fillStyle;
+    ctx.fill();
+  }
+};
+
+const cleanupImageCache = () => {
+  if (imageCache.size <= IMAGE_CACHE_LIMIT) return;
+  const now = Date.now();
+  for (const [key, value] of imageCache.entries()) {
+    if (!value || value.expiresAt <= now) imageCache.delete(key);
+  }
+  while (imageCache.size > IMAGE_CACHE_LIMIT) {
+    const oldest = imageCache.keys().next().value;
+    imageCache.delete(oldest);
+  }
+};
+
+const resolveImage = async (url) => {
+  const normalized = String(url || '').trim();
+  if (!normalized) return null;
+
+  const cached = imageCache.get(normalized);
+  if (cached && cached.expiresAt > Date.now()) return cached.image;
+
+  try {
+    const response = await axios.get(normalized, {
+      responseType: 'arraybuffer',
+      timeout: IMAGE_TIMEOUT_MS,
+      validateStatus: (status) => status >= 200 && status < 400,
+    });
+    const image = await loadImage(Buffer.from(response.data));
+    imageCache.set(normalized, {
+      image,
+      expiresAt: Date.now() + IMAGE_CACHE_TTL_MS,
+    });
+    cleanupImageCache();
+    return image;
+  } catch (error) {
+    logger.debug('Falha ao carregar imagem para perfil canvas.', {
+      url: normalized,
+      error: error.message,
+    });
+    return null;
+  }
+};
+
+const drawProgressBar = ({ ctx, x, y, width, height, progressPct = 0, color = '#22d3ee', background = 'rgba(15,23,42,0.75)' }) => {
+  drawRoundRect(ctx, x, y, width, height, Math.min(14, Math.round(height / 2)), background);
+  const ratio = clamp(Number(progressPct) / 100, 0, 1);
+  if (ratio <= 0) return;
+  drawRoundRect(ctx, x + 2, y + 2, Math.max(0, (width - 4) * ratio), Math.max(0, height - 4), Math.min(12, Math.round((height - 4) / 2)), color);
+};
+
+const sanitizeProfileText = (text) => {
+  const raw = String(text || '');
+  return raw
+    .split('\n')
+    .map((line) =>
+      String(line || '')
+        .replace(/\*/g, '')
+        .replace(/\s+$/g, ''),
+    )
+    .filter((line, index, lines) => line || (index > 0 && lines[index - 1]));
+};
+
+const wrapLine = (ctx, line, maxWidth) => {
+  const text = String(line || '').trim();
+  if (!text) return [''];
+
+  const words = text.split(' ');
+  const wrapped = [];
+  let current = '';
+
+  for (const word of words) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (ctx.measureText(candidate).width <= maxWidth) {
+      current = candidate;
+      continue;
+    }
+    if (current) {
+      wrapped.push(current);
+      current = word;
+      continue;
+    }
+
+    let chunk = word;
+    while (chunk.length > 1 && ctx.measureText(chunk).width > maxWidth) {
+      const safeSize = Math.max(1, Math.floor((maxWidth / Math.max(1, ctx.measureText(chunk).width)) * chunk.length));
+      const part = chunk.slice(0, safeSize);
+      wrapped.push(`${part}…`);
+      chunk = chunk.slice(safeSize);
+    }
+    current = chunk;
+  }
+
+  if (current) wrapped.push(current);
+  return wrapped.length ? wrapped : [''];
+};
+
+const isHeaderLine = (line) => {
+  const value = String(line || '').trim();
+  if (!value) return false;
+  if (/^\d+\./.test(value)) return false;
+  if (value.startsWith('•')) return false;
+  return value.length <= 36;
+};
+
+export const renderProfileCanvasCard = async ({ trainerLabel = 'Treinador', generatedAtLabel = null, activePokemon = null, summary = {}, profileText = '' }) => {
+  const canvas = createCanvas(WIDTH, HEIGHT);
+  const ctx = canvas.getContext('2d');
+
+  const primaryType = String(activePokemon?.types?.[0] || '')
+    .trim()
+    .toLowerCase();
+  const accent = TYPE_COLORS.get(primaryType) || '#38bdf8';
+
+  const bgGradient = ctx.createLinearGradient(0, 0, WIDTH, HEIGHT);
+  bgGradient.addColorStop(0, '#0b1220');
+  bgGradient.addColorStop(0.55, '#111827');
+  bgGradient.addColorStop(1, '#1e293b');
+  ctx.fillStyle = bgGradient;
+  ctx.fillRect(0, 0, WIDTH, HEIGHT);
+
+  const glow = ctx.createRadialGradient(240, 240, 40, 240, 240, 560);
+  glow.addColorStop(0, `${accent}70`);
+  glow.addColorStop(1, 'rgba(2,6,23,0)');
+  ctx.fillStyle = glow;
+  ctx.fillRect(0, 0, WIDTH, HEIGHT);
+
+  const leftX = 40;
+  const leftY = 40;
+  const leftW = 470;
+  const leftH = HEIGHT - 80;
+  drawRoundRect(ctx, leftX, leftY, leftW, leftH, PANEL_RADIUS, 'rgba(2, 6, 23, 0.72)');
+
+  const rightX = leftX + leftW + 24;
+  const rightY = 40;
+  const rightW = WIDTH - rightX - 40;
+  const rightH = HEIGHT - 80;
+  drawRoundRect(ctx, rightX, rightY, rightW, rightH, PANEL_RADIUS, 'rgba(2, 6, 23, 0.65)');
+
+  ctx.fillStyle = '#e2e8f0';
+  ctx.font = '700 40px Sans';
+  ctx.fillText('PERFIL RPG', leftX + 30, leftY + 62);
+
+  ctx.fillStyle = '#94a3b8';
+  ctx.font = '500 22px Sans';
+  ctx.fillText(trimText(trainerLabel, 22), leftX + 30, leftY + 96);
+
+  const levelText = `Nivel ${toInt(summary?.level, 1)}`;
+  const goldText = `${toInt(summary?.gold, 0)} gold`;
+  ctx.fillStyle = '#f8fafc';
+  ctx.font = '700 28px Sans';
+  ctx.fillText(levelText, leftX + 30, leftY + 146);
+  ctx.fillText(goldText, leftX + 30, leftY + 184);
+
+  ctx.fillStyle = '#94a3b8';
+  ctx.font = '500 20px Sans';
+  const rankText = Number.isFinite(Number(summary?.pvpWeeklyRank)) ? `Rank PvP: #${toInt(summary?.pvpWeeklyRank, 0)}` : 'Rank PvP: sem rank';
+  const streakText = `Streak: ${toText(summary?.streakLabel, 'Sem historico')}`;
+  ctx.fillText(trimText(rankText, 34), leftX + 30, leftY + 220);
+  ctx.fillText(trimText(streakText, 34), leftX + 30, leftY + 248);
+
+  const xpProgressPct = clamp(toInt(summary?.xpProgressPct, 0), 0, 100);
+  drawProgressBar({
+    ctx,
+    x: leftX + 30,
+    y: leftY + 272,
+    width: leftW - 60,
+    height: 24,
+    progressPct: xpProgressPct,
+    color: accent,
+  });
+
+  ctx.fillStyle = '#e2e8f0';
+  ctx.font = '600 18px Sans';
+  ctx.fillText(`XP: ${toInt(summary?.xp, 0)} (${xpProgressPct}%)`, leftX + 30, leftY + 325);
+  if (toInt(summary?.xpToNextLevel, 0) > 0) {
+    ctx.fillText(`Faltam ${toInt(summary?.xpToNextLevel, 0)} XP para o nivel ${toInt(summary?.nextLevel, toInt(summary?.level, 1) + 1)}`, leftX + 30, leftY + 350);
+  } else {
+    ctx.fillText('Nivel maximo alcancado', leftX + 30, leftY + 350);
+  }
+
+  const spriteX = leftX + 30;
+  const spriteY = leftY + 380;
+  const spriteW = leftW - 60;
+  const spriteH = 330;
+  drawRoundRect(ctx, spriteX, spriteY, spriteW, spriteH, 22, 'rgba(15, 23, 42, 0.8)');
+
+  const image = await resolveImage(activePokemon?.imageUrl || activePokemon?.sprite || null);
+  if (image) {
+    const size = Math.min(spriteW - 36, spriteH - 36);
+    const drawX = spriteX + (spriteW - size) / 2;
+    const drawY = spriteY + (spriteH - size) / 2;
+    ctx.drawImage(image, drawX, drawY, size, size);
+  } else {
+    ctx.fillStyle = 'rgba(148, 163, 184, 0.2)';
+    drawRoundRect(ctx, spriteX + 18, spriteY + 18, spriteW - 36, spriteH - 36, 18, 'rgba(148, 163, 184, 0.14)');
+    ctx.fillStyle = '#94a3b8';
+    ctx.font = '600 22px Sans';
+    ctx.textAlign = 'center';
+    ctx.fillText('Imagem indisponivel', spriteX + spriteW / 2, spriteY + spriteH / 2 + 8);
+    ctx.textAlign = 'start';
+  }
+
+  const pokemonName = trimText(activePokemon?.displayName || activePokemon?.name || 'Sem Pokemon ativo', 28);
+  ctx.fillStyle = '#f8fafc';
+  ctx.font = '700 26px Sans';
+  ctx.fillText(pokemonName, leftX + 30, leftY + 748);
+
+  const hpCurrent = Math.max(0, toInt(activePokemon?.currentHp, 0));
+  const hpMax = Math.max(1, toInt(activePokemon?.maxHp, 1));
+  const typeText = Array.isArray(activePokemon?.types) && activePokemon.types.length ? activePokemon.types.join(', ') : 'tipo indefinido';
+  ctx.fillStyle = '#94a3b8';
+  ctx.font = '500 20px Sans';
+  ctx.fillText(`Lv.${Math.max(1, toInt(activePokemon?.level, 1))}  |  HP ${hpCurrent}/${hpMax}`, leftX + 30, leftY + 782);
+  ctx.fillText(trimText(`Tipos: ${typeText}`, 36), leftX + 30, leftY + 812);
+
+  if (generatedAtLabel) {
+    ctx.fillStyle = '#64748b';
+    ctx.font = '500 17px Sans';
+    ctx.fillText(`Atualizado em ${generatedAtLabel}`, leftX + 30, leftY + leftH - 24);
+  }
+
+  ctx.fillStyle = '#e2e8f0';
+  ctx.font = '700 34px Sans';
+  ctx.fillText('Informacoes do jogador', rightX + 28, rightY + 56);
+
+  ctx.fillStyle = '#94a3b8';
+  ctx.font = '500 18px Sans';
+  ctx.fillText('Resumo completo em duas colunas', rightX + 28, rightY + 84);
+
+  const textLines = sanitizeProfileText(profileText);
+  ctx.font = '500 20px Sans';
+
+  const contentTop = rightY + 122;
+  const contentBottom = rightY + rightH - 28;
+  const lineHeight = 24;
+  const colGap = 28;
+  const colWidth = Math.floor((rightW - 56 - colGap) / 2);
+  const colOneX = rightX + 28;
+  const colTwoX = colOneX + colWidth + colGap;
+  const maxLinesPerCol = Math.max(1, Math.floor((contentBottom - contentTop) / lineHeight));
+  const maxLines = maxLinesPerCol * 2;
+
+  const wrapped = [];
+  for (const line of textLines) {
+    const normalized = String(line || '');
+    if (!normalized.trim()) {
+      wrapped.push('');
+      continue;
+    }
+    const segments = wrapLine(ctx, normalized, colWidth - 2);
+    segments.forEach((segment) => wrapped.push(segment));
+  }
+
+  const truncated = wrapped.length > maxLines;
+  const visible = wrapped.slice(0, maxLines);
+  if (truncated && visible.length) {
+    visible[visible.length - 1] = '... use /rpg perfil para ver texto completo';
+  }
+
+  visible.forEach((line, index) => {
+    const colIndex = Math.floor(index / maxLinesPerCol);
+    const rowIndex = index % maxLinesPerCol;
+    const x = colIndex === 0 ? colOneX : colTwoX;
+    const y = contentTop + rowIndex * lineHeight;
+
+    if (!line) return;
+
+    if (isHeaderLine(line)) {
+      ctx.fillStyle = '#f8fafc';
+      ctx.font = '700 20px Sans';
+      ctx.fillText(trimText(line, 64), x, y);
+      return;
+    }
+
+    ctx.fillStyle = '#cbd5e1';
+    ctx.font = '500 19px Sans';
+    ctx.fillText(trimText(line, 94), x, y);
+  });
+
+  return canvas.toBuffer('image/png', { compressionLevel: 4 });
+};

package/app/modules/statsModule/globalRankingCommand.js

@@ -0,0 +1,65 @@
+import logger from '../../utils/logger/loggerModule.js';
+import { resolveBotJid } from '../../config/baileysConfig.js';
+import { isWhatsAppUserId } from '../../services/lidMapService.js';
+import { buildRankingMessage, getRankingReport, renderRankingImage } from './rankingCommon.js';
+import { sendAndStore } from '../../services/messagePersistenceService.js';
+
+const RANKING_LIMIT = 5;
+const RENDER_TIMEOUT_MS = 15000;
+
+const withTimeout = (promise, timeoutMs) =>
+  Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Tempo limite excedido (${timeoutMs}ms)`)), timeoutMs);
+    }),
+  ]);
+
+/**
+ * Handler do comando de ranking global.
+ * @param {object} params
+ * @param {object} params.sock
+ * @param {string} params.remoteJid
+ * @param {object} params.messageInfo
+ * @param {number|undefined} params.expirationMessage
+ * @param {boolean|undefined} params.isGroupMessage
+ * @returns {Promise<void>}
+ */
+export async function handleGlobalRankingCommand({ sock, remoteJid, messageInfo, expirationMessage, isGroupMessage: _isGroupMessage }) {
+  try {
+    const botJid = resolveBotJid(sock?.user?.id);
+    const report = await getRankingReport({
+      scope: 'global',
+      botJid,
+      limit: RANKING_LIMIT,
+      includeTopType: false,
+      enrichRows: false,
+    });
+    const text = buildRankingMessage({ scope: 'global', limit: RANKING_LIMIT, ...report });
+    const mentions = report.rows.map((row) => row.mention_id).filter((jid) => isWhatsAppUserId(jid));
+
+    try {
+      const imageBuffer = await withTimeout(
+        renderRankingImage({
+          sock,
+          remoteJid,
+          rows: report.rows,
+          totalMessages: report.totalMessages,
+          topType: report.topType,
+          scope: 'global',
+          limit: RANKING_LIMIT,
+        }),
+        RENDER_TIMEOUT_MS,
+      );
+      await sendAndStore(sock, remoteJid, { image: imageBuffer, caption: text, ...(mentions.length ? { mentions } : {}) }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+    } catch (renderError) {
+      logger.warn('Falha/timeout ao renderizar imagem do ranking global; enviando somente texto.', {
+        error: renderError?.message,
+      });
+      await sendAndStore(sock, remoteJid, { text, ...(mentions.length ? { mentions } : {}) }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+    }
+  } catch (error) {
+    logger.error('Erro ao gerar ranking global:', { error: error.message });
+    await sendAndStore(sock, remoteJid, { text: `Erro ao gerar ranking global: ${error.message}` }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+  }
+}

package/app/modules/statsModule/noMessageCommand.js

@@ -0,0 +1,288 @@
+import { executeQuery } from '../../../database/index.js';
+import logger from '../../utils/logger/loggerModule.js';
+import { getGroupParticipants, isUserAdmin } from '../../config/groupUtils.js';
+import { resolveBotJid } from '../../config/baileysConfig.js';
+import {
+  primeLidCache,
+  resolveUserIdCached,
+  isLidUserId,
+  isWhatsAppUserId,
+} from '../../services/lidMapService.js';
+import { sendAndStore } from '../../services/messagePersistenceService.js';
+
+const getParticipantJid = (participant) =>
+  participant?.id || participant?.jid || participant?.lid || null;
+
+const MAX_MENTIONS_PER_MESSAGE = 80;
+const BATCH_DELAY_MS = 400;
+
+const parseMinMessages = (text = '') => {
+  const tokens = text.trim().split(/\s+/).filter(Boolean);
+  let min = null;
+  tokens.forEach((token) => {
+    const minMatch = /^min=(\d+)$/i.exec(token);
+    if (minMatch) {
+      min = Number(minMatch[1]);
+      return;
+    }
+    if (/^\d+$/.test(token) && min === null) {
+      min = Number(token);
+    }
+  });
+  if (!Number.isFinite(min)) return 1;
+  return Math.max(0, min);
+};
+
+const parsePeriod = (text = '') => {
+  const tokens = text.trim().split(/\s+/).filter(Boolean);
+  let days = null;
+  let all = false;
+  tokens.forEach((token) => {
+    const lower = token.toLowerCase();
+    if (lower === 'all') all = true;
+    const match = /^(\d+)d$/i.exec(lower);
+    if (match) {
+      days = Number(match[1]);
+    }
+  });
+  if (all || !days || days <= 0) {
+    return { sinceDate: null, label: 'histórico completo' };
+  }
+  const sinceDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+  return { sinceDate, label: `últimos ${days} dias` };
+};
+
+const fetchMessageCounts = async (remoteJid, sinceDate) => {
+  const params = [remoteJid];
+  let sql = 'SELECT sender_id, COUNT(*) AS total FROM messages WHERE chat_id = ?';
+  if (sinceDate) {
+    sql += ' AND created_at >= ?';
+    params.push(sinceDate);
+  }
+  sql += ' GROUP BY sender_id';
+  return executeQuery(sql, params);
+};
+
+const normalizeParticipant = (participant, sock) => {
+  const rawId = getParticipantJid(participant);
+  const participantAlt = participant?.participantAlt || participant?.jid || participant?.id || null;
+  const canonical = resolveUserIdCached({
+    lid: rawId,
+    jid: rawId,
+    participantAlt,
+  });
+  const contact =
+    (canonical && sock?.contacts?.[canonical]) ||
+    (participantAlt && sock?.contacts?.[participantAlt]) ||
+    (rawId && sock?.contacts?.[rawId]) ||
+    null;
+  const displayName =
+    participant?.notify || participant?.name || contact?.notify || contact?.name || contact?.short;
+  return {
+    rawId,
+    participantAlt,
+    canonical: canonical || rawId || null,
+    displayName: displayName || null,
+  };
+};
+
+const buildNoMessageText = ({
+  minMessages,
+  periodLabel,
+  totalParticipants,
+  totalListed,
+  batchIndex = 1,
+  batchTotal = 1,
+  batchSize = 0,
+}) => {
+  const title =
+    minMessages <= 1 ? '🔇 *Membros sem mensagens no grupo*' : '🔇 *Membros abaixo do mínimo*';
+  const lines = [
+    title,
+    '',
+    `• Mínimo de mensagens: ${minMessages}`,
+    `• Período: ${periodLabel}`,
+    `• Participantes: ${totalParticipants}`,
+    `• Abaixo do mínimo: ${totalListed}`,
+    ...(batchTotal > 1
+      ? [`• Parte: ${batchIndex}/${batchTotal}`, `• Notificados nesta mensagem: ${batchSize}`]
+      : []),
+  ];
+
+  if (!totalListed) {
+    lines.push('', '✅ Todos os membros atingiram o mínimo.');
+  }
+
+  return lines.join('\n');
+};
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const splitEntriesByMentions = (entries, maxMentions) => {
+  if (!maxMentions || maxMentions <= 0) return [entries];
+  const batches = [];
+  let current = [];
+  let mentionCount = 0;
+
+  entries.forEach((entry) => {
+    const needsMention = Boolean(entry.mentionJid);
+    if (current.length > 0 && needsMention && mentionCount + 1 > maxMentions) {
+      batches.push(current);
+      current = [];
+      mentionCount = 0;
+    }
+    current.push(entry);
+    if (needsMention) mentionCount += 1;
+  });
+
+  if (current.length) batches.push(current);
+  return batches;
+};
+
+export async function handleNoMessageCommand({
+  sock,
+  remoteJid,
+  messageInfo,
+  expirationMessage,
+  isGroupMessage,
+  senderJid,
+  text,
+}) {
+  if (!isGroupMessage) {
+    await sendAndStore(sock, 
+      remoteJid,
+      { text: 'Este comando so pode ser usado em grupos.' },
+      { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+    );
+    return;
+  }
+  if (!(await isUserAdmin(remoteJid, senderJid))) {
+    await sendAndStore(sock, 
+      remoteJid,
+      { text: 'Você não tem permissão para usar este comando.' },
+      { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+    );
+    return;
+  }
+
+  try {
+    const participants = await getGroupParticipants(remoteJid);
+    if (!participants || participants.length === 0) {
+      await sendAndStore(sock, 
+        remoteJid,
+        { text: 'Nao foi possivel obter os participantes do grupo.' },
+        { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+      );
+      return;
+    }
+
+    const minMessages = parseMinMessages(text || '');
+    const { sinceDate, label: periodLabel } = parsePeriod(text || '');
+    const senderRows = await fetchMessageCounts(remoteJid, sinceDate);
+    const senderIds = senderRows.map((row) => row.sender_id).filter(Boolean);
+
+    const lidsToPrime = new Set();
+    senderIds.forEach((id) => {
+      if (isLidUserId(id)) lidsToPrime.add(id);
+    });
+    participants.forEach((participant) => {
+      const rawId = getParticipantJid(participant);
+      if (isLidUserId(rawId)) lidsToPrime.add(rawId);
+    });
+    if (lidsToPrime.size > 0) {
+      await primeLidCache(Array.from(lidsToPrime));
+    }
+
+    const countsByCanonical = new Map();
+    senderRows.forEach((row) => {
+      const rawId = row.sender_id;
+      if (!rawId) return;
+      const canonical = resolveUserIdCached({ lid: rawId, jid: rawId });
+      if (!canonical) return;
+      const total = Number(row.total || 0);
+      countsByCanonical.set(canonical, (countsByCanonical.get(canonical) || 0) + total);
+    });
+
+    const normalizedParticipants = new Map();
+    participants.forEach((participant) => {
+      const normalized = normalizeParticipant(participant, sock);
+      if (!normalized.canonical && !normalized.rawId) return;
+      const key = normalized.canonical || normalized.rawId;
+      if (!key) return;
+      if (!normalizedParticipants.has(key)) {
+        normalizedParticipants.set(key, normalized);
+      }
+    });
+
+    const botJid = resolveBotJid(sock?.user?.id);
+    const botCanonical = botJid ? resolveUserIdCached({ jid: botJid, lid: botJid }) : null;
+
+    const entries = [];
+    normalizedParticipants.forEach((participant) => {
+      const canonical = participant.canonical || participant.rawId;
+      if (!canonical) return;
+      if (botCanonical && canonical === botCanonical) return;
+      const total = countsByCanonical.get(canonical) || 0;
+      if (total >= minMessages) return;
+      const mentionJid = isWhatsAppUserId(canonical)
+        ? canonical
+        : isWhatsAppUserId(participant.participantAlt)
+        ? participant.participantAlt
+        : null;
+      entries.push({
+        canonical,
+        rawId: participant.rawId,
+        mentionJid,
+      });
+    });
+
+    const totalParticipants = normalizedParticipants.size;
+    const totalListed = entries.length;
+    const batches = splitEntriesByMentions(entries, MAX_MENTIONS_PER_MESSAGE);
+    if (!batches.length) {
+      const responseText = buildNoMessageText({
+        minMessages,
+        periodLabel,
+        totalParticipants,
+        totalListed,
+      });
+      await sendAndStore(sock, 
+        remoteJid,
+        { text: responseText },
+        { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+      );
+      return;
+    }
+
+    for (let index = 0; index < batches.length; index += 1) {
+      const batch = batches[index];
+      const batchMentions = Array.from(
+        new Set(batch.map((entry) => entry.mentionJid).filter(Boolean)),
+      );
+      const responseText = buildNoMessageText({
+        minMessages,
+        periodLabel,
+        totalParticipants,
+        totalListed,
+        batchIndex: index + 1,
+        batchTotal: batches.length,
+        batchSize: batch.length,
+      });
+      await sendAndStore(sock, 
+        remoteJid,
+        { text: responseText, mentions: batchMentions },
+        { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+      );
+      if (index < batches.length - 1) {
+        await sleep(BATCH_DELAY_MS);
+      }
+    }
+  } catch (error) {
+    logger.error('Erro ao buscar membros sem mensagens:', { error: error.message });
+    await sendAndStore(sock, 
+      remoteJid,
+      { text: `Erro ao buscar membros sem mensagens: ${error.message}` },
+      { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+    );
+  }
+}