package sniper

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"huya-go/internal/huya"
)

// TestClassifyExchangeThrottleTexts 覆盖 2026-10-16 三台机器日志里真实出现过的限流文案。
//
// 这些文案过去全部落到 failed：既看不出被限流，也享受不到限流该有的退避语义
// （pc-1 的 1421 次请求里 917 次「活动太火爆」+ 244 次「领取频率限制」）。
func TestClassifyExchangeThrottleTexts(t *testing.T) {
	throttleTexts := []string{
		"活动太火爆了，请稍后重试",
		"领取频率限制，请稍后重试！！",
		"请求太频繁，请稍后重试",
		"操作频繁,请稍后再试",
		"当前网络繁忙，请稍后重试",
		"您点击太快，请稍等再试",
	}
	for _, text := range throttleTexts {
		resp := &huya.ScoreExchangePrizeResp{Status: 500, Msg: text}
		if got := ClassifyExchange(resp, nil); got != CategoryTooFrequent {
			t.Fatalf("ClassifyExchange(%q)=%s, want %s", text, got, CategoryTooFrequent)
		}
	}
}

// TestClassifyExchangeOrderPrefersSpecificReason 验证具体原因优先于限流：
// 「库存不足，请稍后重试」必须判成售罄而不是限流。
func TestClassifyExchangeOrderPrefersSpecificReason(t *testing.T) {
	cases := []struct {
		text string
		want string
	}{
		{text: "库存不足，请稍后重试", want: CategorySoldOut},
		{text: "该奖品已抢完", want: CategorySoldOut},
		{text: "兑换货币不足，请参与活动获得兑换货币", want: CategoryNotEnough},
		{text: "奖品暂未开放兑换", want: CategoryNotOpen},
		{text: "账号未绑定！", want: CategorySessionLost},
		{text: "登录态已失效，请重新登录", want: CategorySessionLost},
		{text: "奖品已下架", want: CategoryOffShelf},
	}
	for _, tt := range cases {
		resp := &huya.ScoreExchangePrizeResp{Status: 500, Msg: tt.text}
		if got := ClassifyExchange(resp, nil); got != tt.want {
			t.Fatalf("ClassifyExchange(%q)=%s, want %s", tt.text, got, tt.want)
		}
	}
}

// TestClassifyExchangeProtocolError 验证协议层错误与普通失败分开归类。
func TestClassifyExchangeProtocolError(t *testing.T) {
	protocolErr := fmt.Errorf("%w: webActUI.scoreExchangePrize 响应缺少 tRsp/tResp（iRet=-1 keys={tErr}）", huya.ErrProtocolResponse)
	if got := ClassifyExchange(nil, protocolErr); got != CategoryProtocol {
		t.Fatalf("协议错误应归为 %s，实际 %s", CategoryProtocol, got)
	}
	if got := ClassifyExchange(nil, errors.New("timeout")); got != CategoryError {
		t.Fatalf("普通网络错误应归为 %s，实际 %s", CategoryError, got)
	}
}

// TestCategoryLabelAndLogLevel 验证新增分类的标签与日志等级映射。
func TestCategoryLabelAndLogLevel(t *testing.T) {
	if got := CategoryLabel(CategoryProtocol); got != "协议异常" {
		t.Fatalf("CategoryLabel(protocol)=%q", got)
	}
	if got := LogLevelForCategory(CategoryProtocol); got != "error" {
		t.Fatalf("协议异常应为 error 级，实际 %s", got)
	}
	if got := LogLevelForCategory(CategorySessionLost); got != "warn" {
		t.Fatalf("会话失效应为 warn 级，实际 %s", got)
	}
}

