package customer_binding

import (
	"context"
	"fmt"
	"testing"

	"gorm.io/gorm"

	"github.com/break/junhong_cmp_fiber/internal/model"
)

// ---- 测试工具 ----

// bindKey 构建 mock 中使用的查找键
func bindKey(customerID uint, key string) string {
	return fmt.Sprintf("%d:%s", customerID, key)
}

// ---- mock 实现 ----

type mockCardReader struct {
	cards map[uint]*model.IotCard
}

func (m *mockCardReader) GetByID(_ context.Context, id uint) (*model.IotCard, error) {
	if c, ok := m.cards[id]; ok {
		return c, nil
	}
	return nil, gorm.ErrRecordNotFound
}

type mockDeviceReader struct {
	devices map[uint]*model.Device
}

func (m *mockDeviceReader) GetByID(_ context.Context, id uint) (*model.Device, error) {
	if d, ok := m.devices[id]; ok {
		return d, nil
	}
	return nil, gorm.ErrRecordNotFound
}

// mockPCDOps 模拟 tb_personal_customer_device 操作
type mockPCDOps struct {
	// bindings["customerID:virtualNo"] = true 表示有效（status=1）绑定
	bindings   map[string]bool
	created    []*model.PersonalCustomerDevice
	counts     map[string]int64              // virtualNo → count（用于首绑判断）
	allRecords []*model.PersonalCustomerDevice // GetByDeviceNo 和 UpdateStatus/UpdateVirtualNo 使用
}

func (m *mockPCDOps) ExistsByCustomerAndDevice(_ context.Context, customerID uint, deviceNo string) (bool, error) {
	return m.bindings[bindKey(customerID, deviceNo)], nil
}

func (m *mockPCDOps) Create(_ context.Context, record *model.PersonalCustomerDevice) error {
	m.created = append(m.created, record)
	return nil
}

func (m *mockPCDOps) CountByVirtualNo(_ context.Context, virtualNo string) (int64, error) {
	if m.counts != nil {
		return m.counts[virtualNo], nil
	}
	return 0, nil
}

func (m *mockPCDOps) GetByDeviceNo(_ context.Context, deviceNo string) ([]*model.PersonalCustomerDevice, error) {
	var result []*model.PersonalCustomerDevice
	for _, r := range m.allRecords {
		if r.VirtualNo == deviceNo {
			result = append(result, r)
		}
	}
	return result, nil
}

func (m *mockPCDOps) UpdateStatus(_ context.Context, id uint, status int) error {
	for _, r := range m.allRecords {
		if r.ID == id {
			r.Status = status
			return nil
		}
	}
	return nil
}

func (m *mockPCDOps) UpdateVirtualNo(_ context.Context, id uint, newVirtualNo string) error {
	for _, r := range m.allRecords {
		if r.ID == id {
			r.VirtualNo = newVirtualNo
			return nil
		}
	}
	return nil
}

// mockPCIOps 模拟 tb_personal_customer_iccid 操作
type mockPCIOps struct {
	bindings   map[string]bool
	created    []*model.PersonalCustomerICCID
	counts     map[string]int64              // iccid → count
	allRecords []*model.PersonalCustomerICCID // GetByICCID 和 UpdateStatus 使用
}

func (m *mockPCIOps) ExistsByCustomerAndICCID(_ context.Context, customerID uint, iccid string) (bool, error) {
	return m.bindings[bindKey(customerID, iccid)], nil
}

func (m *mockPCIOps) Create(_ context.Context, record *model.PersonalCustomerICCID) error {
	m.created = append(m.created, record)
	return nil
}

func (m *mockPCIOps) CountByICCID(_ context.Context, iccid string) (int64, error) {
	if m.counts != nil {
		return m.counts[iccid], nil
	}
	return 0, nil
}

func (m *mockPCIOps) GetByICCID(_ context.Context, iccid string) ([]*model.PersonalCustomerICCID, error) {
	var result []*model.PersonalCustomerICCID
	for _, r := range m.allRecords {
		if r.ICCID == iccid {
			result = append(result, r)
		}
	}
	return result, nil
}

