/**
 * TDS (Tax Deducted at Source) Calculator for Indian Income Tax
 * Supports both OLD and NEW tax regimes with FY-based configuration
 * Fully compliant with latest Indian income tax rules and payroll standards
 */

// Tax regime types
export enum TaxRegime {
  OLD = "old",
  NEW = "new",
}

// Financial Year enum for configuration
export enum FinancialYear {
  FY_2024_25 = "FY_2024_25",
  FY_2025_26 = "FY_2025_26",
}

// Tax slab interface
interface TaxSlab {
  min: number
  max: number
  rate: number
}

// Surcharge slab interface
interface SurchargeConfig {
  threshold: number
  rate: number
}

// FY-based tax configuration
interface FYTaxConfig {
  oldRegimeSlabs: TaxSlab[]
  newRegimeSlabs: TaxSlab[]
  standardDeduction: {
    OLD_REGIME: number
    NEW_REGIME: number
  }
  section87ARebate: {
    OLD_REGIME: {
      INCOME_LIMIT: number
      MAX_REBATE: number
    }
    NEW_REGIME: {
      INCOME_LIMIT: number
      MAX_REBATE: number
    }
  }
  surchargeSlabs: SurchargeConfig[]
  cessRate: number
}

// FY 2024-25 Configuration
const FY_2024_25_CONFIG: FYTaxConfig = {
  oldRegimeSlabs: [
    { min: 0, max: 250000, rate: 0 },
    { min: 250000, max: 500000, rate: 5 },
    { min: 500000, max: 1000000, rate: 20 },
    { min: 1000000, max: Infinity, rate: 30 },
  ],
  newRegimeSlabs: [
    { min: 0, max: 400000, rate: 0 },
    { min: 400000, max: 800000, rate: 5 },
    { min: 800000, max: 1200000, rate: 10 },
    { min: 1200000, max: 1600000, rate: 15 },
    { min: 1600000, max: 2000000, rate: 20 },
    { min: 2000000, max: 2400000, rate: 25 },
    { min: 2400000, max: Infinity, rate: 30 },
  ],
  standardDeduction: {
    OLD_REGIME: 50000,
    NEW_REGIME: 75000,
  },
  section87ARebate: {
    OLD_REGIME: {
      INCOME_LIMIT: 500000,
      MAX_REBATE: 12500,
    },
    NEW_REGIME: {
      INCOME_LIMIT: 1200000,
      MAX_REBATE: 60000,
    },
  },
  surchargeSlabs: [
    { threshold: 5000000, rate: 10 }, // ₹50L → 10%
    { threshold: 10000000, rate: 15 }, // ₹1Cr → 15%
    { threshold: 20000000, rate: 25 }, // ₹2Cr → 25%
    { threshold: 50000000, rate: 37 }, // ₹5Cr → 37%
  ],
  cessRate: 4, // 4% Health & Education Cess
}

// FY 2025-26 Configuration (Updated slabs)
const FY_2025_26_CONFIG: FYTaxConfig = {
  oldRegimeSlabs: [
    { min: 0, max: 250000, rate: 0 },
    { min: 250000, max: 500000, rate: 5 },
    { min: 500000, max: 1000000, rate: 20 },
    { min: 1000000, max: Infinity, rate: 30 },
  ],
  newRegimeSlabs: [
    { min: 0, max: 400000, rate: 0 }, // 0–4L → 0%
    { min: 400000, max: 800000, rate: 5 }, // 4–8L → 5%
    { min: 800000, max: 1200000, rate: 10 }, // 8–12L → 10%
    { min: 1200000, max: 1600000, rate: 15 }, // 12–16L → 15%
    { min: 1600000, max: 2000000, rate: 20 }, // 16–20L → 20%
    { min: 2000000, max: 2400000, rate: 25 }, // 20–24L → 25%
    { min: 2400000, max: Infinity, rate: 30 }, // Above 24L → 30%
  ],
  standardDeduction: {
    OLD_REGIME: 50000,
    NEW_REGIME: 75000,
  },
  section87ARebate: {
    OLD_REGIME: {
      INCOME_LIMIT: 500000, // income ≤ ₹5,00,000
      MAX_REBATE: 12500, // max rebate ₹12,500
    },
    NEW_REGIME: {
      INCOME_LIMIT: 1200000, // income ≤ ₹12,00,000
      MAX_REBATE: 60000, // max rebate ₹60,000
    },
  },
  surchargeSlabs: [
    { threshold: 5000000, rate: 10 }, // ₹50L → 10%
    { threshold: 10000000, rate: 15 }, // ₹1Cr → 15%
    { threshold: 20000000, rate: 25 }, // ₹2Cr → 25%
    { threshold: 50000000, rate: 37 }, // ₹5Cr → 37%
  ],
  cessRate: 4, // 4% Health & Education Cess
}

