package api_test

import (
	gosql "database/sql"
	"fmt"
	"math"
	"math/big"
	"sort"
	"time"

	"github.com/ethereum/go-ethereum/crypto"
	. "github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/services/explorer/graphql/server/graph/model"

	"github.com/brianvoe/gofakeit/v6"
	"github.com/ethereum/go-ethereum/common"
	"github.com/synapsecns/sanguine/services/explorer/db/sql"
)

//nolint:cyclop
func (g APISuite) TestAddressRanking() {
	var chainID uint32
	chainIDs := []uint32{g.chainIDs[0], g.chainIDs[1], g.chainIDs[2]}
	destinationChainIDA := g.chainIDs[3]
	destinationChainIDB := g.chainIDs[4]
	contractAddress := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()

	address := common.BigToAddress(big.NewInt(gofakeit.Int64()))

	// used for validation later
	var addressesTried = make(map[string]int)

	// this counter lets us have a random variation in address occurrence
	resetTokenAddrCounter := gofakeit.Number(1, 3)
	// random token addr
	tokenAddr := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	// for holding the current token addr in line the gofakeit.Bool() decides to pass true
	lastTokenAddr := tokenAddr
	// Generate bridge events for different chain IDs.
	for blockNumber := uint64(1); blockNumber <= 10; blockNumber++ {
		var destinationChainID uint32
		if blockNumber%2 == 0 {
			destinationChainID = destinationChainIDA
		} else {
			destinationChainID = destinationChainIDB
		}

		// if the token counter is zero reset it
		if resetTokenAddrCounter == 0 {
			tokenAddr = common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
			lastTokenAddr = tokenAddr
			resetTokenAddrCounter = gofakeit.Number(1, 3)
		} else {
			// before using the current token addr, let throw in some randomness
			if gofakeit.Bool() {
				tokenAddr = common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
			} else {
				resetTokenAddrCounter--
			}
		}

		currentTime := uint64(time.Now().Unix())

		// change up chainID (1/3 chance of using a new chain)
		chainID = chainIDs[gofakeit.Number(0, 2)]
		txHash := common.BigToHash(big.NewInt(gofakeit.Int64()))
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.BridgeEvent{
			InsertTime:         1,
			ChainID:            chainID,
			Recipient:          gosql.NullString{String: address.String(), Valid: true},
			DestinationChainID: big.NewInt(int64(destinationChainID)),
			BlockNumber:        blockNumber,
			TxHash:             txHash.String(),
			EventIndex:         gofakeit.Uint64(),
			Token:              tokenAddr,
			Sender:             tokenAddr,
			TimeStamp:          &currentTime,
		})
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.TokenIndex{
			ChainID:         chainID,
			TokenAddress:    tokenAddr,
			ContractAddress: contractAddress,
			TokenIndex:      1,
		})

		// add the tokenAddr inserted to the test map (for validation later)
		addressesTried[tokenAddr]++

		// Set all times after current time, so we can get the events.
		err := g.eventDB.StoreBlockTime(g.GetTestContext(), chainIDs[0], blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), chainIDs[1], blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), chainIDs[2], blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), destinationChainIDA, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), destinationChainIDB, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)

		// if a random address was inserted, revert to address corresponding to resetTokenAddrCounter
		if lastTokenAddr != tokenAddr {
			tokenAddr = lastTokenAddr
		}
	}

	blockNumberInit := uint64(10)
	err := g.eventDB.StoreBlockTime(g.GetTestContext(), chainID, blockNumberInit, uint64(time.Now().Unix())*blockNumberInit)
	Nil(g.T(), err)

	result, err := g.client.GetAddressRanking(g.GetTestContext(), nil)
	Nil(g.T(), err)
	NotNil(g.T(), result)
	// check if the length of the response is same to the number of unique addresses inserted into test db
	Equal(g.T(), len(addressesTried), len(result.Response))

	// Validate contents of response by comparing to addressesTried
	for k, v := range addressesTried {
		for _, res := range result.Response {
			if *res.Address == k {
				Equal(g.T(), v, *res.Count)
			}
		}
	}
}

