package service

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync"
	"testing"
	"time"

	"affiliate_dash/internal/model"
	"affiliate_dash/internal/pkg/timeutil"
	"affiliate_dash/internal/testdb"
	"gorm.io/gorm"
)

func newRockTestDB(t *testing.T) *gorm.DB {
	t.Helper()
	return testdb.New(t,
		&model.Merchant{},
		&model.Product{},
		&model.MerchantProduct{},
		&model.FulfillmentOrder{},
		&model.RockConfig{},
		&model.RockToken{},
	)
}

func TestRockProvider_KillSwitch(t *testing.T) {
	db := newRockTestDB(t)
	client := NewRockClient("https://example.com")
	rockSvc := NewRockService(db, client)
	provider := NewRockProvider(rockSvc)

	// 1. 初始化配置并关闭总开关
	cfg, err := rockSvc.GetConfig(context.Background())
	if err != nil {
		t.Fatalf("get config: %v", err)
	}
	f := false
	_, err = rockSvc.UpdateConfig(context.Background(), UpdateRockConfigReq{
		AutoDeliveryEnabled: &f,
	})
	if err != nil {
		t.Fatalf("update config: %v", err)
	}

	order := &model.FulfillmentOrder{
		OrderNo:    "ROCK-ORDER-001",
		ProductSKU: model.RockSKUBlackTshirt,
	}

	// 2. PrepareDelivery 检查是否触发熔断
	state, err := provider.PrepareDelivery(context.Background(), order, nil)
	if err != nil {
		t.Fatalf("prepare delivery: %v", err)
	}
	if state.CanShip {
		t.Fatalf("总开关关闭时应该不可发货")
	}
	if !strings.Contains(state.CannotShipReason, "维护中") {
		t.Fatalf("熔断提示信息不符: %s", state.CannotShipReason)
	}

	// 3. 恢复开启总开关
	tr := true
	_, _ = rockSvc.UpdateConfig(context.Background(), UpdateRockConfigReq{
		AutoDeliveryEnabled: &tr,
	})
	_ = cfg
}

func TestRockProvider_PrepareDelivery_ZeroStockWithAssignedToken(t *testing.T) {
	db := newRockTestDB(t)
	client := NewRockClient("https://example.com")
	rockSvc := NewRockService(db, client)
	provider := NewRockProvider(rockSvc)

	// 开启总开关
	tr := true
	_, _ = rockSvc.UpdateConfig(context.Background(), UpdateRockConfigReq{
		AutoDeliveryEnabled: &tr,
	})

	// 当前数据库没有可用 Token (available = 0)
	// 场景 1：未分配 Token 的新订单
	newOrder := &model.FulfillmentOrder{
		OrderNo:    "ROCK-ORDER-NEW",
		ProductSKU: model.RockSKUBlackTshirt,
	}
	stateNew, err := provider.PrepareDelivery(context.Background(), newOrder, nil)
	if err != nil {
		t.Fatalf("prepare new order: %v", err)
	}
	if stateNew.CanShip {
		t.Fatalf("库存为 0 且未分配 Token 时新订单应该不可发货")
	}
	if !strings.Contains(stateNew.CannotShipReason, "库存补充中") {
		t.Fatalf("期望库存补充中提示，实际为: %s", stateNew.CannotShipReason)
	}

	// 场景 2：已分配并锁定 Token 的订单 (using 或 bound 状态)
	assignedOrder := &model.FulfillmentOrder{
		OrderNo:    "ROCK-ORDER-ASSIGNED",
		ProductSKU: model.RockSKUBlackTshirt,
	}
	now := time.Now()
	token := model.RockToken{
		UpstreamTokenID: "999888",
		Token:           "token_assigned",
		RedeemCode:      "code_assigned",
		Color:           model.RockColorBlack,
		Status:          model.RockStatusBound,
		AssignedOrderNo: "ROCK-ORDER-ASSIGNED",
		ExpectedUID:     "123456",
		ClaimedAt:       &now,
	}
	db.Create(&token)

	stateAssigned, err := provider.PrepareDelivery(context.Background(), assignedOrder, nil)
	if err != nil {
		t.Fatalf("prepare assigned order: %v", err)
	}
	if !stateAssigned.CanShip {
		t.Fatalf("已分配并锁定 Token 的订单即使池子空闲库存为 0 也必须允许继续提货发货: %s", stateAssigned.CannotShipReason)
	}
}

