Update endpoints/antibot.js

endpoints/antibot.js

@@ -6,6 +6,10 @@ function mapAnswer(soalArray, jawaban, botIndex) {
   return jawaban;
 }
 
+function normalizeText(text) {
+  return text.toLowerCase().replace(/[^\w\s]/g, '').trim();
+}
+
 function isValueMatch(value, targetSoal) {
   const numberMap = {
     '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four',
@@ -16,21 +20,69 @@ function isValueMatch(value, targetSoal) {
     'VI': '6', 'VII': '7', 'VIII': '8', 'IX': '9', 'X': '10'
   };
 
-  const normalizedValue = value.toLowerCase().trim();
-  const normalizedSoal = targetSoal.toLowerCase().trim();
+  // Normalisasi teks
+  const normalizedValue = normalizeText(value);
+  const normalizedSoal = normalizeText(targetSoal);
 
+  // Cek exact match setelah normalisasi
   if (normalizedValue === normalizedSoal) return true;
 
-  const mappedValue = numberMap[normalizedValue] || numberMap[normalizedValue.toUpperCase()];
-  const mappedSoal = numberMap[normalizedSoal] || numberMap[normalizedSoal.toUpperCase()];
+  // Cek match dengan number mapping
+  const mappedValue = numberMap[normalizedValue] || numberMap[value] || normalizedValue;
+  const mappedSoal = numberMap[normalizedSoal] || numberMap[targetSoal] || normalizedSoal;
 
   if (mappedValue === normalizedSoal) return true;
   if (normalizedValue === mappedSoal) return true;
-  if (mappedValue === mappedSoal && mappedValue) return true;
+  if (mappedValue === mappedSoal) return true;
+
+  // Cek untuk operasi matematika sederhana
+  try {
+    const valueResult = evaluateSimpleMath(value);
+    const soalResult = evaluateSimpleMath(targetSoal);
+    
+    if (valueResult !== null && soalResult !== null && valueResult === soalResult) {
+      return true;
+    }
+  } catch (e) {
+    // Ignore math evaluation errors
+  }
 
   return false;
 }
 
+function evaluateSimpleMath(expression) {
+  if (!expression) return null;
+  
+  const cleanExpr = expression.toString().replace(/[^\d+\-*/.()]/g, '');
+  if (!cleanExpr) return null;
+  
+  try {
+    // Safety check untuk ekspresi yang terlalu kompleks
+    if (cleanExpr.length > 10) return null;
+    
+    // Gunakan Function constructor sebagai alternatif yang lebih aman dari eval
+    const result = Function(`"use strict"; return (${cleanExpr})`)();
+    return typeof result === 'number' ? result : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function parseSoalText(text) {
+  // Split dengan berbagai delimiter: . , : ; dan spasi
+  const delimiters = /[.,:;\\/\s]+/;
+  
+  // Split dan filter elemen kosong
+  let parts = text.split(delimiters).filter(part => part.trim() !== '');
+  
+  // Jika hasil split hanya 1 elemen, coba split dengan spasi saja
+  if (parts.length === 1) {
+    parts = text.split(/\s+/).filter(part => part.trim() !== '');
+  }
+  
+  return parts;
+}
+
 async function antibot(data) {
   try {
     const { main, bots } = data;
@@ -38,14 +90,16 @@ async function antibot(data) {
     const mainBuffer = Buffer.from(main, 'base64');
     const mainText = await extractTextFromImage(mainBuffer);
     
-    const soalText = mainText.response;
-    const soalArray = soalText.replace(/[,;]/g, ' ').split(' ').filter(n => n.trim());
+    // Parse soal dengan delimiter yang benar
+    const soalArray = parseSoalText(mainText.response);
     
-    const soalRaw = soalArray;
-    const soalLeet = soalArray;
+    if (soalArray.length === 0) {
+      throw new Error('Tidak ada soal yang terdeteksi');
+    }
 
     const botResults = [];
     
+    // Process semua bot
     for (let i = 0; i < bots.length; i++) {
       const bot = bots[i];
       try {
@@ -57,7 +111,8 @@ async function antibot(data) {
         botResults.push({
           id: bot.id,
           text: botText.response,
-          value: mappedValue
+          value: mappedValue,
+          normalized: normalizeText(botText.response)
         });
         
       } catch (error) {
@@ -66,17 +121,18 @@ async function antibot(data) {
           id: bot.id,
           text: '',
           value: '',
+          normalized: '',
           error: error.message
         });
       }
     }
 
-    // LOGIC BARU: Hitung yang cocok dulu
+    // LOGIC MATCHING YANG DIPERBAIKI
     const result = [];
     const usedIds = new Set();
     let matchedCount = 0;
 
-    // STEP 1: CARI YANG COCOK
+    // STEP 1: CARI YANG COCOK PERSIS
     for (let i = 0; i < soalArray.length; i++) {
       const targetSoal = soalArray[i];
       let foundId = null;
@@ -91,17 +147,45 @@ async function antibot(data) {
         }
       }
 
-      result.push({ id: foundId });
+      result.push({ 
+        id: foundId,
+        soal: targetSoal,
+        matchType: foundId ? 'exact' : 'none'
+      });
     }
 
-    // STEP 2: ISI BERDASARKAN LOGIC BARU
+    // STEP 2: CARI MATCH DENGAN NORMALIZATION (untuk kasus seperti "T!g3r" vs "tiger")
+    if (matchedCount < soalArray.length) {
+      for (let i = 0; i < result.length; i++) {
+        if (!result[i].id) {
+          const targetSoal = soalArray[i];
+          const normalizedSoal = normalizeText(targetSoal);
+          
+          for (const bot of botResults) {
+            if (!usedIds.has(bot.id) && bot.normalized && bot.normalized.trim() !== '') {
+              // Cek match setelah normalisasi
+              if (bot.normalized === normalizedSoal) {
+                result[i].id = bot.id;
+                result[i].matchType = 'normalized';
+                usedIds.add(bot.id);
+                matchedCount++;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // STEP 3: LOGIC FALLBACK BERDASARKAN MATCH COUNT
     if (matchedCount >= 2) {
-      // Kalo ada 2 atau 3 yang cocok, isi yang kosong dengan sisa bot
+      // Jika 2 atau lebih match, isi sisanya dengan bot yang tersisa
       for (let i = 0; i < result.length; i++) {
         if (!result[i].id) {
           for (const bot of botResults) {
             if (!usedIds.has(bot.id) && bot.value && bot.value.trim() !== '') {
               result[i].id = bot.id;
+              result[i].matchType = 'fallback';
               usedIds.add(bot.id);
               break;
             }
@@ -109,33 +193,41 @@ async function antibot(data) {
         }
       }
     } else if (matchedCount === 1) {
-      // Kalo cuma 1 yang cocok, yang kosong kasih "invalid"
+      // Jika hanya 1 match, yang lain diisi invalid
       for (let i = 0; i < result.length; i++) {
         if (!result[i].id) {
           result[i].id = 'invalid';
+          result[i].matchType = 'invalid';
         }
       }
     } else {
-      // Kalo ga ada yang cocok, semua kasih "invalid"
+      // Jika tidak ada match sama sekali, semua invalid
       for (let i = 0; i < result.length; i++) {
         result[i].id = 'invalid';
+        result[i].matchType = 'invalid';
       }
     }
 
-    // Pastikan semua slot terisi
+    // Final cleanup - pastikan semua slot terisi
     for (let i = 0; i < result.length; i++) {
       if (!result[i].id) {
         result[i].id = 'invalid';
+        result[i].matchType = 'invalid';
       }
     }
 
     return {
       success: true,
       data: {
-        soal: soalRaw,
-        soalLeet: soalLeet,
+        soal: soalArray,
+        soalLeet: soalArray, // Tetap sama untuk sekarang
         botResults: botResults,
-        result: result
+        result: result.map(r => ({ id: r.id })), // Hanya return id untuk kompatibilitas
+        debug: {
+          parsedSoal: soalArray,
+          matches: result.map(r => ({ id: r.id, matchType: r.matchType, soal: r.soal })),
+          totalMatches: matchedCount
+        }
       }
     };