dygou_go/douyu_client.go

package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"reflect"
	"strconv"
	"strings"
	"time"
)

// NewDouyuClient 创建一个专门请求斗鱼接口的客户端。
func NewDouyuClient(timeAPIURL string, trace *traceRecorder) *DouyuClient {
	return &DouyuClient{
		timeAPIURL: timeAPIURL,
		trace:      trace,
		httpClient: &http.Client{
			Timeout: 8 * time.Second,
			Transport: &http.Transport{
				MaxConnsPerHost:     120,
				MaxIdleConns:        120,
				MaxIdleConnsPerHost: 80,
				IdleConnTimeout:     30 * time.Second,
			},
		},
	}
}

// ServerTime 从商品详情接口读取 data.preExchange.currentTime。
func (c *DouyuClient) ServerTime() (time.Time, error) {
	var lastErr error
	for i := 0; i < 3; i++ {
		t, err := c.fetchServerTimeOnce()
		if err == nil {
			return t, nil
		}
		lastErr = err
		time.Sleep(100 * time.Millisecond)
	}
	return time.Now().UTC(), fmt.Errorf("服务端时间获取失败，已降级本地时间: %w", lastErr)
}

// fetchServerTimeOnce 执行一次服务端时间请求。
func (c *DouyuClient) fetchServerTimeOnce() (time.Time, error) {
	url := appendCacheBuster(c.timeAPIURL)
	var result struct {
		APIResponse
		Data struct {
			PreExchange struct {
				CurrentTime string `json:"currentTime"`
			} `json:"preExchange"`
		} `json:"data"`
	}
	if err := c.getJSON(url, "", "服务时间", &result); err != nil {
		return time.Time{}, err
	}
	ts, err := strconv.ParseInt(result.Data.PreExchange.CurrentTime, 10, 64)
	if err != nil || ts <= 0 {
		return time.Time{}, fmt.Errorf("currentTime 无效: %q", result.Data.PreExchange.CurrentTime)
	}
	return time.Unix(ts, 0).UTC(), nil
}

// Products 拉取商城商品列表。
func (c *DouyuClient) Products() ([]Product, error) {
	var result struct {
		APIResponse
		Data struct {
			List []Product `json:"list"`
		} `json:"data"`
	}
	if err := c.getJSON(storeHomeURL, "", "商品列表", &result); err != nil {
		return nil, err
	}
	if result.Error != 0 {
		return nil, fmt.Errorf("商品接口失败: %s", result.Msg)
	}
	return result.Data.List, nil
}

// Score 查询账号积分余额。
func (c *DouyuClient) Score(cookie string) (int, error) {
	req, err := http.NewRequest("POST", scoreURL, strings.NewReader(`{}`))
	if err != nil {
		return 0, err
	}
	c.setJSONHeaders(req, cookie)
	req.Header.Set("Referer", baseURL+"/")

	var result struct {
		APIResponse
		Data struct {
			Balance int `json:"balance"`
		} `json:"data"`
	}
	if err := c.doJSON(req, &result, "积分余额"); err != nil {
		return 0, err
	}
	if result.Error != 0 {
		return 0, fmt.Errorf("积分接口失败: %s", result.Msg)
	}
	return result.Data.Balance, nil
}

