Straw Buyer Detection Failures

class StrawBuyerDetector:
    """Detect straw buyer fraud indicators"""
    
    def analyze_application(self, application: dict) -> dict:
        """Analyze application for straw buyer indicators"""
        
        indicators = []
        risk_score = 0
        
        # Property-borrower fit analysis
        fit_result = self.analyze_property_fit(application)
        if fit_result["mismatch"]:
            indicators.append(fit_result)
            risk_score += fit_result["risk_weight"]
        
        # Commute analysis
        commute_result = self.analyze_commute(application)
        if commute_result["implausible"]:
            indicators.append(commute_result)
            risk_score += commute_result["risk_weight"]
        
        # Gift fund analysis
        gift_result = self.analyze_gift_funds(application)
        if gift_result["suspicious"]:
            indicators.append(gift_result)
            risk_score += gift_result["risk_weight"]
        
        # Cross-application check
        cross_result = self.check_cross_application(application)
        if cross_result["linked"]:
            indicators.append(cross_result)
            risk_score += cross_result["risk_weight"]
        
        return {
            "straw_buyer_risk": min(risk_score, 1.0),
            "indicators": indicators,
            "recommendation": self.get_recommendation(risk_score)
        }
    
    def analyze_property_fit(self, application: dict) -> dict:
        """Analyze if property fits borrower profile"""
        
        income = application.get("annual_income", 0)
        property_value = application.get("property_value", 0)
        property_type = application.get("property_type")
        borrower_age = application.get("borrower_age")
        family_size = application.get("family_size", 1)
        
        issues = []
        
        # Income to property ratio
        if property_value > income * 7:
            issues.append("Property value high relative to income")
        
        # Property size vs family
        bedrooms = application.get("bedrooms", 0)
        if family_size == 1 and bedrooms >= 5:
            issues.append("Large property for single occupant")
        
        # First-time buyer with investment property
        if application.get("first_time_buyer") and property_type == "multi_unit":
            issues.append("First-time buyer purchasing multi-unit")
        
        return {
            "indicator": "property_fit",
            "mismatch": len(issues) > 0,
            "issues": issues,
            "risk_weight": len(issues) * 0.15
        }
    
    def analyze_commute(self, application: dict) -> dict:
        """Analyze commute plausibility for occupancy"""
        
        property_location = application.get("property_address")
        employer_location = application.get("employer_address")
        
        if not property_location or not employer_location:
            return {"implausible": False}
        
        # Calculate distance
        distance = self.calculate_distance(property_location, employer_location)
        
        # Check for remote work
        is_remote = application.get("remote_work", False)
        
        if distance > 100 and not is_remote:
            return {
                "indicator": "commute_analysis",
                "implausible": True,
                "distance_miles": distance,
                "issue": f"Property {distance} miles from employer, no remote work indicated",
                "risk_weight": 0.35
            }
        
        return {"implausible": False}
    
    def analyze_gift_funds(self, application: dict) -> dict:
        """Analyze gift funds for straw buyer indicators"""
        
        gifts = application.get("gift_funds", [])
        suspicious = False
        issues = []
        
        for gift in gifts:
            donor = gift.get("donor_relationship", "").lower()
            amount = gift.get("amount", 0)
            
            # Non-relative large gifts
            if donor not in ["parent", "grandparent", "sibling", "spouse"]:
                if amount > 10000:
                    issues.append({
                        "type": "non_relative_gift",
                        "donor": donor,
                        "amount": amount
                    })
                    suspicious = True
            
            # Gift equals exact down payment
            down_payment = application.get("down_payment")
            if amount == down_payment:
                issues.append({
                    "type": "gift_equals_down_payment",
                    "amount": amount
                })
        
        return {
            "indicator": "gift_fund_analysis",
            "suspicious": suspicious,
            "issues": issues,
            "risk_weight": 0.25 if suspicious else 0
        }
    
    def check_cross_application(self, application: dict) -> dict:
        """Check for links to other applications"""
        
        # Query database for linked applications
        links = self.find_linked_applications(
            employer=application.get("employer_name"),
            property_address=application.get("property_address"),
            gift_donor=self.get_gift_donors(application),
            closing_agent=application.get("closing_agent")
        )
        
        if len(links) > 2:
            return {
                "indicator": "cross_application",
                "linked": True,
                "linked_applications": len(links),
                "common_elements": self.identify_common_elements(links),
                "risk_weight": 0.40
            }
        
        return {"linked": False}