// Configuration registry
const FY_CONFIGS: Record<FinancialYear, FYTaxConfig> = {
  [FinancialYear.FY_2024_25]: FY_2024_25_CONFIG,
  [FinancialYear.FY_2025_26]: FY_2025_26_CONFIG,
}

// Get configuration for specific FY
export const getFYConfig = (
  fy: FinancialYear = FinancialYear.FY_2025_26,
): FYTaxConfig => {
  return FY_CONFIGS[fy]
}

// Legacy exports for backward compatibility (using latest FY)
export const OLD_REGIME_TAX_SLABS = getFYConfig().oldRegimeSlabs
export const NEW_REGIME_TAX_SLABS = getFYConfig().newRegimeSlabs
export const STANDARD_DEDUCTION = getFYConfig().standardDeduction
export const SECTION_87A_REBATE = getFYConfig().section87ARebate

// HRA exemption rates
export const HRA_EXEMPTION_RATES = {
  METRO: 0.5, // 50% of basic salary for metro cities
  NON_METRO: 0.4, // 40% of basic salary for non-metro cities
  RENT_THRESHOLD: 0.1, // 10% of basic salary threshold for rent paid
}

// Salary component codes (as per static-const.ts)
export const SALARY_COMPONENT_CODES = {
  BASIC: "BASIC",
  HRA: "HRA",
  SPECIAL_ALLOWANCE: "SPECIAL_ALLOWANCE",
  LTA: "LTA",
  EMPLOYEE_PF: "EMPLOYEE_PF",
  PROFESSIONAL_TAX: "PROFESSIONAL_TAX",
  LWF: "LWF",
}

// Protected salary setting codes that cannot be deleted
export const PROTECTED_SALARY_CODES = [
  SALARY_COMPONENT_CODES.BASIC,
  SALARY_COMPONENT_CODES.HRA,
  SALARY_COMPONENT_CODES.SPECIAL_ALLOWANCE,
  SALARY_COMPONENT_CODES.LTA,
]

/**
 * Interface for salary breakdown by component code
 */
export interface SalaryBreakdown {
  [code: string]: {
    amount: number
    is_taxable: boolean
  }
}

/**
 * Interface for TDS calculation input
 */
export interface TdsCalculationInput {
  employeeId: number
  annualCTC: number
  regimeType: TaxRegime
  salaryBreakdown: SalaryBreakdown
  isMetroCity?: boolean // Default: false (non-metro)
  ltaClaimed?: boolean // Default: false (LTA not claimed, so fully taxable)
  rentPaid?: number // Annual rent paid (for HRA calculation)
  financialYear?: FinancialYear // Default: FY_2025_26
  // Payroll-grade TDS support
  taxAlreadyDeducted?: number // Tax already deducted in current FY
  remainingMonths?: number // Remaining months in FY for TDS calculation
  employerPF?: number
  gratuity?: number
  employerNps?: number
}

/**
 * Interface for TDS calculation result
 */
export interface TdsCalculationResult {
  employeeId: number
  annualCTC: number
  regimeType: TaxRegime
  financialYear: FinancialYear
  taxableIncome: number
  taxBeforeDeductions: number
  section87ARebate: {
    isEligible: boolean
    rebateAmount: number
    incomeLimit: number
  }
  taxAfterRebate: number
  surcharge: {
    applicable: boolean
    rate: number
    amount: number
    marginalRelief: number
  }
  taxAfterSurcharge: number
  cess: {
    rate: number
    amount: number
  }
  totalTax: number
  standardDeduction: number
  finalTaxableIncome: number
  annualTdsAmount: number
  monthlyTdsAmount: number
  // Payroll-grade TDS
  taxAlreadyDeducted: number
  remainingMonths: number
  adjustedMonthlyTds: number
  breakdown: {
    basicSalary: number
    hraTaxable: number
    hraExempt: number
    specialAllowanceTaxable: number
    ltaTaxable: number
    otherTaxableComponents: number
    totalDeductions: number
    // Employer contributions (for reporting)
    annualEmployerPF: number
    annualGratuity: number
    annualEmployerNps: number
    annualGrossSalary: number
  }
}