//nolint:cyclop
func (g APISuite) TestGetCountByChainID() {
	chainID := g.chainIDs[0]
	chainID2 := g.chainIDs[1]
	chainID3 := g.chainIDs[2]
	address := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	contractAddress := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	tokenAddress := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	// Generate bridge events for different chain IDs.
	for blockNumber := uint64(1); blockNumber <= 10; blockNumber++ {
		var destinationChainID int64
		var inputChain uint32
		destinationChainID = int64(g.chainIDs[1])
		inputChain = chainID
		if blockNumber > 1 {
			if blockNumber%2 == 0 {
				inputChain = chainID2
				destinationChainID = 0
			} else {
				inputChain = chainID3
				destinationChainID = int64(g.chainIDs[0])
			}
		}

		currentTime := uint64(time.Now().Unix())
		txHash := common.BigToHash(big.NewInt(gofakeit.Int64()))
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.BridgeEvent{
			ChainID:            inputChain,
			EventType:          gofakeit.Uint8(),
			DestinationChainID: big.NewInt(destinationChainID),
			Recipient:          gosql.NullString{String: address.String(), Valid: true},
			BlockNumber:        blockNumber,
			TxHash:             txHash.String(),
			EventIndex:         gofakeit.Uint64(),
			TimeStamp:          &currentTime,
			ContractAddress:    contractAddress,
			Token:              tokenAddress,
		})
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.TokenIndex{
			ChainID:         chainID,
			TokenAddress:    tokenAddress,
			ContractAddress: contractAddress,
			TokenIndex:      1,
		})

		// Set all times after current time, so we can get the events.
		err := g.eventDB.StoreBlockTime(g.GetTestContext(), chainID, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), chainID2, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), chainID3, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
	}

	addressRef := address.String()
	directionRef := model.DirectionOut
	resultOut, err := g.client.GetCountByChainID(g.GetTestContext(), nil, &addressRef, &directionRef, nil)
	Nil(g.T(), err)
	// There should be 3 chains, 2 for the destination chain IDs and 1 for the source chain ID.
	Equal(g.T(), 1, len(resultOut.Response))
	// The source chain ID should have 10 events out, and the destination chain IDs should have 0 events out.
	var reached = 0
	for _, res := range resultOut.Response {
		switch *res.ChainID {
		case int(chainID):
			Equal(g.T(), 1, *res.Count)
			reached++
		case int(chainID2):
			Equal(g.T(), 5, *res.Count)
			reached++
		case int(chainID3):
			Equal(g.T(), 4, *res.Count)
			reached++
		}
	}
	Equal(g.T(), 1, reached)

	directionRef = model.DirectionIn
	resultIn, err := g.client.GetCountByChainID(g.GetTestContext(), nil, &addressRef, &directionRef, nil)
	Nil(g.T(), err)
	// Again, there should be 3 chains, 2 for the destination chain IDs and 1 for the source chain ID.
	Equal(g.T(), 2, len(resultIn.Response))
	// The source chain ID should have 0 events in, and the destination chain IDs should have 5 events in.
	reached = 0
	for _, res := range resultIn.Response {
		switch *res.ChainID {
		case int(chainID):
			Equal(g.T(), 1, *res.Count)
			reached++
		case int(chainID2):
			Equal(g.T(), 5, *res.Count)
			reached++
		case int(chainID3):
			Equal(g.T(), 4, *res.Count)
			reached++
		}
	}
	Equal(g.T(), 2, reached)
}

