package testutil

import (
	"context"
	"fmt"
	"github.com/synapsecns/sanguine/core/metrics"
	"net/http"
	"testing"
	"time"

	"github.com/Flaque/filet"
	"github.com/phayes/freeport"
	"github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/ethergo/backends"
	"github.com/synapsecns/sanguine/ethergo/backends/geth"
	"github.com/synapsecns/sanguine/services/explorer/consumer/client"
	"github.com/synapsecns/sanguine/services/explorer/db"
	"github.com/synapsecns/sanguine/services/explorer/db/sql"
	gqlServer "github.com/synapsecns/sanguine/services/explorer/graphql/server"
	"github.com/synapsecns/sanguine/services/explorer/testutil/clickhouse"
	"github.com/synapsecns/sanguine/services/scribe/api"
	scribedb "github.com/synapsecns/sanguine/services/scribe/db"
	"github.com/synapsecns/sanguine/services/scribe/db/datastore/sql/sqlite"
	"github.com/synapsecns/sanguine/services/scribe/graphql/server"
	"go.uber.org/atomic"
	"k8s.io/apimachinery/pkg/util/wait"
)

// NewTestEnvDB sets up the test env with a database.
func NewTestEnvDB(ctx context.Context, t *testing.T, handler metrics.Handler) (db db.ConsumerDB, eventDB scribedb.EventDB, gqlClient *client.Client, logIndex atomic.Int64, cleanup func(), testBackend backends.SimulatedTestBackend, deployManager *DeployManager) {
	t.Helper()
	dbPath := filet.TmpDir(t, "")

	sqliteStore, err := sqlite.NewSqliteStore(ctx, dbPath, handler, false)
	assert.Nil(t, err)

	eventDB = sqliteStore

	logIndex.Store(0)

	freePort := freeport.GetPort()

	go func() {
		assert.Nil(t, api.Start(ctx, api.Config{
			Port:     uint16(freePort),
			Database: "sqlite",
			Path:     dbPath,
		}, handler))
	}()

	baseURL := fmt.Sprintf("http://127.0.0.1:%d", freePort)

	gqlClient = client.NewClient(http.DefaultClient, fmt.Sprintf("%s%s", baseURL, gqlServer.GraphqlEndpoint))

	checkConnection := func() bool {
		request, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s%s", baseURL, server.GraphiqlEndpoint), nil)
		assert.Nil(t, err)
		res, err := gqlClient.Client.Client.Do(request)
		if err == nil {
			defer func() {
				_ = res.Body.Close()
			}()
			return true
		}
		return false
	}
	cancellableCtx, cancel := context.WithCancel(ctx)
	isTrue := false
	wait.UntilWithContext(cancellableCtx, func(cancellableCtx context.Context) {
		if checkConnection() {
			isTrue = true
			cancel()
		}
	}, time.Millisecond)

	// make sure the context didn't cancel
	if !isTrue {
		t.Errorf("expected %T to be true before test context timed out", checkConnection)
	}

	cleanup, port, err := clickhouse.NewClickhouseStore("explorer")
	if cleanup == nil {
		panic("Clickhouse spin up failure, no open port found.")
	}
	if port == nil || err != nil {
		cleanup()
		panic("Clickhouse spin up failure, destroying container...")
	}
	assert.Equal(t, err, nil)
	dbURL := "clickhouse://clickhouse_test:clickhouse_test@localhost:" + fmt.Sprintf("%d", *port) + "/clickhouse_test"
	consumerDB, err := sql.OpenGormClickhouse(ctx, dbURL, false, handler)
	assert.Nil(t, err)
	db = consumerDB

	testBackend = geth.NewEmbeddedBackend(ctx, t)
	deployManager = NewDeployManager(t)

	return db, eventDB, gqlClient, logIndex, cleanup, testBackend, deployManager
}