package db_test

import (
	"strings"

	"github.com/brianvoe/gofakeit/v6"
	"github.com/ethereum/go-ethereum/common"
	"github.com/synapsecns/sanguine/ethergo/mocks"
	"github.com/synapsecns/sanguine/services/cctp-relayer/db"
	"github.com/synapsecns/sanguine/services/cctp-relayer/types"
)

func (d *DBSuite) mockMessage(originChainID, destinationChainID, blockNumber uint32) types.Message {
	return types.Message{
		OriginTxHash:     mocks.NewMockHash(d.T()).String(),
		DestTxHash:       mocks.NewMockHash(d.T()).String(),
		OriginChainID:    originChainID,
		DestChainID:      destinationChainID,
		Message:          []byte(gofakeit.Paragraph(10, 10, 10, " ")),
		MessageHash:      mocks.NewMockHash(d.T()).String(),
		Attestation:      []byte(gofakeit.Paragraph(10, 10, 10, " ")),
		RequestVersion:   0,
		FormattedRequest: []byte(gofakeit.Paragraph(10, 10, 10, " ")),
		RequestID:        strings.TrimPrefix(mocks.NewMockHash(d.T()).String(), "0x"),
		BlockNumber:      uint64(blockNumber),
		State:            types.Pending,
	}
}

func (d *DBSuite) TestGetMessageByHash() {
	d.RunOnAllDBs(func(testDB db.CCTPRelayerDB) {
		message1 := d.mockMessage(gofakeit.Uint32(), gofakeit.Uint32(), gofakeit.Uint32())
		message2 := d.mockMessage(gofakeit.Uint32(), gofakeit.Uint32(), gofakeit.Uint32())

		err := testDB.StoreMessage(d.GetTestContext(), message1)
		d.Nil(err)

		err = testDB.StoreMessage(d.GetTestContext(), message2)
		d.Nil(err)

		message, err := testDB.GetMessageByOriginHash(d.GetTestContext(), common.HexToHash(message1.OriginTxHash))
		d.Nil(err)

		d.Equal(message1.MessageHash, message.MessageHash)
	})
}

func (d *DBSuite) TestGetMessageByRequestID() {
	d.RunOnAllDBs(func(testDB db.CCTPRelayerDB) {
		message1 := d.mockMessage(gofakeit.Uint32(), gofakeit.Uint32(), gofakeit.Uint32())
		message2 := d.mockMessage(gofakeit.Uint32(), gofakeit.Uint32(), gofakeit.Uint32())

		err := testDB.StoreMessage(d.GetTestContext(), message1)
		d.Nil(err)

		err = testDB.StoreMessage(d.GetTestContext(), message2)
		d.Nil(err)

		message, err := testDB.GetMessageByRequestID(d.GetTestContext(), message1.RequestID)
		d.Nil(err)

		d.Equal(message1.MessageHash, message.MessageHash)
	})
}

func (d *DBSuite) TestLastBlockNumber() {
	d.RunOnAllDBs(func(testDB db.CCTPRelayerDB) {
		originChainID := gofakeit.Uint32()
		destChainID := gofakeit.Uint32()

		// make sure w/ no messages inserted the last block number is 0
		lastBlockNumber, err := testDB.GetLastBlockNumber(d.GetTestContext(), originChainID)
		d.Nil(err)

		d.Equal(uint64(0), lastBlockNumber)

		// insert a message for origin chain id. Make sure the last block number matches for the origin chain
		// and not the dest chain.
		newBlockNumber := gofakeit.Uint32()
		message := d.mockMessage(originChainID, destChainID, newBlockNumber)

		err = testDB.StoreMessage(d.GetTestContext(), message)
		d.Nil(err)

		lastBlockNumber, err = testDB.GetLastBlockNumber(d.GetTestContext(), originChainID)
		d.Nil(err)
		d.Equal(uint64(newBlockNumber), lastBlockNumber)

		destBlockNumber, err := testDB.GetLastBlockNumber(d.GetTestContext(), destChainID)
		d.Nil(err)

		d.Equal(uint64(0), destBlockNumber)
	})
}

// TestUpsertStoreMessage asserts that the messages are correctly stored in the database
// regardless of what state they are in.
func (d *DBSuite) TestUpsertStoreMessage() {
	d.RunOnAllDBs(func(testDB db.CCTPRelayerDB) {
		message := d.mockMessage(gofakeit.Uint32(), gofakeit.Uint32(), gofakeit.Uint32())
		// first insert w/ no error
		message.Attestation = nil
		message.State = types.Pending

		err := testDB.StoreMessage(d.GetTestContext(), message)
		d.Nil(err)

		var fetchedMessages []types.Message
		fetchedMessages, err = testDB.GetMessagesByState(d.GetTestContext(), types.Pending)
		d.Nil(err)

		fetchedMessage := fetchedMessages[0]
		d.Equal(fetchedMessage.State, types.Pending)

		message.State = types.Attested
		err = testDB.StoreMessage(d.GetTestContext(), message)
		d.Nil(err)

		// this will be empty if the previous message was actually upserted
		emptyMessages, err := testDB.GetMessagesByState(d.GetTestContext(), types.Pending)
		d.Nil(err)
		d.Empty(emptyMessages)

		fetchedMessages, err = testDB.GetMessagesByState(d.GetTestContext(), types.Attested)
		d.Nil(err)

		fetchedMessage = fetchedMessages[0]
		d.Equal(fetchedMessage.State, types.Attested)
	})
}