Commitment Accounting Logic

class CommitmentService {

  /** Check if budget has sufficient balance for a new commitment */
  async checkBudgetAvailability(projectId, costCodeId, amount) {
    const budget = await BudgetLine.findOne({
      project_id: projectId, cost_code_id: costCodeId, status: 'approved'
    });
    const committed = await Commitment.sum('revised_amount', {
      project_id: projectId, cost_code_id: costCodeId, status: ['open', 'partial']
    });
    const available = budget.revised_amount - committed;
    if (amount > available) throw new InsufficientBudgetError(available, amount);
    return { available, requested: amount, remaining: available - amount };
  }

  /** Create commitment when PO/WO is approved */
  async createCommitment(referenceType, referenceId) {
    const doc = await (referenceType === 'PO'
      ? PurchaseOrder.findById(referenceId)
      : WorkOrder.findById(referenceId));
    await this.checkBudgetAvailability(doc.project_id, doc.cost_code_id, doc.total_amount);
    const commitment = await Commitment.create({
      project_id: doc.project_id,
      commitment_type: referenceType,
      po_id: referenceType === 'PO' ? referenceId : null,
      wo_id: referenceType === 'WO' ? referenceId : null,
      original_amount: doc.total_amount, revised_amount: doc.total_amount,
      invoiced_amount: 0, paid_amount: 0,
      balance: doc.total_amount, status: 'open'
    });
    // Post commitment journal: Dr Commitment Control, Cr Commitment Liability
    await JournalService.postCommitment(commitment);
    return commitment;
  }

  /** Create accrual when GRN/DMB is approved */
  async createAccrual(commitmentId, grnOrDmbId, amount) {
    const entry = await ProvisionalEntry.create({
      entity_id, entry_type: 'accrual',
      reference_type: 'GRN', reference_id: grnOrDmbId,
      amount, status: 'active'
    });
    // Post provisional JE: Dr Expense, Cr Accrual Liability
    await JournalService.postAccrual(entry);
    return entry;
  }

  /** Update commitment when invoice is booked */
  async onInvoiceBooked(commitmentId, invoiceAmount) {
    await Commitment.update(commitmentId, {
      invoiced_amount: literal('invoiced_amount + ' + invoiceAmount),
      balance: literal('revised_amount - paid_amount')
    });
    await ProvisionalEntry.reverse(commitmentId);
  }

  /** Update commitment when payment is released */
  async onPaymentReleased(commitmentId, paidAmount) {
    await Commitment.update(commitmentId, {
      paid_amount: literal('paid_amount + ' + paidAmount),
      balance: literal('revised_amount - paid_amount')
    });
    const c = await Commitment.findById(commitmentId);
    if (c.balance <= 0) await c.update({ status: 'closed' });
  }
}