package rpcinfo_test

import (
	"context"
	"net/http"
	"net/http/httptest"
	"sync"
	"time"

	. "github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/core/metrics"
	"github.com/synapsecns/sanguine/ethergo/backends/geth"
	"github.com/synapsecns/sanguine/ethergo/backends/preset"
	"github.com/synapsecns/sanguine/services/omnirpc/rpcinfo"
	"golang.org/x/sync/errgroup"
)

func (r *LatencySuite) TestRPCLatency() {
	var bsc, avalanche *geth.Backend
	g, _ := errgroup.WithContext(r.GetTestContext())
	g.Go(func() error {
		bsc = preset.GetMaticMumbai().Geth(r.GetTestContext(), r.T())
		return nil
	})
	g.Go(func() error {
		avalanche = preset.GetSepolia().Geth(r.GetTestContext(), r.T())
		return nil
	})
	Nil(r.T(), g.Wait())

	latencySlice := rpcinfo.GetRPCLatency(r.GetTestContext(), time.Second*3, []string{bsc.HTTPEndpoint(), avalanche.HTTPEndpoint()}, metrics.NewNullHandler())
	NotEqual(r.T(), latencySlice[0].URL, latencySlice[1].URL)
	for _, latencyData := range latencySlice {
		False(r.T(), latencyData.HasError)
		Nil(r.T(), latencyData.Error)
	}
}

var statusCodes = []int{
	http.StatusBadRequest,
	http.StatusUnauthorized,
	http.StatusPaymentRequired,
	http.StatusNotFound,
	http.StatusMethodNotAllowed,
	http.StatusNotAcceptable,
	http.StatusRequestTimeout,
	http.StatusGone,
	http.StatusLengthRequired,
	http.StatusPreconditionRequired,
	http.StatusPreconditionFailed,
	http.StatusRequestEntityTooLarge,
	http.StatusRequestEntityTooLarge,
	// just for fun
	http.StatusTeapot,
	http.StatusMisdirectedRequest,
	http.StatusTooManyRequests,
	http.StatusRequestHeaderFieldsTooLarge,
	http.StatusInternalServerError,
	http.StatusNotImplemented,
	http.StatusGatewayTimeout,
	http.StatusBadGateway,
	http.StatusBadRequest,
	http.StatusLoopDetected,
	http.StatusNotExtended,
	http.StatusNetworkAuthenticationRequired,
}

func (r *LatencySuite) TestGetLatencyError() {
	ctx, cancel := context.WithTimeout(r.GetTestContext(), time.Minute)
	defer cancel()

	wg := &sync.WaitGroup{}

	for _, status := range statusCodes {
		// capture func literal
		status := status

		wg.Add(1)

		go func() {
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(status)
			}))

			res := rpcinfo.GetLatency(ctx, server.URL)

			// there's an error, these should be nil
			Equal(r.T(), res.Latency, time.Duration(0))
			Equal(r.T(), res.BlockAge, time.Duration(0))

			server.Close()
			wg.Done()
		}()
	}

	select {
	case <-wrapWait(wg):
		// all good
	case <-ctx.Done():
		// context canceled
		r.T().Fail()
	}
}

// helper function to allow using WaitGroup in a select
// see: https://stackoverflow.com/a/70050009
func wrapWait(wg *sync.WaitGroup) <-chan struct{} {
	out := make(chan struct{})
	go func() {
		wg.Wait()
		out <- struct{}{}
	}()
	return out
}