package payment

import (
	"context"
	"fmt"
	"sort"
	"strconv"
	"strings"

	"hyapp-admin-server/internal/model"
	"hyapp-admin-server/internal/repository"
	walletv1 "hyapp.local/api/proto/wallet/v1"
)

type financeCoinSellerRechargeQuery struct {
	RechargeType      string
	Status            string
	PaidState         string
	Keyword           string
	RegionID          int64
	StartAtMS         int64
	EndAtMS           int64
	TzOffsetMinutes   int32
	TargetUserID      int64
	HasUserOnlyFilter bool
	Page              int
	PageSize          int
	MaxPageSize       int
	RequestID         string
	UserID            int64
}

type financeCoinSellerRechargeStats struct {
	Total   rechargeBillSummaryBucketDTO
	Daily   map[string]rechargeBillSummaryBucketDTO
	Regions []rechargeBillRegionBucketDTO
}

const (
	financeCoinSellerRechargeMaxPageSize = 100
	financeRechargeMergeMaxPrefetch      = 5000
)

func (h *Handler) applyFinanceCoinSellerSummary(ctx context.Context, appCode string, query financeCoinSellerRechargeQuery, summary *rechargeBillSummaryDTO) error {
	if summary == nil {
		return nil
	}
	rechargeType := normalizedRechargeType(query.RechargeType)
	if rechargeType != "" && rechargeType != "coin_seller" {
		summary.CoinSeller = rechargeBillSummaryBucketDTO{}
		legacyRecomputeSummaryTotal(summary)
		return nil
	}
	stats, err := h.financeCoinSellerRechargeStats(ctx, appCode, query)
	if err != nil {
		return err
	}
	summary.CoinSeller = stats.Total
	if rechargeType == "coin_seller" {
		summary.GooglePlay = rechargeBillSummaryBucketDTO{}
		summary.ThirdParty = rechargeBillSummaryBucketDTO{}
	}
	legacyRecomputeSummaryTotal(summary)
	return nil
}

func (h *Handler) applyFinanceCoinSellerOverview(ctx context.Context, appCode string, query financeCoinSellerRechargeQuery, overview *rechargeBillOverviewDTO) error {
	if overview == nil {
		return nil
	}
	rechargeType := normalizedRechargeType(query.RechargeType)
	if rechargeType != "" && rechargeType != "coin_seller" {
		for i := range overview.Daily {
			overview.Daily[i].CoinSellerUsdMinor = 0
			overview.Daily[i].CoinSellerCoinAmount = 0
		}
		return nil
	}
	stats, err := h.financeCoinSellerRechargeStats(ctx, appCode, query)
	if err != nil {
		return err
	}
	byDate := map[string]int{}
	for i := range overview.Daily {
		byDate[overview.Daily[i].Date] = i
		// 财务工作台的币商充值只认后台币商订单 + H5 币商身份充值；wallet 库存流水和 legacy dashboard 旧聚合先清掉再重填。
		overview.Daily[i].CoinSellerUsdMinor = 0
		overview.Daily[i].CoinSellerCoinAmount = 0
	}
	for date, bucket := range stats.Daily {
		if date == "" {
			continue
		}
		index, ok := byDate[date]
		if !ok {
			overview.Daily = append(overview.Daily, rechargeBillDailyBucketDTO{Date: date})
			index = len(overview.Daily) - 1
			byDate[date] = index
		}
		overview.Daily[index].CoinSellerUsdMinor = bucket.USDMinorAmount
		overview.Daily[index].CoinSellerCoinAmount = bucket.CoinAmount
	}
	sort.Slice(overview.Daily, func(i, j int) bool {
		return overview.Daily[i].Date < overview.Daily[j].Date
	})
	if rechargeType == "coin_seller" {
		overview.Regions = h.fillFinanceCoinSellerRegionNames(ctx, appCode, stats.Regions)
		return nil
	}
	if rechargeType == "" {
		overview.Regions = h.fillFinanceCoinSellerRegionNames(ctx, appCode, mergeRechargeRegionBuckets(overview.Regions, stats.Regions))
	}
	return nil
}

