package queryapi

import (
	"testing"

	"queryorchestration/internal/client"
	"queryorchestration/internal/query"
	resultprocessor "queryorchestration/internal/query/result/processor"

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

func TestParseQueries(t *testing.T) {
	cfg := "hey"
	in := []*query.Query{
		{
			ID:            uuid.New(),
			Type:          resultprocessor.TypeContextFull,
			ActiveVersion: 1,
			LatestVersion: 2,
			RequiredQueryIDs: &[]uuid.UUID{
				uuid.New(),
			},
			Config: &cfg,
		},
	}
	out, err := parseQueries(in)
	require.NoError(t, err)
	assert.Len(t, out, len(in))
	assert.ElementsMatch(t, []Query{
		{
			Id:            in[0].ID,
			Type:          CONTEXTFULL,
			ActiveVersion: 1,
			LatestVersion: 2,
			RequiredQueries: &[]types.UUID{
				(*in[0].RequiredQueryIDs)[0],
			},
			Config: in[0].Config,
		},
	}, out)
}

func TestParseQuery(t *testing.T) {
	cfg := "hey"
	in := &query.Query{
		ID:            uuid.New(),
		Type:          resultprocessor.TypeContextFull,
		ActiveVersion: 1,
		LatestVersion: 2,
		RequiredQueryIDs: &[]uuid.UUID{
			uuid.New(),
		},
		Config: &cfg,
	}
	out, err := parseQuery(in)
	require.NoError(t, err)
	assert.EqualExportedValues(t, Query{
		Id:            in.ID,
		Type:          CONTEXTFULL,
		ActiveVersion: 1,
		LatestVersion: 2,
		RequiredQueries: &[]types.UUID{
			(*in.RequiredQueryIDs)[0],
		},
		Config: in.Config,
	},
		*out)
}

func TestParseQueryMinimal(t *testing.T) {
	in := &query.Query{
		ID:            uuid.New(),
		Type:          resultprocessor.TypeContextFull,
		ActiveVersion: 1,
		LatestVersion: 2,
	}
	out, err := parseQuery(in)
	require.NoError(t, err)
	assert.EqualExportedValues(t, Query{
		Id:            in.ID,
		Type:          CONTEXTFULL,
		ActiveVersion: 1,
		LatestVersion: 2,
	},
		*out)
}

func TestParseQueryType(t *testing.T) {
	qt, err := parseQueryType(resultprocessor.TypeContextFull)
	require.NoError(t, err)
	assert.Equal(t, CONTEXTFULL, qt)

	qt, err = parseQueryType(resultprocessor.TypeJsonExtractor)
	require.NoError(t, err)
	assert.Equal(t, JSONEXTRACTOR, qt)

	_, err = parseQueryType(resultprocessor.Type(-1))
	assert.Error(t, err)
}

func TestParseSpecQueryType(t *testing.T) {
	qt, err := parseSpecQueryType(CONTEXTFULL)
	require.NoError(t, err)
	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeContextFull), qt)

	qt, err = parseSpecQueryType(JSONEXTRACTOR)
	require.NoError(t, err)
	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), qt)

	_, err = parseSpecQueryType("invalid")
	assert.Error(t, err)
}

func TestParseStringToUUIDArray(t *testing.T) {
	ids := []uuid.UUID{uuid.New()}

	out, err := parseStringToUUIDArray(&[]string{ids[0].String()})
	require.NoError(t, err)
	assert.ElementsMatch(t, ids, *out)
	_, err = parseStringToUUIDArray(&[]string{"invalid_uuid"})
	assert.Error(t, err)
	out, err = parseStringToUUIDArray(nil)
	require.NoError(t, err)
	assert.Nil(t, out)
}

func TestParseSpecClientStatus(t *testing.T) {
	qt := parseClientStatus(client.IN_SYNC)
	assert.Equal(t, INSYNC, qt)

	qt = parseClientStatus(client.NOT_SYNCED)
	assert.Equal(t, NOTSYNCED, qt)

	qt = parseClientStatus(client.NOT_SYNCING)
	assert.Equal(t, NOTSYNCING, qt)

	qt = parseClientStatus("invalid")
	assert.Equal(t, NOTSYNCED, qt)
}