// TestRetryEscalationMath 验证退避阶梯的两个纯函数。
func TestRetryEscalationMath(t *testing.T) {
	wantStreak := map[int]int{1: 1, 2: 1, 3: 2, 4: 4, 5: 4, 9: 4}
	for streak, want := range wantStreak {
		if got := streakMultiplier(streak); got != want {
			t.Fatalf("streakMultiplier(%d)=%d, want %d", streak, got, want)
		}
	}
	wantStage := map[time.Duration]int{
		500 * time.Millisecond: 1,
		3 * time.Second:        2,
		6 * time.Second:        3,
	}
	for elapsed, want := range wantStage {
		if got := stageMultiplier(elapsed, CategoryFailed); got != want {
			t.Fatalf("stageMultiplier(%v)=%d, want %d", elapsed, got, want)
		}
	}
	// 正常等待类（售罄/未开放）放慢得更保守，避免错过库存回流。
	if got := stageMultiplier(6*time.Second, CategorySoldOut); got != 2 {
		t.Fatalf("售罄阶段倍率=%d, want 2", got)
	}
}

// TestThrottleGovernorEscalatesAndRecovers 验证全局降速器：连续无进展才降速、有进展立刻回退。
func TestThrottleGovernorEscalatesAndRecovers(t *testing.T) {
	g := newThrottleGovernor()
	g.minRequests = 2
	g.stallWindow = time.Millisecond
	g.lastProgress = time.Now().Add(-time.Second)
	g.lastEscalate = time.Now().Add(-time.Second)

	g.observe(CategoryTooFrequent)
	if got := g.current(); got != 1 {
		t.Fatalf("未达阈值不该降速，factor=%v", got)
	}
	g.observe(CategoryTooFrequent)
	if got := g.current(); got <= 1 {
		t.Fatalf("连续无进展应开始降速，factor=%v", got)
	}
	if got := g.peak(); got <= 1 {
		t.Fatalf("peak 应记录最大倍率，实际 %v", got)
	}

	before := g.current()
	g.observe(CategorySuccess)
	if got := g.current(); got >= before {
		t.Fatalf("有进展后应回退，factor 从 %v 到 %v", before, got)
	}
	if got := g.current(); got < 1 {
		t.Fatalf("倍率不应小于 1，实际 %v", got)
	}
}

// TestRunStateFirstWaveStagger 验证首发错峰：第 0 个账号立即发，其余按步长错开，每个账号只生效一次。
func TestRunStateFirstWaveStagger(t *testing.T) {
	accounts := []Account{{UID: 1, Cookie: "yyuid=1"}, {UID: 2, Cookie: "yyuid=2"}, {UID: 3, Cookie: "yyuid=3"}}
	state := newRunState(accounts, 1, 1, Config{
		OpenAt:           time.Now(),
		FirstWaveSpread:  DefaultFirstWaveSpread,
		FirstWaveMaxStep: DefaultFirstWaveMaxStep,
	})
	want := []time.Duration{0, DefaultFirstWaveMaxStep, 2 * DefaultFirstWaveMaxStep}
	for index, account := range accounts {
		if got := state.takeFirstWaveDelay(account.UID); got != want[index] {
			t.Fatalf("账号 %d 首发等待=%v, want %v", account.UID, got, want[index])
		}
	}
	if got := state.takeFirstWaveDelay(1); got != 0 {
		t.Fatalf("同一账号不应重复错峰，实际 %v", got)
	}
}

// TestRunTargetsWindowModeKeepsTryingUntilDeadline 是 P1 的核心回归：
// 账号很少时，旧实现会「20 轮 × 150ms」在开抢前把预算烧光（pc-3 instance-4 0 成功），
// 窗口模式必须一直打到窗口结束。
func TestRunTargetsWindowModeKeepsTryingUntilDeadline(t *testing.T) {
	client := &fakeActivityClient{
		exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
			return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "活动太火爆了，请稍后重试"}, nil
		},
	}
	runner := Runner{Client: client}
	started := time.Now()
	err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{{PID: 12889}}, Config{
		SID:                2203,
		OpenAt:             started,
		windowOverride:     120 * time.Millisecond,
		Loops:              0, // 窗口模式：不限制轮次
		Delay:              5 * time.Millisecond,
		ErrorBackoff:       time.Millisecond,
		TooFrequentBackoff: time.Millisecond,
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if elapsed := time.Since(started); elapsed < 100*time.Millisecond {
		t.Fatalf("窗口模式应跑到窗口结束，实际只跑了 %v", elapsed)
	}
	_, exchangeCount, _ := client.counts()
	if exchangeCount < 5 {
		t.Fatalf("窗口内应持续尝试，实际只有 %d 次", exchangeCount)
	}
}