func TestRockProvider_AntiGhostAndUIDMismatch(t *testing.T) {
	db := newRockTestDB(t)

	// Mock 上游 0666.pro 响应
	var currentBoundAccount string
	var currentBoundRoleID string
	var currentBindChangedAt string

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if strings.HasPrefix(r.URL.Path, "/api/redeem/") {
			_ = json.NewEncoder(w).Encode(RockRedeemDetailResponse{
				ID:         151153,
				RedeemCode: "mock_redeem_code",
				Color:      "black",
				Status:     "available",
				BindURL:    "https://gp.qq.com/cp/mock_bind",
			})
			return
		}
		if strings.HasSuffix(r.URL.Path, "/refresh") {
			var resp RockRefreshResponse
			if currentBoundRoleID != "" {
				resp.Token.Status = "bound"
				resp.Token.BoundAccount = currentBoundAccount
				resp.Token.BoundAccountID = currentBoundRoleID
				resp.Token.Region = "安卓-微信"
				resp.Token.BindChangedAt = currentBindChangedAt
			}
			_ = json.NewEncoder(w).Encode(resp)
			return
		}
		w.WriteHeader(http.StatusNotFound)
	}))
	defer server.Close()

	client := NewRockClient(server.URL)
	rockSvc := NewRockService(db, client)
	provider := NewRockProvider(rockSvc)

	// 预先插入 1 个可用 Token，模拟历史残留数据
	now := time.Now()
	token := model.RockToken{
		UpstreamTokenID: "151153",
		Token:           "mock_jwt_token",
		RedeemCode:      "mock_redeem_code",
		Color:           model.RockColorBlack,
		Status:          model.RockStatusAvailable,
		ClaimedAt:       &now,
	}
	db.Create(&token)

	// 模拟场景 A：上游初始已有历史残留账号“总荒凉”(3751279035)
	currentBoundAccount = "总荒凉"
	currentBoundRoleID = "3751279035"
	currentBindChangedAt = "2026-10-01 10:00:00"

	// 买家期望 UID 为 3688825401
	expectedUID := "3688825401"
	order := &model.FulfillmentOrder{
		OrderNo:    "ROCK-ORDER-002",
		ProductSKU: model.RockSKUBlackTshirt,
		ResultData: fmt.Sprintf(`{"expected_uid":"%s"}`, expectedUID),
	}

	// 1. 买家点击生成绑定二维码
	bindRes, err := provider.Bind(context.Background(), order, expectedUID)
	if err != nil {
		t.Fatalf("bind error: %v", err)
	}
	if bindRes.BindURL == "" {
		t.Fatalf("bind URL 不应为空")
	}

	// 2. 买家尚未扫码，轮询 CheckBind：应当识别出历史残留并忽略，不报错也不发货
	check1, err := provider.CheckBind(context.Background(), order, bindRes.BindUUID)
	if err != nil {
		t.Fatalf("check bind: %v", err)
	}
	if check1.Bound {
		t.Fatalf("买家尚未扫码，不应判定为绑定成功（被历史残留误导）")
	}

	// 3. 买家扫错了号！拿了微信小号扫码，实际角色变成了“错误小号”(9999999999)
	currentBoundAccount = "错误小号"
	currentBoundRoleID = "9999999999"
	currentBindChangedAt = "2026-10-05 14:00:00"

	check2, err := provider.CheckBind(context.Background(), order, bindRes.BindUUID)
	if err != nil {
		t.Fatalf("check bind mismatch: %v", err)
	}
	if !check2.Mismatch {
		t.Fatalf("UID 不匹配时必须标记 mismatch = true！")
	}
	if check2.Bound {
		t.Fatalf("UID 不匹配时严禁 bound = true！")
	}

	// 检查数据库中 Token 状态是否已跃迁为 mismatch
	var dbToken model.RockToken
	db.First(&dbToken, token.ID)
	if dbToken.Status != model.RockStatusMismatch {
		t.Fatalf("Token 状态应为 mismatch，当前为 %s", dbToken.Status)
	}
	if !strings.Contains(dbToken.MismatchReason, "不一致") {
		t.Fatalf("mismatch reason 异常: %s", dbToken.MismatchReason)
	}

	// 3b. 绑定失败后，即使池里还有库存、买家改了 UID，也不能再领新号。
	spare := model.RockToken{
		UpstreamTokenID: "151154",
		Token:           "spare_jwt_token",
		RedeemCode:      "spare_redeem_code",
		Color:           model.RockColorBlack,
		Status:          model.RockStatusAvailable,
		ClaimedAt:       &now,
	}
	db.Create(&spare)
	_, err = provider.Bind(context.Background(), order, "1111111111")
	if err == nil || !strings.Contains(err.Error(), "联系客服") {
		t.Fatalf("mismatch 后必须拒绝更换提货号，实际: %v", err)
	}
	var spareAfter model.RockToken
	db.First(&spareAfter, spare.ID)
	if spareAfter.Status != model.RockStatusAvailable || spareAfter.AssignedOrderNo != "" {
		t.Fatalf("拒绝换号后备用库存应保持可用，实际 status=%s order=%s", spareAfter.Status, spareAfter.AssignedOrderNo)
	}
	var assignedCount int64
	db.Model(&model.RockToken{}).Where("assigned_order_no = ?", order.OrderNo).Count(&assignedCount)
	if assignedCount != 1 {
		t.Fatalf("一个订单只能占用一个提货号，实际 %d", assignedCount)
	}
	// 4. 客服确认买家输错，执行人工解冻重置
	err = rockSvc.ResetMismatchToken(context.Background(), token.ID)
	if err != nil {
		t.Fatalf("reset mismatch token: %v", err)
	}
	db.First(&dbToken, token.ID)
	if dbToken.Status != model.RockStatusAvailable {
		t.Fatalf("重置后状态应为 available，当前为 %s", dbToken.Status)
	}

	// 5. 重新绑定正确账号“感性的洁少”(3688825401)
	currentBoundAccount = "感性的洁少"
	currentBoundRoleID = "3688825401"
	currentBindChangedAt = "2026-10-05 14:05:00"

	bindRes2, err := provider.Bind(context.Background(), order, expectedUID)
	if err != nil {
		t.Fatalf("rebind error: %v", err)
	}
	check3, err := provider.CheckBind(context.Background(), order, bindRes2.BindUUID)
	if err != nil {
		t.Fatalf("check bind match: %v", err)
	}
	if !check3.Bound {
		t.Fatalf("正确账号扫码后应判定为 bound = true")
	}
	if check3.RoleName != "感性的洁少" {
		t.Fatalf("正确账号扫码后应正确读取角色名 感性的洁少，实际为: %s", check3.RoleName)
	}
}

