huya-go/internal/sniper/sniper.go

package sniper

import (
	"context"
	"errors"
	"fmt"
	"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"
)

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
	Loops                   int
	Delay                   time.Duration
	Concurrency             int
	StopAfterSuccess        bool
	StopAccountAfterSuccess bool
	Prewarm                 bool
	DirectExchange          bool
	ListBeforeExchange      bool
	SharePrizeList          bool
	RefreshAfterSuccess     bool
	StopOnNotEnough         bool
	ContinueOnNotEnough     bool
	StopOnSoldOut           bool
	ContinueOnSoldOut       bool
	TooFrequentBackoff      time.Duration
	ErrorBackoff            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
}

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
}

type targetState struct {
	Done       bool
	RetryAfter time.Time
}

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))
	for loop := 1; loop <= cfg.Loops; loop++ {
		if ctx.Err() != nil {
			return ctx.Err()
		}
		if state.allDone() {
			return nil
		}

		sharedList := r.sharedList(ctx, client, accounts, targets, cfg, state)
		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
				}
				r.runAccountLoop(ctx, client, state, account, targets, cfg, loop, sharedList, emit, cancel)
			}()
		}
		wg.Wait()
		if ctx.Err() != nil {
			return ctx.Err()
		}
		if state.allDone() {
			return nil
		}
		if loop < cfg.Loops {
			if err := sleepContext(ctx, cfg.Delay); err != nil {
				return 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()
}

func (r *Runner) runAccountLoop(ctx context.Context, client huya.ActivityClient, state *runState, account Account, targets []Target, cfg Config, loop int, sharedList *listSnapshot, 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) {
			result := r.exchangeTarget(ctx, client, account, target, index, loop, cfg.SID, nil)
			result = r.applyExchangeDecision(state, account, index, cfg, result, cancel)
			if emit != nil {
				emit(result)
			}
			r.refreshAfterSuccess(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
	}

	list := sharedList
	if list == nil {
		resp, err := client.GetActPrizeList(ctx, account.UID, account.Cookie, cfg.SID)
		list = &listSnapshot{resp: resp, err: err}
	}
	if list.err != nil || list.resp == nil {
		errText := "奖品列表响应为空"
		if list.err != nil {
			errText = list.err.Error()
		}
		for _, index := range listTargets {
			retryAt := time.Now().Add(cfg.ErrorBackoff)
			state.setRetryAfter(account.UID, index, retryAt)
			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
	}

	for _, index := range listTargets {
		target := targets[index]
		prize := matchPrize(list.resp.Prizes, target)
		if prize == nil {
			result := Result{
				Loop:        loop,
				UID:         account.UID,
				TargetIndex: index,
				Target:      target,
				Action:      "not_found",
				Category:    CategoryNotFound,
				Message:     "未查询到所需物品，继续监控",
			}
			if emit != nil {
				emit(result)
			}
			continue
		}
		result := r.exchangeTarget(ctx, client, account, target, index, loop, cfg.SID, prize)
		result = r.applyExchangeDecision(state, account, index, cfg, result, cancel)
		if emit != nil {
			emit(result)
		}
		r.refreshAfterSuccess(client, account, target, index, loop, cfg, result, emit)
		if ctx.Err() != nil {
			return
		}
	}
}

func (r *Runner) exchangeTarget(ctx context.Context, client huya.ActivityClient, 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,
	}
	exchange, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, sid, pid)
	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 {
	now := time.Now()
	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, CategorySoldOut:
		if cfg.StopOnSoldOut {
			state.markTargetDone(index)
			result.Done = true
		} else {
			retryAt := now.Add(cfg.ErrorBackoff)
			state.setRetryAfter(account.UID, index, retryAt)
			result.RetryAfter = retryAt.UnixMilli()
		}
	case CategoryTooFrequent:
		retryAt := now.Add(cfg.TooFrequentBackoff)
		state.setRetryAfter(account.UID, index, retryAt)
		result.RetryAfter = retryAt.UnixMilli()
	case CategoryError:
		retryAt := now.Add(cfg.ErrorBackoff)
		state.setRetryAfter(account.UID, index, retryAt)
		result.RetryAfter = retryAt.UnixMilli()
	case CategoryFailed:
		retryAt := now.Add(cfg.ErrorBackoff)
		state.setRetryAfter(account.UID, index, retryAt)
		result.RetryAfter = retryAt.UnixMilli()
	}
	return result
}