func (m *mockPCIOps) UpdateStatus(_ context.Context, id uint, status int) error {
	for _, r := range m.allRecords {
		if r.ID == id {
			r.Status = status
			return nil
		}
	}
	return nil
}

// ---- 测试 Service 构造器 ----

// soldCalls 记录 markAsSold 调用
type soldCalls struct {
	items []string
}

func (s *soldCalls) mark(_ context.Context, _ *gorm.DB, assetType string, _ uint) error {
	s.items = append(s.items, assetType)
	return nil
}

func newTestService(cards cardReader, devices deviceReader, pcd pcdOps, pci pciOps) (*Service, *soldCalls) {
	sold := &soldCalls{}
	return &Service{
		cards:   cards,
		devices: devices,
		readCard: func(ctx context.Context, _ *gorm.DB, id uint) (*model.IotCard, error) {
			return cards.GetByID(ctx, id)
		},
		readDevice: func(ctx context.Context, _ *gorm.DB, id uint) (*model.Device, error) {
			return devices.GetByID(ctx, id)
		},
		makePCD:    func(_ *gorm.DB) pcdOps { return pcd },
		makePCI:    func(_ *gorm.DB) pciOps { return pci },
		markAsSold: sold.mark,
	}, sold
}

// ---- OwnsAsset 测试 ----

// 验证：有虚拟号卡 + 客户有有效绑定 → true（tracer bullet）
func TestOwnsAsset_有虚拟号卡_有效绑定_返回true(t *testing.T) {
	card := &model.IotCard{VirtualNo: "VN001"}
	card.ID = 1

	pcd := &mockPCDOps{
		bindings: map[string]bool{bindKey(10, "VN001"): true},
	}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{1: card}},
		&mockDeviceReader{},
		pcd,
		&mockPCIOps{},
	)

	owned, err := svc.OwnsAsset(context.Background(), 10, "iot_card", 1)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if !owned {
		t.Fatal("期望返回 true，实际返回 false")
	}
}

// 验证：有虚拟号卡 + status=0 的绑定 → false（修复安全缺口）
func TestOwnsAsset_有虚拟号卡_禁用绑定_返回false(t *testing.T) {
	card := &model.IotCard{VirtualNo: "VN002"}
	card.ID = 2

	pcd := &mockPCDOps{
		// status=0 的绑定：在 ExistsByCustomerAndDevice 中会过滤掉（bindings 中不存在）
		bindings: map[string]bool{},
	}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{2: card}},
		&mockDeviceReader{},
		pcd,
		&mockPCIOps{},
	)

	owned, err := svc.OwnsAsset(context.Background(), 10, "iot_card", 2)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if owned {
		t.Fatal("期望返回 false（status=0），实际返回 true")
	}
}

// 验证：有虚拟号卡 + 无绑定 → false
func TestOwnsAsset_有虚拟号卡_无绑定_返回false(t *testing.T) {
	card := &model.IotCard{VirtualNo: "VN003"}
	card.ID = 3

	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{3: card}},
		&mockDeviceReader{},
		&mockPCDOps{bindings: map[string]bool{}},
		&mockPCIOps{},
	)

	owned, err := svc.OwnsAsset(context.Background(), 10, "iot_card", 3)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if owned {
		t.Fatal("期望返回 false（无绑定），实际返回 true")
	}
}

// 验证：assetType="card"（来自 assetService.Resolve）等价于 "iot_card"
func TestOwnsAsset_assetType_card_等价iot_card(t *testing.T) {
	card := &model.IotCard{VirtualNo: "VN_CARD"}
	card.ID = 9

	pcd := &mockPCDOps{
		bindings: map[string]bool{bindKey(10, "VN_CARD"): true},
	}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{9: card}},
		&mockDeviceReader{},
		pcd,
		&mockPCIOps{},
	)

	owned, err := svc.OwnsAsset(context.Background(), 10, "card", 9)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if !owned {
		t.Fatal("期望 card 类型等价 iot_card 返回 true，实际 false")
	}
}