func (h *Handler) financeCoinSellerRechargeStats(ctx context.Context, appCode string, query financeCoinSellerRechargeQuery) (financeCoinSellerRechargeStats, error) {
	stats := financeCoinSellerRechargeStats{Daily: map[string]rechargeBillSummaryBucketDTO{}}
	rechargeType := normalizedRechargeType(query.RechargeType)
	if rechargeType != "" && rechargeType != "coin_seller" {
		return stats, nil
	}
	if !financeCoinSellerSucceededStatus(query.Status) || strings.TrimSpace(query.PaidState) != "" || query.HasUserOnlyFilter {
		return stats, nil
	}
	if h != nil && h.store != nil {
		repoStats, err := h.store.CoinSellerRechargeOrderStats(repository.CoinSellerRechargeOrderStatsOptions{
			AppCode:         appCode,
			RegionID:        query.RegionID,
			TargetUserID:    query.TargetUserID,
			Keyword:         query.Keyword,
			CreatedFromMS:   query.StartAtMS,
			CreatedToMS:     query.EndAtMS,
			TzOffsetMinutes: query.TzOffsetMinutes,
		})
		if err != nil {
			return stats, err
		}
		stats.addBucket(rechargeBillSummaryBucketDTO{
			BillCount:      repoStats.VerifiedCount,
			CoinAmount:     repoStats.VerifiedCoinAmount,
			USDMinorAmount: repoStats.VerifiedUSDMinor,
		})
		for date, bucket := range repoStats.VerifiedDaily {
			stats.addDaily(date, rechargeBillSummaryBucketDTO{BillCount: bucket.Count, CoinAmount: bucket.CoinAmount, USDMinorAmount: bucket.USDMinor})
		}
		for _, row := range repoStats.VerifiedRegionBuckets {
			stats.addRegion(row.RegionID, row.Count, row.USDMinor)
		}
	}
	if h != nil && h.walletDB != nil {
		if err := h.addH5CoinSellerRechargeStats(ctx, appCode, query, &stats); err != nil {
			return stats, err
		}
	}
	sort.Slice(stats.Regions, func(i, j int) bool {
		return stats.Regions[i].UsdMinorAmount > stats.Regions[j].UsdMinorAmount
	})
	return stats, nil
}

func (s *financeCoinSellerRechargeStats) addBucket(bucket rechargeBillSummaryBucketDTO) {
	if s == nil {
		return
	}
	s.Total.BillCount += bucket.BillCount
	s.Total.CoinAmount += bucket.CoinAmount
	s.Total.USDMinorAmount += bucket.USDMinorAmount
}

func (s *financeCoinSellerRechargeStats) addDaily(date string, bucket rechargeBillSummaryBucketDTO) {
	if s == nil || date == "" {
		return
	}
	if s.Daily == nil {
		s.Daily = map[string]rechargeBillSummaryBucketDTO{}
	}
	current := s.Daily[date]
	current.BillCount += bucket.BillCount
	current.CoinAmount += bucket.CoinAmount
	current.USDMinorAmount += bucket.USDMinorAmount
	s.Daily[date] = current
}

func (s *financeCoinSellerRechargeStats) addRegion(regionID int64, billCount int64, usdMinor int64) {
	if s == nil || regionID <= 0 {
		return
	}
	for i := range s.Regions {
		if s.Regions[i].RegionID == regionID {
			s.Regions[i].BillCount += billCount
			s.Regions[i].UsdMinorAmount += usdMinor
			return
		}
	}
	s.Regions = append(s.Regions, rechargeBillRegionBucketDTO{RegionID: regionID, BillCount: billCount, UsdMinorAmount: usdMinor})
}