// nolint (needed for testing all possibilities)
func (g APISuite) TestGetCountByTokenAddress() {
	chainID := g.chainIDs[0]
	destinationChainID := g.chainIDs[1]
	tokenAddressA := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	tokenAddressB := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	address := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	contractAddress := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	// Generate bridge events for different chain IDs.
	for blockNumber := uint64(1); blockNumber <= 10; blockNumber++ {
		var tokenAddress common.Address
		if blockNumber%2 == 0 {
			tokenAddress = tokenAddressA
			destinationChainID = g.chainIDs[1]
		} else {
			tokenAddress = tokenAddressB
			destinationChainID = 0
		}
		currentTime := uint64(time.Now().Unix())
		txHash := common.BigToHash(big.NewInt(gofakeit.Int64()))
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.BridgeEvent{
			ChainID:            chainID,
			EventType:          gofakeit.Uint8(),
			Recipient:          gosql.NullString{String: address.String(), Valid: true},
			DestinationChainID: big.NewInt(int64(destinationChainID)),
			Token:              tokenAddress.String(),
			BlockNumber:        blockNumber,
			TxHash:             txHash.String(),
			EventIndex:         gofakeit.Uint64(),
			TimeStamp:          &currentTime,
			ContractAddress:    contractAddress,
		})
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.TokenIndex{
			ChainID:         chainID,
			TokenAddress:    tokenAddress.String(),
			ContractAddress: contractAddress,
			TokenIndex:      1,
		})
		// Set all times after current time, so we can get the events.
		err := g.eventDB.StoreBlockTime(g.GetTestContext(), chainID, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), destinationChainID, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
	}

	addressRef := address.String()
	directionRef := model.DirectionOut

	resultOut, err := g.client.GetCountByTokenAddress(g.GetTestContext(), nil, &addressRef, &directionRef, nil)
	Nil(g.T(), err)

	Equal(g.T(), 1, len(resultOut.Response))
	reached := 0
	for _, res := range resultOut.Response {
		if *res.ChainID == int(chainID) {
			if *res.TokenAddress == tokenAddressA.String() {
				Equal(g.T(), 5, *res.Count)
				reached++
			}
			if *res.TokenAddress == tokenAddressB.String() {
				Equal(g.T(), 5, *res.Count)
				reached++
			}
		}
		if *res.ChainID == int(destinationChainID) {
			if *res.TokenAddress == tokenAddressA.String() {
				Equal(g.T(), 5, *res.Count)
				reached++
			}
			if *res.TokenAddress == tokenAddressB.String() {
				Equal(g.T(), 5, *res.Count)
				reached++
			}
		}
	}
	Equal(g.T(), 1, reached)

	directionRef = model.DirectionIn
	resultIn, err := g.client.GetCountByTokenAddress(g.GetTestContext(), nil, nil, &directionRef, nil)
	Nil(g.T(), err)

	Equal(g.T(), 1, len(resultIn.Response))
	reached = 0
	for _, res := range resultIn.Response {
		if *res.ChainID == int(destinationChainID) {
			if *res.TokenAddress == tokenAddressA.String() {
				Equal(g.T(), *res.Count, 5)
				reached++
			}
			if *res.TokenAddress == tokenAddressB.String() {
				Equal(g.T(), *res.Count, 5)
				reached++
			}
		}
		if *res.ChainID == int(chainID) {
			if *res.TokenAddress == tokenAddressA.String() {
				Equal(g.T(), 5, *res.Count)
				reached++
			}
			if *res.TokenAddress == tokenAddressB.String() {
				Equal(g.T(), 5, *res.Count)
				reached++
			}
		}
	}
	Equal(g.T(), 1, reached)
}

