TRID Timing Violations

class TRIDComplianceChecker:
    """Check TRID timing and tolerance compliance"""
    
    FEDERAL_HOLIDAYS = [
        # List of federal holidays
        "2026-01-01",  # New Year's Day
        "2026-01-20",  # MLK Day
        # ... etc
    ]
    
    # Fee tolerance categories
    ZERO_TOLERANCE = [
        "origination_fee",
        "discount_points",
        "transfer_taxes"
    ]
    
    TEN_PERCENT_TOLERANCE = [
        "title_services",
        "required_services_borrower_cannot_shop"
    ]
    
    UNLIMITED_TOLERANCE = [
        "prepaid_interest",
        "property_insurance",
        "services_borrower_can_shop"
    ]
    
    def calculate_business_days(self, 
                                start_date: date, 
                                end_date: date) -> int:
        """Calculate business days between dates (TRID definition)"""
        business_days = 0
        current = start_date + timedelta(days=1)
        
        while current <= end_date:
            # TRID business day: Mon-Sat, excluding federal holidays
            if current.weekday() < 6:  # Not Sunday
                if current.isoformat() not in self.FEDERAL_HOLIDAYS:
                    business_days += 1
            current += timedelta(days=1)
        
        return business_days
    
    def check_le_timing(self, 
                        application_date: date,
                        le_delivery_date: date) -> dict:
        """Check Loan Estimate delivery timing"""
        business_days = self.calculate_business_days(
            application_date, 
            le_delivery_date
        )
        
        compliant = business_days <= 3
        
        return {
            "compliant": compliant,
            "application_date": application_date,
            "le_delivery_date": le_delivery_date,
            "business_days": business_days,
            "deadline": self.add_business_days(application_date, 3),
            "violation": None if compliant else "LE delivered late"
        }
    
    def check_cd_timing(self,
                        cd_delivery_date: date,
                        cd_delivery_method: str,
                        closing_date: date) -> dict:
        """Check Closing Disclosure timing"""
        # If mailed, add 3 calendar days for receipt
        if cd_delivery_method == "mail":
            receipt_date = cd_delivery_date + timedelta(days=3)
        else:
            receipt_date = cd_delivery_date
        
        business_days = self.calculate_business_days(
            receipt_date,
            closing_date
        )
        
        compliant = business_days >= 3
        
        return {
            "compliant": compliant,
            "cd_delivery": cd_delivery_date,
            "delivery_method": cd_delivery_method,
            "deemed_receipt": receipt_date,
            "closing_date": closing_date,
            "business_days_before_closing": business_days,
            "earliest_closing": self.add_business_days(receipt_date, 3),
            "violation": None if compliant else "CD waiting period not met"
        }
    
    def check_fee_tolerance(self,
                            le_fees: dict,
                            cd_fees: dict,
                            changed_circumstances: list) -> dict:
        """Check fee tolerance compliance"""
        violations = []
        
        for fee_name, cd_amount in cd_fees.items():
            le_amount = le_fees.get(fee_name, 0)
            difference = cd_amount - le_amount
            
            if difference <= 0:
                continue  # Decrease is always OK
            
            # Check tolerance category
            if fee_name in self.ZERO_TOLERANCE:
                # Zero tolerance - any increase is violation
                # Unless valid changed circumstance
                if not self.valid_changed_circumstance(
                    fee_name, changed_circumstances
                ):
                    violations.append({
                        "fee": fee_name,
                        "tolerance": "zero",
                        "le_amount": le_amount,
                        "cd_amount": cd_amount,
                        "increase": difference,
                        "violation": True
                    })
            
            elif fee_name in self.TEN_PERCENT_TOLERANCE:
                # 10% cumulative tolerance
                # Checked at category level, not individual fee
                pass  # Handled separately
        
        return {
            "compliant": len(violations) == 0,
            "violations": violations
        }
    
    def validate_changed_circumstance(self,
                                      cc_reason: str,
                                      documentation: list) -> dict:
        """Validate changed circumstance is documented"""
        valid_reasons = [
            "borrower_requested_change",
            "rate_lock",
            "new_information",
            "natural_disaster",
            "title_issue"
        ]
        
        required_docs = {
            "rate_lock": ["rate_lock_request", "lock_confirmation"],
            "borrower_requested_change": ["written_request"],
            "new_information": ["credit_supplement", "appraisal"]
        }
        
        if cc_reason not in valid_reasons:
            return {
                "valid": False,
                "reason": f"Invalid CC reason: {cc_reason}"
            }
        
        # Check documentation
        required = required_docs.get(cc_reason, [])
        found = [d for d in documentation if d in required]
        
        if len(found) < len(required):
            return {
                "valid": False,
                "reason": f"Missing documentation for {cc_reason}",
                "required": required,
                "found": found
            }
        
        return {"valid": True}

instructions: |
  ## TRID COMPLIANCE CHECKING
  
  BUSINESS DAY DEFINITION (TRID):
  - Monday through Saturday
  - EXCLUDING federal holidays
  - Sunday is NEVER a business day
  
  LOAN ESTIMATE TIMING:
  - Must deliver within 3 BUSINESS days of application
  - Application date = Day 0
  - Count forward: Mon-Sat, skip Sun + holidays
  
  CLOSING DISCLOSURE TIMING:
  - Borrower must RECEIVE 3 business days before closing
  - If mailed: Add 3 CALENDAR days for receipt
  - Then count 3 business days from receipt
  
  FEE TOLERANCES:
  - ZERO tolerance (cannot increase without valid CC):
    * Origination charges
    * Points
    * Transfer taxes
  
  - 10% tolerance (cumulative):
    * Title services
    * Required services borrower cannot shop
  
  - Unlimited (can increase any amount):
    * Prepaid interest
    * Insurance premiums
    * Services borrower shopped for
  
  CHANGED CIRCUMSTANCES (must be documented):
  - Borrower requested change
  - New information affecting eligibility
  - Natural disaster
  - Rate lock (requires lock request + confirmation)
  
  FLAG violations, don't auto-correct. Include:
  - Specific rule violated
  - Dates involved
  - Business day calculation
  - Recommended cure