func (h *Handler) addH5CoinSellerRechargeStats(ctx context.Context, appCode string, query financeCoinSellerRechargeQuery, stats *financeCoinSellerRechargeStats) error {
	where, args := h5CoinSellerRechargeWhere(appCode, query)
	var total rechargeBillSummaryBucketDTO
	if err := h.walletDB.QueryRowContext(ctx, `
		SELECT COUNT(*), COALESCE(SUM(eo.coin_amount), 0), COALESCE(SUM(eo.usd_minor_amount), 0)
		FROM external_recharge_orders eo
		JOIN wallet_transactions wt ON wt.app_code = eo.app_code AND wt.transaction_id = eo.wallet_transaction_id
		`+where, args...).Scan(&total.BillCount, &total.CoinAmount, &total.USDMinorAmount); err != nil {
		return err
	}
	stats.addBucket(total)

	tzOffsetMS := int64(query.TzOffsetMinutes) * 60_000
	dailyArgs := append([]any{tzOffsetMS}, args...)
	rows, err := h.walletDB.QueryContext(ctx, `
		SELECT DATE_FORMAT(FROM_UNIXTIME((eo.updated_at_ms + ?) / 1000), '%Y-%m-%d') AS date,
		       COUNT(*), COALESCE(SUM(eo.coin_amount), 0), COALESCE(SUM(eo.usd_minor_amount), 0)
		FROM external_recharge_orders eo
		JOIN wallet_transactions wt ON wt.app_code = eo.app_code AND wt.transaction_id = eo.wallet_transaction_id
		`+where+`
		GROUP BY date
		ORDER BY date ASC`, dailyArgs...)
	if err != nil {
		return err
	}
	defer rows.Close()
	for rows.Next() {
		var date string
		var bucket rechargeBillSummaryBucketDTO
		if err := rows.Scan(&date, &bucket.BillCount, &bucket.CoinAmount, &bucket.USDMinorAmount); err != nil {
			return err
		}
		stats.addDaily(date, bucket)
	}
	if err := rows.Err(); err != nil {
		return err
	}

	regionRows, err := h.walletDB.QueryContext(ctx, `
		SELECT eo.target_region_id, COUNT(*), COALESCE(SUM(eo.usd_minor_amount), 0)
		FROM external_recharge_orders eo
		JOIN wallet_transactions wt ON wt.app_code = eo.app_code AND wt.transaction_id = eo.wallet_transaction_id
		`+where+`
		GROUP BY eo.target_region_id
		ORDER BY 3 DESC`, args...)
	if err != nil {
		return err
	}
	defer regionRows.Close()
	for regionRows.Next() {
		var regionID, billCount, usdMinor int64
		if err := regionRows.Scan(&regionID, &billCount, &usdMinor); err != nil {
			return err
		}
		stats.addRegion(regionID, billCount, usdMinor)
	}
	return regionRows.Err()
}

func (h *Handler) listFinanceCoinSellerRechargeBills(ctx context.Context, appCode string, query financeCoinSellerRechargeQuery) ([]rechargeBillDTO, int64, error) {
	if !financeCoinSellerSucceededStatus(query.Status) || strings.TrimSpace(query.PaidState) != "" || query.HasUserOnlyFilter {
		return []rechargeBillDTO{}, 0, nil
	}
	page, pageSize := financeCoinSellerPage(query.Page, query.PageSize, query.MaxPageSize)
	prefetch := financeRechargePrefetch(page, pageSize, query.MaxPageSize)
	items := make([]rechargeBillDTO, 0, prefetch*2)
	var total int64
	if h != nil && h.store != nil {
		orders, orderTotal, err := h.store.ListCoinSellerRechargeOrders(repository.CoinSellerRechargeOrderListOptions{
			Page:          1,
			PageSize:      prefetch,
			PageSizeLimit: prefetch,
			AppCode:       appCode,
			VerifyStatus:  model.CoinSellerRechargeVerifyStatusVerified,
			Keyword:       query.Keyword,
			TargetUserID:  query.TargetUserID,
			RegionID:      query.RegionID,
			CreatedFromMS: query.StartAtMS,
			CreatedToMS:   query.EndAtMS,
		})
		if err != nil {
			return nil, 0, err
		}
		total += orderTotal
		for _, order := range orders {
			if query.RegionID > 0 && order.TargetRegionID != query.RegionID {
				continue
			}
			items = append(items, financeCoinSellerRechargeOrderBill(order))
		}
	}
	if h != nil && h.walletDB != nil {
		h5Items, h5Total, err := h.listH5CoinSellerRechargeBills(ctx, appCode, query, prefetch)
		if err != nil {
			return nil, 0, err
		}
		total += h5Total
		items = append(items, h5Items...)
	}
	sortRechargeBills(items)
	offset := (page - 1) * pageSize
	if offset >= len(items) {
		return []rechargeBillDTO{}, total, nil
	}
	end := offset + pageSize
	if end > len(items) {
		end = len(items)
	}
	return items[offset:end], total, nil
}