// 验证：设备资产 + 有效绑定 → true
func TestOwnsAsset_设备_有效绑定_返回true(t *testing.T) {
	device := &model.Device{VirtualNo: "DEV001"}
	device.ID = 5

	pcd := &mockPCDOps{
		bindings: map[string]bool{bindKey(10, "DEV001"): true},
	}
	svc, _ := newTestService(
		&mockCardReader{},
		&mockDeviceReader{devices: map[uint]*model.Device{5: device}},
		pcd,
		&mockPCIOps{},
	)

	owned, err := svc.OwnsAsset(context.Background(), 10, "device", 5)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if !owned {
		t.Fatal("期望返回 true，实际返回 false")
	}
}

// ---- Bind 测试 ----

// 验证：首次绑定有虚拟号卡 → 写入 pcd 记录 + 触发 markAssetAsSold
func TestBind_有虚拟号卡_首次绑定_创建记录并标记已售(t *testing.T) {
	card := &model.IotCard{VirtualNo: "VN010"}
	card.ID = 10

	pcd := &mockPCDOps{
		bindings: map[string]bool{},
		counts:   map[string]int64{"VN010": 0}, // 首次绑定
	}
	svc, sold := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{10: card}},
		&mockDeviceReader{},
		pcd,
		&mockPCIOps{},
	)

	err := svc.Bind(context.Background(), nil, 20, "iot_card", 10)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if len(pcd.created) != 1 {
		t.Fatalf("期望创建 1 条 pcd 记录，实际: %d", len(pcd.created))
	}
	if pcd.created[0].VirtualNo != "VN010" {
		t.Errorf("期望 VirtualNo=VN010，实际: %s", pcd.created[0].VirtualNo)
	}
	if pcd.created[0].CustomerID != 20 {
		t.Errorf("期望 CustomerID=20，实际: %d", pcd.created[0].CustomerID)
	}
	if len(sold.items) != 1 || sold.items[0] != "iot_card" {
		t.Errorf("期望触发 markAssetAsSold(iot_card)，实际: %v", sold.items)
	}
}

// 验证：重复绑定 → 不创建新记录
func TestBind_有虚拟号卡_已有绑定_不重复创建(t *testing.T) {
	card := &model.IotCard{VirtualNo: "VN011"}
	card.ID = 11

	pcd := &mockPCDOps{
		bindings: map[string]bool{bindKey(20, "VN011"): true},
		counts:   map[string]int64{"VN011": 1},
	}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{11: card}},
		&mockDeviceReader{},
		pcd,
		&mockPCIOps{},
	)

	err := svc.Bind(context.Background(), nil, 20, "iot_card", 11)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if len(pcd.created) != 0 {
		t.Fatalf("期望不创建新记录，实际创建了 %d 条", len(pcd.created))
	}
}

// 验证：非首次绑定（已有其他客户绑定）→ 创建记录但不触发 markAssetAsSold
func TestBind_有虚拟号卡_非首次绑定_创建记录不标记已售(t *testing.T) {
	card := &model.IotCard{VirtualNo: "VN012"}
	card.ID = 12

	pcd := &mockPCDOps{
		bindings: map[string]bool{},
		counts:   map[string]int64{"VN012": 1}, // 已有其他绑定
	}
	svc, sold := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{12: card}},
		&mockDeviceReader{},
		pcd,
		&mockPCIOps{},
	)

	err := svc.Bind(context.Background(), nil, 30, "iot_card", 12)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if len(pcd.created) != 1 {
		t.Fatalf("期望创建 1 条记录，实际: %d", len(pcd.created))
	}
	if len(sold.items) != 0 {
		t.Errorf("期望不触发 markAssetAsSold，实际触发了: %v", sold.items)
	}
}

// ---- Issue 02: 无虚拟号卡 pci 路径测试 ----