// GenerateCSRF 调用 generateCsrf，并从 Set-Cookie 中取 cvl_csrf_token。
func (c *DouyuClient) GenerateCSRF(cookie string) (string, error) {
	req, err := http.NewRequest("POST", csrfURL, nil)
	if err != nil {
		return "", err
	}
	c.setBrowserHeaders(req, cookie)

	start := time.Now()
	reqBody := traceRequestBody(c.trace, req)
	resp, err := c.httpClient.Do(req)
	if err != nil {
		c.trace.record("生成CSRF", req, 0, time.Since(start), reqBody, nil, err.Error(), 0, "")
		logNetworkError("生成CSRF", req, time.Since(start), err)
		return "", err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, nil, err.Error(), 0, "")
		logNetworkError("生成CSRF", req, time.Since(start), err)
		return "", err
	}
	if resp.StatusCode != http.StatusOK {
		c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, "", 0, "")
		logNetworkHTTPError("生成CSRF", req, resp.StatusCode, time.Since(start), body)
		return "", fmt.Errorf("CSRF HTTP %d: %s", resp.StatusCode, trimForLog(string(body), 120))
	}

	var api APIResponse
	if err := json.Unmarshal(body, &api); err != nil {
		c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, err.Error(), 0, "")
		logNetworkParseError("生成CSRF", req, time.Since(start), body, err)
		return "", fmt.Errorf("CSRF 响应解析失败: %w", err)
	}
	traceErr := ""
	if api.Error != 0 {
		traceErr = api.Msg
		c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, traceErr, api.Error, api.Msg)
		logNetworkAPIResult("生成CSRF", req, time.Since(start), api.Error, api.Msg)
		return "", fmt.Errorf("CSRF 接口失败: %s", api.Msg)
	}
	for _, ck := range resp.Cookies() {
		if ck.Name == "cvl_csrf_token" && ck.Value != "" {
			c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, "", api.Error, api.Msg)
			logNetworkSuccess("生成CSRF", req, time.Since(start), 0, "")
			return ck.Value, nil
		}
	}
	c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, "响应没有 cvl_csrf_token", api.Error, api.Msg)
	logEvent("网络", "warn", "接口返回异常: 生成CSRF %s %s 耗时=%s msg=响应没有 cvl_csrf_token",
		req.Method, requestPath(req), roundDuration(time.Since(start)))
	return "", errors.New("CSRF 响应没有 cvl_csrf_token")
}

// BatchExchangeLimit 请求兑换限制接口，返回本次允许的批量上限。
func (c *DouyuClient) BatchExchangeLimit(cookie, commodityID, csrf string) (int, error) {
	var result struct {
		APIResponse
		Data struct {
			Limit string `json:"limit"`
		} `json:"data"`
	}
	if err := c.postMultipart(batchLimitURL, cookie, csrf, "批量限制", map[string]string{
		"manualID":    manualID,
		"commodityID": commodityID,
		"rid":         roomID,
		"csrfToken":   csrf,
	}, &result); err != nil {
		return 0, err
	}
	if result.Error != 0 {
		return 0, fmt.Errorf("批量限制接口失败: %s", result.Msg)
	}
	limit, err := strconv.Atoi(result.Data.Limit)
	if err != nil {
		return 0, fmt.Errorf("批量限制值无效: %q", result.Data.Limit)
	}
	return limit, nil
}

// PreExchange 按抓包流程执行预兑换检查。
func (c *DouyuClient) PreExchange(cookie, commodityID, csrf string) error {
	var result APIResponse
	if err := c.postMultipart(preExchangeURL, cookie, csrf, "预兑换", map[string]string{
		"manualID":    manualID,
		"rid":         roomID,
		"commodityID": commodityID,
		"num":         "1",
		"csrfToken":   csrf,
	}, &result); err != nil {
		return err
	}
	if result.Error != 0 {
		return fmt.Errorf("预兑换失败: %s", result.Msg)
	}
	return nil
}

// Exchange 正式兑换一个商品，num 固定为 1，和浏览器抓包一致。
func (c *DouyuClient) Exchange(cookie, commodityID, csrf string) (string, error) {
	var result struct {
		APIResponse
		Data struct {
			ExchangeID   int    `json:"exchangeId"`
			ExchangeNum  string `json:"exchangeNum"`
			CommodityTyp int    `json:"commodityType"`
		} `json:"data"`
	}
	if err := c.postMultipart(exchangeURL, cookie, csrf, "正式兑换", map[string]string{
		"manualID":    manualID,
		"commodityID": commodityID,
		"num":         "1",
		"rid":         roomID,
		"csrfToken":   csrf,
	}, &result); err != nil {
		return "", err
	}
	if result.Error != 0 {
		if strings.TrimSpace(result.Msg) == "" {
			return "", errors.New("兑换失败，接口未返回原因")
		}
		return "", fmt.Errorf("兑换失败: %s", result.Msg)
	}
	return fmt.Sprintf("exchangeId=%d,num=%s", result.Data.ExchangeID, result.Data.ExchangeNum), nil
}

