package gas_test

import (
	"github.com/brianvoe/gofakeit/v6"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/params"
	. "github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/ethergo/backends/simulated"
	"github.com/synapsecns/sanguine/ethergo/chain/gas"
	"github.com/synapsecns/sanguine/ethergo/mocks"
	"math/big"
)

func (s GasSuite) TestGasPriceEstimator() {
	testChain := simulated.NewSimulatedBackend(s.GetTestContext(), s.T())
	estimator := gas.NewGasPriceEstimator(s.GetTestContext(), testChain)
	height, err := testChain.BlockByNumber(s.GetTestContext(), nil)
	Nil(s.T(), err)

	// below ethconfig.FullNodeGPO.Blocks, price should be default
	price, err := estimator.EstimateGasPrice(s.GetTestContext(), height.NumberU64(), gas.GetConfig())
	Nil(s.T(), err)
	Equal(s.T(), gas.DefaultGasPriceEstimate, price)
	s.mockGasEvents(testChain)

	// price at new height should not be the same
	height, err = testChain.BlockByNumber(s.GetTestContext(), nil)
	Nil(s.T(), err)

	price, err = estimator.EstimateGasPrice(s.GetTestContext(), height.NumberU64(), gas.GetConfig())
	Nil(s.T(), err)
	NotEqual(s.T(), gas.DefaultGasPriceEstimate.Uint64(), price.Uint64())
	Less(s.T(), gas.GetConfig().IgnorePrice.Uint64(), price.Uint64())

	// finally, let's make sure the new gas price isn't ignored by our backend (base fee test)
	acct := testChain.GetFundedAccount(s.GetTestContext(), big.NewInt(params.Ether))
	to := common.BigToAddress(big.NewInt(0))

	signedTx, err := testChain.SignTx(types.NewTx(&types.LegacyTx{
		Gas:      21000,
		GasPrice: price,
		To:       &to,
		Value:    big.NewInt(params.GWei),
	}), types.LatestSignerForChainID(testChain.Chain.GetBigChainID()), acct.PrivateKey)
	Nil(s.T(), err)

	err = testChain.SendTransaction(s.GetTestContext(), signedTx)
	Nil(s.T(), err)

	testChain.WaitForConfirmation(s.GetTestContext(), signedTx)
}

// mockGasEvents mocks a bunch of gas events.
func (s GasSuite) mockGasEvents(chain *simulated.Backend) {
	// create a new transactor
	transactor := mocks.MockAccount(s.T())

	// fund the transactor w/ 50 eth
	chain.FundAccount(s.GetTestContext(), transactor.Address, *big.NewInt(0).Mul(big.NewInt(params.Ether), big.NewInt(50)))

	// get the current height, so we can discard any txes before the height where gas calculations start
	currentBlock, err := chain.BlockByNumber(s.GetTestContext(), nil)
	Nil(s.T(), err)
	height := int(currentBlock.NumberU64())
	// gasHeight is the height at which gas will be calculated back from
	gasHeight := gas.GetConfig().Blocks + height + 20

	var signedTx *types.Transaction

	destAddress := mocks.MockAddress()
	for i := height; i <= gasHeight; i++ {
		// generate a number between 1 and 256 and multiply it by gwei
		gasPrice := big.NewInt(0).Mul(big.NewInt(params.GWei), big.NewInt(int64(gofakeit.Uint8())+1))
		rawTx := types.NewTx(&types.LegacyTx{
			Gas:      simulated.BlockGasLimit,
			GasPrice: gasPrice,
			To:       &destAddress,
			Value:    big.NewInt(1),
		})
		signedTx, err = chain.SignTx(rawTx, types.LatestSignerForChainID(chain.ChainConfig().ChainID), transactor.PrivateKey)
		Nil(s.T(), err)

		err = chain.Client().SendTransaction(s.GetTestContext(), signedTx)
		Nil(s.T(), err)
		chain.Commit()
	}
	chain.WaitForConfirmation(s.GetTestContext(), signedTx)
}