Name Change Documentation Failures

class NameChangeTracker:
    """Track and validate name changes across documents"""
    
    NAME_CHANGE_DOCUMENTS = [
        "marriage_certificate",
        "divorce_decree",
        "court_order_name_change",
        "ssa_name_change",
        "passport_with_prior_name",
        "drivers_license_with_prior_name"
    ]
    
    def build_name_timeline(self, documents: list) -> dict:
        """Build borrower's name timeline from documents"""
        
        timeline = {
            "names": [],
            "change_events": [],
            "current_name": None,
            "prior_names": []
        }
        
        # Extract names with dates from all documents
        name_occurrences = []
        
        for doc in documents:
            name = doc.get("borrower_name")
            date = doc.get("document_date")
            doc_type = doc.get("type")
            
            if name and date:
                name_occurrences.append({
                    "name": self.normalize_name(name),
                    "date": date,
                    "document": doc_type
                })
        
        # Sort by date
        name_occurrences.sort(key=lambda x: x["date"])
        
        # Identify name changes
        current_name = None
        for occurrence in name_occurrences:
            if current_name is None:
                current_name = occurrence["name"]
            elif occurrence["name"] != current_name:
                # Name changed
                timeline["change_events"].append({
                    "from": current_name,
                    "to": occurrence["name"],
                    "approximate_date": occurrence["date"],
                    "detected_in": occurrence["document"]
                })
                timeline["prior_names"].append(current_name)
                current_name = occurrence["name"]
        
        timeline["current_name"] = current_name
        timeline["names"] = list(set(
            [n["name"] for n in name_occurrences]
        ))
        
        return timeline
    
    def validate_name_changes(self, 
                              timeline: dict,
                              documents: list) -> dict:
        """Validate name changes have supporting documentation"""
        
        validation_results = []
        
        for change in timeline["change_events"]:
            # Look for supporting documentation
            support_doc = self.find_name_change_document(
                documents,
                change["from"],
                change["to"],
                change["approximate_date"]
            )
            
            if support_doc:
                validation_results.append({
                    "change": change,
                    "documented": True,
                    "document": support_doc["type"],
                    "status": "verified"
                })
            else:
                validation_results.append({
                    "change": change,
                    "documented": False,
                    "document": None,
                    "status": "requires_documentation",
                    "action": "Request name change documentation"
                })
        
        all_documented = all(r["documented"] for r in validation_results)
        
        return {
            "all_changes_documented": all_documented,
            "results": validation_results,
            "risk_score": 0.0 if all_documented else 0.3
        }
    
    def find_name_change_document(self,
                                  documents: list,
                                  name_from: str,
                                  name_to: str,
                                  change_date: date) -> dict:
        """Find document supporting name change"""
        
        for doc in documents:
            doc_type = doc.get("type", "").lower()
            
            # Check if it's a name change document type
            if not any(nc in doc_type for nc in self.NAME_CHANGE_DOCUMENTS):
                continue
            
            # Check date proximity
            doc_date = doc.get("document_date")
            if doc_date:
                days_diff = abs((doc_date - change_date).days)
                if days_diff > 365:  # Within 1 year
                    continue
            
            # Check names mentioned
            doc_names = doc.get("names_mentioned", [])
            from_found = any(
                self.names_match(name_from, n) for n in doc_names
            )
            to_found = any(
                self.names_match(name_to, n) for n in doc_names
            )
            
            if from_found and to_found:
                return doc
        
        return None
    
    def correlate_credit_akas(self, 
                              timeline: dict,
                              credit_report: dict) -> dict:
        """Correlate timeline with credit report AKAs"""
        
        akas = credit_report.get("aka_names", [])
        
        correlations = []
        unmatched_akas = []
        
        for aka in akas:
            normalized_aka = self.normalize_name(aka)
            
            # Check if AKA is in timeline
            found = False
            for name in timeline["names"]:
                if self.names_match(normalized_aka, name):
                    correlations.append({
                        "aka": aka,
                        "matched_to": name,
                        "status": "correlated"
                    })
                    found = True
                    break
            
            if not found:
                unmatched_akas.append(aka)
        
        return {
            "correlations": correlations,
            "unmatched_akas": unmatched_akas,
            "risk_score": len(unmatched_akas) * 0.15,
            "action": "Investigate unmatched AKAs" if unmatched_akas else None
        }