package util_test

import (
	"github.com/brianvoe/gofakeit/v6"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/core"
	"github.com/synapsecns/sanguine/core/testsuite"
	"github.com/synapsecns/sanguine/ethergo/mocks"
	"github.com/synapsecns/sanguine/ethergo/util"
	"math/big"
	"testing"
)

// nolint: cyclop, gocognit
func (u *UtilSuite) TestCopyTX() {
	mockDynamicTXS := mocks.GetMockTxes(u.GetTestContext(), u.T(), 100, types.DynamicFeeTxType)
	mockLegacyTXes := mocks.GetMockTxes(u.GetTestContext(), u.T(), 100, types.LegacyTxType)

	// delete me
	mockTXes := append(mockDynamicTXS, mockLegacyTXes...)

	for _, tx := range mockTXes {
		// fuzz some data
		txFuzzData := makeFuzzData(u.T(), tx)
		txFuzzData.txType = types.DynamicFeeTxType // delete me

		// build options
		var options []util.CopyOption
		if txFuzzData.nonce != tx.Nonce() {
			options = append(options, util.WithNonce(txFuzzData.nonce))
		}

		if txFuzzData.gasPrice != nil && txFuzzData.gasPrice.Cmp(tx.GasPrice()) != 0 && tx.Type() == types.LegacyTxType {
			options = append(options, util.WithGasPrice(txFuzzData.gasPrice))
		}

		if txFuzzData.feeCap != nil && txFuzzData.feeCap.Cmp(tx.GasFeeCap()) != 0 && tx.Type() == types.DynamicFeeTxType {
			options = append(options, util.WithGasFeeCap(txFuzzData.feeCap))
		}

		if txFuzzData.tipCap != nil && txFuzzData.tipCap.Cmp(tx.GasTipCap()) != 0 && tx.Type() == types.DynamicFeeTxType {
			options = append(options, util.WithGasTipCap(txFuzzData.tipCap))
		}

		if txFuzzData.txType != tx.Type() {
			options = append(options, util.WithTxType(txFuzzData.txType))
		}

		// copy the tx with the options
		newTx, err := util.CopyTX(tx, options...)
		u.Require().NoError(err)

		ogV, ogR, ogS := tx.RawSignatureValues()
		newV, newR, newS := newTx.RawSignatureValues()

		// make sure pointers changed
		assert.False(u.T(), core.ArePointersEqual(tx.ChainId(), newTx.ChainId()))
		assert.False(u.T(), core.ArePointersEqual(tx.Nonce(), newTx.Nonce()))
		assert.False(u.T(), core.ArePointersEqual(tx.GasPrice(), newTx.GasPrice()))
		assert.False(u.T(), core.ArePointersEqual(tx.GasTipCap(), newTx.GasTipCap()))
		assert.False(u.T(), core.ArePointersEqual(tx.GasFeeCap(), newTx.GasFeeCap()))
		assert.False(u.T(), core.ArePointersEqual(ogV, newV))
		assert.False(u.T(), core.ArePointersEqual(ogR, newR))
		assert.False(u.T(), core.ArePointersEqual(ogS, newS))

		// make sure fields without options were not changed
		assert.Equal(u.T(), tx.ChainId(), newTx.ChainId(), testsuite.BigIntComparer())
		assert.Equal(u.T(), tx.To(), newTx.To())
		assert.Equal(u.T(), tx.Value(), newTx.Value(), testsuite.BigIntComparer())
		assert.Equal(u.T(), tx.Data(), newTx.Data(), testsuite.BigIntComparer())

		// they won't be equal in this case
		if tx.Type() == txFuzzData.txType {
			assert.Equal(u.T(), tx.Type(), newTx.Type())
		}
		// make sure new tx matches target
		assert.Equal(u.T(), newTx.Type(), txFuzzData.txType)
		assert.Equal(u.T(), tx.Gas(), newTx.Gas())

		// don't check the v param if we've changed it to return the chainid correctly
		if tx.Type() == txFuzzData.txType {
			assert.Equal(u.T(), ogV, newV, testsuite.BigIntComparer())
			// this wil change slightly, it's not a problem
			assert.Equal(u.T(), tx.AccessList(), newTx.AccessList())

			// make sure the newTX matches the fuzz data
			if !txFuzzData.matchesTX(newTx) {
				u.T().Errorf("expected tx to match fuzz data, but it did not. tx: %v, fuzzData: %v", newTx, txFuzzData)
			}
		}
		assert.Equal(u.T(), ogR, newR, testsuite.BigIntComparer())
		assert.Equal(u.T(), ogS, newS, testsuite.BigIntComparer())
	}
}

// nolint: gocognit, cyclop
func makeFuzzData(tb testing.TB, tx *types.Transaction) fuzzData {
	tb.Helper()

	txType := tx.Type()
	nonce := tx.Nonce()
	if gofakeit.Bool() {
		nonce = gofakeit.Uint64()
	}
	var gasPrice, feeCap, tipCap *big.Int
	if tx.Type() == types.DynamicFeeTxType {
		feeCap = tx.GasFeeCap()
		if gofakeit.Bool() {
			feeCap = new(big.Int).SetUint64(gofakeit.Uint64())
		}

		tipCap = tx.GasTipCap()
		if gofakeit.Bool() {
			tipCap = new(big.Int).SetUint64(gofakeit.Uint64())
		}
	}
	if tx.Type() == types.LegacyTxType {
		gasPrice = tx.GasPrice()

		if gofakeit.Bool() {
			gasPrice = new(big.Int).SetUint64(gofakeit.Uint64())
		}
	}

	if gofakeit.Bool() {
		var err error
		txTypes := []uint8{types.DynamicFeeTxType, types.LegacyTxType}
		txType, err = core.RandomItem[uint8](txTypes)
		assert.Nilf(tb, err, "failed to get random tx type: %v", err)
	}

	return fuzzData{
		nonce:    nonce,
		gasPrice: gasPrice,
		feeCap:   feeCap,
		tipCap:   tipCap,
		txType:   txType,
	}
}