func TestRockProvider_SubmitBlueAndBlack(t *testing.T) {
	db := newRockTestDB(t)

	var receivedSkin string
	var receivedCurrency string
	var receivedAccount string

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if strings.HasSuffix(r.URL.Path, "/refresh") {
			var resp RockRefreshResponse
			resp.DeliveryList = []RockDeliveryItem{
				{FulfillID: 888999},
			}
			_ = json.NewEncoder(w).Encode(resp)
			return
		}
		if strings.HasPrefix(r.URL.Path, "/api/redeem/") {
			if !strings.HasPrefix(r.Header.Get("Authorization"), "Bearer ") {
				w.WriteHeader(http.StatusUnauthorized)
				_ = json.NewEncoder(w).Encode(map[string]string{"error": "请先登录"})
				return
			}
			var req map[string]string
			_ = json.NewDecoder(r.Body).Decode(&req)
			receivedSkin = req["skin"]
			receivedCurrency = req["currency"]
			receivedAccount = req["account"]

			resp := RockRedeemResponse{
				Status:  "success",
				Message: "领取成功",
			}
			resp.Token.Status = "redeemed"
			resp.Token.RedeemSkin = receivedSkin
			resp.Token.RedeemCurrency = receivedCurrency
			_ = json.NewEncoder(w).Encode(resp)
			return
		}
		w.WriteHeader(http.StatusOK)
	}))
	defer server.Close()

	client := NewRockClient(server.URL)
	rockSvc := NewRockService(db, client)
	provider := NewRockProvider(rockSvc)
	db.Model(&model.RockConfig{}).Where("id = 1").Update("bearer_token", "mock_bearer_token")

	// 场景 A：兑换蓝色运动服上衣
	now := time.Now()
	tokenBlue := model.RockToken{
		UpstreamTokenID: "151154",
		Token:           "token_blue",
		RedeemCode:      "code_blue",
		Color:           model.RockColorBlack, // 通用黑色 Token
		Status:          model.RockStatusBound,
		AssignedOrderNo: "ORDER-BLUE-001",
		ExpectedUID:     "4331027062",
		ActualRoleName:  "破浪小王子",
		ActualRoleID:    "4331027062",
		BoundAt:         &now,
	}
	db.Create(&tokenBlue)

	orderBlue := &model.FulfillmentOrder{
		OrderNo:    "ORDER-BLUE-001",
		ProductSKU: model.RockSKUBlueSportswear, // 蓝色运动服
		ResultData: `{"expected_uid":"4331027062"}`,
	}

	submitRes, err := provider.Submit(context.Background(), orderBlue, "4331027062", fmt.Sprintf("%d", tokenBlue.ID))
	if err != nil {
		t.Fatalf("submit blue error: %v", err)
	}

	if receivedSkin != model.RockSkinBlueSportswear {
		t.Fatalf("蓝色运动服发货应传入 %s，实际为 %s", model.RockSkinBlueSportswear, receivedSkin)
	}
	if receivedAccount != "破浪小王子" {
		t.Fatalf("发货账号应为 破浪小王子，实际为 %s", receivedAccount)
	}
	if submitRes.ProviderOrderNo != "888999" {
		t.Fatalf("期望官方 fulfillId 888999，实际为 %s", submitRes.ProviderOrderNo)
	}

	// 检查数据库记录
	var dbToken model.RockToken
	db.First(&dbToken, tokenBlue.ID)
	if dbToken.Status != model.RockStatusRedeemed {
		t.Fatalf("发货后 Token 状态应为 redeemed，当前为 %s", dbToken.Status)
	}
	if dbToken.UpstreamFulfillID != 888999 {
		t.Fatalf("fulfillID 记录错误: %d", dbToken.UpstreamFulfillID)
	}
}