func (h *Handler) listFinanceAllRechargeBills(ctx context.Context, appCode string, source RechargeBillSource, query financeCoinSellerRechargeQuery) ([]rechargeBillDTO, int64, error) {
	page, pageSize := financeCoinSellerPage(query.Page, query.PageSize, query.MaxPageSize)
	prefetch := financeRechargePrefetch(page, pageSize, query.MaxPageSize)
	items := make([]rechargeBillDTO, 0, prefetch*3)
	var total int64

	if source != nil {
		if !query.HasUserOnlyFilter && query.TargetUserID == 0 {
			// legacy 普通充值源没有 user/seller 过滤能力；有用户筛选时宁可不展示普通源，避免 all 视图返回未过滤全量。
			ordinary, ordinaryTotal, err := source.ListRechargeBills(ctx, legacyRechargeBillQuery{
				Keyword:         query.Keyword,
				RechargeType:    "",
				PaidState:       query.PaidState,
				RegionID:        query.RegionID,
				StartAtMS:       query.StartAtMS,
				EndAtMS:         query.EndAtMS,
				TzOffsetMinutes: query.TzOffsetMinutes,
				Page:            1,
				PageSize:        prefetch,
			})
			if err != nil {
				return nil, 0, err
			}
			items = append(items, ordinary...)
			total += ordinaryTotal
		}
	} else if h != nil && h.wallet != nil {
		// wallet 的空 recharge_type 会并入 coin_seller_stock_records；all 视图必须拆成普通三方和 Google 两路，币商改走财务新口径。
		for _, rechargeType := range []string{"third_party", "google_play_recharge"} {
			resp, err := h.wallet.ListRechargeBills(ctx, &walletv1.ListRechargeBillsRequest{
				RequestId:    query.RequestID,
				AppCode:      appCode,
				UserId:       query.UserID,
				SellerUserId: query.TargetUserID,
				RegionId:     query.RegionID,
				RechargeType: rechargeType,
				PaidState:    query.PaidState,
				Status:       query.Status,
				Keyword:      query.Keyword,
				StartAtMs:    query.StartAtMS,
				EndAtMs:      query.EndAtMS,
				Page:         1,
				PageSize:     int32(prefetch),
			})
			if err != nil {
				return nil, 0, err
			}
			total += resp.GetTotal()
			for _, item := range resp.GetBills() {
				items = append(items, rechargeBillFromProto(item))
			}
		}
	}

	coinItems, coinTotal, err := h.listFinanceCoinSellerRechargeBills(ctx, appCode, financeCoinSellerRechargeQuery{
		RechargeType:      "coin_seller",
		Status:            query.Status,
		PaidState:         query.PaidState,
		Keyword:           query.Keyword,
		RegionID:          query.RegionID,
		StartAtMS:         query.StartAtMS,
		EndAtMS:           query.EndAtMS,
		TzOffsetMinutes:   query.TzOffsetMinutes,
		TargetUserID:      query.TargetUserID,
		HasUserOnlyFilter: query.HasUserOnlyFilter,
		Page:              1,
		PageSize:          prefetch,
		MaxPageSize:       prefetch,
	})
	if err != nil {
		return nil, 0, err
	}
	items = append(items, coinItems...)
	total += coinTotal

	sortRechargeBills(items)
	offset := (page - 1) * pageSize
	if offset >= len(items) {
		return []rechargeBillDTO{}, total, nil
	}
	end := offset + pageSize
	if end > len(items) {
		end = len(items)
	}
	return items[offset:end], total, nil
}