type fuzzData struct {
	nonce    uint64
	gasPrice *big.Int
	feeCap   *big.Int
	tipCap   *big.Int
	txType   uint8
}

func (f *fuzzData) matchesTX(tx *types.Transaction) bool {
	if f.nonce != tx.Nonce() {
		return false
	}
	if f.gasPrice != nil && f.gasPrice.Cmp(tx.GasPrice()) != 0 {
		return false
	}
	if f.txType == tx.Type() {
		if f.feeCap != nil && f.feeCap.Cmp(tx.GasFeeCap()) != 0 {
			return false
		}

		if f.tipCap != nil && f.tipCap.Cmp(tx.GasTipCap()) != 0 {
			return false
		}
	}
	return true
}

func TestMakeOptionsNil(t *testing.T) {
	opts := util.MakeOptions()
	if opts.Nonce() != nil {
		t.Errorf("expected nonce to be nil, got %v", opts.Nonce())
	}
	if opts.GasPrice() != nil {
		t.Errorf("expected gas price to be nil, got %v", opts.GasPrice())
	}
	if opts.GasFeeCap() != nil {
		t.Errorf("expected gas fee cap to be nil, got %v", opts.GasFeeCap())
	}
	if opts.GasTipCap() != nil {
		t.Errorf("expected gas tip cap to be nil, got %v", opts.GasTipCap())
	}
}

func TestMakeOptionsWithNonce(t *testing.T) {
	opts := util.MakeOptions(util.WithNonce(1234))

	if opts.Nonce() == nil {
		t.Errorf("expected nonce to be set, got nil")
	}
	if *opts.Nonce() != 1234 {
		t.Errorf("expected nonce to be 1234, got %v", *opts.Nonce())
	}
	if opts.GasPrice() != nil {
		t.Errorf("expected gas price to be nil, got %v", opts.GasPrice())
	}
	if opts.GasFeeCap() != nil {
		t.Errorf("expected gas fee cap to be nil, got %v", opts.GasFeeCap())
	}
	if opts.GasTipCap() != nil {
		t.Errorf("expected gas tip cap to be nil, got %v", opts.GasTipCap())
	}
}

func TestMakeOptionsWithTxType(t *testing.T) {
	txTypes := []uint8{types.LegacyTxType, types.DynamicFeeTxType, types.AccessListTxType}
	for _, txType := range txTypes {
		opts := util.MakeOptions(util.WithTxType(txType))

		if opts.Nonce() != nil {
			t.Errorf("expected nonce to not be set, got %v", opts.Nonce())
		}

		if opts.TxType() == nil {
			t.Errorf("expected tx type to be set, got nil")
		}

		if *opts.TxType() != txType {
			t.Errorf("expected tx type to be %v, got %v", txType, *opts.TxType())
		}

		if opts.GasPrice() != nil {
			t.Errorf("expected gas price to be nil, got %v", opts.GasPrice())
		}
		if opts.GasFeeCap() != nil {
			t.Errorf("expected gas fee cap to be nil, got %v", opts.GasFeeCap())
		}
		if opts.GasTipCap() != nil {
			t.Errorf("expected gas tip cap to be nil, got %v", opts.GasTipCap())
		}
	}
}

func TestMakeOptionsWithGasPrice(t *testing.T) {
	gasPrice := big.NewInt(100)
	opts := util.MakeOptions(util.WithGasPrice(gasPrice))

	if opts.Nonce() != nil {
		t.Errorf("expected nonce to be nil, got %v", opts.Nonce())
	}
	if opts.GasPrice() == nil {
		t.Errorf("expected gas price to be set, got nil")
	}
	if opts.GasPrice().Cmp(gasPrice) != 0 {
		t.Errorf("expected gas price to be %v, got %v", gasPrice, opts.GasPrice())
	}
	if opts.GasFeeCap() != nil {
		t.Errorf("expected gas fee cap to be nil, got %v", opts.GasFeeCap())
	}
	if opts.GasTipCap() != nil {
		t.Errorf("expected gas tip cap to be nil, got %v", opts.GasTipCap())
	}
}

func TestMakeOptionsWithGasFeeCap(t *testing.T) {
	gasFeeCap := big.NewInt(200)
	gasTipCap := big.NewInt(300)
	opts := util.MakeOptions(util.WithGasFeeCap(gasFeeCap), util.WithGasTipCap(gasTipCap))

	if opts.Nonce() != nil {
		t.Errorf("expected nonce to be nil, got %v", opts.Nonce())
	}
	if opts.GasPrice() != nil {
		t.Errorf("expected gas price to be nil, got %v", opts.GasPrice())
	}
	if opts.GasFeeCap() == nil {
		t.Errorf("expected gas fee cap to be set, got nil")
	}
	if opts.GasFeeCap().Cmp(gasFeeCap) != 0 {
		t.Errorf("expected gas fee cap to be %v, got %v", gasFeeCap, opts.GasFeeCap())
	}
	if opts.GasTipCap() != gasTipCap {
		t.Errorf("expected gas tip cap to be nil, got %v", opts.GasTipCap())
	}
}