huya-go/internal/sniper/sniper.go

package sniper

import (
	"context"
	"errors"
	"fmt"
	"math/rand"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"huya-go/internal/huya"
)

const (
	CategoryReady       = "ready"
	CategorySuccess     = "success"
	CategoryNotFound    = "not_found"
	CategoryNotOpen     = "not_open"
	CategoryTooFrequent = "too_frequent"
	CategoryNotEnough   = "not_enough"
	CategoryAlreadyDone = "already_done"
	CategoryOffShelf    = "off_shelf"
	CategorySoldOut     = "sold_out"
	CategoryFailed      = "failed"
	CategoryError       = "error"
	// CategoryCondition 表示服务端返回了 precondition 门禁（条件未达成），
	// 没有可识别文案，按可重试失败处理但单独分类便于观察。
	CategoryCondition = "condition"
	// CategoryProtocol 表示服务端回包结构与协议约定不符（缺少 tRsp/tResp、解码失败等）。
	//
	// 单列一类是为了把「服务端回了看不懂的包」和普通业务失败分开：2026-10-16 pc-3
	// 日志里同一账号连续 13 次命中它，而同实例另外 28 个账号全部成功。
	CategoryProtocol = "protocol"
	// CategorySessionLost 表示会话/身份在服务端被重置（典型文案「账号未绑定！」）。
	//
	// 实测是瞬时错误——同一账号下一轮就能成功（pc-1 1199665636376：loop4 未绑定、
	// loop5 success），所以照常重试，只是单独计数，避免和真失败混在一起。
	CategorySessionLost = "session_lost"

	// actionExchangeCanceled 表示申请并发额度时任务已被取消：这次请求根本没发出去，
	// 不应产出结果，否则停止监控时每个排队账号都会刷一条错误。
	actionExchangeCanceled = "exchange_canceled"

	// DefaultWindowSeconds 是窗口模式下默认的抢购窗口长度。
	//
	// 实测 2026-10-16 开抢窗口只有约 9 秒（17:00:00.1 放量 → 17:00:09 售罄），但库存会
	// 因为别人锁单未支付 / 订单释放而回流（pc-2 在 17:02 手动补兑仍成功），
	// 所以默认给 30 秒：既能覆盖争抢期，又不会无限重试。
	DefaultWindowSeconds = 30
	// DefaultStartAhead 是窗口循环相对开抢时刻的提前量（先手缓冲），
	// 让第一轮请求正好落在开抢瞬间而不是晚一个 RTT。
	DefaultStartAhead = 60 * time.Millisecond
	// DefaultFirstWaveSpread / DefaultFirstWaveMaxStep 是首发错峰参数：
	// 第 0 个账号立即发，其余按 min(spread/(n-1), maxStep) 依次错开，整批最多铺开 spread。
	// 同机 152 个账号在同一毫秒齐射会把整机压上服务端令牌桶（pc-1 实测 82% 请求被限流）。
	DefaultFirstWaveSpread  = 300 * time.Millisecond
	DefaultFirstWaveMaxStep = 8 * time.Millisecond

	// maxRetryDelay 是任何一次账号退避的上限。
	//
	// 抢购窗口只有十几秒，库存随时可能回流，等待超过 1.5 秒就可能正好错过它
	// （参考 dygou_go：把任何一次等待都压在 2 秒以内）。
	maxRetryDelay = 1500 * time.Millisecond

	// governorMinRequests / governorStallWindow / governorMaxFactor 控制全局自适应降速。
	//
	// 触发信号刻意选「无进展」而不是「限流占比」：2026-10-16 的日志显示，即使成功率
	// 97.6% 的那一次，被限流的请求也占 67%，用占比阈值会把正常运行一起拖慢。
	// 真正的危险信号是「发了一堆请求、连一个业务响应都拿不到」，说明整机已经压在
	// 服务端令牌桶上（pc-1 峰值 122 req/s）。此时按 1.5 倍逐级降速，一旦恢复进展就快速回退。
	governorMinRequests = 12
	governorStallWindow = 800 * time.Millisecond
	governorMaxFactor   = 4.0
	governorStep        = 1.5

	// defaultRetryBackoff 是配置缺失时的退避基准（界面默认值同样是 300ms）。
	defaultRetryBackoff = 300 * time.Millisecond
	// prefireMinGap 是「还值得单独预打一轮」的最小时间余量：小于它就说明已经在窗口起点附近，
	// 直接进入窗口循环即可，避免把首发齐射打两遍。
	prefireMinGap = 250 * time.Millisecond
	// defaultSessionLostLimit 是「连续会话失效多少次后停止该账号」的默认阈值。
	// 实测同一账号下一轮就能成功，所以阈值不能太小（3 次足以排除偶发抖动）。
	defaultSessionLostLimit = 3

	// sharedListTTL 是共享奖品列表快照（SharePrizeList）的存活时间。
	//
	// 单次列表查询约 100ms，而单账号节奏是 cfg.Delay（默认 150~300ms）：TTL 取 1 秒既能让
	// 同一波账号复用同一份快照（pc-1 的 152 个账号从 152 次查询降到 1 次），又能在库存
	// 变化时及时刷新（实测库存会因别人锁单未支付而回流，快照不能太旧）。
	sharedListTTL = 1000 * time.Millisecond
)

// TargetSummary 把目标列表渲染成「13437(冠军之刃)」这样的单行摘要，供启动日志使用。
//
// 2026-10-16 的复盘正卡在「日志里没有目标 pid」：三台机器都只记了 sid 与 targets=1，
// 看不出各自打的是哪个奖品，也就无法解释为什么一台售罄、另一台库存完好。
func TargetSummary(targets []Target) string {
	parts := make([]string, 0, len(targets))
	for _, target := range targets {
		name := strings.TrimSpace(target.Name)
		switch {
		case target.PID > 0 && name != "":
			parts = append(parts, fmt.Sprintf("%d(%s)", target.PID, name))
		case target.PID > 0:
			parts = append(parts, strconv.FormatInt(int64(target.PID), 10))
		case name != "":
			parts = append(parts, name)
		case target.Auto:
			parts = append(parts, "自动选择")
		}
	}
	if len(parts) == 0 {
		return "未指定"
	}
	return strings.Join(parts, ",")
}

// CategoryLabel 返回结局分类的中文短标签，供任务结束时的结局日志使用。
func CategoryLabel(category string) string {
	switch category {
	case CategorySuccess:
		return "已抢到"
	case CategorySoldOut:
		return "售罄"
	case CategoryTooFrequent:
		return "被限流"
	case CategoryNotOpen:
		return "未开放"
	case CategoryNotEnough:
		return "积分不足"
	case CategoryAlreadyDone:
		return "已兑换过"
	case CategoryOffShelf:
		return "已下架"
	case CategorySessionLost:
		return "会话失效"
	case CategoryProtocol:
		return "协议异常"
	case CategoryCondition:
		return "条件未达成"
	case CategoryNotFound:
		return "未匹配到奖品"
	case CategoryError:
		return "请求异常"
	default:
		return "失败"
	}
}

// CategoryText 把类目限制渲染成日志文案（空串表示不限类目）。
func CategoryText(category string) string {
	key := strings.TrimSpace(category)
	if key == "" {
		return "不限"
	}
	return key
}

// LogLevelForCategory 把结果分类映射成日志等级，供界面按等级高亮与筛选。
func LogLevelForCategory(category string) string {
	switch category {
	case CategorySuccess:
		return "success"
	case CategoryError, CategoryProtocol:
		return "error"
	case CategoryFailed, CategoryTooFrequent, CategoryCondition, CategorySessionLost:
		return "warn"
	default:
		return "info"
	}
}

type Account struct {
	UID    int64  `json:"uid"`
	Cookie string `json:"-"`
}

type Target struct {
	PID      int32  `json:"pid"`
	Name     string `json:"name"`
	Auto     bool   `json:"auto,omitempty"`
	MaxPrice int64  `json:"max_price,omitempty"`
	MinLeft  int64  `json:"min_left,omitempty"`
}

