apskel-pos-backend/internal/repository/earning_repository.go

package repository

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/google/uuid"
	"gorm.io/gorm"

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

// ErrEarningOrderNotFound means the order does not exist.
var ErrEarningOrderNotFound = errors.New("earning: order not found")

// EarningOrder is what earning needs to know about an order.
type EarningOrder struct {
	ID             uuid.UUID
	OrganizationID uuid.UUID
	OutletID       uuid.UUID
	OrderNumber    string
	OutletName     string
	CustomerID     *uuid.UUID
	Subtotal       float64
	DiscountAmount float64
	PaymentStatus  string
	IsVoid         bool
	// Cumulative rupiah refunded so far.
	RefundAmount float64
	// Nil when the order has no customer, or the customer row is gone.
	CustomerIsDefault *bool
	CustomerIsActive  *bool
}

// EarningCursor pages through orders by (updated_at, id).
type EarningCursor struct {
	UpdatedAt time.Time
	ID        uuid.UUID
}

// EarningRepository reads orders for loyalty earning (docs/prd-point-coin.md F3).
type EarningRepository interface {
	GetOrderForEarning(ctx context.Context, orderID uuid.UUID) (*EarningOrder, error)
	// ListPaidOrdersWithoutEarning pages, oldest first, through orders updated since
	// the given time that are paid, not void, have an eligible customer, belong to an
	// outlet that earns something, and have no EARN row yet. Pass the previous page's
	// last cursor to continue; nil starts at the beginning.
	ListPaidOrdersWithoutEarning(ctx context.Context, since time.Time, after *EarningCursor, limit int) ([]EarningCursor, error)
	// ListEarnTransactions returns the EARN rows written for an order.
	ListEarnTransactions(ctx context.Context, orderID uuid.UUID) ([]entities.WalletTransaction, error)
	// ReversalRequested is how much has been asked back from an EARN row so far: what
	// was taken plus any shortfall.
	ReversalRequested(ctx context.Context, earnTransactionID uuid.UUID) (int64, error)
	// LotIDsCreatedBy returns the lots a credit created.
	LotIDsCreatedBy(ctx context.Context, transactionID uuid.UUID) ([]uuid.UUID, error)
	// EarnedByOrders sums the EARN rows of each order per currency, as
	// map[order]map[currency]amount. Orders that earned nothing are absent.
	EarnedByOrders(ctx context.Context, orderIDs []uuid.UUID) (map[uuid.UUID]map[string]int64, error)
}

type earningRepository struct {
	db *gorm.DB
}

func NewEarningRepository(db *gorm.DB) EarningRepository {
	return &earningRepository{db: db}
}

func (r *earningRepository) GetOrderForEarning(ctx context.Context, orderID uuid.UUID) (*EarningOrder, error) {
	var rows []struct {
		ID                string
		OrganizationID    string
		OutletID          string
		OrderNumber       string
		OutletName        string
		CustomerID        *string
		Subtotal          float64
		DiscountAmount    float64
		PaymentStatus     string
		IsVoid            bool
		RefundAmount      float64
		CustomerIsDefault *bool
		CustomerIsActive  *bool
	}
	err := DBFromContext(ctx, r.db).WithContext(ctx).Raw(`
		SELECT o.id::text AS id, o.organization_id::text AS organization_id, o.outlet_id::text AS outlet_id,
			o.order_number, COALESCE(ou.name, '') AS outlet_name, o.customer_id::text AS customer_id,
			o.subtotal, COALESCE(o.discount_amount, 0) AS discount_amount, o.payment_status,
			COALESCE(o.is_void, false) AS is_void, COALESCE(o.refund_amount, 0) AS refund_amount,
			c.is_default AS customer_is_default, c.is_active AS customer_is_active
		FROM orders o
		LEFT JOIN outlets ou ON ou.id = o.outlet_id
		LEFT JOIN customers c ON c.id = o.customer_id
		WHERE o.id = ?
		LIMIT 1`, orderID).Scan(&rows).Error
	if err != nil {
		return nil, fmt.Errorf("failed to get order for earning: %w", err)
	}
	if len(rows) == 0 {
		return nil, ErrEarningOrderNotFound
	}
	row := rows[0]
	order := &EarningOrder{
		OrderNumber:       row.OrderNumber,
		OutletName:        row.OutletName,
		Subtotal:          row.Subtotal,
		DiscountAmount:    row.DiscountAmount,
		PaymentStatus:     row.PaymentStatus,
		IsVoid:            row.IsVoid,
		RefundAmount:      row.RefundAmount,
		CustomerIsDefault: row.CustomerIsDefault,
		CustomerIsActive:  row.CustomerIsActive,
	}
	order.ID, _ = uuid.Parse(row.ID)
	order.OrganizationID, _ = uuid.Parse(row.OrganizationID)
	order.OutletID, _ = uuid.Parse(row.OutletID)
	if row.CustomerID != nil {
		if id, err := uuid.Parse(*row.CustomerID); err == nil {
			order.CustomerID = &id
		}
	}
	return order, nil
}