// TODO add other platforms to make this test more exhaustive
// nolint:cyclop
func (g APISuite) TestDailyStatisticsByChain() {
	chainID := g.chainIDs[0]
	destinationChainIDA := g.chainIDs[1]
	destinationChainIDB := g.chainIDs[2]
	address := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	tokenAddr := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	nowTime := time.Now().Unix()
	senders := []string{common.BigToHash(big.NewInt(gofakeit.Int64())).String(), common.BigToHash(big.NewInt(gofakeit.Int64())).String(), common.BigToHash(big.NewInt(gofakeit.Int64())).String()}
	cumulativePrice := []float64{}
	contract := common.BigToHash(big.NewInt(gofakeit.Int64()))
	// Generate bridge events for different chain IDs.
	for blockNumber := uint64(1); blockNumber <= 10; blockNumber++ {
		var destinationChainID uint32
		if blockNumber%2 == 0 {
			destinationChainID = destinationChainIDA
		} else {
			destinationChainID = destinationChainIDB
		}
		price := float64(gofakeit.Number(1, 300))
		cumulativePrice = append(cumulativePrice, price)
		txHash := common.BigToHash(big.NewInt(gofakeit.Int64()))

		timestamp := uint64(nowTime) - (10*blockNumber)*86400
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.BridgeEvent{
			ChainID:            chainID,
			ContractAddress:    contract.String(),
			EventType:          gofakeit.Uint8(),
			Recipient:          gosql.NullString{String: address.String(), Valid: true},
			DestinationChainID: big.NewInt(int64(destinationChainID)),
			BlockNumber:        blockNumber,
			TxHash:             txHash.String(),
			EventIndex:         gofakeit.Uint64(),
			Token:              tokenAddr,
			Amount:             big.NewInt(int64(gofakeit.Number(1, 300))),
			AmountUSD:          &price,
			Sender:             senders[blockNumber%3],
			TimeStamp:          &timestamp,
		})
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.TokenIndex{
			ChainID:      chainID,
			TokenAddress: tokenAddr,
			TokenIndex:   1,
		})
		// Set all times after current time, so we can get the events.
		err := g.eventDB.StoreBlockTime(g.GetTestContext(), chainID, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), destinationChainIDA, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), destinationChainIDB, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
	}
	total := 0.0
	for _, v := range cumulativePrice {
		total += v
	}
	platform := model.PlatformBridge
	days := model.DurationAllTime
	typeArg := model.DailyStatisticTypeVolume
	result, err := g.client.GetDailyStatisticsByChain(g.GetTestContext(), nil, &typeArg, &days, &platform, nil)
	Nil(g.T(), err)
	NotNil(g.T(), result)
	Equal(g.T(), cumulativePrice[len(cumulativePrice)-1], *result.Response[0].Total)
	Equal(g.T(), len(cumulativePrice), len(result.Response))

	typeArg = model.DailyStatisticTypeAddresses
	result, err = g.client.GetDailyStatisticsByChain(g.GetTestContext(), nil, &typeArg, &days, &platform, nil)
	Nil(g.T(), err)
	NotNil(g.T(), result)
	Equal(g.T(), float64(1), *result.Response[0].Total)
	Equal(g.T(), len(cumulativePrice), len(result.Response))

	typeArg = model.DailyStatisticTypeTransactions
	result, err = g.client.GetDailyStatisticsByChain(g.GetTestContext(), nil, &typeArg, &days, &platform, nil)
	Nil(g.T(), err)
	NotNil(g.T(), result)
	Equal(g.T(), float64(1), *result.Response[0].Total)
	Equal(g.T(), len(cumulativePrice), len(result.Response))
}