type Config struct {
	SID int32
	// Category 限定只在某个类目（限量返场/精英专享，或类目 id）里挑选可兑奖品，
	// 留空表示不限制。见 huya.GetActPrizeListResp.FilterByCategory。
	Category                string
	Loops                   int
	Delay                   time.Duration
	Concurrency             int
	StopAfterSuccess        bool
	StopAccountAfterSuccess bool
	Prewarm                 bool
	DirectExchange          bool
	ListBeforeExchange      bool
	SharePrizeList          bool
	RefreshAfterSuccess     bool
	// StopOnNotEnough 表示「积分不足 / 已兑换」后终止该账号该奖品（默认 true：
	// 积分不会自己变多，继续打只是浪费请求）。
	StopOnNotEnough     bool
	ContinueOnNotEnough bool
	// StopOnSoldOut 表示「已抢完」后终止该奖品。默认 false：别人锁单未支付或取消
	// 会让库存回流，窗口内应当继续低频探测（dygou_go 2026-10-03 实测结论）。
	StopOnSoldOut      bool
	TooFrequentBackoff time.Duration
	ErrorBackoff       time.Duration

	// OpenAt 是本次抢购的开抢时刻（已按服务端时钟对齐的本机时刻）。
	//
	// 非零即「窗口模式」：终止条件由 OpenAt+WindowSeconds 决定，Loops 只作为可选的
	// 轮次上限。这样账号少时也不会像旧实现那样「20 轮 × 150ms = 3 秒」在开抢前把预算烧光
	// （2026-10-16 pc-3 instance-4 只有一个账号，20 轮全部打在开抢前 0.3 秒，0 成功）。
	OpenAt time.Time
	// WindowSeconds 是窗口长度（秒）；窗口模式下 <=0 时取 DefaultWindowSeconds。
	WindowSeconds int
	// StartAhead 是窗口循环相对 OpenAt 的提前量；<=0 时取 DefaultStartAhead。
	StartAhead time.Duration
	// FirstWaveSpread / FirstWaveMaxStep 是首发错峰参数，参考 dygou_go 的 firstWaveSpread。
	// FirstWaveSpread<=0 表示不启用错峰（测试与直接调用 RunTargets 的老行为）。
	FirstWaveSpread  time.Duration
	FirstWaveMaxStep time.Duration
	// DisableAdaptiveThrottle 关闭全局自适应降速。
	//
	// 默认开启（Go 零值无法表达「默认开」，所以这里用反向开关）：产品入口（GUI/CLI）
	// 默认不设置它，也就是开启；只有显式配置才关闭。
	DisableAdaptiveThrottle bool
	// SessionLostLimit 是同一账号连续多少次「会话失效」后停止该账号；<=0 时取默认值 3。
	SessionLostLimit int

	// windowOverride 仅供测试：非零时直接作为窗口长度，避免「秒」粒度把单测拖慢。
	windowOverride time.Duration
}

type Result struct {
	Loop        int                           `json:"loop"`
	UID         int64                         `json:"uid"`
	TargetIndex int                           `json:"target_index,omitempty"`
	Target      Target                        `json:"target"`
	Action      string                        `json:"action"`
	Category    string                        `json:"category,omitempty"`
	Message     string                        `json:"message,omitempty"`
	Prize       *huya.PrizeInfo               `json:"prize,omitempty"`
	Exchange    *huya.ScoreExchangePrizeResp  `json:"exchange,omitempty"`
	Score       *huya.GetUserScoreResp        `json:"score,omitempty"`
	Records     *huya.GetUserPrizeRecordsResp `json:"records,omitempty"`
	Done        bool                          `json:"done,omitempty"`
	RetryAfter  int64                         `json:"retry_after,omitempty"`
	Error       string                        `json:"error,omitempty"`
}

type Runner struct {
	Client huya.ActivityClient
	// OnSummary 在任务结束时回调一次汇总（可为 nil）。
	// 汇总在成功后的异步刷新全部结束后才输出，因此能带上刷新产生的请求次数。
	OnSummary func(RunSummary)
}

// RunSummary 汇总一次抢购任务的请求次数与结局分布，供日志复盘。
// 形状参考 dygou_go 的 logRunSummary：抢购结束后只打一行，替代逐条刷屏。
type RunSummary struct {
	Loops        int
	Accounts     int
	Targets      int
	Duration     time.Duration
	ListReqs     int
	ExchangeReqs int
	ScoreReqs    int
	RecordReqs   int
	SuccessUIDs  int
	Outcomes     map[string]int
	// AccountOutcomes 是每账号一行的最终结局（按 uid 升序），供任务结束后逐行复盘。
	AccountOutcomes []AccountOutcome
	// RequestStats 是按接口类型的请求统计（次数/失败/平均/最慢/最后错误）。
	RequestStats []RequestStat
	// WindowSeconds / OpenAt 描述本次窗口；非窗口模式时为零值。
	WindowSeconds int
	OpenAt        time.Time
	// ThrottleFactor 是自适应降速用到的最大倍率（1 表示全程没有触发降速）。
	ThrottleFactor float64
}

// AccountOutcome 是单个账号在一次任务里的最终结局。
type AccountOutcome struct {
	UID      int64  `json:"uid"`
	Category string `json:"category"`
	Message  string `json:"message,omitempty"`
	Attempts int    `json:"attempts"`
	Done     bool   `json:"done,omitempty"`
}

// RequestStat 是一种接口的调用统计。
type RequestStat struct {
	Kind    string        `json:"kind"`
	Count   int           `json:"count"`
	Failed  int           `json:"failed"`
	Total   time.Duration `json:"total"`
	Slowest time.Duration `json:"slowest"`
	LastErr string        `json:"lastErr,omitempty"`
}

// Average 返回平均耗时。
func (s RequestStat) Average() time.Duration {
	if s.Count <= 0 {
		return 0
	}
	return s.Total / time.Duration(s.Count)
}

// requestStat 是内部的请求统计累加器。
type requestStat struct {
	count   int
	failed  int
	total   time.Duration
	slowest time.Duration
	lastErr string
}

func (s *requestStat) observe(cost time.Duration, err error) {
	s.count++
	s.total += cost
	if cost > s.slowest {
		s.slowest = cost
	}
	if err != nil {
		s.failed++
		s.lastErr = err.Error()
	}
}

// Categories 按次数从多到少返回结局分类，次数相同时按名称排序，保证日志稳定。
func (s RunSummary) Categories() []string {
	names := make([]string, 0, len(s.Outcomes))
	for name := range s.Outcomes {
		names = append(names, name)
	}
	sort.Slice(names, func(i, j int) bool {
		if s.Outcomes[names[i]] != s.Outcomes[names[j]] {
			return s.Outcomes[names[i]] > s.Outcomes[names[j]]
		}
		return names[i] < names[j]
	})
	return names
}

type ActivityPrewarmer interface {
	PrewarmActivity(ctx context.Context, uid int64, cookie string, sid int32) error
}

type runState struct {
	mu         sync.Mutex
	accounts   map[int64][]targetState
	targetDone []bool
	// exchanged 记录每个账号已成功兑换的奖品，避免多个 target 命中同一奖品时重复兑换。
	exchanged map[int64]map[int64]bool
	// duplicateNotified 保证「该奖品已兑换过」只提示一次：窗口模式下每轮都会跳过，
	// 不记录会刷屏。
	duplicateNotified map[int64]map[int64]bool
	// refresh 用于等待成功后的异步刷新，确保 RunTargets 返回前不会提前释放连接。
	refresh sync.WaitGroup
	// sem 是请求级并发闸门：一个额度对应一次在途请求，账号在退避等待期间
	// 不再占用额度（参考 dygou_go runControl.enter）。旧实现把额度给整个账号
	// 循环，退避中的账号会一直霸占额度，账号多时互相饿死。
	sem chan struct{}
	// stats 记录请求次数与结局分布，任务结束时汇总成一行日志。
	stats runStats

	// 窗口模式：deadline 非零表示到点即收工；openAt 用于「开抢前只预打一轮」。
	startedAt   time.Time
	openAt      time.Time
	deadline    time.Time
	windowLen   time.Duration
	startAhead  time.Duration
	prefireDone bool
	// 首发错峰：第 0 个账号立即发，其余按 step 依次错开，整批最多铺开 spread。
	firstWaveSpread time.Duration
	firstWaveStep   time.Duration
	firstWaveUsed   int
	firstWaveSent   map[int64]bool
	// governor 是全局自适应降速器；DisableAdaptiveThrottle 时为 nil（空操作）。
	governor *throttleGovernor
	// rounds 记录所有账号里跑过的最大轮次，供汇总日志使用。
	rounds int
	// listMu 保护共享列表快照（SharePrizeList 模式）：listInflight 非空表示
	// 已有账号在查询，其余账号等它完成后复用结果。
	listMu       sync.Mutex
	listSnapshot *listSnapshot
	listCachedAt time.Time
	listInflight chan struct{}
}

// runStats 是一次任务的运行统计。
type runStats struct {
	listReqs     int
	exchangeReqs int
	scoreReqs    int
	recordReqs   int
	outcomes     map[string]int
	successUIDs  map[int64]bool
	// requests 按接口类型记录次数/失败/耗时，任务结束时输出接口统计行。
	requests map[requestKind]*requestStat
	// accounts 是每账号的最终结局，任务结束时逐行输出。
	accounts map[int64]*AccountOutcome
}

