package integration_test

import (
	"edge-infra.dev/pkg/edge/api/graph/model"
	testApi "edge-infra.dev/pkg/edge/api/graph/test"
	"edge-infra.dev/test/framework/integration"

	guuid "github.com/google/uuid"
	"github.com/udacity/graphb"
)

func (s *Suite) TestCreateLabel() {
	var response struct {
		CreateLabel bool
	}
	bannerID := testApi.TestOrgEdgeID
	org := testApi.TestOrgID
	if integration.IsIntegrationTest() {
		bannerID = s.testBannerEU.EdgeID
		org = s.Config.TestTenant
	}
	randomID := guuid.New().String()
	mutation := createLabelMutation(randomID, "purp", bannerID, "description", "type_test", true, true, true)
	//override auth token
	ResolverClient.MustPost(mutation, &response, WithAuth(s.Resolver, org, s.Config.TestUsername, s.Config.TestPassword, string(model.RoleEdgeBannerAdmin)))
	s.NotNil(response.CreateLabel)
	s.Equal(true, response.CreateLabel)
	row := s.DB.QueryRow("SELECT label_key, label_edge_id FROM labels WHERE label_key = $1 AND banner_edge_id = $2", randomID, bannerID)
	var labelID string
	var key string
	err = row.Scan(&key, &labelID)
	s.NoError(err)
	s.Equal(randomID, key)
	if integration.IsIntegrationTest() {
		_, err := s.DB.Exec("DELETE FROM labels WHERE label_edge_id = $1", labelID)
		s.NoError(err)
	}
}

func (s *Suite) TestClusterLabels() {
	integration.SkipIf(s.Framework)
	var response struct {
		ClusterLabels []*model.ClusterLabel
	}

	query := clusterLabelsQuery("6e04c043-89ca-4dc2-a2ea-4605dbdd4c65", "")
	ResolverClient.MustPost(query, &response)
	s.NotNil(response.ClusterLabels)
	s.Equal(0, len(response.ClusterLabels))

	query = clusterLabelsQuery(testClusterEdgeID2, "")
	ResolverClient.MustPost(query, &response)
	s.NotNil(response.ClusterLabels)
	s.Equal(4, len(response.ClusterLabels))
	for _, res := range response.ClusterLabels {
		s.Equal(testClusterEdgeID2, res.ClusterEdgeID)
	}

	testLabelEdgeID := "442f2e77-279d-45af-acae-4ec5458b7e00"
	query = clusterLabelsQuery(testClusterEdgeID2, testLabelEdgeID)
	ResolverClient.MustPost(query, &response)
	s.NotNil(response.ClusterLabels)
	s.Equal(1, len(response.ClusterLabels))
	s.Equal(testClusterEdgeID2, response.ClusterLabels[0].ClusterEdgeID)
	s.Equal(testLabelEdgeID, response.ClusterLabels[0].LabelEdgeID)
}

func (s *Suite) TestAddClusterLabels() {
	integration.SkipIf(s.Framework)
	var response struct {
		AddClusterLabels bool
	}
	mutation := addClusterLabelsMutation(testClusterEdgeID, []string{"bbb5a40b-65d1-4092-ab5f-e35d7c2482dc"})
	ResolverClient.MustPost(mutation, &response)
	s.NotNil(response.AddClusterLabels)
	s.Equal(true, response.AddClusterLabels)
}

func (s *Suite) TestAddClusterLabelsError() {
	integration.SkipIf(s.Framework)
	var response struct {
		AddClusterLabels bool
	}

	//invalid label id
	mutation := addClusterLabelsMutation(testClusterEdgeID, []string{"ca18bfab-091b-4a7f-9db6-011d2603b949", "label-not-exist"})
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)

	//test label being rolled back
	mutation = addClusterLabelsMutation(testClusterEdgeID, []string{"ca18bfab-091b-4a7f-9db6-011d2603b949"})
	err = ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.Equal(true, response.AddClusterLabels)

	//mapping already exist
	mutation = addClusterLabelsMutation(testClusterEdgeID, []string{"ca18bfab-091b-4a7f-9db6-011d2603b949"})
	err = ResolverClient.Post(mutation, &response)
	s.Error(err)
}

func createLabelMutation(key, color, bannerEdgeID, description, labelType string, visible, editable, unique bool) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "createLabel",
				Arguments: []graphb.Argument{
					graphb.ArgumentCustomType("newLabel",
						graphb.ArgumentString("key", key),
						graphb.ArgumentString("color", color),
						graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
						graphb.ArgumentString("description", description),
						graphb.ArgumentString("type", labelType),
						graphb.ArgumentBool("visible", visible),
						graphb.ArgumentBool("editable", editable),
						graphb.ArgumentBool("unique", unique),
					),
				},
			},
		},
	})
}

func addClusterLabelsMutation(clusterEdgeID string, labelEdgeIDs []string) string { //nolint: unparam
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "addClusterLabels",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
					graphb.ArgumentStringSlice("labelEdgeIds", labelEdgeIDs...),
				},
			},
		},
	})
}

func clusterLabelsQuery(clusterEdgeID string, labelEdgeID string) string {
	payloadArgs := []graphb.Argument{}
	if clusterEdgeID != "" {
		payloadArgs = append(payloadArgs, graphb.ArgumentString("clusterEdgeId", clusterEdgeID))
	}
	if labelEdgeID != "" {
		payloadArgs = append(payloadArgs, graphb.ArgumentString("labelEdgeId", labelEdgeID))
	}

	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "clusterLabels",
				Arguments: []graphb.Argument{
					graphb.ArgumentCustomType("clusterLabelParameters", payloadArgs...),
				},
				Fields: graphb.Fields("clusterEdgeId", "labelEdgeId"),
			},
		},
	})
}