package backend_test

import (
	"github.com/synapsecns/sanguine/services/scribe/backend"
	"github.com/synapsecns/sanguine/services/scribe/testutil"

	"math/big"
	"sync"
	"testing"

	. "github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/ethergo/backends/geth"
	"github.com/synapsecns/sanguine/ethergo/util"
	"k8s.io/apimachinery/pkg/util/sets"
)

func (b *BackendSuite) TestLogsInRange() {
	const desiredBlockHeight = 10

	var testChainHandler *testutil.TestChainHandler
	var err error
	var wg sync.WaitGroup

	wg.Add(2)
	testBackend := geth.NewEmbeddedBackend(b.GetTestContext(), b.T())
	go func() {
		defer wg.Done()
		testChainHandler, err = testutil.PopulateWithLogs(b.GetTestContext(), b.T(), testBackend, desiredBlockHeight, []*testutil.DeployManager{b.manager})
		Nil(b.T(), err)
	}()

	var host string
	go func() {
		defer wg.Done()
		host = testutil.StartOmnirpcServer(b.GetTestContext(), b.T(), testBackend)
	}()

	wg.Wait()

	scribeBackend, err := backend.DialBackend(b.GetTestContext(), host, b.metrics)
	Nil(b.T(), err)

	chainID, err := scribeBackend.ChainID(b.GetTestContext())
	Nil(b.T(), err)

	lastBlock, err := testBackend.BlockNumber(b.GetTestContext())
	Nil(b.T(), err)

	iterator := util.NewChunkIterator(big.NewInt(int64(1)), big.NewInt(int64(lastBlock)), 1, true)

	var blockRanges []*util.Chunk
	blockRange := iterator.NextChunk()

	for blockRange != nil {
		blockRanges = append(blockRanges, blockRange)
		blockRange = iterator.NextChunk()
	}

	res, err := backend.GetLogsInRange(b.GetTestContext(), scribeBackend, testChainHandler.Addresses, chainID.Uint64(), blockRanges, nil)
	Nil(b.T(), err)

	// use to make sure we don't double use values
	intSet := sets.NewInt64()

	itr := res.Iterator()

	numLogs := 0
	for !itr.Done() {
		index, chunk := itr.Next()

		Falsef(b.T(), intSet.Has(int64(index)), "%d appears at least twice", index)
		intSet.Insert(int64(index))
		NotNil(b.T(), chunk)
		for range *chunk {
			numLogs++
		}
	}
	Equal(b.T(), int(testChainHandler.EventsEmitted[testChainHandler.Addresses[0]]), numLogs)
}

func (b *BackendSuite) TestLogsInRangeWithMultipleContracts() {
	const desiredBlockHeight = 10

	var testChainHandler *testutil.TestChainHandler
	var err error
	var wg sync.WaitGroup

	wg.Add(2)
	testBackend := geth.NewEmbeddedBackend(b.GetTestContext(), b.T())

	managerB := testutil.NewDeployManager(b.T())
	managerC := testutil.NewDeployManager(b.T())
	managers := []*testutil.DeployManager{b.manager, managerB, managerC}

	go func() {
		defer wg.Done()
		testChainHandler, err = testutil.PopulateWithLogs(b.GetTestContext(), b.T(), testBackend, desiredBlockHeight, managers)
		Nil(b.T(), err)
	}()

	var host string
	go func() {
		defer wg.Done()
		host = testutil.StartOmnirpcServer(b.GetTestContext(), b.T(), testBackend)
	}()

	wg.Wait()

	scribeBackend, err := backend.DialBackend(b.GetTestContext(), host, b.metrics)
	Nil(b.T(), err)

	chainID, err := scribeBackend.ChainID(b.GetTestContext())
	Nil(b.T(), err)
	iterator := util.NewChunkIterator(big.NewInt(int64(1)), big.NewInt(int64(desiredBlockHeight)), 1, true)

	var blockRanges []*util.Chunk
	blockRange := iterator.NextChunk()

	for blockRange != nil {
		blockRanges = append(blockRanges, blockRange)
		blockRange = iterator.NextChunk()
	}
	res, err := backend.GetLogsInRange(b.GetTestContext(), scribeBackend, testChainHandler.Addresses, chainID.Uint64(), blockRanges, nil)
	Nil(b.T(), err)

	// use to make sure we don't double use values
	intSet := sets.NewInt64()

	itr := res.Iterator()

	numLogs := 0
	logs := make(map[string]int)
	for !itr.Done() {
		index, chunk := itr.Next()

		Falsef(b.T(), intSet.Has(int64(index)), "%d appears at least twice", index)
		intSet.Insert(int64(index))
		NotNil(b.T(), chunk)
		for i := range *chunk {
			logAddr := (*chunk)[i].Address.String()
			logs[logAddr]++
			numLogs++
		}
	}
	Equal(b.T(), len(managers), numLogs)

	// Check if there's a log for each of the contracts
	for i := range testChainHandler.Addresses {
		Equal(b.T(), int(testChainHandler.EventsEmitted[testChainHandler.Addresses[i]]), logs[testChainHandler.Addresses[i].String()])
	}
}

func TestMakeRange(t *testing.T) {
	testIntRange := backend.MakeRange(0, 4)
	Equal(t, []int{0, 1, 2, 3, 4}, testIntRange)

	testUintRange := backend.MakeRange(uint16(10), uint16(12))
	Equal(t, testUintRange, []uint16{10, 11, 12})
}

func (b *BackendSuite) TestBlockHashesInRange() {
	testBackend := geth.NewEmbeddedBackend(b.GetTestContext(), b.T())

	// start an omnirpc proxy and run 10 test tranactions so we can batch call blocks
	//  1-10
	var wg sync.WaitGroup
	wg.Add(2)

	const desiredBlockHeight = 10

	go func() {
		defer wg.Done()
		err := testutil.ReachBlockHeight(b.GetTestContext(), b.T(), testBackend, desiredBlockHeight)
		Nil(b.T(), err)
	}()

	var host string
	go func() {
		defer wg.Done()
		host = testutil.StartOmnirpcServer(b.GetTestContext(), b.T(), testBackend)
	}()

	wg.Wait()

	scribeBackend, err := backend.DialBackend(b.GetTestContext(), host, b.metrics)
	Nil(b.T(), err)

	res, err := backend.BlockHashesInRange(b.GetTestContext(), scribeBackend, 1, 10)
	Nil(b.T(), err)

	// use to make sure we don't double use values
	intSet := sets.NewInt64()

	itr := res.Iterator()

	for !itr.Done() {
		index, _, _ := itr.Next()
		Falsef(b.T(), intSet.Has(int64(index)), "%d appears at least twice", index)
	}
}