// TestRunTargetsPrefireOnceBeforeOpen 验证开抢前只预打一轮，然后静默等到窗口起点。
func TestRunTargetsPrefireOnceBeforeOpen(t *testing.T) {
	var mu sync.Mutex
	var calls []time.Time
	client := &fakeActivityClient{
		exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
			mu.Lock()
			calls = append(calls, time.Now())
			mu.Unlock()
			return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "奖品暂未开放兑换"}, nil
		},
	}
	runner := Runner{Client: client}
	// 触发时刻远早于窗口起点：应当先预打一轮，再静默等到窗口起点。
	openAt := time.Now().Add(500 * time.Millisecond)
	started := time.Now()
	err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{{PID: 12889}}, Config{
		SID:                2203,
		OpenAt:             openAt,
		windowOverride:     60 * time.Millisecond,
		Loops:              0,
		Delay:              5 * time.Millisecond,
		StartAhead:         20 * time.Millisecond,
		ErrorBackoff:       time.Millisecond,
		TooFrequentBackoff: time.Millisecond,
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	mu.Lock()
	captured := append([]time.Time(nil), calls...)
	mu.Unlock()
	if len(captured) < 2 {
		t.Fatalf("应有预打 + 窗口内重试，实际 %d 次", len(captured))
	}
	windowStart := openAt.Add(-20 * time.Millisecond)
	if !captured[0].Before(windowStart.Add(-50 * time.Millisecond)) {
		t.Fatalf("第一次请求应明显早于窗口起点（预打），实际 %v（窗口起点 %v）", captured[0], windowStart)
	}
	for _, at := range captured[1:] {
		if at.Before(windowStart.Add(-30 * time.Millisecond)) {
			t.Fatalf("预打之后应等到窗口起点，实际在 %v（窗口起点 %v）", at, windowStart)
		}
	}
	if elapsed := time.Since(started); elapsed < 500*time.Millisecond {
		t.Fatalf("应跑到窗口结束（%v），实际 %v", openAt.Add(60*time.Millisecond), elapsed)
	}
}

