yumi-golang/internal/service/rechargereward/mapper.go

package rechargereward

import (
	"context"
	"sort"
	"strings"
	"time"

	"chatapp3-golang/internal/integration"
	"chatapp3-golang/internal/model"
)

func configSnapshotFromModel(row model.RechargeRewardConfig) rechargeRewardConfigSnapshot {
	return rechargeRewardConfigSnapshot{
		ID:         row.ID,
		SysOrigin:  row.SysOrigin,
		Enabled:    row.Enabled,
		Timezone:   normalizeRechargeRewardTimezone(row.Timezone),
		UpdateTime: row.UpdateTime,
	}
}

func levelSnapshotFromModel(row model.RechargeRewardLevel) rechargeRewardLevelSnapshot {
	return rechargeRewardLevelSnapshot{
		ID:                  row.ID,
		Level:               row.Level,
		RechargeAmountCents: row.RechargeAmountCents,
		RewardGold:          row.RewardGold,
		RewardGroupID:       row.RewardGroupID,
		RewardGroupName:     strings.TrimSpace(row.RewardGroupName),
		Enabled:             row.Enabled,
	}
}

func buildLevelPayloads(
	levels []rechargeRewardLevelSnapshot,
	rewardItems map[int64][]RechargeRewardRewardItem,
	currentRechargeCents int64,
	matchedLevel int,
) []RechargeRewardLevelPayload {
	payloads := make([]RechargeRewardLevelPayload, 0, len(levels))
	for _, level := range levels {
		if !level.Enabled {
			continue
		}
		var items []RechargeRewardRewardItem
		if level.RewardGroupID != nil {
			items = rewardItems[*level.RewardGroupID]
		}
		payloads = append(payloads, RechargeRewardLevelPayload{
			ID:                  level.ID,
			Level:               level.Level,
			RechargeAmount:      formatAmountCents(level.RechargeAmountCents),
			RechargeAmountCents: level.RechargeAmountCents,
			RewardGold:          level.RewardGold,
			RewardGroupID:       level.RewardGroupID,
			RewardGroupName:     level.RewardGroupName,
			RewardItems:         items,
			Enabled:             level.Enabled,
			Reached:             currentRechargeCents >= level.RechargeAmountCents,
			Current:             matchedLevel > 0 && level.Level == matchedLevel,
		})
	}
	return payloads
}

func buildAdminLevelPayloads(
	levels []rechargeRewardLevelSnapshot,
	rewardItems map[int64][]RechargeRewardRewardItem,
) []RechargeRewardLevelPayload {
	payloads := make([]RechargeRewardLevelPayload, 0, len(levels))
	for _, level := range levels {
		var items []RechargeRewardRewardItem
		if level.RewardGroupID != nil {
			items = rewardItems[*level.RewardGroupID]
		}
		payloads = append(payloads, RechargeRewardLevelPayload{
			ID:                  level.ID,
			Level:               level.Level,
			RechargeAmount:      formatAmountCents(level.RechargeAmountCents),
			RechargeAmountCents: level.RechargeAmountCents,
			RewardGold:          level.RewardGold,
			RewardGroupID:       level.RewardGroupID,
			RewardGroupName:     level.RewardGroupName,
			RewardItems:         items,
			Enabled:             level.Enabled,
		})
	}
	return payloads
}

func pickMatchedLevel(levels []rechargeRewardLevelSnapshot, currentRechargeCents int64) (rechargeRewardLevelSnapshot, bool) {
	var matched rechargeRewardLevelSnapshot
	ok := false
	for _, level := range levels {
		if !level.Enabled || level.RechargeAmountCents <= 0 {
			continue
		}
		if currentRechargeCents >= level.RechargeAmountCents && (!ok || level.RechargeAmountCents > matched.RechargeAmountCents) {
			matched = level
			ok = true
		}
	}
	return matched, ok
}

func pickNextLevel(levels []rechargeRewardLevelSnapshot, currentRechargeCents int64) (rechargeRewardLevelSnapshot, bool) {
	for _, level := range levels {
		if !level.Enabled || level.RechargeAmountCents <= currentRechargeCents {
			continue
		}
		return level, true
	}
	return rechargeRewardLevelSnapshot{}, false
}

func sortLevels(levels []rechargeRewardLevelSnapshot) {
	sort.Slice(levels, func(i, j int) bool {
		if levels[i].RechargeAmountCents == levels[j].RechargeAmountCents {
			return levels[i].Level < levels[j].Level
		}
		return levels[i].RechargeAmountCents < levels[j].RechargeAmountCents
	})
}

func (s *Service) loadRewardItemsMap(
	ctx context.Context,
	levels []rechargeRewardLevelSnapshot,
) map[int64][]RechargeRewardRewardItem {
	if s.java == nil {
		return map[int64][]RechargeRewardRewardItem{}
	}
	groupIDs := make([]int64, 0)
	seen := make(map[int64]struct{})
	for _, level := range levels {
		if level.RewardGroupID == nil || *level.RewardGroupID <= 0 {
			continue
		}
		if _, exists := seen[*level.RewardGroupID]; exists {
			continue
		}
		seen[*level.RewardGroupID] = struct{}{}
		groupIDs = append(groupIDs, *level.RewardGroupID)
	}
	sort.Slice(groupIDs, func(i, j int) bool { return groupIDs[i] < groupIDs[j] })

	result := make(map[int64][]RechargeRewardRewardItem, len(groupIDs))
	for _, groupID := range groupIDs {
		detail, err := s.java.GetRewardGroupDetail(ctx, groupID)
		if err != nil {
			continue
		}
		items := make([]RechargeRewardRewardItem, 0, len(detail.RewardConfigList))
		for _, item := range detail.RewardConfigList {
			items = append(items, RechargeRewardRewardItem{
				ID:       int64(item.ID),
				Type:     strings.TrimSpace(item.Type),
				Name:     strings.TrimSpace(item.Name),
				Content:  strings.TrimSpace(item.Content),
				Quantity: int64(item.Quantity),
				Cover:    strings.TrimSpace(item.Cover),
				Remark:   strings.TrimSpace(item.Remark),
			})
		}
		result[groupID] = items
	}
	return result
}

func totalRechargeCents(entries []integration.UserTotalRecharge) int64 {
	var total int64
	for _, entry := range entries {
		total += parseIntegrationAmountCents(integrationAmount(entry.Amount))
	}
	return total
}

func formatDateTime(t time.Time) string {
	if t.IsZero() {
		return ""
	}
	return t.Format("2006-01-02 15:04:05")
}