package binancex

import (
	"testing"

	"me.thuanle/bbot/internal/data"
	"me.thuanle/bbot/internal/data/market"
)

type resolverMarketStub struct {
	spotPairs    map[string]bool
	futuresPairs map[string]bool
}

func (m *resolverMarketStub) GetFuturePrice(symbol string) (float64, float64, int64, bool) {
	return 0, 0, 0, false
}
func (m *resolverMarketStub) GetAllPremiumIndex() (map[string]market.PremiumIndex, error) {
	return nil, nil
}
func (m *resolverMarketStub) GetAllFundRate() (map[string]float64, map[string]int64) { return nil, nil }
func (m *resolverMarketStub) GetSpotPrice(symbol string) (float64, bool)              { return 0, false }
func (m *resolverMarketStub) GetMarginInterestRates() map[string]float64              { return nil }
func (m *resolverMarketStub) IsAlphaToken(symbol string) bool                          { return false }
func (m *resolverMarketStub) GetAlphaToken(symbol string) (market.AlphaTokenInfo, bool) {
	return market.AlphaTokenInfo{}, false
}
func (m *resolverMarketStub) GetAlphaPrice(symbol string) (float64, bool) { return 0, false }
func (m *resolverMarketStub) IsSpotPair(symbol string) bool                { return m.spotPairs[symbol] }
func (m *resolverMarketStub) IsFuturesPair(symbol string) bool { return m.futuresPairs[symbol] }
func (m *resolverMarketStub) RefreshTradingPairCache() error   { return nil }

func TestToken2FutureSymbols_ResolvesPrefixAndSuffix(t *testing.T) {
	orig := data.Market
	defer func() { data.Market = orig }()

	data.Market = &resolverMarketStub{
		futuresPairs: map[string]bool{
			"1000PEPEUSDT": true,
			"1000PEPEUSDC": true,
		},
	}

	syms := Token2FutureSymbols("pepe")
	if len(syms) == 0 {
		t.Fatalf("expected future symbols for PEPE")
	}

	foundUSDT := false
	foundUSDC := false
	for _, sym := range syms {
		if sym == "1000PEPEUSDT" {
			foundUSDT = true
		}
		if sym == "1000PEPEUSDC" {
			foundUSDC = true
		}
	}

	if !foundUSDT || !foundUSDC {
		t.Fatalf("expected both 1000PEPEUSDT and 1000PEPEUSDC, got %+v", syms)
	}
}

func TestToken2SpotSymbols_AppliesExplicitRemap(t *testing.T) {
	orig := data.Market
	defer func() { data.Market = orig }()

	data.Market = &resolverMarketStub{
		futuresPairs: map[string]bool{"LUNA2USDT": true},
		spotPairs:    map[string]bool{"LUNAUSDT": true},
	}

	spots := Token2SpotSymbols("luna2")
	if len(spots) != 1 || spots[0] != "LUNAUSDT" {
		t.Fatalf("expected [LUNAUSDT], got %+v", spots)
	}
}

func TestToken2SpotSymbols_SpotOnlyFallback(t *testing.T) {
	orig := data.Market
	defer func() { data.Market = orig }()

	data.Market = &resolverMarketStub{
		spotPairs: map[string]bool{"ABCUSDT": true},
	}

	spots := Token2SpotSymbols("abc")
	if len(spots) != 1 || spots[0] != "ABCUSDT" {
		t.Fatalf("expected [ABCUSDT], got %+v", spots)
	}
}