// 验证：无虚拟号卡 + 客户有有效 PCI 绑定 → true
func TestOwnsAsset_无虚拟号卡_有效PCI绑定_返回true(t *testing.T) {
	card := &model.IotCard{ICCID: "89860000000000000001"} // VirtualNo 为空
	card.ID = 20

	pci := &mockPCIOps{
		bindings: map[string]bool{bindKey(10, "89860000000000000001"): true},
	}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{20: card}},
		&mockDeviceReader{},
		&mockPCDOps{bindings: map[string]bool{}},
		pci,
	)

	owned, err := svc.OwnsAsset(context.Background(), 10, "iot_card", 20)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if !owned {
		t.Fatal("期望返回 true，实际返回 false")
	}
}

// 验证：无虚拟号卡 + 无 PCI 绑定 → false
func TestOwnsAsset_无虚拟号卡_无PCI绑定_返回false(t *testing.T) {
	card := &model.IotCard{ICCID: "89860000000000000002"} // VirtualNo 为空
	card.ID = 21

	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{21: card}},
		&mockDeviceReader{},
		&mockPCDOps{bindings: map[string]bool{}},
		&mockPCIOps{bindings: map[string]bool{}},
	)

	owned, err := svc.OwnsAsset(context.Background(), 10, "iot_card", 21)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if owned {
		t.Fatal("期望返回 false（无 PCI 绑定），实际返回 true")
	}
}

// 验证：无虚拟号卡首次绑定 → 写入 pci 记录 + 触发 markAssetAsSold
func TestBind_无虚拟号卡_首次绑定_创建PCI记录并标记已售(t *testing.T) {
	card := &model.IotCard{ICCID: "89860000000000000010"} // VirtualNo 为空
	card.ID = 30

	pci := &mockPCIOps{
		bindings: map[string]bool{},
		counts:   map[string]int64{"89860000000000000010": 0}, // 首次绑定
	}
	svc, sold := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{30: card}},
		&mockDeviceReader{},
		&mockPCDOps{bindings: map[string]bool{}},
		pci,
	)

	err := svc.Bind(context.Background(), nil, 50, "iot_card", 30)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if len(pci.created) != 1 {
		t.Fatalf("期望创建 1 条 pci 记录，实际: %d", len(pci.created))
	}
	if pci.created[0].ICCID != "89860000000000000010" {
		t.Errorf("期望 ICCID=89860000000000000010，实际: %s", pci.created[0].ICCID)
	}
	if pci.created[0].CustomerID != 50 {
		t.Errorf("期望 CustomerID=50，实际: %d", pci.created[0].CustomerID)
	}
	if len(sold.items) != 1 || sold.items[0] != "iot_card" {
		t.Errorf("期望触发 markAssetAsSold(iot_card)，实际: %v", sold.items)
	}
}

// 验证：无虚拟号卡已有绑定 → 不重复创建
func TestBind_无虚拟号卡_已有绑定_不重复创建(t *testing.T) {
	card := &model.IotCard{ICCID: "89860000000000000011"} // VirtualNo 为空
	card.ID = 31

	pci := &mockPCIOps{
		bindings: map[string]bool{bindKey(50, "89860000000000000011"): true},
		counts:   map[string]int64{"89860000000000000011": 1},
	}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{31: card}},
		&mockDeviceReader{},
		&mockPCDOps{bindings: map[string]bool{}},
		pci,
	)

	err := svc.Bind(context.Background(), nil, 50, "iot_card", 31)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if len(pci.created) != 0 {
		t.Fatalf("期望不创建新记录，实际创建了 %d 条", len(pci.created))
	}
}

// ---- Issue 03: Migrate 迁移测试 ----

// newMockPCDRecord 构建一条带 ID 的 pcd 记录（用于迁移测试）
func newMockPCDRecord(id, customerID uint, virtualNo string, status int) *model.PersonalCustomerDevice {
	r := &model.PersonalCustomerDevice{
		CustomerID: customerID,
		VirtualNo:  virtualNo,
		Status:     status,
	}
	r.ID = id
	return r
}

// newMockPCIRecord 构建一条带 ID 的 pci 记录（用于迁移测试）
func newMockPCIRecord(id, customerID uint, iccid string, status int) *model.PersonalCustomerICCID {
	r := &model.PersonalCustomerICCID{
		CustomerID: customerID,
		ICCID:      iccid,
		Status:     status,
	}
	r.ID = id
	return r
}

