Loanly: Building a Comprehensive Home-Loan Calculator for India

/**
 * Calculate monthly EMI
 * EMI = [P × R × (1+R)^N] / [(1+R)^N - 1]
 */
export function calculateEMI(
  principal: number,
  annualRate: number,
  tenureYears: number
): number {
  if (!isFinite(principal) || !isFinite(annualRate) || !isFinite(tenureYears)) {
    throw new Error('Invalid input: All parameters must be finite numbers');
  }

  if (principal <= 0 || tenureYears <= 0) return 0;

  const monthlyRate = annualRate / 12 / 100;
  const numPayments = tenureYears * 12;

  if (monthlyRate === 0) {
    return principal / numPayments; // zero-interest case
  }

  const multiplier = Math.pow(1 + monthlyRate, numPayments);
  const emi = (principal * monthlyRate * multiplier) / (multiplier - 1);

  return Math.round(emi * 100) / 100;
}

// Format in Indian comma system (e.g., 1,00,000 instead of 100,000)
export function formatIndianNumber(num: number): string {
  if (num === 0) return '0';
  const isNegative = num < 0;
  const [integerPart, decimalPart] = Math.abs(num).toString().split('.');

  let formatted = '';
  if (integerPart.length > 3) {
    formatted = integerPart.slice(-3);
    let remaining = integerPart.slice(0, -3);
    while (remaining.length > 0) {
      formatted = `${remaining.slice(-2)},${formatted}`;
      remaining = remaining.slice(0, -2);
    }
  } else {
    formatted = integerPart;
  }

  const result = decimalPart ? `${formatted}.${decimalPart}` : formatted;
  return isNegative ? `-${result}` : result;
}

// Convert large numbers to Lakhs or Crores
export function formatToLakhsCrores(num: number, decimals = 1): string {
  const absNum = Math.abs(num);
  const sign = num < 0 ? '-' : '';

  if (absNum >= CRORE) {
    return `${sign}${CURRENCY_SYMBOL}${(absNum / CRORE).toFixed(decimals)}Cr`;
  } else if (absNum >= LAKH) {
    return `${sign}${CURRENCY_SYMBOL}${(absNum / LAKH).toFixed(decimals)}L`;
  }

  return `${sign}${CURRENCY_SYMBOL}${absNum.toFixed(decimals)}`;
}

/** Calculate stamp duty based on state and gender */
export function calculateStampDuty(
  propertyValue: number,
  state: string,
  gender: 'male' | 'female' | 'joint' = 'male'
): number {
  const stateRates = STAMP_DUTY_RATES[state];
  if (!stateRates) {
    console.warn(`Stamp duty rates not found for ${state}, using default 5%.`);
    return Math.round(propertyValue * 0.05);
  }

  let rate = stateRates.men;
  if (gender === 'female' && stateRates.women !== undefined) {
    rate = stateRates.women;
  }
  if (gender === 'joint' && stateRates.women !== undefined) {
    rate = stateRates.women;
  }

  return Math.round(propertyValue * rate);
}

/** Combine stamp duty, registration fee and GST */
export function calculateStampDutyBreakdown(
  inputs: StampDutyInputs
): StampDutyBreakdown {
  const stampDuty = calculateStampDuty(
    inputs.propertyValue,
    inputs.state,
    inputs.gender
  );
  const registrationFee = calculateRegistrationFee(
    inputs.propertyValue,
    inputs.state
  );
  const gst = calculateGST(
    inputs.propertyValue,
    inputs.isUnderConstruction || false,
    inputs.constructionRatio
  );

  const total = stampDuty + registrationFee + gst;

  return {
    stampDuty,
    registrationFee,
    gst,
    totalTransactionCost: total,
    effectiveRate: total / inputs.propertyValue,
  };
}

export function calculatePMAYSubsidy(inputs: PMAYInputs): PMAYResult {
  // Determine category from annual income
  let category: 'EWS' | 'LIG' | 'MIG1' | 'MIG2' | 'INELIGIBLE';

  if (inputs.annualIncome <= 300000) category = 'EWS';
  else if (inputs.annualIncome <= 600000) category = 'LIG';
  else if (inputs.annualIncome <= 1200000) category = 'MIG1';
  else if (inputs.annualIncome <= 1800000) category = 'MIG2';
  else {
    return {
      eligible: false,
      category: 'INELIGIBLE',
      reason: 'Income exceeds ₹18L',
      /* ... */
    };
  }

  const criteria = PMAY_CRITERIA[category];

  // Compute eligible loan amount and subsidy tenure
  const eligibleLoan = Math.min(inputs.loanAmount, criteria.maxLoanForSubsidy);
  const subsidyTenure = Math.min(inputs.tenureYears, PMAY_MAX_TENURE);

  // Calculate EMI at market rate vs subsidised rate
  const emiMarket = calculateEMI(eligibleLoan, inputs.interestRate, subsidyTenure);
  const emiSubsidised = calculateEMI(
    eligibleLoan,
    inputs.interestRate - criteria.subsidyRate,
    subsidyTenure
  );

  // Discount future savings using an 8% discount rate
  let subsidyNPV = 0;
  const monthlyDiscount = 0.08 / 12;

  for (let month = 1; month <= subsidyTenure * 12; month++) {
    const monthlyDiff = emiMarket - emiSubsidised;
    subsidyNPV += monthlyDiff / Math.pow(1 + monthlyDiscount, month);
  }

  return {
    eligible: true,
    category,
    subsidyNPV,
    effectiveRate:
      inputs.interestRate -
      (criteria.subsidyRate * (eligibleLoan / inputs.loanAmount)),
    savingsPerMonth: emiMarket - emiSubsidised,
    totalSavings: subsidyNPV * (subsidyTenure / inputs.tenureYears),
  };
}

export function calculateAffordability(
  inputs: AffordabilityInputs
): AffordabilityResult {
  const totalIncome = inputs.monthlyIncome + (inputs.coApplicantIncome ?? 0);
  const totalObligations =
    (inputs.existingEMIs ?? 0) + (inputs.otherObligations ?? 0);

  const maxAllowedEMI =
    totalIncome * (inputs.foirPercentage / 100) - totalObligations;

  // Solve reverse EMI formula to find max loan amount
  const monthlyRate = inputs.interestRate / 12 / 100;
  const months = inputs.tenureYears * 12;
  const factor = Math.pow(1 + monthlyRate, months);

  const maxLoanAmount =
    maxAllowedEMI * ((factor - 1) / (monthlyRate * factor));

  const maxPropertyValue = maxLoanAmount + inputs.downPaymentAvailable;
  const ltvRatio = (maxLoanAmount / maxPropertyValue) * 100;

  return {
    maxAffordableEMI: maxAllowedEMI,
    maxLoanAmount,
    maxPropertyValue,
    ltvRatio,
    /* ... recommendations based on RBI limits and FOIR ... */
  };
}