/**
 * Calculate taxable income for TDS (Government-compliant approach)
 * Taxable Income = Annual Gross Salary - Standard Deduction
 */
const calculateTaxableIncome = (
  annualGrossSalary: number,
  regimeType: TaxRegime,
  fyConfig: FYTaxConfig,
): number => {
  // Apply standard deduction based on regime and FY
  const standardDeduction =
    regimeType === TaxRegime.OLD
      ? fyConfig.standardDeduction.OLD_REGIME
      : fyConfig.standardDeduction.NEW_REGIME

  return Math.max(0, annualGrossSalary - standardDeduction)
}

/**
 * Calculate salary breakdown for display purposes only
 * This does NOT affect taxable income calculation
 */
const calculateSalaryBreakdownForDisplay = (
  salaryBreakdown: SalaryBreakdown,
  isMetroCity: boolean,
  ltaClaimed: boolean,
  rentPaid: number,
  regimeType: TaxRegime,
) => {
  // Get basic salary (monthly amount, convert to annual for HRA calculation)
  const basicSalaryComponent = salaryBreakdown[SALARY_COMPONENT_CODES.BASIC]
  const monthlyBasicSalary = basicSalaryComponent?.amount || 0
  const annualBasicSalary = monthlyBasicSalary * 12

  // Calculate HRA exemption (using monthly amounts, then convert to annual)
  const hraComponent = salaryBreakdown[SALARY_COMPONENT_CODES.HRA]
  const monthlyHraReceived = hraComponent?.amount || 0
  const hraCalculation = calculateHraExemption(
    monthlyHraReceived,
    monthlyBasicSalary,
    rentPaid / 12,
    isMetroCity,
    regimeType,
  )
  const annualHraTaxable = hraCalculation.taxable * 12
  const annualHraExempt = hraCalculation.exempt * 12

  // Calculate LTA taxability (convert to annual) - for display only
  const ltaComponent = salaryBreakdown[SALARY_COMPONENT_CODES.LTA]
  const monthlyLtaReceived = ltaComponent?.amount || 0
  const annualLtaTaxable = ltaClaimed ? 0 : monthlyLtaReceived * 12

  // Calculate Special Allowance (fully taxable, convert to annual) - for display only
  const specialAllowanceComponent =
    salaryBreakdown[SALARY_COMPONENT_CODES.SPECIAL_ALLOWANCE]
  const annualSpecialAllowanceTaxable =
    (specialAllowanceComponent?.amount || 0) * 12

  // Calculate other taxable components (convert monthly to annual) - for display only
  let annualOtherTaxableComponents = 0
  let annualTotalDeductions = 0

  Object.entries(salaryBreakdown).forEach(([code, component]) => {
    // Skip components we've already handled
    if (
      [
        SALARY_COMPONENT_CODES.BASIC,
        SALARY_COMPONENT_CODES.HRA,
        SALARY_COMPONENT_CODES.SPECIAL_ALLOWANCE,
        SALARY_COMPONENT_CODES.LTA,
      ].includes(code)
    ) {
      return
    }

    const annualAmount = component.amount * 12

    if (component.is_taxable) {
      annualOtherTaxableComponents += annualAmount
    } else {
      // Non-taxable components are treated as deductions for calculation purposes
      annualTotalDeductions += annualAmount
    }
  })

  return {
    basicSalary: annualBasicSalary,
    hraTaxable: annualHraTaxable,
    hraExempt: annualHraExempt,
    specialAllowanceTaxable: annualSpecialAllowanceTaxable,
    ltaTaxable: annualLtaTaxable,
    otherTaxableComponents: annualOtherTaxableComponents,
    totalDeductions: annualTotalDeductions,
  }
}

/**
 * Calculate HRA exemption as per Indian tax rules
 * Minimum of:
 * 1. Actual HRA received
 * 2. 40% (non-metro) / 50% (metro) of basic salary
 * 3. Rent paid minus 10% of basic salary
 */
