QM/ATR Validation Failures

class QMATRValidator:
    """Validate QM and ATR compliance"""
    
    GENERAL_QM_DTI_LIMIT = 0.43
    
    POINTS_FEES_LIMITS = {
        100000: 0.03,  # 3% for loans >= $100k
        60000: 0.05,   # 5% for $60k-$100k
        20000: 0.08,   # 8% for $20k-$60k
        12500: 1000,   # $1,000 for $12.5k-$20k
        0: 0.08        # 8% for < $12.5k
    }
    
    PROHIBITED_FEATURES = [
        "negative_amortization",
        "interest_only",
        "balloon_payment",
        "term_over_30_years"
    ]
    
    def validate_qm_status(self, loan: dict) -> dict:
        """Determine if loan meets QM requirements"""
        issues = []
        
        # Check DTI
        dti = loan.get("dti", 0)
        if dti > self.GENERAL_QM_DTI_LIMIT:
            issues.append({
                "test": "dti",
                "value": dti,
                "limit": self.GENERAL_QM_DTI_LIMIT,
                "status": "exceeds_general_qm"
            })
        
        # Check points and fees
        pf_result = self.check_points_and_fees(loan)
        if not pf_result["compliant"]:
            issues.append(pf_result)
        
        # Check prohibited features
        for feature in self.PROHIBITED_FEATURES:
            if loan.get(feature):
                issues.append({
                    "test": "prohibited_feature",
                    "feature": feature,
                    "status": "qm_prohibited"
                })
        
        # Check term
        if loan.get("term_months", 0) > 360:
            issues.append({
                "test": "term",
                "value": loan["term_months"],
                "limit": 360,
                "status": "exceeds_30_years"
            })
        
        is_qm = len(issues) == 0
        
        return {
            "qm_eligible": is_qm,
            "qm_type": "general" if is_qm else "non_qm",
            "issues": issues,
            "safe_harbor": is_qm,
            "atr_documentation_required": not is_qm
        }
    
    def check_points_and_fees(self, loan: dict) -> dict:
        """Check points and fees against QM limits"""
        loan_amount = loan.get("loan_amount", 0)
        
        # Determine applicable limit
        limit_pct = 0.03  # Default
        for threshold, pct in sorted(self.POINTS_FEES_LIMITS.items(), reverse=True):
            if loan_amount >= threshold:
                limit_pct = pct
                break
        
        # Calculate points and fees
        points_fees = self.calculate_points_and_fees(loan)
        
        if isinstance(limit_pct, float):
            limit_amount = loan_amount * limit_pct
        else:
            limit_amount = limit_pct
        
        return {
            "test": "points_and_fees",
            "amount": points_fees,
            "limit": limit_amount,
            "limit_pct": limit_pct if isinstance(limit_pct, float) else None,
            "compliant": points_fees <= limit_amount
        }
    
    def calculate_points_and_fees(self, loan: dict) -> float:
        """Calculate total points and fees for QM test"""
        components = [
            loan.get("origination_fee", 0),
            loan.get("discount_points", 0),
            loan.get("broker_fees", 0),
            loan.get("lender_paid_compensation", 0)
        ]
        
        # Certain title insurance if creditor affiliated
        if loan.get("affiliated_title"):
            components.append(loan.get("title_insurance", 0))
        
        return sum(components)
    
    def validate_arm_underwriting(self, loan: dict) -> dict:
        """Validate ARM loan underwritten at max rate"""
        if not loan.get("is_arm"):
            return {"applicable": False}
        
        initial_rate = loan.get("initial_rate")
        first_cap = loan.get("first_adjustment_cap")
        periodic_cap = loan.get("periodic_cap")
        lifetime_cap = loan.get("lifetime_cap")
        
        # Calculate max rate in first 5 years
        max_first_adjustment = initial_rate + first_cap
        
        # For QM, must underwrite at this rate
        underwritten_rate = loan.get("qualifying_rate")
        
        if underwritten_rate < max_first_adjustment:
            return {
                "applicable": True,
                "compliant": False,
                "initial_rate": initial_rate,
                "max_first_5_years": max_first_adjustment,
                "underwritten_at": underwritten_rate,
                "issue": "Not underwritten at maximum rate"
            }
        
        return {
            "applicable": True,
            "compliant": True,
            "max_rate_considered": max_first_adjustment
        }