apskel-pos-backend/internal/processor/earning_calculator.go

package processor

import (
	"math"

	"apskel-pos-be/internal/constants"
	"apskel-pos-be/internal/entities"
	"apskel-pos-be/internal/models"
)

// EarningLine is what an order earns in one currency, and the settings that produced
// it. The settings are kept so the ledger row can freeze them: a later change of
// setting must not change what an earning meant, and a reversal is computed with the
// same numbers (docs/prd-point-coin.md F3).
type EarningLine struct {
	Amount   int64
	Settings models.LoyaltyEarnSettings
	// True when max_per_order cut the amount down.
	Capped bool
}

// EarningResult is what an order earns.
type EarningResult struct {
	// subtotal − discount, in rupiah, never negative.
	// Tax and anything else added on top of the subtotal are not part of it (Q1).
	Basis float64
	Point EarningLine
	Coin  EarningLine
}

// Metadata is the snapshot stored on the currency's EARN ledger row.
func (r EarningResult) Metadata(line EarningLine) entities.Metadata {
	m := entities.Metadata{
		"basis":            r.Basis,
		"earn_per_amount":  line.Settings.EarnPerAmount,
		"earn_value":       line.Settings.EarnValue,
		"min_order_amount": line.Settings.MinOrderAmount,
		"capped":           line.Capped,
	}
	if line.Settings.EarnMode == constants.LoyaltyEarnModePercentage {
		m["earn_mode"] = line.Settings.EarnMode
		m["earn_percent"] = line.Settings.EarnPercent
	}
	if line.Settings.MaxPerOrder != nil {
		m["max_per_order"] = *line.Settings.MaxPerOrder
	}
	return m
}

// CalculateEarning applies the earning formula of docs/prd-point-coin.md F1:
//
//	basis  = subtotal − discount_amount
//	amount = 0                                  if basis < min_order_amount
//	amount = floor(basis / earn_per_amount) × earn_value    in PER_AMOUNT mode
//	amount = floor(basis × earn_percent / 100)              in PERCENTAGE mode
//	amount = min(amount, max_per_order)         if max_per_order is set
//
// Money is handled in whole cents so floor never lands one short on a value like
// 87500.00 that float64 cannot hold exactly. It has no side effects.
func CalculateEarning(order *entities.Order, settings models.OutletLoyaltySettings) EarningResult {
	basisCents := toCents(order.Subtotal) - toCents(order.DiscountAmount)
	if basisCents < 0 {
		basisCents = 0
	}
	return EarningResult{
		Basis: float64(basisCents) / 100,
		Point: earnLine(basisCents, settings.Point),
		Coin:  earnLine(basisCents, settings.Coin),
	}
}

func earnLine(basisCents int64, s models.LoyaltyEarnSettings) EarningLine {
	line := EarningLine{Settings: s}
	if !s.Enabled || basisCents < s.MinOrderAmount*100 {
		return line
	}
	if s.EarnMode == constants.LoyaltyEarnModePercentage {
		// The percent has at most two decimals, so in hundredths it is whole and the
		// product stays in integers: cents × hundredths / (100 × 100 × 100).
		hundredths := int64(math.Round(s.EarnPercent * 100))
		if hundredths <= 0 {
			return line
		}
		line.Amount = basisCents * hundredths / 1_000_000
	} else {
		if s.EarnPerAmount <= 0 || s.EarnValue <= 0 {
			return line
		}
		line.Amount = basisCents / (s.EarnPerAmount * 100) * s.EarnValue
	}
	if s.MaxPerOrder != nil && line.Amount > *s.MaxPerOrder {
		line.Amount = *s.MaxPerOrder
		line.Capped = true
	}
	return line
}

func toCents(rupiah float64) int64 {
	return int64(math.Round(rupiah * 100))
}