func (h *Handler) walletOrdinaryRechargeOverviewRegions(ctx context.Context, appCode string, query financeCoinSellerRechargeQuery) ([]rechargeBillRegionBucketDTO, error) {
	if h == nil || h.wallet == nil {
		return []rechargeBillRegionBucketDTO{}, nil
	}
	if !financeWalletOverviewSupportsOrdinaryFilters(query) {
		// wallet overview proto 没有用户、币商、关键词和 paid_state 字段；过滤条件存在时返回空区域，避免展示未过滤的全量区域。
		return []rechargeBillRegionBucketDTO{}, nil
	}
	var out []rechargeBillRegionBucketDTO
	for _, rechargeType := range []string{"third_party", "google_play_recharge"} {
		resp, err := h.wallet.GetRechargeBillOverview(ctx, &walletv1.GetRechargeBillOverviewRequest{
			RequestId:       query.RequestID,
			AppCode:         appCode,
			RegionId:        query.RegionID,
			RechargeType:    rechargeType,
			Status:          query.Status,
			StartAtMs:       query.StartAtMS,
			EndAtMs:         query.EndAtMS,
			TzOffsetMinutes: query.TzOffsetMinutes,
		})
		if err != nil {
			return nil, err
		}
		for _, bucket := range resp.GetRegions() {
			out = append(out, rechargeBillRegionBucketDTO{
				RegionID:       bucket.GetRegionId(),
				BillCount:      bucket.GetBillCount(),
				UsdMinorAmount: bucket.GetUsdMinorAmount(),
			})
		}
	}
	return mergeRechargeRegionBuckets(out), nil
}

func financeWalletOverviewSupportsOrdinaryFilters(query financeCoinSellerRechargeQuery) bool {
	return query.UserID == 0 && query.TargetUserID == 0 && strings.TrimSpace(query.Keyword) == "" && strings.TrimSpace(query.PaidState) == ""
}

func (h *Handler) listH5CoinSellerRechargeBills(ctx context.Context, appCode string, query financeCoinSellerRechargeQuery, limit int) ([]rechargeBillDTO, int64, error) {
	where, args := h5CoinSellerRechargeWhere(appCode, query)
	var total int64
	if err := h.walletDB.QueryRowContext(ctx, `
		SELECT COUNT(*)
		FROM external_recharge_orders eo
		JOIN wallet_transactions wt ON wt.app_code = eo.app_code AND wt.transaction_id = eo.wallet_transaction_id
		`+where, args...).Scan(&total); err != nil {
		return nil, 0, err
	}
	if limit < 1 {
		return []rechargeBillDTO{}, total, nil
	}
	rows, err := h.walletDB.QueryContext(ctx, `
		SELECT eo.app_code, eo.order_id, wt.command_id, eo.target_user_id, eo.target_region_id,
		       eo.product_id, eo.product_code, eo.product_name, eo.coin_amount, eo.usd_minor_amount,
		       eo.provider_code, eo.currency_code, eo.provider_amount_minor, eo.provider_order_id,
		       eo.wallet_transaction_id, eo.updated_at_ms, eo.created_at_ms
		FROM external_recharge_orders eo
		JOIN wallet_transactions wt ON wt.app_code = eo.app_code AND wt.transaction_id = eo.wallet_transaction_id
		`+where+`
		ORDER BY eo.updated_at_ms DESC, eo.order_id DESC
		LIMIT ?`, append(args, limit)...)
	if err != nil {
		return nil, 0, err
	}
	defer rows.Close()
	items := make([]rechargeBillDTO, 0, limit)
	for rows.Next() {
		var item rechargeBillDTO
		var productID int64
		var productCode, productName, providerOrderID, walletTransactionID string
		var createdAtMS int64
		if err := rows.Scan(
			&item.AppCode,
			&item.ExternalRef,
			&item.CommandID,
			&item.SellerUserID,
			&item.SellerRegionID,
			&productID,
			&productCode,
			&productName,
			&item.CoinAmount,
			&item.USDMinorAmount,
			&item.ProviderCode,
			&item.UserPaidCurrencyCode,
			&item.ProviderAmountMinor,
			&providerOrderID,
			&walletTransactionID,
			&item.CreatedAtMS,
			&createdAtMS,
		); err != nil {
			return nil, 0, err
		}
		item.TransactionID = firstNonEmptyPaymentString(walletTransactionID, item.ExternalRef)
		item.RechargeType = "coin_seller"
		item.Status = "succeeded"
		item.TargetRegionID = item.SellerRegionID
		item.PolicyID = productID
		item.PolicyVersion = productCode
		item.CurrencyCode = "USD"
		item.UserPaidAmountMicro = item.ProviderAmountMinor * 10_000
		item.PaidSyncedAtMS = item.CreatedAtMS
		if item.UserPaidCurrencyCode == "" {
			item.UserPaidCurrencyCode = "USD"
			item.UserPaidAmountMicro = item.USDMinorAmount * 10_000
		}
		if providerOrderID != "" {
			item.ExternalRef = providerOrderID
		}
		if item.CreatedAtMS == 0 {
			item.CreatedAtMS = createdAtMS
		}
		items = append(items, item)
	}
	return items, total, rows.Err()
}

