Update endpoints/antibot.js

endpoints/antibot.js

@@ -2,20 +2,31 @@ const fs = require('fs');
 const path = require('path');
 const { extractTextFromImage, uploadImageToHosting } = require('./imageProcessor');
 
+// Map angka kata -> digit
+const NUMBER_WORDS = {
+  'nol': '0', 'satu': '1', 'dua': '2', 'tiga': '3', 'empat': '4', 'lima': '5',
+  'enam': '6', 'tujuh': '7', 'delapan': '8', 'sembilan': '9', 'sepuluh': '10',
+  'sebelas': '11', 'belas': '', 'puluh': '', 'ratus': '', 'ribu': ''
+};
+
+// Simple leet replacements
+const LEET_MAP = {
+  '4': 'a', '@': 'a', '8': 'b', '3': 'e', '6': 'g', '1': 'i', '!': 'i', '0': 'o',
+  '5': 's', '$': 's', '7': 't', '+': 't', '2': 'z'
+};
+
+function safeString(s) {
+  return (s || '').toString();
+}
+
 async function extractTextFromBuffer(imageBuffer) {
   try {
-    if (!imageBuffer) {
-      throw new Error('No image buffer provided');
-    }
-    if (!Buffer.isBuffer(imageBuffer)) {
-      throw new Error('extractTextFromBuffer expects a Buffer');
-    }
+    if (!imageBuffer) throw new Error('No image buffer provided');
+    if (!Buffer.isBuffer(imageBuffer)) throw new Error('extractTextFromBuffer expects a Buffer');
 
     console.log('🖼️ DEBUG extractTextFromBuffer: Received buffer, size:', imageBuffer.length, 'bytes');
 
-    // Kirim buffer langsung ke extractTextFromImage (tidak perlu membuat file temporary)
     const result = await extractTextFromImage(imageBuffer);
-
     console.log('✅ DEBUG extractTextFromBuffer: Hasil ekstraksi:', result);
     return result;
   } catch (error) {
@@ -24,251 +35,160 @@ async function extractTextFromBuffer(imageBuffer) {
   }
 }
 
-function mapAnswer(soalArray, jawaban, botIndex) {
-  console.log(`🤖 DEBUG mapAnswer: Bot ${botIndex}, Jawaban: "${jawaban}"`);
-  return jawaban;
+function removeAccents(str) {
+  return safeString(str).normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+}
+
+function applyLeetMap(str) {
+  let out = '';
+  for (const ch of str) {
+    out += (LEET_MAP[ch] !== undefined) ? LEET_MAP[ch] : ch;
+  }
+  return out;
+}
+
+function wordsToNumbers(str) {
+  // Very simple conversion for single-word numbers in Indonesian (e.g., "tujuh" -> "7")
+  const tokens = str.split(/\s+/);
+  return tokens.map(t => {
+    const low = t.toLowerCase();
+    return NUMBER_WORDS[low] !== undefined ? NUMBER_WORDS[low] : t;
+  }).join(' ');
 }
 
 function normalizeText(text) {
-  const normalized = text.toLowerCase().replace(/[^\w\s]/g, '').trim();
-  console.log(`🔤 DEBUG normalizeText: "${text}" -> "${normalized}"`);
+  const original = safeString(text);
+  let normalized = removeAccents(original);
+  normalized = normalized.toLowerCase();
+  normalized = applyLeetMap(normalized);
+  // keep letters, numbers and spaces only
+  normalized = normalized.replace(/[^a-z0-9\s]/g, ' ').replace(/\s+/g, ' ').trim();
+  // map simple number words
+  normalized = wordsToNumbers(normalized);
+  console.log(`🔤 DEBUG normalizeText: "${original}" -> "${normalized}"`);
   return normalized;
 }
 
-function isValueMatch(value, targetSoal) {
-  console.log(`🔍 DEBUG isValueMatch: Value="${value}", Soal="${targetSoal}"`);
-  const numberMap = {
-    '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five',
-    '6': 'six', '7': 'seven', '8': 'eight', '9': 'nine', '10': 'ten',
-    'zero': '0', 'one': '1', 'two': '2', 'three': '3', 'four': '4', 'five': '5',
-    'six': '6', 'seven': '7', 'eight': '8', 'nine': '9', 'ten': '10',
-    'I': '1','II': '2','III': '3','IV': '4','V': '5','VI': '6','VII': '7','VIII': '8','IX': '9','X': '10',
-    'i': '1','ii': '2','iii': '3','iv': '4','v': '5','vi': '6','vii': '7','viii': '8','ix': '9','x': '10',
-    'slx': '6','s1x': '6','six': '6','f0ur': '4','f0r': '4','fuor': '4','f1ve': '5','fiv': '5','f1v': '5',
-    'e1ght': '8','elght': '8','eight': '8','n1ne': '9','n1n': '9','nne': '9','se7en': '7','sven': '7','seven': '7',
-    'thre': '3','tree': '3','thr33': '3','tw0': '2','to': '2','tw': '2','0ne': '1','on': '1','oen': '1'
-  };
-
-  const leetMap = {
-    'O': '0','o': '0','I': '1','i': '1','l': '1','Z': '2','z': '2','E': '3','e': '3',
-    'A': '4','a': '4','S': '5','s': '5','G': '6','g': '6','T': '7','t': '7','B': '8','b': '8',
-    'Q': '9','q': '9','U': '4','u': '4','R': '2','r': '2','N': '9','n': '9','V': '7','v': '7'
-  };
+// Levenshtein distance for fuzzy matching
+function levenshtein(a = '', b = '') {
+  const alen = a.length, blen = b.length;
+  if (alen === 0) return blen;
+  if (blen === 0) return alen;
+  const matrix = Array.from({ length: alen + 1 }, () => new Array(blen + 1));
+  for (let i = 0; i <= alen; i++) matrix[i][0] = i;
+  for (let j = 0; j <= blen; j++) matrix[0][j] = j;
+  for (let i = 1; i <= alen; i++) {
+    for (let j = 1; j <= blen; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return matrix[alen][blen];
+}
 
-  const normalizedValue = normalizeText(value);
-  const normalizedSoal = normalizeText(targetSoal);
+function similarity(a, b) {
+  a = safeString(a);
+  b = safeString(b);
+  if (a === b) return 1;
+  const dist = levenshtein(a, b);
+  const maxLen = Math.max(a.length, b.length);
+  return maxLen === 0 ? 1 : 1 - (dist / maxLen);
+}
 
-  if (normalizedValue === normalizedSoal) {
-    console.log('✅ DEBUG: Match exact normalized');
-    return true;
+function tryEvaluateMathExpression(s) {
+  // allow simple expressions like "3+4", " 7 - 2 ", "2 * (3+1)"
+  try {
+    const cleaned = s.replace(/[^0-9+\-*/().\s]/g, '');
+    if (!/[0-9]/.test(cleaned)) return null;
+    // eslint-disable-next-line no-new-func
+    const val = Function(`"use strict"; return (${cleaned});`)();
+    if (typeof val === 'number' && isFinite(val)) return String(val);
+    return null;
+  } catch {
+    return null;
   }
+}
 
-  const convertLeet = (text) => text.split('').map(char => leetMap[char] || char).join('');
-  const leetValue = convertLeet(value);
-  const leetSoal = convertLeet(targetSoal);
-  console.log(`🔢 DEBUG Leet: Value="${leetValue}", Soal="${leetSoal}"`);
+// compare OCR value with expected soal (question) with multiple heuristics
+function isValueMatch(value, soal, options = {}) {
+  const { fuzzyThreshold = 0.75 } = options;
+  console.log('🔍 DEBUG isValueMatch: Value="%s", Soal="%s"', value, soal);
+  if (!value && !soal) return false;
 
-  if (leetValue === normalizedSoal || normalizedValue === leetSoal || leetValue === leetSoal) {
-    console.log('✅ DEBUG: Match leet/normalized combination');
+  const vNorm = normalizeText(safeString(value));
+  const sNorm = normalizeText(safeString(soal));
+
+  // exact match
+  if (vNorm === sNorm) {
+    console.log('✅ DEBUG exact match');
     return true;
   }
 
-  const mappedValue = numberMap[normalizedValue] || numberMap[value] || normalizedValue;
-  const mappedSoal = numberMap[normalizedSoal] || numberMap[targetSoal] || normalizedSoal;
-  console.log(`🔄 DEBUG Number Map: Value="${mappedValue}", Soal="${mappedSoal}"`);
-
-  if (mappedValue === normalizedSoal || normalizedValue === mappedSoal || mappedValue === mappedSoal) {
-    console.log('✅ DEBUG: Match mapped combinations');
+  // try math evaluation for both sides
+  const vMath = tryEvaluateMathExpression(vNorm);
+  const sMath = tryEvaluateMathExpression(sNorm);
+  if (vMath !== null && sMath !== null && vMath === sMath) {
+    console.log('✅ DEBUG math match:', vMath);
     return true;
   }
-
-  const similarity = calculateSimilarity(normalizedValue, normalizedSoal);
-  console.log(`📊 DEBUG Similarity: ${similarity}`);
-  if (similarity >= 0.8) {
-    console.log('✅ DEBUG: Match similarity >= 0.8');
+  if (vMath !== null && sMath === null && vMath === sNorm) {
+    console.log('✅ DEBUG math->soal match:', vMath);
     return true;
   }
-
-  try {
-    const valueResult = evaluateSimpleMath(value);
-    const soalResult = evaluateSimpleMath(targetSoal);
-    console.log(`🧮 DEBUG Math: Value=${valueResult}, Soal=${soalResult}`);
-    if (valueResult !== null && soalResult !== null && valueResult === soalResult) {
-      console.log('✅ DEBUG: Match math evaluation');
-      return true;
-    }
-  } catch (e) {
-    console.log('❌ DEBUG Math evaluation failed');
+  if (sMath !== null && vMath === null && sMath === vNorm) {
+    console.log('✅ DEBUG soal->math match:', sMath);
+    return true;
   }
 
-  console.log('❌ DEBUG: No match found');
-  return false;
-}
-
-function calculateSimilarity(str1, str2) {
-  if (str1 === str2) return 1;
-  if (str1.length === 0 || str2.length === 0) return 0;
-  const longer = str1.length > str2.length ? str1 : str2;
-  const shorter = str1.length > str2.length ? str2 : str1;
-  if (longer.includes(shorter)) return shorter.length / longer.length;
-  let matches = 0;
-  for (let i = 0; i < shorter.length; i++) {
-    if (shorter[i] === longer[i]) matches++;
-  }
-  return matches / longer.length;
-}
-
-function evaluateSimpleMath(expression) {
-  if (!expression) return null;
-  const cleanExpr = expression.toString().replace(/[^\d+\-*/.()]/g, '');
-  if (!cleanExpr) return null;
-  try {
-    if (cleanExpr.length > 10) return null;
-    const result = Function(`"use strict"; return (${cleanExpr})`)();
-    return typeof result === 'number' ? result : null;
-  } catch (e) {
-    return null;
+  // numeric comparison if either is numeric
+  const vNum = parseFloat(vNorm);
+  const sNum = parseFloat(sNorm);
+  if (!isNaN(vNum) && !isNaN(sNum) && Math.abs(vNum - sNum) < 1e-9) {
+    console.log('✅ DEBUG numeric equal');
+    return true;
   }
-}
 
-function parseSoalText(text) {
-  console.log(`📝 DEBUG parseSoalText: Input text: "${text}"`);
-  const ignoreWords = [
-    'hi','how','are','you','hello','hey','tentu','berikut','adalah','teks','dari','gambar',
-    'dipisahkan','sesuai','permintaan','anda','hanya','berikan','jangan','tambahkan',
-    'kata','apapun','seperti','atau','penjelasan','lain','saja'
-  ];
-  const delimiters = /[.,:;\\/\\s]+/;
-  let parts = text.split(delimiters)
-    .filter(part => part.trim() !== '')
-    .filter(part => !ignoreWords.includes(part.toLowerCase()));
-
-  if (parts.length === 0) {
-    parts = text.split(/\s+/)
-      .filter(part => part.trim() !== '')
-      .filter(part => !ignoreWords.includes(part.toLowerCase()));
+  // fuzzy text similarity
+  const sim = similarity(vNorm, sNorm);
+  console.log('📊 DEBUG Similarity:', sim);
+  if (sim >= fuzzyThreshold) {
+    console.log('✅ DEBUG fuzzy match (threshold=', fuzzyThreshold, ')');
+    return true;
   }
 
-  parts = parts.filter(part => part.length <= 3 || !isNaN(part));
-  parts = parts.slice(0, 3);
-  console.log(`📝 DEBUG parseSoalText: Filtered parts (max 3):`, parts);
-  return parts;
-}
-
-async function antibot(data) {
-  console.log('🚀 DEBUG antibot: Memulai proses antibot');
-  console.log('📊 DEBUG: Data received - main:', data.main ? '✅' : '❌', 'bots:', data.bots?.length || 0);
-  try {
-    const { main, bots } = data;
-    console.log('🖼️ DEBUG: Processing main image...');
-    const mainBuffer = Buffer.from(main, 'base64');
-    const mainText = await extractTextFromBuffer(mainBuffer);
-    console.log('📄 DEBUG Main Text Result:', mainText);
-    if (!mainText.status) {
-      throw new Error('Gagal mengekstrak teks dari gambar utama: ' + mainText.response);
-    }
-
-    const soalArray = parseSoalText(mainText.response);
-    console.log(`📋 DEBUG: Soal array:`, soalArray);
-    if (soalArray.length === 0) {
-      throw new Error('Tidak ada soal yang terdeteksi');
-    }
-
-    const botResults = [];
-    console.log(`🤖 DEBUG: Processing ${bots.length} bots...`);
-    for (let i = 0; i < bots.length; i++) {
-      const bot = bots[i];
-      console.log(`🤖 DEBUG: Processing bot ${i+1}/${bots.length} - ID: ${bot.id}`);
-      try {
-        const botBuffer = Buffer.from(bot.img, 'base64');
-        const botText = await extractTextFromBuffer(botBuffer);
-        const mappedValue = mapAnswer(soalArray, botText.response, i);
-        botResults.push({ id: bot.id, text: botText.response, value: mappedValue, normalized: normalizeText(botText.response) });
-        console.log(`✅ DEBUG Bot ${bot.id}:`, { text: botText.response, value: mappedValue, normalized: normalizeText(botText.response) });
-      } catch (error) {
-        console.error(`❌ DEBUG Bot ${bot.id} Error:`, error.message);
-        botResults.push({ id: bot.id, text: '', value: '', normalized: '', error: error.message });
-      }
-    }
-
-    console.log('🔍 DEBUG: Starting matching process...');
-    const result = [];
-    const usedIds = new Set();
-    let successfulMatches = 0;
-
-    const availableSoal = [...soalArray];
-    for (const bot of botResults) {
-      let matchedSoal = null;
-      let matchIndex = -1;
-      if (bot.value && bot.value.trim() !== '') {
-        for (let i = 0; i < availableSoal.length; i++) {
-          if (isValueMatch(bot.value, availableSoal[i])) {
-            matchedSoal = availableSoal[i];
-            matchIndex = i;
-            successfulMatches++;
-            console.log(`✅ DEBUG: Bot ${bot.id} matched with soal "${matchedSoal}"`);
-            break;
-          }
-        }
-      }
-      if (matchedSoal) {
-        result.push({ id: bot.id, soal: matchedSoal, matchType: 'exact' });
-        availableSoal.splice(matchIndex, 1);
-        usedIds.add(bot.id);
-      } else {
-        result.push({ id: null, soal: '', matchType: 'none' });
-      }
-    }
-
-    console.log(`📊 DEBUG: Successful matches: ${successfulMatches}`);
-
-    if (successfulMatches >= 2) {
-      console.log('✅ DEBUG: Minimal 2 match terpenuhi, mengisi bot yang belum match');
-      for (let i = 0; i < result.length; i++) {
-        if (!result[i].id && availableSoal.length > 0) {
-          const bot = botResults[i];
-          result[i].id = bot.id;
-          result[i].soal = availableSoal.shift();
-          result[i].matchType = 'fallback';
-          console.log(`🔄 DEBUG: Bot ${bot.id} diisi dengan soal tersisa`);
-        }
-      }
-    }
-
-    for (let i = 0; i < result.length; i++) {
-      if (!result[i].id) {
-        if (successfulMatches >= 2) {
-          result[i].id = botResults[i].id;
-          result[i].matchType = 'qualified';
-        } else {
-          result[i].id = 'invalid';
-          result[i].matchType = 'invalid';
-        }
+  // partial match: one contains the other with decent length
+  if (vNorm && sNorm) {
+    if (vNorm.includes(sNorm) || sNorm.includes(vNorm)) {
+      const longer = Math.max(vNorm.length, sNorm.length);
+      if (longer >= 3) {
+        console.log('✅ DEBUG partial contains match');
+        return true;
       }
     }
+  }
 
-    console.log('🎉 DEBUG: Process completed successfully');
-    console.log('📋 DEBUG Final Result:', result);
+  console.log('❌ DEBUG: No match found');
+  return false;
+}
 
-    return {
-      success: true,
-      data: {
-        soal: soalArray,
-        soalLeet: soalArray,
-        botResults: botResults,
-        result: result.map(r => ({ id: r.id })),
-        debug: {
-          parsedSoal: soalArray,
-          matches: result.map(r => ({ id: r.id, matchType: r.matchType, soal: r.soal })),
-          totalResults: result.length,
-          successfulMatches: successfulMatches
-        }
-      }
-    };
-  } catch (error) {
-    console.error('💥 DEBUG antibot Error:', error.message);
-    return { success: false, error: error.message, data: { soal: [], botResults: [], result: [] } };
+function mapAnswer(soalArray, jawaban, botIndex) {
+  console.log(`🤖 DEBUG mapAnswer: Bot ${botIndex}, Jawaban: "${jawaban}"`);
+  // jawaban can be object or string; normalize to string for now
+  if (jawaban && typeof jawaban === 'object' && jawaban.response) {
+    return jawaban.response;
   }
+  return jawaban;
 }
 
-module.exports = antibot;
+module.exports = {
+  extractTextFromBuffer,
+  mapAnswer,
+  normalizeText,
+  isValueMatch,
+  levenshtein,
+  similarity
+};