type targetState struct {
	Done       bool
	RetryAfter time.Time
	// FailStreak 是连续可重试失败的次数，用于放大退避（成功/正常等待类结局会清零）。
	FailStreak int
	// SessionStreak 是连续「会话失效」次数，达到阈值即停止该账号该奖品。
	SessionStreak int
}

type listSnapshot struct {
	resp *huya.GetActPrizeListResp
	err  error
}

func (r *Runner) Run(ctx context.Context, accounts []Account, target Target, cfg Config, emit func(Result)) error {
	return r.RunTargets(ctx, accounts, []Target{target}, cfg, emit)
}

func (r *Runner) RunTargets(ctx context.Context, accounts []Account, targets []Target, cfg Config, emit func(Result)) error {
	cfg = normalizeConfig(cfg)
	targets = normalizeTargets(targets)
	if len(accounts) == 0 {
		return errors.New("账号不能为空")
	}
	if len(targets) == 0 {
		return errors.New("目标奖品不能为空")
	}
	client := r.client()

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	if cfg.Prewarm {
		if err := r.Prewarm(ctx, accounts, cfg, emit); err != nil {
			return err
		}
	}

	state := newRunState(accounts, len(targets), cfg.Concurrency, cfg)
	startedAt := time.Now()
	// emit 包装一层，顺手记录每账号最终结局；emit 为 nil 时保持 nil，
	// 否则成功后的异步刷新会在没有上报通道时也发请求（旧行为不允许）。
	emitResult := emit
	if emit != nil {
		emitResult = func(result Result) {
			state.noteOutcome(result)
			emit(result)
		}
	}
	// 成功后的刷新是异步的，等它们结束再返回，避免调用方提前关闭连接；
	// 汇总放在最后，才能把刷新产生的请求次数一起带上。
	defer func() {
		state.refresh.Wait()
		r.emitSummary(state, len(accounts), len(targets), state.maxRound(), time.Since(startedAt))
	}()

	runWave := func(loop int) {
		var wg sync.WaitGroup
		for _, account := range accounts {
			account := account
			wg.Add(1)
			go func() {
				defer wg.Done()
				// 并发额度由每次请求自己申请（见 runState.acquire），
				// 账号在退避等待期间不占额度。
				r.runAccountRound(ctx, client, state, account, targets, cfg, loop, emitResult, cancel)
			}()
		}
		wg.Wait()
	}

	// 开抢前只预打一轮（探是否已开放、顺带验证通道），随后静默等到窗口起点。
	// 旧实现把提前量整段都用来循环重试，代价是先把服务端令牌桶烧掉：
	// 2026-10-16 pc-1 实测 1421 次请求里 82% 被限流挡回。
	if state.needsPrefire() {
		state.markPrefire()
		runWave(1)
		if ctx.Err() != nil {
			return ctx.Err()
		}
		if !state.windowExpired() {
			if err := sleepContext(ctx, time.Until(state.windowStart())); err != nil {
				return err
			}
		}
	}

	// 正式窗口：每个账号在自己的 goroutine 里独立循环到窗口结束（或自己完成），
	// 互不等待、互不阻塞。旧实现按「一轮打完等所有人」（wg.Wait）同步，某个账号卡在
	// 一次慢请求上时，其余账号这一轮只能干等（账号少的实例尤其吃亏）。
	// 请求速率由请求级并发闸门兜底：在途请求数被限制在 cfg.Concurrency。
	var wg sync.WaitGroup
	for _, account := range accounts {
		account := account
		wg.Add(1)
		go func() {
			defer wg.Done()
			r.runAccountLoop(ctx, client, state, account, targets, cfg, emitResult, cancel)
		}()
	}
	wg.Wait()
	if ctx.Err() != nil {
		return ctx.Err()
	}
	return nil
}

func (r *Runner) Prewarm(ctx context.Context, accounts []Account, cfg Config, emit func(Result)) error {
	cfg = normalizeConfig(cfg)
	if len(accounts) == 0 {
		return errors.New("账号不能为空")
	}
	client := r.client()
	prewarmer, ok := client.(ActivityPrewarmer)
	if !ok {
		return nil
	}
	sem := make(chan struct{}, cfg.Concurrency)
	var wg sync.WaitGroup
	for _, account := range accounts {
		account := account
		wg.Add(1)
		go func() {
			defer wg.Done()
			select {
			case sem <- struct{}{}:
				defer func() { <-sem }()
			case <-ctx.Done():
				return
			}
			err := prewarmer.PrewarmActivity(ctx, account.UID, account.Cookie, cfg.SID)
			result := Result{
				UID:      account.UID,
				Action:   "prewarm",
				Category: CategoryReady,
				Message:  "连接已预热",
			}
			if err != nil {
				result.Category = CategoryError
				result.Error = err.Error()
				result.Message = "连接预热失败"
			}
			if emit != nil {
				emit(result)
			}
		}()
	}
	wg.Wait()
	return ctx.Err()
}

// runAccountLoop 是单个账号的独立抢购循环：按自己的节奏重试，直到窗口结束、
// 自己完成或任务被停止。账号之间不互相等待，也不共享节奏。
func (r *Runner) runAccountLoop(ctx context.Context, client huya.ActivityClient, state *runState, account Account, targets []Target, cfg Config, emit func(Result), cancel context.CancelFunc) {
	// 首发错峰：第 0 个账号立即发，其余按小步长依次错开，避免同机上百个账号
	// 在同一毫秒齐射把整机压上服务端令牌桶。
	if wait := state.takeFirstWaveDelay(account.UID); wait > 0 {
		if err := sleepContext(ctx, wait); err != nil {
			return
		}
	}

	for round := 1; ; round++ {
		if ctx.Err() != nil {
			return
		}
		// Loops>0 是显式轮次上限（非窗口模式与测试用）；窗口模式下留空表示打到窗口结束。
		if cfg.Loops > 0 && round > cfg.Loops {
			return
		}
		if state.allDone() || state.windowExpired() || state.accountFinished(account.UID, len(targets)) {
			return
		}
		state.noteRound(round)
		r.runAccountRound(ctx, client, state, account, targets, cfg, round, emit, cancel)
		if ctx.Err() != nil || state.allDone() || state.windowExpired() {
			return
		}
		// 本账号自己的节奏：固定等 cfg.Delay。退避中的目标会在下一轮被 activeTargets 跳过，
		// 所以这里不需要额外等待退避时间（等待本身也会被窗口末尾裁剪）。
		if wait := state.clipToDeadline(cfg.Delay); wait > 0 {
			if err := sleepContext(ctx, wait); err != nil {
				return
			}
		}
	}
}

// runAccountRound 是单账号的一轮尝试：按目标做一次兑换（或多个目标各一次）。
func (r *Runner) runAccountRound(ctx context.Context, client huya.ActivityClient, state *runState, account Account, targets []Target, cfg Config, loop int, emit func(Result), cancel context.CancelFunc) {
	active := state.activeTargets(account.UID, len(targets), time.Now())
	if len(active) == 0 {
		return
	}

	listTargets := make([]int, 0, len(active))
	for _, index := range active {
		target := targets[index]
		if shouldDirectExchange(target, cfg) {
			// 直兑路径没有奖品列表，用 target.PID 判断是否已经兑换过同一奖品。
			if state.prizeExchanged(account.UID, int64(target.PID)) {
				state.emitSkippedDuplicate(emit, loop, account.UID, index, int64(target.PID), target)
				continue
			}
			result := r.exchangeTarget(ctx, client, state, account, target, index, loop, cfg.SID, nil)
			if result.Action == actionExchangeCanceled {
				return
			}
			result = r.applyExchangeDecision(state, account, index, cfg, result, cancel)
			if result.Category == CategorySuccess {
				state.markPrizeExchanged(account.UID, int64(target.PID))
			}
			if emit != nil {
				emit(result)
			}
			r.refreshAfterSuccess(state, client, account, target, index, loop, cfg, result, emit)
			if ctx.Err() != nil {
				return
			}
			continue
		}
		listTargets = append(listTargets, index)
	}
	if len(listTargets) == 0 || ctx.Err() != nil {
		return
	}

	// SharePrizeList 打开时，多账号复用同一份列表快照（带 TTL 的单飞缓存），
	// 避免每个账号每一轮都各查一次列表。
	list := r.listForAccount(ctx, client, account, cfg, state)
	if list.err != nil || list.resp == nil {
		errText := "奖品列表响应为空"
		if list.err != nil {
			errText = list.err.Error()
		}
		for _, index := range listTargets {
			retryAt := time.Now().Add(jitterDuration(cfg.ErrorBackoff))
			state.setRetryAfter(account.UID, index, retryAt)
			state.recordOutcome(CategoryError)
			result := Result{
				Loop:        loop,
				UID:         account.UID,
				TargetIndex: index,
				Target:      targets[index],
				Action:      "list_error",
				Category:    CategoryError,
				Message:     "查询奖品列表失败",
				RetryAfter:  retryAt.UnixMilli(),
				Error:       errText,
			}
			if emit != nil {
				emit(result)
			}
		}
		return
	}

	// 只按目标类目匹配：类目为空表示不限制（限量返场/精英专享都参与）。
	prizes := list.resp.FilterByCategory(cfg.Category)
	for _, index := range listTargets {
		target := targets[index]
		prize := matchPrize(prizes, target)
		if prize == nil {
			state.recordOutcome(CategoryNotFound)
			result := Result{
				Loop:        loop,
				UID:         account.UID,
				TargetIndex: index,
				Target:      target,
				Action:      "not_found",
				Category:    CategoryNotFound,
				Message:     notFoundMessage(cfg.Category),
			}
			if emit != nil {
				emit(result)
			}
			continue
		}
		// 多个 target 可能命中同一个奖品（例如按不同名称匹配），已成功兑换过就跳过。
		if state.prizeExchanged(account.UID, prize.ID) {
			state.emitSkippedDuplicate(emit, loop, account.UID, index, prize.ID, target)
			continue
		}
		result := r.exchangeTarget(ctx, client, state, account, target, index, loop, cfg.SID, prize)
		if result.Action == actionExchangeCanceled {
			return
		}
		result = r.applyExchangeDecision(state, account, index, cfg, result, cancel)
		if result.Category == CategorySuccess {
			state.markPrizeExchanged(account.UID, prize.ID)
		}
		if emit != nil {
			emit(result)
		}
		r.refreshAfterSuccess(state, client, account, target, index, loop, cfg, result, emit)
		if ctx.Err() != nil {
			return
		}
	}
}

