package repository

import (
	"blockchain/internal/config"
	"blockchain/internal/domain/repository"
	"context"
	"fmt"
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"

	miniredis "github.com/alicebob/miniredis/v2"
	"github.com/zeromicro/go-zero/core/stores/redis"
)

func setupMiniRedis() (*miniredis.Miniredis, *redis.Redis) {
	// 啟動 setupMiniRedis 作為模擬的 Redis 服務
	mr, err := miniredis.Run()
	if err != nil {
		panic("failed to start miniRedis: " + err.Error())
	}

	// 使用 setupMiniRedis 的地址配置 go-zero Redis 客戶端
	redisConf := redis.RedisConf{
		Host: mr.Addr(),
		Type: "node",
	}
	r := redis.MustNewRedis(redisConf)

	return mr, r
}

func TestGetSymbolsFromSource_TableDriven(t *testing.T) {
	mr, rdb := setupMiniRedis()
	defer mr.Close()

	cases := []struct {
		name        string
		wantSymbols []string
		expectErr   bool
	}{
		{
			name: "ok",
			//wantSymbols: []string{"BTCUSDT", "ETHUSDT"},
			expectErr: false,
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			repo := MustBinanceRepository(BinanceRepositoryParam{
				Conf: &config.Binance{
					Key:      "",
					Secret:   "",
					TestMode: true,
				},
				Redis: rdb,
			})

			var wg sync.WaitGroup
			total := 10

			for range total {
				wg.Add(1)
				go func() {
					defer wg.Done()
					symbols, err := repo.GetSymbols(context.Background())
					fmt.Println(symbols)
					if err != nil {
						return
					}
				}()
			}
			wg.Wait()
			//got, err := repo.GetSymbolsFromSource(context.Background())
			//if tc.expectErr {
			//	assert.Error(t, err)
			//	assert.Nil(t, got)
			//} else {
			//	assert.NoError(t, err)
			//	assert.Equal(t, tc.wantSymbols, got)
			//}
		})
	}
}

func TestSymbol(t *testing.T) {
	mr, rdb := setupMiniRedis()
	defer mr.Close()

	repo := MustBinanceRepository(BinanceRepositoryParam{
		Conf: &config.Binance{
			Key:      "",
			Secret:   "",
			TestMode: true,
		},
		Redis: rdb,
	})

	k, err := repo.FetchHistoryKline(context.Background(), repository.QueryKline{
		Symbol:        "BTCUSDT",
		Interval:      "1m",
		StartUnixNano: time.Date(2025, 8, 3, 0, 0, 0, 0, time.UTC).UnixNano(),
		EndUnixNano:   time.Date(2025, 8, 4, 0, 0, 0, 0, time.UTC).UnixNano(),
	})
	assert.NoError(t, err)
	for _, item := range k {
		fmt.Println(*item)
	}
}