package tokenpool

import (
	"context"
	"fmt"
	"time"

	"github.com/ethereum/go-ethereum/common"
	lru "github.com/hashicorp/golang-lru/v2"
	"github.com/synapsecns/sanguine/core/retry"
	"github.com/synapsecns/sanguine/services/explorer/consumer/fetcher"
	"github.com/synapsecns/sanguine/services/explorer/db"
)

// Service provides data about tokens using either a cache or bridgeconfig
// cache keys sare always ${KEY_NAME}_CHAIN_ID_ADDRESS so unless a token changes tokenID's
// (not the other way around), data is guaranteed to be accurate.
type Service interface {
	// GetTokenAddress attempts to get token data from the cache otherwise its fetched from the bridge config
	GetTokenAddress(ctx context.Context, chainID uint32, tokenIndex uint8, contractAddress string) (*common.Address, error)
}

const cacheSize = 3000

// maxAttemptTime is how many times we will attempt to get the token data.
const maxAttemptTime = time.Second * 120
const maxAttempt = 60

type tokenPoolDataServiceImpl struct {
	consumerDB db.ConsumerDB
	// tokenCache is the tokenCache of the tokenDataServices
	poolTokenCache *lru.TwoQueueCache[string, common.Address]
	// fetcher is the fetcher used to fetch data from the bridge config contract
	service fetcher.SwapService
}

// NewPoolTokenDataService creates a new token data service.
func NewPoolTokenDataService(service fetcher.SwapService, consumerDB db.ConsumerDB) (Service, error) {
	cache, err := lru.New2Q[string, common.Address](cacheSize)
	if err != nil {
		return nil, fmt.Errorf("could not create token data cache: %w", err)
	}

	return &tokenPoolDataServiceImpl{
		consumerDB:     consumerDB,
		poolTokenCache: cache,
		service:        service,
	}, nil
}

func (t *tokenPoolDataServiceImpl) GetTokenAddress(parentCtx context.Context, chainID uint32, tokenIndex uint8, contractAddress string) (*common.Address, error) {
	key := fmt.Sprintf("token_%d_%d", chainID, tokenIndex)
	if data, ok := t.poolTokenCache.Get(key); ok {
		return &data, nil
	}
	var tokenAddress *common.Address
	ctx, cancel := context.WithTimeout(parentCtx, maxAttemptTime)
	defer cancel()

	//nolint: wrapcheck
	err := retry.WithBackoff(ctx, func(ctx context.Context) error {
		var err error
		tokenAddress, err = t.service.GetTokenAddress(ctx, tokenIndex)
		if err != nil {
			return fmt.Errorf("could not get token data for index %d on chain %d: %w", chainID, tokenIndex, err)
		}
		return nil
	})
	if err != nil {
		return nil, fmt.Errorf("could not get token data with retry backoff chainID %d, tokenIndex %d, contractAddress %s: %w", chainID, tokenIndex, contractAddress, err)
	}

	//nolint: wrapcheck
	err = retry.WithBackoff(ctx, func(ctx context.Context) error {
		return t.storeTokenIndex(ctx, chainID, tokenIndex, tokenAddress, contractAddress)
	}, retry.WithMaxAttemptTime(maxAttemptTime), retry.WithMaxAttempts(maxAttempt))
	if err != nil {
		return nil, fmt.Errorf("could not store token index: %w", err)
	}
	t.poolTokenCache.Add(key, *tokenAddress)

	return tokenAddress, nil
}

func (t *tokenPoolDataServiceImpl) storeTokenIndex(parentCtx context.Context, chainID uint32, tokenIndex uint8, tokenAddress *common.Address, contractAddress string) error {
	err := t.consumerDB.StoreTokenIndex(parentCtx, chainID, tokenIndex, tokenAddress.String(), contractAddress)
	if err != nil {
		return fmt.Errorf("could not store token index: %w", err)
	}
	return nil
}