// TestRunTargetsSkipsPrefireNearWindowStart 验证触发时刻与窗口起点重合时不会把首发齐射打两遍。
func TestRunTargetsSkipsPrefireNearWindowStart(t *testing.T) {
	client := &fakeActivityClient{}
	runner := Runner{Client: client}
	openAt := time.Now().Add(60 * time.Millisecond)
	err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{{PID: 12889}}, Config{
		SID:            2203,
		OpenAt:         openAt,
		windowOverride: 40 * time.Millisecond,
		Loops:          1, // 只跑一轮，用于观察首发是否被重复
		StartAhead:     60 * time.Millisecond,
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if _, exchangeCount, _ := client.counts(); exchangeCount != 1 {
		t.Fatalf("窗口起点附近不应额外预打，实际请求 %d 次", exchangeCount)
	}
}

// TestRunTargetsWindowAlreadyExpiredSkips 验证窗口已过时不再发请求。
func TestRunTargetsWindowAlreadyExpiredSkips(t *testing.T) {
	client := &fakeActivityClient{}
	runner := Runner{Client: client}
	started := time.Now()
	err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{{PID: 12889}}, Config{
		SID:            2203,
		OpenAt:         time.Now().Add(-2 * time.Second),
		windowOverride: time.Second,
		Loops:          0,
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if _, exchangeCount, _ := client.counts(); exchangeCount != 0 {
		t.Fatalf("窗口已过不该发请求，实际 %d 次", exchangeCount)
	}
	if elapsed := time.Since(started); elapsed > 200*time.Millisecond {
		t.Fatalf("窗口已过应立即返回，实际 %v", elapsed)
	}
}

// TestRunTargetsSessionLostStopsAfterLimit 验证会话失效连续多次后停止该账号。
func TestRunTargetsSessionLostStopsAfterLimit(t *testing.T) {
	client := &fakeActivityClient{
		exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
			return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "账号未绑定！"}, nil
		},
	}
	runner := Runner{Client: client}
	err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{{PID: 12889}}, Config{
		SID:              2203,
		Loops:            10,
		Delay:            2 * time.Millisecond,
		ErrorBackoff:     time.Millisecond,
		SessionLostLimit: 3,
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	_, exchangeCount, _ := client.counts()
	if exchangeCount != 3 {
		t.Fatalf("连续失效达到阈值应停止该账号，实际请求 %d 次", exchangeCount)
	}
}

// TestRunTargetsSummaryIncludesRequestAndAccountStats 验证接口统计与逐账号结局。
func TestRunTargetsSummaryIncludesRequestAndAccountStats(t *testing.T) {
	client := &fakeActivityClient{
		exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
			return nil, errors.New("网络抖动")
		},
	}
	var summary RunSummary
	runner := Runner{Client: client, OnSummary: func(item RunSummary) { summary = item }}
	err := runner.RunTargets(context.Background(), []Account{{UID: 7, Cookie: "yyuid=7"}}, []Target{{PID: 12889}}, Config{
		SID:              2203,
		Loops:            2,
		Delay:            time.Millisecond,
		ErrorBackoff:     time.Millisecond,
		StopAfterSuccess: true,
	}, func(Result) {})
	if err != nil {
		t.Fatal(err)
	}
	var exchangeStat *RequestStat
	for index := range summary.RequestStats {
		if summary.RequestStats[index].Kind == reqExchange.String() {
			exchangeStat = &summary.RequestStats[index]
		}
	}
	if exchangeStat == nil {
		t.Fatalf("缺少兑换接口统计: %+v", summary.RequestStats)
	}
	if exchangeStat.Count < 1 || exchangeStat.Failed != exchangeStat.Count || exchangeStat.LastErr == "" {
		t.Fatalf("兑换接口统计不正确: %+v", *exchangeStat)
	}
	if exchangeStat.Slowest <= 0 {
		t.Fatalf("应记录最慢耗时: %+v", *exchangeStat)
	}
	if len(summary.AccountOutcomes) != 1 {
		t.Fatalf("应有 1 条账号结局，实际 %+v", summary.AccountOutcomes)
	}
	outcome := summary.AccountOutcomes[0]
	if outcome.UID != 7 || outcome.Category != CategoryError || outcome.Attempts < 1 {
		t.Fatalf("账号结局不正确: %+v", outcome)
	}
}