// emitSkippedDuplicate 在跳过同一奖品的重复兑换时给出明确结果，便于界面观察。
//
// 每个「账号 + 奖品」只提示一次：窗口模式下每轮都会跳过同一个奖品，
// 不记录会刷出一整个窗口的重复提示（但请求数不会增加）。
func (s *runState) emitSkippedDuplicate(emit func(Result), loop int, uid int64, index int, prizeID int64, target Target) {
	if s.markDuplicateNotified(uid, prizeID) {
		s.recordOutcome(CategoryAlreadyDone)
	}
	if emit == nil {
		return
	}
	emit(Result{
		Loop:        loop,
		UID:         uid,
		TargetIndex: index,
		Target:      target,
		Action:      "skip_duplicate",
		Category:    CategoryAlreadyDone,
		Message:     "该奖品本账号已兑换成功，跳过重复兑换",
	})
}

// markDuplicateNotified 记录并返回是否是首次提示。
func (s *runState) markDuplicateNotified(uid, prizeID int64) bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.duplicateNotified[uid] == nil {
		s.duplicateNotified[uid] = map[int64]bool{}
	}
	if s.duplicateNotified[uid][prizeID] {
		return false
	}
	s.duplicateNotified[uid][prizeID] = true
	return true
}

func (r *Runner) exchangeTarget(ctx context.Context, client huya.ActivityClient, state *runState, account Account, target Target, index int, loop int, sid int32, prize *huya.PrizeInfo) Result {
	pid := target.PID
	if prize != nil {
		pid = int32(prize.ID)
	}
	result := Result{
		Loop:        loop,
		UID:         account.UID,
		TargetIndex: index,
		Target:      target,
		Action:      "exchange",
		Prize:       prize,
	}
	if !state.acquire(ctx) {
		result.Action = actionExchangeCanceled
		result.Category = CategoryError
		result.Message = "任务已取消，未发起兑换"
		result.Error = ctx.Err().Error()
		return result
	}
	started := time.Now()
	exchange, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, sid, pid)
	state.release()
	state.recordRequest(reqExchange, time.Since(started), err)
	result.Exchange = exchange
	result.Category = ClassifyExchange(exchange, err)
	result.Message = ExchangeMessage(exchange)
	if err != nil {
		result.Action = "exchange_error"
		result.Error = err.Error()
		if result.Message == "" {
			result.Message = "兑换请求失败"
		}
	}
	return result
}

func (r *Runner) applyExchangeDecision(state *runState, account Account, index int, cfg Config, result Result, cancel context.CancelFunc) Result {
	state.recordOutcome(result.Category)
	state.observeThrottle(result.Category)
	if result.Category == CategorySuccess {
		state.markSuccessUID(account.UID)
	}
	switch result.Category {
	case CategorySuccess:
		if cfg.StopAccountAfterSuccess {
			state.markDone(account.UID, index)
			result.Done = true
		}
		if cfg.StopAfterSuccess {
			cancel()
		}
	case CategoryNotEnough, CategoryAlreadyDone:
		if cfg.StopOnNotEnough {
			state.markDone(account.UID, index)
			result.Done = true
		}
	case CategoryOffShelf:
		// 已下架 / 奖品不存在：本窗口内不会再出现，直接终止该 target。
		state.markTargetDone(index)
		result.Done = true
	case CategorySessionLost:
		// 会话失效实测是瞬时的（下一轮即可成功），所以先照常重试；
		// 只有连续多次才停止该账号，避免真的失效后白打一整个窗口的请求。
		streak := state.bumpSessionStreak(account.UID, index)
		if limit := sessionLostLimit(cfg); streak >= limit {
			state.markDone(account.UID, index)
			result.Done = true
			result.Message = fmt.Sprintf("会话连续失效 %d 次，停止该账号", streak)
		} else {
			result.RetryAfter = state.scheduleRetry(account.UID, index, cfg, result.Category)
		}
	case CategorySoldOut:
		if cfg.StopOnSoldOut {
			state.markTargetDone(index)
			result.Done = true
		} else {
			// 别人锁单未支付或取消会让库存回流，窗口内继续探测（只是放慢节奏）。
			result.RetryAfter = state.scheduleRetry(account.UID, index, cfg, result.Category)
		}
	case CategoryTooFrequent:
		result.RetryAfter = state.scheduleRetry(account.UID, index, cfg, result.Category)
	case CategoryError, CategoryProtocol, CategoryFailed, CategoryCondition:
		result.RetryAfter = state.scheduleRetry(account.UID, index, cfg, result.Category)
	}
	return result
}

// sessionLostLimit 返回「连续会话失效多少次后停止该账号」的阈值。
func sessionLostLimit(cfg Config) int {
	if cfg.SessionLostLimit > 0 {
		return cfg.SessionLostLimit
	}
	return defaultSessionLostLimit
}

// scheduleRetry 计算并登记某个账号下一次尝试的时间，返回毫秒时间戳供日志展示。
func (s *runState) scheduleRetry(uid int64, index int, cfg Config, category string) int64 {
	delay := s.retryDelay(uid, index, cfg, category)
	// 窗口模式下退避不能跨过窗口结束，否则这段等待纯属浪费。
	if !s.deadline.IsZero() {
		remaining := time.Until(s.deadline)
		if remaining <= 0 {
			delay = 0
		} else if delay > remaining {
			delay = remaining
		}
	}
	when := time.Now().Add(delay)
	s.setRetryAfter(uid, index, when)
	return when.UnixMilli()
}

// retryDelay 计算账号下一次尝试前的退避时间。
//
// 阶梯参考 dygou_go 的 retryDelay：
//  1. 基础值来自界面配置（ErrorBackoff / TooFrequentBackoff，默认 300ms）；
//  2. 按「已抢购时长」分档放大：开抢瞬间要快，窗口后段自然放慢（库存回流概率低）；
//  3. 同一账号连续失败再翻倍（上限 ×4），避免单个账号被风控盯上；
//  4. 乘全局自适应降速倍率（限流风暴时整体降速）；
//  5. 叠加 0-25% 抖动，避免整批账号同一时刻重试形成尖峰；
//  6. 任何一次等待都不超过 maxRetryDelay——超过 1.5 秒就可能正好错过回流库存。
func (s *runState) retryDelay(uid int64, index int, cfg Config, category string) time.Duration {
	base := cfg.ErrorBackoff
	if category == CategoryTooFrequent {
		base = cfg.TooFrequentBackoff
	}
	if base <= 0 {
		base = defaultRetryBackoff
	}
	streak := s.bumpFailStreak(uid, index, category)
	delay := time.Duration(stageMultiplier(s.elapsed(), category)) * base
	if mult := streakMultiplier(streak); mult > 1 {
		delay *= time.Duration(mult)
	}
	if delay > maxRetryDelay {
		delay = maxRetryDelay
	}
	if factor := s.throttleFactor(); factor > 1 {
		delay = time.Duration(float64(delay) * factor)
	}
	return jitterDuration(delay)
}

