The Math of
2026 Taxation.

const BRACKETS_2026_SINGLE = [
  { low: 0,       high: 11600,   rate: 0.10  },
  { low: 11601,   high: 47150,   rate: 0.15  },
  { low: 47151,   high: 119400,  rate: 0.25  },
  { low: 119401,  high: 191950,  rate: 0.28  },
  { low: 191951,  high: 243700,  rate: 0.33  },
  { low: 243701,  high: 609350,  rate: 0.35  },
  { low: 609351,  high: Infinity, rate: 0.396 },
];

/**
 * Computes federal income tax using the cascading-bucket method.
 * @param {number} taxableIncome  - Income after all deductions & adjustments
 * @param {Array}  brackets       - Ordered bracket array for the filing status
 * @returns {{ tax: number, effectiveRate: number, marginalRate: number }}
 */
function computeFederalTax(taxableIncome, brackets) {
  if (taxableIncome <= 0) return { tax: 0, effectiveRate: 0, marginalRate: 0 };

  let totalTax = 0;
  let marginalRate = 0;

  for (const tier of brackets) {
    if (taxableIncome <= tier.low) break;

    // Only the income inside this tier is taxed at tier.rate
    const incomeInTier = Math.min(taxableIncome, tier.high) - tier.low;
    totalTax += incomeInTier * tier.rate;
    marginalRate = tier.rate;
  }

  const effectiveRate = totalTax / taxableIncome;
  return { tax: Math.round(totalTax), effectiveRate, marginalRate };
}

// Example: $150,000 taxable income, single filer
const result = computeFederalTax(150_000, BRACKETS_2026_SINGLE);
// → { tax: 32_268, effectiveRate: 0.215, marginalRate: 0.28 }
//   → Effective rate 21.5%, though marginal rate is 28%

const SE_CONSTANTS_2026 = {
  SS_WAGE_BASE:     174_900,    // Social Security ceiling
  SS_RATE:          0.124,      // 12.4% — employer + employee combined
  MEDICARE_RATE:    0.029,      // 2.9%
  ADDITIONAL_MED:   0.009,      // 0.9% above income threshold
  ADD_MED_THRESHOLD_SINGLE: 200_000,
  NET_EARNINGS_FACTOR: 0.9235,  // 92.35% — removes the "employer half" before calculation
};

function computeSelfEmploymentTax(netProfitFromBusiness, filingStatus = "single") {
  // Step 1: Net earnings from self-employment (92.35% of net profit)
  const netEarnings = netProfitFromBusiness * SE_CONSTANTS_2026.NET_EARNINGS_FACTOR;

  // Step 2: Social Security component — capped at wage base
  const ssEarnings = Math.min(netEarnings, SE_CONSTANTS_2026.SS_WAGE_BASE);
  const ssTax = ssEarnings * SE_CONSTANTS_2026.SS_RATE;

  // Step 3: Medicare — no ceiling
  const medicareTax = netEarnings * SE_CONSTANTS_2026.MEDICARE_RATE;

  // Step 4: Additional Medicare Tax on earnings above threshold
  const threshold = filingStatus === "mfj"
    ? 250_000
    : SE_CONSTANTS_2026.ADD_MED_THRESHOLD_SINGLE;

  const addlMedBase = Math.max(0, netEarnings - threshold);
  const addlMedicareTax = addlMedBase * SE_CONSTANTS_2026.ADDITIONAL_MED;

  const totalSETax = ssTax + medicareTax + addlMedicareTax;

  // Step 5: The deductible portion — half of SE tax reduces AGI
  const deductibleHalf = totalSETax / 2;

  return {
    totalSETax: Math.round(totalSETax),
    deductibleHalf: Math.round(deductibleHalf),
    ssComponent: Math.round(ssTax),
    medicareComponent: Math.round(medicareTax + addlMedicareTax),
  };
}

// The two-pass approach for circular dependency:
// Pass 1: Estimate SE tax ignoring the deductible half
// Pass 2: Subtract deductible half from AGI, recompute
// Converges in ≤3 iterations for all practical inputs