func TestRockService_StatsAndPurchase(t *testing.T) {
	db := newRockTestDB(t)

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if r.URL.Path == "/api/user/dashboard" {
			writeRockDashboardJSON(w, 999, "20.0")
			return
		}
		if r.URL.Path == "/api/me" {
			_ = json.NewEncoder(w).Encode(map[string]interface{}{
				"user": map[string]interface{}{
					"id":       10028,
					"username": "王大锤",
					"role":     "merchant",
					"points":   "8271.2", // 真实上游 0666.pro 返回字符串格式
					"status":   "active",
				},
			})
			return
		}
		if r.URL.Path == "/api/user/tokens/claim" {
			_ = json.NewEncoder(w).Encode(map[string]interface{}{
				"tokens": []map[string]interface{}{
					{
						"id":          20001,
						"token":       "token_mock_1",
						"color":       "black",
						"region":      "Q/V可用",
						"status":      "available",
						"redeem_code": "code_mock_1",
						"claimed_at":  "2026-10-05 14:00:00",
					},
					{
						"id":          20002,
						"token":       "token_mock_2",
						"color":       "black",
						"region":      "Q/V可用",
						"status":      "available",
						"redeem_code": "code_mock_2",
						"claimed_at":  "2026-10-05 14:00:00",
					},
				},
			})
			return
		}
		w.WriteHeader(http.StatusOK)
	}))
	defer server.Close()

	client := NewRockClient(server.URL)
	rockSvc := NewRockService(db, client)

	// 1. 测试 Token 连通性
	me, err := rockSvc.TestConnection(context.Background(), "mock_bearer_token")
	if err != nil {
		t.Fatalf("test connection: %v", err)
	}
	if me.User.Username != "王大锤" || me.User.Points != 8271.2 {
		t.Fatalf("用户信息解析不符: %+v", me.User)
	}

	// 2. 更新系统配置设置 BearerToken
	tokenStr := "mock_bearer_token"
	_, err = rockSvc.UpdateConfig(context.Background(), UpdateRockConfigReq{
		BearerToken: &tokenStr,
	})
	if err != nil {
		t.Fatalf("update config: %v", err)
	}

	// 3. 采购 2 个黑色通用 Token
	tokens, err := rockSvc.PurchaseTokens(context.Background(), 2, false)
	if err != nil {
		t.Fatalf("purchase tokens: %v", err)
	}
	if len(tokens) != 2 {
		t.Fatalf("期望采购 2 个，实际返回 %d", len(tokens))
	}

	// 4. 检查库存统计
	stats, err := rockSvc.GetStats(context.Background())
	if err != nil {
		t.Fatalf("get stats: %v", err)
	}
	if stats.AvailableStock != 2 {
		t.Fatalf("期望可用库存为 2，实际为 %d", stats.AvailableStock)
	}
	if stats.Username != "王大锤" {
		t.Fatalf("期望采购商户名为王大锤，实际为 %s", stats.Username)
	}

	// 5. 分页查询列表
	list, total, err := rockSvc.ListTokens(context.Background(), 1, 10, "", "")
	if err != nil {
		t.Fatalf("list tokens: %v", err)
	}
	if total != 2 || len(list) != 2 {
		t.Fatalf("期望查询到 2 条，实际为 total=%d len=%d", total, len(list))
	}

	// 6. 测试关联履约订单与创建订单商户单号反查
	orderNo := "FO_TEST_ROCK_999"
	clientOrderNo := "SHOP_ORDER_PDD_888"
	_ = db.Create(&model.FulfillmentOrder{
		OrderNo:       orderNo,
		ClientOrderNo: clientOrderNo,
		ProductSKU:    "rock_black_tshirt",
		ProductName:   "黑色ROCK长袖T恤",
	}).Error
	_ = db.Model(&model.RockToken{}).Where("id = ?", list[0].ID).Update("assigned_order_no", orderNo).Error

	listWithClient, _, err := rockSvc.ListTokens(context.Background(), 1, 10, "", "")
	if err != nil {
		t.Fatalf("list tokens with client: %v", err)
	}
	found := false
	for _, tk := range listWithClient {
		if tk.ID == list[0].ID {
			found = true
			if tk.ClientOrderNo != clientOrderNo {
				t.Fatalf("期望商户单号为 %s，实际为 %s", clientOrderNo, tk.ClientOrderNo)
			}
		}
	}
	if !found {
		t.Fatalf("未找到对应的 Token 记录")
	}

	// 7. 测试按商户单号关键词搜索
	searchList, searchTotal, err := rockSvc.ListTokens(context.Background(), 1, 10, "", "PDD_888")
	if err != nil {
		t.Fatalf("search tokens by client_order_no: %v", err)
	}
	if searchTotal != 1 || len(searchList) != 1 {
		t.Fatalf("期望按商户单号搜索出 1 条，实际为 total=%d len=%d", searchTotal, len(searchList))
	}
}

