package rechargereward

import (
	"context"
	"encoding/json"
	"fmt"
	"math"
	"net/http"
	"strings"
	"time"
)

var personalMonthlyRechargeTypes = []string{
	"UNDEFINED",
	"HUAWEI",
	"GOOGLE",
	"APPLE",
	"PAYER_MAX",
	"SHIPPING_AGENT",
	"STRIPE",
	"SALARY_EXCHANGE",
	"PAY_PAL",
	"CLIPSPAY",
	"SELLER_AGENT",
}

type rechargeRewardClaimRecordRow struct {
	UserID           int64  `gorm:"column:user_id"`
	RechargeAmount   string `gorm:"column:recharge_amount"`
	LastRechargeTime string `gorm:"column:last_recharge_time"`
	LastClaimTime    string `gorm:"column:last_claim_time"`
	Account          string `gorm:"column:account"`
	UserAvatar       string `gorm:"column:user_avatar"`
	UserNickname     string `gorm:"column:user_nickname"`
	CountryCode      string `gorm:"column:country_code"`
	CountryName      string `gorm:"column:country_name"`
}

type rechargeRewardClaimDetailRow struct {
	UserID          int64  `gorm:"column:user_id"`
	ActivityID      int64  `gorm:"column:activity_id"`
	Level           int    `gorm:"column:level"`
	ResourceGroupID *int64 `gorm:"column:resource_group_id"`
	RuleDescription string `gorm:"column:rule_description"`
	JSONData        string `gorm:"column:json_data"`
	ClaimTime       string `gorm:"column:claim_time"`
}

// PageClaimRecords 分页返回真实领取过累计充值奖励的用户。
func (s *Service) PageClaimRecords(ctx context.Context, sysOrigin string, month string, userID int64, cursor int, limit int) (*RechargeRewardClaimRecordPageResponse, error) {
	sysOrigin = s.normalizeSysOrigin(sysOrigin)
	cursor, limit = NormalizePage(cursor, limit)

	bundle, err := s.loadConfigBundle(ctx, sysOrigin)
	if err != nil {
		return nil, err
	}
	location := s.location
	if bundle.Config != nil {
		location = resolveLocation(bundle.Config.Timezone, s.location)
	}
	rechargeDate, displayMonth, err := normalizeRechargeRewardRecordMonth(month, time.Now().In(location))
	if err != nil {
		return nil, err
	}

	var total int64
	countSQL := `
SELECT COUNT(DISTINCT receive.user_id)
FROM user_activity_reward_receive_record AS receive
INNER JOIN props_activity_rule_config AS rule ON rule.id = receive.activity_id
WHERE receive.recharge_date = ?
  AND rule.sys_origin = ?
  AND rule.activity_type = 'CUMULATIVE_RECHARGE'
  AND COALESCE(rule.is_del, 0) = 0
  AND (? = 0 OR receive.user_id = ?)`
	if err := s.db.WithContext(ctx).Raw(
		countSQL,
		rechargeDate,
		sysOrigin,
		userID,
		userID,
	).Scan(&total).Error; err != nil {
		return nil, err
	}

	records := make([]RechargeRewardClaimRecordView, 0)
	if total > 0 {
		var rows []rechargeRewardClaimRecordRow
		listSQL := `
SELECT
  claims.user_id,
  COALESCE(recharge.recharge_amount, 0) AS recharge_amount,
  COALESCE(recharge.last_recharge_time, '') AS last_recharge_time,
  claims.last_claim_time,
  user.account,
  user.user_avatar,
  user.user_nickname,
  user.country_code,
  user.country_name
FROM (
  SELECT
    receive.user_id,
    MAX(receive.create_time) AS last_claim_time
  FROM user_activity_reward_receive_record AS receive
  INNER JOIN props_activity_rule_config AS rule ON rule.id = receive.activity_id
  WHERE receive.recharge_date = ?
    AND rule.sys_origin = ?
    AND rule.activity_type = 'CUMULATIVE_RECHARGE'
    AND COALESCE(rule.is_del, 0) = 0
    AND (? = 0 OR receive.user_id = ?)
  GROUP BY receive.user_id
  ORDER BY MAX(receive.create_time) DESC, receive.user_id ASC
  LIMIT ? OFFSET ?
) AS claims
INNER JOIN user_base_info AS user ON user.id = claims.user_id
LEFT JOIN (
  SELECT
    recharge.user_id,
    SUM(recharge.amount) AS recharge_amount,
    MAX(recharge.update_time) AS last_recharge_time
  FROM user_monthly_recharge_v2 AS recharge
  WHERE recharge.recharge_date = ?
    AND recharge.type IN ?
  GROUP BY recharge.user_id
) AS recharge ON recharge.user_id = claims.user_id
ORDER BY claims.last_claim_time DESC, claims.user_id ASC`
		if err := s.db.WithContext(ctx).Raw(
			listSQL,
			rechargeDate,
			sysOrigin,
			userID,
			userID,
			limit,
			(cursor-1)*limit,
			rechargeDate,
			personalMonthlyRechargeTypes,
		).Scan(&rows).Error; err != nil {
			return nil, err
		}
		details, err := s.loadClaimDetails(ctx, sysOrigin, rechargeDate, claimRecordUserIDs(rows))
		if err != nil {
			return nil, err
		}
		rewardItems := s.loadRewardItemsMap(ctx, claimDetailLevels(details))
		records = make([]RechargeRewardClaimRecordView, 0, len(rows))
		for _, row := range rows {
			records = append(records, rechargeRewardClaimRecordView(row, displayMonth, rechargeDate, details[row.UserID], rewardItems))
		}
	}

	return &RechargeRewardClaimRecordPageResponse{
		Month:        displayMonth,
		RechargeDate: rechargeDate,
		Timezone:     location.String(),
		Records:      records,
		Total:        total,
		Current:      cursor,
		Size:         limit,
	}, nil
}

