Name Variation Mishandling

class NameMatcher:
    """Match names across mortgage documents"""
    
    SUFFIX_VARIANTS = {
        "jr": ["jr", "jr.", "junior", "jnr"],
        "sr": ["sr", "sr.", "senior", "snr"],
        "ii": ["ii", "2nd", "second"],
        "iii": ["iii", "3rd", "third"],
        "iv": ["iv", "4th", "fourth"]
    }
    
    # Common transliterations
    TRANSLITERATIONS = {
        "mohammed": ["mohammed", "mohammad", "mohamed", "muhammed", "muhammad"],
        "william": ["william", "will", "bill", "billy", "wm"],
        "robert": ["robert", "rob", "bob", "bobby", "robt"],
        "elizabeth": ["elizabeth", "elisabeth", "liz", "beth", "betty"]
    }
    
    def normalize_name(self, name: str) -> dict:
        """Normalize name into components"""
        name = name.lower().strip()
        
        # Remove punctuation
        name = re.sub(r'[.,]', '', name)
        
        # Extract suffix
        suffix = None
        for canonical, variants in self.SUFFIX_VARIANTS.items():
            for variant in variants:
                if name.endswith(f" {variant}"):
                    suffix = canonical
                    name = name[:-len(variant)-1].strip()
                    break
        
        # Split into components
        parts = name.split()
        
        if len(parts) >= 3:
            return {
                "first": parts[0],
                "middle": parts[1:-1],
                "last": parts[-1],
                "suffix": suffix,
                "normalized": name
            }
        elif len(parts) == 2:
            return {
                "first": parts[0],
                "middle": [],
                "last": parts[1],
                "suffix": suffix,
                "normalized": name
            }
        else:
            return {
                "first": parts[0] if parts else "",
                "middle": [],
                "last": "",
                "suffix": suffix,
                "normalized": name
            }
    
    def match_names(self, name1: str, name2: str) -> dict:
        """Match two names with confidence score"""
        norm1 = self.normalize_name(name1)
        norm2 = self.normalize_name(name2)
        
        scores = {}
        
        # First name match
        scores["first"] = self.match_component(
            norm1["first"], 
            norm2["first"],
            allow_transliteration=True
        )
        
        # Last name match (strict)
        scores["last"] = self.match_component(
            norm1["last"],
            norm2["last"],
            allow_transliteration=False,
            strict=True
        )
        
        # Middle name match (flexible)
        scores["middle"] = self.match_middle_names(
            norm1["middle"],
            norm2["middle"]
        )
        
        # Suffix match
        scores["suffix"] = 1.0 if norm1["suffix"] == norm2["suffix"] else 0.8
        
        # Calculate overall confidence
        # Last name weighted heavily
        confidence = (
            scores["first"] * 0.25 +
            scores["last"] * 0.50 +
            scores["middle"] * 0.15 +
            scores["suffix"] * 0.10
        )
        
        return {
            "match": confidence >= 0.85,
            "confidence": confidence,
            "component_scores": scores,
            "risk_level": self.assess_risk(confidence, scores)
        }
    
    def match_component(self, 
                       comp1: str, 
                       comp2: str,
                       allow_transliteration: bool = False,
                       strict: bool = False) -> float:
        """Match individual name component"""
        
        if comp1 == comp2:
            return 1.0
        
        # Check for initial match (R. vs Robert)
        if len(comp1) == 1 and comp2.startswith(comp1):
            return 0.95
        if len(comp2) == 1 and comp1.startswith(comp2):
            return 0.95
        
        # Check transliterations
        if allow_transliteration:
            for canonical, variants in self.TRANSLITERATIONS.items():
                if comp1 in variants and comp2 in variants:
                    return 0.95
        
        # Phonetic similarity
        if not strict:
            if self.soundex(comp1) == self.soundex(comp2):
                return 0.80
        
        # Levenshtein distance
        distance = self.levenshtein(comp1, comp2)
        max_len = max(len(comp1), len(comp2))
        
        if max_len == 0:
            return 1.0
        
        similarity = 1 - (distance / max_len)
        
        # For strict matching, penalize more
        if strict and similarity < 0.95:
            return similarity * 0.5
        
        return similarity
    
    def match_middle_names(self, middle1: list, middle2: list) -> float:
        """Match middle names (very flexible)"""
        
        # Both empty
        if not middle1 and not middle2:
            return 1.0
        
        # One empty (middle name optional)
        if not middle1 or not middle2:
            return 0.90
        
        # Compare first middle names
        m1 = middle1[0] if middle1 else ""
        m2 = middle2[0] if middle2 else ""
        
        return self.match_component(m1, m2, allow_transliteration=True)
    
    def assess_risk(self, confidence: float, scores: dict) -> str:
        """Assess risk level based on match scores"""
        
        # Critical: Last name mismatch
        if scores["last"] < 0.9:
            return "high"
        
        # Medium: First name issues
        if scores["first"] < 0.8:
            return "medium"
        
        # Based on overall confidence
        if confidence >= 0.95:
            return "low"
        elif confidence >= 0.85:
            return "medium"
        else:
            return "high"