const calculateHraExemption = (
  hraReceived: number,
  basicSalary: number,
  rentPaid: number = 0,
  isMetroCity: boolean = false,
  regimeType: TaxRegime = TaxRegime.OLD,
): { exempt: number; taxable: number } => {
  if (hraReceived <= 0) {
    return { exempt: 0, taxable: 0 }
  }

  // Under NEW regime, there's no HRA exemption
  if (regimeType === TaxRegime.NEW) {
    return {
      exempt: 0,
      taxable: hraReceived,
    }
  }

  // Calculate exemption limits for OLD regime
  const salaryBasedExemption =
    basicSalary *
    (isMetroCity ? HRA_EXEMPTION_RATES.METRO : HRA_EXEMPTION_RATES.NON_METRO)
  const rentBasedExemption = Math.max(
    0,
    rentPaid - basicSalary * HRA_EXEMPTION_RATES.RENT_THRESHOLD,
  )

  // HRA exemption is minimum of actual HRA, salary-based limit, and rent-based limit
  const hraExemption = Math.min(
    hraReceived,
    salaryBasedExemption,
    rentBasedExemption,
  )
  const hraTaxable = hraReceived - hraExemption

  return {
    exempt: hraExemption,
    taxable: hraTaxable,
  }
}

/**
 * Calculate tax using progressive tax slabs
 */
const calculateTaxFromSlabs = (
  taxableIncome: number,
  taxSlabs: TaxSlab[],
): number => {
  let tax = 0
  let remainingIncome = taxableIncome

  for (const slab of taxSlabs) {
    if (remainingIncome <= 0) break

    const taxableInThisSlab = Math.min(remainingIncome, slab.max - slab.min)
    tax += (taxableInThisSlab * slab.rate) / 100
    remainingIncome -= taxableInThisSlab
  }

  return Math.round(tax)
}

/**
 * Calculate surcharge on tax amount
 */
const calculateSurcharge = (
  taxAfterRebate: number,
  taxableIncome: number,
  regimeType: TaxRegime,
  fyConfig: FYTaxConfig,
): { rate: number; amount: number; marginalRelief: number } => {
  if (taxAfterRebate <= 0) {
    return { rate: 0, amount: 0, marginalRelief: 0 }
  }

  // Find applicable surcharge rate
  let applicableRate = 0
  let applicableThreshold = 0

  for (const slab of fyConfig.surchargeSlabs) {
    if (taxableIncome > slab.threshold) {
      applicableRate = slab.rate
      applicableThreshold = slab.threshold
    }
  }

  if (applicableRate === 0) {
    return { rate: 0, amount: 0, marginalRelief: 0 }
  }

  // Cap surcharge at 25% for NEW regime
  if (regimeType === TaxRegime.NEW && applicableRate > 25) {
    applicableRate = 25
  }

  // Calculate surcharge amount
  const surchargeAmount = Math.round((taxAfterRebate * applicableRate) / 100)

  // Calculate marginal relief
  let marginalRelief = 0
  if (applicableThreshold > 0) {
    // Tax at threshold income
    const taxAtThreshold = calculateTaxFromSlabs(
      applicableThreshold,
      regimeType === TaxRegime.OLD
        ? fyConfig.oldRegimeSlabs
        : fyConfig.newRegimeSlabs,
    )

    // Apply Section 87A rebate at threshold
    const rebateAtThreshold = calculateSection87ARebate(
      applicableThreshold,
      taxAtThreshold,
      regimeType,
      fyConfig,
    )

    // Surcharge at threshold
    const surchargeAtThreshold = Math.round(
      (rebateAtThreshold.finalTax * applicableRate) / 100,
    )

    // Total tax at threshold
    const totalTaxAtThreshold =
      rebateAtThreshold.finalTax + surchargeAtThreshold

    // Excess income above threshold
    const excessIncome = taxableIncome - applicableThreshold

    // Marginal relief calculation
    const totalTaxWithoutRelief = taxAfterRebate + surchargeAmount
    const totalTaxWithRelief = totalTaxAtThreshold + excessIncome

    if (totalTaxWithoutRelief > totalTaxWithRelief) {
      marginalRelief = totalTaxWithoutRelief - totalTaxWithRelief
    }
  }

  return {
    rate: applicableRate,
    amount: Math.max(0, surchargeAmount - marginalRelief),
    marginalRelief,
  }
}