// elapsed 返回任务开始至今的时长，用于按阶段取退避节奏。
func (s *runState) elapsed() time.Duration {
	if s.startedAt.IsZero() {
		return 0
	}
	return time.Since(s.startedAt)
}

// stageMultiplier 按已抢购时长返回退避倍率：开抢头 2 秒最激进，5 秒后放慢到 3 倍。
func stageMultiplier(elapsed time.Duration, category string) int {
	if escalatingCategory(category) {
		switch {
		case elapsed < 2*time.Second:
			return 1
		case elapsed < 5*time.Second:
			return 2
		default:
			return 3
		}
	}
	// 售罄 / 未开放这类「正常等待」也随窗口放慢，但基数保持 1：库存回流仍要探到。
	if elapsed >= 5*time.Second {
		return 2
	}
	return 1
}

// escalatingCategory 返回该分类是否参与「连续失败翻倍」的统计。
func escalatingCategory(category string) bool {
	switch category {
	case CategoryFailed, CategoryTooFrequent, CategoryError, CategoryProtocol, CategorySessionLost, CategoryCondition:
		return true
	default:
		return false
	}
}

// streakMultiplier 把连续失败次数换算成翻倍系数：第 3 次起 ×2，第 4 次起 ×4。
//
// 刻意从第 3 次才翻倍：前两次保持配置里的最快节奏，抢购前期不该因为一次失败就变慢。
func streakMultiplier(streak int) int {
	if streak <= 2 {
		return 1
	}
	mult := 1
	for i := 2; i < streak && mult < 4; i++ {
		mult <<= 1
	}
	return mult
}

// bumpFailStreak 累加账号的连续失败次数；非失败类结局会把它清零。
func (s *runState) bumpFailStreak(uid int64, index int, category string) int {
	s.mu.Lock()
	defer s.mu.Unlock()
	items := s.accounts[uid]
	if index < 0 || index >= len(items) {
		return 1
	}
	if !escalatingCategory(category) {
		items[index].FailStreak = 0
		s.accounts[uid] = items
		return 1
	}
	items[index].FailStreak++
	streak := items[index].FailStreak
	s.accounts[uid] = items
	return streak
}

// bumpSessionStreak 累加账号的连续会话失效次数。
func (s *runState) bumpSessionStreak(uid int64, index int) int {
	s.mu.Lock()
	defer s.mu.Unlock()
	items := s.accounts[uid]
	if index < 0 || index >= len(items) {
		return 0
	}
	items[index].SessionStreak++
	streak := items[index].SessionStreak
	s.accounts[uid] = items
	return streak
}

// observeThrottle 把结局交给全局降速器。会话失效等其它结局会重置「无进展」计数。
func (s *runState) observeThrottle(category string) {
	if s.governor == nil {
		return
	}
	if category != CategoryTooFrequent {
		s.clearSessionStreak(category)
	}
	s.governor.observe(category)
}

// clearSessionStreak 在拿到任何非会话失效结局后清空连续失效计数。
func (s *runState) clearSessionStreak(category string) {
	if category == CategorySessionLost {
		return
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	for uid, items := range s.accounts {
		changed := false
		for index := range items {
			if items[index].SessionStreak != 0 {
				items[index].SessionStreak = 0
				changed = true
			}
		}
		if changed {
			s.accounts[uid] = items
		}
	}
}

// throttleFactor 返回当前的自适应降速倍率（未启用时恒为 1）。
func (s *runState) throttleFactor() float64 {
	if s.governor == nil {
		return 1
	}
	return s.governor.current()
}

// throttleGovernor 是全局自适应降速器。
//
// 触发信号刻意选「无进展」而不是「限流占比」：2026-10-16 实测，即使成功率 97.6% 的 pc-3
// 也有 67% 的请求被限流，用占比阈值会把正常运行的机器一起拖慢。真正危险的是
// 「连着十几个请求、连一个业务响应都拿不到」——说明整机已经压在服务端令牌桶上
// （pc-1 峰值 122 req/s、82% 被限流）。命中后每 800ms 按 1.5 倍逐级降速（上限 4 倍），
// 一旦恢复进展就立刻回退，避免错过库存回流。
type throttleGovernor struct {
	mu           sync.Mutex
	factor       float64
	maxSeen      float64
	stall        int
	lastProgress time.Time
	lastEscalate time.Time
	// 阈值做成字段是为了让单测能把时间窗口压到毫秒级。
	minRequests int
	stallWindow time.Duration
	maxFactor   float64
}

func newThrottleGovernor() *throttleGovernor {
	now := time.Now()
	return &throttleGovernor{
		factor:       1,
		maxSeen:      1,
		minRequests:  governorMinRequests,
		stallWindow:  governorStallWindow,
		maxFactor:    governorMaxFactor,
		lastProgress: now,
		lastEscalate: now,
	}
}

func (g *throttleGovernor) observe(category string) {
	g.mu.Lock()
	defer g.mu.Unlock()
	now := time.Now()
	if category != CategoryTooFrequent {
		// 只要服务端确实处理了请求（哪怕是售罄/未开放/协议错误），就算有进展。
		g.stall = 0
		g.lastProgress = now
		if g.factor > 1 {
			g.factor /= governorStep
			if g.factor < 1 {
				g.factor = 1
			}
		}
		return
	}
	g.stall++
	if g.stall < g.minRequests || now.Sub(g.lastProgress) < g.stallWindow {
		return
	}
	if now.Sub(g.lastEscalate) < g.stallWindow {
		return
	}
	g.lastEscalate = now
	g.factor *= governorStep
	if g.factor > g.maxFactor {
		g.factor = g.maxFactor
	}
	if g.factor > g.maxSeen {
		g.maxSeen = g.factor
	}
}

func (g *throttleGovernor) current() float64 {
	g.mu.Lock()
	defer g.mu.Unlock()
	return g.factor
}

// peak 返回本次任务用过的最大降速倍率，供汇总日志展示。
func (g *throttleGovernor) peak() float64 {
	g.mu.Lock()
	defer g.mu.Unlock()
	return g.maxSeen
}

func (r *Runner) refreshAfterSuccess(state *runState, client huya.ActivityClient, account Account, target Target, index int, loop int, cfg Config, result Result, emit func(Result)) {
	if !cfg.RefreshAfterSuccess || emit == nil || result.Category != CategorySuccess {
		return
	}
	state.refresh.Add(1)
	go func() {
		defer state.refresh.Done()
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()

		// 刷新请求同样走并发闸门，但用拥有 5 秒预算的独立 ctx。
		score, err := func() (*huya.GetUserScoreResp, error) {
			if !state.acquire(ctx) {
				return nil, ctx.Err()
			}
			defer state.release()
			started := time.Now()
			resp, err := client.QueryUserScore(ctx, account.UID, account.Cookie, cfg.SID)
			state.recordRequest(reqScore, time.Since(started), err)
			return resp, err
		}()
		scoreResult := Result{
			Loop:        loop,
			UID:         account.UID,
			TargetIndex: index,
			Target:      target,
			Action:      "refresh_score",
			Category:    CategoryReady,
			Message:     "刷新积分完成",
			Score:       score,
		}
		if err != nil {
			scoreResult.Category = CategoryError
			scoreResult.Message = "刷新积分失败"
			scoreResult.Error = err.Error()
		} else if score != nil {
			scoreResult.Message = fmt.Sprintf("剩余积分: %d", score.AvailableScore())
		}
		emit(scoreResult)

		records, err := func() (*huya.GetUserPrizeRecordsResp, error) {
			if !state.acquire(ctx) {
				return nil, ctx.Err()
			}
			defer state.release()
			started := time.Now()
			resp, err := client.GetUserPrizeRecords(ctx, account.UID, account.Cookie, cfg.SID)
			state.recordRequest(reqRecord, time.Since(started), err)
			return resp, err
		}()
		recordResult := Result{
			Loop:        loop,
			UID:         account.UID,
			TargetIndex: index,
			Target:      target,
			Action:      "refresh_records",
			Category:    CategoryReady,
			Message:     "刷新兑换记录完成",
			Records:     records,
		}
		if err != nil {
			recordResult.Category = CategoryError
			recordResult.Message = "刷新兑换记录失败"
			recordResult.Error = err.Error()
		}
		emit(recordResult)
	}()
}

// listForAccount 返回本账号本轮要用的奖品列表快照。
//
// SharePrizeList 打开时多账号复用同一份快照：TTL 内第一个账号查完，其余账号直接复用
// （单飞：同一时刻只有一个账号在查，避免并发重复查询）。关闭时各查各的。
func (r *Runner) listForAccount(ctx context.Context, client huya.ActivityClient, account Account, cfg Config, state *runState) *listSnapshot {
	fetch := func() *listSnapshot {
		if !state.acquire(ctx) {
			return &listSnapshot{err: ctx.Err()}
		}
		started := time.Now()
		resp, err := client.GetActPrizeList(ctx, account.UID, account.Cookie, cfg.SID)
		state.release()
		state.recordRequest(reqList, time.Since(started), err)
		return &listSnapshot{resp: resp, err: err}
	}
	if !cfg.SharePrizeList {
		return fetch()
	}
	return state.sharedListOnce(ctx, fetch)
}

func (r *Runner) client() huya.ActivityClient {
	if r.Client != nil {
		return r.Client
	}
	return huya.NewHTTPClient(nil)
}

func newRunState(accounts []Account, targetCount, concurrency int, cfg Config) *runState {
	if concurrency <= 0 {
		concurrency = 1
	}
	state := &runState{
		startedAt:         time.Now(),
		accounts:          make(map[int64][]targetState, len(accounts)),
		targetDone:        make([]bool, targetCount),
		exchanged:         make(map[int64]map[int64]bool, len(accounts)),
		duplicateNotified: make(map[int64]map[int64]bool, len(accounts)),
		firstWaveSent:     make(map[int64]bool, len(accounts)),
		sem:               make(chan struct{}, concurrency),
		stats: runStats{
			outcomes:    map[string]int{},
			successUIDs: map[int64]bool{},
			requests:    map[requestKind]*requestStat{},
			accounts:    map[int64]*AccountOutcome{},
		},
	}
	for _, account := range accounts {
		state.accounts[account.UID] = make([]targetState, targetCount)
	}
	state.configureWindow(cfg, len(accounts))
	return state
}

// configureWindow 按配置初始化窗口与首发错峰参数。
//
// 只有 OpenAt 非零才是窗口模式：测试与直接调用 RunTargets 的老用法（只给 Loops）
// 保持原来的轮次语义，不会被 30 秒窗口拖住。
func (s *runState) configureWindow(cfg Config, accountCount int) {
	if cfg.OpenAt.IsZero() {
		return
	}
	window := time.Duration(cfg.WindowSeconds) * time.Second
	if cfg.WindowSeconds <= 0 {
		window = DefaultWindowSeconds * time.Second
	}
	if cfg.windowOverride > 0 {
		window = cfg.windowOverride
	}
	startAhead := cfg.StartAhead
	if startAhead <= 0 {
		startAhead = DefaultStartAhead
	}
	s.openAt = cfg.OpenAt
	s.startAhead = startAhead
	s.windowLen = window
	s.deadline = cfg.OpenAt.Add(window)

	if cfg.FirstWaveSpread > 0 {
		step := cfg.FirstWaveSpread / time.Duration(maxInt(accountCount-1, 1))
		maxStep := cfg.FirstWaveMaxStep
		if maxStep <= 0 {
			maxStep = DefaultFirstWaveMaxStep
		}
		if step > maxStep {
			step = maxStep
		}
		if step < 0 {
			step = 0
		}
		s.firstWaveSpread = cfg.FirstWaveSpread
		s.firstWaveStep = step
	}
	if !cfg.DisableAdaptiveThrottle {
		s.governor = newThrottleGovernor()
	}
}

// windowed 返回是否处于窗口模式。
func (s *runState) windowed() bool {
	return !s.deadline.IsZero()
}

// windowExpired 返回窗口是否已经结束（非窗口模式永远为 false）。
func (s *runState) windowExpired() bool {
	if s.deadline.IsZero() {
		return false
	}
	return !time.Now().Before(s.deadline)
}

// windowStart 返回窗口循环应当开始发请求的时刻（开抢时刻减去先手缓冲）。
func (s *runState) windowStart() time.Time {
	return s.openAt.Add(-s.startAhead)
}

// needsPrefire 返回是否还欠一轮「开抢前预打」。
//
// 只有距离窗口起点还有一段时间才值得单独预打一轮：正常情况下触发时刻（开抢 − advance）
// 与窗口起点（开抢 − StartAhead）几乎重合，此时再预打一轮就等于把首发齐射打两遍。
func (s *runState) needsPrefire() bool {
	if s.openAt.IsZero() || s.prefireDone {
		return false
	}
	return time.Now().Add(prefireMinGap).Before(s.windowStart())
}

func (s *runState) markPrefire() {
	s.prefireDone = true
}

// clipToDeadline 把等待时间裁剪到窗口结束，保证不会睡过窗口。
func (s *runState) clipToDeadline(delay time.Duration) time.Duration {
	if s.deadline.IsZero() {
		return delay
	}
	remaining := time.Until(s.deadline)
	if remaining <= 0 {
		return 0
	}
	if delay > remaining {
		return remaining
	}
	return delay
}

// noteRound 记录所有账号里跑过的最大轮次（用于汇总日志）。
func (s *runState) noteRound(round int) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if round > s.rounds {
		s.rounds = round
	}
}