// 验证：旧卡有虚拟号 + pcd 有绑定 + 新卡有虚拟号 → pcd.virtual_no 更新为新卡虚拟号
func TestMigrate_有虚拟号旧卡_有绑定_换有虚拟号新卡_更新VirtualNo(t *testing.T) {
	oldCard := &model.IotCard{VirtualNo: "OLD_VN"}
	oldCard.ID = 100
	newCard := &model.IotCard{VirtualNo: "NEW_VN"}
	newCard.ID = 101

	existing := newMockPCDRecord(1, 50, "OLD_VN", 1)
	pcd := &mockPCDOps{
		bindings:   map[string]bool{},
		allRecords: []*model.PersonalCustomerDevice{existing},
	}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{100: oldCard, 101: newCard}},
		&mockDeviceReader{},
		pcd,
		&mockPCIOps{},
	)

	err := svc.Migrate(context.Background(), nil, "iot_card", 100, "iot_card", 101)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if existing.VirtualNo != "NEW_VN" {
		t.Errorf("期望 VirtualNo 更新为 NEW_VN，实际: %s", existing.VirtualNo)
	}
}

// 验证：旧卡有虚拟号 + pcd 有绑定 + 新卡无虚拟号 → 旧 pcd status=0，新 pci 创建
func TestMigrate_有虚拟号旧卡_有绑定_换无虚拟号新卡_迁移到PCI(t *testing.T) {
	oldCard := &model.IotCard{VirtualNo: "OLD_VN2"}
	oldCard.ID = 110
	newCard := &model.IotCard{ICCID: "89860000000000000099"} // 无虚拟号
	newCard.ID = 111

	existing := newMockPCDRecord(2, 60, "OLD_VN2", 1)
	pcd := &mockPCDOps{
		allRecords: []*model.PersonalCustomerDevice{existing},
	}
	pci := &mockPCIOps{}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{110: oldCard, 111: newCard}},
		&mockDeviceReader{},
		pcd,
		pci,
	)

	err := svc.Migrate(context.Background(), nil, "iot_card", 110, "iot_card", 111)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if existing.Status != 0 {
		t.Errorf("期望旧 pcd 记录 status=0，实际: %d", existing.Status)
	}
	if len(pci.created) != 1 {
		t.Fatalf("期望创建 1 条 pci 记录，实际: %d", len(pci.created))
	}
	if pci.created[0].CustomerID != 60 {
		t.Errorf("期望 pci CustomerID=60，实际: %d", pci.created[0].CustomerID)
	}
	if pci.created[0].ICCID != "89860000000000000099" {
		t.Errorf("期望 pci ICCID=89860000000000000099，实际: %s", pci.created[0].ICCID)
	}
}

// 验证：旧卡有虚拟号 + pcd 无绑定 + 新卡无虚拟号 → 跳过，无写入
func TestMigrate_有虚拟号旧卡_无绑定_换无虚拟号新卡_跳过(t *testing.T) {
	oldCard := &model.IotCard{VirtualNo: "OLD_VN3"}
	oldCard.ID = 120
	newCard := &model.IotCard{ICCID: "89860000000000000088"} // 无虚拟号
	newCard.ID = 121

	pcd := &mockPCDOps{allRecords: []*model.PersonalCustomerDevice{}} // 空
	pci := &mockPCIOps{}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{120: oldCard, 121: newCard}},
		&mockDeviceReader{},
		pcd,
		pci,
	)

	err := svc.Migrate(context.Background(), nil, "iot_card", 120, "iot_card", 121)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if len(pci.created) != 0 {
		t.Fatalf("期望无写入，实际创建了 %d 条 pci 记录", len(pci.created))
	}
}