func financeCoinSellerRechargeOrderBill(order model.CoinSellerRechargeOrder) rechargeBillDTO {
	currency := firstNonEmptyPaymentString(order.ProviderCurrencyCode, "USD")
	providerAmountMinor := order.ProviderAmountMinor
	userPaidAmountMicro := providerAmountMinor * 10_000
	if providerAmountMinor == 0 {
		userPaidAmountMicro = order.USDMinorAmount * 10_000
	}
	return rechargeBillDTO{
		AppCode:              order.AppCode,
		TransactionID:        firstNonEmptyPaymentString(order.WalletTransactionID, fmt.Sprintf("coin-seller-order:%d", order.ID)),
		CommandID:            order.WalletCommandID,
		RechargeType:         "coin_seller",
		Status:               "succeeded",
		ExternalRef:          firstNonEmptyPaymentString(order.ProviderOrderID, order.ExternalOrderNo),
		SellerUserID:         order.TargetUserID,
		SellerRegionID:       order.TargetRegionID,
		TargetRegionID:       order.TargetRegionID,
		CurrencyCode:         "USD",
		CoinAmount:           order.CoinAmount,
		USDMinorAmount:       order.USDMinorAmount,
		ProviderAmountMinor:  providerAmountMinor,
		CreatedAtMS:          order.CreatedAtMS,
		ProviderCode:         order.ProviderCode,
		UserPaidCurrencyCode: currency,
		UserPaidAmountMicro:  userPaidAmountMicro,
		PaidSyncedAtMS:       order.CreatedAtMS,
	}
}

func h5CoinSellerRechargeWhere(appCode string, query financeCoinSellerRechargeQuery) (string, []any) {
	where := []string{
		"eo.app_code = ?",
		"eo.audience_type = 'coin_seller'",
		"eo.status = 'credited'",
		"eo.wallet_transaction_id <> ''",
		"wt.biz_type = 'coin_seller_recharge'",
		"wt.status = 'succeeded'",
	}
	args := []any{appCode}
	if query.TargetUserID > 0 {
		where = append(where, "eo.target_user_id = ?")
		args = append(args, query.TargetUserID)
	}
	if query.RegionID > 0 {
		where = append(where, "eo.target_region_id = ?")
		args = append(args, query.RegionID)
	}
	if query.StartAtMS > 0 {
		where = append(where, "eo.updated_at_ms >= ?")
		args = append(args, query.StartAtMS)
	}
	if query.EndAtMS > 0 {
		where = append(where, "eo.updated_at_ms < ?")
		args = append(args, query.EndAtMS)
	}
	if keyword := strings.TrimSpace(query.Keyword); keyword != "" {
		like := "%" + keyword + "%"
		where = append(where, "(eo.order_id LIKE ? OR eo.provider_order_id LIKE ? OR eo.wallet_transaction_id LIKE ? OR eo.product_code LIKE ? OR eo.product_name LIKE ? OR eo.tx_hash LIKE ? OR CAST(eo.target_user_id AS CHAR) LIKE ?)")
		args = append(args, like, like, like, like, like, like, like)
	}
	return "WHERE " + strings.Join(where, " AND "), args
}