/**
 * Calculate Section 87A rebate as per Indian Income Tax Act
 * Section 87A provides tax rebate for taxpayers with lower income
 */
const calculateSection87ARebate = (
  taxableIncome: number,
  calculatedTax: number,
  regimeType: TaxRegime,
  fyConfig: FYTaxConfig,
): { rebateAmount: number; finalTax: number; isEligible: boolean } => {
  const rebateConfig =
    regimeType === TaxRegime.OLD
      ? fyConfig.section87ARebate.OLD_REGIME
      : fyConfig.section87ARebate.NEW_REGIME

  // Check if taxpayer is eligible for Section 87A rebate
  const isEligible = taxableIncome <= rebateConfig.INCOME_LIMIT

  if (!isEligible) {
    return {
      rebateAmount: 0,
      finalTax: calculatedTax,
      isEligible: false,
    }
  }

  // Calculate rebate amount
  let rebateAmount = 0
  let finalTax = calculatedTax

  if (regimeType === TaxRegime.NEW) {
    // NEW regime: Complete tax exemption if income ≤ rebate limit
    rebateAmount = calculatedTax
    finalTax = 0
  } else {
    // OLD regime: Rebate up to max rebate amount if income ≤ income limit
    rebateAmount = Math.min(calculatedTax, rebateConfig.MAX_REBATE)
    finalTax = Math.max(0, calculatedTax - rebateAmount)
  }

  return {
    rebateAmount,
    finalTax,
    isEligible: true,
  }
}

/**
 * Calculate Health and Education Cess
 */
const calculateCess = (
  taxAfterSurcharge: number,
  cessRate: number,
): { rate: number; amount: number } => {
  const cessAmount = Math.round((taxAfterSurcharge * cessRate) / 100)
  return {
    rate: cessRate,
    amount: cessAmount,
  }
}

/**
 * Calculate payroll-grade monthly TDS
 * Monthly TDS = (Annual Tax - Tax Already Deducted) / Remaining Months
 */
const computeMonthlyTds = (
  annualTdsAmount: number,
  taxAlreadyDeducted: number = 0,
  remainingMonths: number = 12,
): { monthlyTdsAmount: number; adjustedMonthlyTds: number } => {
  const monthlyTdsAmount = Math.round(annualTdsAmount / 12)

  // Calculate adjusted monthly TDS based on remaining months
  const remainingTaxToDeduct = Math.max(0, annualTdsAmount - taxAlreadyDeducted)
  const adjustedMonthlyTds =
    remainingMonths > 0 ? Math.round(remainingTaxToDeduct / remainingMonths) : 0

  return {
    monthlyTdsAmount,
    adjustedMonthlyTds,
  }
}

/**
 * Main TDS calculation function
 * Calculates annual TDS amount based on salary breakdown and tax regime
 * Fully compliant with latest Indian income tax rules and payroll standards
 */