// TestPlanTriggerDynamicAdvance 验证定时触发计划：动态提前量、预热/复校/窗口时刻。
func TestPlanTriggerDynamicAdvance(t *testing.T) {
	target := time.Date(2026, 10, 16, 17, 0, 0, 0, time.Local)
	calibration := huya.TimeCalibration{
		Offset:     900 * time.Millisecond, // 本机比服务端慢 0.9s（pc-3 实测）
		ErrorBound: 30 * time.Millisecond,
		RTT:        60 * time.Millisecond,
	}
	plan := PlanTrigger(target, calibration, 0, 30*time.Second)

	if want := 60 * time.Millisecond; plan.Advance != want {
		t.Fatalf("动态提前量=%v, want %v", plan.Advance, want)
	}
	wantOpen := target.Add(-900 * time.Millisecond)
	if !plan.OpenAt.Equal(wantOpen) {
		t.Fatalf("开抢时刻=%v, want %v", plan.OpenAt, wantOpen)
	}
	if !plan.TriggerAt.Equal(wantOpen.Add(-60 * time.Millisecond)) {
		t.Fatalf("触发时刻=%v", plan.TriggerAt)
	}
	if !plan.WarmupAt.Equal(wantOpen.Add(-WarmupLead)) {
		t.Fatalf("预热时刻=%v", plan.WarmupAt)
	}
	if !plan.ResyncAt.Equal(wantOpen.Add(-ResyncLead)) {
		t.Fatalf("复校时刻=%v", plan.ResyncAt)
	}
	if !plan.WindowEnd.Equal(wantOpen.Add(30 * time.Second)) {
		t.Fatalf("窗口结束=%v", plan.WindowEnd)
	}

	if got := PlanTrigger(target, calibration, 2500*time.Millisecond, time.Second).Advance; got != 2500*time.Millisecond {
		t.Fatalf("显式提前量应覆盖动态值，实际 %v", got)
	}
	if got := PlanTrigger(target, huya.TimeCalibration{}, 0, time.Second).Advance; got != MinTriggerAdvance {
		t.Fatalf("提前量下限=%v, want %v", got, MinTriggerAdvance)
	}
	if got := WindowDuration(0); got != DefaultWindowSeconds*time.Second {
		t.Fatalf("默认窗口=%v", got)
	}
}

// TestRunTargetsPerAccountLoopsAreIndependent 是「每账号独立循环」的核心回归：
// 一个账号卡在慢请求上时，其他账号必须继续按自己的节奏推进。
//
// 旧实现按「一轮打完等所有人」（wg.Wait）同步，账号 1 的慢请求会把账号 2 的第二轮
// 死死卡在起跑线上；账号少的实例尤其吃亏（pc-3 instance-4 因此 0 成功）。
func TestRunTargetsPerAccountLoopsAreIndependent(t *testing.T) {
	blocked := make(chan struct{})
	entered := make(chan struct{})
	var enterOnce sync.Once
	var slowExchanges, fastExchanges int64

	client := &fakeActivityClient{
		exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
			if uid == 1 {
				atomic.AddInt64(&slowExchanges, 1)
				enterOnce.Do(func() { close(entered) })
				<-blocked
				return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "活动太火爆了，请稍后重试"}, nil
			}
			atomic.AddInt64(&fastExchanges, 1)
			return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "活动太火爆了，请稍后重试"}, nil
		},
	}
	runner := Runner{Client: client}
	accounts := []Account{{UID: 1, Cookie: "yyuid=1"}, {UID: 2, Cookie: "yyuid=2"}}

	done := make(chan error, 1)
	go func() {
		done <- runner.RunTargets(context.Background(), accounts, []Target{{PID: 12889}}, Config{
			SID:                2203,
			Loops:              30,
			Delay:              time.Millisecond,
			ErrorBackoff:       time.Millisecond,
			TooFrequentBackoff: time.Millisecond,
			Concurrency:        4,
		}, nil)
	}()

	select {
	case <-entered:
	case <-time.After(2 * time.Second):
		t.Fatal("账号 1 的慢请求未开始")
	}

	// 账号 1 仍阻塞在第一个请求里：账号 2 应当已经独立跑完多轮。
	deadline := time.Now().Add(2 * time.Second)
	for atomic.LoadInt64(&fastExchanges) < 3 && time.Now().Before(deadline) {
		time.Sleep(2 * time.Millisecond)
	}
	got := atomic.LoadInt64(&fastExchanges)
	close(blocked)

	if err := <-done; err != nil {
		t.Fatal(err)
	}
	if got < 3 {
		t.Fatalf("账号 1 阻塞期间账号 2 只完成了 %d 次兑换，独立循环应继续推进（want >= 3）", got)
	}
}