// TODO add swap txs.
func (g APISuite) TestGetBridgeTransactions() {
	chainID := g.chainIDs[0]
	destinationChainID := g.chainIDs[1]
	contractAddr := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	tokenAddress := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	address := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	senderAddress := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	senderString := senderAddress.String()
	txHashA := common.BigToHash(big.NewInt(gofakeit.Int64()))
	txHashB := common.BigToHash(big.NewInt(gofakeit.Int64()))
	kappaString := crypto.Keccak256Hash(txHashA.Bytes()).String()
	txHashString := txHashA.String()
	amount := big.NewInt(int64(gofakeit.Uint64()))
	amountUSD := float64(gofakeit.Number(1, 300))
	tokenDecimals := uint8(gofakeit.Number(0, 3))
	tokenSymbol := gofakeit.Word()
	timestamp := uint64(time.Now().Unix())
	page := 1

	g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.BridgeEvent{
		InsertTime:         1,
		ContractAddress:    common.BigToAddress(big.NewInt(gofakeit.Int64())).String(),
		ChainID:            chainID,
		EventType:          gofakeit.Uint8(),
		Sender:             senderString,
		Recipient:          gosql.NullString{String: address.String(), Valid: true},
		DestinationChainID: big.NewInt(int64(destinationChainID)),
		Token:              tokenAddress,
		BlockNumber:        1,
		TxHash:             txHashA.String(),
		DestinationKappa:   kappaString,
		EventIndex:         gofakeit.Uint64(),
		Amount:             amount,
		AmountUSD:          &amountUSD,
		TokenDecimal:       &tokenDecimals,
		TokenSymbol:        gosql.NullString{String: tokenSymbol, Valid: true},
		TimeStamp:          &timestamp,
	})
	g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.TokenIndex{
		ChainID:         chainID,
		TokenAddress:    tokenAddress,
		TokenIndex:      1,
		ContractAddress: contractAddr,
	})
	g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.BridgeEvent{
		InsertTime:      1,
		ChainID:         destinationChainID,
		EventType:       gofakeit.Uint8(),
		Recipient:       gosql.NullString{String: address.String(), Valid: true},
		Token:           tokenAddress,
		BlockNumber:     1,
		TxHash:          txHashB.String(),
		Kappa:           gosql.NullString{String: kappaString, Valid: true},
		SwapSuccess:     big.NewInt(1),
		EventIndex:      gofakeit.Uint64(),
		Amount:          amount,
		AmountUSD:       &amountUSD,
		TokenDecimal:    &tokenDecimals,
		Sender:          gofakeit.Word(),
		TokenSymbol:     gosql.NullString{String: tokenSymbol, Valid: true},
		TimeStamp:       &timestamp,
		ContractAddress: contractAddr,
	})
	g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.TokenIndex{
		ChainID:         destinationChainID,
		TokenAddress:    tokenAddress,
		ContractAddress: contractAddr,
		TokenIndex:      1,
	})
	err := g.eventDB.StoreBlockTime(g.GetTestContext(), chainID, 1, timestamp)
	Nil(g.T(), err)
	err = g.eventDB.StoreBlockTime(g.GetTestContext(), destinationChainID, 1, timestamp)
	Nil(g.T(), err)
	pending := false
	//nolint:dupword
	originRes, err := g.client.GetBridgeTransactions(g.GetTestContext(), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, &txHashString, nil, &pending, &page, nil, nil, nil)

	Nil(g.T(), err)
	Equal(g.T(), 1, len(originRes.Response))
	originResOne := *originRes.Response[0]
	Equal(g.T(), kappaString, *originResOne.Kappa)
	// do pending
	Equal(g.T(), *originResOne.SwapSuccess, true)

	fromInfo := *originResOne.FromInfo
	Equal(g.T(), int(chainID), *fromInfo.ChainID)
	Equal(g.T(), address.String(), *fromInfo.Address)
	Equal(g.T(), txHashA.String(), *fromInfo.TxnHash)
	Equal(g.T(), amount.String(), *fromInfo.Value)
	Equal(g.T(), amountUSD, *fromInfo.USDValue)
	formattedValue := uint64((float64(amount.Int64()) / math.Pow10(int(tokenDecimals))) * 1000000)
	Equal(g.T(), formattedValue, uint64(*fromInfo.FormattedValue*1000000))
	Equal(g.T(), tokenSymbol, *fromInfo.TokenSymbol)
	Equal(g.T(), tokenAddress, *fromInfo.TokenAddress)
	Equal(g.T(), 1, *fromInfo.BlockNumber)
	Equal(g.T(), int(timestamp), *fromInfo.Time)

	toInfo := *originResOne.ToInfo
	Equal(g.T(), int(destinationChainID), *toInfo.ChainID)
	Equal(g.T(), address.String(), *toInfo.Address)
	Equal(g.T(), txHashB.String(), *toInfo.TxnHash)
	Equal(g.T(), amount.String(), *toInfo.Value)
	Equal(g.T(), amountUSD, *toInfo.USDValue)
	Equal(g.T(), formattedValue, uint64(*toInfo.FormattedValue*1000000))
	Equal(g.T(), tokenSymbol, *toInfo.TokenSymbol)
	Equal(g.T(), tokenAddress, *toInfo.TokenAddress)
	Equal(g.T(), 1, *toInfo.BlockNumber)
	Equal(g.T(), int(timestamp), *toInfo.Time)

	pending = false
	//nolint:dupword
	destinationRes, err := g.client.GetBridgeTransactions(g.GetTestContext(), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, &kappaString, &pending, &page, nil, nil, nil)
	Nil(g.T(), err)
	Equal(g.T(), 1, len(destinationRes.Response))
	destinationResOne := *destinationRes.Response[0]
	Equal(g.T(), originResOne, destinationResOne)

	pending = true
	addressRes, err := g.client.GetBridgeTransactions(g.GetTestContext(), nil, nil, nil, &senderString, nil, nil, nil, nil, nil, nil, nil, nil, &pending, &page, nil, nil, nil)
	Nil(g.T(), err)
	Equal(g.T(), 1, len(addressRes.Response))

	addressResOne := *addressRes.Response[0]
	Equal(g.T(), originResOne, addressResOne)
}