export const calculateTdsAmount = (
  input: TdsCalculationInput,
): TdsCalculationResult => {
  const {
    employeeId,
    annualCTC,
    regimeType,
    salaryBreakdown,
    isMetroCity = false,
    ltaClaimed = false,
    rentPaid = 0,
    financialYear = FinancialYear.FY_2025_26,
    taxAlreadyDeducted = 0,
    remainingMonths = 12,
    employerPF = 0,
    gratuity = 0,
    employerNps = 0,
  } = input

  // Get FY-specific configuration
  const fyConfig = getFYConfig(financialYear)

  // Compute annual employer contributions
  const annualEmployerPF = employerPF * 12
  const annualGratuity = gratuity * 12
  const annualEmployerNps = employerNps * 12

  // Compute GROSS salary (CTC - employer contributions if not already included)
  // For most payroll systems, CTC already includes employer contributions
  const annualGrossSalary =
    annualCTC - annualEmployerPF - annualGratuity - annualEmployerNps

  // Calculate taxable income using government-compliant approach
  // Taxable Income = Annual Gross Salary - Standard Deduction
  const finalTaxableIncome = calculateTaxableIncome(
    annualGrossSalary,
    regimeType,
    fyConfig,
  )

  // Get standard deduction for reporting
  const standardDeduction =
    regimeType === TaxRegime.OLD
      ? fyConfig.standardDeduction.OLD_REGIME
      : fyConfig.standardDeduction.NEW_REGIME

  // Calculate salary breakdown for display purposes only (does NOT affect tax calculation)
  const salaryBreakdown_display = calculateSalaryBreakdownForDisplay(
    salaryBreakdown,
    isMetroCity,
    ltaClaimed,
    rentPaid,
    regimeType,
  )

  // Calculate tax based on regime (FY-aware slabs)
  const taxSlabs =
    regimeType === TaxRegime.OLD
      ? fyConfig.oldRegimeSlabs
      : fyConfig.newRegimeSlabs
  const incomeTax = calculateTaxFromSlabs(finalTaxableIncome, taxSlabs)

  // Apply Section 87A rebate (FY-aware)
  const section87AResult = calculateSection87ARebate(
    finalTaxableIncome,
    incomeTax,
    regimeType,
    fyConfig,
  )

  // Calculate surcharge with marginal relief
  const surchargeResult = calculateSurcharge(
    section87AResult.finalTax,
    finalTaxableIncome,
    regimeType,
    fyConfig,
  )
  const taxAfterSurcharge = section87AResult.finalTax + surchargeResult.amount

  // Calculate Health and Education Cess (4% of tax + surcharge)
  const cessResult = calculateCess(taxAfterSurcharge, fyConfig.cessRate)
  const totalTax = taxAfterSurcharge + cessResult.amount

  // Final annual TDS amount
  const annualTdsAmount = Math.max(0, totalTax)

  // Calculate payroll-grade monthly TDS
  const payrollTdsResult = computeMonthlyTds(
    annualTdsAmount,
    taxAlreadyDeducted,
    remainingMonths,
  )

  return {
    employeeId,
    annualCTC,
    regimeType,
    financialYear,
    taxableIncome: annualGrossSalary, // Report gross salary as taxable income base
    taxBeforeDeductions: incomeTax,
    section87ARebate: {
      isEligible: section87AResult.isEligible,
      rebateAmount: section87AResult.rebateAmount,
      incomeLimit:
        fyConfig.section87ARebate[
          regimeType === TaxRegime.OLD ? "OLD_REGIME" : "NEW_REGIME"
        ].INCOME_LIMIT,
    },
    taxAfterRebate: section87AResult.finalTax,
    surcharge: {
      applicable: surchargeResult.amount > 0,
      rate: surchargeResult.rate,
      amount: surchargeResult.amount,
      marginalRelief: surchargeResult.marginalRelief,
    },
    taxAfterSurcharge,
    cess: cessResult,
    totalTax,
    standardDeduction,
    finalTaxableIncome,
    annualTdsAmount,
    monthlyTdsAmount: payrollTdsResult.monthlyTdsAmount,
    // Payroll-grade TDS
    taxAlreadyDeducted,
    remainingMonths,
    adjustedMonthlyTds: payrollTdsResult.adjustedMonthlyTds,
    breakdown: {
      basicSalary: salaryBreakdown_display.basicSalary,
      hraTaxable: salaryBreakdown_display.hraTaxable,
      hraExempt: salaryBreakdown_display.hraExempt,
      specialAllowanceTaxable: salaryBreakdown_display.specialAllowanceTaxable,
      ltaTaxable: salaryBreakdown_display.ltaTaxable,
      otherTaxableComponents: salaryBreakdown_display.otherTaxableComponents,
      totalDeductions: salaryBreakdown_display.totalDeductions,
      // Employer contributions (for reporting)
      annualEmployerPF,
      annualGratuity,
      annualEmployerNps,
      annualGrossSalary,
    },
  }
}

/**
 * Utility function to convert employee salary details to salary breakdown format
 */