// maxRound 返回所有账号里跑过的最大轮次。
func (s *runState) maxRound() int {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.rounds
}

// accountFinished 返回该账号是否已经没有可尝试的目标（全部成功或进入终态）。
func (s *runState) accountFinished(uid int64, targetCount int) bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	items := s.accounts[uid]
	for index := 0; index < targetCount; index++ {
		if index < len(s.targetDone) && s.targetDone[index] {
			continue
		}
		if index < len(items) && !items[index].Done {
			return false
		}
	}
	return true
}

// sharedListOnce 保证同一时刻只有一个账号去查询奖品列表，其余账号等它完成后复用结果。
//
// 只缓存成功的快照：失败结果不缓存，否则一次抖动会让所有账号一起失败。
func (s *runState) sharedListOnce(ctx context.Context, fetch func() *listSnapshot) *listSnapshot {
	s.listMu.Lock()
	if s.listSnapshot != nil && time.Since(s.listCachedAt) <= sharedListTTL {
		snapshot := s.listSnapshot
		s.listMu.Unlock()
		return snapshot
	}
	if inflight := s.listInflight; inflight != nil {
		s.listMu.Unlock()
		select {
		case <-inflight:
		case <-ctx.Done():
			return &listSnapshot{err: ctx.Err()}
		}
		s.listMu.Lock()
		snapshot := s.listSnapshot
		s.listMu.Unlock()
		if snapshot != nil {
			return snapshot
		}
		return &listSnapshot{err: errors.New("奖品列表响应为空")}
	}
	inflight := make(chan struct{})
	s.listInflight = inflight
	s.listMu.Unlock()

	snapshot := fetch()

	s.listMu.Lock()
	if snapshot != nil && snapshot.err == nil && snapshot.resp != nil {
		s.listSnapshot = snapshot
		s.listCachedAt = time.Now()
	}
	s.listInflight = nil
	s.listMu.Unlock()
	close(inflight)
	return snapshot
}

