package repository

import (
	"code.30cm.net/digimon/app-cloudep-wallet-service/pkg/domain/entity"
	"code.30cm.net/digimon/app-cloudep-wallet-service/pkg/domain/wallet"
	"context"
	"github.com/shopspring/decimal"
	"github.com/stretchr/testify/assert"
	"gorm.io/gorm"
	"testing"
)

func buildSchema(t *testing.T, db *gorm.DB) {
	// 先手動建表
	createTable := `
	CREATE TABLE IF NOT EXISTS wallet (
	  id         BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
	  brand      VARCHAR(50) NOT NULL,
	  uid        VARCHAR(64) NOT NULL,
	  asset      VARCHAR(32) NOT NULL,
	  balance    DECIMAL(30,18) NOT NULL DEFAULT 0,
	  type       TINYINT NOT NULL,
	  create_at  INTEGER NOT NULL DEFAULT 0,
	  update_at  INTEGER NOT NULL DEFAULT 0,
	  PRIMARY KEY (id),
	  UNIQUE KEY uq_brand_uid_asset_type (brand, uid, asset, type)
	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`
	assert.NoError(t, db.Exec(createTable).Error)
}

func TestUserWalletManager_InitWallets(t *testing.T) {
	_, db, teardown, err := SetupTestWalletRepository()
	assert.NoError(t, err)
	defer teardown()

	buildSchema(t, db)
	type args struct {
		uid   string
		asset string
		brand string
	}
	tests := []struct {
		name       string
		args       args
		wantCount  int
		wantErr    bool
		validateDB bool
	}{
		{
			name:      "正常初始化一次",
			args:      args{uid: "user1", asset: "BTC", brand: "brandA"},
			wantCount: len(wallet.AllTypes),
		},
		{
			name:       "再次初始化同一 UID/asset/brand，應因 UNIQUE KEY 失敗",
			args:       args{uid: "user1", asset: "BTC", brand: "brandA"},
			wantErr:    true,
			validateDB: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			service := NewUserWalletManager(db, tt.args.uid, tt.args.asset)
			ctx := context.Background()

			got, err := service.InitWallets(ctx, tt.args.brand)
			if tt.wantErr {
				assert.Error(t, err)
				return
			}
			assert.NoError(t, err)
			// 回傳 slice 長度應等於 AllTypes
			assert.Len(t, got, tt.wantCount)

			if tt.validateDB {
				// 再查一次 DB，確認確實寫入
				var dbRows []entity.Wallet
				err := db.WithContext(ctx).
					Where("uid = ? AND asset = ? AND brand = ?", tt.args.uid, tt.args.asset, tt.args.brand).
					Find(&dbRows).Error
				assert.NoError(t, err)
				assert.Len(t, dbRows, tt.wantCount)
				// 檢查每一筆都初始為零
				for _, w := range dbRows {
					assert.Equal(t, decimal.Zero, w.Balance)
				}
			}
		})
	}
}

