package testutil

import (
	"context"
	"fmt"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/stretchr/testify/assert"
	"math/big"
	"reflect"
	"testing"
)

// MustAdjustAmount multiplies a token by the number of decimals in the amount.
// see AdjustAmount.
func MustAdjustAmount(ctx context.Context, tb testing.TB, amount *big.Int, handler interface{}) (res *big.Int) {
	tb.Helper()
	res, err := AdjustAmount(ctx, amount, handler)
	assert.Nil(tb, err)
	return res
}

// AdjustAmount multiplies a token by the number of decimals in the amount.
// this does not use an interface with a Decimals() methods since usdt returns a (non-erc 20 compliant)
// *big.Int rather than a uint8 for decimals. If the handler is determined to be usdt (via a type switch)
// that decimals method is called, otherwise the standard decimals method is called.
func AdjustAmount(ctx context.Context, amount *big.Int, handler interface{}) (res *big.Int, err error) {
	decimalCount, err := GetDecimals(ctx, handler)
	if err != nil {
		return nil, fmt.Errorf("could not get decimals: %w", err)
	}
	decimalMultiplier := big.NewInt(0).Exp(big.NewInt(10), big.NewInt(int64(decimalCount)), nil)
	return big.NewInt(0).Mul(decimalMultiplier, amount), nil
}

// ERC20DecimalHandler gets the decimal count from a standard erc20 token.
type ERC20DecimalHandler interface {
	// Decimals gets the erc-20 decimals
	Decimals(opts *bind.CallOpts) (uint8, error)
}

// BigIntDecimalHandler is the decimal handler for tokens which return a *big.Int
// this is non-standard: but it's done by usdt token (see: https://tether.to/).
type BigIntDecimalHandler interface {
	// Decimals gets the decimals from the big int
	Decimals(opts *bind.CallOpts) (*big.Int, error)
}

// GetDecimals gets decimals from token that adheres to either the tether or the erc-20 standard.
func GetDecimals(ctx context.Context, handler interface{}) (res uint8, err error) {
	var decimalCount *big.Int
	switch decimalHandler := handler.(type) {
	case BigIntDecimalHandler:
		decimalCount, err = decimalHandler.Decimals(&bind.CallOpts{Context: ctx})
	case ERC20DecimalHandler:
		var decimals uint8
		decimals, err = decimalHandler.Decimals(&bind.CallOpts{Context: ctx})
		decimalCount = big.NewInt(int64(decimals))
	default:
		err = fmt.Errorf("no handler available for type %s", reflect.TypeOf(decimalHandler))
	}
	if err != nil {
		return res, fmt.Errorf("could not get decimals: %w", err)
	}
	return uint8(decimalCount.Uint64()), nil
}