Barcode Data Mismatch

class BarcodeValidator:
    """Validate document barcodes against visible text"""
    
    DOCUMENT_BARCODE_FIELDS = {
        "w2": {
            "barcode_type": ["code128", "pdf417"],
            "fields": ["box1_wages", "box2_federal_tax", "ein"]
        },
        "tax_return": {
            "barcode_type": ["pdf417", "2d"],
            "fields": ["dcn", "agi", "ssn_last4"]
        },
        "bank_statement": {
            "barcode_type": ["qr"],
            "fields": ["account_hash", "ending_balance", "period"]
        },
        "pay_stub": {
            "barcode_type": ["code39", "qr"],
            "fields": ["net_pay", "employee_id"]
        }
    }
    
    def validate_document(self, document: dict) -> dict:
        """Validate barcode against OCR data"""
        
        doc_type = document.get("type")
        ocr_data = document.get("ocr_extracted")
        image = document.get("image")
        
        result = {
            "barcode_found": False,
            "barcode_decoded": False,
            "mismatches": [],
            "risk_score": 0.0
        }
        
        # Detect barcodes in document
        barcodes = self.detect_barcodes(image)
        
        if not barcodes:
            result["barcode_found"] = False
            # Some documents should have barcodes
            if doc_type in ["w2", "tax_return"]:
                result["risk_score"] = 0.15  # Missing expected barcode
            return result
        
        result["barcode_found"] = True
        
        # Decode each barcode
        for barcode in barcodes:
            decoded = self.decode_barcode(barcode)
            if decoded:
                result["barcode_decoded"] = True
                
                # Compare to OCR data
                mismatches = self.compare_to_ocr(
                    decoded, 
                    ocr_data,
                    doc_type
                )
                
                result["mismatches"].extend(mismatches)
        
        # Calculate risk
        if result["mismatches"]:
            # Any mismatch is critical
            result["risk_score"] = 0.5
            for mismatch in result["mismatches"]:
                if mismatch["type"] == "amount":
                    result["risk_score"] = min(
                        result["risk_score"] + 0.2, 
                        1.0
                    )
        
        return result
    
    def detect_barcodes(self, image) -> list:
        """Detect all barcodes in document image"""
        
        barcodes = []
        
        # Use pyzbar or similar library
        # decoded_objects = decode(image)
        
        # Detect different formats
        formats = ["code128", "code39", "pdf417", "qr", "datamatrix"]
        
        for fmt in formats:
            detected = self.detect_format(image, fmt)
            barcodes.extend(detected)
        
        return barcodes
    
    def decode_barcode(self, barcode: dict) -> dict:
        """Decode barcode data into structured format"""
        
        raw_data = barcode.get("data")
        barcode_type = barcode.get("type")
        
        # Parse based on format
        if barcode_type == "pdf417":
            return self.parse_pdf417(raw_data)
        elif barcode_type == "qr":
            return self.parse_qr(raw_data)
        elif barcode_type in ["code128", "code39"]:
            return self.parse_linear(raw_data)
        
        return {"raw": raw_data}
    
    def compare_to_ocr(self, 
                       barcode_data: dict,
                       ocr_data: dict,
                       doc_type: str) -> list:
        """Compare decoded barcode to OCR extracted data"""
        
        mismatches = []
        
        field_mapping = self.DOCUMENT_BARCODE_FIELDS.get(doc_type, {})
        fields_to_check = field_mapping.get("fields", [])
        
        for field in fields_to_check:
            barcode_value = barcode_data.get(field)
            ocr_value = ocr_data.get(field)
            
            if barcode_value is None or ocr_value is None:
                continue
            
            # Normalize for comparison
            bc_normalized = self.normalize_value(barcode_value)
            ocr_normalized = self.normalize_value(ocr_value)
            
            if bc_normalized != ocr_normalized:
                mismatch_type = "amount" if self.is_amount(field) else "text"
                
                mismatches.append({
                    "field": field,
                    "barcode_value": barcode_value,
                    "ocr_value": ocr_value,
                    "type": mismatch_type,
                    "variance": self.calculate_variance(
                        barcode_value, 
                        ocr_value
                    ) if mismatch_type == "amount" else None
                })
        
        return mismatches
    
    def normalize_value(self, value) -> str:
        """Normalize value for comparison"""
        if isinstance(value, (int, float)):
            return str(round(float(value), 2))
        return str(value).strip().lower()
    
    def is_amount(self, field: str) -> bool:
        """Check if field represents a monetary amount"""
        amount_fields = [
            "wages", "tax", "balance", "pay", "amount",
            "agi", "gross", "net", "withholding"
        ]
        return any(af in field.lower() for af in amount_fields)