//
//func TestUserWalletManager_FetchAllWallets(t *testing.T) {
//	_, db, teardown, err := SetupTestWalletRepository()
//	assert.NoError(t, err)
//	defer teardown()
//
//	// 建表
//	createTable := `
//	CREATE TABLE IF NOT EXISTS wallet (
//	  id         BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
//	  brand      VARCHAR(50) NOT NULL,
//	  uid        VARCHAR(64) NOT NULL,
//	  asset      VARCHAR(32) NOT NULL,
//	  balance    DECIMAL(30,18) NOT NULL DEFAULT 0,
//	  type       TINYINT NOT NULL,
//	  create_at  INTEGER NOT NULL DEFAULT 0,
//	  update_at  INTEGER NOT NULL DEFAULT 0,
//	  PRIMARY KEY (id),
//	  UNIQUE KEY uq_brand_uid_asset_type (brand, uid, asset, type)
//	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`
//	assert.NoError(t, db.Exec(createTable).Error)
//
//	type seedRow struct {
//		Brand   string
//		UID     string
//		Asset   string
//		Balance decimal.Decimal
//		Type    wallet.Types
//	}
//
//	type args struct {
//		uid   string
//		asset string
//		brand string
//	}
//	tests := []struct {
//		name      string
//		args      args
//		seed      []seedRow
//		wantCount int
//	}{
//		{
//			name:      "no data returns empty",
//			args:      args{"u1", "BTC", "b1"},
//			seed:      nil,
//			wantCount: 0,
//		},
//		{
//			name: "single user many types",
//			args: args{"u1", "BTC", "b1"},
//			seed: []seedRow{
//				{"b1", "u1", "BTC", decimal.NewFromInt(10), wallet.AllTypes[0]},
//				{"b1", "u1", "BTC", decimal.NewFromInt(20), wallet.AllTypes[1]},
//				{"b1", "u1", "BTC", decimal.NewFromInt(30), wallet.AllTypes[2]},
//			},
//			wantCount: 3,
//		},
//		{
//			name: "mixed users and assets",
//			args: args{"u2", "ETH", "b2"},
//			seed: []seedRow{
//				{"b1", "u1", "BTC", decimal.NewFromInt(10), wallet.AllTypes[0]},
//				{"b2", "u2", "ETH", decimal.NewFromInt(15), wallet.AllTypes[1]},
//				{"b2", "u2", "ETH", decimal.NewFromInt(25), wallet.AllTypes[2]},
//			},
//			wantCount: 2,
//		},
//	}
//
//	for _, tt := range tests {
//		t.Run(tt.name, func(t *testing.T) {
//			ctx := context.Background()
//			// 清空表
//			assert.NoError(t, db.Exec(`DELETE FROM wallet`).Error)
//
//			// 插入 seed
//			for _, row := range tt.seed {
//				err := db.WithContext(ctx).Exec(
//					`INSERT INTO wallet (brand, uid, asset, balance, type, create_at, update_at)
//					 VALUES (?, ?, ?, ?, ?, ?, ?)`,
//					row.Brand, row.UID, row.Asset, row.Balance, row.Type,
//					time.Now().Unix(), time.Now().Unix(),
//				).Error
//				assert.NoError(t, err)
//			}
//
//			// 建立 service
//			svc := NewWalletService(db, tt.args.uid, tt.args.asset)
//
//			// 呼叫 GetAllBalances
//			got, err := svc.GetAllBalances(ctx)
//			assert.NoError(t, err)
//			assert.Len(t, got, tt.wantCount)
//
//			// 檢查回傳資料與本地快取一致
//			ws := svc.(*WalletService)
//			for _, w := range got {
//				// 回傳的每筆都應該存在於 localBalances
//				cached, ok := ws.localBalances[w.Type]
//				assert.True(t, ok)
//				assert.Equal(t, w.Balance, cached.Balance)
//				assert.Equal(t, w.Asset, cached.Asset)
//				assert.Equal(t, w.Type, cached.Type)
//			}
//		})
//	}
//}
//
//func TestUserWalletManager_GetBalancesForTypes(t *testing.T) {
//	_, db, teardown, err := SetupTestWalletRepository()
//	assert.NoError(t, err)
//	defer teardown()
//
//	// 建表
//	createTable := `
//	CREATE TABLE IF NOT EXISTS wallet (
//	  id         BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
//	  brand      VARCHAR(50) NOT NULL,
//	  uid        VARCHAR(64) NOT NULL,
//	  asset      VARCHAR(32) NOT NULL,
//	  balance    DECIMAL(30,18) NOT NULL DEFAULT 0,
//	  type       TINYINT NOT NULL,
//	  create_at  INTEGER NOT NULL DEFAULT 0,
//	  update_at  INTEGER NOT NULL DEFAULT 0,
//	  PRIMARY KEY (id),
//	  UNIQUE KEY uq_brand_uid_asset_type (brand, uid, asset, type)
//	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`
//	assert.NoError(t, db.Exec(createTable).Error)
//
//	type seedRow struct {
//		Brand   string
//		UID     string
//		Asset   string
//		Balance decimal.Decimal
//		Type    wallet.Types
//	}
//
//	tests := []struct {
//		name      string
//		uid       string
//		asset     string
//		brand     string
//		seed      []seedRow
//		kinds     []wallet.Types
//		wantCount int
//	}{
//		{
//			name: "no matching types returns empty",
//			uid:  "user1", asset: "BTC", brand: "b1",
//			seed: []seedRow{
//				{"b1", "user1", "BTC", decimal.NewFromInt(5), wallet.AllTypes[0]},
//			},
//			kinds:     []wallet.Types{wallet.AllTypes[1]},
//			wantCount: 0,
//		},
//		{
//			name: "single type match",
//			uid:  "user1", asset: "BTC", brand: "b1",
//			seed: []seedRow{
//				{"b1", "user1", "BTC", decimal.NewFromInt(5), wallet.AllTypes[0]},
//				{"b1", "user1", "BTC", decimal.NewFromInt(7), wallet.AllTypes[1]},
//			},
//			kinds:     []wallet.Types{wallet.AllTypes[1]},
//			wantCount: 1,
//		},
//		{
//			name: "multiple type matches",
//			uid:  "user2", asset: "ETH", brand: "b2",
//			seed: []seedRow{
//				{"b2", "user2", "ETH", decimal.NewFromInt(3), wallet.AllTypes[0]},
//				{"b2", "user2", "ETH", decimal.NewFromInt(8), wallet.AllTypes[2]},
//				{"b2", "user2", "ETH", decimal.NewFromInt(10), wallet.AllTypes[1]},
//			},
//			kinds:     []wallet.Types{wallet.AllTypes[0], wallet.AllTypes[2]},
//			wantCount: 2,
//		},
//	}
//
//	for _, tt := range tests {
//		t.Run(tt.name, func(t *testing.T) {
//			ctx := context.Background()
//			// 清表
//			assert.NoError(t, db.Exec(`DELETE FROM wallet`).Error)
//
//			// 插入種子資料
//			for _, r := range tt.seed {
//				assert.NoError(t, db.Exec(
//					`INSERT INTO wallet (brand, uid, asset, balance, type, create_at, update_at)
//					 VALUES (?, ?, ?, ?, ?, ?, ?)`,
//					r.Brand, r.UID, r.Asset, r.Balance, r.Type,
//					time.Now().Unix(), time.Now().Unix(),
//				).Error)
//			}
//
//			// 建立 service
//			svc := NewWalletService(db, tt.uid, tt.asset)
//
//			// 呼叫 GetBalancesForTypes
//			got, err := svc.GetBalancesForTypes(ctx, tt.kinds)
//			assert.NoError(t, err)
//			assert.Len(t, got, tt.wantCount)
//
//			// 檢查每筆結果皆正確緩存
//			ws := svc.(*WalletService)
//			for _, w := range got {
//				cached, ok := ws.localBalances[w.Type]
//				assert.True(t, ok)
//				assert.Equal(t, w.Balance, cached.Balance)
//				assert.Equal(t, w.Asset, cached.Asset)
//			}
//		})
//	}
//}
//
//func TestForUpdateLockBehavior(t *testing.T) {
//	// 建立測試環境
//	_, db, teardown, err := SetupTestWalletRepository()
//	assert.NoError(t, err)
//	defer teardown()
//
//	// 建表
//	createTable := `
//	CREATE TABLE IF NOT EXISTS wallet (
//	  id         BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
//	  brand      VARCHAR(50) NOT NULL,
//	  uid        VARCHAR(64) NOT NULL,
//	  asset      VARCHAR(32) NOT NULL,
//	  balance    DECIMAL(30,18) NOT NULL DEFAULT 0,
//	  type       TINYINT NOT NULL,
//	  create_at  INTEGER NOT NULL DEFAULT 0,
//	  update_at  INTEGER NOT NULL DEFAULT 0,
//	  PRIMARY KEY (id),
//	  UNIQUE KEY uq_brand_uid_asset_type (brand, uid, asset, type)
//	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`
//	assert.NoError(t, db.Exec(createTable).Error)
//
//	// 種子資料：一筆 wallet
//	ctx := context.Background()
//	initial := entity.Wallet{
//		Brand:   "b1",
//		UID:     "user1",
//		Asset:   "BTC",
//		Balance: decimal.NewFromInt(100),
//		Type:    wallet.AllTypes[0],
//	}
//	err = db.WithContext(ctx).Create(&initial).Error
//	assert.NoError(t, err)
//
//	// 讀回自動產生的 ID
//	var seeded entity.Wallet
//	assert.NoError(t, db.Where("uid = ? AND asset = ?", initial.UID, initial.Asset).
//		First(&seeded).Error)
//
//	// 開啟第一個 transaction 並 SELECT … FOR UPDATE
//	tx1 := db.Begin()
//	var locked entity.Wallet
//	err = tx1.Clauses(clause.Locking{Strength: "UPDATE"}).
//		WithContext(ctx).
//		Where("id = ?", seeded.ID).
//		Take(&locked).Error
//	assert.NoError(t, err)
//
//	// 啟動 goroutine 嘗試在第二 transaction 更新該 row
//	done := make(chan error, 1)
//	go func() {
//		tx2 := db.Begin()
//		// 試圖更新，被 FOR UPDATE 鎖住前應該會 block
//		err := tx2.WithContext(ctx).
//			Model(&entity.Wallet{}).
//			Where("id = ?", seeded.ID).
//			Update("balance", seeded.Balance.Add(decimal.NewFromInt(50))).Error
//		done <- err
//	}()
//
//	// 等 100ms 確認尚未完成
//	time.Sleep(100 * time.Millisecond)
//	select {
//	case err2 := <-done:
//		t.Fatalf("expected update to be blocked, but completed with err=%v", err2)
//	default:
//		// 正在等待鎖
//	}
//
//	// 釋放鎖
//	assert.NoError(t, tx1.Commit().Error)
//
//	// 現在第二 transaction 應該很快完成
//	select {
//	case err2 := <-done:
//		assert.NoError(t, err2)
//	case <-time.After(500 * time.Millisecond):
//		t.Fatal("update did not complete after lock released")
//	}
//}
//
//func TestWalletService_IncreaseBalance(t *testing.T) {
//	uid := "user1"
//	asset := "BTC"
//
//	type testCase struct {
//		name        string
//		kind        wallet.Types
//		initial     *entity.Wallet // nil 表示不存在
//		orderID     string
//		amount      decimal.Decimal
//		wantErr     error
//		wantBalance decimal.Decimal
//		wantTxCount int
//	}
//	tests := []testCase{
//		{
//			name:        "missing wallet type",
//			kind:        wallet.AllTypes[0],
//			initial:     nil,
//			orderID:     "ord1",
//			amount:      decimal.NewFromInt(10),
//			wantErr:     repository.ErrRecordNotFound,
//			wantBalance: decimal.Zero,
//			wantTxCount: 0,
//		},
//		{
//			name:        "increase from zero",
//			kind:        wallet.AllTypes[1],
//			initial:     &entity.Wallet{Balance: decimal.Zero},
//			orderID:     "ord2",
//			amount:      decimal.NewFromInt(15),
//			wantErr:     nil,
//			wantBalance: decimal.NewFromInt(15),
//			wantTxCount: 1,
//		},
//		{
//			name:        "successful increment on non-zero",
//			kind:        wallet.AllTypes[2],
//			initial:     &entity.Wallet{Balance: decimal.NewFromInt(5)},
//			orderID:     "ord3",
//			amount:      decimal.NewFromInt(7),
//			wantErr:     nil,
//			wantBalance: decimal.NewFromInt(12),
//			wantTxCount: 1,
//		},
//		{
//			name:        "insufficient leads to error",
//			kind:        wallet.AllTypes[2],
//			initial:     &entity.Wallet{Balance: decimal.NewFromInt(3)},
//			orderID:     "ord4",
//			amount:      decimal.NewFromInt(-5),
//			wantErr:     repository.ErrBalanceInsufficient,
//			wantBalance: decimal.NewFromInt(3),
//			wantTxCount: 0,
//		},
//	}
//
//	for _, tc := range tests {
//		t.Run(tc.name, func(t *testing.T) {
//			// 準備 WalletService
//			svc := NewWalletService(nil, uid, asset).(*WalletService)
//			// 初始化本地快取
//			if tc.initial != nil {
//				svc.localBalances = map[wallet.Types]entity.Wallet{tc.kind: *tc.initial}
//			} else {
//				svc.localBalances = map[wallet.Types]entity.Wallet{}
//			}
//			// 清空交易紀錄
//			svc.transactions = nil
//
//			// 執行
//			err := svc.IncreaseBalance(tc.kind, tc.orderID, tc.amount)
//
//			// 驗證錯誤
//			if tc.wantErr != nil {
//				assert.ErrorIs(t, err, tc.wantErr)
//			} else {
//				assert.NoError(t, err)
//			}
//
//			// 驗證快取餘額
//			gotBal := svc.CurrentBalance(tc.kind)
//			assert.True(t, gotBal.Equal(tc.wantBalance), "balance = %s, want %s", gotBal, tc.wantBalance)
//
//			// 驗證交易筆數
//			assert.Len(t, svc.transactions, tc.wantTxCount)
//			if tc.wantTxCount > 0 {
//				tx := svc.transactions[0]
//				assert.Equal(t, tc.orderID, tx.OrderID)
//				assert.Equal(t, uid, tx.UID)
//				assert.Equal(t, asset, tx.Asset)
//				assert.True(t, tx.Amount.Equal(tc.amount))
//				assert.True(t, tx.Balance.Equal(tc.wantBalance))
//			}
//		})
//	}
//}
//
//func TestWalletService_PrepareTransactions(t *testing.T) {
//	const (
//		txID       = int64(42)
//		orderID    = "order-123"
//		brand      = "brandX"
//		bizNameStr = "business-test"
//	)
//	biz := wallet.BusinessName(bizNameStr)
//
//	tests := []struct {
//		name       string
//		initialTxs []entity.WalletTransaction
//		wantCount  int
//	}{
//		{
//			name:       "no transactions returns empty slice",
//			initialTxs: nil,
//			wantCount:  0,
//		},
//		{
//			name: "single transaction is populated",
//			initialTxs: []entity.WalletTransaction{
//				{
//					OrderID:    "placeholder",
//					UID:        "u1",
//					WalletType: wallet.AllTypes[0],
//					Asset:      "BTC",
//					Amount:     decimal.NewFromInt(5),
//					Balance:    decimal.NewFromInt(10),
//				},
//			},
//			wantCount: 1,
//		},
//		{
//			name: "multiple transactions are all populated",
//			initialTxs: []entity.WalletTransaction{
//				{UID: "u1", WalletType: wallet.AllTypes[1], Asset: "ETH", Amount: decimal.NewFromInt(1), Balance: decimal.NewFromInt(1)},
//				{UID: "u2", WalletType: wallet.AllTypes[2], Asset: "TWD", Amount: decimal.NewFromInt(2), Balance: decimal.NewFromInt(2)},
//				{UID: "u3", WalletType: wallet.AllTypes[3%len(wallet.AllTypes)], Asset: "USD", Amount: decimal.NewFromInt(3), Balance: decimal.NewFromInt(3)},
//			},
//			wantCount: 3,
//		},
//	}
//
//	for _, tc := range tests {
//		t.Run(tc.name, func(t *testing.T) {
//			// 建立 WalletService 並注入初始交易
//			svc := &WalletService{
//				transactions: make([]entity.WalletTransaction, len(tc.initialTxs)),
//			}
//			copy(svc.transactions, tc.initialTxs)
//
//			// 執行 PrepareTransactions
//			result := svc.PrepareTransactions(txID, orderID, brand, biz)
//
//			// 檢查回傳長度
//			assert.Len(t, result, tc.wantCount)
//			assert.Len(t, svc.transactions, tc.wantCount)
//
//			// 驗證每筆交易的共用欄位是否正確
//			for i := 0; i < tc.wantCount; i++ {
//				tx := result[i]
//				assert.Equal(t, txID, tx.TransactionID, "tx[%d].TransactionID", i)
//				assert.Equal(t, orderID, tx.OrderID, "tx[%d].OrderID", i)
//				assert.Equal(t, brand, tx.Brand, "tx[%d].Brand", i)
//				assert.Equal(t, biz.ToInt8(), tx.BusinessType, "tx[%d].BusinessType", i)
//				// 原有欄位保持不變
//				assert.Equal(t, tc.initialTxs[i].UID, tx.UID, "tx[%d].UID unchanged", i)
//				assert.Equal(t, tc.initialTxs[i].WalletType, tx.WalletType, "tx[%d].WalletType unchanged", i)
//				assert.Equal(t, tc.initialTxs[i].Asset, tx.Asset, "tx[%d].Asset unchanged", i)
//				assert.True(t, tx.Amount.Equal(tc.initialTxs[i].Amount), "tx[%d].Amount unchanged", i)
//				assert.True(t, tx.Balance.Equal(tc.initialTxs[i].Balance), "tx[%d].Balance unchanged", i)
//			}
//		})
//	}
//}
//
//func TestWalletService_PersistBalances(t *testing.T) {
//	_, db, teardown, err := SetupTestWalletRepository()
//	assert.NoError(t, err)
//	defer teardown()
//
//	// helper：删除表、重建表、插入两笔 seed 数据，返回这两笔带 ID 的 slice
//	seedWallets := func() []entity.Wallet {
//		// DROP + AutoMigrate
//		assert.NoError(t, db.Migrator().DropTable(&entity.Wallet{}))
//		assert.NoError(t, db.AutoMigrate(&entity.Wallet{}))
//
//		base := []entity.Wallet{
//			{UID: "u1", Asset: "BTC", Brand: "b", Balance: decimal.NewFromInt(10), Type: wallet.AllTypes[0]},
//			{UID: "u1", Asset: "BTC", Brand: "b", Balance: decimal.NewFromInt(20), Type: wallet.AllTypes[1]},
//		}
//		assert.NoError(t, db.Create(&base).Error)
//		return base
//	}
//
//	type fields struct {
//		updates map[wallet.Types]decimal.Decimal
//	}
//	type want struct {
//		final []decimal.Decimal
//		err   bool
//	}
//
//	tests := []struct {
//		name   string
//		fields fields
//		want   want
//	}{
//		{
//			name:   "no local balances → no change",
//			fields: fields{updates: map[wallet.Types]decimal.Decimal{}},
//			want: want{
//				final: []decimal.Decimal{decimal.NewFromInt(10), decimal.NewFromInt(20)},
//				err:   false,
//			},
//		},
//		{
//			name: "update both balances",
//			fields: fields{updates: map[wallet.Types]decimal.Decimal{
//				wallet.AllTypes[0]: decimal.NewFromInt(15),
//				wallet.AllTypes[1]: decimal.NewFromInt(5),
//			}},
//			want: want{
//				final: []decimal.Decimal{decimal.NewFromInt(15), decimal.NewFromInt(5)},
//				err:   false,
//			},
//		},
//	}
//
//	for _, tc := range tests {
//		t.Run(tc.name, func(t *testing.T) {
//			// seed 并拿到带 ID 的记录
//			seed := seedWallets()
//
//			// 构造 localBalances：只有 Type 在 updates 里的才覆盖
//			localMap := make(map[wallet.Types]entity.Wallet, len(tc.fields.updates))
//			for _, w := range seed {
//				if nb, ok := tc.fields.updates[w.Type]; ok {
//					localMap[w.Type] = entity.Wallet{
//						ID:      w.ID,
//						Balance: nb,
//					}
//				}
//			}
//
//			// 初始化 service 并注入 localBalances
//			svc := NewWalletService(db, "u1", "BTC").(*WalletService)
//			svc.localBalances = localMap
//
//			// 执行 PersistBalances
//			err := svc.PersistBalances(context.Background())
//			if tc.want.err {
//				assert.Error(t, err)
//				return
//			}
//			assert.NoError(t, err)
//
//			// 重新查 DB，按 ID 顺序比较余额
//			var got []entity.Wallet
//			assert.NoError(t, db.
//				Where("uid = ?", "u1").
//				Order("id").
//				Find(&got).Error)
//
//			assert.Len(t, got, len(seed))
//			for i, w := range got {
//				assert.Truef(t,
//					w.Balance.Equal(tc.want.final[i]),
//					"第 %d 条记录 (id=%d) 余额 = %s, 期望 %s",
//					i, w.ID, w.Balance, tc.want.final[i],
//				)
//			}
//		})
//	}
//}
//
//func TestWalletService_PersistOrderBalances(t *testing.T) {
//	_, db, teardown, err := SetupTestWalletRepository()
//	assert.NoError(t, err)
//	defer teardown()
//
//	// helper：重建 transaction 表並 seed 資料
//	seedTransactions := func() []entity.Transaction {
//		// DROP + AutoMigrate
//		_ = db.Migrator().DropTable(&entity.Transaction{})
//		assert.NoError(t, db.AutoMigrate(&entity.Transaction{}))
//
//		// 插入兩筆 transaction
//		base := []entity.Transaction{
//			{PostTransferBalance: decimal.NewFromInt(100)},
//			{PostTransferBalance: decimal.NewFromInt(200)},
//		}
//		assert.NoError(t, db.Create(&base).Error)
//		return base
//	}
//
//	type fields struct {
//		updates map[int64]decimal.Decimal
//	}
//	type want struct {
//		final []decimal.Decimal
//		err   bool
//	}
//
//	tests := []struct {
//		name   string
//		fields fields
//		want   want
//	}{
//		{
//			name:   "no local order balances → no change",
//			fields: fields{updates: map[int64]decimal.Decimal{}},
//			want: want{
//				final: []decimal.Decimal{decimal.NewFromInt(100), decimal.NewFromInt(200)},
//				err:   false,
//			},
//		},
//		{
//			name: "update first order balance only",
//			fields: fields{updates: map[int64]decimal.Decimal{
//				1: decimal.NewFromInt(150),
//			}},
//			want: want{
//				final: []decimal.Decimal{decimal.NewFromInt(150), decimal.NewFromInt(200)},
//				err:   false,
//			},
//		},
//		{
//			name: "update both order balances",
//			fields: fields{updates: map[int64]decimal.Decimal{
//				1: decimal.NewFromInt(110),
//				2: decimal.NewFromInt(220),
//			}},
//			want: want{
//				final: []decimal.Decimal{decimal.NewFromInt(110), decimal.NewFromInt(220)},
//				err:   false,
//			},
//		},
//	}
//
//	for _, tc := range tests {
//		t.Run(tc.name, func(t *testing.T) {
//			// seed 資料並拿回 slice（包含自動產生的 ID）
//			seed := seedTransactions()
//
//			// 建構 localOrderBalances：key 是 seed[i].ID
//			localMap := make(map[int64]decimal.Decimal, len(tc.fields.updates))
//			for id, newBal := range tc.fields.updates {
//				localMap[id] = newBal
//			}
//
//			// 初始化 service、注入 localOrderBalances
//			svc := NewWalletService(db, "u1", "BTC").(*WalletService)
//			svc.localOrderBalances = localMap
//
//			// 執行 PersistOrderBalances
//			err := svc.PersistOrderBalances(context.Background())
//			if tc.want.err {
//				assert.Error(t, err)
//				return
//			}
//			assert.NoError(t, err)
//
//			// 依照 seed 的 ID 順序讀回資料庫
//			var got []entity.Transaction
//			assert.NoError(t, db.
//				Where("1 = 1").
//				Order("id").
//				Find(&got).Error)
//			// 長度要和 seed 相同
//			assert.Len(t, got, len(seed))
//			// 比對每一筆 balance
//			for i, tr := range got {
//				assert.Truef(t,
//					tr.PostTransferBalance.Equal(tc.want.final[i]),
//					"第 %d 筆交易(id=%d) balance = %s, want %s",
//					i, tr.ID, tr.PostTransferBalance, tc.want.final[i],
//				)
//			}
//		})
//	}
//}
//
//func TestWalletService_HasAvailableBalance(t *testing.T) {
//	_, db, teardown, err := SetupTestWalletRepository()
//	assert.NoError(t, err)
//	defer teardown()
//
//	// 建表
//	createTable := `
//	CREATE TABLE IF NOT EXISTS wallet (
//	  id         BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
//	  brand      VARCHAR(50) NOT NULL,
//	  uid        VARCHAR(64) NOT NULL,
//	  asset      VARCHAR(32) NOT NULL,
//	  balance    DECIMAL(30,18) NOT NULL DEFAULT 0,
//	  type       TINYINT NOT NULL,
//	  create_at  INTEGER NOT NULL DEFAULT 0,
//	  update_at  INTEGER NOT NULL DEFAULT 0,
//	  PRIMARY KEY (id),
//	  UNIQUE KEY uq_brand_uid_asset_type (brand, uid, asset, type)
//	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`
//	assert.NoError(t, db.Exec(createTable).Error)
//
//	type seedRow struct {
//		Brand   string
//		UID     string
//		Asset   string
//		Type    wallet.Types
//		Balance decimal.Decimal
//	}
//
//	tests := []struct {
//		name      string
//		uid       string
//		asset     string
//		seed      []seedRow
//		wantExist bool
//	}{
//		{
//			name:      "無任何紀錄",
//			uid:       "user1",
//			asset:     "BTC",
//			seed:      nil,
//			wantExist: false,
//		},
//		{
//			name:  "只有其他類型錢包",
//			uid:   "user1",
//			asset: "BTC",
//			seed: []seedRow{
//				{"", "user1", "BTC", wallet.TypeFreeze, decimal.Zero},
//				{"", "user1", "BTC", wallet.TypeUnconfirmed, decimal.Zero},
//			},
//			wantExist: false,
//		},
//		{
//			name:  "已有可用錢包",
//			uid:   "user1",
//			asset: "BTC",
//			seed: []seedRow{
//				{"", "user1", "BTC", wallet.TypeAvailable, decimal.NewFromInt(10)},
//			},
//			wantExist: true,
//		},
//		{
//			name:  "不同 UID 不算",
//			uid:   "user2",
//			asset: "BTC",
//			seed: []seedRow{
//				{"", "user1", "BTC", wallet.TypeAvailable, decimal.NewFromInt(5)},
//			},
//			wantExist: false,
//		},
//		{
//			name:  "不同 Asset 不算",
//			uid:   "user1",
//			asset: "ETH",
//			seed: []seedRow{
//				{"", "user1", "BTC", wallet.TypeAvailable, decimal.NewFromInt(5)},
//			},
//			wantExist: false,
//		},
//	}
//
//	for _, tc := range tests {
//		t.Run(tc.name, func(t *testing.T) {
//			// 每個子測試前都清空 wallet table
//			assert.NoError(t, db.Exec("DELETE FROM wallet").Error)
//
//			// seed 資料到 wallet
//			for _, r := range tc.seed {
//				w := entity.Wallet{
//					Brand:   r.Brand,
//					UID:     r.UID,
//					Asset:   r.Asset,
//					Type:    r.Type,
//					Balance: r.Balance,
//				}
//				assert.NoError(t, db.Create(&w).Error)
//			}
//
//			// 建 service
//			svc := NewWalletService(db, tc.uid, tc.asset).(*WalletService)
//			got, err := svc.HasAvailableBalance(context.Background())
//			assert.NoError(t, err)
//			assert.Equal(t, tc.wantExist, got)
//		})
//	}
//}
//
//
//
//func TestWalletService_GetBalancesForUpdate(t *testing.T) {
//	db, tearDown := SetupTestDB(t)
//	defer tearDown()
//
//	type seedRow struct {
//		Brand   string
//		UID     string
//		Asset   string
//		Type    wallet.Types
//		Balance decimal.Decimal
//	}
//
//	tests := []struct {
//		name      string
//		uid       string
//		asset     string
//		seed      []seedRow
//		kinds     []wallet.Types
//		wantIDs   []int64
//		expectErr bool
//	}{
//		{
//			name:      "查詢空結果",
//			uid:       "u1",
//			asset:     "BTC",
//			seed:      nil,
//			kinds:     []wallet.Types{wallet.TypeAvailable},
//			wantIDs:   nil,
//			expectErr: false,
//		},
//		{
//			name:  "單一類型查詢",
//			uid:   "u1",
//			asset: "BTC",
//			seed: []seedRow{
//				{"", "u1", "BTC", wallet.TypeAvailable, decimal.NewFromInt(5)},
//				{"", "u1", "BTC", wallet.TypeFreeze, decimal.NewFromInt(2)},
//			},
//			kinds:     []wallet.Types{wallet.TypeFreeze},
//			wantIDs:   []int64{2},
//			expectErr: false,
//		},
//		{
//			name:  "多類型查詢",
//			uid:   "u1",
//			asset: "BTC",
//			seed: []seedRow{
//				{"", "u1", "BTC", wallet.TypeAvailable, decimal.NewFromInt(5)},
//				{"", "u1", "BTC", wallet.TypeFreeze, decimal.NewFromInt(2)},
//				{"", "u1", "BTC", wallet.TypeUnconfirmed, decimal.NewFromInt(3)},
//			},
//			kinds:     []wallet.Types{wallet.TypeAvailable, wallet.TypeUnconfirmed},
//			wantIDs:   []int64{3, 5},
//			expectErr: false,
//		},
//		{
//			name:  "不同 UID 不列入",
//			uid:   "u2",
//			asset: "BTC",
//			seed: []seedRow{
//				{"", "u1", "BTC", wallet.TypeAvailable, decimal.NewFromInt(5)},
//			},
//			kinds:     []wallet.Types{wallet.TypeAvailable},
//			wantIDs:   nil,
//			expectErr: false,
//		},
//		{
//			name:  "不同 Asset 不列入",
//			uid:   "u1",
//			asset: "ETH",
//			seed: []seedRow{
//				{"", "u1", "BTC", wallet.TypeAvailable, decimal.NewFromInt(5)},
//			},
//			kinds:     []wallet.Types{wallet.TypeAvailable},
//			wantIDs:   nil,
//			expectErr: false,
//		},
//	}
//
//	for _, tc := range tests {
//		t.Run(tc.name, func(t *testing.T) {
//			// 清空資料
//			assert.NoError(t, db.Exec("DELETE FROM wallet").Error)
//			// Seed
//			for _, r := range tc.seed {
//				w := entity.Wallet{
//					Brand:   r.Brand,
//					UID:     r.UID,
//					Asset:   r.Asset,
//					Type:    r.Type,
//					Balance: r.Balance,
//				}
//				// Create will auto-assign incremental IDs
//				assert.NoError(t, db.Create(&w).Error)
//			}
//
//			// 建 Service
//			svc := NewWalletService(db, tc.uid, tc.asset).(*WalletService)
//			got, err := svc.GetBalancesForUpdate(context.Background(), tc.kinds)
//			if tc.expectErr {
//				assert.Error(t, err)
//				return
//			}
//			assert.NoError(t, err)
//
//			// 取回 IDs 並排序
//			var gotIDs []int64
//			for _, w := range got {
//				gotIDs = append(gotIDs, w.ID)
//				// localBalances 應該被更新
//				assert.Equal(t, w, svc.localBalances[w.Type])
//			}
//			assert.Equal(t, tc.wantIDs, gotIDs)
//		})
//	}
//}
//
//func TestWalletService_GetOrderBalance(t *testing.T) {
//	_, db, tearDown, err := SetupTestWalletRepository()
//	assert.NoError(t, err)
//	defer tearDown()
//
//	// create transaction table
//	create := `
//	CREATE TABLE IF NOT EXISTS transaction (
//	  id BIGINT AUTO_INCREMENT PRIMARY KEY,
//	  order_id VARCHAR(64),
//	  transaction_id VARCHAR(64),
//	  brand VARCHAR(32),
//	  uid VARCHAR(64),
//	  to_uid VARCHAR(64),
//	  type TINYINT,
//	  business_type TINYINT,
//	  asset VARCHAR(32),
//	  amount    DECIMAL(30,18),
//	  before_balance DECIMAL(30,18),
//	  post_transfer_balance DECIMAL(30,18),
//	  status TINYINT,
//	  create_at BIGINT,
//	  due_time BIGINT
//	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`
//	assert.NoError(t, db.Exec(create).Error)
//
//	// seed a row
//	now := time.Now().Unix()
//	seed := `
//	INSERT INTO transaction
//	  (order_id, transaction_id, brand, uid, to_uid,
//	   type, business_type, asset, amount,
//	   before_balance, post_transfer_balance,
//	   status, create_at, due_time)
//	VALUES
//	  (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
//	_, err = db.Exec(seed,
//		"order1", "tx-uuid-1", "brandA", "user1", "user2",
//		1, 2, "BTC", "42.5",
//		"10.0", "52.5",
//		1, now, now+3600,
//	).RowsAffected, db.Error
//	assert.NoError(t, err)
//
//	svc := NewWalletService(db, "user1", "BTC")
//
//	type want struct {
//		tx      entity.Transaction
//		errIsNF bool
//	}
//
//	tests := []struct {
//		name    string
//		orderID string
//		want    want
//	}{
//		{
//			name:    "found existing transaction",
//			orderID: "order1",
//			want: want{
//				tx: entity.Transaction{
//					ID:                  1,
//					OrderID:             "order1",
//					TransactionID:       "tx-uuid-1",
//					Brand:               "brandA",
//					UID:                 "user1",
//					ToUID:               "user2",
//					TxType:              wallet.TxType(1),
//					BusinessType:        int8(2),
//					Asset:               "BTC",
//					Amount:              decimal.RequireFromString("42.5"),
//					BeforeBalance:       decimal.RequireFromString("10.0"),
//					PostTransferBalance: decimal.RequireFromString("52.5"),
//					Status:              wallet.Enable(1),
//					CreateAt:            now,
//					DueTime:             now + 3600,
//				},
//				errIsNF: false,
//			},
//		},
//		{
//			name:    "not found returns ErrRecordNotFound",
//			orderID: "order2",
//			want:    want{errIsNF: true},
//		},
//	}
//
//	for _, tt := range tests {
//		t.Run(tt.name, func(t *testing.T) {
//			got, err := svc.GetOrderBalance(context.Background(), tt.orderID)
//			if tt.want.errIsNF {
//				assert.Error(t, err)
//				assert.True(t, errors.Is(err, repository.ErrRecordNotFound))
//			} else {
//				assert.NoError(t, err)
//				// compare all fields except those auto‐set by GORM (e.g. pointers)
//				assert.Equal(t, tt.want.tx.ID, got.ID)
//				assert.Equal(t, tt.want.tx.OrderID, got.OrderID)
//				assert.Equal(t, tt.want.tx.TransactionID, got.TransactionID)
//				assert.Equal(t, tt.want.tx.Brand, got.Brand)
//				assert.Equal(t, tt.want.tx.UID, got.UID)
//				assert.Equal(t, tt.want.tx.ToUID, got.ToUID)
//				assert.Equal(t, tt.want.tx.TxType, got.TxType)
//				assert.Equal(t, tt.want.tx.BusinessType, got.BusinessType)
//				assert.Equal(t, tt.want.tx.Asset, got.Asset)
//				assert.True(t, tt.want.tx.Amount.Equal(got.Amount))
//				assert.True(t, tt.want.tx.BeforeBalance.Equal(got.BeforeBalance))
//				assert.True(t, tt.want.tx.PostTransferBalance.Equal(got.PostTransferBalance))
//				assert.Equal(t, tt.want.tx.Status, got.Status)
//				assert.Equal(t, tt.want.tx.CreateAt, got.CreateAt)
//				assert.Equal(t, tt.want.tx.DueTime, got.DueTime)
//			}
//		})
//	}
//}
//
//func TestWalletService_GetOrderBalanceForUpdate(t *testing.T) {
//	// setup container + DB + repo
//	_, db, tearDown, err := SetupTestWalletRepository()
//	assert.NoError(t, err)
//	defer tearDown()
//
//	// create transaction table
//	create := `
//	CREATE TABLE IF NOT EXISTS transaction (
//	  id BIGINT AUTO_INCREMENT PRIMARY KEY,
//	  order_id VARCHAR(64),
//	  transaction_id VARCHAR(64),
//	  brand VARCHAR(32),
//	  uid VARCHAR(64),
//	  to_uid VARCHAR(64),
//	  type TINYINT,
//	  business_type TINYINT,
//	  asset VARCHAR(32),
//	  amount DECIMAL(30,18),
//	  before_balance DECIMAL(30,18),
//	  post_transfer_balance DECIMAL(30,18),
//	  status TINYINT,
//	  create_at BIGINT,
//	  due_time BIGINT
//	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`
//	assert.NoError(t, db.Exec(create).Error)
//
//	// seed one row
//	now := time.Now().Unix()
//	_, err = db.Exec(
//		`INSERT INTO transaction
//		  (order_id, transaction_id, brand, uid, to_uid, type, business_type, asset,
//		   amount, before_balance, post_transfer_balance, status, create_at, due_time)
//		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
//		"ordX", "tx-XYZ", "brandZ", "u1", "u2",
//		1, 2, "ETH",
//		"100.0", "50.0", "150.0",
//		1, now, now+600,
//	).RowsAffected, db.Error
//	assert.NoError(t, err)
//
//	// service under test
//	svc := NewWalletService(db, "u1", "ETH")
//
//	type want struct {
//		tx      entity.Transaction
//		errIsNF bool
//	}
//
//	cases := []struct {
//		name    string
//		orderID string
//		want    want
//	}{
//		{
//			name:    "found and locks",
//			orderID: "ordX",
//			want: want{
//				tx: entity.Transaction{
//					ID:                  1,
//					OrderID:             "ordX",
//					TransactionID:       "tx-XYZ",
//					Brand:               "brandZ",
//					UID:                 "u1",
//					ToUID:               "u2",
//					TxType:              wallet.TxType(1),
//					BusinessType:        int8(2),
//					Asset:               "ETH",
//					Amount:              decimal.RequireFromString("100.0"),
//					BeforeBalance:       decimal.RequireFromString("50.0"),
//					PostTransferBalance: decimal.RequireFromString("150.0"),
//					Status:              wallet.Enable(1),
//					CreateAt:            now,
//					DueTime:             now + 600,
//				},
//				errIsNF: false,
//			},
//		},
//		{
//			name:    "missing row returns ErrRecordNotFound",
//			orderID: "ordY",
//			want:    want{errIsNF: true},
//		},
//	}
//
//	for _, tt := range cases {
//		t.Run(tt.name, func(t *testing.T) {
//			got, err := svc.GetOrderBalanceForUpdate(context.Background(), tt.orderID)
//			if tt.want.errIsNF {
//				assert.Error(t, err)
//				return
//			}
//			assert.NoError(t, err)
//
//			// verify all fields
//			expected := tt.want.tx
//			assert.Equal(t, expected.ID, got.ID)
//			assert.Equal(t, expected.OrderID, got.OrderID)
//			assert.Equal(t, expected.TransactionID, got.TransactionID)
//			assert.Equal(t, expected.Brand, got.Brand)
//			assert.Equal(t, expected.UID, got.UID)
//			assert.Equal(t, expected.ToUID, got.ToUID)
//			assert.Equal(t, expected.TxType, got.TxType)
//			assert.Equal(t, expected.BusinessType, got.BusinessType)
//			assert.Equal(t, expected.Asset, got.Asset)
//			assert.True(t, expected.Amount.Equal(got.Amount))
//			assert.True(t, expected.BeforeBalance.Equal(got.BeforeBalance))
//			assert.True(t, expected.PostTransferBalance.Equal(got.PostTransferBalance))
//			assert.Equal(t, expected.Status, got.Status)
//			assert.Equal(t, expected.CreateAt, got.CreateAt)
//			assert.Equal(t, expected.DueTime, got.DueTime)
//
//			// verify local cache was set
//			cached, ok := svc.(*WalletService).localOrderBalances[got.ID]
//			assert.True(t, ok, "expected localOrderBalances to contain key")
//			assert.True(t, expected.PostTransferBalance.Equal(cached))
//		})
//	}
//}