func TestReleaseUnboundUsingToken(t *testing.T) {
	db := newRockTestDB(t)

	var boundRoleID string
	var bindChangedAt string
	var deliveryTime string
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if strings.HasSuffix(r.URL.Path, "/refresh") {
			var resp RockRefreshResponse
			if boundRoleID != "" {
				resp.Token.Status = "bound"
				resp.Token.BoundAccount = "已扫码角色"
				resp.Token.BoundAccountID = boundRoleID
				resp.Token.BindChangedAt = bindChangedAt
			}
			if deliveryTime != "" {
				resp.DeliveryList = []RockDeliveryItem{{
					Time:    deliveryTime,
					Role:    "iOS-微信-已扫码角色",
					Message: "成功发放",
				}}
			}
			_ = json.NewEncoder(w).Encode(resp)
			return
		}
		w.WriteHeader(http.StatusNotFound)
	}))
	defer server.Close()

	client := NewRockClient(server.URL)
	rockSvc := NewRockService(db, client)
	provider := NewRockProvider(rockSvc)
	bearer := "mock_bearer_token"
	if _, err := rockSvc.UpdateConfig(context.Background(), UpdateRockConfigReq{BearerToken: &bearer}); err != nil {
		t.Fatalf("update config: %v", err)
	}

	snap := BindingSnapshot{
		Bound:         true,
		RoleName:      "历史残留",
		RoleID:        "111",
		BindChangedAt: "2026-10-01 10:00:00",
	}
	snapBytes, _ := json.Marshal(snap)
	token := model.RockToken{
		UpstreamTokenID:      "88001",
		Token:                "jwt",
		RedeemCode:           "redeem-unused",
		Color:                model.RockColorBlack,
		Status:               model.RockStatusUsing,
		AssignedOrderNo:      "FO-RELEASE-1",
		ExpectedUID:          "3688825401",
		InitialBoundSnapshot: string(snapBytes),
	}
	if err := db.Create(&token).Error; err != nil {
		t.Fatalf("create token: %v", err)
	}
	if err := db.Create(&model.FulfillmentOrder{
		OrderNo:     "FO-RELEASE-1",
		ProductSKU:  model.RockSKUBlackTshirt,
		ProductName: "黑色ROCK长袖T恤",
		ResultData:  fmt.Sprintf(`{"provider":"rock","rock_token_id":%d,"rock_redeem_code":"redeem-unused","expected_uid":"3688825401"}`, token.ID),
	}).Error; err != nil {
		t.Fatalf("create order: %v", err)
	}

	// 历史残留与快照一致，视为买家还没扫，允许释放。
	boundRoleID = "111"
	bindChangedAt = "2026-10-01 10:00:00"
	if err := rockSvc.ReleaseUnboundUsingToken(context.Background(), token.ID); err != nil {
		t.Fatalf("release ghost snapshot: %v", err)
	}
	var released model.RockToken
	if err := db.First(&released, token.ID).Error; err != nil {
		t.Fatalf("reload token: %v", err)
	}
	if released.Status != model.RockStatusAvailable || released.AssignedOrderNo != "" || released.ExpectedUID != "" {
		t.Fatalf("释放后应回到可用库存，实际 status=%s order=%s uid=%s", released.Status, released.AssignedOrderNo, released.ExpectedUID)
	}
	var order model.FulfillmentOrder
	if err := db.Where("order_no = ?", "FO-RELEASE-1").First(&order).Error; err != nil {
		t.Fatalf("reload order: %v", err)
	}
	if resultDataNumber(order.ResultData, "rock_token_id") != 0 || !strings.Contains(order.ResultData, "rock_token_released") {
		t.Fatalf("原订单仍指向已释放链接: %s", order.ResultData)
	}

	// 旧发货页继续轮询时，不能把已释放的链接再改成绑定。
	boundRoleID = "3688825401"
	bindChangedAt = "2026-10-05 21:00:00"
	check, err := provider.CheckBind(context.Background(), &order, fmt.Sprintf("%d", token.ID))
	if err != nil {
		t.Fatalf("check bind after release: %v", err)
	}
	if check.Bound {
		t.Fatalf("已释放链接不应再判定为绑定成功")
	}
	if err := db.First(&released, token.ID).Error; err != nil {
		t.Fatalf("reload after check: %v", err)
	}
	if released.Status != model.RockStatusAvailable {
		t.Fatalf("旧页面轮询后状态被改写为 %s", released.Status)
	}

	// 上游已经出现新扫码时拒绝释放。
	using := model.RockToken{
		UpstreamTokenID: "88002",
		Token:           "jwt2",
		RedeemCode:      "redeem-bound",
		Color:           model.RockColorBlack,
		Status:          model.RockStatusUsing,
		AssignedOrderNo: "FO-RELEASE-2",
		ExpectedUID:     "3688825401",
	}
	if err := db.Create(&using).Error; err != nil {
		t.Fatalf("create using token: %v", err)
	}
	boundRoleID = "3688825401"
	bindChangedAt = "2026-10-05 21:10:00"
	if err := rockSvc.ReleaseUnboundUsingToken(context.Background(), using.ID); err == nil || !strings.Contains(err.Error(), "已扫码绑定") {
		t.Fatalf("已绑定链接必须拒绝释放，实际: %v", err)
	}
	var stillUsing model.RockToken
	if err := db.First(&stillUsing, using.ID).Error; err != nil {
		t.Fatalf("reload using: %v", err)
	}
	if stillUsing.Status != model.RockStatusUsing || stillUsing.AssignedOrderNo != "FO-RELEASE-2" {
		t.Fatalf("拒绝释放后应保持使用中，实际 status=%s order=%s", stillUsing.Status, stillUsing.AssignedOrderNo)
	}

	// 上游 status=bound，但发货记录早于本次领取、绑定时间仍为空：历史残留，可以再次使用。
	// 上游时间串不带偏移，统一按业务时区解析；这里的时间基线也必须用同一时区，
	// 否则测试结果会随宿主机 TZ 漂移。
	claimedAt := time.Date(2026, 10, 5, 20, 32, 17, 0, timeutil.Location())
	stale := model.RockToken{
		UpstreamTokenID:      "152415",
		Token:                "jwt3",
		RedeemCode:           "dbece05764c701a3be3bb5c689926d07",
		Color:                model.RockColorBlack,
		Status:               model.RockStatusUsing,
		AssignedOrderNo:      "FO-RELEASE-3",
		ExpectedUID:          "3364503067",
		ClaimedAt:            &claimedAt,
		InitialBoundSnapshot: `{"bound":true,"role_name":"予心纯白","role_id":"1900505843","channel":"iOS-微信","bind_changed_at":""}`,
	}
	if err := db.Create(&stale).Error; err != nil {
		t.Fatalf("create stale token: %v", err)
	}
	boundRoleID = "1900505843"
	bindChangedAt = ""
	deliveryTime = "2026-09-27T14:38:51.23"
	if err := rockSvc.ReleaseUnboundUsingToken(context.Background(), stale.ID); err != nil {
		t.Fatalf("历史残留应允许释放: %v", err)
	}

	// 领取之后出现新的发货记录，不能释放。
	fresh := model.RockToken{
		UpstreamTokenID: "152420",
		Token:           "jwt4",
		RedeemCode:      "redeem-fresh-delivery",
		Color:           model.RockColorBlack,
		Status:          model.RockStatusUsing,
		AssignedOrderNo: "FO-RELEASE-4",
		ExpectedUID:     "4744920014",
		ClaimedAt:       &claimedAt,
	}
	if err := db.Create(&fresh).Error; err != nil {
		t.Fatalf("create fresh token: %v", err)
	}
	boundRoleID = "4744920014"
	bindChangedAt = "2026-10-05 21:52:30"
	deliveryTime = "2026-10-05T21:52:40.61"
	if err := rockSvc.ReleaseUnboundUsingToken(context.Background(), fresh.ID); err == nil || !strings.Contains(err.Error(), "已扫码绑定") {
		t.Fatalf("领取后的新发货必须拒绝释放，实际: %v", err)
	}
}

