pay/internal/store/refund.go

package store

import (
	"errors"
	"fmt"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"

	"github.com/wangjia/pay/internal/model"
)

var ErrRefundNotFound = errors.New("store: refund not found")

type RefundStore struct{ db *gorm.DB }

func NewRefundStore(db *gorm.DB) *RefundStore { return &RefundStore{db: db} }

// CreateRefund is a plain insert with no over-refund guard — safe only for
// callers that already hold their own serialization (e.g. tests, backfills).
// Money-path callers (退款下单) MUST use CreateRefundGuarded instead: a bare
// RefundSum(...)-then-CreateRefund round trip races under concurrent refund
// requests (both read reserved=0, both pass, both insert → over-refund).
func (s *RefundStore) CreateRefund(r *model.Refund) error {
	if r.RefundID == "" {
		return fmt.Errorf("store.CreateRefund: empty RefundID")
	}
	if err := s.db.Create(r).Error; err != nil {
		return fmt.Errorf("store.CreateRefund: %w", err)
	}
	return nil
}

// CreateRefundGuarded 在单事务内完成 锁定订单行 → 求和(非failed)→ 超退校验 → 插入。
// 返回 (false, nil) 表示超退拒绝;并发同单退款经订单行锁串行化。
//
// 订单行锁 clause.Locking{Strength: "UPDATE"} 在 MySQL 上是真正的 SELECT ... FOR
// UPDATE 行锁;SQLite 不支持行级锁,glebarez/sqlite 的 "FOR" ClauseBuilder 会把它
// 静默丢弃(不报错、也不生效)。SQLite 侧真正的串行化来自 DSN 的
// _txlock=immediate(见 internal/model/testdb.go / main.go initDB):BEGIN IMMEDIATE
// 让事务一开始就抢库级写锁,第二个并发事务的 BEGIN 会阻塞到第一个提交/回滚为止,
// 效果等价于「锁行」。没有 _txlock=immediate 时 SQLite 默认 BEGIN DEFERRED,写锁
// 推迟到第一次写语句才抢,两个事务的读阶段(求和)仍可能交错,防不住超退。
func (s *RefundStore) CreateRefundGuarded(r *model.Refund, paidAmountMinor int64) (bool, error) {
	if r.RefundID == "" {
		return false, fmt.Errorf("store.CreateRefundGuarded: empty RefundID")
	}
	if r.OutTradeNo == "" {
		return false, fmt.Errorf("store.CreateRefundGuarded: empty OutTradeNo")
	}
	var ok bool
	err := s.db.Transaction(func(tx *gorm.DB) error {
		var o model.OrderV2
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
			Where("out_trade_no = ?", r.OutTradeNo).First(&o).Error; err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return ErrOrderNotFound
			}
			return fmt.Errorf("lock order: %w", err)
		}

		var reserved int64
		q := tx.Model(&model.Refund{}).
			Where("out_trade_no = ? AND status <> ?", r.OutTradeNo, model.RefundFailed)
		if err := q.Select("COALESCE(SUM(amount_minor),0)").Scan(&reserved).Error; err != nil {
			return fmt.Errorf("sum refunds: %w", err)
		}

		if reserved+r.AmountMinor > paidAmountMinor {
			ok = false
			return nil
		}

		if err := tx.Create(r).Error; err != nil {
			return err
		}
		ok = true
		return nil
	})
	if err != nil {
		return false, fmt.Errorf("store.CreateRefundGuarded: %w", err)
	}
	return ok, nil
}

func (s *RefundStore) GetRefund(refundID string) (*model.Refund, error) {
	var r model.Refund
	if err := s.db.Where("refund_id = ?", refundID).First(&r).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrRefundNotFound
		}
		return nil, fmt.Errorf("store.GetRefund: %w", err)
	}
	return &r, nil
}

// RefundSum sums amount_minor of an order's refunds in the given statuses
// (no statuses = all). 用两种口径:守卫查非失败之和(占额度),态机查 succeeded 之和。
func (s *RefundStore) RefundSum(outTradeNo string, statuses ...model.RefundStatus) (int64, error) {
	var total int64
	q := s.db.Model(&model.Refund{}).Where("out_trade_no = ?", outTradeNo)
	if len(statuses) > 0 {
		q = q.Where("status IN ?", statuses)
	}
	if err := q.Select("COALESCE(SUM(amount_minor),0)").Scan(&total).Error; err != nil {
		return 0, fmt.Errorf("store.RefundSum: %w", err)
	}
	return total, nil
}

// MarkRefundStatus flips a refund from an expected status to a new one
// (conditional UPDATE + RowsAffected). Returns false if not in the from-status.
func (s *RefundStore) MarkRefundStatus(refundID string, from, to model.RefundStatus, providerRefundRef string, at time.Time) (bool, error) {
	updates := map[string]any{"status": to}
	if providerRefundRef != "" {
		updates["provider_refund_ref"] = providerRefundRef
	}
	if to == model.RefundSucceeded || to == model.RefundFailed {
		updates["completed_at"] = at
	}
	res := s.db.Model(&model.Refund{}).
		Where("refund_id = ? AND status = ?", refundID, from).
		Updates(updates)
	if res.Error != nil {
		return false, fmt.Errorf("store.MarkRefundStatus: %w", res.Error)
	}
	return res.RowsAffected > 0, nil
}

// ListManualPending lists refunds awaiting manual (crypto) settlement.
func (s *RefundStore) ListManualPending(limit int) ([]model.Refund, error) {
	if limit <= 0 || limit > 200 {
		limit = 50
	}
	var out []model.Refund
	if err := s.db.Where("status = ?", model.RefundManualPending).
		Order("id ASC").Limit(limit).Find(&out).Error; err != nil {
		return nil, fmt.Errorf("store.ListManualPending: %w", err)
	}
	return out, nil
}