package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"sort"
	"strings"

	"bindbox-game/configs"
	"bindbox-game/internal/pkg/env"
	"bindbox-game/internal/pkg/logger"
	"bindbox-game/internal/repository/mysql"
	tcmodel "bindbox-game/internal/repository/mysql/task_center"
	taskcenter "bindbox-game/internal/service/task_center"
)

func main() {
	userID := flag.Int64("user", 0, "用户ID")
	taskID := flag.Int64("task", 0, "任务ID")
	flag.Parse()

	if *userID == 0 || *taskID == 0 {
		log.Fatalf("必须通过 -user 与 -task 指定用户与任务")
	}

	// 确认环境
	env.Active() // 触发解析 -env 或 ACTIVE_ENV
	configs.Init()

	repo, err := mysql.New()
	if err != nil {
		log.Fatalf("初始化 MySQL 失败: %v", err)
	}
	defer repo.DbRClose()
	defer repo.DbWClose()

	logg, err := logger.NewCustomLogger()
	if err != nil {
		log.Fatalf("初始化 logger 失败: %v", err)
	}

	svc := taskcenter.New(logg, repo, nil, nil, nil)

	ctx := context.Background()
	progress, err := svc.GetUserProgress(ctx, *userID, *taskID)
	if err != nil {
		log.Fatalf("查询进度失败: %v", err)
	}

	fmt.Printf("任务 %d 用户 %d 进度:\n", *taskID, *userID)
	fmt.Printf("  OrderCount=%d OrderAmount=%.2f InviteCount=%d FirstOrder=%v\n",
		progress.OrderCount,
		float64(progress.OrderAmount)/100,
		progress.InviteCount,
		progress.FirstOrder,
	)

	claimed := make(map[int64]struct{}, len(progress.ClaimedTiers))
	for _, tid := range progress.ClaimedTiers {
		claimed[tid] = struct{}{}
	}

	tiers := make([]tcmodel.TaskTier, 0)
	if err := repo.GetDbR().Where("task_id = ?", *taskID).Order("threshold ASC, id ASC").Find(&tiers).Error; err != nil {
		log.Fatalf("加载档位失败: %v", err)
	}

	fmt.Println("档位详情：")
	for _, tier := range tiers {
		tp := progress.TierProgressMap[tier.ID]
		currentValue, display := extractMetricValue(tier.Metric, tp)

		status := "未达标"
		if checkThreshold(tier, currentValue, progress.FirstOrder) {
			status = "已达标"
		}
		if _, ok := claimed[tier.ID]; ok {
			status += " (已领取)"
		}

		fmt.Printf("- Tier %d | metric=%s threshold=%d operator=%s window=%s activity=%d\n",
			tier.ID, tier.Metric, tier.Threshold, tier.Operator, tier.Window, tier.ActivityID)
		fmt.Printf("    当前值: %s -> %s\n", display, status)
	}

	if len(progress.ClaimedTiers) > 0 {
		sort.Slice(progress.ClaimedTiers, func(i, j int) bool { return progress.ClaimedTiers[i] < progress.ClaimedTiers[j] })
		fmt.Printf("已领取档位: %s\n", joinInt64s(progress.ClaimedTiers))
	}
}

func extractMetricValue(metric string, tp taskcenter.TierProgress) (int64, string) {
	switch metric {
	case taskcenter.MetricOrderAmount:
		return tp.OrderAmount, fmt.Sprintf("OrderAmount=%.2f", float64(tp.OrderAmount)/100)
	case taskcenter.MetricOrderCount:
		return tp.OrderCount, fmt.Sprintf("OrderCount=%d", tp.OrderCount)
	case taskcenter.MetricInviteCount:
		return tp.InviteCount, fmt.Sprintf("InviteCount=%d", tp.InviteCount)
	case taskcenter.MetricFirstOrder:
		if tp.FirstOrder {
			return 1, "FirstOrder=true"
		}
		return 0, "FirstOrder=false"
	default:
		return 0, "(unknown metric)"
	}
}

func checkThreshold(tier tcmodel.TaskTier, currentValue int64, firstOrder bool) bool {
	switch tier.Metric {
	case taskcenter.MetricFirstOrder:
		return firstOrder
	default:
		if tier.Operator == taskcenter.OperatorGTE {
			return currentValue >= tier.Threshold
		}
		return currentValue == tier.Threshold
	}
}

func joinInt64s(vals []int64) string {
	parts := make([]string, len(vals))
	for i, v := range vals {
		parts[i] = fmt.Sprintf("%d", v)
	}
	return strings.Join(parts, ",")
}