const QBI_THRESHOLDS_2026 = {
  single:  { low: 191_950, high: 241_950 },
  mfj:     { low: 383_900, high: 483_900 },
};

function computeQBIDeduction({
  qualifiedBusinessIncome,   // Net QBI from Schedule C / K-1
  taxableIncome,             // AFTER standard or itemized deduction
  w2WagesPaid,              // W-2 wages paid by the business (non-SSTBs above threshold)
  ubiaQualifiedProperty,    // Unadjusted Basis Immediately After Acquisition
  isSST B = false,           // Is this a Specified Service Trade or Business?
  filingStatus = "single",
}) {
  const { low, high } = QBI_THRESHOLDS_2026[filingStatus];

  // Zone 1: Below threshold — simple 20% of QBI
  if (taxableIncome <= low) {
    return Math.max(0, qualifiedBusinessIncome * 0.20);
  }

  // Zone 3 upper bound for SSTB: full phase-out
  if (isSSTB && taxableIncome >= high) return 0;

  // Reduction ratio for phase-out range (Zones 2 and partial 3)
  const ratio = Math.min(1, (taxableIncome - low) / (high - low));

  // W-2 wage limitation (for above-threshold non-SSTBs)
  const w2Limit       = w2WagesPaid * 0.50;
  const combinedLimit = (w2WagesPaid * 0.25) + (ubiaQualifiedProperty * 0.025);
  const wageCap       = Math.max(w2Limit, combinedLimit);

  // Tentative deduction without wage cap
  const tentative = qualifiedBusinessIncome * 0.20;

  // Phase in the wage limitation across the phase-out window
  const limitedDeduction = tentative - ratio * Math.max(0, tentative - wageCap);

  // For SSTBs: scale down by (1 - ratio) for phase-out window
  if (isSSTB) return Math.max(0, tentative * (1 - ratio));

  return Math.max(0, limitedDeduction);
}

const AMT_2026 = {
  EXEMPTION_SINGLE:  70_300,
  EXEMPTION_MFJ:     109_400,
  PHASEOUT_SINGLE:   626_350,   // exemption reduces by $0.25 per $1 above this
  PHASEOUT_MFJ:      1_252_700,
  RATE_LOW:          0.26,      // On AMTI ≤ $232,600
  AMTI_TIER_BREAK:   232_600,
  RATE_HIGH:         0.28,
};

function computeAMT({
  regularTaxableIncome,
  saltDeductionTaken,       // full amount, not capped — added back in full
  isoSpread = 0,
  acceleratedDepreciation = 0,
  filingStatus = "single",
}) {
  // Step 1: Build AMTI by adding preference items back
  const amti = regularTaxableIncome
    + saltDeductionTaken
    + isoSpread
    + acceleratedDepreciation;

  // Step 2: Compute phased-out exemption
  const { EXEMPTION_SINGLE, EXEMPTION_MFJ, PHASEOUT_SINGLE, PHASEOUT_MFJ } = AMT_2026;
  const rawExemption = filingStatus === "mfj" ? EXEMPTION_MFJ : EXEMPTION_SINGLE;
  const phaseoutFloor = filingStatus === "mfj" ? PHASEOUT_MFJ : PHASEOUT_SINGLE;
  const phaseoutReduction = Math.max(0, (amti - phaseoutFloor) * 0.25);
  const exemption = Math.max(0, rawExemption - phaseoutReduction);

  // Step 3: Taxable AMTI after exemption
  const taxableAMTI = Math.max(0, amti - exemption);
  if (taxableAMTI === 0) return 0;

  // Step 4: Apply 26%/28% two-tier rates
  const lowTier = Math.min(taxableAMTI, AMT_2026.AMTI_TIER_BREAK);
  const highTier = Math.max(0, taxableAMTI - AMT_2026.AMTI_TIER_BREAK);
  const tentativeMinTax = (lowTier * AMT_2026.RATE_LOW) + (highTier * AMT_2026.RATE_HIGH);

  return Math.round(tentativeMinTax);
}