func (g APISuite) TestLeaderboard() {
	chainID := g.chainIDs[0]
	address := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	var addressNS gosql.NullString
	addressNS.String = address.String()
	addressNS.Valid = true

	tokenAddr := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	senders := []string{common.BigToHash(big.NewInt(gofakeit.Int64())).String(), common.BigToHash(big.NewInt(gofakeit.Int64())).String(), common.BigToHash(big.NewInt(gofakeit.Int64())).String()}
	nowTime := time.Now().Unix()
	contract := common.BigToHash(big.NewInt(gofakeit.Int64()))
	// Generate bridge events for different chain IDs.
	for blockNumber := uint64(1); blockNumber <= 10; blockNumber++ {
		price := float64(gofakeit.Number(1, 300))
		txHash := common.BigToHash(big.NewInt(gofakeit.Int64()))

		timestamp := uint64(nowTime) - (10*blockNumber)*86400
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&MvBridgeEvent{
			FChainID:         chainID,
			FContractAddress: contract.String(),
			FEventType:       gofakeit.Uint8(),
			FBlockNumber:     blockNumber,
			FTxHash:          txHash.String(),
			FEventIndex:      gofakeit.Uint64(),
			FAmountUSD:       &price,
			FFeeAmountUSD:    &price,
			FSender:          senders[blockNumber%3],
			FTimeStamp:       &timestamp,
			TChainID:         chainID,
			TContractAddress: contract.String(),
			TEventType:       gofakeit.Uint8(),
			TBlockNumber:     blockNumber,
			TTxHash:          txHash.String(),
			TEventIndex:      gofakeit.Uint64(),
			TAmountUSD:       &price,
			TFeeAmountUSD:    &price,
			TSender:          senders[blockNumber%3],
			TTimeStamp:       &timestamp,
		})
		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.TokenIndex{
			ChainID:      chainID,
			TokenAddress: tokenAddr,
			TokenIndex:   1,
		})
		// Set all times after current time, so we can get the events.
		err := g.eventDB.StoreBlockTime(g.GetTestContext(), chainID, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
	}

	useMv := true
	page := 1
	duration := model.DurationAllTime
	result, err := g.client.GetLeaderboard(g.GetTestContext(), &duration, nil, &useMv, &page)
	Nil(g.T(), err)
	NotNil(g.T(), result)
	for i := 0; i < len(result.Response); i++ {
		NotNil(g.T(), result.Response[i].Address)
		NotNil(g.T(), result.Response[i].VolumeUsd)
		NotNil(g.T(), result.Response[i].Fees)
		NotNil(g.T(), result.Response[i].Txs)
		NotNil(g.T(), result.Response[i].Rank)
		NotNil(g.T(), result.Response[i].AvgVolumeUsd)
	}
}