func financeCoinSellerSucceededStatus(status string) bool {
	switch strings.ToLower(strings.TrimSpace(status)) {
	case "", "all", "succeeded", "success":
		return true
	default:
		return false
	}
}

func financeCoinSellerPage(page int, pageSize int, maxPageSize int) (int, int) {
	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 10
	}
	if maxPageSize <= 0 {
		maxPageSize = financeCoinSellerRechargeMaxPageSize
	}
	if pageSize > maxPageSize {
		pageSize = maxPageSize
	}
	return page, pageSize
}

func financeRechargePrefetch(page int, pageSize int, maxPageSize int) int {
	prefetch := page * pageSize
	limit := financeRechargeMergeMaxPrefetch
	if maxPageSize > limit {
		limit = maxPageSize
	}
	if prefetch > limit {
		return limit
	}
	return prefetch
}

func sortRechargeBills(items []rechargeBillDTO) {
	sort.Slice(items, func(i, j int) bool {
		if items[i].CreatedAtMS == items[j].CreatedAtMS {
			return items[i].TransactionID > items[j].TransactionID
		}
		return items[i].CreatedAtMS > items[j].CreatedAtMS
	})
}

func mergeRechargeRegionBuckets(groups ...[]rechargeBillRegionBucketDTO) []rechargeBillRegionBucketDTO {
	byRegion := map[int64]*rechargeBillRegionBucketDTO{}
	for _, group := range groups {
		for _, row := range group {
			if row.RegionID <= 0 {
				continue
			}
			bucket, ok := byRegion[row.RegionID]
			if !ok {
				copy := row
				byRegion[row.RegionID] = &copy
				continue
			}
			bucket.BillCount += row.BillCount
			bucket.UsdMinorAmount += row.UsdMinorAmount
			if bucket.Name == "" {
				bucket.Name = row.Name
			}
		}
	}
	out := make([]rechargeBillRegionBucketDTO, 0, len(byRegion))
	for _, bucket := range byRegion {
		out = append(out, *bucket)
	}
	sort.Slice(out, func(i, j int) bool {
		return out[i].UsdMinorAmount > out[j].UsdMinorAmount
	})
	return out
}

func (h *Handler) fillFinanceCoinSellerRegionNames(ctx context.Context, appCode string, buckets []rechargeBillRegionBucketDTO) []rechargeBillRegionBucketDTO {
	if len(buckets) == 0 {
		return buckets
	}
	names := map[int64]string{}
	if h != nil {
		if regions, err := h.listRechargeBillRegions(ctx, appCode); err == nil {
			for _, region := range regions {
				name := firstNonEmptyPaymentString(region.Name, region.RegionCode, strconv.FormatInt(region.RegionID, 10))
				names[region.RegionID] = name
			}
		}
	}
	for i := range buckets {
		if name := names[buckets[i].RegionID]; name != "" {
			buckets[i].Name = name
			continue
		}
		buckets[i].Name = strconv.FormatInt(buckets[i].RegionID, 10)
	}
	return buckets
}

func firstNonEmptyPaymentString(values ...string) string {
	for _, value := range values {
		if strings.TrimSpace(value) != "" {
			return strings.TrimSpace(value)
		}
	}
	return ""
}