@transfergratis/react-native-sdk 0.1.28 → 0.1.30

package/src/modules/api/CardAuthentification.ts

@@ -1,25 +1,50 @@
 import kycService, { authentification, errorMessage, truncateFields } from "./KYCService";
-import { cropByObb, getCardInFrame, getObbConfidence, OBB_CONFIDENCE_THRESHOLD } from "../../utils/cropByObb";
+import { cropByObb, getObbConfidence, OBB_CONFIDENCE_THRESHOLD } from "../../utils/cropByObb";
 import { GovernmentDocumentType, IBbox } from "../../types/KYC.types";
 import { KycEnvironment } from "../../types/env.types";
 import { logger } from "../../utils/logger";
+import { countryData } from "../../config/countriesData";
 
-export async function frontVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, env: KycEnvironment = 'PRODUCTION') {
+// 1. Add this interface to tell TypeScript what the AI response actually looks like
+interface CardObbData {
+    obb: number[][];
+    confidence: number;
+    card_in_frame?: boolean;
+    cropped_sides?: string[];
+}
+
+interface ApiVerificationResponse {
+    result?: boolean;
+    detail?: any[];
+    card_obb?: CardObbData[] | any; 
+    [key: string]: any; 
+}
+
+export async function frontVerification(
+    result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, 
+    env: KycEnvironment = 'PRODUCTION'
+) {
     try {
         console.log("Front verification START", JSON.stringify({ result }, null, 2));
         logger.log("Front verification", JSON.stringify({ result }, null, 2));
         
-        // SANDBOX mode: skip AI verification and return mock response
+        // SANDBOX mode
         if (env === 'SANDBOX') {
             console.log("SANDBOX mode: Skipping AI verification for front document");
             logger.log("SANDBOX mode: Returning mock front verification response");
-            const mockBbox: IBbox = { minX: 50, minY: 50, width: 200, height: 200 };
+            const mockBbox: IBbox = { minX: 400, minY: 800, width: 2200, height: 1400 };
+            
             const mockResponse = {
                 result: true,
                 detail: [{ confidence: 0.95 }],
-                card_obb: { x: 50, y: 50, width: 200, height: 200 },
+                card_obb: [{
+                    obb: [[400,800], [2600,800], [2600,2200], [400,2200]],
+                    confidence: 0.95,
+                    card_in_frame: true,
+                    cropped_sides: []
+                }],
                 bbox: mockBbox,
-                ...(result.regionMapping.authMethod.includes('MRZ') ? {
+                ...(result.regionMapping?.authMethod?.includes('MRZ') ? {
                     mrz: {
                         success: true,
                         parsed_data: {
@@ -34,38 +59,78 @@ export async function frontVerification(result: { path?: string, regionMapping:
         }
         
         const token = await authentification();
-        const detected = await kycService.detectFaceOnId(result?.path || '', token, result?.selectedDocumentType || '', env)
+                
+        // Cast the response so TypeScript knows about card_obb
+        const detected = await kycService.detectFaceOnId(result?.path || '', token, result?.selectedDocumentType || '', env) as ApiVerificationResponse;
 
         if (!detected.result) {
             throw new Error('Aucun visage détecté sur la carte. Veuillez reprendre.');
         }
 
-        // If the backend indicates that the card is not fully in frame, stop early
-        const cardInFrame = getCardInFrame((detected as any).card_obb);
-        if (cardInFrame === false) {
-            // Use a stable error code; the UI maps this to a localized i18n message (cardNotFullyInFrame)
+        const cardData = detected.card_obb && Array.isArray(detected.card_obb) && detected.card_obb.length > 0 
+            ? detected.card_obb[0] 
+            : null;
+
+        let points = null;
+        let isCardInFrame = true;
+        let hasCroppedSides = false;
+
+        // Extract data safely
+        if (cardData) {
+            points = cardData.obb;
+            if (typeof cardData.card_in_frame !== 'undefined') {
+                isCardInFrame = cardData.card_in_frame === true;
+                hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
+            }
+        }
+
+        // --- 1. STRICT FRAMING CHECK (MUST HAPPEN FIRST) ---
+        if (!isCardInFrame || hasCroppedSides) {
+            logger.log(`Front Framing failed. Cropped sides detected.`);
             throw new Error('CARD_NOT_FULLY_IN_FRAME');
         }
 
-        const obbConfidence = getObbConfidence((detected as any).card_obb);
+        // --- 2. STRICT DISTANCE CHECK (ONLY RUNS IF FULLY IN FRAME) ---
+        if (points && points.length === 4) {
+            const getDistance = (p1: number[], p2: number[]) => Math.sqrt(Math.pow(p2[0] - p1[0], 2) + Math.pow(p2[1] - p1[1], 2));
+            const longestCardEdge = Math.max(getDistance(points[0], points[1]), getDistance(points[1], points[2]));
+
+            const maxX = Math.max(points[0][0], points[1][0], points[2][0], points[3][0]);
+            const maxY = Math.max(points[0][1], points[1][1], points[2][1], points[3][1]);
+            const estimatedImageScale = Math.max(maxX, maxY);
+
+            const fillPercentage = longestCardEdge / estimatedImageScale;
+            logger.log(`Front Card Fill Percentage: ${(fillPercentage * 100).toFixed(1)}%`);
+
+            if (fillPercentage < 0.50) { 
+                logger.log("🛑 Front Image rejected: Document is too far away.");
+                throw new Error("TOO_FAR_AWAY"); 
+            }
+        }
+
+    
+
+        
+
+        // Check Confidence Threshold
+        const obbConfidence = getObbConfidence(detected.card_obb);
         if (obbConfidence !== null && obbConfidence < OBB_CONFIDENCE_THRESHOLD) {
             throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
         }
 
-        // Optional: crop image using card_obb for better MRZ/barcode extraction (only when confidence >= threshold)
+        // Optional: crop image using card_obb for better MRZ/barcode extraction
         let croppedBase64: string | undefined;
         let bbox: IBbox | undefined;
         let mrz: any | undefined;
         try {
-            const crop = await cropByObb(result?.path || '', (detected as any).card_obb);
+            const crop = await cropByObb(result?.path || '', detected.card_obb);
             croppedBase64 = crop.base64;
             bbox = crop.bbox;
         } catch { }
 
-        if (result.regionMapping.authMethod.length > 0 && result.regionMapping.authMethod.includes('MRZ')) {
-
-
-            mrz = await kycService.extractMrzText(
+        // MRZ Extraction
+        if (result.regionMapping?.authMethod?.length > 0 && result.regionMapping.authMethod.includes('MRZ')) {
+            const mrzResponse = await kycService.extractMrzText(
                 {
                     fileUri: result.path || '',
                     docType: result?.selectedDocumentType || '',
@@ -75,154 +140,363 @@ export async function frontVerification(result: { path?: string, regionMapping:
                     template_path: result?.templatePath || '',
                     mrz_type: result?.mrzType || ''
                 },
-                env)
+                env
+            );
 
+            // Safety check: parse if it was returned as a raw string
+            mrz = typeof mrzResponse === 'string' ? JSON.parse(mrzResponse) : mrzResponse;
+
+            if (mrz && (!mrz.success || mrz.parsed_data?.status === 'FAILURE')) {
+                logger.log("🛑 Front MRZ Extraction Failed:", mrz.parsed_data?.status_message);
+                throw new Error(`MRZ illisible: ${mrz.parsed_data?.status_message || 'Veuillez nettoyer l\'objectif et réessayer'}`);
+            }
         }
 
         return { ...detected, croppedBase64, bbox, ...(mrz ? { mrz } : {}) };
     } catch (e: any) {
-        logger.error('Error front verification:', JSON.stringify(errorMessage(e), null, 2));
+        logger.error('Error front verification:', e?.message);
+        // Do not use LogBox for background silent errors
         throw new Error(e?.message || 'Erreur de détection du visage');
     }
 }
 
-export async function backVerification(result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, env: KycEnvironment = 'PRODUCTION') {
+// export async function frontVerification(
+//     result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, 
+//     env: KycEnvironment = 'PRODUCTION'
+// ) {
+//     try {
+//         console.log("Front verification START", JSON.stringify({ result }, null, 2));
+//         logger.log("Front verification", JSON.stringify({ result }, null, 2));
+        
+//         // SANDBOX mode
+//         if (env === 'SANDBOX') {
+//             console.log("SANDBOX mode: Skipping AI verification for front document");
+//             logger.log("SANDBOX mode: Returning mock front verification response");
+//             const mockBbox: IBbox = { minX: 400, minY: 800, width: 2200, height: 1400 };
+            
+//             // ==========================================
+//             // 🧪 TEST OVERRIDE (SANDBOX) 🧪
+//             // Immediately throw the error to test the UI
+//             // ==========================================
+//             throw new Error('CARD_NOT_FULLY_IN_FRAME'); 
+
+//             const mockResponse = {
+//                 result: true,
+//                 detail: [{ confidence: 0.95 }],
+//                 card_obb: [{
+//                     obb: [[400,800], [2600,800], [2600,2200], [400,2200]],
+//                     confidence: 0.95,
+//                     card_in_frame: false, // Hardcoded to false
+//                     cropped_sides: ['left', 'top'] // Hardcoded cropped sides
+//                 }],
+//                 bbox: mockBbox,
+//                 ...(result.regionMapping?.authMethod?.includes('MRZ') ? {
+//                     mrz: {
+//                         success: true,
+//                         parsed_data: {
+//                             status: 'success',
+//                             document_type: result.selectedDocumentType,
+//                             mrz_type: result.mrzType || 'TD1'
+//                         }
+//                     }
+//                 } : {})
+//             };
+//             return mockResponse;
+//         }
+        
+//         const token = await authentification();
+                
+//         // Cast the response so TypeScript knows about card_obb
+//         const detected = await kycService.detectFaceOnId(result?.path || '', token, result?.selectedDocumentType || '', env) as ApiVerificationResponse;
+
+//         // ==========================================
+//         // 🧪 TEST OVERRIDE (PRODUCTION) 🧪
+//         // Hijack the real API response and force it to look cropped
+//         // ==========================================
+//         if (detected.card_obb && Array.isArray(detected.card_obb) && detected.card_obb.length > 0) {
+//             detected.card_obb[0].card_in_frame = false;
+//             detected.card_obb[0].cropped_sides = ['left', 'top'];
+//             console.warn("⚠️ FORCING CROPPED ERROR FOR UI TESTING ⚠️");
+//         }
+//         // ==========================================
+
+//         if (!detected.result) {
+//             throw new Error('Aucun visage détecté sur la carte. Veuillez reprendre.');
+//         }
+
+//         const cardData = detected.card_obb && Array.isArray(detected.card_obb) && detected.card_obb.length > 0 
+//             ? detected.card_obb[0] 
+//             : null;
+
+//         // --- STRICT FRAMING CHECK ---
+//         if (cardData && typeof cardData.card_in_frame !== 'undefined') {
+//             const isCardInFrame = cardData.card_in_frame === true;
+//             const hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
+
+//             // If it is NOT in the frame, OR if any side is cropped, block progression
+//             if (!isCardInFrame || hasCroppedSides) {
+//                 logger.log(`Framing failed. Cropped sides: ${hasCroppedSides ? cardData.cropped_sides?.join(', ') : 'none'}`);
+//                 throw new Error('CARD_NOT_FULLY_IN_FRAME');
+//             }
+//         }
+
+//         // Check Confidence Threshold
+//         const obbConfidence = getObbConfidence(detected.card_obb);
+//         if (obbConfidence !== null && obbConfidence < OBB_CONFIDENCE_THRESHOLD) {
+//             throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+//         }
+
+//         // Optional: crop image using card_obb for better MRZ/barcode extraction
+//         let croppedBase64: string | undefined;
+//         let bbox: IBbox | undefined;
+//         let mrz: any | undefined;
+//         try {
+//             const crop = await cropByObb(result?.path || '', detected.card_obb);
+//             croppedBase64 = crop.base64;
+//             bbox = crop.bbox;
+//         } catch { }
+
+//         // MRZ Extraction
+//         if (result.regionMapping?.authMethod?.length > 0 && result.regionMapping.authMethod.includes('MRZ')) {
+//             mrz = await kycService.extractMrzText(
+//                 {
+//                     fileUri: result.path || '',
+//                     docType: result?.selectedDocumentType || '',
+//                     docRegion: result?.code || "",
+//                     postfix: result?.currentSide,
+//                     token: token,
+//                     template_path: result?.templatePath || '',
+//                     mrz_type: result?.mrzType || ''
+//                 },
+//                 env
+//             );
+//         }
+
+//         return { ...detected, croppedBase64, bbox, ...(mrz ? { mrz } : {}) };
+//     } catch (e: any) {
+//         logger.error('Error front verification:', JSON.stringify(errorMessage(e), null, 2));
+//         throw new Error(e?.message || 'Erreur de détection du visage');
+//     }
+// }
+
+
+export async function backVerification(
+    result: { path?: string, regionMapping: { authMethod: string[], mrzTypes: string[] }, selectedDocumentType: string, code: string, currentSide: string, templatePath?: string, mrzType?: string }, 
+    env: KycEnvironment = 'PRODUCTION'
+) {
     try {
         if (!result.path) throw new Error('No path provided');
         logger.log("result.regionMapping", result.regionMapping, result.currentSide, result.code);
         
-        // SANDBOX mode: skip AI verification and return mock response
         if (env === 'SANDBOX') {
             console.log("SANDBOX mode: Skipping AI verification for back document");
-            logger.log("SANDBOX mode: Returning mock back verification response");
-            const mockBbox: IBbox = { minX: 50, minY: 50, width: 200, height: 200 };
             
-            if (result.regionMapping.authMethod.includes('MRZ')) {
+            const mockBbox: IBbox = { minX: 400, minY: 800, width: 2200, height: 1400 };
+            const mockCardObb = [{
+                obb: [[400,800], [2600,800], [2600,2200], [400,2200]],
+                confidence: 0.95,
+                card_in_frame: true,
+                cropped_sides: []
+            }];
+            
+            if (result.regionMapping?.authMethod?.includes('MRZ')) {
                 return {
                     success: true,
-                    parsed_data: {
-                        status: 'success',
-                        document_type: result.selectedDocumentType,
-                        mrz_type: result.mrzType || 'TD1'
+                    mrz: { 
+                        success: true,
+                        parsed_data: {
+                            status: 'SUCCESS', 
+                            document_type: result.selectedDocumentType,
+                            mrz_type: result.mrzType || 'TD1'
+                        }
                     },
                     bbox: mockBbox,
-                    card_obb: { x: 50, y: 50, width: 200, height: 200 }
+                    card_obb: mockCardObb
                 };
-            } else if (result.regionMapping.authMethod.includes('2D_barcode')) {
+            } else if (result.regionMapping?.authMethod?.includes('2D_barcode')) {
                 return {
-                    barcode_data: 'SANDBOX_MOCK_BARCODE',
+                    success: true,
+                    barcode: { barcode_data: 'SANDBOX_MOCK_BARCODE' },
                     bbox: mockBbox,
-                    card_obb: { x: 50, y: 50, width: 200, height: 200 }
+                    card_obb: mockCardObb
                 };
             }
-            return { bbox: mockBbox };
+            return { success: true, bbox: mockBbox, card_obb: mockCardObb };
         }
         
         const token = await authentification();
 
+        logger.log("1. Checking template and framing for back document...");
+        
+        const templateResponse = await kycService.checkTemplateType({
+            fileUri: result.path,
+            docType: result.selectedDocumentType as any,
+            docRegion: result.code,
+            postfix: 'back',
+            token: token
+        }, env) as ApiVerificationResponse;
 
+        if (templateResponse.success === false || templateResponse.Error) {
+            logger.log("Backend returned an error:", templateResponse.Error);
+            throw new Error('Impossible de lire le document. Veuillez vous rapprocher et stabiliser la caméra.');
+        }
 
-        // Fonction helper pour essayer MRZ puis barcode en fallback
-        const tryMrzWithBarcodeFallback = async () => {
-            try {
+        const cardData = templateResponse?.card_obb && Array.isArray(templateResponse.card_obb) && templateResponse.card_obb.length > 0 
+            ? templateResponse.card_obb[0] 
+            : null;
 
-                logger.log("Tentative d'extraction MRZ");
-                const mrz = await kycService.extractMrzText({
-                    fileUri: result.path!,
-                    docType: result?.selectedDocumentType || '',
-                    docRegion: result?.code || '',
-                    postfix: 'back',
-                    token: token,
-                    template_path: result?.templatePath || '',
-                    mrz_type: result?.mrzType || ''
-                }, env);
-                const mrzObbConf = getObbConfidence((mrz as any).card_obb);
-                if (mrzObbConf !== null && mrzObbConf < OBB_CONFIDENCE_THRESHOLD) {
-                    throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
-                }
-                let bbox: IBbox | undefined;
-                let croppedBase64: string | undefined;
+        if (!cardData) {
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        }
 
-                try {
-                    const crop = await cropByObb(result?.path || '', (mrz as any).card_obb);
-                    bbox = crop.bbox;
-                    croppedBase64 = crop.base64;
+        let points = null;
+        let isCardInFrame = false; 
+        let hasCroppedSides = true; 
 
-                } catch { }
-                return { ...mrz, bbox, croppedBase64 }
-            } catch (mrzError: any) {
-                logger.log("MRZ échoué, tentative d'extraction barcode");
-                try {
-                    const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
-                    const barcodeObbConf = getObbConfidence((barcode as any).card_obb);
-                    if (barcodeObbConf !== null && barcodeObbConf < OBB_CONFIDENCE_THRESHOLD) {
-                        throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
-                    }
-                    return barcode;
-                } catch (barcodeError: any) {
-                    throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${barcodeError?.message}`);
+        // Safely extract coordinates and frame status
+        if (cardData.obb) { 
+            points = cardData.obb;
+            if (typeof cardData.card_in_frame !== 'undefined') {
+                isCardInFrame = cardData.card_in_frame === true;
+                hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
+            }
+        } else if (Array.isArray(cardData) && Array.isArray(cardData[0])) { 
+            points = cardData[0];
+            isCardInFrame = true; 
+            hasCroppedSides = false;
+            
+            if (points && points.length === 4) {
+                const minX = Math.min(...points.map((p: number[]) => p[0]));
+                const minY = Math.min(...points.map((p: number[]) => p[1]));
+                if (minX <= 15 || minY <= 15) {
+                    isCardInFrame = false;
+                    hasCroppedSides = true;
                 }
             }
-        };
+        }
+
+        // --- 2. STRICT FRAMING CHECK (MUST HAPPEN FIRST) ---
+        if (!isCardInFrame || hasCroppedSides) {
+            logger.log(`Back Framing failed. Coordinates hit image boundary.`);
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        }
 
+        // --- 3. STRICT DISTANCE CHECK (ONLY RUNS IF FULLY IN FRAME) ---
+        if (points && points.length === 4) {
+            const getDistance = (p1: number[], p2: number[]) => Math.sqrt(Math.pow(p2[0] - p1[0], 2) + Math.pow(p2[1] - p1[1], 2));
+            const longestCardEdge = Math.max(getDistance(points[0], points[1]), getDistance(points[1], points[2]));
+
+            const maxX = Math.max(points[0][0], points[1][0], points[2][0], points[3][0]);
+            const maxY = Math.max(points[0][1], points[1][1], points[2][1], points[3][1]);
+            const estimatedImageScale = Math.max(maxX, maxY);
+
+            const fillPercentage = longestCardEdge / estimatedImageScale;
+            logger.log(`Back Card Fill Percentage: ${(fillPercentage * 100).toFixed(1)}%`);
+
+            if (fillPercentage < 0.50) { 
+                logger.log("🛑 Back Image rejected: Document is too far away.");
+                throw new Error("TOO_FAR_AWAY"); 
+            }
+        }
+        
+        const obbConf = getObbConfidence(templateResponse?.card_obb);
+        if (obbConf !== null && obbConf < OBB_CONFIDENCE_THRESHOLD) {
+            throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+        }
 
+        const activeTemplatePath = templateResponse.template_path || result.templatePath || '';
+        
+        if (activeTemplatePath) {
+            const expectedCountryName = countryData[result.code]?.name_en || '';
+            const hasCodeMatch = activeTemplatePath.includes(`_${result.code}_`);
+            const hasNameMatch = expectedCountryName && activeTemplatePath.toLowerCase().includes(expectedCountryName.toLowerCase());
 
-        if (result.regionMapping.authMethod.length > 2 && (!result?.mrzType || result?.mrzType.length === 0)) {
-            return await tryMrzWithBarcodeFallback();
+            if (!hasCodeMatch && !hasNameMatch) {
+                logger.log(`Template mismatch! Expected country: ${result.code} (${expectedCountryName}), Detected: ${activeTemplatePath}`);
+                throw new Error(`Le document ne correspond pas au pays sélectionné (${result.code}).`);
+            }
         }
 
-        if (result.regionMapping.authMethod.length > 0 && result.regionMapping.authMethod.includes('MRZ') && result?.mrzType && result?.mrzType.length > 0) {
-            try {
+        logger.log("Framing and Country Template verified successfully. Proceeding to Data Extraction.");
+
+        const hasMrz = result.regionMapping?.authMethod?.includes('MRZ') || !result.regionMapping?.authMethod?.length;
+        const hasBarcode = result.regionMapping?.authMethod?.includes('2D_barcode');
 
-                let mrz: any | undefined;
-                mrz = await kycService.extractMrzText({
+        let extractionResult: any = {};
+
+        // --- 4. Try MRZ First (If required or default) ---
+        if (hasMrz) {
+            try {
+                logger.log("Tentative d'extraction MRZ");
+                const mrzResponse = await kycService.extractMrzText({
                     fileUri: result.path!,
                     docType: result?.selectedDocumentType || '',
                     docRegion: result?.code || '',
                     postfix: 'back',
                     token: token,
-                    template_path: result?.templatePath || '',
-                    mrz_type: result?.mrzType || ''
+                    template_path: activeTemplatePath, 
+                    mrz_type: result?.mrzType || '' // Safe to send empty string
                 }, env);
-                const mrzObbConf = getObbConfidence((mrz as any).card_obb);
-                if (mrzObbConf !== null && mrzObbConf < OBB_CONFIDENCE_THRESHOLD) {
-                    throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+                
+                const mrz = typeof mrzResponse === 'string' ? JSON.parse(mrzResponse) : mrzResponse;
+                
+                if (!mrz || !mrz.success || mrz.parsed_data?.status === 'FAILURE') {
+                    throw new Error(mrz?.parsed_data?.status_message || 'Lecture MRZ échouée');
                 }
-                let bbox: IBbox | undefined;
-                try {
-                    const crop = await cropByObb(result?.path || '', (mrz as any).card_obb);
-                    bbox = crop.bbox;
-                } catch { }
-                return { ...mrz, bbox };
-            } catch (mrzError: any) {
-                throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${mrzError?.message}`);
-            }
-        }
+                
+                extractionResult = { mrz };
 
-        if (result.regionMapping.authMethod.length > 0 && result.regionMapping.authMethod.includes('2D_barcode')) {
-            try {
-                logger.log("Tentative d'extraction barcode");
-                const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
-                const barcodeObbConf = getObbConfidence((barcode as any).card_obb);
-                if (barcodeObbConf !== null && barcodeObbConf < OBB_CONFIDENCE_THRESHOLD) {
-                    throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
+            } catch (mrzError: any) {
+                if (hasBarcode) {
+                    logger.log(`MRZ échoué (${mrzError?.message}), tentative d'extraction barcode...`);
+                    try {
+                        const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
+                        extractionResult = { barcode };
+                    } catch (barcodeError: any) {
+                        throw new Error(`MRZ et Barcode ont échoué. Veuillez stabiliser la carte.`);
+                    }
+                } else {
+                    throw new Error(`Lecture MRZ invalide: ${mrzError?.message}`);
                 }
-                let bbox: IBbox | undefined;
-                try {
-                    const crop = await cropByObb(result?.path || '', (barcode as any).card_obb);
-                    bbox = crop.bbox;
-                } catch { }
-                return { ...barcode, bbox };
-            } catch (barcodeError: any) {
-                throw new Error(`Barcode et MRZ ont échoué. Barcode: ${barcodeError?.message}, MRZ: ${barcodeError?.message}`);
             }
+        } 
+        // --- 5. Try Barcode Only ---
+        else if (hasBarcode) {
+             try {
+                logger.log("Tentative d'extraction barcode seule");
+                const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
+                extractionResult = { barcode };
+             } catch (e: any) {
+                 throw new Error(`Lecture Barcode échouée: ${e?.message}`);
+             }
         }
-        return null;
+
+        let bbox: IBbox | undefined;
+        let croppedBase64: string | undefined;
+
+        try {
+            const crop = await cropByObb(result?.path || '', templateResponse.card_obb);
+            bbox = crop.bbox;
+            croppedBase64 = crop.base64;
+        } catch { }
+
+        return { 
+            success: true,
+            ...extractionResult, 
+            bbox, 
+            croppedBase64, 
+            card_obb: templateResponse.card_obb 
+        };
+
     } catch (e: any) {
-        throw new Error(e?.message || 'Erreur de détection du MRZ ou barcode');
+        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME' || e?.message === 'TOO_FAR_AWAY') {
+            throw e; 
+        }
+        throw new Error(e?.message || 'Erreur de détection des données');
     }
 }
 
+
 /**
  * Check template type
  * @param result 
@@ -230,23 +504,86 @@ export async function backVerification(result: { path?: string, regionMapping: {
  */
 export async function checkTemplateType(result: { path?: string, docType: string, docRegion: string, postfix: string }, env: KycEnvironment = 'PRODUCTION') {
     try {
-        // SANDBOX mode: skip AI verification and return mock response
         if (env === 'SANDBOX') {
-            console.log("SANDBOX mode: Skipping AI template type check");
-            logger.log("SANDBOX mode: Returning mock template type response");
             return {
                 template_path: `templates/${result.docType}_${result.docRegion}_${result.postfix}.jpg`,
-                card_obb: { x: 50, y: 50, width: 200, height: 200 }
+                card_obb: [{
+                    obb: [[400,800], [2600,800], [2600,2200], [400,2200]],
+                    confidence: 0.95,
+                    card_in_frame: true,
+                    cropped_sides: []
+                }]
             };
         }
         
         const token = await authentification();
         const templateType = await kycService.checkTemplateType({ fileUri: result.path || '', docType: result?.docType as GovernmentDocumentType, docRegion: result?.docRegion || "", postfix: result?.postfix, token: token }, env);
 
+        if (templateType.success === false || templateType.Error) {
+            logger.log("Backend returned an error:", templateType.Error);
+            throw new Error('Impossible de lire le document. Veuillez vous rapprocher et stabiliser la caméra.');
+        }
+
+        const cardData = templateType.card_obb && Array.isArray(templateType.card_obb) && templateType.card_obb.length > 0 
+            ? templateType.card_obb[0] 
+            : null;
+
+        if (!cardData) {
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        }
+
+        // Default to FALSE so it must prove it is in the frame
+        let points = null;
+        let isCardInFrame = false; 
+        let hasCroppedSides = true; 
+
+        // Extract data safely based on API response format
+        if (cardData.obb) { 
+            points = cardData.obb;
+            if (typeof cardData.card_in_frame !== 'undefined') {
+                isCardInFrame = cardData.card_in_frame === true;
+                hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
+            }
+        } else if (Array.isArray(cardData) && Array.isArray(cardData[0])) { 
+            points = cardData[0];
+            isCardInFrame = true; // Passed initial existence check
+            hasCroppedSides = false;
+            
+            // MATH FALLBACK: Check if the coordinates are touching the absolute edge of the photo.
+            if (points && points.length === 4) {
+                const minX = Math.min(...points.map((p: number[]) => p[0]));
+                const minY = Math.min(...points.map((p: number[]) => p[1]));
+                // If any corner is within 15 pixels of the edge, it is physically cut off!
+                if (minX <= 15 || minY <= 15) {
+                    isCardInFrame = false;
+                    hasCroppedSides = true;
+                }
+            }
+        }
+
+        // --- 3. STRICT FRAMING CHECK (MUST HAPPEN FIRST) ---
+        if (!isCardInFrame || hasCroppedSides) {
+            logger.log(`Template Framing failed. Coordinates hit image boundary.`);
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        }
+
+      
+        const LPIPS_THRESHOLD = 0.75; 
+        
+        if (templateType.lpips_score !== undefined && templateType.lpips_score > LPIPS_THRESHOLD) {
+            logger.log(`🛑 Country Mismatch! LPIPS Score too high: ${templateType.lpips_score}`);
+            throw new Error(`Le document présenté ne correspond pas au pays sélectionné (${result.docRegion}).`);
+        }
+
         logger.log("templateType result", JSON.stringify(truncateFields(templateType), null, 2));
         return templateType;
     } catch (e: any) {
         logger.error('Error checking template type:', JSON.stringify(errorMessage(e), null, 2));
+        
+        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME' || e?.message?.includes('ne correspond pas')) {
+            throw e; 
+        }
+        
         throw new Error(e?.message || 'Erreur de vérification du template');
     }
 }