import type { Expense, Participant, ParticipantId, Settlement } from '../types'
import { computeSplit } from './split'

export function calculateBalances(
  participants: Participant[],
  expenses: Expense[],
): { netBalances: Record<ParticipantId, number>, settlements: Settlement[] } {
  const netBalances: Record<ParticipantId, number> = {}
  for (const participant of participants) {
    netBalances[participant.id] = 0
  }

  // A settlement payment (fromId pays toId) is folded in as a regular
  // expense: payerId = fromId, participantIds = [toId]. The math is
  // identical to a one-person split, so no separate handling is needed here.
  for (const expense of expenses) {
    netBalances[expense.payerId] = (netBalances[expense.payerId] ?? 0) + expense.amountCents
    const shares = computeSplit(expense.amountCents, expense.participantIds)
    for (const [participantId, share] of Object.entries(shares)) {
      const id = Number(participantId)
      netBalances[id] = (netBalances[id] ?? 0) - share
    }
  }

  const settlements = simplifyDebts(netBalances)

  return { netBalances, settlements }
}

function simplifyDebts(netBalances: Record<ParticipantId, number>): Settlement[] {
  const creditors: { id: ParticipantId, amount: number }[] = []
  const debtors: { id: ParticipantId, amount: number }[] = []

  for (const [id, amount] of Object.entries(netBalances)) {
    if (amount > 0) creditors.push({ id: Number(id), amount })
    else if (amount < 0) debtors.push({ id: Number(id), amount: -amount })
  }

  creditors.sort((a, b) => b.amount - a.amount)
  debtors.sort((a, b) => b.amount - a.amount)

  const settlements: Settlement[] = []
  let ci = 0
  let di = 0

  while (ci < creditors.length && di < debtors.length) {
    const creditor = creditors[ci]!
    const debtor = debtors[di]!
    const amount = Math.min(creditor.amount, debtor.amount)

    if (amount > 0) {
      settlements.push({ fromId: debtor.id, toId: creditor.id, amountCents: amount })
    }

    creditor.amount -= amount
    debtor.amount -= amount

    if (creditor.amount === 0) ci++
    if (debtor.amount === 0) di++
  }

  return settlements
}