func emptyRechargeRewardClaimRecordPage(month string, rechargeDate int, timezone string, cursor int, limit int) *RechargeRewardClaimRecordPageResponse {
	return &RechargeRewardClaimRecordPageResponse{
		Month:        month,
		RechargeDate: rechargeDate,
		Timezone:     timezone,
		Records:      []RechargeRewardClaimRecordView{},
		Total:        0,
		Current:      cursor,
		Size:         limit,
	}
}

func normalizeRechargeRewardRecordMonth(raw string, now time.Time) (int, string, error) {
	value := strings.TrimSpace(raw)
	if value == "" {
		value = now.Format("2006-01")
	}
	if len(value) == 6 && !strings.Contains(value, "-") {
		value = value[:4] + "-" + value[4:]
	}
	parsed, err := time.Parse("2006-01", value)
	if err != nil {
		return 0, "", NewAppError(http.StatusBadRequest, "invalid_month", "month must be YYYY-MM")
	}
	rechargeDate := parsed.Year()*100 + int(parsed.Month())
	return rechargeDate, parsed.Format("2006-01"), nil
}

func enabledRechargeRewardLevels(levels []rechargeRewardLevelSnapshot) []rechargeRewardLevelSnapshot {
	result := make([]rechargeRewardLevelSnapshot, 0, len(levels))
	for _, level := range levels {
		if !level.Enabled || level.RechargeAmountCents <= 0 {
			continue
		}
		result = append(result, level)
	}
	sortLevels(result)
	return result
}

func rechargeRewardClaimRecordView(
	row rechargeRewardClaimRecordRow,
	month string,
	rechargeDate int,
	details []rechargeRewardClaimDetailRow,
	rewardItems map[int64][]RechargeRewardRewardItem,
) RechargeRewardClaimRecordView {
	rechargeCents := parseIntegrationAmountCents(integrationAmount(row.RechargeAmount))
	reached := claimDetailPayloads(details, rewardItems)
	return RechargeRewardClaimRecordView{
		RecordKey:           fmt.Sprintf("%d-%d", row.UserID, rechargeDate),
		UserID:              row.UserID,
		Account:             strings.TrimSpace(row.Account),
		UserAvatar:          strings.TrimSpace(row.UserAvatar),
		UserNickname:        strings.TrimSpace(row.UserNickname),
		CountryCode:         strings.TrimSpace(row.CountryCode),
		CountryName:         strings.TrimSpace(row.CountryName),
		RechargeMonth:       month,
		RechargeDate:        rechargeDate,
		RechargeAmount:      formatAmountCents(rechargeCents),
		RechargeAmountCents: rechargeCents,
		ReachedLevels:       reached,
		ClaimedRewards:      rechargeRewardClaimedRewards(reached),
		LastRechargeTime:    formatRechargeRewardRecordTime(row.LastRechargeTime),
	}
}

func (s *Service) loadClaimDetails(ctx context.Context, sysOrigin string, rechargeDate int, userIDs []int64) (map[int64][]rechargeRewardClaimDetailRow, error) {
	if len(userIDs) == 0 {
		return map[int64][]rechargeRewardClaimDetailRow{}, nil
	}
	var rows []rechargeRewardClaimDetailRow
	detailSQL := `
SELECT
  receive.user_id,
  receive.activity_id,
  COALESCE(rule.sort, 0) AS level,
  rule.resource_group_id,
  rule.rule_description,
  rule.json_data,
  receive.create_time AS claim_time
FROM user_activity_reward_receive_record AS receive
INNER JOIN props_activity_rule_config AS rule ON rule.id = receive.activity_id
WHERE receive.recharge_date = ?
  AND rule.sys_origin = ?
  AND rule.activity_type = 'CUMULATIVE_RECHARGE'
  AND COALESCE(rule.is_del, 0) = 0
  AND receive.user_id IN ?
ORDER BY receive.user_id ASC, COALESCE(rule.sort, 0) ASC, receive.create_time ASC`
	if err := s.db.WithContext(ctx).Raw(detailSQL, rechargeDate, sysOrigin, userIDs).Scan(&rows).Error; err != nil {
		return nil, err
	}
	result := make(map[int64][]rechargeRewardClaimDetailRow, len(userIDs))
	for _, row := range rows {
		result[row.UserID] = append(result[row.UserID], row)
	}
	return result, nil
}

