Update endpoints/antibot.js

endpoints/antibot.js

@@ -5,254 +5,200 @@ const sharp = require("sharp");
 
 const buf = b => Buffer.from(b.replace(/^data:image\/\w+;base64,/, ""), "base64");
 
-// ==========================
-// FIXED LEET MAPPING
-// ==========================
-const LEET_MAP = {
-  'a': '4', 'e': '3', 'i': '1', 'o': '0', 's': '5', 't': '7', 'b': '8', 'g': '9', 'z': '2',
-  'A': '4', 'E': '3', 'I': '1', 'O': '0', 'S': '5', 'T': '7', 'B': '8', 'G': '9', 'Z': '2'
+const LEET = {
+  a:"4", e:"3", g:"9", i:"1", l:"1", o:"0", s:"5", t:"7", b:"8", z:"2",
+  "@":"4", "$":"5", "&":"8"
 };
 
-const ENGLISH_NUMBERS = {
-  'zero': '0', 'one': '1', 'two': '2', 'three': '3', 'four': '4', 'five': '5',
-  'six': '6', 'seven': '7', 'eight': '8', 'nine': '9', 'ten': '10',
-  'on': '1', 'tw': '2', 'thre': '3', 'fou': '4', 'fiv': '5', 
-  'si': '6', 'seve': '7', 'eigh': '8', 'nin': '9'
-};
-
-function cleanText(text) {
-  return text.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+function leetize(str) {
+  return str
+    .toLowerCase()
+    .split("")
+    .map(c => LEET[c] ?? c)
+    .join("");
 }
 
-function leetConvert(text) {
-  if (!text) return '';
-  
-  const clean = cleanText(text);
-  
-  // Check if it's an English number word
-  if (ENGLISH_NUMBERS[clean]) {
-    return ENGLISH_NUMBERS[clean];
-  }
-  
-  // Apply leet mapping
-  return clean.split('').map(char => LEET_MAP[char] || char).join('');
+function toAlpha(str) {
+  return str
+    .toLowerCase()
+    .replace(/0/g,"o")
+    .replace(/1/g,"i")
+    .replace(/3/g,"e")
+    .replace(/4/g,"a")
+    .replace(/5/g,"s")
+    .replace(/7/g,"t")
+    .replace(/8/g,"b")
+    .replace(/9/g,"g");
 }
 
-// ==========================
-// BETTER OCR PROCESSING
-// ==========================
-async function enhanceImage(imageBuffer, type = "soal") {
-  try {
-    let pipeline = sharp(imageBuffer);
-    
-    if (type === "soal") {
-      return pipeline
-        .resize({ width: 1000 })
-        .grayscale()
-        .linear(1.5, -40)
-        .normalize()
-        .sharpen({ sigma: 2 })
-        .median(2)
-        .threshold(128)
-        .toBuffer();
-    } else {
-      return pipeline
-        .resize({ width: 800 })
-        .grayscale()
-        .linear(1.3, -30)
-        .normalize()
-        .sharpen({ sigma: 1.5 })
-        .median(1)
-        .toBuffer();
+function levenshtein(a, b) {
+  const m = [];
+  for (let i = 0; i <= a.length; i++) {
+    m[i] = [i];
+    for (let j = 1; j <= b.length; j++) {
+      m[i][j] =
+        i === 0
+          ? j
+          : Math.min(
+              m[i - 1][j] + 1,
+              m[i][j - 1] + 1,
+              m[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+            );
     }
-  } catch (error) {
-    return imageBuffer;
   }
+  return m[a.length][b.length];
+}
+
+function similarity(a, b) {
+  const dist = levenshtein(a, b);
+  return 1 - dist / Math.max(a.length, b.length);
+}
+
+function classify(text) {
+  if (/^[0-9]+$/.test(text)) return "digit";
+  if (/^[A-Za-z]+$/.test(text)) return "word";
+  return "mixed";
+}
+
+async function preprocessSoal(b) {
+  return sharp(b)
+    .resize({ width: 1000 })
+    .grayscale()
+    .normalize()
+    .sharpen({ sigma: 2 })
+    .median(2)
+    .toBuffer();
+}
+
+async function preprocessBot(b) {
+  return sharp(b)
+    .resize({ width: 800 })
+    .grayscale()
+    .normalize()
+    .sharpen({ sigma: 1.5 })
+    .median(1)
+    .toBuffer();
 }
 
-async function reliableOCR(imageBuffer, mode = "soal") {
+async function ocr(buf, mode = "soal") {
+  const tmp = path.join(__dirname, "tmp_" + Date.now() + ".png");
+  fs.writeFileSync(tmp, buf);
+
+  const whitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@$&";
+
   try {
-    const config = {
-      tessedit_char_whitelist: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+    const r = await Tesseract.recognize(tmp, "eng", {
+      tessedit_char_whitelist: whitelist,
       tessedit_pageseg_mode: mode === "soal" ? "7" : "8",
       tessedit_ocr_engine_mode: "1"
-    };
-
-    const result = await Tesseract.recognize(imageBuffer, "eng", config);
-    return result.data.text.trim();
-  } catch (error) {
+    });
+    fs.unlinkSync(tmp);
+    return r.data.text.trim();
+  } catch {
+    fs.unlinkSync(tmp);
     return "";
   }
 }
 
-// ==========================
-// SIMPLE MATCHING ALGORITHM
-// ==========================
-function calculateMatch(soalText, botText) {
-  if (!soalText || !botText) return 0;
-  
-  // Exact match
-  if (soalText === botText) return 1.0;
-  
-  // Contains match
-  if (botText.includes(soalText) || soalText.includes(botText)) return 0.8;
-  
-  // Length similarity
-  const lengthDiff = Math.abs(soalText.length - botText.length);
-  const maxLength = Math.max(soalText.length, botText.length);
-  const lengthScore = 1 - (lengthDiff / maxLength);
-  
-  // Character match
-  let matchCount = 0;
-  const minLength = Math.min(soalText.length, botText.length);
-  for (let i = 0; i < minLength; i++) {
-    if (soalText[i] === botText[i]) matchCount++;
-  }
-  const charScore = matchCount / maxLength;
-  
-  return (lengthScore + charScore) / 2;
-}
-
-// ==========================
-// MAIN FUNCTION - IMPROVED
-// ==========================
-module.exports = async (data) => {
-  console.log("🔄 PROCESSING...");
-  
+module.exports = async data => {
   try {
-    // 1. PROCESS SOAL
-    const soalBuffer = buf(data.main);
-    const soalEnhanced = await enhanceImage(soalBuffer, "soal");
-    const soalOCR = await reliableOCR(soalEnhanced, "soal");
-    
-    console.log("📝 RAW SOAL OCR:", soalOCR);
-    
-    // Split soal into words (assuming space separation)
-    const soalWords = soalOCR.split(/\s+/).filter(w => w.length > 0).slice(0, 3);
-    
-    // If OCR failed to get 3 words, use fallback
-    while (soalWords.length < 3) {
-      soalWords.push(`word${soalWords.length + 1}`);
-    }
-    
-    const soalLeet = soalWords.map(leetConvert);
-    
-    console.log("🔤 SOAL WORDS:", soalWords);
-    console.log("🔢 SOAL LEET:", soalLeet);
-    
-    // 2. PROCESS BOTS
+    const soalImg = buf(data.main);
+    const soalProcessed = await preprocessSoal(soalImg);
+    const soalText = await ocr(soalProcessed, "soal");
+
+    const rawSoal = soalText
+      .split(/\s+/)
+      .filter(x => x)
+      .slice(0, 3);
+
+    const soalInfo = rawSoal.map(s => {
+      const type = classify(s);
+      const clean = s.replace(/[^A-Za-z0-9]/g,"");
+      return {
+        raw: clean,
+        type,
+        leet: leetize(clean),
+        alpha: toAlpha(clean)
+      };
+    });
+
     const botResults = [];
-    for (const bot of data.bots) {
-      const botBuffer = buf(bot.img);
-      const botEnhanced = await enhanceImage(botBuffer, "bot");
-      const botOCR = await reliableOCR(botEnhanced, "bot");
-      const botLeet = leetConvert(botOCR);
-      
+    for (const b of data.bots) {
+      const d = buf(b.img);
+      const p = await preprocessBot(d);
+      const t = await ocr(p, "bot");
+
+      const clean = t.replace(/[^A-Za-z0-9]/g,"");
+      const type = classify(clean);
+
       botResults.push({
-        id: bot.id,
-        text: botOCR || `bot${bot.id}`,
-        value: botLeet || `bot${bot.id}`
+        id: b.id,
+        raw: clean,
+        type,
+        leet: leetize(clean),
+        alpha: toAlpha(clean)
       });
     }
-    
-    console.log("🤖 BOT RESULTS:");
-    botResults.forEach(bot => {
-      console.log(`   ${bot.id}: "${bot.text}" -> "${bot.value}"`);
-    });
-    
-    // 3. SMART MATCHING
+
     const result = [];
-    const usedBots = new Set();
-    
-    console.log("\n🎯 MATCHING:");
-    
-    // Try to match each soal word with bots
-    for (let i = 0; i < soalLeet.length; i++) {
-      const soal = soalLeet[i];
-      
-      console.log(`\n   Soal ${i}: "${soal}"`);
-      
-      let bestMatch = null;
+    const used = new Set();
+
+    for (const s of soalInfo) {
+      let best = null;
       let bestScore = 0;
-      
-      for (const bot of botResults) {
-        if (usedBots.has(bot.id)) continue;
-        
-        const score = calculateMatch(soal, bot.value);
-        console.log(`     Bot ${bot.id} ("${bot.value}"): ${score.toFixed(2)}`);
-        
-        if (score > bestScore) {
+
+      for (const b of botResults) {
+        if (used.has(b.id) || !b.raw) continue;
+
+        let score = 0;
+
+        if (s.type === "digit" && b.type === "digit") {
+          if (s.raw === b.raw) score = 1.0;
+        } else {
+          const sa = s.alpha;
+          const ba = b.alpha;
+          score = similarity(sa, ba);
+        }
+
+        if (score > bestScore && score >= 0.3) {
           bestScore = score;
-          bestMatch = bot.id;
+          best = b.id;
         }
       }
-      
-      // Use threshold 0.3 for matching
-      if (bestMatch && bestScore >= 0.3) {
-        result.push(bestMatch);
-        usedBots.add(bestMatch);
-        console.log(`   ✅ MATCHED: Bot ${bestMatch}`);
+
+      if (best) {
+        used.add(best);
+        result.push(best);
       } else {
         result.push(null);
-        console.log(`   ❌ NO MATCH`);
       }
     }
-    
-    // 4. FILL EMPTY SLOTS
-    console.log("\n🔄 FILLING EMPTY SLOTS...");
-    
-    const unusedBots = botResults.filter(bot => !usedBots.has(bot.id));
-    
+
     for (let i = 0; i < result.length; i++) {
       if (result[i] === null) {
-        if (unusedBots.length > 0) {
-          result[i] = unusedBots.shift().id;
-          console.log(`   Filled slot ${i} with bot ${result[i]}`);
-        } else {
-          // Use any bot that hasn't been used twice
-          for (const bot of botResults) {
-            const usageCount = result.filter(id => id === bot.id).length;
-            if (usageCount < 2) {
-              result[i] = bot.id;
-              console.log(`   Reused bot ${bot.id} for slot ${i}`);
-              break;
-            }
+        for (const b of botResults) {
+          if (!used.has(b.id) && b.raw) {
+            result[i] = b.id;
+            used.add(b.id);
+            break;
           }
         }
       }
     }
-    
-    // Final check - ensure all slots filled
-    for (let i = 0; i < result.length; i++) {
-      if (result[i] === null) {
-        result[i] = botResults[0].id;
-        console.log(`   Emergency fill slot ${i} with bot ${result[i]}`);
-      }
-    }
-    
-    console.log("\n🎉 FINAL RESULT:", result);
-    
+
     return {
-      soal: soalWords,
-      soalLeet: soalLeet,
-      botResults: botResults,
-      result: result
+      soal: rawSoal,
+      soalInfo,
+      botResults,
+      result
     };
-    
-  } catch (error) {
-    console.error("💥 ERROR:", error);
-    
-    // Fallback: use first 3 bots
-    const fallbackResult = data.bots.slice(0, 3).map(bot => bot.id);
-    while (fallbackResult.length < 3) {
-      fallbackResult.push(data.bots[0]?.id || 1);
-    }
-    
+
+  } catch {
     return {
-      soal: ["text1", "text2", "text3"],
-      soalLeet: ["text1", "text2", "text3"],
-      botResults: data.bots.map(bot => ({ id: bot.id, text: "text", value: "text" })),
-      result: fallbackResult
+      soal: [],
+      soalInfo: [],
+      botResults: [],
+      result: []
     };
   }
 };