package types_test

import (
	"context"
	"math/big"
	"testing"
	"time"

	"github.com/brianvoe/gofakeit/v6"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	. "github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/agents/testutil"
	"github.com/synapsecns/sanguine/agents/types"
	"github.com/synapsecns/sanguine/ethergo/backends/simulated"
)

func TestSnapshotRootAndProofs(t *testing.T) {
	// TODO (Max Planck): Fix me
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
	defer cancel()

	testBackend := simulated.NewSimulatedBackend(ctx, t)
	deployManager := testutil.NewDeployManager(t)

	_, snapshotContract := deployManager.GetSnapshotHarness(ctx, testBackend)
	_, stateContract := deployManager.GetStateHarness(ctx, testBackend)

	rootA := common.BigToHash(big.NewInt(gofakeit.Int64()))
	rootB := common.BigToHash(big.NewInt(gofakeit.Int64()))
	originA := gofakeit.Uint32()
	originB := gofakeit.Uint32()
	nonceA := gofakeit.Uint32()
	nonceB := gofakeit.Uint32()
	blockNumberA := randomUint40BigInt(t)
	blockNumberB := randomUint40BigInt(t)
	timestampA := randomUint40BigInt(t)
	timestampB := randomUint40BigInt(t)

	gasPriceA := gofakeit.Uint16()
	dataPriceA := gofakeit.Uint16()
	execBufferA := gofakeit.Uint16()
	amortAttCostA := gofakeit.Uint16()
	etherPriceA := gofakeit.Uint16()
	markupA := gofakeit.Uint16()
	gasDataA := types.NewGasData(gasPriceA, dataPriceA, execBufferA, amortAttCostA, etherPriceA, markupA)

	stateA := types.NewState(rootA, originA, nonceA, blockNumberA, timestampA, gasDataA)

	gasPriceB := gofakeit.Uint16()
	dataPriceB := gofakeit.Uint16()
	execBufferB := gofakeit.Uint16()
	amortAttCostB := gofakeit.Uint16()
	etherPriceB := gofakeit.Uint16()
	markupB := gofakeit.Uint16()
	gasDataB := types.NewGasData(gasPriceB, dataPriceB, execBufferB, amortAttCostB, etherPriceB, markupB)

	stateB := types.NewState(rootB, originB, nonceB, blockNumberB, timestampB, gasDataB)
	snapshot := types.NewSnapshot([]types.State{stateA, stateB})

	snapshotRoot, _, err := snapshot.SnapshotRootAndProofs()
	Nil(t, err)

	encodedSnapshot, err := snapshot.Encode()
	Nil(t, err)

	snapshotContractStatesAmount, err := snapshotContract.StatesAmount(&bind.CallOpts{Context: ctx}, encodedSnapshot)
	Nil(t, err)

	Equal(t, big.NewInt(2), snapshotContractStatesAmount)

	snapshotContractStateA, err := snapshotContract.State(&bind.CallOpts{Context: ctx}, encodedSnapshot, 0)
	Nil(t, err)

	stateABytes, err := stateA.Encode()
	Nil(t, err)

	Equal(t, stateABytes, snapshotContractStateA)

	snapshotContractStateB, err := snapshotContract.State(&bind.CallOpts{Context: ctx}, encodedSnapshot, 1)
	Nil(t, err)

	stateBBytes, err := stateB.Encode()
	Nil(t, err)

	Equal(t, stateBBytes, snapshotContractStateB)

	stateALeaf, err := stateA.Hash()
	Nil(t, err)

	stateContractStateALeaf, err := stateContract.Leaf(&bind.CallOpts{Context: ctx}, stateABytes)
	Nil(t, err)

	Equal(t, stateALeaf, stateContractStateALeaf)

	stateBLeaf, err := stateB.Hash()
	Nil(t, err)

	stateContractStateBLeaf, err := stateContract.Leaf(&bind.CallOpts{Context: ctx}, stateBBytes)
	Nil(t, err)

	Equal(t, stateBLeaf, stateContractStateBLeaf)

	snapshotContractRoot, err := snapshotContract.CalculateRoot(&bind.CallOpts{Context: ctx}, encodedSnapshot)
	Nil(t, err)

	Equal(t, snapshotRoot, snapshotContractRoot)
}