func TestRockProvider_SchemeB_UIDSelfHealing(t *testing.T) {
	db := newRockTestDB(t)

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if strings.Contains(r.URL.Path, "/api/redeem/") {
			_ = json.NewEncoder(w).Encode(map[string]interface{}{
				"id":          1001,
				"bind_url":    "https://igame.qq.com/activity/test?code=redeem_scheme_b",
				"redeem_code": "redeem_scheme_b",
			})
			return
		}
		if strings.Contains(r.URL.Path, "refresh") {
			_ = json.NewEncoder(w).Encode(map[string]interface{}{
				"token": map[string]interface{}{
					"id":               152001,
					"status":           "bound",
					"bind_changed_at":  "2026-10-06 10:00:00",
					"bound_account":    "少年有点忧郁",
					"bound_account_id": "3454648872",
					"region":           "安卓-微信",
				},
				"deliveryList": []interface{}{},
			})
			return
		}
		w.WriteHeader(http.StatusNotFound)
	}))
	defer server.Close()

	client := NewRockClient(server.URL)
	rockSvc := NewRockService(db, client)
	provider := NewRockProvider(rockSvc)
	ctx := context.Background()

	now := time.Now()
	token := model.RockToken{
		UpstreamTokenID: "152001",
		Token:           "test_jwt_scheme_b",
		RedeemCode:      "redeem_scheme_b",
		Color:           model.RockColorBlack,
		Status:          model.RockStatusAvailable,
		ClaimedAt:       &now,
	}
	db.Create(&token)

	order := &model.FulfillmentOrder{
		OrderNo:    "ROCK-ORDER-HEAL",
		ProductSKU: model.RockSKUBlackTshirt,
	}
	db.Create(order)

	// 1. 买家一开始输错 UID 为 3658745636，触发分配
	bindRes1, err := provider.Bind(ctx, order, "3658745636")
	if err != nil {
		t.Fatalf("首次分配失败: %v", err)
	}
	if bindRes1.Bound {
		t.Fatalf("尚未扫码，bound 应为 false")
	}

	// 2. 扫码反查，真实角色是 3454648872，发生 mismatch
	check1, err := provider.CheckBind(ctx, order, bindRes1.BindUUID)
	if err != nil {
		t.Fatalf("check bind failed: %v", err)
	}
	if !check1.Mismatch {
		t.Fatalf("UID 不一致必须标记为 mismatch")
	}
	if !strings.Contains(check1.Message, "3454648872") {
		t.Fatalf("提示信息应包含引导买家确认修改为 3454648872，实际: %s", check1.Message)
	}

	// 3. 买家尝试换成第三个账号 9999999999，应坚决被拦截
	_, err = provider.Bind(ctx, order, "9999999999")
	if err == nil || !strings.Contains(err.Error(), "3454648872") {
		t.Fatalf("更换为非扫码角色应被拦截，实际 err: %v", err)
	}

	// 4. 方案 B：买家确认更换为扫码角色 UID 3454648872
	bindRes2, err := provider.Bind(ctx, order, "3454648872")
	if err != nil {
		t.Fatalf("确认更换为扫码角色 UID 应自愈成功，实际失败: %v", err)
	}
	if !bindRes2.Bound {
		t.Fatalf("自愈后 bound 应为 true")
	}
	if bindRes2.RoleName != "少年有点忧郁" || bindRes2.GameAccount != "3454648872" {
		t.Fatalf("自愈后返回的角色信息不符: %v", bindRes2)
	}

	// 5. 校验数据库状态与订单占号唯一性
	var dbToken model.RockToken
	db.First(&dbToken, token.ID)
	if dbToken.Status != model.RockStatusBound {
		t.Fatalf("自愈后 token 状态应为 bound，当前: %s", dbToken.Status)
	}
	if dbToken.ExpectedUID != "3454648872" {
		t.Fatalf("自愈后 expectedUID 应为 3454648872，当前: %s", dbToken.ExpectedUID)
	}
	var count int64
	db.Model(&model.RockToken{}).Where("assigned_order_no = ?", order.OrderNo).Count(&count)
	if count != 1 {
		t.Fatalf("整个流程该订单必须严格只占用 1 个 Token，实际占用: %d", count)
	}
}

