package endtoend

import (
	"context"
	"log"
	"os"
	"path"
	"regexp"
	"testing"

	"queryorchestration/internal/serviceconfig"
	"queryorchestration/internal/serviceconfig/queue"
	"queryorchestration/internal/test"
	queryservice "queryorchestration/pkg/queryService"

	"github.com/oapi-codegen/runtime/types"
	"github.com/stretchr/testify/assert"
)

type CollectorConfig struct {
	serviceconfig.BaseConfig
	queue.QueueConfig
}

func TestCollectorService(t *testing.T) {
	ctx := context.Background()

	cfg := &CollectorConfig{}
	test.SetCfgProvider(t, cfg)
	cfg.SetBasePath(path.Join(os.Getenv("PWD"), "../.."))

	network, ncleanup := test.CreateNetwork(t, ctx)
	defer ncleanup()

	_, clean := test.CreateAWSContainer(t, ctx, &test.CreateAWSConfig{
		Cfg:     cfg,
		Network: network,
	})
	defer clean()

	err := cfg.SetQueueClient(ctx)
	assert.NoError(t, err)
	clientsyncurl := test.CreateQueue(t, ctx, cfg, test.ClientSyncRunner)

	c, cleanup := test.CreateServiceNetwork(t, ctx, &test.ServiceNetworkConfig{
		Cfg:     cfg,
		Network: network,
		Name:    test.QueryService,
		Env: map[string]string{
			"CLIENT_SYNC_URL":        clientsyncurl,
			"QUERY_VERSION_SYNC_URL": "iamthere",
		},
	})
	defer cleanup()

	client, err := queryservice.NewClientWithResponses(c.URI)
	assert.NoError(t, err)

	contextRes, err := client.CreateQueryWithResponse(ctx, queryservice.QueryCreate{
		Type: queryservice.CONTEXTFULL,
	})
	assert.NoError(t, err)

	jsoncfg := "{\"path\":\"key\"}"
	jsonRes, err := client.CreateQueryWithResponse(ctx, queryservice.QueryCreate{
		Type:   queryservice.JSONEXTRACTOR,
		Config: &jsoncfg,
		RequiredQueries: &[]types.UUID{
			contextRes.JSON201.Id,
		},
	})
	assert.NoError(t, err)

	clientRes, err := client.CreateClientWithResponse(ctx, queryservice.ClientCreate{
		Name: "example_name",
	})
	assert.NoError(t, err)
	id := clientRes.JSON201.Id

	collRes, err := client.GetCollectorByClientIdWithResponse(ctx, id)
	assert.NoError(t, err)
	assert.Equal(t, id, collRes.JSON200.ClientId)
	assert.Equal(t, int32(0), collRes.JSON200.ActiveVersion)
	assert.Equal(t, int32(0), collRes.JSON200.LatestVersion)
	assert.Equal(t, int32(0), collRes.JSON200.MinimumCleanerVersion)
	assert.Equal(t, int32(0), collRes.JSON200.MinimumTextVersion)
	assert.Len(t, collRes.JSON200.Fields, 0)

	av := int32(1)
	fields := []queryservice.CollectorField{
		{
			Name:    "json",
			QueryId: jsonRes.JSON201.Id,
		},
	}
	uRes, err := client.SetCollectorByClientIdWithResponse(ctx, id, queryservice.CollectorSet{
		ActiveVersion: &av,
		Fields:        &fields,
	})
	assert.NoError(t, err)
	log.Print(string(uRes.Body))
	assert.Equal(t, 200, uRes.StatusCode())

	test.AssertMessageBody(t, ctx, cfg, clientsyncurl, regexp.MustCompile(`{"id":".+"}`))

	collRes, err = client.GetCollectorByClientIdWithResponse(ctx, id)
	assert.NoError(t, err)
	assert.Equal(t, id, collRes.JSON200.ClientId)
	assert.Equal(t, int32(1), collRes.JSON200.ActiveVersion)
	assert.Equal(t, int32(1), collRes.JSON200.LatestVersion)
	assert.Equal(t, int32(0), collRes.JSON200.MinimumCleanerVersion)
	assert.Equal(t, int32(0), collRes.JSON200.MinimumTextVersion)
	assert.Len(t, collRes.JSON200.Fields, 1)
	assert.ElementsMatch(t, fields, collRes.JSON200.Fields)
}