Document Template Validation

from dataclasses import dataclass
from typing import List, Dict, Optional
from enum import Enum
import imagehash
from PIL import Image

class TemplateMatchResult(Enum):
    MATCH = "match"
    PARTIAL = "partial_match"
    MISMATCH = "mismatch"
    UNKNOWN = "unknown_template"

@dataclass
class TemplateCheckResult:
    element: str
    expected: str
    found: str
    status: str
    confidence: float

class DocumentTemplateValidator:
    """Validate documents against expected templates"""
    
    # Template definitions
    TEMPLATES = {
        "w2": {
            "required_elements": [
                "employer_ein", "employer_address", 
                "employee_ssn", "employee_address",
                "box1_wages", "box2_federal_tax"
            ],
            "layout": {
                "employer_section": "top_left",
                "employee_section": "top_right", 
                "wage_boxes": "middle",
                "tax_boxes": "lower"
            },
            "omb_number": "1545-0008",
            "valid_years": [2023, 2024, 2025]
        },
        "bank_statement": {
            "required_elements": [
                "institution_logo", "account_number",
                "statement_period", "beginning_balance",
                "ending_balance", "transaction_table"
            ],
            "institution_specific": True
        }
    }
    
    # Known institution templates
    INSTITUTION_TEMPLATES = {
        "chase": {
            "logo_hash": "abc123...",  # Perceptual hash
            "logo_position": "top_left",
            "account_format": r"\*{4}\d{4}",
            "font_family": "Chase Sans",
            "required_footer": ["FDIC", "JPMorgan Chase Bank"]
        },
        "wells_fargo": {
            "logo_hash": "def456...",
            "logo_position": "top_center",
            "account_format": r"\*{4}\d{4}",
            "required_footer": ["FDIC", "Wells Fargo Bank"]
        }
    }
    
    def validate_document(self, 
                         document: dict,
                         doc_type: str,
                         institution: Optional[str] = None) -> dict:
        """Validate document against expected template"""
        
        result = {
            "template_match": TemplateMatchResult.UNKNOWN,
            "checks": [],
            "issues": [],
            "risk_score": 0.0
        }
        
        template = self.TEMPLATES.get(doc_type)
        if not template:
            return result
        
        # Check required elements
        for element in template.get("required_elements", []):
            check = self.check_element(document, element)
            result["checks"].append(check)
            
            if check.status == "missing":
                result["issues"].append(f"missing_{element}")
                result["risk_score"] += 0.1
        
        # Check layout
        if layout := template.get("layout"):
            layout_check = self.verify_layout(document, layout)
            result["checks"].extend(layout_check)
            
            layout_issues = [c for c in layout_check if c.status != "correct"]
            if layout_issues:
                result["issues"].append("layout_mismatch")
                result["risk_score"] += 0.2
        
        # Check form version
        if "omb_number" in template:
            omb_check = self.verify_omb(document, template["omb_number"])
            result["checks"].append(omb_check)
            if omb_check.status != "correct":
                result["issues"].append("wrong_omb_number")
                result["risk_score"] += 0.15
        
        # Institution-specific validation
        if institution and template.get("institution_specific"):
            inst_result = self.validate_institution_template(
                document, 
                institution
            )
            result["checks"].extend(inst_result["checks"])
            result["issues"].extend(inst_result["issues"])
            result["risk_score"] += inst_result["risk_score"]
        
        # Determine overall match
        issue_count = len(result["issues"])
        if issue_count == 0:
            result["template_match"] = TemplateMatchResult.MATCH
        elif issue_count <= 2:
            result["template_match"] = TemplateMatchResult.PARTIAL
        else:
            result["template_match"] = TemplateMatchResult.MISMATCH
        
        result["risk_score"] = min(result["risk_score"], 1.0)
        
        return result
    
    def validate_institution_template(self,
                                      document: dict,
                                      institution: str) -> dict:
        """Validate against institution-specific template"""
        
        result = {
            "checks": [],
            "issues": [],
            "risk_score": 0.0
        }
        
        template = self.INSTITUTION_TEMPLATES.get(institution.lower())
        if not template:
            return result
        
        # Check logo
        if logo := document.get("logo_image"):
            logo_check = self.verify_logo(logo, template)
            result["checks"].append(logo_check)
            
            if logo_check.status == "mismatch":
                result["issues"].append("logo_mismatch")
                result["risk_score"] += 0.3
            elif logo_check.status == "low_quality":
                result["issues"].append("low_quality_logo")
                result["risk_score"] += 0.25
        
        # Check account format
        if account := document.get("account_number"):
            import re
            pattern = template.get("account_format", "")
            if not re.match(pattern, account):
                result["checks"].append(TemplateCheckResult(
                    element="account_format",
                    expected=pattern,
                    found=account,
                    status="mismatch",
                    confidence=0.9
                ))
                result["issues"].append("account_format_mismatch")
                result["risk_score"] += 0.2
        
        # Check required footer elements
        footer_text = document.get("footer_text", "").lower()
        for required in template.get("required_footer", []):
            if required.lower() not in footer_text:
                result["checks"].append(TemplateCheckResult(
                    element=f"footer_{required}",
                    expected=required,
                    found="missing",
                    status="missing",
                    confidence=0.95
                ))
                result["issues"].append(f"missing_footer_{required}")
                result["risk_score"] += 0.15
        
        return result
    
    def verify_logo(self, logo_image, template: dict) -> TemplateCheckResult:
        """Verify institution logo matches expected"""
        
        # Calculate perceptual hash
        try:
            img = Image.open(logo_image)
            logo_hash = str(imagehash.phash(img))
            expected_hash = template.get("logo_hash", "")
            
            # Compare hashes (lower distance = more similar)
            distance = imagehash.hex_to_hash(logo_hash) - \
                       imagehash.hex_to_hash(expected_hash)
            
            if distance < 5:
                status = "match"
            elif distance < 15:
                status = "similar"
            else:
                status = "mismatch"
            
            # Check resolution
            if img.width < 100 or img.height < 50:
                status = "low_quality"
            
            return TemplateCheckResult(
                element="logo",
                expected=expected_hash[:8],
                found=logo_hash[:8],
                status=status,
                confidence=1.0 - (distance / 64)
            )
            
        except Exception:
            return TemplateCheckResult(
                element="logo",
                expected="valid_logo",
                found="unreadable",
                status="error",
                confidence=0.0
            )
    
    def verify_layout(self, 
                      document: dict,
                      expected_layout: dict) -> List[TemplateCheckResult]:
        """Verify document layout matches expected"""
        
        results = []
        
        # Would use OCR bounding boxes to verify positions
        detected_layout = document.get("detected_layout", {})
        
        for element, expected_position in expected_layout.items():
            actual_position = detected_layout.get(element)
            
            if actual_position:
                match = self.positions_match(expected_position, actual_position)
                results.append(TemplateCheckResult(
                    element=f"layout_{element}",
                    expected=expected_position,
                    found=actual_position,
                    status="correct" if match else "incorrect",
                    confidence=0.8
                ))
            else:
                results.append(TemplateCheckResult(
                    element=f"layout_{element}",
                    expected=expected_position,
                    found="not_detected",
                    status="missing",
                    confidence=0.5
                ))
        
        return results
    
    def check_element(self, 
                      document: dict,
                      element: str) -> TemplateCheckResult:
        """Check if required element is present"""
        
        value = document.get(element)
        
        if value:
            return TemplateCheckResult(
                element=element,
                expected="present",
                found="present",
                status="present",
                confidence=1.0
            )
        else:
            return TemplateCheckResult(
                element=element,
                expected="present",
                found="missing",
                status="missing",
                confidence=1.0
            )
    
    def verify_omb(self, 
                   document: dict,
                   expected_omb: str) -> TemplateCheckResult:
        """Verify OMB number on IRS forms"""
        
        found_omb = document.get("omb_number", "")
        
        if found_omb == expected_omb:
            status = "correct"
        elif found_omb:
            status = "incorrect"
        else:
            status = "missing"
        
        return TemplateCheckResult(
            element="omb_number",
            expected=expected_omb,
            found=found_omb,
            status=status,
            confidence=1.0
        )
    
    def positions_match(self, expected: str, actual: str) -> bool:
        """Check if layout positions match"""
        
        return expected.lower() == actual.lower()