package chain_test

import (
	"bytes"
	"github.com/brianvoe/gofakeit/v6"
	"github.com/ethereum/go-ethereum/core/types"
	. "github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/ethergo/backends/simulated"
	"github.com/synapsecns/sanguine/ethergo/chain"
	"github.com/synapsecns/sanguine/ethergo/chain/client"
	"math/big"
	"time"
)

// TestSimulatedBlockByTime runs the test block by time method
// on a simulated backend to catch any exceptions we might encounter with a non mocked chain.
func (s ChainSuite) TestSimulatedBlockByTime() {
	simulatedBackend := simulated.NewSimulatedBackend(s.GetTestContext(), s.T())

	const mockedBlocks = 300

	// create mockedBlocks an hour apart
	for i := 1; i < mockedBlocks+1; i++ {
		simulatedBackend.EmptyBlock(time.Now().Add(-1 * time.Hour * time.Duration(mockedBlocks-i)))
	}

	// make the test chain. The simulated backend contains one, but we want to create a new one
	// when testing the chain module
	testChain, err := chain.NewFromClient(s.GetTestContext(), &client.Config{
		ChainID: int(simulatedBackend.GetChainID()),
	}, simulatedBackend.Client())
	Nil(s.T(), err)

	latestBlock, err := simulatedBackend.BlockByNumber(s.GetTestContext(), nil)
	Nil(s.T(), err)

	// test start block enabled and disabled
	for _, useStartBlock := range []bool{false, true} {
		for i := 1; i <= int(latestBlock.Number().Uint64()); i++ {
			targetBlock, err := simulatedBackend.Chain.HeaderByNumber(s.GetTestContext(), big.NewInt(int64(i)))
			Nil(s.T(), err)

			// get the target as a time
			target := s.fuzzTime(targetBlock)

			var startBlock *big.Int
			if useStartBlock && i != 1 && i != int(latestBlock.NumberU64()) {
				startBlockNumber := gofakeit.Number(1, int(targetBlock.Number.Uint64())-1)
				startBlock = big.NewInt(0).Sub(targetBlock.Number, big.NewInt(int64(startBlockNumber)))
			}

			resultingBlock, err := testChain.HeaderByTime(s.GetTestContext(), startBlock, target)
			Nil(s.T(), err)

			if targetBlock.Number.Uint64() != resultingBlock.Number.Uint64() {
				_, err := testChain.HeaderByTime(s.GetTestContext(), startBlock, target)
				Nil(s.T(), err)
			}
			Equal(s.T(), targetBlock.Number.Uint64(), resultingBlock.Number.Uint64())
			True(s.T(), bytes.Equal(resultingBlock.Hash().Bytes(), targetBlock.Hash().Bytes()))
		}
	}
}

// fuzzTime fuzzes the time up to half an hour in either direction.
// 1/3 chance it's the same.
func (s ChainSuite) fuzzTime(block *types.Header) time.Time {
	parsedTime := time.Unix(int64(block.Time), 0)
	fuzzDirection := gofakeit.Number(-1, 1)
	if fuzzDirection == 0 {
		return parsedTime
	}

	fuzzInterval := time.Duration(gofakeit.Number(1, 29)) * time.Minute
	parsedTime = parsedTime.Add(fuzzInterval * time.Duration(fuzzDirection))

	return parsedTime
}