func (r *Runner) refreshAfterSuccess(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
	}
	go func() {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()

		score, err := client.QueryUserScore(ctx, account.UID, account.Cookie, cfg.SID)
		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 := client.GetUserPrizeRecords(ctx, account.UID, account.Cookie, cfg.SID)
		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)
	}()
}

func (r *Runner) sharedList(ctx context.Context, client huya.ActivityClient, accounts []Account, targets []Target, cfg Config, state *runState) *listSnapshot {
	if !cfg.SharePrizeList || len(accounts) == 0 {
		return nil
	}
	needsList := false
	for _, account := range accounts {
		for _, index := range state.activeTargets(account.UID, len(targets), time.Now()) {
			if !shouldDirectExchange(targets[index], cfg) {
				needsList = true
				break
			}
		}
		if needsList {
			break
		}
	}
	if !needsList {
		return nil
	}
	resp, err := client.GetActPrizeList(ctx, accounts[0].UID, accounts[0].Cookie, cfg.SID)
	return &listSnapshot{resp: resp, err: err}
}

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

func newRunState(accounts []Account, targetCount int) *runState {
	state := &runState{
		accounts:   make(map[int64][]targetState, len(accounts)),
		targetDone: make([]bool, targetCount),
	}
	for _, account := range accounts {
		state.accounts[account.UID] = make([]targetState, targetCount)
	}
	return state
}

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 {
	if cfg.Loops <= 0 {
		cfg.Loops = 1
	}
	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, 300*time.Millisecond)
	}
	if cfg.ErrorBackoff <= 0 {
		cfg.ErrorBackoff = maxDuration(cfg.Delay, 300*time.Millisecond)
	}
	if !cfg.ContinueOnNotEnough {
		cfg.StopOnNotEnough = true
	}
	if !cfg.ContinueOnSoldOut {
		cfg.StopOnSoldOut = true
	}
	if !cfg.ListBeforeExchange {
		cfg.DirectExchange = true
	}
	return cfg
}

func normalizeTargets(targets []Target) []Target {
	out := make([]Target, 0, len(targets))
	seen := map[string]bool{}
	for _, target := range targets {
		target.Name = strings.TrimSpace(target.Name)
		if target.PID <= 0 && target.Name == "" && !target.Auto {
			continue
		}
		key := targetKey(target)
		if seen[key] {
			continue
		}
		seen[key] = true
		out = append(out, target)
	}
	return out
}

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

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
}

func ClassifyExchange(resp *huya.ScoreExchangePrizeResp, err error) string {
	if err != nil {
		return CategoryError
	}
	if resp == nil {
		return CategoryFailed
	}
	if resp.Success() {
		return CategorySuccess
	}
	msg := exchangeMessage(resp)
	switch {
	case containsAny(msg, "操作频繁", "太频繁", "稍后再试"):
		return CategoryTooFrequent
	case containsAny(msg, "暂未开放", "未开放", "未开始", "活动未开始"):
		return CategoryNotOpen
	case containsAny(msg, "已抢完", "已兑完", "库存不足", "没有库存", "领完了"):
		return CategorySoldOut
	case containsAny(msg, "货币不足", "积分不足", "余额不足", "点券不足", "不足"):
		return CategoryNotEnough
	case containsAny(msg, "已兑换", "重复兑换", "已领取", "超过兑换次数", "达到上限", "限购"):
		return CategoryAlreadyDone
	case containsAny(msg, "奖品已下架", "已下架", "奖品不存在", "活动不存在"):
		return CategoryOffShelf
	case resp.Status != 0:
		return CategoryFailed
	default:
		return CategoryFailed
	}
}

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
}