Income Calculation Errors

class MortgageIncomeCalculator:
    """Calculate qualifying income per mortgage guidelines"""
    
    PAY_FREQUENCIES = {
        "weekly": 52,
        "bi-weekly": 26,
        "semi-monthly": 24,
        "monthly": 12
    }
    
    OVERTIME_HISTORY_MONTHS = 24
    BONUS_HISTORY_MONTHS = 24
    PART_TIME_HISTORY_MONTHS = 24
    
    def calculate_salary_income(self, paystub: dict) -> dict:
        """Calculate salary income from paystub"""
        # Detect pay frequency
        frequency = self.detect_pay_frequency(paystub)
        periods_per_year = self.PAY_FREQUENCIES[frequency]
        
        # Use current period gross (not YTD for extrapolation issues)
        current_gross = paystub.get("current_gross")
        
        # Calculate annual
        annual_income = current_gross * periods_per_year
        monthly_income = annual_income / 12
        
        return {
            "annual": annual_income,
            "monthly": monthly_income,
            "frequency": frequency,
            "calculation": f"{current_gross} × {periods_per_year} periods"
        }
    
    def detect_pay_frequency(self, paystub: dict) -> str:
        """Detect pay frequency from paystub"""
        # Check explicit frequency field
        if paystub.get("pay_frequency"):
            return self.normalize_frequency(paystub["pay_frequency"])
        
        # Infer from dates
        start = paystub.get("period_start")
        end = paystub.get("period_end")
        
        if start and end:
            days = (end - start).days + 1
            
            if days == 7:
                return "weekly"
            elif days == 14:
                return "bi-weekly"
            elif days in [15, 16]:
                return "semi-monthly"
            elif days in range(28, 32):
                return "monthly"
        
        # Default to semi-monthly (most common)
        return "semi-monthly"
    
    def calculate_self_employment_income(self, 
                                         schedule_c: dict,
                                         years: int = 2) -> dict:
        """Calculate self-employment qualifying income"""
        net_profit = schedule_c.get("net_profit", 0)
        depreciation = schedule_c.get("depreciation", 0)
        amortization = schedule_c.get("amortization", 0)
        depletion = schedule_c.get("depletion", 0)
        
        # Qualifying income = Net + Non-cash deductions
        qualifying = net_profit + depreciation + amortization + depletion
        
        # If 2-year average required
        if years == 2 and schedule_c.get("prior_year"):
            prior = schedule_c["prior_year"]
            prior_qualifying = (
                prior.get("net_profit", 0) +
                prior.get("depreciation", 0)
            )
            qualifying = (qualifying + prior_qualifying) / 2
        
        return {
            "net_profit": net_profit,
            "add_backs": {
                "depreciation": depreciation,
                "amortization": amortization,
                "depletion": depletion
            },
            "qualifying_annual": qualifying,
            "qualifying_monthly": qualifying / 12
        }
    
    def calculate_overtime_income(self,
                                  paystubs: list,
                                  employment_months: int) -> dict:
        """Calculate overtime income if qualifying"""
        # Check history requirement
        if employment_months < self.OVERTIME_HISTORY_MONTHS:
            return {
                "qualifies": False,
                "reason": f"Only {employment_months} months history, "
                         f"need {self.OVERTIME_HISTORY_MONTHS}",
                "monthly": 0
            }
        
        # Calculate average
        ot_amounts = [p.get("overtime", 0) for p in paystubs]
        average = sum(ot_amounts) / len(ot_amounts)
        
        # Check for declining trend (last 6 months vs prior 6)
        if len(ot_amounts) >= 12:
            recent = sum(ot_amounts[-6:]) / 6
            prior = sum(ot_amounts[-12:-6]) / 6
            
            if recent < prior * 0.8:  # 20% decline
                return {
                    "qualifies": False,
                    "reason": "Declining overtime trend",
                    "monthly": 0
                }
        
        return {
            "qualifies": True,
            "monthly": average,
            "annual": average * 12
        }
    
    def validate_w2_extraction(self, w2: dict) -> dict:
        """Validate W-2 income extraction"""
        # Box 1 is qualifying wages
        box1 = w2.get("box1_wages", 0)
        
        # Box 12 codes are NOT added to Box 1
        # They're already excluded (401k, HSA, etc.)
        box12 = w2.get("box12", {})
        
        # Common error: adding Box 12 to Box 1
        if w2.get("extracted_total") and w2["extracted_total"] != box1:
            return {
                "error": "incorrect_total",
                "extracted": w2["extracted_total"],
                "correct": box1,
                "likely_cause": "Box 12 incorrectly added"
            }
        
        return {
            "valid": True,
            "qualifying_income": box1
        }

instructions: |
  ## MORTGAGE INCOME CALCULATION
  
  PAY FREQUENCY DETECTION:
  - Weekly: 7 days per period → 52 periods/year
  - Bi-weekly: 14 days → 26 periods/year
  - Semi-monthly: 15-16 days → 24 periods/year
  - Monthly: 28-31 days → 12 periods/year
  
  NEVER assume monthly. Always detect frequency.
  
  W-2 EXTRACTION:
  - Box 1 = Qualifying wages
  - Box 12 = PRE-TAX deductions (already excluded from Box 1)
  - NEVER add Box 12 to Box 1
  
  SELF-EMPLOYMENT:
  - Start with Schedule C net profit
  - ADD BACK: depreciation, amortization, depletion
  - These are non-cash expenses that don't reduce cash flow
  
  QUALIFYING RULES:
  - Overtime: Need 2-year history, check for declining trend
  - Bonus: Need 2-year history, average both years
  - Part-time: Need 2-year history
  - Commission: Need 2-year history, check declining trend
  
  If income type doesn't meet history requirement:
  - Flag it as non-qualifying
  - Calculate DTI both with and without
  
  ALWAYS output calculation steps for verification.