func TestRockService_CorrectMismatchUIDKeepsAssignment(t *testing.T) {
	db := newRockTestDB(t)
	now := time.Now()
	token := model.RockToken{
		UpstreamTokenID: "179",
		Token:           "token-179",
		RedeemCode:      "redeem-179",
		Color:           model.RockColorBlack,
		Status:          model.RockStatusMismatch,
		AssignedOrderNo: "FO-KEEP-179",
		ExpectedUID:     "3780457044",
		ActualRoleName:  "德州火箭头",
		ActualRoleID:    "3780451044",
		ActualChannel:   "安卓-微信",
		MismatchAt:      &now,
		MismatchReason:  "预期UID(3780457044) 与 扫码UID(德州火箭头/3780451044) 不一致",
	}
	if err := db.Create(&token).Error; err != nil {
		t.Fatalf("create token: %v", err)
	}
	order := model.FulfillmentOrder{
		OrderNo:     "FO-KEEP-179",
		MerchantID:  2,
		ProductSKU:  model.RockSKUBlackTshirt,
		OrderStatus: "paid",
		ResultData:  `{"expected_uid":"3780457044","provider":"rock"}`,
	}
	if err := db.Create(&order).Error; err != nil {
		t.Fatalf("create order: %v", err)
	}

	rockSvc := NewRockService(db, NewRockClient("https://example.com"))
	kept, err := rockSvc.CorrectMismatchExpectedUID(context.Background(), token.ID, "1111111111")
	if err != nil {
		t.Fatalf("update unmatched uid: %v", err)
	}
	if kept.Status != model.RockStatusMismatch || kept.AssignedOrderNo != "FO-KEEP-179" || kept.ExpectedUID != "1111111111" {
		t.Fatalf("未对上扫码 UID 时应保持占用和阻断，实际 status=%s order=%s uid=%s", kept.Status, kept.AssignedOrderNo, kept.ExpectedUID)
	}

	bound, err := rockSvc.CorrectMismatchExpectedUID(context.Background(), token.ID, "3780451044")
	if err != nil {
		t.Fatalf("correct to scanned uid: %v", err)
	}
	if bound.Status != model.RockStatusBound || bound.AssignedOrderNo != "FO-KEEP-179" || bound.ExpectedUID != "3780451044" {
		t.Fatalf("改成扫码 UID 后应解除阻断并留在原订单，实际 status=%s order=%s uid=%s", bound.Status, bound.AssignedOrderNo, bound.ExpectedUID)
	}

	var savedOrder model.FulfillmentOrder
	if err := db.Where("order_no = ?", "FO-KEEP-179").First(&savedOrder).Error; err != nil {
		t.Fatalf("reload order: %v", err)
	}
	if !strings.Contains(savedOrder.ResultData, "3780451044") {
		t.Fatalf("订单期望 UID 应同步为扫码 UID，实际: %s", savedOrder.ResultData)
	}
}

func TestRockBindLinkStillFreshUsesURLTimestamp(t *testing.T) {
	now := time.Now()
	stale := fmt.Sprintf("https://gp.qq.com/cp/a20241128mobile/index.html?timestamp=%d", now.Add(-rockBindLinkMaxAge-time.Second).Unix())
	fresh := fmt.Sprintf("https://gp.qq.com/cp/a20241128mobile/index.html?timestamp=%d", now.Add(-time.Minute).Unix())
	if rockBindLinkStillFresh(rockBindLinkCacheItem{bindURL: stale, cachedAt: now}, now) {
		t.Fatal("签名已超过刷新点时，不能因为刚写入缓存就继续展示")
	}
	if !rockBindLinkStillFresh(rockBindLinkCacheItem{bindURL: fresh, cachedAt: now.Add(-time.Hour)}, now) {
		t.Fatal("签名仍在刷新点内就应该继续展示")
	}
}

func TestRockProvider_CheckBindRefreshesSameTokenLink(t *testing.T) {
	db := newRockTestDB(t)

	var mu sync.Mutex
	redeemHits := 0
	staleTS := time.Now().Add(-rockBindLinkMaxAge - time.Second).Unix()
	freshTS := time.Now().Unix()
	oldURL := fmt.Sprintf("https://gp.qq.com/cp/a20241128mobile/index.html?timestamp=%d&nonce=old&sign=old", staleTS)
	newURL := fmt.Sprintf("https://gp.qq.com/cp/a20241128mobile/index.html?timestamp=%d&nonce=new&sign=new", freshTS)
	currentURL := oldURL
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if strings.HasPrefix(r.URL.Path, "/api/redeem/") {
			mu.Lock()
			redeemHits++
			bindURL := currentURL
			mu.Unlock()
			_ = json.NewEncoder(w).Encode(RockRedeemDetailResponse{BindURL: bindURL})
			return
		}
		if strings.HasSuffix(r.URL.Path, "/refresh") {
			_ = json.NewEncoder(w).Encode(RockRefreshResponse{})
			return
		}
		w.WriteHeader(http.StatusNotFound)
	}))
	defer server.Close()

	client := NewRockClient(server.URL)
	rockSvc := NewRockService(db, client)
	provider := NewRockProvider(rockSvc)

	now := time.Now()
	token := model.RockToken{
		UpstreamTokenID: "177",
		Token:           "token-177",
		RedeemCode:      "7b7445735ab7432fdc9db997c7637913",
		Color:           model.RockColorBlack,
		Status:          model.RockStatusUsing,
		AssignedOrderNo: "FO20261006170653afd37ce7e19",
		ExpectedUID:     "3763064651",
		ClaimedAt:       &now,
	}
	if err := db.Create(&token).Error; err != nil {
		t.Fatalf("create token: %v", err)
	}
	order := &model.FulfillmentOrder{
		OrderNo:    token.AssignedOrderNo,
		ProductSKU: model.RockSKUBlackTshirt,
		ResultData: `{"expected_uid":"3763064651","provider":"rock"}`,
	}

	// 缓存刚写入，但链接上的签名时间已经超过刷新点，必须换新码。
	rockSvc.bindLinkCache.Store(token.ID, rockBindLinkCacheItem{
		bindURL:   oldURL,
		qrURL:     "https://example.test/old.png",
		cachedAt:  time.Now(),
		fetchedAt: time.Now().Add(-rockBindLinkRetryGap - time.Second),
	})
	mu.Lock()
	currentURL = newURL
	mu.Unlock()

	check, err := provider.CheckBind(context.Background(), order, fmt.Sprintf("%d", token.ID))
	if err != nil {
		t.Fatalf("check bind: %v", err)
	}
	if check.BindURL != currentURL {
		t.Fatalf("过期后应返回同一提取码的新链接，实际: %s", check.BindURL)
	}
	if check.BindUUID != fmt.Sprintf("%d", token.ID) || check.Bound || check.Mismatch {
		t.Fatalf("刷新二维码不能换号或改绑定状态: %+v", check)
	}

	var saved model.RockToken
	if err := db.First(&saved, token.ID).Error; err != nil {
		t.Fatalf("reload token: %v", err)
	}
	if saved.Status != model.RockStatusUsing || saved.AssignedOrderNo != token.AssignedOrderNo {
		t.Fatalf("必须留在原提货号，实际 status=%s order=%s", saved.Status, saved.AssignedOrderNo)
	}
	var tokenCount int64
	db.Model(&model.RockToken{}).Count(&tokenCount)
	if tokenCount != 1 {
		t.Fatalf("不能另发提货号，实际 %d 条", tokenCount)
	}

	mu.Lock()
	hitsAfterRefresh := redeemHits
	currentURL = "https://gp.qq.com/cp/should-not-fetch"
	mu.Unlock()
	checkCached, err := provider.CheckBind(context.Background(), order, fmt.Sprintf("%d", token.ID))
	if err != nil {
		t.Fatalf("cached check: %v", err)
	}
	if checkCached.BindURL != newURL {
		t.Fatalf("有效期内应复用刚取到的链接，实际: %s", checkCached.BindURL)
	}
	mu.Lock()
	if redeemHits != hitsAfterRefresh {
		t.Fatalf("有效期内不应再次请求 0666，实际多了 %d 次", redeemHits-hitsAfterRefresh)
	}
	mu.Unlock()

	other := &model.FulfillmentOrder{
		OrderNo:    "FO-OTHER",
		ProductSKU: model.RockSKUBlackTshirt,
		ResultData: `{"expected_uid":"3763064651"}`,
	}
	checkOther, err := provider.CheckBind(context.Background(), other, fmt.Sprintf("%d", token.ID))
	if err != nil {
		t.Fatalf("other order check: %v", err)
	}
	if checkOther.BindURL != "" {
		t.Fatalf("其他订单不能拿到这个提货号的二维码: %s", checkOther.BindURL)
	}
}