export const convertSalaryDetailsToBreakdown = (
  salaryDetails: Array<{
    salarySetting?: {
      code: string
      is_taxable: number
    }
    salary_setting?: {
      code: string
      is_taxable: number
    }
    calculated_amount: number
  }>,
  basicSalary: number,
): SalaryBreakdown => {
  const breakdown: SalaryBreakdown = {}

  // Add basic salary (always taxable)
  breakdown[SALARY_COMPONENT_CODES.BASIC] = {
    amount: basicSalary,
    is_taxable: true,
  }

  // Add other salary components
  salaryDetails.forEach((detail) => {
    // Handle both camelCase (salarySetting) and snake_case (salary_setting) naming
    const setting = detail.salarySetting || detail.salary_setting
    if (setting?.code) {
      breakdown[setting.code] = {
        amount: detail.calculated_amount || 0,
        is_taxable: setting.is_taxable === 1,
      }
    }
  })

  return breakdown
}

/**
 * Validate if a salary setting code can be deleted
 */
export const canDeleteSalarySetting = (code: string): boolean => {
  return !PROTECTED_SALARY_CODES.includes(code)
}

/**
 * Get protected salary setting codes
 */
export const getProtectedSalaryCodes = (): string[] => {
  return [...PROTECTED_SALARY_CODES]
}

/**
 * Check if taxpayer is eligible for Section 87A rebate (FY-aware)
 */
export const isEligibleForSection87A = (
  taxableIncome: number,
  regimeType: TaxRegime,
  financialYear: FinancialYear = FinancialYear.FY_2025_26,
): boolean => {
  const fyConfig = getFYConfig(financialYear)
  const rebateConfig =
    regimeType === TaxRegime.OLD
      ? fyConfig.section87ARebate.OLD_REGIME
      : fyConfig.section87ARebate.NEW_REGIME

  return taxableIncome <= rebateConfig.INCOME_LIMIT
}

/**
 * Get Section 87A income limits for both regimes (FY-aware)
 */
export const getSection87ALimits = (
  financialYear: FinancialYear = FinancialYear.FY_2025_26,
) => {
  const fyConfig = getFYConfig(financialYear)
  return {
    OLD_REGIME: fyConfig.section87ARebate.OLD_REGIME,
    NEW_REGIME: fyConfig.section87ARebate.NEW_REGIME,
  }
}

/**
 * Get tax slabs for specific regime and FY
 */
export const getTaxSlabs = (
  regimeType: TaxRegime,
  financialYear: FinancialYear = FinancialYear.FY_2025_26,
): TaxSlab[] => {
  const fyConfig = getFYConfig(financialYear)
  return regimeType === TaxRegime.OLD
    ? fyConfig.oldRegimeSlabs
    : fyConfig.newRegimeSlabs
}

/**
 * Get standard deduction for specific regime and FY
 */
export const getStandardDeduction = (
  regimeType: TaxRegime,
  financialYear: FinancialYear = FinancialYear.FY_2025_26,
): number => {
  const fyConfig = getFYConfig(financialYear)
  return regimeType === TaxRegime.OLD
    ? fyConfig.standardDeduction.OLD_REGIME
    : fyConfig.standardDeduction.NEW_REGIME
}

/**
 * Get surcharge slabs for specific FY
 */
export const getSurchargeSlabs = (
  financialYear: FinancialYear = FinancialYear.FY_2025_26,
): SurchargeConfig[] => {
  const fyConfig = getFYConfig(financialYear)
  return fyConfig.surchargeSlabs
}

/**
 * Get available financial years
 */
export const getAvailableFinancialYears = (): FinancialYear[] => {
  return Object.values(FinancialYear)
}

/**
 * Quick verification function for TDS calculation
 * Example: ₹18,00,000 annual salary in NEW regime should give around ₹12,500 monthly TDS
 */
export const verifyTdsCalculation = () => {
  const testInput: TdsCalculationInput = {
    employeeId: 1,
    annualCTC: 1800000, // ₹18 lakhs
    regimeType: TaxRegime.NEW,
    salaryBreakdown: {
      [SALARY_COMPONENT_CODES.BASIC]: { amount: 75000, is_taxable: true }, // Monthly basic
    },
    financialYear: FinancialYear.FY_2025_26,
  }

  const result = calculateTdsAmount(testInput)

  return {
    annualCTC: result.annualCTC,
    grossSalary: result.breakdown.annualGrossSalary,
    finalTaxableIncome: result.finalTaxableIncome,
    annualTax: result.annualTdsAmount,
    monthlyTds: result.monthlyTdsAmount,
    adjustedMonthlyTds: result.adjustedMonthlyTds,
  }
}