// takeFirstWaveDelay 领取本账号的首发错峰等待时间，每个账号只生效一次。
func (s *runState) takeFirstWaveDelay(uid int64) time.Duration {
	if s.firstWaveStep <= 0 {
		return 0
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.firstWaveSent[uid] {
		return 0
	}
	s.firstWaveSent[uid] = true
	slot := s.firstWaveUsed
	s.firstWaveUsed++
	return time.Duration(slot) * s.firstWaveStep
}

// noteOutcome 记录一个账号最近一次兑换类结果，供任务结束时的逐账号结局输出。
func (s *runState) noteOutcome(result Result) {
	switch result.Action {
	case "exchange", "exchange_error", "skip_duplicate", "not_found":
	default:
		return
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.stats.accounts == nil {
		s.stats.accounts = map[int64]*AccountOutcome{}
	}
	outcome := s.stats.accounts[result.UID]
	if outcome == nil {
		outcome = &AccountOutcome{UID: result.UID}
		s.stats.accounts[result.UID] = outcome
	}
	if result.Action != "skip_duplicate" {
		outcome.Attempts++
	}
	outcome.Category = result.Category
	outcome.Message = result.Message
	if result.Category == CategorySuccess || result.Done {
		outcome.Done = true
	}
}

// requestKind 标识一次在途请求的类型，用于汇总日志里的请求次数。
type requestKind int

const (
	reqList requestKind = iota
	reqExchange
	reqScore
	reqRecord
)

// String 返回接口类型的中文名，用于「接口统计」日志。
func (k requestKind) String() string {
	switch k {
	case reqList:
		return "奖品列表"
	case reqExchange:
		return "兑换"
	case reqScore:
		return "积分"
	case reqRecord:
		return "兑换记录"
	default:
		return "未知"
	}
}

// acquire 申请一个请求额度；ctx 结束时会返回 false，调用方应直接放弃这次请求。
func (s *runState) acquire(ctx context.Context) bool {
	if s.sem == nil {
		return ctx.Err() == nil
	}
	select {
	case s.sem <- struct{}{}:
		return true
	case <-ctx.Done():
		return false
	}
}

func (s *runState) release() {
	if s.sem == nil {
		return
	}
	<-s.sem
}

// recordRequest 记录一次请求的次数、耗时与错误。
//
// 除了原来的分类计数，还累计耗时/失败/最后错误，任务结束时输出「接口统计」行，
// 这样复盘时能一眼看出是「请求打不出去（慢/超时）」还是「打出去被拒（限流）」。
func (s *runState) recordRequest(kind requestKind, cost time.Duration, err error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	switch kind {
	case reqList:
		s.stats.listReqs++
	case reqExchange:
		s.stats.exchangeReqs++
	case reqScore:
		s.stats.scoreReqs++
	case reqRecord:
		s.stats.recordReqs++
	}
	if s.stats.requests == nil {
		s.stats.requests = map[requestKind]*requestStat{}
	}
	stat := s.stats.requests[kind]
	if stat == nil {
		stat = &requestStat{}
		s.stats.requests[kind] = stat
	}
	stat.observe(cost, err)
}

// recordOutcome 累计一条结局分类，供任务结束时的汇总日志使用。
func (s *runState) recordOutcome(category string) {
	if category == "" {
		return
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.stats.outcomes == nil {
		s.stats.outcomes = map[string]int{}
	}
	s.stats.outcomes[category]++
}

func (s *runState) markSuccessUID(uid int64) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.stats.successUIDs == nil {
		s.stats.successUIDs = map[int64]bool{}
	}
	s.stats.successUIDs[uid] = true
}

func (s *runState) snapshotStats() runStats {
	s.mu.Lock()
	defer s.mu.Unlock()
	out := runStats{
		listReqs:     s.stats.listReqs,
		exchangeReqs: s.stats.exchangeReqs,
		scoreReqs:    s.stats.scoreReqs,
		recordReqs:   s.stats.recordReqs,
		outcomes:     make(map[string]int, len(s.stats.outcomes)),
		successUIDs:  make(map[int64]bool, len(s.stats.successUIDs)),
		requests:     make(map[requestKind]*requestStat, len(s.stats.requests)),
		accounts:     make(map[int64]*AccountOutcome, len(s.stats.accounts)),
	}
	for key, value := range s.stats.outcomes {
		out.outcomes[key] = value
	}
	for uid := range s.stats.successUIDs {
		out.successUIDs[uid] = true
	}
	for kind, stat := range s.stats.requests {
		if stat == nil {
			continue
		}
		copied := *stat
		out.requests[kind] = &copied
	}
	for uid, outcome := range s.stats.accounts {
		if outcome == nil {
			continue
		}
		copied := *outcome
		out.accounts[uid] = &copied
	}
	return out
}

// emitSummary 在任务结束时回调一次汇总；OnSummary 为 nil 时不做任何事。
func (r *Runner) emitSummary(state *runState, accounts, targets, loops int, cost time.Duration) {
	if r.OnSummary == nil {
		return
	}
	stats := state.snapshotStats()
	summary := RunSummary{
		Loops:        loops,
		Accounts:     accounts,
		Targets:      targets,
		Duration:     cost,
		ListReqs:     stats.listReqs,
		ExchangeReqs: stats.exchangeReqs,
		ScoreReqs:    stats.scoreReqs,
		RecordReqs:   stats.recordReqs,
		SuccessUIDs:  len(stats.successUIDs),
		Outcomes:     stats.outcomes,
	}
	if state.windowed() {
		summary.OpenAt = state.openAt
		summary.WindowSeconds = int(state.windowLen / time.Second)
	}
	if state.governor != nil {
		summary.ThrottleFactor = state.governor.peak()
	}
	for _, kind := range []requestKind{reqList, reqExchange, reqScore, reqRecord} {
		stat := stats.requests[kind]
		if stat == nil || stat.count == 0 {
			continue
		}
		summary.RequestStats = append(summary.RequestStats, RequestStat{
			Kind:    kind.String(),
			Count:   stat.count,
			Failed:  stat.failed,
			Total:   stat.total,
			Slowest: stat.slowest,
			LastErr: stat.lastErr,
		})
	}
	uids := make([]int64, 0, len(stats.accounts))
	for uid := range stats.accounts {
		uids = append(uids, uid)
	}
	sort.Slice(uids, func(i, j int) bool { return uids[i] < uids[j] })
	for _, uid := range uids {
		summary.AccountOutcomes = append(summary.AccountOutcomes, *stats.accounts[uid])
	}
	r.OnSummary(summary)
}

// prizeExchanged 判断该账号是否已经成功兑换过这个奖品。
func (s *runState) prizeExchanged(uid, prizeID int64) bool {
	if prizeID <= 0 {
		return false
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.exchanged[uid][prizeID]
}

func (s *runState) markPrizeExchanged(uid, prizeID int64) {
	if prizeID <= 0 {
		return
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.exchanged[uid] == nil {
		s.exchanged[uid] = map[int64]bool{}
	}
	s.exchanged[uid][prizeID] = true
}

func (s *runState) activeTargets(uid int64, targetCount int, now time.Time) []int {
	s.mu.Lock()
	defer s.mu.Unlock()
	items := s.accounts[uid]
	active := make([]int, 0, targetCount)
	for i := 0; i < targetCount; i++ {
		if i < len(s.targetDone) && s.targetDone[i] {
			continue
		}
		if i >= len(items) || items[i].Done {
			continue
		}
		if !items[i].RetryAfter.IsZero() && items[i].RetryAfter.After(now) {
			continue
		}
		active = append(active, i)
	}
	return active
}

func (s *runState) markDone(uid int64, index int) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if items := s.accounts[uid]; index >= 0 && index < len(items) {
		items[index].Done = true
		items[index].RetryAfter = time.Time{}
		s.accounts[uid] = items
	}
}

func (s *runState) markTargetDone(index int) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if index >= 0 && index < len(s.targetDone) {
		s.targetDone[index] = true
	}
}

func (s *runState) setRetryAfter(uid int64, index int, when time.Time) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if items := s.accounts[uid]; index >= 0 && index < len(items) {
		items[index].RetryAfter = when
		s.accounts[uid] = items
	}
}

func (s *runState) allDone() bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	for index, globallyDone := range s.targetDone {
		if globallyDone {
			continue
		}
		for _, items := range s.accounts {
			if index < len(items) && !items[index].Done {
				return false
			}
		}
	}
	return true
}

func normalizeConfig(cfg Config) Config {
	cfg.Category = strings.TrimSpace(cfg.Category)
	if cfg.Loops <= 0 && cfg.OpenAt.IsZero() {
		// 非窗口模式必须有个有限轮次，否则会变成死循环。
		cfg.Loops = 1
	}
	// 窗口模式下 Loops<=0 表示「一直打到窗口结束」，由 deadline 兜底，这里不做限制。
	if cfg.Delay <= 0 {
		cfg.Delay = 150 * time.Millisecond
	}
	if cfg.Concurrency <= 0 {
		cfg.Concurrency = 1
	}
	if cfg.TooFrequentBackoff <= 0 {
		cfg.TooFrequentBackoff = maxDuration(cfg.Delay*2, defaultRetryBackoff)
	}
	if cfg.ErrorBackoff <= 0 {
		cfg.ErrorBackoff = maxDuration(cfg.Delay, defaultRetryBackoff)
	}
	// 首发错峰给了 spread 就至少要有 1ms 步长，否则等于没启用。
	if cfg.FirstWaveSpread > 0 && cfg.FirstWaveMaxStep <= 0 {
		cfg.FirstWaveMaxStep = DefaultFirstWaveMaxStep
	}
	// 积分不足是终态：积分不会自己变多，继续打只是浪费请求，默认停手。
	if !cfg.ContinueOnNotEnough {
		cfg.StopOnNotEnough = true
	}
	// 售罄刻意不给默认值：库存可能因别人取消 / 锁单过期而回流，默认继续探测到
	// 窗口结束；需要「售罄即停」时显式设置 StopOnSoldOut。
	if !cfg.ListBeforeExchange {
		cfg.DirectExchange = true
	}
	return cfg
}