func TestRockService_TokenRemarkAndAbnormal(t *testing.T) {
	db := testdb.New(t)
	client := NewRockClient("https://0666.pro")
	rockSvc := NewRockService(db, client)

	now := time.Now()
	token := model.RockToken{
		UpstreamTokenID: "TEST_REMARK_1",
		Token:           "jwt-remark-1",
		RedeemCode:      "CODE_REMARK_1",
		Status:          model.RockStatusMismatch,
		AssignedOrderNo: "ORDER_REMARK_1",
		ExpectedUID:     "123456",
		ActualRoleID:    "654321",
		ActualRoleName:  "路人甲",
		MismatchAt:      &now,
		MismatchReason:  "预期UID不符",
	}
	if err := db.Create(&token).Error; err != nil {
		t.Fatalf("create test token failed: %v", err)
	}

	// 1. 测试单纯更新备注
	updated, err := rockSvc.UpdateTokenRemark(context.Background(), token.ID, "买家联系客服核对中", "")
	if err != nil {
		t.Fatalf("update remark failed: %v", err)
	}
	if updated.Remark != "买家联系客服核对中" || updated.Status != model.RockStatusMismatch {
		t.Fatalf("更新备注不符: remark=%s status=%s", updated.Remark, updated.Status)
	}

	// 2. 测试快捷标记为已上报失效 (MarkTokenAbnormal)
	abnormalToken, err := rockSvc.MarkTokenAbnormal(context.Background(), token.ID, "已上报0868客服 (卡密绑定错误废弃)")
	if err != nil {
		t.Fatalf("mark abnormal failed: %v", err)
	}
	if abnormalToken.Status != model.RockStatusAbnormal {
		t.Fatalf("标记异常后状态应为 abnormal，实际: %s", abnormalToken.Status)
	}
	if abnormalToken.Remark != "已上报0868客服 (卡密绑定错误废弃)" {
		t.Fatalf("标记异常后备注不符: %s", abnormalToken.Remark)
	}

	// 3. 搜索备注测试
	list, total, err := rockSvc.ListTokens(context.Background(), 1, 10, "", "卡密绑定错误废弃")
	if err != nil {
		t.Fatalf("list by remark search error: %v", err)
	}
	if total != 1 || len(list) != 1 || list[0].ID != token.ID {
		t.Fatalf("通过备注搜索未检索到目标 token, total=%d", total)
	}

	// 4. 从 abnormal 状态解冻重置回 available
	if err := rockSvc.ResetMismatchToken(context.Background(), token.ID); err != nil {
		t.Fatalf("reset abnormal token error: %v", err)
	}
	var resetToken model.RockToken
	if err := db.First(&resetToken, token.ID).Error; err != nil {
		t.Fatalf("find reset token error: %v", err)
	}
	if resetToken.Status != model.RockStatusAvailable {
		t.Fatalf("重置后应为 available，实际: %s", resetToken.Status)
	}
	if resetToken.AssignedOrderNo != "" || resetToken.ExpectedUID != "" {
		t.Fatalf("重置后应清空订单关联, assigned_order_no=%s", resetToken.AssignedOrderNo)
	}
}