// RoleName 查询绑定角色名。
func (c *DouyuClient) RoleName(cookie string) (string, error) {
	var result struct {
		APIResponse
		Data struct {
			GameRole struct {
				RoleName string `json:"roleName"`
			} `json:"gameRole"`
		} `json:"data"`
	}
	if err := c.getJSON(bindInfoURL, cookie, "角色绑定", &result); err != nil {
		return "", err
	}
	if result.Error != 0 {
		return "", fmt.Errorf("角色接口失败: %s", result.Msg)
	}
	return result.Data.GameRole.RoleName, nil
}

// getJSON 发送 GET 请求并解析 JSON。
func (c *DouyuClient) getJSON(url, cookie, label string, out any) error {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return err
	}
	c.setBrowserHeaders(req, cookie)
	return c.doJSON(req, out, label)
}

// postMultipart 发送 multipart/form-data 请求并解析 JSON。
func (c *DouyuClient) postMultipart(url, cookie, csrf, label string, fields map[string]string, out any) error {
	var body bytes.Buffer
	writer := multipart.NewWriter(&body)
	for key, value := range fields {
		if err := writer.WriteField(key, value); err != nil {
			return err
		}
	}
	if err := writer.Close(); err != nil {
		return err
	}

	req, err := http.NewRequest("POST", url, &body)
	if err != nil {
		return err
	}
	c.setBrowserHeaders(req, mergeCookie(cookie, "cvl_csrf_token", csrf))
	req.Header.Set("Content-Type", writer.FormDataContentType())
	return c.doJSON(req, out, label)
}

// doJSON 执行请求、检查 HTTP 状态码并解析 JSON。
func (c *DouyuClient) doJSON(req *http.Request, out any, label string) error {
	start := time.Now()
	reqBody := traceRequestBody(c.trace, req)
	resp, err := c.httpClient.Do(req)
	if err != nil {
		c.trace.record(label, req, 0, time.Since(start), reqBody, nil, err.Error(), 0, "")
		logNetworkError(label, req, time.Since(start), err)
		return err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, nil, err.Error(), 0, "")
		logNetworkError(label, req, time.Since(start), err)
		return err
	}
	if resp.StatusCode != http.StatusOK {
		c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, "", 0, "")
		logNetworkHTTPError(label, req, resp.StatusCode, time.Since(start), body)
		return fmt.Errorf("HTTP %d: %s", resp.StatusCode, trimForLog(string(body), 160))
	}
	if err := json.Unmarshal(body, out); err != nil {
		c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, err.Error(), 0, "")
		logNetworkParseError(label, req, time.Since(start), body, err)
		return fmt.Errorf("JSON 解析失败: %w, body=%s", err, trimForLog(string(body), 160))
	}
	if apiError, apiMsg, ok := extractAPIStatus(out); ok && apiError != 0 {
		c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, apiMsg, apiError, apiMsg)
		logNetworkAPIResult(label, req, time.Since(start), apiError, apiMsg)
	} else if shouldLogNetworkSuccess(label) {
		c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, "", 0, "")
		logNetworkSuccess(label, req, time.Since(start), 0, "")
	} else {
		c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, "", 0, "")
	}
	return nil
}

func shouldLogNetworkSuccess(label string) bool {
	return label != "服务时间"
}