// The caller pays max(regularTax, amtLiability):
// const finalTax = Math.max(regularTax, computeAMT({ ... }))

const PAYMENT_DATES_2026 = [
  { period: "Q1", due: "2026-04-15", incomeMonths: [1, 2, 3]     },
  { period: "Q2", due: "2026-06-16", incomeMonths: [4, 5]        },
  { period: "Q3", due: "2026-09-15", incomeMonths: [6, 7, 8]     },
  { period: "Q4", due: "2027-01-15", incomeMonths: [9, 10, 11, 12] },
];

function computeEstimatedPayments({
  estimatedCurrentYearTax,   // Your best estimate of 2026 federal tax
  priorYearTax,              // Actual 2025 federal tax from prior return
  priorYearAGI,              // 2025 AGI — determines whether 100% or 110% applies
}) {
  // Safe Harbor B multiplier
  const safeHarborBRate = priorYearAGI > 150_000 ? 1.10 : 1.00;

  // Safe Harbor A: 90% of current year, spread evenly across 4 payments
  const safeHarborA_annual = estimatedCurrentYearTax * 0.90;
  const safeHarborA_quarterly = safeHarborA_annual / 4;

  // Safe Harbor B: 100% (or 110%) of prior year, evenly spread
  const safeHarborB_annual = priorYearTax * safeHarborBRate;
  const safeHarborB_quarterly = safeHarborB_annual / 4;

  // The lower quarterly payment satisfies one safe harbor — choose lower
  const recommendedQuarterly = Math.min(safeHarborA_quarterly, safeHarborB_quarterly);

  return {
    quarterlyPayment: Math.ceil(recommendedQuarterly),
    annualRequired: Math.ceil(recommendedQuarterly * 4),
    safeHarborAQuarterly: Math.ceil(safeHarborA_quarterly),
    safeHarborBQuarterly: Math.ceil(safeHarborB_quarterly),
    paymentSchedule: PAYMENT_DATES_2026.map(p => ({
      ...p,
      amount: Math.ceil(recommendedQuarterly)
    })),
  };
}

// Base interface — all state strategies must implement this shape
class StateTaxStrategy {
  calculate(federalAGI, filingStatus) { return 0; }
  get name() { return "Base"; }
}

// No-income-tax states (Florida, Texas, Nevada, etc.)
class NoIncomeTaxStrategy extends StateTaxStrategy {
  calculate() { return 0; }
  get name() { return "No State Income Tax"; }
}

// California 2026 — 13 progressive brackets, top rate 13.3%
class CaliforniaStrategy extends StateTaxStrategy {
  get name() { return "California"; }

  calculate(federalAGI, filingStatus) {
    const brackets = filingStatus === "mfj"
      ? CA_BRACKETS_2026_MFJ
      : CA_BRACKETS_2026_SINGLE;

    // SDI (State Disability Insurance): 1.1% on all wages, no cap in 2026
    const sdi = federalAGI * 0.011;

    return runBracketEngine(federalAGI, brackets) + sdi;
  }
}

// North Carolina 2026 — flat 4.5%
class NorthCarolinaStrategy extends StateTaxStrategy {
  get name() { return "North Carolina"; }
  calculate(federalAGI) {
    const NC_STANDARD_DEDUCTION_SINGLE = 10_750;
    return Math.max(0, federalAGI - NC_STANDARD_DEDUCTION_SINGLE) * 0.045;
  }
}

// TaxEngine consumes any strategy via dependency injection
class TaxEngine {
  constructor(stateStrategy = new NoIncomeTaxStrategy()) {
    this.stateStrategy = stateStrategy;
  }

  computeTotal({ taxableIncome, federalAGI, brackets, filingStatus }) {
    const federal = computeFederalTax(taxableIncome, brackets);
    const state   = this.stateStrategy.calculate(federalAGI, filingStatus);
    return { federal, state, total: federal.tax + state };
  }
}

// Swap states without touching TaxEngine:
const engine = new TaxEngine(new CaliforniaStrategy());