func claimRecordUserIDs(rows []rechargeRewardClaimRecordRow) []int64 {
	result := make([]int64, 0, len(rows))
	seen := make(map[int64]struct{}, len(rows))
	for _, row := range rows {
		if row.UserID <= 0 {
			continue
		}
		if _, exists := seen[row.UserID]; exists {
			continue
		}
		seen[row.UserID] = struct{}{}
		result = append(result, row.UserID)
	}
	return result
}

func claimDetailLevels(details map[int64][]rechargeRewardClaimDetailRow) []rechargeRewardLevelSnapshot {
	levels := make([]rechargeRewardLevelSnapshot, 0)
	seen := make(map[int64]struct{})
	for _, rows := range details {
		for _, row := range rows {
			if row.ResourceGroupID == nil || *row.ResourceGroupID <= 0 {
				continue
			}
			if _, exists := seen[*row.ResourceGroupID]; exists {
				continue
			}
			seen[*row.ResourceGroupID] = struct{}{}
			levels = append(levels, rechargeRewardLevelSnapshot{
				RewardGroupID: row.ResourceGroupID,
				Enabled:       true,
			})
		}
	}
	return levels
}

func claimDetailPayloads(
	details []rechargeRewardClaimDetailRow,
	rewardItems map[int64][]RechargeRewardRewardItem,
) []RechargeRewardLevelPayload {
	result := make([]RechargeRewardLevelPayload, 0, len(details))
	for index, detail := range details {
		level := detail.Level
		if level <= 0 {
			level = index + 1
		}
		var items []RechargeRewardRewardItem
		if detail.ResourceGroupID != nil {
			items = rewardItems[*detail.ResourceGroupID]
		}
		thresholdCents := rechargeRewardRuleQuantityCents(detail.JSONData)
		result = append(result, RechargeRewardLevelPayload{
			ID:                  detail.ActivityID,
			Level:               level,
			RechargeAmount:      formatAmountCents(thresholdCents),
			RechargeAmountCents: thresholdCents,
			RewardGroupID:       detail.ResourceGroupID,
			RewardGroupName:     strings.TrimSpace(detail.RuleDescription),
			RewardItems:         items,
			Enabled:             true,
			Reached:             true,
		})
	}
	return result
}

func rechargeRewardRuleQuantityCents(raw string) int64 {
	var payload map[string]any
	if err := json.Unmarshal([]byte(strings.TrimSpace(raw)), &payload); err != nil {
		return 0
	}
	value, ok := payload["quantity"]
	if !ok {
		return 0
	}
	switch typed := value.(type) {
	case float64:
		return int64(math.Round(typed * 100))
	case string:
		cents, err := parseAmountCents(typed)
		if err != nil {
			return 0
		}
		return cents
	default:
		cents, err := parseAmountCents(fmt.Sprint(typed))
		if err != nil {
			return 0
		}
		return cents
	}
}

func reachedRechargeRewardLevels(
	levels []rechargeRewardLevelSnapshot,
	rewardItems map[int64][]RechargeRewardRewardItem,
	rechargeCents int64,
) []RechargeRewardLevelPayload {
	result := make([]RechargeRewardLevelPayload, 0)
	for _, level := range levels {
		if rechargeCents < level.RechargeAmountCents {
			continue
		}
		var items []RechargeRewardRewardItem
		if level.RewardGroupID != nil {
			items = rewardItems[*level.RewardGroupID]
		}
		result = append(result, 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:             true,
		})
	}
	return result
}

func rechargeRewardClaimedRewards(levels []RechargeRewardLevelPayload) []RechargeRewardClaimedRewardPayload {
	result := make([]RechargeRewardClaimedRewardPayload, 0, len(levels))
	for _, level := range levels {
		result = append(result, RechargeRewardClaimedRewardPayload{
			Level:               level.Level,
			RechargeAmount:      level.RechargeAmount,
			RechargeAmountCents: level.RechargeAmountCents,
			RewardGold:          level.RewardGold,
			RewardGroupID:       level.RewardGroupID,
			RewardGroupName:     level.RewardGroupName,
			RewardItems:         level.RewardItems,
		})
	}
	return result
}

func formatRechargeRewardRecordTime(raw string) string {
	value := strings.TrimSpace(raw)
	if value == "" {
		return ""
	}
	for _, layout := range []string{
		"2006-01-02 15:04:05.999999999-07:00",
		"2006-01-02 15:04:05.999999999",
		"2006-01-02 15:04:05",
		time.RFC3339Nano,
		time.RFC3339,
	} {
		if parsed, err := time.Parse(layout, value); err == nil {
			return formatDateTime(parsed)
		}
	}
	if len(value) > len("2006-01-02 15:04:05") {
		return value[:len("2006-01-02 15:04:05")]
	}
	return value
}