func logNetworkSuccess(label string, req *http.Request, cost time.Duration, apiError int, apiMsg string) {
	if !shouldLogNetworkSuccess(label) {
		return
	}
	extra := ""
	if apiMsg != "" || apiError != 0 {
		extra = fmt.Sprintf(" apiError=%d msg=%s", apiError, trimForLog(apiMsg, 80))
	}
	logEvent("网络", "info", "请求完成: %s %s %s 耗时=%s%s", label, req.Method, requestPath(req), roundDuration(cost), extra)
}

func logNetworkAPIResult(label string, req *http.Request, cost time.Duration, apiError int, apiMsg string) {
	logEvent("网络", "warn", "接口返回异常: %s %s %s 耗时=%s apiError=%d msg=%s",
		label, req.Method, requestPath(req), roundDuration(cost), apiError, trimForLog(apiMsg, 120))
}

func logNetworkHTTPError(label string, req *http.Request, status int, cost time.Duration, body []byte) {
	logEvent("网络", "error", "HTTP异常: %s %s %s 状态=%d 耗时=%s 响应=%s",
		label, req.Method, requestPath(req), status, roundDuration(cost), trimForLog(string(body), 160))
}

func logNetworkParseError(label string, req *http.Request, cost time.Duration, body []byte, err error) {
	logEvent("网络", "error", "响应解析失败: %s %s %s 耗时=%s 错误=%v 响应=%s",
		label, req.Method, requestPath(req), roundDuration(cost), err, trimForLog(string(body), 160))
}

func logNetworkError(label string, req *http.Request, cost time.Duration, err error) {
	logEvent("网络", "error", "请求失败: %s %s %s 耗时=%s 错误=%v",
		label, req.Method, requestPath(req), roundDuration(cost), err)
}

func requestPath(req *http.Request) string {
	if req == nil || req.URL == nil {
		return "-"
	}
	return req.URL.Path
}

func roundDuration(d time.Duration) time.Duration {
	return d.Round(time.Millisecond)
}

func extractAPIStatus(out any) (int, string, bool) {
	if out == nil {
		return 0, "", false
	}
	v := reflect.ValueOf(out)
	if v.Kind() == reflect.Pointer {
		if v.IsNil() {
			return 0, "", false
		}
		v = v.Elem()
	}
	if !v.IsValid() {
		return 0, "", false
	}
	if v.Type() == reflect.TypeOf(APIResponse{}) {
		api := v.Interface().(APIResponse)
		return api.Error, api.Msg, true
	}
	if v.Kind() != reflect.Struct {
		return 0, "", false
	}
	if field := v.FieldByName("APIResponse"); field.IsValid() && field.CanInterface() {
		if api, ok := field.Interface().(APIResponse); ok {
			return api.Error, api.Msg, true
		}
	}
	errorField := v.FieldByName("Error")
	msgField := v.FieldByName("Msg")
	if errorField.IsValid() && msgField.IsValid() && errorField.CanInt() && msgField.Kind() == reflect.String {
		return int(errorField.Int()), msgField.String(), true
	}
	return 0, "", false
}

// setBrowserHeaders 设置接近浏览器抓包的通用请求头。
func (c *DouyuClient) setBrowserHeaders(req *http.Request, cookie string) {
	req.Header.Set("Accept", "application/json, text/plain, */*")
	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en-US;q=0.6,en;q=0.5")
	req.Header.Set("User-Agent", userAgent)
	req.Header.Set("Origin", baseURL)
	req.Header.Set("Referer", shopReferer)
	req.Header.Set("Sec-Fetch-Dest", "empty")
	req.Header.Set("Sec-Fetch-Mode", "cors")
	req.Header.Set("Sec-Fetch-Site", "same-origin")
	if strings.TrimSpace(cookie) != "" {
		req.Header.Set("Cookie", cookie)
	}
}

// setJSONHeaders 设置 JSON POST 请求头。
func (c *DouyuClient) setJSONHeaders(req *http.Request, cookie string) {
	c.setBrowserHeaders(req, cookie)
	req.Header.Set("Content-Type", "application/json")
}