// TODO rewrite this test so that it is exhaustive with all platform and statistic types.
// nolint:cyclop
func (g APISuite) TestAmountStatistic() {
	chainID := g.chainIDs[0]
	destinationChainIDA := g.chainIDs[1]
	destinationChainIDB := g.chainIDs[2]
	address := common.BigToAddress(big.NewInt(gofakeit.Int64()))
	contractAddress := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()

	tokenAddr := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	sender := common.BigToAddress(big.NewInt(gofakeit.Int64())).String()
	cumulativePrice := []float64{}
	// Generate bridge events for different chain IDs.
	for blockNumber := uint64(1); blockNumber <= 10; blockNumber++ {
		var destinationChainID uint32
		if blockNumber%2 == 0 {
			destinationChainID = destinationChainIDA
		} else {
			destinationChainID = destinationChainIDB
		}

		currentTime := uint64(time.Now().Unix())
		price := float64(gofakeit.Number(1, 300))
		cumulativePrice = append(cumulativePrice, price)
		txHash := common.BigToHash(big.NewInt(gofakeit.Int64()))

		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&MvBridgeEvent{
			InsertTime:       1,
			FChainID:         chainID,
			FContractAddress: contractAddress,
			FEventType:       gofakeit.Uint8(),
			FBlockNumber:     blockNumber,
			FTxHash:          txHash.String(),
			FEventIndex:      gofakeit.Uint64(),
			FAmountUSD:       &price,
			FFeeAmountUSD:    &price,
			FRecipient:       gosql.NullString{String: address.String(), Valid: true},
			FSender:          sender,
			FTimeStamp:       &currentTime,
			TChainID:         destinationChainID,
			TContractAddress: contractAddress,
			TEventType:       gofakeit.Uint8(),
			TBlockNumber:     blockNumber,
			TTxHash:          txHash.String(),
			TEventIndex:      gofakeit.Uint64(),
			TAmountUSD:       &price,
			TFeeAmountUSD:    &price,
			TSender:          sender,
			TTimeStamp:       &currentTime,
		})

		g.db.UNSAFE_DB().WithContext(g.GetTestContext()).Create(&sql.TokenIndex{
			ChainID:         chainID,
			TokenAddress:    tokenAddr,
			ContractAddress: contractAddress,
			TokenIndex:      1,
		})
		// Set all times after current time, so we can get the events.
		err := g.eventDB.StoreBlockTime(g.GetTestContext(), chainID, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), destinationChainIDA, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
		err = g.eventDB.StoreBlockTime(g.GetTestContext(), destinationChainIDB, blockNumber, uint64(time.Now().Unix())*blockNumber)
		Nil(g.T(), err)
	}

	total := 0.0
	for _, v := range cumulativePrice {
		total += v
	}
	count := float64(len(cumulativePrice))
	mean := total / count
	var median float64
	sort.Float64s(cumulativePrice)
	switch {
	case count == 0:
		median = 0.0
	case len(cumulativePrice)%2 == 0:
		median = (cumulativePrice[len(cumulativePrice)/2-1] + cumulativePrice[len(cumulativePrice)/2]) / 2
	default:
		median = cumulativePrice[len(cumulativePrice)/2]
	}

	statType := model.StatisticTypeTotalVolumeUsd
	duration := model.DurationAllTime
	platform := model.PlatformBridge
	// nolint:dupword
	result, err := g.client.GetAmountStatistic(g.GetTestContext(), statType, &platform, &duration, nil, nil, nil, nil)
	Nil(g.T(), err)
	NotNil(g.T(), result)

	Equal(g.T(), fmt.Sprintf("%f", total), *result.Response.Value)

	statType = model.StatisticTypeCountTransactions
	// nolint:dupword
	result, err = g.client.GetAmountStatistic(g.GetTestContext(), statType, &platform, &duration, nil, nil, nil, nil)
	Nil(g.T(), err)
	NotNil(g.T(), result)
	Equal(g.T(), fmt.Sprintf("%f", count), *result.Response.Value)

	statType = model.StatisticTypeMeanVolumeUsd
	// nolint:dupword
	result, err = g.client.GetAmountStatistic(g.GetTestContext(), statType, &platform, &duration, nil, nil, nil, nil)
	Nil(g.T(), err)
	NotNil(g.T(), result)
	Equal(g.T(), fmt.Sprintf("%f", mean), *result.Response.Value)

	statType = model.StatisticTypeMedianVolumeUsd
	result, err = g.client.GetAmountStatistic(g.GetTestContext(), statType, &platform, &duration, nil, nil, nil, nil)
	Nil(g.T(), err)
	NotNil(g.T(), result)
	Equal(g.T(), fmt.Sprintf("%f", median), *result.Response.Value)

	statType = model.StatisticTypeCountAddresses
	result, err = g.client.GetAmountStatistic(g.GetTestContext(), statType, &platform, &duration, nil, nil, nil, nil)

	Nil(g.T(), err)
	NotNil(g.T(), result)
	Equal(g.T(), "1.000000", *result.Response.Value)
}

func (g APISuite) TestGetBlockHeight() {
	chainID1 := 1
	chainID2 := 56

	type1 := model.ContractTypeCctp
	type2 := model.ContractTypeBridge

	contract1 := g.config.Chains[uint32(chainID1)].Contracts.CCTP
	contract2 := g.config.Chains[uint32(chainID2)].Contracts.Bridge

	block1 := uint64(3)
	block2 := uint64(4)

	contracts := []*model.ContractQuery{
		{
			ChainID: chainID1,
			Type:    type1,
		},
		{
			ChainID: chainID2,
			Type:    type2,
		},
	}

	// Store blocks in the database.
	err := g.db.StoreLastBlock(g.GetTestContext(), uint32(chainID1), block1, contract1)
	Nil(g.T(), err)

	err = g.db.StoreLastBlock(g.GetTestContext(), uint32(chainID2), block2, contract2)
	Nil(g.T(), err)

	results, err := g.client.GetBlockHeight(g.GetTestContext(), contracts)
	Nil(g.T(), err)

	Equal(g.T(), 2, len(results.Response))
	Equal(g.T(), int(block1), *results.Response[0].BlockNumber)
	Equal(g.T(), int(block2), *results.Response[1].BlockNumber)
}