// TestRunTargetsSharedListTTLSingleFlight 验证共享列表快照是「TTL + 单飞」：
// 多个账号多轮里只查一次列表，既不被单次抖动拖垮，也不把名单打爆。
//
// 只做单飞（无 TTL）时每轮都会重新查询，2 账号 × 3 轮最坏要 6 次。
func TestRunTargetsSharedListTTLSingleFlight(t *testing.T) {
	client := &fakeActivityClient{
		listResp: &huya.GetActPrizeListResp{
			Status: 200,
			Msg:    "请求成功",
			Prizes: []huya.PrizeInfo{{ID: 12889, SID: 2203, Name: "套装-潮萌小黄鸭", NewScore: 988, LeftNum: 10}},
		},
		exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
			return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "活动太火爆了，请稍后重试"}, nil
		},
	}
	runner := Runner{Client: client}
	accounts := []Account{{UID: 1, Cookie: "yyuid=1"}, {UID: 2, Cookie: "yyuid=2"}}

	err := runner.RunTargets(context.Background(), accounts, []Target{{Name: "小黄鸭"}}, Config{
		SID:                2203,
		Loops:              3,
		Delay:              time.Millisecond,
		ErrorBackoff:       time.Millisecond,
		TooFrequentBackoff: time.Millisecond,
		Concurrency:        4,
		ListBeforeExchange: true,
		SharePrizeList:     true,
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	listCount, _, _ := client.counts()
	if listCount != 1 {
		t.Fatalf("共享列表应只查一次（TTL 内复用），实际 %d 次", listCount)
	}
}

// TestRunStateClipToDeadline 验证等待时间被裁剪到窗口结束，不会睡过 deadline。
func TestRunStateClipToDeadline(t *testing.T) {
	state := &runState{deadline: time.Now().Add(50 * time.Millisecond)}
	if got := state.clipToDeadline(10 * time.Millisecond); got != 10*time.Millisecond {
		t.Fatalf("窗口内等待不应被改动，实际 %v", got)
	}
	if got := state.clipToDeadline(time.Second); got <= 0 || got > 60*time.Millisecond {
		t.Fatalf("超出窗口的等待应被裁剪，实际 %v", got)
	}
	if got := (&runState{deadline: time.Now().Add(-time.Millisecond)}).clipToDeadline(time.Second); got != 0 {
		t.Fatalf("窗口已过应不再等待，实际 %v", got)
	}
	if got := (&runState{}).clipToDeadline(time.Second); got != time.Second {
		t.Fatalf("非窗口模式不应裁剪，实际 %v", got)
	}
}

// TestRunStateAccountFinishedAndRoundTracking 覆盖独立循环新增的两个判定：
// accountFinished（账号自己打完就退出，同时尊重全局目标终止）与最大轮次统计。
func TestRunStateAccountFinishedAndRoundTracking(t *testing.T) {
	state := newRunState([]Account{{UID: 1}}, 2, 1, Config{})
	if state.accountFinished(1, 2) {
		t.Fatal("目标都没完成时不应判定账号结束")
	}
	state.accounts[1][0].Done = true
	if state.accountFinished(1, 2) {
		t.Fatal("还有一个目标未完成时不应判定账号结束")
	}
	state.accounts[1][1].Done = true
	if !state.accountFinished(1, 2) {
		t.Fatal("所有目标完成后应判定账号结束")
	}

	// 全局目标终止（售罄 / 下架）后，即使本账号状态未落，也算完成。
	global := newRunState([]Account{{UID: 2}}, 1, 1, Config{})
	global.targetDone[0] = true
	if !global.accountFinished(2, 1) {
		t.Fatal("全局目标已终止时账号应判定结束")
	}

	rounds := newRunState([]Account{{UID: 3}}, 1, 1, Config{})
	rounds.noteRound(3)
	rounds.noteRound(2)
	rounds.noteRound(7)
	if got := rounds.maxRound(); got != 7 {
		t.Fatalf("最大轮次=%d, want 7", got)
	}
}