// normalizeTargets 去掉空目标与重复目标。
//
// 除了完全相同的 target，还按 pid / 名称去重：界面选品会同时提交 pid、名称，
// 以及 targetText 里的同一个 pid，不去重就会对同一奖品重复兑换（实测踩过）。
func normalizeTargets(targets []Target) []Target {
	out := make([]Target, 0, len(targets))
	seenKey := map[string]bool{}
	seenPID := map[int32]bool{}
	seenName := map[string]bool{}
	for _, target := range targets {
		target.Name = strings.TrimSpace(target.Name)
		if target.PID <= 0 && target.Name == "" && !target.Auto {
			continue
		}
		if target.PID > 0 && seenPID[target.PID] {
			continue
		}
		if target.Name != "" && seenName[target.Name] {
			continue
		}
		key := targetKey(target)
		if seenKey[key] {
			continue
		}
		seenKey[key] = true
		if target.PID > 0 {
			seenPID[target.PID] = true
		}
		if target.Name != "" {
			seenName[target.Name] = true
		}
		out = append(out, target)
	}
	return out
}

func shouldDirectExchange(target Target, cfg Config) bool {
	return cfg.DirectExchange && !cfg.ListBeforeExchange && target.PID > 0 && !target.Auto
}

// notFoundMessage 在未命中时把类目限制写进提示，便于区分「被类目过滤掉」与「列表里确实没有」。
func notFoundMessage(category string) string {
	if strings.TrimSpace(category) == "" {
		return "未查询到所需物品，继续监控"
	}
	return fmt.Sprintf("类目[%s]内未查询到所需物品，继续监控", strings.TrimSpace(category))
}

func matchPrize(prizes []huya.PrizeInfo, target Target) *huya.PrizeInfo {
	if target.Auto {
		return autoPrize(prizes, target)
	}
	for i := range prizes {
		if target.PID > 0 && int32(prizes[i].ID) != target.PID {
			continue
		}
		if target.PID == 0 && target.Name != "" && !strings.Contains(prizes[i].Name, target.Name) {
			continue
		}
		if target.MaxPrice > 0 && prizes[i].Price() > target.MaxPrice {
			continue
		}
		if target.MinLeft > 0 && prizes[i].EstimatedLeft() < target.MinLeft {
			continue
		}
		return &prizes[i]
	}
	return nil
}

func autoPrize(prizes []huya.PrizeInfo, target Target) *huya.PrizeInfo {
	var fallback *huya.PrizeInfo
	for i := range prizes {
		if target.MaxPrice > 0 && prizes[i].Price() > target.MaxPrice {
			continue
		}
		if target.MinLeft > 0 && prizes[i].EstimatedLeft() < target.MinLeft {
			continue
		}
		if fallback == nil {
			fallback = &prizes[i]
		}
		if prizes[i].EstimatedLeft() > 0 {
			return &prizes[i]
		}
	}
	return fallback
}

// exchangeSignals 汇总一次兑换响应里可用于判定的信号。
//
// 虎牙把失败原因分散在 msg / actPreCondition(Tip/ButtonDesc/ConditionParams)
// 和 exchangeInfo.desc 里，status 除 200 外没有可依据的公开语义，
// 所以判定顺序是：文案 -> 成功结构（status=200 且有 orderId）-> 结构门禁 -> 兜底失败。
type exchangeSignals struct {
	text          string
	status        int32
	hasOrderID    bool
	conditionType int32
}

func buildExchangeSignals(resp *huya.ScoreExchangePrizeResp) exchangeSignals {
	if resp == nil {
		return exchangeSignals{}
	}
	parts := []string{
		resp.Msg,
		resp.ActPreCondition.Tip,
		resp.ActPreCondition.ButtonDesc,
		resp.ExchangeInfo.Desc,
	}
	for _, value := range resp.ActPreCondition.ConditionParams {
		parts = append(parts, value)
	}
	texts := make([]string, 0, len(parts))
	for _, part := range parts {
		if item := strings.TrimSpace(part); item != "" {
			texts = append(texts, item)
		}
	}
	return exchangeSignals{
		text:          strings.Join(texts, " "),
		status:        resp.Status,
		hasOrderID:    strings.TrimSpace(resp.OrderID) != "",
		conditionType: resp.ActPreCondition.ConditionType,
	}
}

// classifyExchangeText 只依据文案判定失败原因，命中时返回分类。
//
// 判定顺序固定：未开放 → 售罄 → 货币/次数 → 会话失效 → 下架 → 限流。
// 顺序很关键：限流关键词里有「稍后重试」「稍后」，如果排在前面会把更具体的原因吃掉。
// 2026-10-16 的日志里 244 条「领取频率限制，请稍后重试！！」和 917 条「活动太火爆了，
// 请稍后重试」过去全落到 failed：既看不出是被限流，也享受不到限流该有的退避语义。
func classifyExchangeText(text string) (string, bool) {
	switch {
	case containsAny(text, "暂未开放", "未开放", "未开始", "活动未开始"):
		return CategoryNotOpen, true
	case containsAny(text, "已抢完", "已抢光", "已兑完", "已售完", "库存不足", "没有库存", "领完了", "库存已耗完"):
		return CategorySoldOut, true
	case containsAny(text, "货币不足", "积分不足", "余额不足", "点券不足", "不足"):
		return CategoryNotEnough, true
	case containsAny(text, "已兑换", "重复兑换", "已领取", "超过兑换次数", "达到上限", "限购"):
		return CategoryAlreadyDone, true
	case containsAny(text, "账号未绑定", "未绑定账号", "未绑定手机", "登录态", "登录失效", "请先登录", "凭证失效", "token 失效"):
		return CategorySessionLost, true
	case containsAny(text, "奖品已下架", "已下架", "奖品不存在", "活动不存在"):
		return CategoryOffShelf, true
	case containsAny(text, "操作频繁", "太频繁", "稍后再试", "稍后重试", "火爆", "频繁", "频率", "限流", "繁忙", "人多", "排队", "手慢", "点击太快", "请求过多", "行为异常"):
		return CategoryTooFrequent, true
	}
	return "", false
}

func ClassifyExchange(resp *huya.ScoreExchangePrizeResp, err error) string {
	if err != nil {
		// 协议层错误（缺少 tRsp/tResp、解码失败）单独归类：它不是业务失败，
		// 通常是服务端在高并发下回了错误信封，需要单独统计与排查。
		if errors.Is(err, huya.ErrProtocolResponse) {
			return CategoryProtocol
		}
		return CategoryError
	}
	if resp == nil {
		return CategoryFailed
	}
	if resp.Success() {
		return CategorySuccess
	}
	signals := buildExchangeSignals(resp)
	if category, ok := classifyExchangeText(signals.text); ok {
		return category
	}
	// 成功回包也可能不带中文文案：status=200 且有 orderId 视为成功。
	if signals.status == 200 && signals.hasOrderID {
		return CategorySuccess
	}
	// 没有文案但服务端回了 precondition 门禁，归为条件未达成，按可重试失败处理。
	if signals.conditionType != 0 {
		return CategoryCondition
	}
	return CategoryFailed
}

// ExchangeMessage 返回响应里最有代表性的提示文案，供日志与 GUI 展示。
func ExchangeMessage(resp *huya.ScoreExchangePrizeResp) string {
	if resp == nil {
		return ""
	}
	for _, text := range []string{
		resp.Msg,
		resp.ActPreCondition.Tip,
		resp.ActPreCondition.ButtonDesc,
		resp.ExchangeInfo.Desc,
	} {
		if strings.TrimSpace(text) != "" {
			return strings.TrimSpace(text)
		}
	}
	return ""
}

func containsAny(text string, needles ...string) bool {
	for _, needle := range needles {
		if strings.Contains(text, needle) {
			return true
		}
	}
	return false
}

func targetKey(target Target) string {
	return strings.Join([]string{
		strings.TrimSpace(target.Name),
		int32String(target.PID),
		strconv.FormatBool(target.Auto),
		int64String(target.MaxPrice),
		int64String(target.MinLeft),
	}, "\x00")
}

func int32String(value int32) string {
	return strconv.FormatInt(int64(value), 10)
}

func int64String(value int64) string {
	return strconv.FormatInt(value, 10)
}

func sleepContext(ctx context.Context, d time.Duration) error {
	timer := time.NewTimer(d)
	defer timer.Stop()
	select {
	case <-timer.C:
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}

func maxDuration(a, b time.Duration) time.Duration {
	if a > b {
		return a
	}
	return b
}

func maxInt(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// jitterDuration 在基准退避上叠加 0-25% 的随机抖动。
//
// 多个账号同时失败时，固定退避会让它们在同一个时刻整批重试，形成周期性尖峰，
// 更容易撞上限频（参考 dygou_go 的 jitterFraction）。这里只往长了抖，不缩短，
// 保证配置值始终是退避下限。
func jitterDuration(base time.Duration) time.Duration {
	if base <= 0 {
		return base
	}
	span := int64(base) / 4
	if span <= 0 {
		return base
	}
	return base + time.Duration(rand.Int63n(span+1))
}