func (r *earningRepository) ListPaidOrdersWithoutEarning(ctx context.Context, since time.Time, after *EarningCursor, limit int) ([]EarningCursor, error) {
	cursorAt, cursorID := since, uuid.Nil
	if after != nil {
		cursorAt, cursorID = after.UpdatedAt, after.ID
	}
	var rows []struct {
		ID        string
		UpdatedAt time.Time
	}
	// An outlet that has neither currency switched on can never earn, so its orders are
	// not candidates; otherwise every order of such an outlet would be rescanned on
	// every run.
	err := DBFromContext(ctx, r.db).WithContext(ctx).Raw(`
		SELECT o.id::text AS id, o.updated_at
		FROM orders o
		JOIN customers c ON c.id = o.customer_id
		WHERE o.payment_status = ?
			AND COALESCE(o.is_void, false) = false
			AND c.is_default = false AND c.is_active = true
			AND o.updated_at >= ?
			AND (o.updated_at, o.id) > (?, ?)
			AND EXISTS (
				SELECT 1 FROM outlet_settings s
				WHERE s.outlet_id = o.outlet_id
					AND s.key IN (?, ?)
					AND lower(trim(s.value)) IN ('true', 't', '1')
			)
			AND NOT EXISTS (
				SELECT 1 FROM wallet_transactions t
				WHERE t.reference_type = ? AND t.reference_id = o.id AND t.type = ?
			)
		ORDER BY o.updated_at, o.id
		LIMIT ?`,
		entities.PaymentStatusCompleted, since, cursorAt, cursorID,
		constants.LoyaltyPointEnabledKey, constants.LoyaltyCoinEnabledKey,
		constants.WalletRefTypeOrder, constants.WalletTxTypeEarn, limit).
		Scan(&rows).Error
	if err != nil {
		return nil, fmt.Errorf("failed to list paid orders without earning: %w", err)
	}
	out := make([]EarningCursor, 0, len(rows))
	for _, row := range rows {
		if id, err := uuid.Parse(row.ID); err == nil {
			out = append(out, EarningCursor{UpdatedAt: row.UpdatedAt, ID: id})
		}
	}
	return out, nil
}

func (r *earningRepository) ListEarnTransactions(ctx context.Context, orderID uuid.UUID) ([]entities.WalletTransaction, error) {
	var rows []entities.WalletTransaction
	err := DBFromContext(ctx, r.db).WithContext(ctx).
		Where("reference_type = ? AND reference_id = ? AND type = ?", constants.WalletRefTypeOrder, orderID, constants.WalletTxTypeEarn).
		Order("currency").
		Find(&rows).Error
	if err != nil {
		return nil, fmt.Errorf("failed to list EARN rows: %w", err)
	}
	return rows, nil
}

func (r *earningRepository) ReversalRequested(ctx context.Context, earnTransactionID uuid.UUID) (int64, error) {
	var total int64
	err := DBFromContext(ctx, r.db).WithContext(ctx).Raw(`
		SELECT COALESCE(SUM(COALESCE((metadata->>'requested_amount')::bigint, -amount)), 0)
		FROM wallet_transactions
		WHERE reverses_transaction_id = ? AND type = ?`,
		earnTransactionID, constants.WalletTxTypeEarnReversal).Scan(&total).Error
	if err != nil {
		return 0, fmt.Errorf("failed to sum earning reversals: %w", err)
	}
	return total, nil
}

func (r *earningRepository) LotIDsCreatedBy(ctx context.Context, transactionID uuid.UUID) ([]uuid.UUID, error) {
	var ids []string
	err := DBFromContext(ctx, r.db).WithContext(ctx).
		Table("wallet_lots").
		Where("source_transaction_id = ?", transactionID).
		Order("expires_at NULLS LAST, created_at, id").
		Pluck("id::text", &ids).Error
	if err != nil {
		return nil, fmt.Errorf("failed to list lots of a credit: %w", err)
	}
	out := make([]uuid.UUID, 0, len(ids))
	for _, s := range ids {
		if id, err := uuid.Parse(s); err == nil {
			out = append(out, id)
		}
	}
	return out, nil
}

func (r *earningRepository) EarnedByOrders(ctx context.Context, orderIDs []uuid.UUID) (map[uuid.UUID]map[string]int64, error) {
	earned := map[uuid.UUID]map[string]int64{}
	if len(orderIDs) == 0 {
		return earned, nil
	}
	var rows []struct {
		OrderID  string
		Currency string
		Amount   int64
	}
	err := DBFromContext(ctx, r.db).WithContext(ctx).Raw(`
		SELECT reference_id::text AS order_id, currency, SUM(amount) AS amount
		FROM wallet_transactions
		WHERE reference_type = ? AND type = ? AND reference_id IN ?
		GROUP BY reference_id, currency`,
		constants.WalletRefTypeOrder, constants.WalletTxTypeEarn, orderIDs).Scan(&rows).Error
	if err != nil {
		return nil, fmt.Errorf("failed to sum earnings of orders: %w", err)
	}
	for _, row := range rows {
		id, err := uuid.Parse(row.OrderID)
		if err != nil {
			continue
		}
		if earned[id] == nil {
			earned[id] = map[string]int64{}
		}
		earned[id][row.Currency] = row.Amount
	}
	return earned, nil
}