// 验证：旧卡无虚拟号 + pci 有绑定 + 新卡有虚拟号 → 旧 pci status=0，新 pcd 创建
func TestMigrate_无虚拟号旧卡_有绑定_换有虚拟号新卡_迁移到PCD(t *testing.T) {
	oldCard := &model.IotCard{ICCID: "89860000000000000077"} // 无虚拟号
	oldCard.ID = 130
	newCard := &model.IotCard{VirtualNo: "NEW_VN3"}
	newCard.ID = 131

	existingPCI := newMockPCIRecord(3, 70, "89860000000000000077", 1)
	pci := &mockPCIOps{allRecords: []*model.PersonalCustomerICCID{existingPCI}}
	pcd := &mockPCDOps{}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{130: oldCard, 131: newCard}},
		&mockDeviceReader{},
		pcd,
		pci,
	)

	err := svc.Migrate(context.Background(), nil, "iot_card", 130, "iot_card", 131)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if existingPCI.Status != 0 {
		t.Errorf("期望旧 pci 记录 status=0，实际: %d", existingPCI.Status)
	}
	if len(pcd.created) != 1 {
		t.Fatalf("期望创建 1 条 pcd 记录，实际: %d", len(pcd.created))
	}
	if pcd.created[0].CustomerID != 70 {
		t.Errorf("期望 pcd CustomerID=70，实际: %d", pcd.created[0].CustomerID)
	}
	if pcd.created[0].VirtualNo != "NEW_VN3" {
		t.Errorf("期望 pcd VirtualNo=NEW_VN3，实际: %s", pcd.created[0].VirtualNo)
	}
}

// 验证：旧卡无虚拟号 + pci 有绑定 + 新卡也无虚拟号 → 旧 pci status=0，新 pci 创建新 ICCID
func TestMigrate_无虚拟号旧卡_有绑定_换无虚拟号新卡_迁移PCI(t *testing.T) {
	oldCard := &model.IotCard{ICCID: "89860000000000000066"} // 无虚拟号
	oldCard.ID = 140
	newCard := &model.IotCard{ICCID: "89860000000000000055"} // 无虚拟号
	newCard.ID = 141

	existingPCI := newMockPCIRecord(4, 80, "89860000000000000066", 1)
	pci := &mockPCIOps{allRecords: []*model.PersonalCustomerICCID{existingPCI}}
	pcd := &mockPCDOps{}
	svc, _ := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{140: oldCard, 141: newCard}},
		&mockDeviceReader{},
		pcd,
		pci,
	)

	err := svc.Migrate(context.Background(), nil, "iot_card", 140, "iot_card", 141)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if existingPCI.Status != 0 {
		t.Errorf("期望旧 pci 记录 status=0，实际: %d", existingPCI.Status)
	}
	if len(pci.created) != 1 {
		t.Fatalf("期望创建 1 条新 pci 记录，实际: %d", len(pci.created))
	}
	if pci.created[0].CustomerID != 80 {
		t.Errorf("期望 pci CustomerID=80，实际: %d", pci.created[0].CustomerID)
	}
	if pci.created[0].ICCID != "89860000000000000055" {
		t.Errorf("期望 pci ICCID=89860000000000000055，实际: %s", pci.created[0].ICCID)
	}
}

// 验证：无虚拟号卡非首次绑定（已有其他客户）→ 创建记录但不触发 markAssetAsSold
func TestBind_无虚拟号卡_非首次绑定_创建记录不标记已售(t *testing.T) {
	card := &model.IotCard{ICCID: "89860000000000000012"} // VirtualNo 为空
	card.ID = 32

	pci := &mockPCIOps{
		bindings: map[string]bool{},
		counts:   map[string]int64{"89860000000000000012": 1}, // 已有其他客户绑定
	}
	svc, sold := newTestService(
		&mockCardReader{cards: map[uint]*model.IotCard{32: card}},
		&mockDeviceReader{},
		&mockPCDOps{bindings: map[string]bool{}},
		pci,
	)

	err := svc.Bind(context.Background(), nil, 60, "iot_card", 32)

	if err != nil {
		t.Fatalf("期望无错误，实际: %v", err)
	}
	if len(pci.created) != 1 {
		t.Fatalf("期望创建 1 条记录，实际: %d", len(pci.created))
	}
	if len(sold.items) != 0 {
		t.Errorf("期望不触发 markAssetAsSold，实际触发了: %v", sold.items)
	}
}