Appraisal Data Discrepancy Detection Failures

class AppraisalQCValidator:
    """Validate appraisals against GSE requirements"""
    
    GLA_THRESHOLD_PCT = 0.05  # 5%
    GLA_THRESHOLD_ABS = 100   # sq ft
    
    def validate_appraisal(self, appraisal: dict) -> dict:
        """Comprehensive appraisal validation"""
        findings = []
        
        # Check GLA against county records
        gla_result = self.validate_gla(appraisal)
        if gla_result["discrepancy"]:
            findings.append(gla_result)
        
        # Check adjustment consistency
        adj_result = self.validate_adjustments(appraisal)
        findings.extend(adj_result["inconsistencies"])
        
        # Check market conditions
        market_result = self.validate_market_conditions(appraisal)
        if market_result["mismatch"]:
            findings.append(market_result)
        
        # Predict CU findings
        cu_prediction = self.predict_cu_findings(appraisal)
        
        return {
            "findings": findings,
            "finding_count": len(findings),
            "cu_risk_score": cu_prediction["risk_score"],
            "predicted_cu_flags": cu_prediction["flags"],
            "recommendation": "address_before_delivery" if findings else "proceed"
        }
    
    def validate_gla(self, appraisal: dict) -> dict:
        """Validate GLA against county records"""
        appraisal_gla = appraisal.get("subject_gla")
        
        # Fetch county data
        county_data = self.county_api.get_property(
            appraisal["subject_address"]
        )
        county_gla = county_data.get("finished_area")
        
        if not county_gla:
            return {"discrepancy": False, "note": "No county data available"}
        
        # Calculate discrepancy
        diff = abs(appraisal_gla - county_gla)
        diff_pct = diff / county_gla
        
        if diff > self.GLA_THRESHOLD_ABS or diff_pct > self.GLA_THRESHOLD_PCT:
            return {
                "discrepancy": True,
                "type": "gla_mismatch",
                "appraisal_value": appraisal_gla,
                "county_value": county_gla,
                "difference": diff,
                "difference_pct": diff_pct,
                "severity": "high" if diff_pct > 0.10 else "medium",
                "action": "Require explanation or re-measure"
            }
        
        return {"discrepancy": False}
    
    def validate_adjustments(self, appraisal: dict) -> dict:
        """Check adjustment consistency across comparables"""
        comps = appraisal.get("comparables", [])
        inconsistencies = []
        
        # Group comps by similar characteristics
        adjustment_types = ["location", "gla", "condition", "view"]
        
        for adj_type in adjustment_types:
            adjustments = []
            
            for i, comp in enumerate(comps):
                adj_value = comp.get(f"{adj_type}_adjustment", 0)
                characteristic = comp.get(adj_type)
                adjustments.append({
                    "comp": i + 1,
                    "adjustment": adj_value,
                    "characteristic": characteristic
                })
            
            # Check for inconsistencies
            # Same characteristic should have similar adjustments
            grouped = {}
            for adj in adjustments:
                key = adj["characteristic"]
                if key not in grouped:
                    grouped[key] = []
                grouped[key].append(adj)
            
            for characteristic, adj_list in grouped.items():
                if len(adj_list) > 1:
                    values = [a["adjustment"] for a in adj_list]
                    if max(values) - min(values) > 5000:  # $5K threshold
                        inconsistencies.append({
                            "type": f"{adj_type}_adjustment_inconsistency",
                            "characteristic": characteristic,
                            "adjustments": adj_list,
                            "variance": max(values) - min(values),
                            "severity": "medium"
                        })
        
        return {"inconsistencies": inconsistencies}
    
    def validate_market_conditions(self, appraisal: dict) -> dict:
        """Validate market conditions against actual data"""
        stated_conditions = appraisal.get("market_conditions", "").lower()
        
        # Get market data
        market_data = self.market_api.get_conditions(
            appraisal["subject_address"],
            months=6
        )
        
        # Determine actual conditions
        appreciation = market_data.get("price_appreciation_yoy", 0)
        median_dom = market_data.get("median_days_on_market", 0)
        
        if appreciation > 5 and median_dom < 30:
            actual_conditions = "increasing"
        elif appreciation < -3 or median_dom > 90:
            actual_conditions = "declining"
        else:
            actual_conditions = "stable"
        
        if actual_conditions != stated_conditions:
            return {
                "mismatch": True,
                "type": "market_conditions_mismatch",
                "stated": stated_conditions,
                "actual": actual_conditions,
                "data": {
                    "appreciation_yoy": appreciation,
                    "median_dom": median_dom
                },
                "severity": "medium"
            }
        
        return {"mismatch": False}